]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - ITS/AliITSDetTypeRec.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Considering the case when there is no entry in the list for the trigger-class or...
[u/mrichter/AliRoot.git] / ITS / AliITSDetTypeRec.cxx
... / ...
CommitLineData
1/***************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Conributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/*
17 $Id$
18*/
19
20////////////////////////////////////////////////////////////////////////
21// This class defines the "Standard" reconstruction for the ITS //
22// detector. //
23// //
24////////////////////////////////////////////////////////////////////////
25#include "TObjArray.h"
26#include "TTree.h"
27
28#include "AliCDBManager.h"
29#include "AliCDBEntry.h"
30#include "AliITSClusterFinder.h"
31#include "AliITSClusterFinderV2SPD.h"
32#include "AliITSClusterFinderV2SDD.h"
33#include "AliITSClusterFinderV2SSD.h"
34#include "AliITSDetTypeRec.h"
35#include "AliITSDDLModuleMapSDD.h"
36#include "AliITSRecPoint.h"
37#include "AliITSRecPointContainer.h"
38#include "AliITSCalibrationSDD.h"
39#include "AliITSMapSDD.h"
40#include "AliITSCalibrationSSD.h"
41#include "AliITSNoiseSSDv2.h"
42#include "AliITSGainSSDv2.h"
43#include "AliITSBadChannelsSSDv2.h"
44#include "AliITSNoiseSSD.h"
45#include "AliITSGainSSD.h"
46#include "AliITSBadChannelsSSD.h"
47#include "AliITSresponseSDD.h"
48#include "AliITSsegmentationSPD.h"
49#include "AliITSsegmentationSDD.h"
50#include "AliITSsegmentationSSD.h"
51#include "AliLog.h"
52#include "AliITSRawStreamSPD.h"
53#include "AliITSTriggerConditions.h"
54#include "AliITSFOSignalsSPD.h"
55#include "AliRunLoader.h"
56#include "AliDataLoader.h"
57#include "AliITSLoader.h"
58
59class AliITSDriftSpeedArraySDD;
60class AliITSCorrMapSDD;
61class AliITSRecoParam;
62
63const Int_t AliITSDetTypeRec::fgkNdettypes = 3;
64const Int_t AliITSDetTypeRec::fgkDefaultNModulesSPD = 240;
65const Int_t AliITSDetTypeRec::fgkDefaultNModulesSDD = 260;
66const Int_t AliITSDetTypeRec::fgkDefaultNModulesSSD = 1698;
67
68ClassImp(AliITSDetTypeRec)
69
70//________________________________________________________________
71AliITSDetTypeRec::AliITSDetTypeRec(): TObject(),
72fNMod(0),
73fITSgeom(0),
74fReconstruction(0),
75fSegmentation(0),
76fCalibration(0),
77fSSDCalibration(0),
78fSPDDead(0),
79fSPDSparseDead(0),
80fTriggerConditions(0),
81fDigits(0),
82fFOSignals(0),
83fDDLMapSDD(0),
84fRespSDD(0),
85fAveGainSDD(0),
86fRecPoints(0),
87fNRecPoints(0),
88fFirstcall(kTRUE),
89fLoadOnlySPDCalib(0),
90fFastOrFiredMap(1200){
91 // Standard Constructor
92 // Inputs:
93 // none.
94 // Outputs:
95 // none.
96 // Return:
97 //
98
99 fReconstruction = new TObjArray(fgkNdettypes);
100 fDigits = new TObjArray(fgkNdettypes);
101 for(Int_t i=0; i<3; i++){
102 fkDigClassName[i]=0;
103 }
104 fSSDCalibration=new AliITSCalibrationSSD();
105 fNMod = new Int_t [fgkNdettypes];
106 fNMod[0] = fgkDefaultNModulesSPD;
107 fNMod[1] = fgkDefaultNModulesSDD;
108 fNMod[2] = fgkDefaultNModulesSSD;
109 fNRecPoints = 0;
110
111
112}
113
114//______________________________________________________________________
115AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec & rec):TObject(rec),
116fNMod(rec.fNMod),
117fITSgeom(rec.fITSgeom),
118fReconstruction(rec.fReconstruction),
119fSegmentation(rec.fSegmentation),
120fCalibration(rec.fCalibration),
121fSSDCalibration(rec.fSSDCalibration),
122fSPDDead(rec.fSPDDead),
123fSPDSparseDead(rec.fSPDSparseDead),
124fTriggerConditions(rec.fTriggerConditions),
125fDigits(rec.fDigits),
126fFOSignals(rec.fFOSignals),
127fDDLMapSDD(rec.fDDLMapSDD),
128fRespSDD(rec.fRespSDD),
129fAveGainSDD(rec.fAveGainSDD),
130fRecPoints(rec.fRecPoints),
131fNRecPoints(rec.fNRecPoints),
132fFirstcall(rec.fFirstcall),
133fLoadOnlySPDCalib(rec.fLoadOnlySPDCalib),
134fFastOrFiredMap(rec.fFastOrFiredMap){
135
136 // Copy constructor.
137 for(Int_t i=0; i<3; i++){
138 fkDigClassName[i]=rec.fkDigClassName[i]; // NB only copies Char_t*, so not so safe, but this code should never be reached anyways
139 }
140}
141//______________________________________________________________________
142AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& source){
143 // Assignment operator.
144 this->~AliITSDetTypeRec();
145 new(this) AliITSDetTypeRec(source);
146 return *this;
147
148}
149
150//_____________________________________________________________________
151AliITSDetTypeRec::~AliITSDetTypeRec(){
152 //Destructor
153
154 if(fReconstruction){
155 fReconstruction->Delete();
156 delete fReconstruction;
157 }
158 if(fSegmentation){
159 fSegmentation->Delete();
160 delete fSegmentation;
161 }
162 if(fCalibration){
163 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
164 fCalibration->Delete();
165 delete fCalibration;
166 if(fRespSDD) delete fRespSDD;
167 if(fDDLMapSDD) delete fDDLMapSDD;
168 }
169 }
170 if(fSSDCalibration){
171 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
172 delete fSSDCalibration;
173 }
174 }
175 if(fSPDDead){
176 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
177 fSPDDead->Delete();
178 delete fSPDDead;
179 }
180 }
181 if(fSPDSparseDead){
182 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
183 fSPDSparseDead->Delete();
184 delete fSPDSparseDead;
185 }
186 }
187 if(fTriggerConditions){
188 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
189 fTriggerConditions->Delete();
190 delete fTriggerConditions;
191 }
192 }
193 if(fDigits){
194 fDigits->Delete();
195 delete fDigits;
196 }
197 if(fRecPoints){
198 fRecPoints->Delete();
199 delete fRecPoints;
200 }
201 delete [] fNMod;
202
203 if (fITSgeom) delete fITSgeom;
204
205}
206
207//___________________________________________________________________
208void AliITSDetTypeRec::SetReconstructionModel(Int_t dettype,AliITSClusterFinder *clf){
209
210 //Set reconstruction model for detector type
211
212 if(fReconstruction==0) fReconstruction = new TObjArray(fgkNdettypes);
213 if(fReconstruction->At(dettype)!=0) delete fReconstruction->At(dettype);
214 fReconstruction->AddAt(clf,dettype);
215}
216//______________________________________________________________________
217AliITSClusterFinder* AliITSDetTypeRec::GetReconstructionModel(Int_t dettype) const{
218
219 //Get reconstruction model for detector type
220 if(fReconstruction==0) {
221 Warning("GetReconstructionModel","fReconstruction is 0!");
222 return 0;
223 }
224 return (AliITSClusterFinder*)fReconstruction->At(dettype);
225}
226
227//______________________________________________________________________
228void AliITSDetTypeRec::SetSegmentationModel(Int_t dettype,AliITSsegmentation *seg){
229
230 //Set segmentation model for detector type
231
232 if(fSegmentation==0) fSegmentation = new TObjArray(fgkNdettypes);
233 if(fSegmentation->At(dettype)!=0) delete fSegmentation->At(dettype);
234 fSegmentation->AddAt(seg,dettype);
235
236}
237//______________________________________________________________________
238AliITSsegmentation* AliITSDetTypeRec::GetSegmentationModel(Int_t dettype) const {
239
240 //Get segmentation model for detector type
241
242 if(fSegmentation==0) {
243 Warning("GetSegmentationModel","fSegmentation is 0!");
244 return 0;
245 }
246 return (AliITSsegmentation*)fSegmentation->At(dettype);
247
248}
249//_______________________________________________________________________
250void AliITSDetTypeRec::SetCalibrationModel(Int_t iMod, AliITSCalibration *cal){
251
252 //Set calibration (response) for the module iMod of type dettype
253 if (fCalibration==0) {
254 fCalibration = new TObjArray(GetITSgeom()->GetIndexMax());
255 fCalibration->SetOwner(kTRUE);
256 fCalibration->Clear();
257 }
258
259 if (fCalibration->At(iMod) != 0)
260 delete (AliITSCalibration*) fCalibration->At(iMod);
261 fCalibration->AddAt(cal,iMod);
262
263}
264//_______________________________________________________________________
265void AliITSDetTypeRec::SetSPDDeadModel(Int_t iMod, AliITSCalibration *cal){
266
267 //Set dead pixel info for the SPD module iMod
268 if (fSPDDead==0) {
269 fSPDDead = new TObjArray(fgkDefaultNModulesSPD);
270 fSPDDead->SetOwner(kTRUE);
271 fSPDDead->Clear();
272 }
273
274 if (fSPDDead->At(iMod) != 0)
275 delete (AliITSCalibration*) fSPDDead->At(iMod);
276 fSPDDead->AddAt(cal,iMod);
277}
278//_______________________________________________________________________
279void AliITSDetTypeRec::SetSPDSparseDeadModel(Int_t iMod, AliITSCalibration *cal){
280
281 //Set dead pixel info for the SPD ACTIVE module iMod
282 if (fSPDSparseDead==0) {
283 fSPDSparseDead = new TObjArray(fgkDefaultNModulesSPD);
284 fSPDSparseDead->SetOwner(kTRUE);
285 fSPDSparseDead->Clear();
286 }
287
288 if (fSPDSparseDead->At(iMod) != 0)
289 delete (AliITSCalibration*) fSPDSparseDead->At(iMod);
290 fSPDSparseDead->AddAt(cal,iMod);
291}
292//_______________________________________________________________________
293AliITSCalibration* AliITSDetTypeRec::GetCalibrationModel(Int_t iMod) const {
294
295 //Get calibration model for module type
296
297 if(fCalibration==0) {
298 Warning("GetalibrationModel","fCalibration is 0!");
299 return 0;
300 }
301
302 if(iMod<fgkDefaultNModulesSPD+fgkDefaultNModulesSDD){
303 return (AliITSCalibration*)fCalibration->At(iMod);
304 }else{
305 Int_t i=iMod-(fgkDefaultNModulesSPD+fgkDefaultNModulesSDD);
306 fSSDCalibration->SetModule(i);
307 return (AliITSCalibration*)fSSDCalibration;
308 }
309
310}
311//_______________________________________________________________________
312AliITSCalibration* AliITSDetTypeRec::GetSPDDeadModel(Int_t iMod) const {
313
314 //Get SPD dead for module iMod
315
316 if(fSPDDead==0) {
317 AliWarning("fSPDDead is 0!");
318 return 0;
319 }
320 return (AliITSCalibration*)fSPDDead->At(iMod);
321}
322//_______________________________________________________________________
323AliITSCalibration* AliITSDetTypeRec::GetSPDSparseDeadModel(Int_t iMod) const {
324
325 //Get SPD dead for module iMod
326
327 if(fSPDSparseDead==0) {
328 AliWarning("fSPDSparseDead is 0!");
329 return 0;
330 }
331 return (AliITSCalibration*)fSPDSparseDead->At(iMod);
332}
333//_______________________________________________________________________
334AliITSTriggerConditions* AliITSDetTypeRec::GetTriggerConditions() const {
335 //Get Pixel Trigger Conditions
336 if (fTriggerConditions==0) {
337 AliWarning("fTriggerConditions is 0!");
338 }
339 return fTriggerConditions;
340}
341//______________________________________________________________________
342void AliITSDetTypeRec::SetTreeAddressD(TTree* const treeD){
343 // Set branch address for the tree of digits.
344
345 const char *det[4] = {"SPD","SDD","SSD","ITS"};
346 TBranch *branch;
347 const Char_t* digclass;
348 Int_t i;
349 char branchname[30];
350
351 if(!treeD) return;
352 if (fDigits == 0x0) {
353 fDigits = new TObjArray(fgkNdettypes);
354 }
355 else {
356 ResetDigits();
357 }
358 for (i=0; i<fgkNdettypes; i++) {
359 digclass = GetDigitClassName(i);
360 fDigits->AddAt(new TClonesArray(digclass,1000),i);
361 if (fgkNdettypes==3) snprintf(branchname,29,"%sDigits%s",det[3],det[i]);
362 else snprintf(branchname,29,"%sDigits%d",det[3],i+1);
363 branch = treeD->GetBranch(branchname);
364 if (branch) branch->SetAddress(&((*fDigits)[i]));
365 }
366
367}
368
369//_______________________________________________________________________
370TBranch* AliITSDetTypeRec::MakeBranchInTree(TTree* const tree,
371 const char* name, const char *classname,
372 void* address,Int_t size,Int_t splitlevel)
373{
374//
375// Makes branch in given tree and diverts them to a separate file
376//
377//
378//
379
380 if (tree == 0x0) {
381 Error("MakeBranchInTree","Making Branch %s Tree is NULL",name);
382 return 0x0;
383 }
384 TBranch *branch = tree->GetBranch(name);
385 if (branch) {
386 return branch;
387 }
388 if (classname){
389 branch = tree->Branch(name,classname,address,size,splitlevel);
390 }
391 else {
392 branch = tree->Bronch(name, "TClonesArray", address, size, splitlevel);
393 }
394
395 return branch;
396}
397
398//____________________________________________________________________
399void AliITSDetTypeRec::SetDefaults(){
400
401 //Set defaults for segmentation and response
402
403 if(!GetITSgeom()){
404 Warning("SetDefaults","null pointer to AliITSgeomGeom !");
405 return;
406 }
407
408 AliITSsegmentation* seg;
409 if(!GetCalibration()) {AliFatal("Exit");exit(0);}
410
411 for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
412 if(dettype==0){
413 seg = new AliITSsegmentationSPD();
414 SetSegmentationModel(dettype,seg);
415 SetDigitClassName(dettype,"AliITSdigitSPD");
416 }
417 if(dettype==1){
418 seg = new AliITSsegmentationSDD();
419 if(fLoadOnlySPDCalib==kFALSE){
420 AliITSCalibrationSDD* cal=(AliITSCalibrationSDD*)GetCalibrationModel(fgkDefaultNModulesSPD+1);
421 if(cal->IsAMAt20MHz()){
422 seg->SetPadSize(seg->Dpz(0),20.);
423 seg->SetNPads(seg->Npz()/2,128);
424 }
425 }
426 SetSegmentationModel(dettype,seg);
427 SetDigitClassName(dettype,"AliITSdigitSDD");
428 }
429 if(dettype==2){
430 AliITSsegmentationSSD* seg2 = new AliITSsegmentationSSD();
431 SetSegmentationModel(dettype,seg2);
432 SetDigitClassName(dettype,"AliITSdigitSSD");
433 }
434 }
435}
436//______________________________________________________________________
437Bool_t AliITSDetTypeRec::GetCalibration() {
438 // Get Default calibration if a storage is not defined.
439
440 if(!fFirstcall){
441 AliITSCalibration* cal = GetCalibrationModel(0);
442 if(cal)return kTRUE;
443 }else {
444 fFirstcall = kFALSE;
445 }
446
447 // SetRunNumber((Int_t)AliCDBManager::Instance()->GetRun());
448 // Int_t run=GetRunNumber();
449
450 Bool_t cacheStatus = AliCDBManager::Instance()->GetCacheFlag();
451 if (fCalibration==0) {
452 fCalibration = new TObjArray(GetITSgeom()->GetIndexMax());
453 fCalibration->SetOwner(!cacheStatus);
454 fCalibration->Clear();
455 }
456
457 Bool_t retCode=GetCalibrationSPD(cacheStatus);
458 if(retCode==kFALSE) return kFALSE;
459
460 if(fLoadOnlySPDCalib==kFALSE){
461 retCode=GetCalibrationSDD(cacheStatus);
462 if(retCode==kFALSE) return kFALSE;
463 retCode=GetCalibrationSSD(cacheStatus);
464 if(retCode==kFALSE) return kFALSE;
465 }
466
467 AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database",
468 fNMod[0], fNMod[1], fNMod[2]));
469 return kTRUE;
470}
471//______________________________________________________________________
472Bool_t AliITSDetTypeRec::GetCalibrationSPD(Bool_t cacheStatus) {
473 // Get SPD calibration objects from OCDB
474 // dead pixel are not used for local reconstruction
475
476
477 AliCDBEntry *noisySPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDNoisy");
478 AliCDBEntry *deadSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead");
479 AliCDBEntry *deadSparseSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDSparseDead");
480 AliCDBEntry *pitCond = AliCDBManager::Instance()->Get("TRIGGER/SPD/PITConditions");
481 if(!noisySPD || !deadSPD || !pitCond ){
482 AliFatal("SPD Calibration object retrieval failed! ");
483 return kFALSE;
484 }
485
486 TObjArray *calNoisySPD = (TObjArray*) noisySPD->GetObject();
487 if (!cacheStatus) noisySPD->SetObject(NULL);
488 noisySPD->SetOwner(kTRUE);
489
490 TObjArray *calDeadSPD = (TObjArray*) deadSPD->GetObject();
491 if (!cacheStatus) deadSPD->SetObject(NULL);
492 deadSPD->SetOwner(kTRUE);
493
494 TObjArray *calSparseDeadSPD = (TObjArray*) deadSparseSPD->GetObject();
495 if (!cacheStatus) deadSparseSPD->SetObject(NULL);
496 deadSparseSPD->SetOwner(kTRUE);
497
498
499 AliITSTriggerConditions *calPitCond = (AliITSTriggerConditions*) pitCond->GetObject();
500 if (!cacheStatus) pitCond->SetObject(NULL);
501 pitCond->SetOwner(kTRUE);
502
503 if(!cacheStatus){
504 delete noisySPD;
505 delete deadSPD;
506 delete deadSparseSPD;
507 delete pitCond;
508 }
509 if ((!calNoisySPD) || (!calDeadSPD) || (!calSparseDeadSPD) || (!calPitCond)){
510 AliWarning("Can not get SPD calibration from calibration database !");
511 return kFALSE;
512 }
513
514 fNMod[0] = calNoisySPD->GetEntries();
515
516 AliITSCalibration* cal;
517 for (Int_t i=0; i<fNMod[0]; i++) {
518 cal = (AliITSCalibration*) calNoisySPD->At(i);
519 SetCalibrationModel(i, cal);
520 cal = (AliITSCalibration*) calDeadSPD->At(i);
521 SetSPDDeadModel(i, cal);
522 cal = (AliITSCalibration*) calSparseDeadSPD->At(i);
523 SetSPDSparseDeadModel(i, cal);
524 }
525 fTriggerConditions = calPitCond;
526
527 return kTRUE;
528}
529
530//______________________________________________________________________
531Bool_t AliITSDetTypeRec::GetCalibrationSDD(Bool_t cacheStatus) {
532 // Get SDD calibration objects from OCDB
533
534 AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD");
535 AliCDBEntry *entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD");
536 AliCDBEntry *drSpSDD = AliCDBManager::Instance()->Get("ITS/Calib/DriftSpeedSDD");
537 AliCDBEntry *ddlMapSDD = AliCDBManager::Instance()->Get("ITS/Calib/DDLMapSDD");
538 // AliCDBEntry *mapASDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsAnodeSDD");
539 AliCDBEntry *mapTSDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsTimeSDD");
540
541 if(!entrySDD || !entry2SDD || !drSpSDD || !ddlMapSDD || !mapTSDD ){
542 AliFatal("SDD Calibration object retrieval failed! ");
543 return kFALSE;
544 }
545
546
547
548 TObjArray *calSDD = (TObjArray *)entrySDD->GetObject();
549 if(!cacheStatus)entrySDD->SetObject(NULL);
550 entrySDD->SetOwner(kTRUE);
551
552 AliITSresponseSDD *pSDD = (AliITSresponseSDD*)entry2SDD->GetObject();
553 if(!cacheStatus)entry2SDD->SetObject(NULL);
554 entry2SDD->SetOwner(kTRUE);
555
556 TObjArray *drSp = (TObjArray *)drSpSDD->GetObject();
557 if(!cacheStatus)drSpSDD->SetObject(NULL);
558 drSpSDD->SetOwner(kTRUE);
559
560 AliITSDDLModuleMapSDD *ddlsdd=(AliITSDDLModuleMapSDD*)ddlMapSDD->GetObject();
561 if(!cacheStatus)ddlMapSDD->SetObject(NULL);
562 ddlMapSDD->SetOwner(kTRUE);
563
564// TObjArray *mapAn = (TObjArray *)mapASDD->GetObject();
565// if(!cacheStatus)mapASDD->SetObject(NULL);
566// mapASDD->SetOwner(kTRUE);
567
568 TObjArray *mapT = (TObjArray *)mapTSDD->GetObject();
569 if(!cacheStatus)mapTSDD->SetObject(NULL);
570 mapTSDD->SetOwner(kTRUE);
571
572
573 // DB entries are deleted. In this way metadeta objects are deleted as well
574 if(!cacheStatus){
575 delete entrySDD;
576 delete entry2SDD;
577 //delete mapASDD;
578 delete mapTSDD;
579 delete drSpSDD;
580 delete ddlMapSDD;
581 }
582
583 if ((!pSDD)||(!calSDD) || (!drSp) || (!ddlsdd) || (!mapT) ){
584 AliWarning("Can not get SDD calibration from calibration database !");
585 return kFALSE;
586 }
587
588 fNMod[1] = calSDD->GetEntries();
589
590 fDDLMapSDD=ddlsdd;
591 fRespSDD=pSDD;
592 AliITSCalibration* cal;
593 Float_t avegain=0.;
594 Float_t nGdAnodes=0;
595 Bool_t oldMapFormat=kFALSE;
596 TObject* objmap=(TObject*)mapT->At(0);
597 TString cname(objmap->ClassName());
598 if(cname.CompareTo("AliITSMapSDD")==0){
599 oldMapFormat=kTRUE;
600 AliInfo("SDD Maps converted to new format");
601 }
602 for(Int_t iddl=0; iddl<AliITSDDLModuleMapSDD::GetNDDLs(); iddl++){
603 for(Int_t icar=0; icar<AliITSDDLModuleMapSDD::GetNModPerDDL();icar++){
604 Int_t iMod=fDDLMapSDD->GetModuleNumber(iddl,icar);
605 if(iMod==-1) continue;
606 Int_t i=iMod - fgkDefaultNModulesSPD;
607 cal = (AliITSCalibration*) calSDD->At(i);
608 Int_t i0=2*i;
609 Int_t i1=1+2*i;
610 for(Int_t iAnode=0;iAnode< ((AliITSCalibrationSDD*)cal)->NOfAnodes(); iAnode++){
611 if(((AliITSCalibrationSDD*)cal)->IsBadChannel(iAnode)) continue;
612 avegain+= ((AliITSCalibrationSDD*)cal)->GetChannelGain(iAnode);
613 nGdAnodes++;
614 }
615 AliITSDriftSpeedArraySDD* arr0 = (AliITSDriftSpeedArraySDD*) drSp->At(i0);
616 AliITSDriftSpeedArraySDD* arr1 = (AliITSDriftSpeedArraySDD*) drSp->At(i1);
617
618 AliITSCorrMapSDD* mt0 = 0;
619 AliITSCorrMapSDD* mt1 = 0;
620 if(oldMapFormat){
621 AliITSMapSDD* oldmap0=(AliITSMapSDD*)mapT->At(i0);
622 AliITSMapSDD* oldmap1=(AliITSMapSDD*)mapT->At(i1);
623 mt0=oldmap0->ConvertToNewFormat();
624 mt1=oldmap1->ConvertToNewFormat();
625 }else{
626 mt0=(AliITSCorrMapSDD*)mapT->At(i0);
627 mt1=(AliITSCorrMapSDD*)mapT->At(i1);
628 }
629 cal->SetDriftSpeed(0,arr0);
630 cal->SetDriftSpeed(1,arr1);
631 cal->SetMapT(0,mt0);
632 cal->SetMapT(1,mt1);
633 SetCalibrationModel(iMod, cal);
634 }
635 }
636 if(nGdAnodes) fAveGainSDD=avegain/nGdAnodes;
637 return kTRUE;
638}
639
640
641//______________________________________________________________________
642Bool_t AliITSDetTypeRec::GetCalibrationSSD(Bool_t cacheStatus) {
643 // Get SSD calibration objects from OCDB
644 // AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD");
645
646 AliCDBEntry *entryNoiseSSD = AliCDBManager::Instance()->Get("ITS/Calib/NoiseSSD");
647 AliCDBEntry *entryGainSSD = AliCDBManager::Instance()->Get("ITS/Calib/GainSSD");
648 AliCDBEntry *entryBadChannelsSSD = AliCDBManager::Instance()->Get("ITS/Calib/BadChannelsSSD");
649
650 if(!entryNoiseSSD || !entryGainSSD || !entryBadChannelsSSD){
651 AliFatal("SSD Calibration object retrieval failed! ");
652 return kFALSE;
653 }
654
655 TObject *emptyssd = 0; TString ssdobjectname;
656 AliITSNoiseSSDv2 *noiseSSD = NULL;
657 emptyssd = (TObject *)entryNoiseSSD->GetObject();
658 ssdobjectname = emptyssd->GetName();
659 if(ssdobjectname=="TObjArray") {
660 TObjArray *noiseSSDOld = (TObjArray *)entryNoiseSSD->GetObject();
661 noiseSSD = new AliITSNoiseSSDv2();
662 ReadOldSSDNoise(noiseSSDOld, noiseSSD);
663 }
664 else if(ssdobjectname=="AliITSNoiseSSDv2")
665 noiseSSD = (AliITSNoiseSSDv2 *)entryNoiseSSD->GetObject();
666 if(!cacheStatus)entryNoiseSSD->SetObject(NULL);
667 entryNoiseSSD->SetOwner(kTRUE);
668
669 AliITSGainSSDv2 *gainSSD = NULL;;
670 emptyssd = (TObject *)entryGainSSD->GetObject();
671 ssdobjectname = emptyssd->GetName();
672 if(ssdobjectname=="Gain") {
673 TObjArray *gainSSDOld = (TObjArray *)entryGainSSD->GetObject();
674 gainSSD = new AliITSGainSSDv2();
675 ReadOldSSDGain(gainSSDOld, gainSSD);
676 }
677 else if(ssdobjectname=="AliITSGainSSDv2")
678 gainSSD = (AliITSGainSSDv2 *)entryGainSSD->GetObject();
679 if(!cacheStatus)entryGainSSD->SetObject(NULL);
680 entryGainSSD->SetOwner(kTRUE);
681
682 AliITSBadChannelsSSDv2 *badChannelsSSD = NULL;
683 emptyssd = (TObject *)entryBadChannelsSSD->GetObject();
684 ssdobjectname = emptyssd->GetName();
685 if(ssdobjectname=="TObjArray") {
686 TObjArray *badChannelsSSDOld = (TObjArray *)entryBadChannelsSSD->GetObject();
687 badChannelsSSD = new AliITSBadChannelsSSDv2();
688 ReadOldSSDBadChannels(badChannelsSSDOld, badChannelsSSD);
689 }
690 else if(ssdobjectname=="AliITSBadChannelsSSDv2")
691 badChannelsSSD = (AliITSBadChannelsSSDv2*)entryBadChannelsSSD->GetObject();
692 if(!cacheStatus)entryBadChannelsSSD->SetObject(NULL);
693 entryBadChannelsSSD->SetOwner(kTRUE);
694
695 // DB entries are deleted. In this way metadeta objects are deleted as well
696 if(!cacheStatus){
697 delete entryNoiseSSD;
698 delete entryGainSSD;
699 delete entryBadChannelsSSD;
700 }
701
702 if ((!noiseSSD)|| (!gainSSD)|| (!badChannelsSSD)) {
703 AliWarning("Can not get SSD calibration from calibration database !");
704 return kFALSE;
705 }
706
707 fSSDCalibration->SetNoise(noiseSSD);
708 fSSDCalibration->SetGain(gainSSD);
709 fSSDCalibration->SetBadChannels(badChannelsSSD);
710 //fSSDCalibration->FillBadChipMap();
711
712 return kTRUE;
713}
714
715//________________________________________________________________
716void AliITSDetTypeRec::SetDefaultClusterFindersV2(Bool_t rawdata){
717
718 //Set defaults for cluster finder V2
719
720 if(!GetITSgeom()){
721 Warning("SetDefaults","Null pointer to AliITSgeom !");
722 return;
723 }
724
725 AliITSClusterFinder *clf;
726
727 for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
728 //SPD
729 if(dettype==0){
730 if(!GetReconstructionModel(dettype)){
731 clf = new AliITSClusterFinderV2SPD(this);
732 clf->InitGeometry();
733 if(!rawdata) clf->SetDigits(DigitsAddress(0));
734 SetReconstructionModel(dettype,clf);
735
736 }
737 }
738 //SDD
739 if(dettype==1){
740 if(!GetReconstructionModel(dettype)){
741 clf = new AliITSClusterFinderV2SDD(this);
742 clf->InitGeometry();
743 if(!rawdata) clf->SetDigits(DigitsAddress(1));
744 SetReconstructionModel(dettype,clf);
745 }
746
747 }
748
749 //SSD
750 if(dettype==2){
751 if(!GetReconstructionModel(dettype)){
752 clf = new AliITSClusterFinderV2SSD(this);
753 clf->InitGeometry();
754 if(!rawdata) clf->SetDigits(DigitsAddress(2));
755 SetReconstructionModel(dettype,clf);
756 }
757 }
758
759 }
760
761}
762//______________________________________________________________________
763void AliITSDetTypeRec::MakeBranch(TTree* tree, Option_t* option){
764
765 //Creates branches for clusters and recpoints
766 Bool_t cR = (strstr(option,"R")!=0);
767 Bool_t cRF = (strstr(option,"RF")!=0);
768
769 if(cRF)cR = kFALSE;
770
771 if(cR) MakeBranchR(tree);
772 if(cRF) MakeBranchRF(tree);
773
774}
775
776//___________________________________________________________________
777void AliITSDetTypeRec::ResetDigits(){
778 // Reset number of digits and the digits array for the ITS detector.
779
780 if(!fDigits) return;
781 for(Int_t i=0;i<fgkNdettypes;i++){
782 ResetDigits(i);
783 }
784}
785//___________________________________________________________________
786void AliITSDetTypeRec::ResetDigits(Int_t branch){
787 // Reset number of digits and the digits array for this branch.
788
789 if(fDigits->At(branch)) ((TClonesArray*)fDigits->At(branch))->Clear();
790
791}
792//__________________________________________________________________
793void AliITSDetTypeRec::MakeBranchR(TTree *treeR, Option_t *opt){
794
795 //Creates tree branches for recpoints
796 // Inputs:
797 // cont char *file File name where RecPoints branch is to be written
798 // to. If blank it write the SDigits to the same
799 // file in which the Hits were found.
800
801 Int_t buffsz = 4000;
802 char branchname[30];
803
804 // only one branch for rec points for all detector types
805 Bool_t oFast= (strstr(opt,"Fast")!=0);
806
807 Char_t detname[10] = "ITS";
808
809
810 if(oFast){
811 snprintf(branchname,29,"%sRecPointsF",detname);
812 } else {
813 snprintf(branchname,29,"%sRecPoints",detname);
814 }
815
816 if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000);
817 if (treeR)
818 MakeBranchInTree(treeR,branchname,0,&fRecPoints,buffsz,99);
819}
820//______________________________________________________________________
821void AliITSDetTypeRec::SetTreeAddressR(TTree* const treeR){
822 // Set branch address for the Reconstructed points Trees.
823 // Inputs:
824 // TTree *treeR Tree containing the RecPoints.
825 // Outputs:
826 // none.
827 // Return:
828
829 char branchname[30];
830 Char_t namedet[10]="ITS";
831
832 if(!treeR) return;
833 if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
834 TBranch *branch;
835 snprintf(branchname,29,"%sRecPoints",namedet);
836 branch = treeR->GetBranch(branchname);
837 if (branch) {
838 branch->SetAddress(&fRecPoints);
839 }
840 else {
841 snprintf(branchname,29,"%sRecPointsF",namedet);
842 branch = treeR->GetBranch(branchname);
843 if (branch) {
844 branch->SetAddress(&fRecPoints);
845 }
846 }
847}
848//____________________________________________________________________
849void AliITSDetTypeRec::AddRecPoint(const AliITSRecPoint &r){
850 // Add a reconstructed space point to the list
851 // Inputs:
852 // const AliITSRecPoint &r RecPoint class to be added to the tree
853 // of reconstructed points TreeR.
854 // Outputs:
855 // none.
856 // Return:
857 // none.
858 TClonesArray &lrecp = *fRecPoints;
859 new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
860}
861
862//______________________________________________________________________
863void AliITSDetTypeRec::DigitsToRecPoints(TTree *treeD,TTree *treeR,Int_t lastentry,Option_t *opt, Int_t optCluFind){
864 // cluster finding and reconstruction of space points
865 // the condition below will disappear when the geom class will be
866 // initialized for all versions - for the moment it is only for v5 !
867 // 7 is the SDD beam test version
868 // Inputs:
869 // TTree *treeD Digits tree
870 // TTree *treeR Clusters tree
871 // Int_t lastentry Offset for module when not all of the modules
872 // are processed.
873 // Option_t *opt String indicating which ITS sub-detectors should
874 // be processed. If ="All" then all of the ITS
875 // sub detectors are processed.
876
877 const char *all = strstr(opt,"All");
878 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
879 strstr(opt,"SSD")};
880 if(optCluFind==0){
881 SetDefaultClusterFindersV2();
882 AliDebug(1,"V2 cluster finder has been selected \n");
883 }else{
884 SetDefaultClusterFindersV2();
885 AliInfo("Cluster Finder Option not implemented, V2 cluster finder will be used \n");
886 }
887
888
889 // Reset Fast-OR fired map
890 ResetFastOrFiredMap();
891
892 if (all || det[0]) { // SPD present
893 // Get the FO signals for this event
894 AliRunLoader* runLoader = AliRunLoader::Instance();
895 AliITSLoader* itsLoader = (AliITSLoader*) runLoader->GetLoader("ITSLoader");
896 if (!itsLoader) {
897 AliError("ITS loader is NULL.");
898 }
899 else {
900 fFOSignals = (AliITSFOSignalsSPD*)itsLoader->TreeD()->GetUserInfo()->FindObject("AliITSFOSignalsSPD");
901 if(!fFOSignals) AliError("FO signals not retrieved");
902 }
903
904 }
905
906
907 AliITSClusterFinder *rec = 0;
908 Int_t id,module,first=0;
909 for(module=0;module<GetITSgeom()->GetIndexMax();module++){
910 id = GetITSgeom()->GetModuleType(module);
911 if (!all && !det[id]) continue;
912 if(det[id]) first = GetITSgeom()->GetStartDet(id);
913 rec = (AliITSClusterFinder*)GetReconstructionModel(id);
914 TClonesArray *itsDigits = DigitsAddress(id);
915 if (!rec){
916 AliFatal("The reconstruction class was not instanciated!");
917 return;
918 }
919 ResetDigits(); // MvL: Not sure we neeed this when rereading anyways
920 if (all) {
921 treeD->GetEvent(lastentry+module);
922 }
923 else {
924 treeD->GetEvent(lastentry+(module-first));
925 }
926 Int_t ndigits = itsDigits->GetEntriesFast();
927 if (ndigits>0 || id==0) { // for SPD we always want to call FindRawClusters (to process FO signals)
928 rec->SetDetTypeRec(this);
929 rec->SetDigits(DigitsAddress(id));
930 // rec->SetClusters(ClustersAddress(id));
931 rec->FindRawClusters(module);
932 } // end if
933 treeR->Fill();
934 ResetRecPoints();
935 }
936
937 // Remove PIT in-active chips from Fast-OR fired map
938 if (all || det[0]) { // SPD present
939 RemoveFastOrFiredInActive();
940 // here removing bits which have no associated clusters
941 RemoveFastOrFiredFromDead(GetFiredChipMap(treeR));
942 }
943
944 AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
945 Int_t nClu[6];
946 nClu[0]=rpcont->GetNClustersInLayer(1,treeR);
947 for(Int_t iLay=2; iLay<=6; iLay++) nClu[iLay-1]=rpcont->GetNClustersInLayerFast(iLay);
948 AliInfo(Form("Number of RecPoints in ITS Layers = %d %d %d %d %d %d",
949 nClu[0],nClu[1],nClu[2],nClu[3],nClu[4],nClu[5]));
950}
951//______________________________________________________________________
952void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,TTree *treeR,Option_t *opt){
953 // cluster finding and reconstruction of space points
954 // the condition below will disappear when the geom class will be
955 // initialized for all versions - for the moment it is only for v5 !
956 // 7 is the SDD beam test version
957 // Inputs:
958 // AliRawReader *rawReader Pointer to the raw-data reader
959 // TTree *treeR Clusters tree
960 // Outputs:
961 // none.
962 // Return:
963 // none.
964 const char *all = strstr(opt,"All");
965 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
966 strstr(opt,"SSD")};
967
968 Int_t id=0;
969 AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
970 rpc->FullReset();
971 TClonesArray* array = rpc->UncheckedGetClusters(0);
972 TBranch *branch = treeR->Branch("ITSRecPoints",&array);
973 DigitsToRecPoints(rawReader,opt);
974
975 Int_t nClusters =0;
976 for(Int_t iModule=0;iModule<GetITSgeom()->GetIndexMax();iModule++){
977 id = GetITSgeom()->GetModuleType(iModule);
978 if (!all && !det[id]) continue;
979 array = rpc->UncheckedGetClusters(iModule);
980 if(!array){
981 AliDebug(1,Form("data for module %d missing!",iModule));
982 }
983 branch->SetAddress(&array);
984 treeR->Fill();
985 nClusters+=array->GetEntriesFast();
986 }
987
988 rpc->FullReset();
989
990 AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
991 Int_t nClu[6];
992 nClu[0]=rpcont->GetNClustersInLayer(1,treeR);
993 for(Int_t iLay=2; iLay<=6; iLay++) nClu[iLay-1]=rpcont->GetNClustersInLayerFast(iLay);
994 AliInfo(Form("Number of RecPoints in ITS Layers = %d %d %d %d %d %d, Total = %d",
995 nClu[0],nClu[1],nClu[2],nClu[3],nClu[4],nClu[5],nClusters));
996}
997//______________________________________________________________________
998void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,Option_t *opt){
999 // cluster finding and reconstruction of space points
1000 // the condition below will disappear when the geom class will be
1001 // initialized for all versions - for the moment it is only for v5 !
1002 // 7 is the SDD beam test version
1003 // Inputs:
1004 // AliRawReader *rawReader Pointer to the raw-data reader
1005 // Outputs:
1006 // none.
1007 // Return:
1008 // none.
1009 const char *all = strstr(opt,"All");
1010 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1011 strstr(opt,"SSD")};
1012
1013 // Reset Fast-OR fired map
1014 ResetFastOrFiredMap();
1015
1016 AliITSClusterFinder *rec = 0;
1017 Int_t id=0;
1018
1019 for(id=0;id<3;id++){
1020 if (!all && !det[id]) continue;
1021 rec = (AliITSClusterFinder*)GetReconstructionModel(id);
1022 if (!rec){
1023 AliFatal("The reconstruction class was not instantiated");
1024 return;
1025 }
1026 rec->SetDetTypeRec(this);
1027 rec->RawdataToClusters(rawReader);
1028 }
1029
1030 // Remove PIT in-active chips from Fast-OR fired map
1031 if (all || det[0]) { // SPD present
1032 RemoveFastOrFiredInActive();
1033 // here removing bits which have no associated clusters
1034 RemoveFastOrFiredFromDead(GetFiredChipMap());
1035
1036 }
1037}
1038//______________________________________________________________________
1039void AliITSDetTypeRec::ReadOldSSDNoise(const TObjArray *array,
1040 AliITSNoiseSSDv2 *noiseSSD) {
1041 //Reads the old SSD calibration object and converts it to the new format
1042 const Int_t fgkSSDSTRIPSPERMODULE = 1536;
1043 const Int_t fgkSSDPSIDESTRIPSPERMODULE = 768;
1044
1045 Int_t gNMod = array->GetEntries();
1046 AliInfo("Converting old calibration object for noise...\n");
1047
1048 //NOISE
1049 Double_t noise = 0.0;
1050 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
1051 AliITSNoiseSSD *noiseModule = (AliITSNoiseSSD*) (array->At(iModule));
1052 for(Int_t iStrip = 0; iStrip < fgkSSDSTRIPSPERMODULE; iStrip++) {
1053 noise = (iStrip < fgkSSDPSIDESTRIPSPERMODULE) ? noiseModule->GetNoiseP(iStrip) : noiseModule->GetNoiseN(1535 - iStrip);
1054 if(iStrip < fgkSSDPSIDESTRIPSPERMODULE)
1055 noiseSSD->AddNoiseP(iModule,iStrip,noise);
1056 if(iStrip >= fgkSSDPSIDESTRIPSPERMODULE)
1057 noiseSSD->AddNoiseN(iModule,1535 - iStrip,noise);
1058 }//loop over strips
1059 }//loop over modules
1060}
1061
1062//______________________________________________________________________
1063void AliITSDetTypeRec::ReadOldSSDBadChannels(const TObjArray *array,
1064 AliITSBadChannelsSSDv2 *badChannelsSSD) {
1065 //Reads the old SSD calibration object and converts it to the new format
1066 Int_t gNMod = array->GetEntries();
1067 AliInfo("Converting old calibration object for bad channels...");
1068 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
1069 //for (Int_t iModule = 0; iModule < 1; iModule++) {
1070 AliITSBadChannelsSSD *bad = (AliITSBadChannelsSSD*) (array->At(iModule));
1071 TArrayI arrayPSide = bad->GetBadPChannelsList();
1072 for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++)
1073 badChannelsSSD->AddBadChannelP(iModule,
1074 iPCounter,
1075 (Char_t)arrayPSide.At(iPCounter));
1076
1077 TArrayI arrayNSide = bad->GetBadNChannelsList();
1078 for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++)
1079 badChannelsSSD->AddBadChannelN(iModule,
1080 iNCounter,
1081 (Char_t)arrayNSide.At(iNCounter));
1082
1083 }//loop over modules
1084}
1085
1086//______________________________________________________________________
1087void AliITSDetTypeRec::ReadOldSSDGain(const TObjArray *array,
1088 AliITSGainSSDv2 *gainSSD) {
1089 //Reads the old SSD calibration object and converts it to the new format
1090
1091 Int_t gNMod = array->GetEntries();
1092 AliInfo("Converting old calibration object for gain...\n");
1093
1094 //GAIN
1095 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
1096 AliITSGainSSD *gainModule = (AliITSGainSSD*) (array->At(iModule));
1097 TArrayF arrayPSide = gainModule->GetGainP();
1098 for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++)
1099 gainSSD->AddGainP(iModule,
1100 iPCounter,
1101 arrayPSide.At(iPCounter));
1102 TArrayF arrayNSide = gainModule->GetGainN();
1103 for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++)
1104 gainSSD->AddGainN(iModule,
1105 iNCounter,
1106 arrayNSide.At(iNCounter));
1107 }//loop over modules
1108}
1109//______________________________________________________________________
1110void AliITSDetTypeRec::RemoveFastOrFiredInActive() {
1111 // Removes the chips that were in-active in the pixel trigger (from fast-or fired map)
1112
1113 if (fTriggerConditions==NULL) {
1114 AliError("Pixel trigger conditions are missing.");
1115 return;
1116 }
1117 Int_t eq = -1;
1118 Int_t hs = -1;
1119 Int_t chip = -1;
1120 while (fTriggerConditions->GetNextInActiveChip(eq,hs,chip)) {
1121 UInt_t chipKey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1122 fFastOrFiredMap.SetBitNumber(chipKey,kFALSE);
1123 }
1124}
1125//______________________________________________________________________
1126TBits AliITSDetTypeRec::GetFiredChipMap() const {
1127
1128 //
1129 // TBits of the fired chips
1130 //
1131
1132 AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
1133
1134 TBits isfiredchip(1200);
1135
1136 AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)GetSegmentationModel(0);
1137 if(!segSPD) {
1138 AliError("no segmentation model for SPD available, the fired chip map is empty. Exiting");
1139 return isfiredchip;
1140 }
1141
1142
1143 for(Int_t imod =0; imod < fgkDefaultNModulesSPD; imod++){
1144 TClonesArray *array = rpc->UncheckedGetClusters(imod);
1145 if(!array) continue;
1146 Int_t nCluster = array->GetEntriesFast();
1147
1148 while(nCluster--) {
1149 AliITSRecPoint* cluster = (AliITSRecPoint*)array->UncheckedAt(nCluster);
1150 if (cluster->GetLayer()>1)continue;
1151 Float_t local[3]={-1,-1};
1152 local[1]=cluster->GetDetLocalX();
1153 local[0]=cluster->GetDetLocalZ();
1154
1155 Int_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(imod);
1156 Int_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(imod);
1157 Int_t row, col;
1158 segSPD->LocalToDet(0.5,local[0],row,col);
1159 Int_t chip = AliITSRawStreamSPD::GetOnlineChipFromOffline(imod,col);
1160 Int_t chipkey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1161 isfiredchip.SetBitNumber(chipkey,kTRUE);
1162 }
1163
1164 }
1165
1166 return isfiredchip;
1167
1168}
1169//______________________________________________________________________
1170TBits AliITSDetTypeRec::GetFiredChipMap(TTree *treeR) const{
1171 //
1172 // TBits of the fired chips
1173 //
1174 TBits isfiredchip(1200);
1175
1176 if(!treeR) {
1177 AliError("no treeR. fired chip map stays empty. Exiting.");
1178 return isfiredchip;
1179 }
1180
1181 AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
1182 TClonesArray *recpoints = NULL;
1183 rpcont->FetchClusters(0,treeR);
1184 if(!rpcont->GetStatusOK() || !rpcont->IsSPDActive()){
1185 AliError("no clusters. fired chip map stays empty. Exiting.");
1186 return isfiredchip;
1187 }
1188
1189 AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)GetSegmentationModel(0);
1190
1191 for(Int_t imod =0; imod < fgkDefaultNModulesSPD; imod++){
1192 recpoints = rpcont->UncheckedGetClusters(imod);
1193 Int_t nCluster = recpoints->GetEntriesFast();
1194
1195 // loop over clusters
1196 while(nCluster--) {
1197 AliITSRecPoint* cluster = (AliITSRecPoint*)recpoints->UncheckedAt(nCluster);
1198 if (cluster->GetLayer()>1)continue;
1199 Float_t local[3]={-1,-1};
1200 local[1]=cluster->GetDetLocalX();
1201 local[0]=cluster->GetDetLocalZ();
1202
1203 Int_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(imod);
1204 Int_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(imod);
1205 Int_t row, col;
1206 segSPD->LocalToDet(0.5,local[0],row,col);
1207 Int_t chip = AliITSRawStreamSPD::GetOnlineChipFromOffline(imod,col);
1208 Int_t chipkey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1209 isfiredchip.SetBitNumber(chipkey,kTRUE);
1210 }
1211 }
1212
1213 return isfiredchip;
1214}
1215//______________________________________________________________________
1216void AliITSDetTypeRec::RemoveFastOrFiredFromDead(TBits firedchipmap){
1217 //
1218 // resetting of the fast-or bit on cluster basis.
1219 // fast-or bits can be remnant from SPD ideal simulation (no dead channels)
1220 //
1221
1222 for(Int_t chipKey=0; chipKey<1200; chipKey++){
1223 // FO masked chips have been previously removed
1224 if(!fFastOrFiredMap.TestBitNumber(chipKey)) continue;
1225 if(!firedchipmap.TestBitNumber(chipKey)) {
1226 fFastOrFiredMap.SetBitNumber(chipKey,kFALSE);
1227 AliDebug(2,Form("removing bit in key %i \n ",chipKey));
1228 }
1229 }
1230
1231}
1232//______________________________________________________________________
1233void AliITSDetTypeRec::SetFastOrFiredMapOnline(UInt_t eq, UInt_t hs, UInt_t chip) {
1234 // Set fast-or fired map for this chip
1235 Int_t chipKey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1236 return SetFastOrFiredMap(chipKey);
1237}
1238