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