Code related to new SPDSSpareseDead object in the OCDB + Coverity fixes (A. Mastroserio)
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Feb 2011 09:18:49 +0000 (09:18 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Feb 2011 09:18:49 +0000 (09:18 +0000)
ITS/AliITSChannelStatus.cxx
ITS/AliITSChannelStatus.h
ITS/AliITSDetTypeRec.cxx
ITS/AliITSDetTypeRec.h
ITS/AliITSDetTypeSim.cxx
ITS/AliITSDetTypeSim.h
ITS/AliITSOnlineCalibrationSPDhandler.cxx
ITS/AliITSOnlineCalibrationSPDhandler.h
ITS/AliITSOnlineSPDphys.cxx
ITS/AliITSPlaneEffSPD.cxx

index b957545..4eb8ffd 100644 (file)
@@ -68,6 +68,11 @@ fSSDChannelStatus(0)
   TObjArray* deadArrSPD = (TObjArray*)spdEntryD->GetObject();
   if (!deadArrSPD) AliFatal("No object found in SPDDead file");
 
+  AliCDBEntry* spdEntrySparseD = cdb->Get("ITS/Calib/SPDSparseDead");
+  if (!spdEntrySparseD) AliFatal("Cannot get CDB entry for SPDSparseDead");
+  TObjArray* deadSparseArrSPD = (TObjArray*)spdEntrySparseD->GetObject();
+  if (!deadSparseArrSPD) AliFatal("No object found in SPDSparseDead file");
+  
   AliCDBEntry* spdEntryN = cdb->Get("ITS/Calib/SPDNoisy");
   if (!spdEntryN) AliFatal("Cannot get CDB entry for SPDNoisy");
   TObjArray* noisArrSPD = (TObjArray*)spdEntryN->GetObject();
@@ -89,7 +94,7 @@ fSSDChannelStatus(0)
   fSDDChannelStatus=new TBits(nSDDchan);
   UInt_t nSSDchan=kSSDModules*kSSDStripsPerModule;
   fSSDChannelStatus=new TBits(nSSDchan);
-  InitFromOCDB(deadArrSPD,noisArrSPD,calArrSDD,calArrSSD);
+  InitFromOCDB(deadArrSPD,deadSparseArrSPD,noisArrSPD,calArrSDD,calArrSSD);
 }
 //______________________________________________________________________
 AliITSChannelStatus::AliITSChannelStatus(const AliITSDetTypeRec *dtrec):
@@ -124,6 +129,15 @@ fSSDChannelStatus(0)
       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
       fSPDChannelStatus->SetBitNumber(index,kFALSE);      
     }
+    
+       // Mask SPD sparse dead pixels
+    AliITSCalibrationSPD* deadSparseSpd=(AliITSCalibrationSPD*)dtrec->GetSPDSparseDeadModel(imod);
+    for(Int_t ipix=0; ipix<deadSparseSpd->GetNrBad();ipix++){
+      deadSparseSpd->GetBadPixel(ipix,ix,iz);
+      Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
+      fSPDChannelStatus->SetBitNumber(index,kFALSE);      
+    }
+    
     // Mask SPD noisy pixels
     AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)dtrec->GetCalibrationModel(imod);
     for(Int_t ipix=0; ipix<noisspd->GetNrBad();ipix++){
@@ -184,7 +198,7 @@ void  AliITSChannelStatus::InitDefaults(){
   }
 }
 //______________________________________________________________________
