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