fix in calling of gaussian spread function
[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 fSPDSparseDead(0),
80 fTriggerConditions(0),
81 fDigits(0),
82 fFOSignals(0),
83 fDDLMapSDD(0),
84 fRespSDD(0),
85 fAveGainSDD(0),
86 fRecPoints(0),
87 fNRecPoints(0),
88 fFirstcall(kTRUE),
89 fLoadOnlySPDCalib(0),
90 fFastOrFiredMap(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 //______________________________________________________________________
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 fSPDSparseDead(rec.fSPDSparseDead),
124 fTriggerConditions(rec.fTriggerConditions),
125 fDigits(rec.fDigits),
126 fFOSignals(rec.fFOSignals),
127 fDDLMapSDD(rec.fDDLMapSDD),
128 fRespSDD(rec.fRespSDD),
129 fAveGainSDD(rec.fAveGainSDD),
130 fRecPoints(rec.fRecPoints),
131 fNRecPoints(rec.fNRecPoints),
132 fFirstcall(rec.fFirstcall),
133 fLoadOnlySPDCalib(rec.fLoadOnlySPDCalib),
134 fFastOrFiredMap(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 //______________________________________________________________________
142 AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& source){
143     // Assignment operator. 
144     this->~AliITSDetTypeRec();
145     new(this) AliITSDetTypeRec(source);
146     return *this;
147
148 }
149
150 //_____________________________________________________________________
151 AliITSDetTypeRec::~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 //___________________________________________________________________
208 void 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 //______________________________________________________________________
217 AliITSClusterFinder* 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 //______________________________________________________________________
228 void 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 //______________________________________________________________________
238 AliITSsegmentation* 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 //_______________________________________________________________________
250 void 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 //_______________________________________________________________________
265 void 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 //_______________________________________________________________________
279 void 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 //_______________________________________________________________________
293 AliITSCalibration* 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 //_______________________________________________________________________
312 AliITSCalibration* 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 //_______________________________________________________________________
323 AliITSCalibration* 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 //_______________________________________________________________________
334 AliITSTriggerConditions* AliITSDetTypeRec::GetTriggerConditions() const {
335   //Get Pixel Trigger Conditions
336   if (fTriggerConditions==0) {
337     AliWarning("fTriggerConditions is 0!");
338   }
339   return fTriggerConditions;
340 }
341 //______________________________________________________________________
342 void 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 //_______________________________________________________________________
370 TBranch* 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 //____________________________________________________________________
399 void 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 //______________________________________________________________________
437 Bool_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 //______________________________________________________________________
472 Bool_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 //______________________________________________________________________
531 Bool_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 //______________________________________________________________________
642 Bool_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 //________________________________________________________________
716 void 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 //______________________________________________________________________
763 void 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 //___________________________________________________________________
777 void 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 //___________________________________________________________________
786 void 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 //__________________________________________________________________
793 void 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 //______________________________________________________________________
821 void 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 //____________________________________________________________________
849 void 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 //______________________________________________________________________
863 void 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 //______________________________________________________________________
952 void 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 //______________________________________________________________________
998 void 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 //______________________________________________________________________
1039 void 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 //______________________________________________________________________
1063 void 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 //______________________________________________________________________
1087 void 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 //______________________________________________________________________
1110 void 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 //______________________________________________________________________
1126 TBits 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 //______________________________________________________________________
1170 TBits 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 //______________________________________________________________________
1216 void  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 //______________________________________________________________________
1233 void 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