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