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