-void AliITSChannelStatus::InitFromOCDB(TObjArray* deadArrSPD, TObjArray* noisArrSPD, TObjArray* calArrSDD, TObjArray *calArrSSD){
+void AliITSChannelStatus::InitFromOCDB(TObjArray* deadArrSPD, TObjArray* deadSingleArrSPD, TObjArray* noisArrSPD, TObjArray* calArrSDD, TObjArray *calArrSSD){
 // fills bitmaps from arrays of AliITSCalibrationSXD objects
 
   // SPD modules
@@ -204,6 +218,14 @@ void AliITSChannelStatus::InitFromOCDB(TObjArray* deadArrSPD, TObjArray* noisArr
       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
       fSPDChannelStatus->SetBitNumber(index,kFALSE);      
     }
+    
+    // Mask SPD sparse dead pixels
+    AliITSCalibrationSPD* deadSparseSpd=(AliITSCalibrationSPD*)deadArrSPD->At(imod);
+    for(Int_t ipix=0; ipix<deadSparseSpd->GetNrBad();ipix++){
+      deadSparseSpd->GetBadPixel(ipix,ix,iz);
+      Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
+      fSPDChannelStatus->SetBitNumber(index,kFALSE);      
+    }
 
     // Mask SPD noisy pixels
     AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)noisArrSPD->At(imod);
index 3dcac79..b4feb11 100644 (file)
@@ -44,7 +44,7 @@ class AliITSChannelStatus : public TObject {
   
  protected:
   void InitDefaults();
-  void InitFromOCDB(TObjArray* deadArrSPD, TObjArray* noisArrSPD, TObjArray* calArrSDD, TObjArray* noisArrSSD);
+  void InitFromOCDB(TObjArray* deadArrSPD, TObjArray* deadSparseArrSPD, TObjArray* noisArrSPD, TObjArray* calArrSDD, TObjArray* noisArrSSD);
   Bool_t CheckBounds(Int_t imod, Int_t iz, Int_t ix=0) const;
   Bool_t GetSPDLimits(Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax, Int_t& izmin, Int_t& izmax, Int_t& ixmin, Int_t& ixmax)  const;
   Bool_t GetSDDLimits(Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax, Int_t& izmin, Int_t& izmax, Int_t& izmin2, Int_t& izmax2) const;
index fdc2c10..27efa51 100644 (file)
@@ -76,6 +76,7 @@ fSegmentation(0),
 fCalibration(0),
 fSSDCalibration(0),
 fSPDDead(0),
+fSPDSparseDead(0),
 fTriggerConditions(0),
 fDigits(0),
 fFOSignals(0),
@@ -120,6 +121,7 @@ fSegmentation(rec.fSegmentation),
 fCalibration(rec.fCalibration),
 fSSDCalibration(rec.fSSDCalibration),
 fSPDDead(rec.fSPDDead),
+fSPDSparseDead(rec.fSPDSparseDead),
 fTriggerConditions(rec.fTriggerConditions),
 fDigits(rec.fDigits),
 fFOSignals(rec.fFOSignals),
@@ -182,6 +184,13 @@ AliITSDetTypeRec::~AliITSDetTypeRec(){
       fSPDDead = 0;
     }
   } 
+     if(fSPDSparseDead){
+    if(!(AliCDBManager::Instance()->GetCacheFlag())) {
+      fSPDSparseDead->Delete();
+      delete fSPDSparseDead;
+      fSPDSparseDead = 0;
+    }
+  } 
   if(fTriggerConditions){
     if(!(AliCDBManager::Instance()->GetCacheFlag())) {
       fTriggerConditions->Delete();
@@ -277,6 +286,20 @@ void AliITSDetTypeRec::SetSPDDeadModel(Int_t iMod, AliITSCalibration *cal){
   fSPDDead->AddAt(cal,iMod);
 }
 //_______________________________________________________________________
+void AliITSDetTypeRec::SetSPDSparseDeadModel(Int_t iMod, AliITSCalibration *cal){
+
+  //Set dead pixel info for the SPD ACTIVE module iMod
+  if (fSPDSparseDead==0) {
+    fSPDSparseDead = new TObjArray(fgkDefaultNModulesSPD);
+    fSPDSparseDead->SetOwner(kTRUE);
+    fSPDSparseDead->Clear();
+  }
+
+  if (fSPDSparseDead->At(iMod) != 0)
+    delete (AliITSCalibration*) fSPDSparseDead->At(iMod);
+  fSPDSparseDead->AddAt(cal,iMod);
+}
+//_______________________________________________________________________
 AliITSCalibration* AliITSDetTypeRec::GetCalibrationModel(Int_t iMod) const {
   
   //Get calibration model for module type
@@ -307,6 +330,17 @@ AliITSCalibration* AliITSDetTypeRec::GetSPDDeadModel(Int_t iMod) const {
   return (AliITSCalibration*)fSPDDead->At(iMod);
 }
 //_______________________________________________________________________
+AliITSCalibration* AliITSDetTypeRec::GetSPDSparseDeadModel(Int_t iMod) const {
+  
+  //Get SPD dead for module iMod
+  
+  if(fSPDSparseDead==0) {
+    AliWarning("fSPDSparseDead is 0!");
+    return 0; 
+  }  
+  return (AliITSCalibration*)fSPDSparseDead->At(iMod);
+}
+//_______________________________________________________________________
 AliITSTriggerConditions* AliITSDetTypeRec::GetTriggerConditions() const {
   //Get Pixel Trigger Conditions
   if (fTriggerConditions==0) {
@@ -452,6 +486,7 @@ Bool_t AliITSDetTypeRec::GetCalibrationSPD(Bool_t cacheStatus) {
  
   AliCDBEntry *noisySPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDNoisy");
   AliCDBEntry *deadSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead");
+  AliCDBEntry *deadSparseSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDSparseDead");
   AliCDBEntry *pitCond = AliCDBManager::Instance()->Get("TRIGGER/SPD/PITConditions");
   if(!noisySPD || !deadSPD || !pitCond ){
     AliFatal("SPD Calibration object retrieval failed! ");
@@ -466,6 +501,11 @@ Bool_t AliITSDetTypeRec::GetCalibrationSPD(Bool_t cacheStatus) {
   if (!cacheStatus) deadSPD->SetObject(NULL);
   deadSPD->SetOwner(kTRUE);
 
+  TObjArray *calSparseDeadSPD = (TObjArray*) deadSparseSPD->GetObject();
+  if (!cacheStatus) deadSparseSPD->SetObject(NULL);
+  deadSparseSPD->SetOwner(kTRUE);
+
+  
   AliITSTriggerConditions *calPitCond = (AliITSTriggerConditions*) pitCond->GetObject();
   if (!cacheStatus) pitCond->SetObject(NULL);
   pitCond->SetOwner(kTRUE);
@@ -473,9 +513,10 @@ Bool_t AliITSDetTypeRec::GetCalibrationSPD(Bool_t cacheStatus) {
   if(!cacheStatus){
     delete noisySPD;
     delete deadSPD;
+    delete deadSparseSPD;
     delete pitCond;
   }
-  if ((!calNoisySPD) || (!calDeadSPD) || (!calPitCond)){ 
+  if ((!calNoisySPD) || (!calDeadSPD) || (!calSparseDeadSPD) || (!calPitCond)){ 
     AliWarning("Can not get SPD calibration from calibration database !");
     return kFALSE;
   }
@@ -488,6 +529,8 @@ Bool_t AliITSDetTypeRec::GetCalibrationSPD(Bool_t cacheStatus) {
     SetCalibrationModel(i, cal);
     cal = (AliITSCalibration*) calDeadSPD->At(i);
     SetSPDDeadModel(i, cal);
+    cal = (AliITSCalibration*) calSparseDeadSPD->At(i);
+    SetSPDSparseDeadModel(i, cal);
   }
   fTriggerConditions = calPitCond;
 
index f80f83d..565cce8 100644 (file)
@@ -50,11 +50,13 @@ class AliITSDetTypeRec : public TObject {
     virtual void SetSegmentationModel(Int_t dettype, AliITSsegmentation *seg);
     virtual void SetCalibrationModel(Int_t iMod, AliITSCalibration *cal);
     virtual void SetSPDDeadModel(Int_t iMod, AliITSCalibration *cal);
+    virtual void SetSPDSparseDeadModel(Int_t iMod, AliITSCalibration *cal);
     virtual void SetReconstructionModel(Int_t dettype, AliITSClusterFinder *rec);
     virtual Bool_t GetCalibration();
     virtual AliITSsegmentation* GetSegmentationModel(Int_t dettype) const;
     virtual AliITSCalibration* GetCalibrationModel(Int_t iMod) const;
     virtual AliITSCalibration* GetSPDDeadModel(Int_t iMod) const;
+    virtual AliITSCalibration* GetSPDSparseDeadModel(Int_t iMod) const;
     virtual AliITSTriggerConditions* GetTriggerConditions() const;
     virtual AliITSClusterFinder* GetReconstructionModel(Int_t dettype) const;
     virtual AliITSDDLModuleMapSDD* GetDDLModuleMapSDD() const { return fDDLMapSDD;}
@@ -133,6 +135,7 @@ class AliITSDetTypeRec : public TObject {
     TObjArray    *fCalibration;   //! [NMod]
     AliITSCalibrationSSD* fSSDCalibration;  //! SSD calibration object
     TObjArray    *fSPDDead;       //! [fgkDefaultNModulesSPD]
+    TObjArray    *fSPDSparseDead;       //! [fgkDefaultNModulesSPD]
     AliITSTriggerConditions *fTriggerConditions; //! PIT conditions object
     TObjArray    *fDigits;        //! [NMod][NDigits]
     AliITSFOSignalsSPD *fFOSignals; //! Fast-Or signals (used when reconstructing from digits)
@@ -150,7 +153,7 @@ class AliITSDetTypeRec : public TObject {
 
     TBits fFastOrFiredMap;     //! Map of FastOr fired chips (after processing of raw signals)
 
-    ClassDef(AliITSDetTypeRec,19) // ITS Reconstruction structure
+    ClassDef(AliITSDetTypeRec,20) // ITS Reconstruction structure
 };
 
 #endif
index 3bafe54..ba09e78 100644 (file)
@@ -83,6 +83,7 @@ fSegmentation(), // [NDet]
 fCalibration(),     // [NMod]
 fSSDCalibration(0),
 fSPDNoisy(0),
+fSPDSparseDead(0),
 fNSDigits(0),    //! number of SDigits
 fSDigits("AliITSpListItem",1000),   
 fNDigits(0),     //! number of Digits
@@ -155,6 +156,13 @@ AliITSDetTypeSim::~AliITSDetTypeSim(){
        fSPDNoisy = 0;
       }
     }
+    if(fSPDSparseDead){
+    if(!(AliCDBManager::Instance()->GetCacheFlag())) {
+       fSPDSparseDead->Delete();
+       delete fSPDSparseDead;
+       fSPDSparseDead = 0;
+      }
+    }
     if(fSimuPar) delete fSimuPar;
     if(fRespSDD){
       if(!(AliCDBManager::Instance()->GetCacheFlag())){
@@ -181,6 +189,7 @@ fSegmentation(source.fSegmentation), // [NDet]
 fCalibration(source.fCalibration),     // [NMod]
 fSSDCalibration(source.fSSDCalibration),
 fSPDNoisy(source.fSPDNoisy),
+fSPDSparseDead(source.fSPDSparseDead),
 fNSDigits(source.fNSDigits),    //! number of SDigits
 fSDigits(*((TClonesArray*)source.fSDigits.Clone())),
 fNDigits(source.fNDigits),     //! number of Digits
@@ -369,6 +378,19 @@ void AliITSDetTypeSim::SetSPDNoisyModel(Int_t iMod, AliITSCalibration *cal){
     delete (AliITSCalibration*) fSPDNoisy->At(iMod);
   fSPDNoisy->AddAt(cal,iMod);
 }
+//_______________________________________________________________________
+void AliITSDetTypeSim::SetSPDSparseDeadModel(Int_t iMod, AliITSCalibration *cal){
+  //Set sparse dead pixel info for the SPD module iMod
+  if (fSPDSparseDead==0) {
+    fSPDSparseDead = new TObjArray(fgkDefaultNModulesSPD);
+    fSPDSparseDead->SetOwner(kTRUE);
+    fSPDSparseDead->Clear();
+  }
+
+  if (fSPDNoisy->At(iMod) != 0)
+    delete (AliITSCalibration*) fSPDNoisy->At(iMod);
+  fSPDNoisy->AddAt(cal,iMod);
+}
 //______________________________________________________________________
 void AliITSDetTypeSim::ResetCalibrationArray(){
     //resets response array
index 19dd162..882ae37 100644 (file)
@@ -59,7 +59,8 @@ class AliITSDetTypeSim : public TObject {
     virtual AliITSsegmentation* GetSegmentationModelByModule(Int_t module) const;
 
     virtual void SetCalibrationModel(Int_t iMod,AliITSCalibration *resp);
-   virtual void SetSPDNoisyModel(Int_t iMod, AliITSCalibration *cal);
+    virtual void SetSPDNoisyModel(Int_t iMod, AliITSCalibration *cal);
+    virtual void SetSPDSparseDeadModel(Int_t iMod, AliITSCalibration *cal);
 
     virtual AliITSCalibration* GetCalibrationModel(Int_t iMod) const;
     virtual AliITSCalibration* GetSPDNoisyModel(Int_t iMod) const;
@@ -144,6 +145,7 @@ class AliITSDetTypeSim : public TObject {
     TObjArray    *fCalibration;  //! [NMod]
     AliITSCalibrationSSD* fSSDCalibration;  //! SSD calibration object
     TObjArray    *fSPDNoisy;     //! [fgkDefaultNModulesSPD]
+    TObjArray    *fSPDSparseDead;//! [fgkDefaultNModulesSPD]
     Int_t         fNSDigits;     //! number of SDigits
     TClonesArray  fSDigits;      //! Summable digits
     Int_t*        fNDigits;      //! [NDet] number of Digits for det.
@@ -159,7 +161,7 @@ class AliITSDetTypeSim : public TObject {
     AliITSFOGeneratorSPD fFOGenerator; //! Fast-OR generator object
     AliITSTriggerConditions* fTriggerConditions; //! Trigger conditions 
        
-    ClassDef(AliITSDetTypeSim,14) // ITS Simulation structure
+    ClassDef(AliITSDetTypeSim,15) // ITS Simulation structure
  
 };
 
index 7aed9f1..06d1b20 100644 (file)
@@ -38,11 +38,12 @@ AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler():
   // constructor
   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
     fNrDead[gloChip]=0;
+    fNrSparseDead[gloChip]=0;
     fNrNoisy[gloChip]=0;
     fDeadPixelMap[gloChip] = new AliITSIntMap();
+    fSparseDeadPixelMap[gloChip] = new AliITSIntMap();
     fNoisyPixelMap[gloChip] = new AliITSIntMap();    
   }
-
   ActivateALL();
   UnSetDeadALL();
 }
@@ -54,12 +55,15 @@ AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliIT
   // copy constructor
   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
     fNrDead[gloChip] = handle.fNrDead[gloChip];
+    fNrSparseDead[gloChip] = handle.fNrSparseDead[gloChip];
     fNrNoisy[gloChip] = handle.fNrNoisy[gloChip];
     fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone();
+    fSparseDeadPixelMap[gloChip] = handle.fSparseDeadPixelMap[gloChip]->Clone();
     fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone();
   }
   for (UInt_t eq=0; eq<20; eq++) {
     fActiveEq[eq] = handle.fActiveEq[eq];
+    fDeadEq[eq]=handle.fDeadEq[eq];
     for (UInt_t hs=0; hs<6; hs++) {
       fActiveHS[eq][hs] = handle.fActiveHS[eq][hs];
       for (UInt_t chip=0; chip<10; chip++) {
@@ -74,6 +78,7 @@ AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() {
   //  ClearMaps();
   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
     delete fDeadPixelMap[gloChip];
+    delete fDeadPixelMap[gloChip];
     delete fNoisyPixelMap[gloChip];
   }
 }
@@ -84,12 +89,15 @@ AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(
     this->ClearMaps();
     for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
       fNrDead[gloChip] = handle.fNrDead[gloChip];
+      fNrSparseDead[gloChip] = handle.fNrSparseDead[gloChip];
       fNrNoisy[gloChip] = handle.fNrNoisy[gloChip];
       fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone();
+      fSparseDeadPixelMap[gloChip] = handle.fSparseDeadPixelMap[gloChip]->Clone();
       fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone();
     }
     for (UInt_t eq=0; eq<20; eq++) {
       fActiveEq[eq] = handle.fActiveEq[eq];
+      fDeadEq[eq] = handle.fDeadEq[eq];
       for (UInt_t hs=0; hs<6; hs++) {
        fActiveHS[eq][hs] = handle.fActiveHS[eq][hs];
        for (UInt_t chip=0; chip<10; chip++) {
@@ -114,7 +122,9 @@ void AliITSOnlineCalibrationSPDhandler::ResetDead() {
   UnSetDeadALL();
   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
     fNrDead[gloChip]=0;
+    fNrSparseDead[gloChip]=0;
     fDeadPixelMap[gloChip]->Clear();
+    fSparseDeadPixelMap[gloChip]->Clear();
   }
 }
 //____________________________________________________________________________________________
@@ -136,6 +146,9 @@ void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eq, UInt_t hs, U
       if (fDeadPixelMap[gloChip]->Remove(key)) {
        fNrDead[gloChip]--;
       }
+      if (fSparseDeadPixelMap[gloChip]->Remove(key)) {
+       fNrSparseDead[gloChip]--;
+      }
     }
   }
 }
@@ -695,6 +708,63 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromDB(Int_t runNr, const Char
   return kTRUE;
 }
 //____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadSparseDeadFromDB(Int_t runNr, const Char_t *storage, Bool_t treeSerial) {
+  // reads dead pixels from DB for given runNr
+  // note that you may want to clear the list (if it is not empty) before reading
+  AliCDBManager* man = AliCDBManager::Instance();
+  TString storageSTR = Form("%s",storage);
+  if (storageSTR.CompareTo("default")==0) {
+    if(!man->IsDefaultStorageSet()) {
+      man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+    }
+  }
+  else {
+    storageSTR = Form("%s",storage);
+    man->SetDefaultStorage(storageSTR.Data());
+  }
+  AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDSparseDead", runNr);
+  TObjArray* spdEntry;
+  if(cdbEntry) {
+    spdEntry = (TObjArray*)cdbEntry->GetObject();
+    if(!spdEntry) return kFALSE;
+  }
+  else {
+    Warning("AliITSOnlineCalibrationSPDhandler::ReadSparseDeadFromDB","Calibration for run %d not found in database.",runNr);
+    return kFALSE;
+  }
+  AliITSCalibrationSPD* calibSPD;
+  for (UInt_t module=0; module<240; module++) {
+    calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
+    UInt_t nrDead = calibSPD->GetNrBadSingle();
+    if (nrDead>0) {
+      if (!treeSerial) {
+        RecursiveInsertSparseDead(calibSPD,module,0,nrDead-1);
+      }
+
+      else {
+        for (UInt_t index=0; index<nrDead; index++) {
+          UInt_t colM = calibSPD->GetBadColAt(index);
+          UInt_t rowM = calibSPD->GetBadRowAt(index);
+          SetSparseDeadPixelM(module,colM,rowM);
+        }
+      }
+    }
+    for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) {
+      UInt_t eq,hs,chip,col,row;
+      AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row);
+      if (calibSPD->IsChipBad(chipIndex)) {
+        SetDeadChip(eq,hs,chip);
+      }
+      else {
+        SetDeadChip(eq,hs,chip,kFALSE);
+      }
+    }
+  }
+  spdEntry->SetOwner(kTRUE);
+  spdEntry->Clear();
+  return kTRUE;
+}
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromDB(Int_t runNr, const Char_t *storage, Bool_t treeSerial) {
   // reads noisy pixels from DB for given runNr
   // note that you may want to clear the list (if it is not empty) before reading
@@ -883,6 +953,54 @@ Bool_t AliITSOnlineCalibrationSPDhandler::WriteDeadToDB(Int_t runNrStart, Int_t
   return kTRUE;
 }
 //____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::WriteSparseDeadToDB(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage) {
+  // writes dead pixels to DB for given runNrs
+  // overwrites any previous entries
+  AliCDBManager* man = AliCDBManager::Instance();
+  TString storageSTR = Form("%s",storage);
+  if (storageSTR.CompareTo("default")==0) {
+    if(!man->IsDefaultStorageSet()) {
+      man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+    }
+  }
+  else {
+    storageSTR = Form("%s",storage);
+    man->SetDefaultStorage(storageSTR.Data());
+  }
+  AliCDBMetaData* metaData = new AliCDBMetaData();
+  metaData->SetResponsible("Annalisa Mastroserio");
+  metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler.");
+  AliCDBId idCalSPD("ITS/Calib/SPDSparseDead",runNrStart,runNrEnd);
+  TObjArray* spdEntry = new TObjArray(240);
+  spdEntry->SetOwner(kTRUE);
+  for(UInt_t module=0; module<240; module++){
+    AliITSCalibrationSPD* calibSPD = new AliITSCalibrationSPD();
+    spdEntry->Add(calibSPD);
+  }
+  for(UInt_t module=0; module<240; module++){
+    AliITSCalibrationSPD* calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
+    //printf(" AliITSOnlineCalibrationSPDhandler::WriteSparseDeadToDB :  nr Sparse dead in module %i - %i \n",module,GetNrSparseDead(module));
+    calibSPD->SetNrBadSingle( GetNrSparseDead(module) );
+    calibSPD->SetBadList( GetSparseDeadArray(module) );
+    for (UInt_t chipIndex=0; chipIndex<5; chipIndex++) {
+      UInt_t eq,hs,chip,col,row;
+      AliITSRawStreamSPD::OfflineToOnline(module, chipIndex*32, 0, eq, hs, chip, col, row);
+      if (IsSilentChip(eq,hs,chip)) {
+        calibSPD->SetChipBad(chipIndex);
+      }
+      else {
+        calibSPD->UnSetChipBad(chipIndex);
+      }
+    }
+  }
+  AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
+  man->Put(cdbEntry);
+  delete spdEntry;
+  delete cdbEntry;
+  delete metaData;
+  return kTRUE;
+}
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::WriteDeadToDBasNoisy(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage) {
   // writes dead pixels to DB for given runNrs
   // overwrites any previous entries
@@ -976,6 +1094,15 @@ void AliITSOnlineCalibrationSPDhandler::RecursiveInsertDead(AliITSCalibrationSPD
   RecursiveInsertDead(calibSPD,module,thisInd+1,highInd);
 }
 //____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::RecursiveInsertSparseDead(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd) {
+  // inserts sparse dead pixels recursively, used when reading from db
+  if (lowInd>highInd) return;
+  Int_t thisInd = lowInd+(highInd-lowInd)/2;
+  SetSparseDeadPixelM(module,calibSPD->GetBadColAt(thisInd),calibSPD->GetBadRowAt(thisInd));
+  RecursiveInsertSparseDead(calibSPD,module,lowInd,thisInd-1);
+  RecursiveInsertSparseDead(calibSPD,module,thisInd+1,highInd);
+}
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::RecursiveInsertNoisy(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd) {
   // inserts noisy pixels recursively, used when reading from db
   if (lowInd>highInd) return;
@@ -1106,6 +1233,34 @@ TArrayS AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module, Bool_t tr
   return returnArray;
 }
 //____________________________________________________________________________________________
+TArrayS AliITSOnlineCalibrationSPDhandler::GetSparseDeadArray(UInt_t module, Bool_t treeSerial) {
+  // get a TArrayS of the single dead pixels (format for the AliITSCalibrationSPD object)
+  TArrayS returnArray;
+
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  UInt_t size=GetNrSparseDead(module);
+  returnArray.Set(size*2);
+  UInt_t gloIndex=0;
+  for (UInt_t ch=0; ch<5; ch++) {
+    UInt_t chip = GetChipFromOffline(module,ch*32);
+    UInt_t gloChip = GetGloChip(eq,hs,chip);
+    if (treeSerial) fSparseDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
+    else fSparseDeadPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values
+    if (!IsSilentChip(eq,hs,chip)) {
+      for (UInt_t index=0; index<fNrSparseDead[gloChip]; index++) {
+        Int_t key = fSparseDeadPixelMap[gloChip]->GetKeyIndex(index);
+        Int_t colM = GetColMFromKey(key);
+        Int_t rowM = GetRowMFromKey(key);
+        returnArray.AddAt(colM,gloIndex*2);
+        returnArray.AddAt(rowM,gloIndex*2+1);
+        gloIndex++;
+      }
+    }
+  }
+  return returnArray;
+}
+//____________________________________________________________________________________________
 TArrayS AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module, Bool_t treeSerial) {
   // get a TArrayS of the single noisy pixels (format for the AliITSCalibrationSPD object)
   TArrayS returnArray;
@@ -1193,7 +1348,7 @@ void AliITSOnlineCalibrationSPDhandler::PrintEqSummary() {
   printf("Eq summary:\n");
   printf("-----------\n");
   for (UInt_t eq=0; eq<20; eq++) {
-    printf("Eq %*d: %*d silent(dead+inactive) , %*d dead , %*d noisy\n",2,eq,6,GetNrSilentEq(eq),6,GetNrDeadEq(eq),6,GetNrNoisyEq(eq));
+    printf("Eq %*d: %*d silent(dead+inactive) , %*d dead , %*d sparse-dead %*d noisy\n",2,eq,6,GetNrSilentEq(eq),6,GetNrDeadEq(eq),6,GetNrSparseDeadEq(eq),6,GetNrNoisyEq(eq));
   }
 }
 //____________________________________________________________________________________________
@@ -1283,6 +1438,29 @@ void AliITSOnlineCalibrationSPDhandler::PrintDead() const {
   }
 }
 //____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::PrintSparseDead() const {
+  // print the single dead pixels to screen (disregards inactive eq,hs,chip)
+  printf("------------------------------------------------------\n");
+  printf("Sparse Dead Pixels: (eq,hs,chip,col,row  |  module,colM,rowM)\n");
+  printf("------------------------------------------------------\n");
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    for (UInt_t index=0; index<fNrSparseDead[gloChip]; index++) {
+      Int_t key = fSparseDeadPixelMap[gloChip]->GetKeyIndex(index);
+      UInt_t eq = GetEqIdFromKey(key);
+      UInt_t hs = GetHSFromKey(key);
+      UInt_t chip = GetChipFromKey(key);
+      UInt_t col = GetColFromKey(key);
+      UInt_t row = GetRowFromKey(key);
+
+      UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
+      UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
+      UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
+
+      printf("%*d,%*d,%*d,%*d,%*d  |  %*d,%*d,%*d\n",2,eq,1,hs,1,chip,2,col,3,row,3,module,3,colM,3,rowM);
+    }
+  }
+}
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const {
   // print the dead pixels to screen
   printf("-------------------------------------------------------\n");
@@ -1327,6 +1505,28 @@ Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(UInt_t eq, UInt_t hs, UIn
   return kFALSE;
 }
 //____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::SetSparseDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
+  // set a dead pixel, returns false if pixel is already dead
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::SetSparseDeadPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
+    return kFALSE;
+  }
+  if (col>=32 && row>=256) {
+    Error("AliITSOnlineCalibrationSPDhandler::SetSparseDeadPixel", "col,row nrs (%d,%d) out of bounds.",col,row);
+    return kFALSE;
+  }
+  Int_t key = GetKey(eq,hs,chip,col,row);
+  // if noisy we dont want to add it...
+  if (fSparseDeadPixelMap[gloChip]->Find(key) != NULL) return kFALSE;
+  if (fSparseDeadPixelMap[gloChip]->Insert(key,gloChip)) {
+    fNrSparseDead[gloChip]++;
+    //printf(" AliITSOnlineCalibrationSPDhandler::SetSparseDeadPixel nSparse Dead : %i \n",fNrSparseDead[gloChip]);    
+    return kTRUE;
+  }
+  return kFALSE;
+}
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
   // set a noisy pixel, returns false if pixel is already noisy
   UInt_t gloChip = GetGloChip(eq,hs,chip);
@@ -1360,6 +1560,16 @@ Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(UInt_t module, UInt_t co
   return SetDeadPixel(eq,hs,chip,col,row);
 }
 //____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::SetSparseDeadPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
+  // set a dead pixel, returns false if pixel is already dead
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  UInt_t chip = GetChipFromOffline(module,colM);
+  UInt_t col = GetColFromOffline(module,colM);
+  UInt_t row = GetRowFromOffline(module,rowM);
+  return SetSparseDeadPixel(eq,hs,chip,col,row);
+}
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
   // set a noisy pixel, returns false if pixel is already noisy
   UInt_t eq = GetEqIdFromOffline(module);
@@ -1385,6 +1595,21 @@ Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel(UInt_t eq, UInt_t hs, U
   return kFALSE;
 }
 //____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::UnSetSparseDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
+  // unset a dead pixel, returns false if pixel is not dead
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::UnSetSparseDeadPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
+    return kFALSE;
+  }
+  Int_t key = GetKey(eq,hs,chip,col,row);
+  if (fSparseDeadPixelMap[gloChip]->Remove(key)) {
+    fNrSparseDead[gloChip]--;
+    return kTRUE;
+  }
+  return kFALSE;
+}
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
   // unset a noisy pixel, returns false if pixel is not noisy
   UInt_t gloChip = GetGloChip(eq,hs,chip);
@@ -1410,6 +1635,16 @@ Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixelM(UInt_t module, UInt_t
   return UnSetDeadPixel(eq,hs,chip,col,row);
 }
 //____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::UnSetSparseDeadPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
+  // unset a dead pixel, returns false if pixel is not dead
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  UInt_t chip = GetChipFromOffline(module,colM);
+  UInt_t col = GetColFromOffline(module,colM);
+  UInt_t row = GetRowFromOffline(module,rowM);
+  return UnSetSparseDeadPixel(eq,hs,chip,col,row);
+}
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
   // unset a noisy pixel, returns false if pixel is not noisy
   UInt_t eq = GetEqIdFromOffline(module);
@@ -1591,6 +1826,15 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead() const {
   return nrDead;
 }
 //____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSparseDead() const {
+  // returns the total nr of dead pixels
+  UInt_t nrSparseDead = 0;
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    nrSparseDead+=fNrSparseDead[gloChip];
+  }
+  return nrSparseDead;
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy() const {
   // returns the total nr of noisy pixels
   UInt_t nrNoisy = 0;
@@ -1760,6 +2004,22 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const {
   return nrDead;
 }
 //____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSparseDead(UInt_t module) const {
+  // returns the number of sparse dead pixels for a certain module
+  if (module>=240) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNrSparseDead", "module nr (%d) out of bounds.",module);
+    return 0;
+  }
+  UInt_t nrDead = 0;
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  for (UInt_t ch=0; ch<5; ch++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
+    nrDead+=fNrSparseDead[gloChip];
+  }
+  return nrDead;
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const {
   // returns the number of noisy pixels for a certain module
   if (module>=240) {
@@ -1904,6 +2164,17 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadEq(UInt_t eq) const {
   return returnval;
 }
 //____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSparseDeadEq(UInt_t eq) const {
+  // returns nr of dead for eq
+  UInt_t returnval=0;
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+      returnval+=GetNrSparseDeadC(eq,hs,chip);
+    }
+  }
+  return returnval;
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyEq(UInt_t eq) const {
   // returns nr of noisy for eq
   UInt_t returnval=0;
@@ -2024,6 +2295,12 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadC(UInt_t eq, UInt_t hs, UInt_
   return GetNrDeadC2(gloChip);
 }
 //____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSparseDeadC(UInt_t eq, UInt_t hs, UInt_t chip) const {
+  // returns nr of sparse dead for chip
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetNrSparseDeadC2(gloChip);
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyC(UInt_t eq, UInt_t hs, UInt_t chip) const {
   // returns nr of noisy for chip
   UInt_t gloChip = GetGloChip(eq,hs,chip);
@@ -2606,6 +2883,15 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadC2(UInt_t gloChip) const {
   return fNrDead[gloChip];
 }
 //____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSparseDeadC2(UInt_t gloChip) const {
+  // returns nr of dead pixels on this chip
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNrSparseDeadC2", "global chip nr (%d) out of bounds.",gloChip);
+    return 0;
+  }
+  return fNrSparseDead[gloChip];
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyC2(UInt_t gloChip) const {
   // returns nr of noisy pixels on this chip
   if (gloChip>=1200) {
@@ -3095,4 +3381,3 @@ printf("n Chips OK %i : ACTIVE mismatch %i  - INACTIVE mismatch in %i \n",nOk,nM
 
 }
 
-
index 4c038ba..8d2590a 100644 (file)
@@ -71,12 +71,14 @@ class AliITSOnlineCalibrationSPDhandler {
   Bool_t  ReadNoisyModuleFromDB(UInt_t module, Int_t runNr, const Char_t *storage="default", Bool_t treeSerial=kFALSE);
   Bool_t  ReadFromDB(Int_t runNr, const Char_t *storage="default", Bool_t treeSerial=kFALSE);
   Bool_t  ReadDeadFromDB(Int_t runNr, const Char_t *storage="default", Bool_t treeSerial=kFALSE);
+  Bool_t  ReadSparseDeadFromDB(Int_t runNr, const Char_t *storage="default", Bool_t treeSerial=kFALSE);
   Bool_t  ReadNoisyFromDB(Int_t runNr, const Char_t *storage="default", Bool_t treeSerial=kFALSE);
   Bool_t  ReadDeadFromDBasNoisy(Int_t runNr, const Char_t *storage="default", Bool_t treeSerial=kFALSE);
   Bool_t  ReadDeadFromCalibObj(TObjArray* calObj);
   Bool_t  ReadNoisyFromCalibObj(TObjArray* calObj);
   Bool_t  WriteToDB(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage="default");
   Bool_t  WriteDeadToDB(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage="default");
+  Bool_t  WriteSparseDeadToDB(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage="default");
   Bool_t  WriteDeadToDBasNoisy(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage="default");
   Bool_t  WriteNoisyToDB(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage="default");
   Bool_t  WritePITConditionsToDB(Int_t runNrStart, Int_t runNrEnd, const Char_t *storage="default");
@@ -86,6 +88,7 @@ class AliITSOnlineCalibrationSPDhandler {
 
   TArrayS GetSilentArray(UInt_t module, Bool_t treeSerial=kFALSE); // temporarily needed
   TArrayS GetDeadArray(UInt_t module, Bool_t treeSerial=kFALSE);
+  TArrayS GetSparseDeadArray(UInt_t module, Bool_t treeSerial=kFALSE);
   TArrayS GetNoisyArray(UInt_t module, Bool_t treeSerial=kFALSE);
 
   TArrayI GetDeadArrayOnline(UInt_t eq);
@@ -94,15 +97,20 @@ class AliITSOnlineCalibrationSPDhandler {
   void    PrintEqSummary();
   void    PrintSilent() const; // silent = dead or inactive
   void    PrintDead() const;
+  void    PrintSparseDead() const;
   void    PrintNoisy() const;
 
   Bool_t  SetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
+  Bool_t  SetSparseDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
   Bool_t  SetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
   Bool_t  SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row);
+  Bool_t  SetSparseDeadPixelM(UInt_t module, UInt_t colM, UInt_t row);
   Bool_t  SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t row);
   Bool_t  UnSetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
+  Bool_t  UnSetSparseDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
   Bool_t  UnSetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
   Bool_t  UnSetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row);
+  Bool_t  UnSetSparseDeadPixelM(UInt_t module, UInt_t colM, UInt_t row);
   Bool_t  UnSetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t row);
 
   Bool_t SetInactiveChipInPITmask(UInt_t eq, UInt_t hs, UInt_t chip);
@@ -124,6 +132,7 @@ class AliITSOnlineCalibrationSPDhandler {
   UInt_t  GetNrBad() const; // bad = silent or noisy
   UInt_t  GetNrSilent() const; // silent = dead or inactive
   UInt_t  GetNrDead() const;
+  UInt_t  GetNrSparseDead() const;
   UInt_t  GetDeadEqIdAt(UInt_t index) const;
   UInt_t  GetDeadHSAt(UInt_t index) const;
   UInt_t  GetDeadChipAt(UInt_t index) const;
@@ -140,6 +149,7 @@ class AliITSOnlineCalibrationSPDhandler {
   UInt_t  GetNrBad(UInt_t module) const; // bad = silent or noisy
   UInt_t  GetNrSilent(UInt_t module) const; // silent = dead or inactive
   UInt_t  GetNrDead(UInt_t module) const;
+  UInt_t  GetNrSparseDead(UInt_t module) const;
   UInt_t  GetNrDeadSingle(UInt_t module) const;
   UInt_t  GetDeadEqIdAt(UInt_t module,UInt_t index) const;
   UInt_t  GetDeadHSAt(UInt_t module,UInt_t index) const;
@@ -157,6 +167,7 @@ class AliITSOnlineCalibrationSPDhandler {
   UInt_t  GetNrBadEq(UInt_t eq) const; // bad = silent or noisy
   UInt_t  GetNrSilentEq(UInt_t eq) const; // silent = dead or inactive
   UInt_t  GetNrDeadEq(UInt_t eq) const;
+  UInt_t  GetNrSparseDeadEq(UInt_t eq) const;
   UInt_t  GetDeadEqIdAtEq(UInt_t eq, UInt_t index) const;
   UInt_t  GetDeadHSAtEq(UInt_t eq, UInt_t index) const;
   UInt_t  GetDeadChipAtEq(UInt_t eq, UInt_t index) const;
@@ -172,6 +183,7 @@ class AliITSOnlineCalibrationSPDhandler {
   UInt_t  GetNrBadC(UInt_t eq, UInt_t hs, UInt_t chip) const; // bad = silent or noisy
   UInt_t  GetNrSilentC(UInt_t eq, UInt_t hs, UInt_t chip) const; // silent = dead or inactive
   UInt_t  GetNrDeadC(UInt_t eq, UInt_t hs, UInt_t chip) const;
+  UInt_t  GetNrSparseDeadC(UInt_t eq, UInt_t hs, UInt_t chip) const;
   UInt_t  GetDeadEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
   UInt_t  GetDeadHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
   UInt_t  GetDeadChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
@@ -231,8 +243,10 @@ class AliITSOnlineCalibrationSPDhandler {
  private:
   TString fFileLocation;              // location (dir) of files to read and write from
   AliITSIntMap* fDeadPixelMap[1200];  // lists of dead pixels for each chip
+  AliITSIntMap* fSparseDeadPixelMap[1200];  // lists of dead pixels for each chip (used to define sparse dead pixel on LHC period basis)
   AliITSIntMap* fNoisyPixelMap[1200]; // lists of noisy pixels for each chip
   UInt_t fNrDead[1200];               // nr of dead pixels for each chip
+  UInt_t fNrSparseDead[1200];         // nr of sparse dead pixels for each chip
   UInt_t fNrNoisy[1200];              // nr of noisy pixels for each chip
   Bool_t fActiveEq[20];               // active bit for each equipment
   Bool_t fActiveHS[20][6];            // active bit for each half-stave
@@ -281,9 +295,11 @@ class AliITSOnlineCalibrationSPDhandler {
   UInt_t   GetRowFromOffline(UInt_t module, UInt_t rowM) const;
 
   void     RecursiveInsertDead(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd);
+  void     RecursiveInsertSparseDead(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd);
   void     RecursiveInsertNoisy(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd);
 
   UInt_t   GetNrDeadC2(UInt_t gloChip) const;
+  UInt_t   GetNrSparseDeadC2(UInt_t gloChip) const;
   UInt_t   GetDeadEqIdAtC2(UInt_t gloChip, UInt_t index) const;
   UInt_t   GetDeadHSAtC2(UInt_t gloChip, UInt_t index) const;
   UInt_t   GetDeadChipAtC2(UInt_t gloChip, UInt_t index) const;
@@ -299,4 +315,3 @@ class AliITSOnlineCalibrationSPDhandler {
 };
 
 #endif
-
index 3d6e6b5..5315fab 100644 (file)
@@ -74,6 +74,7 @@ AliITSOnlineSPDphys::AliITSOnlineSPDphys(const AliITSOnlineSPDphys& /*phys*/) :
   fPhysInfo(NULL),
   fFileName(".")
 {
+  for(Int_t i=0; i<6; i++) fHitArray[i]=0x0;
   printf("This object should not be copied!");
 }
 
@@ -295,3 +296,5 @@ UInt_t AliITSOnlineSPDphys::GetEqNr() const {
 UInt_t AliITSOnlineSPDphys::GetNrEvents() const {
   return fPhysInfo->GetNrEvents();
 }
+
+
index 1c75f03..779a02d 100644 (file)
@@ -426,6 +426,19 @@ if(cdbSPDDead) {
   AliError("GetDeadAndNoisyInChip: did not find Calib/SPDDead.");
   return;
 }
+// retrieve map of sparse dead Pixel 
+AliCDBEntry *cdbSPDSparseDead = man->Get("ITS/Calib/SPDSparseDead", fRunNumber);
+TObjArray* spdSparseDead;
+if(cdbSPDSparseDead) {
+  spdSparseDead = (TObjArray*)cdbSPDSparseDead->GetObject();
+  if(!spdSparseDead) 
+  {AliError("GetDeadAndNoisyInChip: SPDSparseDead not found in CDB");
+   return;}
+} else {
+  AliError("GetDeadAndNoisyInChip: did not find Calib/SPDSparseDead.");
+  return;
+}
+
 // retrieve map of noisy Pixel 
 AliCDBEntry *cdbSPDNoisy = man->Get("ITS/Calib/SPDNoisy", fRunNumber);
 TObjArray* spdNoisy;
@@ -447,6 +460,12 @@ UInt_t nrDead = calibSPD->GetNrBad();
 for (UInt_t index=0; index<nrDead; index++) {
   if(GetChipFromCol(calibSPD->GetBadColAt(index))==chip) nrDeadInChip++;
 }
+// add the number of sparse dead to the previous dead
+calibSPD=(AliITSCalibrationSPD*) spdSparseDead->At(mod);
+UInt_t nrSparseDead = calibSPD->GetNrBad();
+for (UInt_t index=0; index<nrSparseDead; index++) {
+  if(GetChipFromCol(calibSPD->GetBadColAt(index))==chip) nrDeadInChip++;
+}
 calibSPD=(AliITSCalibrationSPD*) spdNoisy->At(mod);
 UInt_t nrNoisy = calibSPD->GetNrBad();
 for (UInt_t index=0; index<nrNoisy; index++) {