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