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