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