Mainly changes related to the added treatment of inactive detector parts in
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 25 Jul 2008 17:04:39 +0000 (17:04 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 25 Jul 2008 17:04:39 +0000 (17:04 +0000)
SPD online dead pixel search:
* ITSSPDPHYSda and AliITSOnlineSPDphysAnalyzer:
Modified algorithm for finding dead pixels (now also including information
about inactive parts).
* AliITSOnlineCalibrationSPD:
Added information on which equipments, half-staves, chips are active.
* AliITSOnlineCalibrationSPDhandler:
Added functionality to treat inactive detector parts. The inactive or dead
pixels are referred to as "silent" in the code.
* AliITSPreprocessorSPD:
Using silent (=dead+inactive) pixels instead of dead.
* AliITSRawStreamSPD:
Added members to keep track of which equipments and half-staves are active.
This information needs to be accessed externally after the "Next" method has
been called for the event. Included two more consistency error codes, only
relevant for SPDmood.
Removed check on header and trailer count. Added method to get event counter
 value
* AliITSRawStreamSPDErrorLog:
Increased the maximum number of error codes.

Henrik Tydejo

ITS/AliITSOnlineCalibrationSPD.cxx
ITS/AliITSOnlineCalibrationSPD.h
ITS/AliITSOnlineCalibrationSPDhandler.cxx
ITS/AliITSOnlineCalibrationSPDhandler.h
ITS/AliITSOnlineSPDphysAnalyzer.cxx
ITS/AliITSPreprocessorSPD.cxx
ITS/AliITSRawStreamSPD.cxx
ITS/AliITSRawStreamSPD.h
ITS/AliITSRawStreamSPDErrorLog.h
ITS/ITSSPDPHYSda.cxx

index 4981f1b..a6364bd 100644 (file)
@@ -11,8 +11,11 @@ ClassImp(AliITSOnlineCalibrationSPD)
 AliITSOnlineCalibrationSPD::AliITSOnlineCalibrationSPD():
 fEqNr(0),
 fNrBad(0),
-fBadChannels(0)
-{}
+fBadChannels(0),
+fActiveEq(kTRUE)
+{
+  ActivateALL();
+}
 //____________________________________________________________________________
 Int_t AliITSOnlineCalibrationSPD::GetKeyAt(UInt_t index) const {
   // Get key of index-th bad pixel
@@ -21,3 +24,61 @@ Int_t AliITSOnlineCalibrationSPD::GetKeyAt(UInt_t index) const {
   }
   return -1;
 }
+//____________________________________________________________________________
+void AliITSOnlineCalibrationSPD::ActivateALL() {
+  // activate eq, all hs, all chips
+  ActivateEq();
+  for (UInt_t hs=0; hs<6; hs++) {
+    ActivateHS(hs);
+    for (UInt_t chip=0; chip<10; chip++) {
+      ActivateChip(hs,chip);
+    }
+  }
+}
+//____________________________________________________________________________
+void AliITSOnlineCalibrationSPD::ActivateEq(Bool_t setval) {
+  // activate this eq
+  fActiveEq = setval;
+}
+//____________________________________________________________________________
+void AliITSOnlineCalibrationSPD::ActivateHS(UInt_t hs, Bool_t setval) {
+  // activate hs on this eq
+  if (hs>=6) {
+    Error("AliITSOnlineCalibrationSPD::ActivateHS", "hs (%d) out of bounds.",hs);
+    return;
+  }
+  fActiveHS[hs] = setval;
+}
+//____________________________________________________________________________
+void AliITSOnlineCalibrationSPD::ActivateChip(UInt_t hs, UInt_t chip, Bool_t setval) {
+  // activate chip on this eq
+  if (hs>=6 || chip>=10) {
+    Error("AliITSOnlineCalibrationSPD::ActivateChip", "hs,chip (%d,%d) out of bounds.",hs,chip);
+    return;
+  }
+  fActiveChip[hs*10+chip] = setval;
+}
+//____________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPD::IsActiveEq() const {
+  // is this eq active?
+  return fActiveEq;
+}
+//____________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPD::IsActiveHS(UInt_t hs) const {
+  // is this hs active?
+  if (hs>=6) {
+    Error("AliITSOnlineCalibrationSPD::IsActiveHS", "hs (%d) out of bounds.",hs);
+    return kFALSE;
+  }
+  return fActiveHS[hs];
+}
+//____________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPD::IsActiveChip(UInt_t hs, UInt_t chip) const {
+  // is this chip active?
+  if (hs>=6 || chip>=10) {
+    Error("AliITSOnlineCalibrationSPD::IsActiveChip", "hs,chip (%d,%d) out of bounds.",hs,chip);
+    return kFALSE;
+  }
+  return fActiveChip[hs*10+chip];
+}
+
index 988148e..dec4e74 100644 (file)
@@ -3,7 +3,7 @@
 
 ///////////////////////////////////////////////////////////////////////
 // Author: Henrik Tydesjo                                            //
-// This class is used as a container to keep the dead and noisy      //
+// This class is used as a container to keep the dead,noisy,active   //
 // pixels online. Each object corresponds to one DDL (eq).           //
 // Note: This class should not be used directly.                     //
 // Use it via AliITSOnlineCalibrationSPDhandler instead.             //
@@ -20,7 +20,7 @@ class AliITSOnlineCalibrationSPD : public TObject {
     AliITSOnlineCalibrationSPD();
     virtual ~AliITSOnlineCalibrationSPD() {}
 
-    void   SetEqNr(UInt_t mod) {fEqNr=mod;}
+    void   SetEqNr(UInt_t eq) {fEqNr=eq;}
     UInt_t GetEqNr() const {return fEqNr;}
     void   SetBadList(TArrayI badlist) {fBadChannels=badlist;}
     void   SetNrBad(UInt_t nr) {fNrBad=nr;}
@@ -30,12 +30,24 @@ class AliITSOnlineCalibrationSPD : public TObject {
 
     void   ClearBad() {fBadChannels.Reset(); fNrBad=0;}
 
- private:
-    UInt_t   fEqNr;         // eq nr
-    UInt_t   fNrBad;        // nr of bad pixels
-    TArrayI  fBadChannels;  // array of keys for the bad
+    Bool_t IsActiveEq() const;
+    Bool_t IsActiveHS(UInt_t hs) const;
+    Bool_t IsActiveChip(UInt_t hs, UInt_t chip) const;
+
+    void   ActivateALL();
+    void   ActivateEq(Bool_t setval = kTRUE);
+    void   ActivateHS(UInt_t hs, Bool_t setval = kTRUE);
+    void   ActivateChip(UInt_t hs, UInt_t chip, Bool_t setval = kTRUE);
 
-    ClassDef(AliITSOnlineCalibrationSPD,1)
+ private:
+    UInt_t   fEqNr;            // eq nr
+    UInt_t   fNrBad;           // nr of bad pixels
+    TArrayI  fBadChannels;     // array of keys for the bad
+    Bool_t   fActiveEq;        // active bit for each equipment
+    Bool_t   fActiveHS[6];     // active bit for each half-stave
+    Bool_t   fActiveChip[60];  // active bit for each chip
+
+    ClassDef(AliITSOnlineCalibrationSPD,2)
 };
 
 #endif
index 6887f0a..fdedb53 100644 (file)
@@ -2,6 +2,10 @@
 // Author: Henrik Tydesjo                                           //
 // For easier handling of dead and noisy pixels they are kept in    //
 // container maps (AliITSIntMap).                                   //
+// Handling of inactive equipments,HSs,chips have been added.       //
+// A pixel that is either dead or inactive is called SILENT here.   //
+// The lists of single dead and noisy pixels are separated from the //
+// information about which eq/hs/chip are inactive.                 //
 // The TArrayS objects that are put in the AliITSCalibrationSPD     //
 // objects can be obtained from the methods GetDeadArray and        //
 // GetNoisyArray.                                                   //
@@ -33,9 +37,11 @@ AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler():
     fNrDead[gloChip]=0;
     fNrNoisy[gloChip]=0;
     fDeadPixelMap[gloChip] = new AliITSIntMap();
-    fNoisyPixelMap[gloChip] = new AliITSIntMap();
+    fNoisyPixelMap[gloChip] = new AliITSIntMap();    
   }
+  ActivateALL();
 }
+//____________________________________________________________________________________________
 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle): 
   fFileLocation(".")
 {
@@ -46,8 +52,18 @@ AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliIT
     fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone();
     fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone();
   }
+  for (UInt_t eq=0; eq<20; eq++) {
+    fActiveEq[eq] = handle.fActiveEq[eq];
+    for (UInt_t hs=0; hs<6; hs++) {
+      fActiveHS[eq][hs] = handle.fActiveHS[eq][hs];
+      for (UInt_t chip=0; chip<10; chip++) {
+       fActiveChip[eq][hs][chip] = handle.fActiveChip[eq][hs][chip];
+      }
+    }
+  }
   fFileLocation = handle.fFileLocation;
 }
+//____________________________________________________________________________________________
 AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() {
   //  ClearMaps();
   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
@@ -55,6 +71,7 @@ AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() {
     delete fNoisyPixelMap[gloChip];
   }
 }
+//____________________________________________________________________________________________
 AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(const AliITSOnlineCalibrationSPDhandler& handle) {
   // assignment operator
   if (this!=&handle) {
@@ -65,6 +82,15 @@ AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(
       fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone();
       fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone();
     }
+    for (UInt_t eq=0; eq<20; eq++) {
+      fActiveEq[eq] = handle.fActiveEq[eq];
+      for (UInt_t hs=0; hs<6; hs++) {
+       fActiveHS[eq][hs] = handle.fActiveHS[eq][hs];
+       for (UInt_t chip=0; chip<10; chip++) {
+         fActiveChip[eq][hs][chip] = handle.fActiveChip[eq][hs][chip];
+       }
+      }
+    }
     fFileLocation = handle.fFileLocation;
   }
   return *this;
@@ -74,14 +100,17 @@ void AliITSOnlineCalibrationSPDhandler::ClearMaps() {
   // clear the lists of dead and noisy
   ResetDead();
   ResetNoisy();
+  ActivateALL();
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::ResetDead() {
-  // reset the dead pixel map
+  // reset the dead pixel map and inactive eq,hs,chip
   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
     fNrDead[gloChip]=0;
     fDeadPixelMap[gloChip]->Clear();
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
   // clear the list of noisy pixels
   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
@@ -89,6 +118,7 @@ void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
     fNoisyPixelMap[gloChip]->Clear();
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eq, UInt_t hs, UInt_t chip) {
   // clear the dead pixels for this chip
   UInt_t gloChip = GetGloChip(eq,hs,chip);
@@ -101,6 +131,7 @@ void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eq, UInt_t hs, U
     }
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip(UInt_t eq, UInt_t hs, UInt_t chip) {
   // clear the noisy pixels for this chip
   UInt_t gloChip = GetGloChip(eq,hs,chip);
@@ -117,6 +148,7 @@ void AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip(UInt_t eq, UInt_t hs,
     }
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::ResetDeadForEq(UInt_t eq) {
   // clear the dead pixels for this eq
   if (eq>=20) {
@@ -129,6 +161,7 @@ void AliITSOnlineCalibrationSPDhandler::ResetDeadForEq(UInt_t eq) {
     }
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::ResetNoisyForEq(UInt_t eq) {
   // clear the noisy pixels for this eq
   if (eq>=20) {
@@ -141,45 +174,56 @@ void AliITSOnlineCalibrationSPDhandler::ResetNoisyForEq(UInt_t eq) {
     }
   }
 }
+
+
 //____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFiles() {
-  // read dead and noisy files from file location. returns true if at least one file found
+  // read files from file location (active,dead,noisy info). returns true if at least one file found
   Bool_t b1 = ReadNoisyFromFiles();
-  Bool_t b2 = ReadDeadFromFiles();
-  return (b1 && b2);
+  Bool_t b2 = ReadSilentFromFiles();
+  return (b1 || b2);
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFiles() {
-  // read dead files from file location. returns true if at least one file found
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadSilentFromFiles() {
+  // read dead,active files from file location. returns true if at least one file found
   Bool_t returnval=kFALSE;
   for (UInt_t eq=0; eq<20; eq++) {
-    if (ReadDeadFromFile(eq)) {
+    if (ReadSilentFromFile(eq)) {
       returnval=kTRUE;
     }
   }
   return returnval;
 }
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFiles() {
-  // read noisy files from file location. returns true if at least one file found
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFiles() {
+  // read dead,active files from file location. returns true if at least one file found
   Bool_t returnval=kFALSE;
   for (UInt_t eq=0; eq<20; eq++) {
-    if (ReadNoisyFromFile(eq)) {
+    if (ReadDeadFromFile(eq)) {
       returnval=kTRUE;
     }
   }
   return returnval;
 }
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadSilentFromFile(UInt_t eq) {
+  // read dead file for eq from file location. 
+  TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq);
+  return ReadSilentFromFileName(fileName.Data());
+}
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(UInt_t eq) {
-  // read dead file for module from file location. 
+  // read dead file for eq from file location. 
   TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq);
   return ReadDeadFromFileName(fileName.Data());
 }
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(UInt_t eq) {
-  // read noisy file for module from file location. 
-  TString fileName = Form("%s/SPD_Noisy_%d.root",fFileLocation.Data(),eq);
-  return ReadNoisyFromFileName(fileName.Data());
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadSilentFromFileName(const char *fileName) {
+  // read dead from file fileName (including inactive)
+  return ReadDeadFromFileName(fileName, kTRUE);
 }
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileName) {
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileName, Bool_t inactive) {
   // read dead from file fileName
   AliITSOnlineCalibrationSPD* calib;
   FILE* fp0 = fopen(fileName, "r");
@@ -201,11 +245,42 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileN
          UInt_t row = GetRowFromKey(key);
          SetDeadPixel(eq,hs,chip,col,row);
        }
+       if (inactive) {
+         UInt_t eq = calib->GetEqNr();
+         if (calib->IsActiveEq()) ActivateEq(eq);
+         else                     ActivateEq(eq,kFALSE);
+         for (UInt_t hs=0; hs<6; hs++) {
+           if (calib->IsActiveHS(hs)) ActivateHS(eq,hs);
+           else                       ActivateHS(eq,hs,kFALSE);
+           for (UInt_t chip=0; chip<10; chip++) {
+             if (calib->IsActiveChip(hs,chip)) ActivateChip(eq,hs,chip);
+             else                              ActivateChip(eq,hs,chip,kFALSE);
+           }
+         }
+       }
       }
     }
   }
   return kTRUE;
 }
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFiles() {
+  // read noisy files from file location. returns true if at least one file found
+  Bool_t returnval=kFALSE;
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (ReadNoisyFromFile(eq)) {
+      returnval=kTRUE;
+    }
+  }
+  return returnval;
+}
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(UInt_t eq) {
+  // read noisy file for eq from file location. 
+  TString fileName = Form("%s/SPD_Noisy_%d.root",fFileLocation.Data(),eq);
+  return ReadNoisyFromFileName(fileName.Data());
+}
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFileName(const char *fileName) {
   // read noisy from file fileName
   AliITSOnlineCalibrationSPD* calib;
@@ -233,6 +308,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFileName(const char *file
   }
   return kTRUE;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName, UInt_t module) {
   // read dead from a text file (lines with eq,hs,chip,col,row). returns nr of pixels added (not already here)
   // insert only those pixels that belong to module (or all if module=240). 
@@ -261,6 +337,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName,
   }
   return newNrDead;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName, UInt_t module) {
   // read noisy from a text file (lines with eq,hs,chip,col,row). returns nr of pixels added (not already here)
   // insert only those pixels that belong to module (or all if module=240). 
@@ -291,28 +368,51 @@ UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName
 }
 //____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::WriteToFilesAlways() {
-  // write the lists of dead and noisy to files
+  // write the lists of active,dead,noisy to files
   for (UInt_t eq=0; eq<20; eq++) {
-    WriteDeadToFile(eq);
+    WriteSilentToFile(eq);
     WriteNoisyToFile(eq);
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::WriteToFiles() {
   // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels) , returns nr of files produced
-  return (WriteNoisyToFiles() + WriteDeadToFiles());
+  return (WriteNoisyToFiles() + WriteSilentToFiles());
+}
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::WriteSilentToFilesAlways() {
+  // write the lists of silent to files
+  for (UInt_t eq=0; eq<20; eq++) {
+      WriteSilentToFile(eq);
+  }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::WriteDeadToFilesAlways() {
   // write the lists of dead to files
   for (UInt_t eq=0; eq<20; eq++) {
       WriteDeadToFile(eq);
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFilesAlways() {
   // write the lists of noisy to files
   for (UInt_t eq=0; eq<20; eq++) {
     WriteNoisyToFile(eq);
   }
 }
+//____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::WriteSilentToFiles() {
+  // write the list of silent to file (only if there are >0 silent pixels) , returns nr of files produced
+  UInt_t nrFiles=0;
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (GetNrSilentEq(eq) > 0) {
+      WriteSilentToFile(eq);
+      nrFiles++;
+    }
+  }
+  return nrFiles;
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::WriteDeadToFiles() {
   // write the list of dead to file (only if there are >0 dead pixels) , returns nr of files produced
   UInt_t nrFiles=0;
@@ -324,6 +424,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::WriteDeadToFiles() {
   }
   return nrFiles;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::WriteNoisyToFiles() {
   // write the list of noisy to file (only if there are >0 noisy pixels) , returns nr of files produced
   UInt_t nrFiles=0;
@@ -335,20 +436,38 @@ UInt_t AliITSOnlineCalibrationSPDhandler::WriteNoisyToFiles() {
   }
   return nrFiles;
 }
-void AliITSOnlineCalibrationSPDhandler::WriteDeadToFile(UInt_t eq) {
-  // write the lists of dead and noisy for module to file
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::WriteSilentToFile(UInt_t eq) {
+  WriteDeadToFile(eq,kTRUE);
+}
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::WriteDeadToFile(UInt_t eq, Bool_t inactive) {
+  // write the lists of dead (and inactive if input boolean is true) for eq to file
   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
   calib->SetEqNr(eq);
   calib->SetBadList(GetDeadArrayOnline(eq));
   calib->SetNrBad(GetNrDeadEq(eq));
+  if (inactive) {
+    if (IsActiveEq(eq)) calib->ActivateEq();
+    else                calib->ActivateEq(kFALSE);
+    for (UInt_t hs=0; hs<6; hs++) {
+      if (IsActiveHS(eq,hs)) calib->ActivateHS(hs);
+      else                   calib->ActivateHS(hs,kFALSE);
+      for (UInt_t chip=0; chip<10; chip++) {
+       if (IsActiveChip(eq,hs,chip)) calib->ActivateChip(hs,chip);
+       else                          calib->ActivateChip(hs,chip,kFALSE);
+      }
+    }
+  }
   TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq);
   TFile file(fileName.Data(), "RECREATE");
   file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
   file.Close();
   delete calib;
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFile(UInt_t eq) {
-  // write the lists of noisy and noisy for module to file
+  // write the lists of noisy for eq to file
   AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
   calib->SetEqNr(eq);
   calib->SetBadList(GetNoisyArrayOnline(eq));
@@ -394,6 +513,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadModuleFromDB(UInt_t module, In
   spdEntry->Clear();
   return kTRUE;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyModuleFromDB(UInt_t module, Int_t runNr, Bool_t treeSerial) {
   // reads noisy pixels from DB for given module and runNr
   AliCDBManager* man = AliCDBManager::Instance();
@@ -427,11 +547,13 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyModuleFromDB(UInt_t module, I
   spdEntry->Clear();
   return kTRUE;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromDB(Int_t runNr, Bool_t treeSerial) {
   // reads dead and noisy pixels from DB for given runNr
   // note that you may want to clear the lists (if they are not empty) before reading
   return (ReadNoisyFromDB(runNr,treeSerial) && ReadDeadFromDB(runNr,treeSerial));
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromDB(Int_t runNr, 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
@@ -469,6 +591,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromDB(Int_t runNr, Bool_t tre
   spdEntry->Clear();
   return kTRUE;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromDB(Int_t runNr, 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
@@ -509,6 +632,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromDB(Int_t runNr, Bool_t tr
   spdEntry->Clear();
   return kTRUE;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromCalibObj(TObjArray* calObj) {
   // reads dead pixels from calib object
   for (UInt_t module=0; module<240; module++) {
@@ -520,6 +644,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromCalibObj(TObjArray* calObj
   }
   return kTRUE;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromCalibObj(TObjArray* calObj) {
   // reads noisy pixels from calib object
   for (UInt_t module=0; module<240; module++) {
@@ -531,11 +656,13 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromCalibObj(TObjArray* calOb
   }
   return kTRUE;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runNrEnd) {
   // writes dead and noisy pixels to DB for given runNrs
   // overwrites any previous entries
   return (WriteNoisyToDB(runNrStart,runNrEnd) && WriteDeadToDB(runNrStart,runNrEnd));
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::WriteDeadToDB(Int_t runNrStart, Int_t runNrEnd) {
   // writes dead pixels to DB for given runNrs
   // overwrites any previous entries
@@ -564,8 +691,8 @@ Bool_t AliITSOnlineCalibrationSPDhandler::WriteDeadToDB(Int_t runNrStart, Int_t
     spdEntry->Add(calObj);
   }
   for(UInt_t module=0; module<240; module++){
-    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrBad( GetNrDead(module) );
-    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetBadList( GetDeadArray(module) );
+    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrBad( GetNrSilent(module) );
+    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetBadList( GetSilentArray(module) );
   }
   AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
   man->Put(cdbEntry);
@@ -574,6 +701,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::WriteDeadToDB(Int_t runNrStart, Int_t
   delete metaData;
   return kTRUE;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::WriteNoisyToDB(Int_t runNrStart, Int_t runNrEnd) {
   // writes noisy pixels to DB for given runNrs
   // overwrites any previous entries
@@ -621,9 +749,9 @@ void AliITSOnlineCalibrationSPDhandler::RecursiveInsertDead(AliITSCalibrationSPD
   RecursiveInsertDead(calibSPD,module,lowInd,thisInd-1);
   RecursiveInsertDead(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
-  printf("Rec mod %d : %d,%d\n",module,lowInd,highInd);
   if (lowInd>highInd) return;
   Int_t thisInd = lowInd+(highInd-lowInd)/2;
   SetNoisyPixelM(module,calibSPD->GetBadColAt(thisInd),calibSPD->GetBadRowAt(thisInd));
@@ -659,6 +787,70 @@ void AliITSOnlineCalibrationSPDhandler::GenerateDCSConfigFile(const Char_t* file
   dcsfile.close();
 }
 //____________________________________________________________________________________________
+TArrayS AliITSOnlineCalibrationSPDhandler::GetSilentArray(UInt_t module, Bool_t treeSerial) {
+  // get a TArrayS of the silent=dead+inactive pixels (format for the AliITSCalibrationSPD object)
+  TArrayS returnArray;
+
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  UInt_t size=0;
+  if ( !( IsActiveEq(eq) && IsActiveHS(eq,hs) ) ) {
+    size = 8192*5;
+  }
+  else {
+    for (UInt_t ch=0; ch<5; ch++) {
+      UInt_t chip = GetChipFromOffline(module,ch*32);
+      if (!(IsActiveChip(eq,hs,chip))) {
+       size += 8192;
+      }
+      else {
+       UInt_t gloChip = GetGloChip(eq,hs,chip);
+       size += fNrDead[gloChip];
+      }
+    }
+  }
+  returnArray.Set(size*2);
+
+  UInt_t gloIndex=0;
+  if ( !( IsActiveEq(eq) && IsActiveHS(eq,hs) ) ) {
+    for (UInt_t colM=0; colM<160; colM++) {
+      for (UInt_t rowM=0; rowM<256; rowM++) {
+       returnArray.AddAt(colM,gloIndex*2);
+       returnArray.AddAt(rowM,gloIndex*2+1);
+       gloIndex++;
+      }
+    }
+  }
+  else {
+    for (UInt_t ch=0; ch<5; ch++) {
+      UInt_t chip = GetChipFromOffline(module,ch*32);
+      if (!(IsActiveChip(eq,hs,chip))) {
+       for (UInt_t colM=ch*32; colM<ch*32+32; colM++) {
+         for (UInt_t rowM=0; rowM<256; rowM++) {
+           returnArray.AddAt(colM,gloIndex*2);
+           returnArray.AddAt(rowM,gloIndex*2+1);
+           gloIndex++;
+         }
+       }
+      }
+      else {
+       UInt_t gloChip = GetGloChip(eq,hs,chip);
+       if (treeSerial) fDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
+       else fDeadPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values
+       for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
+         Int_t key = fDeadPixelMap[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::GetDeadArray(UInt_t module, Bool_t treeSerial) {
   // get a TArrayS of the dead pixels (format for the AliITSCalibrationSPD object)
   TArrayS returnArray;
@@ -666,14 +858,14 @@ TArrayS AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module, Bool_t tr
   UInt_t eq = GetEqIdFromOffline(module);
   UInt_t hs = GetHSFromOffline(module);
   UInt_t size=0;
-  for (UInt_t chip=0; chip<5; chip++) {
-    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+  for (UInt_t ch=0; ch<5; ch++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
     size += fNrDead[gloChip];
   }
   returnArray.Set(size*2);
   UInt_t gloIndex=0;
-  for (UInt_t chip=0; chip<5; chip++) {
-    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+  for (UInt_t ch=0; ch<5; ch++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
     if (treeSerial) fDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
     else fDeadPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values
     for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
@@ -687,6 +879,7 @@ TArrayS AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module, Bool_t tr
   }
   return returnArray;
 }
+//____________________________________________________________________________________________
 TArrayS AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module, Bool_t treeSerial) {
   // get a TArrayS of the noisy pixels (format for the AliITSCalibrationSPD object)
   TArrayS returnArray;
@@ -694,14 +887,14 @@ TArrayS AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module, Bool_t t
   UInt_t eq = GetEqIdFromOffline(module);
   UInt_t hs = GetHSFromOffline(module);
   UInt_t size=0;
-  for (UInt_t chip=0; chip<5; chip++) {
-    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+  for (UInt_t ch=0; ch<5; ch++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
     size += fNrNoisy[gloChip];
   }
   returnArray.Set(size*2);
   UInt_t gloIndex=0;
-  for (UInt_t chip=0; chip<5; chip++) {
-    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+  for (UInt_t ch=0; ch<5; ch++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
     if (treeSerial) fNoisyPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
     else fNoisyPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values
     for (UInt_t index=0; index<fNrNoisy[gloChip]; index++) {
@@ -715,6 +908,7 @@ TArrayS AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module, Bool_t t
   }
   return returnArray;
 }
+//____________________________________________________________________________________________
 TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArrayOnline(UInt_t eq) {
   // get a TArrayI of the dead pixels (format for the AliITSOnlineCalibrationSPD object)
   TArrayI returnArray;
@@ -742,6 +936,7 @@ TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArrayOnline(UInt_t eq) {
   }
   return returnArray;
 }
+//____________________________________________________________________________________________
 TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArrayOnline(UInt_t eq) {
   // get a TArrayI of the noisy pixels (format for the AliITSOnlineCalibrationSPD object)
   TArrayI returnArray;
@@ -776,11 +971,96 @@ void AliITSOnlineCalibrationSPDhandler::PrintEqSummary() {
   printf("Eq summary:\n");
   printf("-----------\n");
   for (UInt_t eq=0; eq<20; eq++) {
-    printf("Eq %*d: %*d dead , %*d noisy\n",2,eq,5,GetNrDeadEq(eq),5,GetNrNoisyEq(eq));
+    printf("Eq %*d: %*d silent(dead+inactive) , %*d dead , %*d noisy\n",2,eq,5,GetNrSilentEq(eq),5,GetNrDeadEq(eq),5,GetNrNoisyEq(eq));
   }
 }
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::PrintSilent() const {
+  // print the inactive and dead pixels to screen
+  printf("------------------------------------------------------\n");
+  printf("Inactive Equipments: (eq  |  module1 .. module12)\n");
+  printf("------------------------------------------------------\n");
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (!IsActiveEq(eq)) {
+      printf("%*d  |  ",2,eq);
+      for (UInt_t hs=0; hs<6; hs++) {
+       for (UInt_t chip=0; chip<10; chip+=5) {
+         UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
+         if (hs>0 || chip==5) printf(",");
+         printf("%*d",3,module);
+       }
+      }
+      printf("\n");
+    }
+  }
+
+  printf("------------------------------------------------------\n");
+  printf("Inactive Half-staves: (eq,hs  |  module1,module2)\n");
+  printf("------------------------------------------------------\n");
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (IsActiveEq(eq)) {
+      for (UInt_t hs=0; hs<6; hs++) {
+       if (!IsActiveHS(eq,hs)) {
+         printf("%*d,%*d  |  ",2,eq,1,hs);
+         for (UInt_t chip=0; chip<10; chip+=5) {
+           UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
+           if (chip==5) printf(",");
+           printf("%*d",3,module);
+         }
+         printf("\n");
+       }
+      }
+    }
+  }
+
+  printf("------------------------------------------------------\n");
+  printf("Inactive Chips: (eq,hs,chip  |  module,colM1-colM2)\n");
+  printf("------------------------------------------------------\n");
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (IsActiveEq(eq)) {
+      for (UInt_t hs=0; hs<6; hs++) {
+       if (IsActiveHS(eq,hs)) {
+         for (UInt_t chip=0; chip<10; chip++) {
+           if (!IsActiveChip(eq,hs,chip)) {
+             printf("%*d,%*d,%*d  |  ",2,eq,1,hs,1,chip);
+             UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
+             UInt_t colM1 = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,0);
+             UInt_t colM2 = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,31);
+             printf("%*d,%*d-%*d\n",3,module,3,colM1,3,colM2);
+           }
+         }
+       }
+      }
+    }
+  }
+
+  PrintDead();
+
+//!!!  printf("------------------------------------------------------\n");
+//!!!  printf("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<fNrDead[gloChip]; index++) {
+//!!!      Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
+//!!!      UInt_t eq = GetEqIdFromKey(key);
+//!!!      UInt_t hs = GetHSFromKey(key);
+//!!!      UInt_t chip = GetChipFromKey(key);
+//!!!      if (!( IsActiveEq(eq) && IsActiveHS(eq,hs) && IsActiveChip(eq,hs,chip) )) continue;
+//!!!      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::PrintDead() const {
-  // print the dead pixels to screen
+  // print the single dead pixels to screen (disregards inactive eq,hs,chip)
   printf("------------------------------------------------------\n");
   printf("Dead Pixels: (eq,hs,chip,col,row  |  module,colM,rowM)\n");
   printf("------------------------------------------------------\n");
@@ -801,6 +1081,7 @@ void AliITSOnlineCalibrationSPDhandler::PrintDead() const {
     }
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const {
   // print the dead pixels to screen
   printf("-------------------------------------------------------\n");
@@ -844,6 +1125,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(UInt_t eq, UInt_t hs, UIn
   }
   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);
@@ -866,6 +1148,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(UInt_t eq, UInt_t hs, UI
   }
   return kFALSE;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(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);
@@ -875,6 +1158,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(UInt_t module, UInt_t co
   UInt_t row = GetRowFromOffline(module,rowM);
   return SetDeadPixel(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);
@@ -884,6 +1168,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixelM(UInt_t module, UInt_t c
   UInt_t row = GetRowFromOffline(module,rowM);
   return SetNoisyPixel(eq,hs,chip,col,row);
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel(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);
@@ -898,6 +1183,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel(UInt_t eq, UInt_t hs, U
   }
   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);
@@ -912,6 +1198,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel(UInt_t eq, UInt_t hs,
   }
   return kFALSE;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixelM(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);
@@ -921,6 +1208,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixelM(UInt_t module, UInt_t
   UInt_t row = GetRowFromOffline(module,rowM);
   return UnSetDeadPixel(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);
@@ -930,6 +1218,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixelM(UInt_t module, UInt_t
   UInt_t row = GetRowFromOffline(module,rowM);
   return UnSetNoisyPixel(eq,hs,chip,col,row);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::SetDeadChip(UInt_t eq, UInt_t hs, UInt_t chip) {
   // set a full chip dead, returns nr of new dead pixels
   UInt_t nrNew = 0;
@@ -942,6 +1231,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::SetDeadChip(UInt_t eq, UInt_t hs, UInt
   }
   return nrNew;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::SetNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip) {
   // set a full chip noisy, returns nr of new noisy pixels
   UInt_t nrNew = 0;
@@ -954,6 +1244,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::SetNoisyChip(UInt_t eq, UInt_t hs, UIn
   }
   return nrNew;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadChip(UInt_t eq, UInt_t hs, UInt_t chip) {
   // unset a full dead chip, returns false if it was not all dead before
   UInt_t nrUnset = 0;
@@ -967,6 +1258,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadChip(UInt_t eq, UInt_t hs, UI
   if (nrUnset+GetNrNoisyC(eq,hs,chip)<8192) return kFALSE;
   else return kTRUE;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip) {
   // unset a full noisy chip, returns false if it was not all noisy before
   UInt_t nrUnset = 0;
@@ -981,36 +1273,51 @@ Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyChip(UInt_t eq, UInt_t hs, U
   else return kTRUE;
 }
 //____________________________________________________________________________________________
-Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
-  // is the pixel dead?
+Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelSilent(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
+  // is the pixel silent (dead or inactive)?
   UInt_t gloChip = GetGloChip(eq,hs,chip);
-  if (gloChip>=1200) {
-    Error("AliITSOnlineCalibrationSPDhandler::IsPixelDead", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
+  if (gloChip>=1200 || col>=32 || row>=256) {
+    Error("AliITSOnlineCalibrationSPDhandler::IsPixelSilent", "eq,hs,chip,col,row nrs (%d,%d,%d,%d,%d) out of bounds.",eq,hs,chip,col,row);
     return kFALSE;
   }
-  UInt_t key = GetKey(eq,hs,chip,col,row);
-  if ( fDeadPixelMap[gloChip]->Find(key) != NULL ) {
-    return kTRUE;
-  }
-  else {
+  if (!(IsActiveEq(eq) && IsActiveHS(eq,hs) && IsActiveChip(eq,hs,chip))) return kTRUE;
+  else return IsPixelDead(eq,hs,chip,col,row);
+}
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
+  // is the pixel?
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200 || col>=32 || row>=256) {
+    Error("AliITSOnlineCalibrationSPDhandler::IsPixelDead", "eq,hs,chip,col,row nrs (%d,%d,%d,%d,%d) out of bounds.",eq,hs,chip,col,row);
     return kFALSE;
   }
+  UInt_t key = GetKey(eq,hs,chip,col,row);
+  if ( fDeadPixelMap[gloChip]->Find(key) != NULL ) return kTRUE;
+  else return kFALSE;
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
   // is the pixel noisy?
   UInt_t gloChip = GetGloChip(eq,hs,chip);
-  if (gloChip>=1200) {
-    Error("AliITSOnlineCalibrationSPDhandler::IsPixelNoisy", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
+  if (gloChip>=1200 || col>=32 || row>=256) {
+    Error("AliITSOnlineCalibrationSPDhandler::IsPixelNoisy", "eq,hs,chip,col,row nrs (%d,%d,%d) out of bounds.",eq,hs,chip,col,row);
     return kFALSE;
   }
   UInt_t key = GetKey(eq,hs,chip,col,row);
-  if ( fNoisyPixelMap[gloChip]->Find(key) != NULL ) {
-    return kTRUE;
-  }
-  else {
-    return kFALSE;
-  }
+  if ( fNoisyPixelMap[gloChip]->Find(key) != NULL ) return kTRUE;
+  else return kFALSE;
 }
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelSilentM(UInt_t module, UInt_t colM, UInt_t rowM) const {
+  // is the pixel silent (dead or inactive)?
+  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 IsPixelSilent(eq,hs,chip,col,row);
+}
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t rowM) const {
   // is the pixel dead?
   UInt_t eq = GetEqIdFromOffline(module);
@@ -1020,6 +1327,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadM(UInt_t module, UInt_t col
   UInt_t row = GetRowFromOffline(module,rowM);
   return IsPixelDead(eq,hs,chip,col,row);
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t rowM) const  {
   // is the pixel noisy?
   UInt_t eq = GetEqIdFromOffline(module);
@@ -1029,6 +1337,17 @@ Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyM(UInt_t module, UInt_t co
   UInt_t row = GetRowFromOffline(module,rowM);
   return IsPixelNoisy(eq,hs,chip,col,row);
 }
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelSilentKey(Int_t key) const {
+  // is this pixel silent (dead or inactive)?
+  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);
+  return IsPixelSilent(eq,hs,chip,col,row);
+}
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadKey(Int_t key) const {
   // is this pixel dead?
   UInt_t eq = GetEqIdFromKey(key);
@@ -1038,6 +1357,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadKey(Int_t key) const {
   UInt_t row = GetRowFromKey(key);
   return IsPixelDead(eq,hs,chip,col,row);
 }
+//____________________________________________________________________________________________
 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyKey(Int_t key) const {
   // is this pixel noisy?
   UInt_t eq = GetEqIdFromKey(key);
@@ -1048,6 +1368,34 @@ Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyKey(Int_t key) const {
   return IsPixelNoisy(eq,hs,chip,col,row);
 }
 //____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSilent() const {
+  // returns the total nr of silent pixels (dead or inactive)
+  UInt_t nrDead = 0;
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (!IsActiveEq(eq)) {
+      nrDead+=81920*6;
+      continue;
+    }
+    for (UInt_t hs=0; hs<6; hs++) {
+      if (!IsActiveHS(eq,hs)) {
+       nrDead+=81920;
+       continue;
+      }
+      for (UInt_t chip=0; chip<10; chip++) {
+       if (!IsActiveChip(eq,hs,chip)) {
+         nrDead+=8192;
+         continue;
+       }
+       else {
+         UInt_t gloChip = GetGloChip(eq,hs,chip);
+         nrDead+=fNrDead[gloChip];
+       }
+      }
+    }
+  }
+  return nrDead;
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead() const {
   // returns the total nr of dead pixels
   UInt_t nrDead = 0;
@@ -1056,6 +1404,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead() const {
   }
   return nrDead;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy() const {
   // returns the total nr of noisy pixels
   UInt_t nrNoisy = 0;
@@ -1064,6 +1413,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy() const {
   }
   return nrNoisy;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t index) {
   // get eq for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1071,6 +1421,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t index) {
   GetChipAndIndexTotDead(index,gloChip,chipIndex);
   return GetDeadEqIdAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t index) {
   // get eq for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1078,6 +1429,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t index) {
   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
   return GetNoisyEqIdAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t index) {
   // get hs for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1085,6 +1437,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t index) {
   GetChipAndIndexTotDead(index,gloChip,chipIndex);
   return GetDeadHSAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t index) {
   // get hs for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1092,6 +1445,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t index) {
   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
   return GetNoisyHSAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t index) {
   // get chip for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1099,6 +1453,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t index) {
   GetChipAndIndexTotDead(index,gloChip,chipIndex);
   return GetDeadChipAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t index) {
   // get chip for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1106,6 +1461,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t index) {
   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
   return GetNoisyChipAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t index) {
   // get hs for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1113,6 +1469,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t index) {
   GetChipAndIndexTotDead(index,gloChip,chipIndex);
   return GetDeadColAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t index) {
   // get hs for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1120,6 +1477,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t index) {
   GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
   return GetNoisyColAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t index) {
   // get hs for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1127,6 +1485,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t index) {
   GetChipAndIndexTotDead(index,gloChip,chipIndex);
   return GetDeadRowAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t index) {
   // get hs for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1135,6 +1494,30 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t index) {
   return GetNoisyRowAtC2(gloChip,chipIndex);
 }
 //____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSilent(UInt_t module) const {
+  // returns the number of silent pixels for a certain module (dead or inactive)
+  if (module>=240) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNrSilent", "module nr (%d) out of bounds.",module);
+    return 0;
+  }
+  UInt_t nrSilent = 0;
+  UInt_t eq = GetEqIdFromOffline(module);
+  if (!IsActiveEq(eq)) return 160*256;
+  UInt_t hs = GetHSFromOffline(module);
+  if (!IsActiveHS(eq,hs)) return 160*256;
+  for (UInt_t ch=0; ch<5; ch++) {
+    UInt_t chip = GetChipFromOffline(module,ch*32);
+    if (!IsActiveChip(eq,hs,chip)) {
+      nrSilent+=8192;
+    }
+    else {
+      UInt_t gloChip = GetGloChip(eq,hs,chip);
+      nrSilent+=fNrDead[gloChip];
+    }
+  }
+  return nrSilent;
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const {
   // returns the number of dead pixels for a certain module
   if (module>=240) {
@@ -1144,13 +1527,13 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const {
   UInt_t nrDead = 0;
   UInt_t eq = GetEqIdFromOffline(module);
   UInt_t hs = GetHSFromOffline(module);
-  for (UInt_t chip=0; chip<5; chip++) {
-    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+  for (UInt_t ch=0; ch<5; ch++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
     nrDead+=fNrDead[gloChip];
-
   }
   return nrDead;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const {
   // returns the number of noisy pixels for a certain module
   if (module>=240) {
@@ -1160,13 +1543,13 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const {
   UInt_t nrNoisy = 0;
   UInt_t eq = GetEqIdFromOffline(module);
   UInt_t hs = GetHSFromOffline(module);
-  for (UInt_t chip=0; chip<5; chip++) {
-    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+  for (UInt_t ch=0; ch<5; ch++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
     nrNoisy+=fNrNoisy[gloChip];
-
   }
   return nrNoisy;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t module, UInt_t index) {
   // get eq for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1174,6 +1557,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t module, UInt_t in
   GetChipAndIndexDead(module,index,gloChip,chipIndex);
   return GetDeadEqIdAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t module, UInt_t index) {
   // get eq for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1181,6 +1565,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t module, UInt_t i
   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
   return GetNoisyEqIdAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t module, UInt_t index) {
   // get hs for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1188,6 +1573,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t module, UInt_t inde
   GetChipAndIndexDead(module,index,gloChip,chipIndex);
   return GetDeadHSAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t module, UInt_t index) {
   // get hs for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1195,6 +1581,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t module, UInt_t ind
   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
   return GetNoisyHSAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t module, UInt_t index) {
   // get chip for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1202,6 +1589,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t module, UInt_t in
   GetChipAndIndexDead(module,index,gloChip,chipIndex);
   return GetDeadChipAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t module, UInt_t index) {
   // get chip for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1209,6 +1597,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t module, UInt_t i
   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
   return GetNoisyChipAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t module, UInt_t index) {
   // get hs for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1216,6 +1605,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t module, UInt_t ind
   GetChipAndIndexDead(module,index,gloChip,chipIndex);
   return GetDeadColAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t module, UInt_t index) {
   // get hs for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1223,6 +1613,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t module, UInt_t in
   GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
   return GetNoisyColAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t module, UInt_t index) {
   // get hs for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1230,6 +1621,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t module, UInt_t ind
   GetChipAndIndexDead(module,index,gloChip,chipIndex);
   return GetDeadRowAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t module, UInt_t index) {
   // get hs for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1238,6 +1630,28 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t module, UInt_t in
   return GetNoisyRowAtC2(gloChip,chipIndex);
 }
 //____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSilentEq(UInt_t eq) const {
+  // returns nr of silent for eq (dead or inactive)
+  UInt_t returnval=0;
+  if (!IsActiveEq(eq)) return 81920*6;
+  for (UInt_t hs=0; hs<6; hs++) {
+    if (!IsActiveHS(eq,hs)) {
+      returnval+=81920;
+      continue;
+    }
+    for (UInt_t chip=0; chip<10; chip++) {
+      if (!IsActiveChip(eq,hs,chip)) {
+       returnval+=8192;
+       continue;
+      }
+      else { 
+       returnval+=GetNrDeadC(eq,hs,chip);
+      }
+    }
+  }
+  return returnval;
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadEq(UInt_t eq) const {
   // returns nr of dead for eq
   UInt_t returnval=0;
@@ -1248,6 +1662,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadEq(UInt_t eq) const {
   }
   return returnval;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyEq(UInt_t eq) const {
   // returns nr of noisy for eq
   UInt_t returnval=0;
@@ -1258,6 +1673,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyEq(UInt_t eq) const {
   }
   return returnval;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtEq(UInt_t eq, UInt_t index) const {
   // get eq for the dead pixel at position index in list of dead
   if (eq<20 && index<GetNrDeadEq(eq)) {
@@ -1267,6 +1683,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtEq(UInt_t eq, UInt_t inde
     return 20;
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtEq(UInt_t eq, UInt_t index) const {
   // get eq for the noisy pixel at position index in list of noisy
   if (eq<20 && index<GetNrNoisyEq(eq)) {
@@ -1276,6 +1693,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtEq(UInt_t eq, UInt_t ind
     return 20;
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtEq(UInt_t eq, UInt_t index) {
   // get hs for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1283,6 +1701,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtEq(UInt_t eq, UInt_t index)
   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
   return GetDeadHSAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtEq(UInt_t eq, UInt_t index) {
   // get hs for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1290,6 +1709,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtEq(UInt_t eq, UInt_t index
   GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
   return GetNoisyHSAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtEq(UInt_t eq, UInt_t index) {
   // get chip for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1297,6 +1717,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtEq(UInt_t eq, UInt_t inde
   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
   return GetDeadChipAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtEq(UInt_t eq, UInt_t index) {
   // get chip for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1304,6 +1725,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtEq(UInt_t eq, UInt_t ind
   GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
   return GetNoisyChipAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtEq(UInt_t eq, UInt_t index) {
   // get hs for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1311,6 +1733,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtEq(UInt_t eq, UInt_t index
   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
   return GetDeadColAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtEq(UInt_t eq, UInt_t index) {
   // get hs for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1318,6 +1741,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtEq(UInt_t eq, UInt_t inde
   GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
   return GetNoisyColAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtEq(UInt_t eq, UInt_t index) {
   // get hs for the dead pixel at position index in list of dead
   UInt_t gloChip;
@@ -1325,6 +1749,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtEq(UInt_t eq, UInt_t index
   GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
   return GetDeadRowAtC2(gloChip,chipIndex);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtEq(UInt_t eq, UInt_t index) {
   // get hs for the noisy pixel at position index in list of noisy
   UInt_t gloChip;
@@ -1333,50 +1758,69 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtEq(UInt_t eq, UInt_t inde
   return GetNoisyRowAtC2(gloChip,chipIndex);
 }
 //____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSilentC(UInt_t eq, UInt_t hs, UInt_t chip) const {
+  // returns nr of silent for chip (dead or inactive)
+  if (!(IsActiveEq(eq) && IsActiveHS(eq,hs) && IsActiveChip(eq,hs,chip))) return 8192;
+  else return GetNrDeadC(eq,hs,chip);
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadC(UInt_t eq, UInt_t hs, UInt_t chip) const {
+  // returns nr of dead for chip
   UInt_t gloChip = GetGloChip(eq,hs,chip);
   return GetNrDeadC2(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);
   return GetNrNoisyC2(gloChip);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
   UInt_t gloChip = GetGloChip(eq,hs,chip);
   return GetDeadEqIdAtC2(gloChip,index);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
   UInt_t gloChip = GetGloChip(eq,hs,chip);
   return GetNoisyEqIdAtC2(gloChip,index);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
   UInt_t gloChip = GetGloChip(eq,hs,chip);
   return GetDeadHSAtC2(gloChip,index);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
   UInt_t gloChip = GetGloChip(eq,hs,chip);
   return GetNoisyHSAtC2(gloChip,index);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
   UInt_t gloChip = GetGloChip(eq,hs,chip);
   return GetDeadChipAtC2(gloChip,index);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
   UInt_t gloChip = GetGloChip(eq,hs,chip);
   return GetNoisyChipAtC2(gloChip,index);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
   UInt_t gloChip = GetGloChip(eq,hs,chip);
   return GetDeadColAtC2(gloChip,index);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
   UInt_t gloChip = GetGloChip(eq,hs,chip);
   return GetNoisyColAtC2(gloChip,index);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
   UInt_t gloChip = GetGloChip(eq,hs,chip);
   return GetDeadRowAtC2(gloChip,index);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
   UInt_t gloChip = GetGloChip(eq,hs,chip);
   return GetNoisyRowAtC2(gloChip,index);
@@ -1393,7 +1837,7 @@ const Char_t* AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC(UInt_t eq,
   if (index<fNrDead[gloChip]) {
     Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
     UInt_t col = GetColFromKey(key);
-    UInt_t row = GetRowFromKey(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);
@@ -1405,6 +1849,7 @@ const Char_t* AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC(UInt_t eq,
     return returnMess.Data();
   }
 }
+//____________________________________________________________________________________________
 const Char_t* AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
   // get a string of noisy pixel info
   TString returnMess = "";
@@ -1429,6 +1874,25 @@ const Char_t* AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC(UInt_t eq,
   }
 }
 //____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::AddSilentFrom(AliITSOnlineCalibrationSPDhandler* other) {
+  // returns number of new silent pixels in this' list (dead or inactive)
+  UInt_t tmpdead = GetNrSilent();
+
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (!(other->IsActiveEq(eq))) ActivateEq(eq,kFALSE);
+    for (UInt_t hs=0; hs<6; hs++) {
+      if (!(other->IsActiveHS(eq,hs))) ActivateHS(eq,hs,kFALSE);
+      for (UInt_t chip=0; chip<10; chip++) {
+       if (!(other->IsActiveChip(eq,hs,chip))) ActivateChip(eq,hs,chip,kFALSE);
+      }
+    }
+  }
+
+  AddDeadFrom(other);
+
+  return GetNrSilent() - tmpdead;
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::AddDeadFrom(AliITSOnlineCalibrationSPDhandler* other) {
   // returns number of new dead pixels in this' list
   UInt_t returnval=0;
@@ -1446,6 +1910,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::AddDeadFrom(AliITSOnlineCalibrationSPD
   }
   return returnval;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::AddNoisyFrom(AliITSOnlineCalibrationSPDhandler* other) {
   // returns number of new noisy pixels in this' list
   UInt_t returnval=0;
@@ -1465,9 +1930,39 @@ UInt_t AliITSOnlineCalibrationSPDhandler::AddNoisyFrom(AliITSOnlineCalibrationSP
 }
 //____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const {
-  // returns nr of dead/noisy in this' lists and not in other's lists
-  return GetNrDeadDiff(other) + GetNrNoisyDiff(other);
+  // returns nr of dead/noisy in this' lists and not in other's lists (including inactive)
+  return GetNrSilentDiff(other) + GetNrNoisyDiff(other);
 }
+//____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrSilentDiff(AliITSOnlineCalibrationSPDhandler* other) const {
+  // returns nr of single silent pixels in this' lists and not in other's lists (dead or inactive)
+  UInt_t returnval=0;
+  for (UInt_t eq=0; eq<20; eq++) {
+    for (UInt_t hs=0; hs<6; hs++) {
+      for (UInt_t chip=0; chip<10; chip++) {
+       if (!(IsActiveEq(eq) && IsActiveHS(eq,hs) && IsActiveChip(eq,hs,chip))) {
+         if (other->IsActiveEq(eq) && other->IsActiveHS(eq,hs) && other->IsActiveChip(eq,hs,chip)) {
+           // if this is inactive and the other is active...
+           returnval+= 8192 - other->GetNrDeadC(eq,hs,chip);
+         }
+       }
+       else {
+         UInt_t gloChip = GetGloChip(eq,hs,chip);
+         for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
+           Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
+           UInt_t col = GetColFromKey(key);
+           UInt_t row = GetRowFromKey(key);
+           if (!(other->IsPixelSilent(eq,hs,chip,col,row))) {
+             returnval++;
+           }
+         }
+       }
+      }
+    }
+  }
+  return returnval;
+}
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
   // returns nr of dead in this' lists and not in other's lists
   UInt_t returnval=0;
@@ -1486,6 +1981,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadDiff(AliITSOnlineCalibrationS
   }
   return returnval;
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
   // returns nr of noisy in this' lists and not in other's lists
   UInt_t returnval=0;
@@ -1504,9 +2000,30 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyDiff(AliITSOnlineCalibration
   }
   return returnval;
 }
+//____________________________________________________________________________________________
 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDiff(AliITSOnlineCalibrationSPDhandler* other) const {
-  // returns handler with dead/noisy in this' lists, except for those in other's lists
+  // returns handler with active/dead/noisy in this' lists, removing those that are in other's lists
   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
+
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (!(IsActiveEq(eq))) {
+      newHandler->ActivateEq(eq,kFALSE);
+      if (!other->IsActiveEq(eq)) newHandler->ActivateEq(eq);
+    }
+    for (UInt_t hs=0; hs<6; hs++) {
+      if (!(IsActiveHS(eq,hs))) {
+       newHandler->ActivateHS(eq,hs,kFALSE);
+       if (!other->IsActiveHS(eq,hs)) newHandler->ActivateHS(eq,hs);
+      }
+      for (UInt_t chip=0; chip<10; chip++) {
+       if (!(IsActiveChip(eq,hs,chip))) {
+         newHandler->ActivateChip(eq,hs,chip,kFALSE);
+         if (!other->IsActiveChip(eq,hs,chip)) newHandler->ActivateHS(eq,hs,chip);
+       }
+      }
+    }
+  }
+
   for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
     for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
@@ -1519,6 +2036,9 @@ AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDiff(Al
        newHandler->SetDeadPixel(eq,hs,chip,col,row);
       }
     }
+  }
+
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
     for (UInt_t ind2=0; ind2<fNrNoisy[gloChip]; ind2++) {
       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(ind2);
       UInt_t eq = GetEqIdFromKey(key);
@@ -1531,8 +2051,50 @@ AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDiff(Al
       }
     }
   }
+
   return newHandler;
 }
+//____________________________________________________________________________________________
+AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetSilentDiff(AliITSOnlineCalibrationSPDhandler* other) const {
+  // returns handler with active/dead in this' lists, removing those that are in other's lists
+  AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
+
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (!(IsActiveEq(eq))) {
+      newHandler->ActivateEq(eq,kFALSE);
+      if (!other->IsActiveEq(eq)) newHandler->ActivateEq(eq);
+    }
+    for (UInt_t hs=0; hs<6; hs++) {
+      if (!(IsActiveHS(eq,hs))) {
+       newHandler->ActivateHS(eq,hs,kFALSE);
+       if (!other->IsActiveHS(eq,hs)) newHandler->ActivateHS(eq,hs);
+      }
+      for (UInt_t chip=0; chip<10; chip++) {
+       if (!(IsActiveChip(eq,hs,chip))) {
+         newHandler->ActivateChip(eq,hs,chip,kFALSE);
+         if (!other->IsActiveChip(eq,hs,chip)) newHandler->ActivateHS(eq,hs,chip);
+       }
+      }
+    }
+  }
+
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
+      Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
+      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);
+      if (!(other->IsPixelDead(eq,hs,chip,col,row))) {
+       newHandler->SetDeadPixel(eq,hs,chip,col,row);
+      }
+    }
+  }
+
+  return newHandler;
+}
+//____________________________________________________________________________________________
 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
   // returns handler with dead in this' lists, except for those in other's lists
   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
@@ -1551,6 +2113,7 @@ AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDeadDif
   }
   return newHandler;
 }
+//____________________________________________________________________________________________
 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
   // returns handler with noisy in this' lists, except for those in other's lists
   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
@@ -1577,8 +2140,8 @@ void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexDead(UInt_t module, UInt_
     UInt_t hs = GetHSFromOffline(module);
     
     UInt_t glVal=0;
-    for (UInt_t chip=0; chip<5; chip++) {
-      gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+    for (UInt_t ch=0; ch<5; ch++) {
+      gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
       if (glVal+fNrDead[gloChip]>index) {
        chipIndex = index-glVal;
        break;
@@ -1593,6 +2156,7 @@ void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexDead(UInt_t module, UInt_
     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexDead", "Index %d out of bounds.", index);
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
   // find gloChip and chipIndex from module and index
   if (index<GetNrNoisy(module)) {
@@ -1600,8 +2164,8 @@ void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy(UInt_t module, UInt
     UInt_t hs = GetHSFromOffline(module);
     
     UInt_t glVal=0;
-    for (UInt_t chip=0; chip<5; chip++) {
-      gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+    for (UInt_t ch=0; ch<5; ch++) {
+      gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,ch*32));
       if (glVal+fNrNoisy[gloChip]>index) {
        chipIndex = index-glVal;
        break;
@@ -1616,6 +2180,7 @@ void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy(UInt_t module, UInt
     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy", "Index %d out of bounds.", index);
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqDead(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
   // find gloChip and chipIndex from module and index
   if (index<GetNrDeadEq(eq)) {
@@ -1639,6 +2204,7 @@ void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqDead(UInt_t eq, UInt_t
     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqDead", "Index %d out of bounds.", index);
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqNoisy(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
   // find gloChip and chipIndex from module and index
   if (index<GetNrNoisyEq(eq)) {
@@ -1662,6 +2228,7 @@ void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqNoisy(UInt_t eq, UInt_t
     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqNoisy", "Index %d out of bounds.", index);
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotDead(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
   // find gloChip and chipIndex from global index
   if (index<GetNrDead()) {
@@ -1682,6 +2249,7 @@ void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotDead(UInt_t index, UIn
     Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotDead", "Index %d out of bounds.", index);
   }
 }
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotNoisy(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
   // find gloChip and chipIndex from global index
   if (index<GetNrNoisy()) {
@@ -1711,6 +2279,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline(UInt_t module) cons
   }
   return AliITSRawStreamSPD::GetOnlineEqIdFromOffline(module);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) const {
   // module to hs mapping
   if (module>=240) {
@@ -1719,6 +2288,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) const
   }
   return AliITSRawStreamSPD::GetOnlineHSFromOffline(module);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt_t colM) const {
   // module,colM to chip mapping
   if (module>=240 || colM>=160) {
@@ -1727,6 +2297,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt
   }
   return AliITSRawStreamSPD::GetOnlineChipFromOffline(module,colM);
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t module, UInt_t colM) const {
   // colM to col mapping
   if (colM>=160) {
@@ -1735,7 +2306,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t module, UInt_
   }
   return AliITSRawStreamSPD::GetOnlineColFromOffline(module,colM);
 }
-
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetRowFromOffline(UInt_t module, UInt_t rowM) const {
   // rowM to row mapping
   if (rowM>=256) {
@@ -1753,6 +2324,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadC2(UInt_t gloChip) const {
   }
   return fNrDead[gloChip];
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyC2(UInt_t gloChip) const {
   // returns nr of noisy pixels on this chip
   if (gloChip>=1200) {
@@ -1761,6 +2333,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyC2(UInt_t gloChip) const {
   }
   return fNrNoisy[gloChip];
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC2(UInt_t gloChip, UInt_t index) const {
   // get eq for the dead pixel at position index in list of dead
   if (gloChip>=1200) {
@@ -1776,6 +2349,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC2(UInt_t gloChip, UInt_t
     return 0;
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC2(UInt_t gloChip, UInt_t index) const {
   // get eq for the noisy pixel at position index in list of noisy
   if (gloChip>=1200) {
@@ -1791,6 +2365,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC2(UInt_t gloChip, UInt_
     return 0;
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC2(UInt_t gloChip, UInt_t index) const {
   // get hs for the dead pixel at position index in list of dead
   if (gloChip>=1200) {
@@ -1806,6 +2381,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC2(UInt_t gloChip, UInt_t i
     return 0;
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC2(UInt_t gloChip, UInt_t index) const {
   // get hs for the noisy pixel at position index in list of noisy
   if (gloChip>=1200) {
@@ -1821,6 +2397,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC2(UInt_t gloChip, UInt_t
     return 0;
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC2(UInt_t gloChip, UInt_t index) const {
   // get chip for the dead pixel at position index in list of dead
   if (gloChip>=1200) {
@@ -1836,6 +2413,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC2(UInt_t gloChip, UInt_t
     return 0;
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC2(UInt_t gloChip, UInt_t index) const {
   // get chip for the noisy pixel at position index in list of noisy
   if (gloChip>=1200) {
@@ -1851,6 +2429,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC2(UInt_t gloChip, UInt_
     return 0;
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2(UInt_t gloChip, UInt_t index) const {
   // get col for the dead pixel at position index in list of dead
   if (gloChip>=1200) {
@@ -1866,6 +2445,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2(UInt_t gloChip, UInt_t
     return 0;
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC2(UInt_t gloChip, UInt_t index) const {
   // get col for the noisy pixel at position index in list of noisy
   if (gloChip>=1200) {
@@ -1881,6 +2461,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC2(UInt_t gloChip, UInt_t
     return 0;
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC2(UInt_t gloChip, UInt_t index) const {
   // get row for the dead pixel at position index in list of dead
   if (gloChip>=1200) {
@@ -1896,6 +2477,7 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC2(UInt_t gloChip, UInt_t
     return 0;
   }
 }
+//____________________________________________________________________________________________
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC2(UInt_t gloChip, UInt_t index) const {
   // get row for the noisy pixel at position index in list of noisy
   if (gloChip>=1200) {
@@ -1911,21 +2493,64 @@ UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC2(UInt_t gloChip, UInt_t
     return 0;
   }
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::ActivateALL() {
+  for (UInt_t eq=0; eq<20; eq++) {
+    ActivateEq(eq);
+    for (UInt_t hs=0; hs<6; hs++) {
+      ActivateHS(eq,hs);
+      for (UInt_t chip=0; chip<10; chip++) {
+       ActivateChip(eq,hs,chip);
+      }
+    }
+  }
+}
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::ActivateEq(UInt_t eq, Bool_t setval) {
+  if (eq>=20) {
+    Error("AliITSOnlineCalibrationSPDhandler::ActivateEq", "eq (%d) out of bounds.",eq);
+    return;
+  }
+  fActiveEq[eq] = setval;
+}
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::ActivateHS(UInt_t eq, UInt_t hs, Bool_t setval) {
+  if (eq>=20 || hs>=6) {
+    Error("AliITSOnlineCalibrationSPDhandler::ActivateHS", "eq,hs (%d,%d) out of bounds.",eq,hs);
+    return;
+  }
+  fActiveHS[eq][hs] = setval;
+}
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::ActivateChip(UInt_t eq, UInt_t hs, UInt_t chip, Bool_t setval) {
+  if (eq>=20 || hs>=6 || chip>=10) {
+    Error("AliITSOnlineCalibrationSPDhandler::ActivateChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip);
+    return;
+  }
+  fActiveChip[eq][hs][chip] = setval;
+}
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::IsActiveEq(UInt_t eq) const {
+  if (eq>=20) {
+    Error("AliITSOnlineCalibrationSPDhandler::IsActiveEq", "eq (%d) out of bounds.",eq);
+    return kFALSE;
+  }
+  return fActiveEq[eq];
+}
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::IsActiveHS(UInt_t eq, UInt_t hs) const {
+  if (eq>=20 || hs>=6) {
+    Error("AliITSOnlineCalibrationSPDhandler::IsActiveHS", "eq,hs (%d,%d) out of bounds.",eq,hs);
+    return kFALSE;
+  }
+  return fActiveHS[eq][hs];
+}
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::IsActiveChip(UInt_t eq, UInt_t hs, UInt_t chip) const {
+  if (eq>=20 || hs>=6 || chip>=10) {
+    Error("AliITSOnlineCalibrationSPDhandler::IsActiveChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip);
+    return kFALSE;
+  }
+  return fActiveChip[eq][hs][chip];
+}
 
index 8dced89..98116b9 100644 (file)
@@ -1,12 +1,12 @@
 #ifndef ALI_ITS_ONLINECALIBRATIONSPDHANDLER_H
 #define ALI_ITS_ONLINECALIBRATIONSPDHANDLER_H
 
-//////////////////////////////////////////////////////////////////////////
-// Author: Henrik Tydesjo                                               //
-// Class that  simplifies the managing of dead and noisy pixels.        //
-// Has interface to the AliITSOnlineCalibrationSPD container objects    //
-// through reading and writing to TFile.                                //
-//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+// Author: Henrik Tydesjo                                                   //
+// Class that  simplifies the managing of dead, noisy, and inactive pixels. //
+// Has interface to the AliITSOnlineCalibrationSPD container objects        //
+// through reading and writing to TFile.                                    //
+//////////////////////////////////////////////////////////////////////////////
 
 /* $Id$  */
 
@@ -38,22 +38,29 @@ class AliITSOnlineCalibrationSPDhandler {
   void    ResetNoisyForEq(UInt_t eq);
 
   Bool_t  ReadFromFiles();
+  Bool_t  ReadSilentFromFiles();
   Bool_t  ReadDeadFromFiles();
   Bool_t  ReadNoisyFromFiles();
+  Bool_t  ReadSilentFromFile(UInt_t eq);
   Bool_t  ReadDeadFromFile(UInt_t eq);
   Bool_t  ReadNoisyFromFile(UInt_t eq);
-  Bool_t  ReadDeadFromFileName(const char *fileName);
+  Bool_t  ReadSilentFromFileName(const char *fileName);
+  Bool_t  ReadDeadFromFileName(const char *fileName, Bool_t inactive=kFALSE);
   Bool_t  ReadNoisyFromFileName(const char *fileName);
+
   UInt_t  ReadDeadFromText(const char *fileName, UInt_t module);
   UInt_t  ReadNoisyFromText(const char *fileName, UInt_t module);
 
   void    WriteToFilesAlways();
   UInt_t  WriteToFiles();
+  void    WriteSilentToFilesAlways();
   void    WriteDeadToFilesAlways();
   void    WriteNoisyToFilesAlways();
+  UInt_t  WriteSilentToFiles();
   UInt_t  WriteDeadToFiles();
   UInt_t  WriteNoisyToFiles();
-  void    WriteDeadToFile(UInt_t eq);
+  void    WriteSilentToFile(UInt_t eq);
+  void    WriteDeadToFile(UInt_t eq, Bool_t inactive=kFALSE);
   void    WriteNoisyToFile(UInt_t eq);
 
 #ifndef SPD_DA_OFF
@@ -71,12 +78,15 @@ class AliITSOnlineCalibrationSPDhandler {
 
   void    GenerateDCSConfigFile(const Char_t* fileName);
 
+  TArrayS GetSilentArray(UInt_t module, Bool_t treeSerial=kFALSE); // temporarily needed
   TArrayS GetDeadArray(UInt_t module, Bool_t treeSerial=kFALSE);
   TArrayS GetNoisyArray(UInt_t module, Bool_t treeSerial=kFALSE);
+
   TArrayI GetDeadArrayOnline(UInt_t eq);
   TArrayI GetNoisyArrayOnline(UInt_t eq);
 
   void    PrintEqSummary();
+  void    PrintSilent() const; // silent = dead or inactive
   void    PrintDead() const;
   void    PrintNoisy() const;
 
@@ -93,75 +103,95 @@ class AliITSOnlineCalibrationSPDhandler {
   Bool_t  UnSetDeadChip(UInt_t eq, UInt_t hs, UInt_t chip);
   Bool_t  UnSetNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip);
 
+  Bool_t  IsPixelSilent(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const; // silent = dead or inactive
   Bool_t  IsPixelDead(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const;
   Bool_t  IsPixelNoisy(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const;
+  Bool_t  IsPixelSilentM(UInt_t module, UInt_t colM, UInt_t row) const;
   Bool_t  IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t row) const;
   Bool_t  IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t row) const;
+  Bool_t  IsPixelSilentKey(Int_t key) const;
   Bool_t  IsPixelDeadKey(Int_t key) const;
   Bool_t  IsPixelNoisyKey(Int_t key) const;
 
+  UInt_t  GetNrSilent() const; // silent = dead or inactive
   UInt_t  GetNrDead() const;
-  UInt_t  GetNrNoisy() const;
   UInt_t  GetDeadEqIdAt(UInt_t index);
-  UInt_t  GetNoisyEqIdAt(UInt_t index);
   UInt_t  GetDeadHSAt(UInt_t index);
-  UInt_t  GetNoisyHSAt(UInt_t index);
   UInt_t  GetDeadChipAt(UInt_t index);
-  UInt_t  GetNoisyChipAt(UInt_t index);
   UInt_t  GetDeadColAt(UInt_t index);
-  UInt_t  GetNoisyColAt(UInt_t index);
   UInt_t  GetDeadRowAt(UInt_t index);
+  UInt_t  GetNrNoisy() const;
+  UInt_t  GetNoisyEqIdAt(UInt_t index);
+  UInt_t  GetNoisyHSAt(UInt_t index);
+  UInt_t  GetNoisyChipAt(UInt_t index);
+  UInt_t  GetNoisyColAt(UInt_t index);
   UInt_t  GetNoisyRowAt(UInt_t index);
 
+  UInt_t  GetNrSilent(UInt_t module) const; // silent = dead or inactive
   UInt_t  GetNrDead(UInt_t module) const;
-  UInt_t  GetNrNoisy(UInt_t module) const;
   UInt_t  GetDeadEqIdAt(UInt_t module,UInt_t index);
-  UInt_t  GetNoisyEqIdAt(UInt_t module, UInt_t index);
   UInt_t  GetDeadHSAt(UInt_t module,UInt_t index);
-  UInt_t  GetNoisyHSAt(UInt_t module, UInt_t index);
   UInt_t  GetDeadChipAt(UInt_t module,UInt_t index);
-  UInt_t  GetNoisyChipAt(UInt_t module, UInt_t index);
   UInt_t  GetDeadColAt(UInt_t module,UInt_t index);
-  UInt_t  GetNoisyColAt(UInt_t module, UInt_t index);
   UInt_t  GetDeadRowAt(UInt_t module,UInt_t index);
+  UInt_t  GetNrNoisy(UInt_t module) const;
+  UInt_t  GetNoisyEqIdAt(UInt_t module, UInt_t index);
+  UInt_t  GetNoisyHSAt(UInt_t module, UInt_t index);
+  UInt_t  GetNoisyChipAt(UInt_t module, UInt_t index);
+  UInt_t  GetNoisyColAt(UInt_t module, UInt_t index);
   UInt_t  GetNoisyRowAt(UInt_t module, UInt_t index);
 
+  UInt_t  GetNrSilentEq(UInt_t eq) const; // silent = dead or inactive
   UInt_t  GetNrDeadEq(UInt_t eq) const;
-  UInt_t  GetNrNoisyEq(UInt_t eq) const;
   UInt_t  GetDeadEqIdAtEq(UInt_t eq, UInt_t index) const;
-  UInt_t  GetNoisyEqIdAtEq(UInt_t eq, UInt_t index) const;
   UInt_t  GetDeadHSAtEq(UInt_t eq, UInt_t index);
-  UInt_t  GetNoisyHSAtEq(UInt_t eq, UInt_t index);
   UInt_t  GetDeadChipAtEq(UInt_t eq, UInt_t index);
-  UInt_t  GetNoisyChipAtEq(UInt_t eq, UInt_t index);
   UInt_t  GetDeadColAtEq(UInt_t eq, UInt_t index);
-  UInt_t  GetNoisyColAtEq(UInt_t eq, UInt_t index);
   UInt_t  GetDeadRowAtEq(UInt_t eq, UInt_t index);
+  UInt_t  GetNrNoisyEq(UInt_t eq) const;
+  UInt_t  GetNoisyEqIdAtEq(UInt_t eq, UInt_t index) const;
+  UInt_t  GetNoisyHSAtEq(UInt_t eq, UInt_t index);
+  UInt_t  GetNoisyChipAtEq(UInt_t eq, UInt_t index);
+  UInt_t  GetNoisyColAtEq(UInt_t eq, UInt_t index);
   UInt_t  GetNoisyRowAtEq(UInt_t eq, UInt_t index);
 
+  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  GetNrNoisyC(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  GetNoisyEqIdAtC(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  GetNoisyHSAtC(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;
-  UInt_t  GetNoisyChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
   UInt_t  GetDeadColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
-  UInt_t  GetNoisyColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
   UInt_t  GetDeadRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetNrNoisyC(UInt_t eq, UInt_t hs, UInt_t chip) const;
+  UInt_t  GetNoisyEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetNoisyHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetNoisyChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetNoisyColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
   UInt_t  GetNoisyRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
 
   const Char_t* GetDeadPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
   const Char_t* GetNoisyPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
 
+  void   ActivateALL();
+  void   ActivateEq(UInt_t eq, Bool_t setval = kTRUE);
+  void   ActivateHS(UInt_t eq, UInt_t hs, Bool_t setval = kTRUE);
+  void   ActivateChip(UInt_t eq, UInt_t hs, UInt_t chip, Bool_t setval = kTRUE);
+
+  Bool_t IsActiveEq(UInt_t eq) const;
+  Bool_t IsActiveHS(UInt_t eq, UInt_t hs) const;
+  Bool_t IsActiveChip(UInt_t eq, UInt_t hs, UInt_t chip) const;
+
+
+  UInt_t  AddSilentFrom(AliITSOnlineCalibrationSPDhandler* other);
   UInt_t  AddDeadFrom(AliITSOnlineCalibrationSPDhandler* other);
   UInt_t  AddNoisyFrom(AliITSOnlineCalibrationSPDhandler* other);
 
   UInt_t  GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const;
+  UInt_t  GetNrSilentDiff(AliITSOnlineCalibrationSPDhandler* other) const;
   UInt_t  GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const;
   UInt_t  GetNrNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const;
   AliITSOnlineCalibrationSPDhandler* GetDiff(AliITSOnlineCalibrationSPDhandler* other) const;
+  AliITSOnlineCalibrationSPDhandler* GetSilentDiff(AliITSOnlineCalibrationSPDhandler* other) const;
   AliITSOnlineCalibrationSPDhandler* GetDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const;
   AliITSOnlineCalibrationSPDhandler* GetNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const;
 
@@ -172,7 +202,10 @@ class AliITSOnlineCalibrationSPDhandler {
   AliITSIntMap* fNoisyPixelMap[1200]; // lists of noisy pixels for each chip
   UInt_t fNrDead[1200];               // nr of 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
+  Bool_t fActiveChip[20][6][10];      // active bit for each chip
+
   Int_t    GetKey(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const 
     {return eq*6*10*32*256 + hs*10*32*256 + chip*32*256 + col*256 + row;}
   UInt_t   GetEqIdFromKey(Int_t key) const 
@@ -192,8 +225,10 @@ class AliITSOnlineCalibrationSPDhandler {
   UInt_t   GetRowMFromKey(Int_t key) const 
     {return AliITSRawStreamSPD::GetOfflineRowFromOnline(GetEqIdFromKey(key),GetHSFromKey(key),GetChipFromKey(key),GetRowFromKey(key));}
   
-  UInt_t   GetGloChip(UInt_t eq, UInt_t hs, UInt_t chip) const
-    {return eq*6*10 + hs*10 + chip;}
+  UInt_t   GetGloChip(UInt_t eq, UInt_t hs, UInt_t chip) const {return eq*60 + hs*10 + chip;}
+  UInt_t   GetEqGlo(UInt_t gloChip) const {return gloChip/60;}
+  UInt_t   GetHSGlo(UInt_t gloChip) const {return (gloChip%60)/10;}
+  UInt_t   GetChipGlo(UInt_t gloChip) const {return (gloChip%60)%10;}
 
   void     GetChipAndIndexDead(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex);
   void     GetChipAndIndexNoisy(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex);
@@ -212,16 +247,16 @@ class AliITSOnlineCalibrationSPDhandler {
   void     RecursiveInsertNoisy(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd);
 
   UInt_t   GetNrDeadC2(UInt_t gloChip) const;
-  UInt_t   GetNrNoisyC2(UInt_t gloChip) const;
   UInt_t   GetDeadEqIdAtC2(UInt_t gloChip, UInt_t index) const;
-  UInt_t   GetNoisyEqIdAtC2(UInt_t gloChip, UInt_t index) const;
   UInt_t   GetDeadHSAtC2(UInt_t gloChip, UInt_t index) const;
-  UInt_t   GetNoisyHSAtC2(UInt_t gloChip, UInt_t index) const;
   UInt_t   GetDeadChipAtC2(UInt_t gloChip, UInt_t index) const;
-  UInt_t   GetNoisyChipAtC2(UInt_t gloChip, UInt_t index) const;
   UInt_t   GetDeadColAtC2(UInt_t gloChip, UInt_t index) const;
-  UInt_t   GetNoisyColAtC2(UInt_t gloChip, UInt_t index) const;
   UInt_t   GetDeadRowAtC2(UInt_t gloChip, UInt_t index) const;   
+  UInt_t   GetNrNoisyC2(UInt_t gloChip) const;
+  UInt_t   GetNoisyEqIdAtC2(UInt_t gloChip, UInt_t index) const;
+  UInt_t   GetNoisyHSAtC2(UInt_t gloChip, UInt_t index) const;
+  UInt_t   GetNoisyChipAtC2(UInt_t gloChip, UInt_t index) const;
+  UInt_t   GetNoisyColAtC2(UInt_t gloChip, UInt_t index) const;
   UInt_t   GetNoisyRowAtC2(UInt_t gloChip, UInt_t index) const;
 
 };
index 4f7eaa8..a1dcd98 100644 (file)
@@ -303,7 +303,7 @@ UInt_t AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels() {
     return 0;
   }
 
-  AliITSOnlineCalibrationSPDhandler *deadChipHandler = new AliITSOnlineCalibrationSPDhandler();
+  AliITSIntMap* possiblyDead  = new AliITSIntMap();
   AliITSIntMap* possiblyIneff = new AliITSIntMap();
 
   fNrEnoughStatChips = 0;
@@ -312,140 +312,139 @@ UInt_t AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels() {
   UInt_t nrPossiblyDeadChips = 0;
   fNrEqHits = 0;
 
-  for (UInt_t hs=0; hs<6; hs++) {
-    for (UInt_t chip=0; chip<10; chip++) {
-      Bool_t good=kFALSE;
 
-      AliITSOnlineCalibrationSPDhandler *deadPixelHandler = new AliITSOnlineCalibrationSPDhandler();
+  AliITSOnlineCalibrationSPDhandler *deadPixelHandler = new AliITSOnlineCalibrationSPDhandler();
 
-      UInt_t nrPossiblyDeadPixels = 0;
-      UInt_t nrPixels = 0;
-      UInt_t nrChipHits = 0;
-      for (UInt_t col=0; col<32; col++) {
-       for (UInt_t row=0; row<256; row++) {
-         UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
-         nrChipHits += nrHits;
-         if (!fHandler->IsPixelNoisy(GetEqNr(),hs,chip,col,row)) {
-           // don't include noisy pixels
-           nrPixels++;
-           if (nrHits==0) {
-             nrPossiblyDeadPixels++;
-             deadPixelHandler->SetDeadPixel(GetEqNr(),hs,chip,col,row);
+  for (UInt_t hs=0; hs<6; hs++) {
+    if (!(fHandler->IsActiveHS(GetEqNr(),hs))) {
+      fNrDeadChips+=10;
+    }
+    else {
+      for (UInt_t chip=0; chip<10; chip++) {
+       if (!(fHandler->IsActiveChip(GetEqNr(),hs,chip))) {
+         fNrDeadChips++;
+       }
+       else {
+         // perform search for individual dead pixels...
+         deadPixelHandler->ResetDead();
+         Bool_t good=kFALSE;
+
+         UInt_t nrPossiblyDeadPixels = 0;
+         UInt_t nrPixels = 0;
+         UInt_t nrChipHits = 0;
+         for (UInt_t col=0; col<32; col++) {
+           for (UInt_t row=0; row<256; row++) {
+             UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
+             nrChipHits += nrHits;
+             if (!fHandler->IsPixelNoisy(GetEqNr(),hs,chip,col,row)) {
+               // don't include noisy pixels
+               nrPixels++;
+               if (nrHits==0) {
+                 nrPossiblyDeadPixels++;
+                 deadPixelHandler->SetDeadPixel(GetEqNr(),hs,chip,col,row);
+               }
+             }
+             else {
+               nrChipHits -= nrHits; // this is needed when running offline (online nrHits should be 0 already)
+             }
            }
          }
-         else {
-           nrChipHits -= nrHits; // this is needed when running offline (online nrHits should be 0 already)
+         fNrEqHits+=nrChipHits;
+
+         // check all pixels that were declared dead from before...
+         UInt_t nrDeadBefore = fHandler->GetNrDeadC(GetEqNr(),hs,chip);
+         AliITSOnlineCalibrationSPDhandler *tmpHand = new AliITSOnlineCalibrationSPDhandler();
+         for (UInt_t index=0; index<nrDeadBefore; index++) {
+           UInt_t col = fHandler->GetDeadColAtC(GetEqNr(),hs,chip,index);
+           UInt_t row = fHandler->GetDeadRowAtC(GetEqNr(),hs,chip,index);
+           if (fPhysObj->GetHits(hs,chip,col,row)>0) {
+             //            fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,col,row); // This was a bug - cannot delete while moving through indices, use tmpHand instead
+             tmpHand->SetDeadPixel(GetEqNr(),hs,chip,col,row);
+           }
          }
-       }
-      }
-      fNrEqHits+=nrChipHits;
-
-      // check all pixels that were declared dead from before...
-      UInt_t nrDeadBefore = fHandler->GetNrDeadC(GetEqNr(),hs,chip);
-      UInt_t nrNoisyNow   = fHandler->GetNrNoisyC(GetEqNr(),hs,chip);
-      if (nrDeadBefore+nrNoisyNow==8192) {
-       if (nrChipHits>0) {
-         fHandler->UnSetDeadChip(GetEqNr(),hs,chip);
-       }
-      }
-      else {
-       AliITSOnlineCalibrationSPDhandler *tmpHand = new AliITSOnlineCalibrationSPDhandler();
-       for (UInt_t index=0; index<nrDeadBefore; index++) {
-         UInt_t col = fHandler->GetDeadColAtC(GetEqNr(),hs,chip,index);
-         UInt_t row = fHandler->GetDeadRowAtC(GetEqNr(),hs,chip,index);
-         if (fPhysObj->GetHits(hs,chip,col,row)>0) {
-           //      fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,col,row);
-           tmpHand->SetDeadPixel(GetEqNr(),hs,chip,col,row);
+         UInt_t nrToRemove = tmpHand->GetNrDead();
+         for (UInt_t index=0; index<nrToRemove; index++) {
+           fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,tmpHand->GetDeadColAtC(GetEqNr(),hs,chip,index),tmpHand->GetDeadRowAtC(GetEqNr(),hs,chip,index));
          }
-       }
-       UInt_t nrToRemove = tmpHand->GetNrDead();
-       for (UInt_t index=0; index<nrToRemove; index++) {
-         fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,tmpHand->GetDeadColAtC(GetEqNr(),hs,chip,index),tmpHand->GetDeadRowAtC(GetEqNr(),hs,chip,index));
-       }
-       delete tmpHand;
-      }
-
+         delete tmpHand;
 
 
 
-      if (nrPossiblyDeadPixels==0) {
-       // no need to see if we have enough statistics...
-       fNrEnoughStatChips++;
-       good=kTRUE;
-       delete deadPixelHandler;
-       good=kTRUE;
-       printf("%3d",good);
-       if (chip==9) printf("\n");
-       continue;
-      }
-
-      if (nrChipHits==0) {
-       nrPossiblyDeadChips++;
-       deadChipHandler->SetDeadChip(GetEqNr(),hs,chip);
-       delete deadPixelHandler;
-       good=kFALSE;
-       printf("%3d",good);
-       if (chip==9) printf("\n");
-       continue;
-      }
+         if (nrPossiblyDeadPixels==0) {
+           // no need to see if we have enough statistics...
+           fNrEnoughStatChips++;
+           good=kTRUE;
+           //  printf("%3d",good);
+           //  if (chip==9) printf("\n");
+           continue;
+         }
 
-      // Binomial with n events and probability p for pixel hit
-      UInt_t n = GetNrEvents();
-      if (nrPixels>0 && n>0) {
+         if (nrChipHits==0) {
+           nrPossiblyDeadChips++;
+           //!!!           deadChipHandler->SetDeadChip(GetEqNr(),hs,chip);
+           possiblyDead->Insert(hs,chip);
+           good=kFALSE;
+           //  printf("%3d",good);
+           //  if (chip==9) printf("\n");
+           continue;
+         }
 
-       Double_t p = (Double_t)nrChipHits/nrPixels/n;
+         // Binomial with n events and probability p for pixel hit
+         UInt_t n = GetNrEvents();
+         if (nrPixels>0 && n>0) {
+
+           Double_t p = (Double_t)nrChipHits/nrPixels/n;
+
+           // probability of falsely assigning a dead pixel
+           Double_t falselyDeadProb = 1;
+           Int_t falselyDeadProbExp = 0;
+           for (UInt_t i=0; i<n; i++) {
+             falselyDeadProb*=(1-p);
+             Exponent(falselyDeadProb,falselyDeadProbExp);
+             // can we find dead pixels...?
+             if (falselyDeadProbExp<fThreshDeadExp || (falselyDeadProbExp==fThreshDeadExp && falselyDeadProb<fThreshDead)) {
+               fNrEnoughStatChips++;
+               good=kTRUE;
+               // add dead pixels to handler
+               fHandler->AddDeadFrom(deadPixelHandler);
+               break;
+             }
+           }
+           if (!good) {
+             // this might be an inefficient chip
+             possiblyIneff->Insert(hs*10+chip,nrChipHits);
+           }
 
-       // probability of falsely assigning a dead pixel
-       Double_t falselyDeadProb = 1;
-       Int_t falselyDeadProbExp = 0;
-       for (UInt_t i=0; i<n; i++) {
-         falselyDeadProb*=(1-p);
-         Exponent(falselyDeadProb,falselyDeadProbExp);
-       }
+         }
+         else {
+           if (n>0) {
+             // this is a completely noisy chip... put in category enough stat
+             fNrEnoughStatChips++;
+             good=kTRUE;
+           }
+         }
 
-       // can we find dead pixels...?
-       if (falselyDeadProbExp<fThreshDeadExp || (falselyDeadProbExp==fThreshDeadExp && falselyDeadProb<fThreshDead)) {
-         fNrEnoughStatChips++;
-         good=kTRUE;
-         // add dead pixels to handler
-         fHandler->AddDeadFrom(deadPixelHandler);
-       }
-       else {
-         // this might be an inefficient chip
-         possiblyIneff->Insert(hs*10+chip,nrChipHits);
-       }
+         //      printf("%3d",good);
+         //      if (chip==9) printf("\n");
 
-      }
-      else {
-       if (n>0) {
-         // this is a completely noisy chip... put in category enough stat
-         fNrEnoughStatChips++;
-         good=kTRUE;
        }
-      }
-
-      delete deadPixelHandler;
-
-      printf("%3d",good);
-      if (chip==9) printf("\n");
-
-    } // for chip
+      } // for chip
+    }
   } // for hs
+  delete deadPixelHandler;
 
-
+  Int_t key,val;
   // dead chips?
   if (fNrEqHits>fMinNrEqHitsForDeadChips) {
-    fHandler->AddDeadFrom(deadChipHandler);
-    fNrDeadChips=nrPossiblyDeadChips;
-  }
-  else {
-    fNrDeadChips=0;
+    while (possiblyDead->Pop(key,val)) {
+      fHandler->ActivateChip(GetEqNr(),key,val,kFALSE);
+    }
+    fNrDeadChips+=nrPossiblyDeadChips;
   }
-  delete deadChipHandler;
-
+  delete possiblyDead;
 
   // inefficient chips?
-  Int_t key,val;
   while (possiblyIneff->Pop(key,val)) {
     if (val<fNrEqHits/60*fRatioToMeanForInefficientChip) {
       fNrInefficientChips++;
index bfc6bca..3f23fda 100644 (file)
@@ -377,10 +377,10 @@ UInt_t AliITSPreprocessorSPD::Process(TMap* /*dcsAliasMap*/)
     }
     // Add dead from the copied FXS files
     handOld->SetFileLocation(".");
-    handOld->ReadDeadFromFiles();
+    handOld->ReadSilentFromFiles();
     for (Int_t module=0; module<240; module++) {
-      ((AliITSCalibrationSPD*) spdEntryDead->At(module)) -> SetNrBad( handOld->GetNrDead(module) );
-      ((AliITSCalibrationSPD*) spdEntryDead->At(module)) -> SetBadList( handOld->GetDeadArray(module) );
+      ((AliITSCalibrationSPD*) spdEntryDead->At(module)) -> SetNrBad( handOld->GetNrSilent(module) );
+      ((AliITSCalibrationSPD*) spdEntryDead->At(module)) -> SetBadList( handOld->GetSilentArray(module) );
     }
     delete handOld;
     // Store the new calibration objects in OCDB
index 01eab5c..c9067a0 100644 (file)
@@ -68,6 +68,9 @@ AliITSRawStreamSPD::AliITSRawStreamSPD(AliRawReader* rawReader) :
   for (UInt_t iword=0; iword<kCalHeadLenMax; iword++) {
     fCalHeadWord[iword]=0xffffffff;
   }
+  for (UInt_t eq=0; eq<20; eq++) {
+    fActiveEq[eq]=kFALSE;
+  }
   NewEvent();
 }
 //__________________________________________________________________________
@@ -151,6 +154,7 @@ void AliITSRawStreamSPD::NewEvent() {
 }
 //__________________________________________________________________________
 Int_t AliITSRawStreamSPD::ReadCalibHeader() {
+  // needs to be called in the beginning of each equipment data
   // read the extra calibration header
   // returns the length of the header if it is present, -1 otherwise
 
@@ -166,10 +170,18 @@ Int_t AliITSRawStreamSPD::ReadCalibHeader() {
   fHeaderOrTrailerReadLast = kFALSE;
   fFillOutOfSynch = kFALSE;
 
-  // check what number of chip headers/trailers to expect
+  // set eq active and the participating half-staves (for access from outside this class), 
+  // set what number of chip headers/trailers to expect
+  fActiveEq[ddlID]=kTRUE;
   fExpectedHeaderTrailerCount = 0;
   for (UInt_t hs=0; hs<6; hs++) {
-    if (!fRawReader->TestBlockAttribute(hs)) fExpectedHeaderTrailerCount+=10;
+    if (!fRawReader->TestBlockAttribute(hs)) {
+      fActiveHS[ddlID][hs]=kTRUE;
+      fExpectedHeaderTrailerCount+=10;
+    }
+    else {
+      fActiveHS[ddlID][hs]=kFALSE;
+    }
   }
 
   if (ddlID>=0 && ddlID<20) fCalHeadRead[ddlID]=kTRUE;
@@ -219,9 +231,10 @@ Bool_t AliITSRawStreamSPD::Next() {
       if (!fCalHeadRead[fDDLID]) {
        if (fLastDDLID!=-1) {  // if not the first equipment for this event
          fEqPLBytesRead -= 2;
-         CheckHeaderAndTrailerCount(fLastDDLID);
+         // The next line is commented, since we do not have the information how many chips to expect
+         // CheckHeaderAndTrailerCount(fLastDDLID);
        }
-       if (ReadCalibHeader()>=0) continue;
+       if (ReadCalibHeader()>=0) continue; // skip to next word if we found a calib header, otherwise parse this word as regular data (go on with this while loop)
       }
     }
     else {
@@ -341,7 +354,8 @@ Bool_t AliITSRawStreamSPD::Next() {
 
   }
   if (fDDLID>=0 && fDDLID<20) {
-    CheckHeaderAndTrailerCount(fDDLID);
+    // The next line is commented, since we do not have the information how many chips to expect
+    // CheckHeaderAndTrailerCount(fDDLID);
   }
   return kFALSE;
 }
@@ -360,7 +374,7 @@ void AliITSRawStreamSPD::CheckHeaderAndTrailerCount(Int_t ddlID) {
                           fEqPLChipTrailersRead,fExpectedHeaderTrailerCount,ddlID);
     AliError(errMess.Data());
     fRawReader->AddMajorErrorLog(kHeaderCountErr,errMess.Data());
-    if (fAdvancedErrorLog) fAdvLogger->ProcessError(kHeaderCountErr,ddlID,-1,-1,errMess.Data());
+    if (fAdvancedErrorLog) fAdvLogger->ProcessError(kTrailerCountErr,ddlID,-1,-1,errMess.Data());
   }
 }
 //__________________________________________________________________________
@@ -393,11 +407,15 @@ const Char_t* AliITSRawStreamSPD::GetErrorName(UInt_t errorCode) {
   else if (errorCode==kHSNumberErr)             return "HS Number Error";
   else if (errorCode==kChipAddrErr)             return "Chip Address Error";
   else if (errorCode==kCalHeaderLengthErr)      return "Calib Header Length Error";
+  else if (errorCode==kAdvEventCounterErr)      return "Event Counter Error (Adv)";
+  else if (errorCode==kAdvEventCounterOrderErr) return "Event Counter Jump Error (Adv)";
   else return "";
 }
 //__________________________________________________________________________
 Bool_t AliITSRawStreamSPD::GetHalfStavePresent(UInt_t hs) {
   // Reads the half stave present status from the block attributes
+  // This is not really needed anymore (kept for now in case it is still used somewhere).
+  // The same information can be reached through the "IsActiveHS" method instead.
   Int_t ddlID = fRawReader->GetDDLID();
   if (ddlID==-1) {
     AliWarning("DDL ID = -1. Cannot read block attributes. Return kFALSE.");
index 068dd86..52b8f93 100644 (file)
@@ -21,7 +21,7 @@ class AliITSRawStreamSPD: public AliITSRawStream {
     AliITSRawStreamSPD& operator=(const AliITSRawStreamSPD& rstream);
     virtual ~AliITSRawStreamSPD() {};
 
-    virtual Bool_t   Next();
+    virtual Bool_t  Next();
     virtual Int_t   ReadCalibHeader();
 
     // the 2 methods below are equivalent to AliITSRawStream::GetCoord1 and GetCoord2
@@ -54,6 +54,10 @@ class AliITSRawStreamSPD: public AliITSRawStream {
     static UInt_t GetOfflineColFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col);
     static UInt_t GetOfflineRowFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t row);
 
+    Int_t  GetEventCounter() {return fEventCounter;}
+
+    Bool_t IsActiveEq(UInt_t eq) const {return fActiveEq[eq];}
+    Bool_t IsActiveHS(UInt_t eq, UInt_t hs) const {return fActiveHS[eq][hs];}
 
     Bool_t GetHalfStavePresent(UInt_t hs);
 
@@ -98,7 +102,9 @@ class AliITSRawStreamSPD: public AliITSRawStream {
       kDDLNumberErr,
       kHSNumberErr,
       kChipAddrErr,
-      kCalHeaderLengthErr
+      kCalHeaderLengthErr,
+      kAdvEventCounterErr,     // used by SPDmood
+      kAdvEventCounterOrderErr // used by SPDmood
     };
 
   private :
@@ -136,6 +142,9 @@ class AliITSRawStreamSPD: public AliITSRawStream {
     Bool_t      fAdvancedErrorLog;           // is the advanced error logging activated?
     AliITSRawStreamSPDErrorLog *fAdvLogger;  // pointer to special error logger object
 
+    Bool_t      fActiveEq[20];               // which equipments are active (found in data)
+    Bool_t      fActiveHS[20][6];            // which half-staves are active (blockattribute bits)
+
     ClassDef(AliITSRawStreamSPD, 0) // class for reading ITS SPD raw digits
 };
 
index 3e3b96f..55e17c3 100644 (file)
@@ -24,7 +24,7 @@ class AliITSRawStreamSPDErrorLog : public TObject {
   AliITSRawStreamSPDErrorLog& operator=(const AliITSRawStreamSPDErrorLog& logger);
   virtual ~AliITSRawStreamSPDErrorLog();
 
-  enum    {kNrErrorCodes = 15};
+  enum    {kNrErrorCodes = 17};
   enum    {kTotal = 0};
 
   void    Reset();
index 4869f12..b0689ff 100644 (file)
@@ -126,6 +126,19 @@ int main(int argc, char **argv) {
 
 
 
+  // create calibration handler (needed already at step 1 in order to fill which eq,hs,chips are active
+  AliITSOnlineCalibrationSPDhandler* handler = new AliITSOnlineCalibrationSPDhandler();
+  // Read silent=dead+inactive info from previous calibrations
+  handler->SetFileLocation(saveDirDead);
+  handler->ReadSilentFromFiles();
+//!!!  // start by deactivating all eq - should then be activated when found in raw data
+//!!!  for (UInt_t eq=0; eq<20; eq++) {
+//!!!    handler->ActivateEq(eq,kFALSE);
+//!!!  }
+
+
+
+
   // ********* STEP 1: Produce phys container files (Reference Data). ***********************************
 
 #ifndef SPD_DA_OFF
@@ -210,46 +223,81 @@ int main(int argc, char **argv) {
       eventT=event->eventType;
       if (eventT == PHYSICS_EVENT){
 
-       eventNr++;
        //      printf("eventNr %d\n",eventNr);
 
        AliRawReader *reader = new AliRawReaderDate((void*)event);
        AliITSRawStreamSPD *str = new AliITSRawStreamSPD(reader);
 
-       //      for (UInt_t eqId=0; eqId<20; eqId++) {
-       //        reader->Reset();
-       //        reader->Select("ITSSPD",eqId,eqId);
-
        while (str->Next()) {
 
          Int_t eqId = reader->GetDDLID();
+         // check that this hs is active in handler object
+         if (!(handler->IsActiveEq(eqId))) {
+           printf("Warning: Found Eq (%d) , previously inactive in this run!\n",eqId);
+           handler->ActivateEq(eqId);
+         }
          if (eqId>=0 && eqId<20) {
-           if (!bPhysInit[eqId]) {
+           if (!bPhysInit[eqId]) { // this code is duplicated for the moment... (see also below)
              TString fileName = Form("%s/SPDphys_run_%d_eq_%d.root",saveDirNoisyRef,runNr,eqId);
              physObj[eqId] = new AliITSOnlineSPDphys(fileName.Data());
              physObj[eqId]->AddRunNr(runNr);
              physObj[eqId]->SetEqNr(eqId);
              bPhysInit[eqId]=kTRUE;
            }
-           
+
            UInt_t hs = str->GetHalfStaveNr();
+           // check that this hs is active in handler object
+           if (!(handler->IsActiveHS(eqId,hs))) {
+             printf("Warning: Found HS (%d,%d) , previously inactive in this run!\n",eqId,hs);
+             handler->ActivateHS(eqId,hs);
+           }
            UInt_t chip = str->GetChipAddr();
+           // check that this chip is active in handler object
+           if (!(handler->IsActiveChip(eqId,hs,chip))) {
+             printf("Info: Found Chip (%d,%d,%d) , inactive in previous run.\n",eqId,hs,chip);
+             handler->ActivateChip(eqId,hs,chip);
+           }
            physObj[eqId]->IncrementHits(hs,chip,str->GetChipCol(),str->GetChipRow());
            
          }
        }
-       
-       for (UInt_t eqId=0; eqId<20; eqId++) {
-         if (bPhysInit[eqId]) {
-           physObj[eqId]->IncrementNrEvents();
+
+
+       // check which eq and hs are active for first event only
+       if (eventNr==0) {
+         for (UInt_t eqId=0; eqId<20; eqId++) {
+           // activate Eq and HSs in handler object
+           if (str->IsActiveEq(eqId)) {
+             handler->ActivateEq(eqId);
+             for (UInt_t hs=0; hs<6; hs++) {
+               handler->ActivateHS(eqId,hs,str->IsActiveHS(eqId,hs));
+             }
+             if (!bPhysInit[eqId]) { // this code is duplicated for the moment... (see also above)
+               TString fileName = Form("%s/SPDphys_run_%d_eq_%d.root",saveDirNoisyRef,runNr,eqId);
+               physObj[eqId] = new AliITSOnlineSPDphys(fileName.Data());
+               physObj[eqId]->AddRunNr(runNr);
+               physObj[eqId]->SetEqNr(eqId);
+               bPhysInit[eqId]=kTRUE;
+             }
+           }
+           else {
+             handler->ActivateEq(eqId,kFALSE);
+           }
          }
        }
 
-       //      }
+
+       for (UInt_t eq=0; eq<20; eq++) {
+         if (bPhysInit[eq]) {
+           physObj[eq]->IncrementNrEvents();
+         }
+       }
 
        delete str;
        delete reader;
 
+       eventNr++;
+
       }
 
       /* free resources */
@@ -264,8 +312,8 @@ int main(int argc, char **argv) {
 #endif
   
   // clean up phys objects (also saves them)
-  for (UInt_t eqId=0; eqId<20; eqId++) {
-    if (physObj[eqId]!=NULL) delete physObj[eqId];
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (physObj[eq]!=NULL) delete physObj[eq];
   }
 
 
@@ -283,12 +331,6 @@ int main(int argc, char **argv) {
   system(command.Data());
 
 
-  // create calibration handler and read dead from previous calibrations
-  AliITSOnlineCalibrationSPDhandler* handler = new AliITSOnlineCalibrationSPDhandler();
-  handler->SetFileLocation(saveDirDead);
-  handler->ReadDeadFromFiles();
-
-
   UInt_t firstRunNrDead = runNr;
 
 
@@ -297,38 +339,38 @@ int main(int argc, char **argv) {
   Bool_t eqActiveNoisy[20];
 
   // *** *** *** start loop over equipments (eq_id)
-  for (UInt_t eqId=0; eqId<20; eqId++) {
-    eqActiveNoisy[eqId] = kFALSE;
+  for (UInt_t eq=0; eq<20; eq++) {
+    eqActiveNoisy[eq] = kFALSE;
 
     // create analyzer for this eq
-    TString fileName = Form("%s/SPDphys_run_%d_eq_%d.root",saveDirNoisyRef,runNr,eqId);
+    TString fileName = Form("%s/SPDphys_run_%d_eq_%d.root",saveDirNoisyRef,runNr,eq);
     AliITSOnlineSPDphysAnalyzer *noisyAnalyzer = new AliITSOnlineSPDphysAnalyzer(fileName.Data(),handler);
 
     // check data in container
-    if (noisyAnalyzer->GetEqNr() != eqId) {
+    if (noisyAnalyzer->GetEqNr() != eq) {
       if (noisyAnalyzer->GetEqNr() != 999) {
        printf("Error: Mismatching EqId in Container data and filename (%d!=%d). Skipping.\n",
-              noisyAnalyzer->GetEqNr(),eqId);
+              noisyAnalyzer->GetEqNr(),eq);
       }
       delete noisyAnalyzer;
       continue;
     }
 
     nrEqActiveNoisy++;
-    eqActiveNoisy[eqId] = kTRUE;
+    eqActiveNoisy[eq] = kTRUE;
 
     // configure analyzer with tuning parameters etc:
     for (UInt_t i=0; i<nrTuningParams; i++) {
       noisyAnalyzer->SetParam(((TString*)paramNames.At(i))->Data(),((TString*)paramVals.At(i))->Data());
     }
 
-    printf("SPD phys STEP 2: Noisy search for eq %d\n",eqId);  
+    printf("SPD phys STEP 2: Noisy search for eq %d\n",eq);  
 
     // search for noisy pixels:
     nrEnoughStatNoisy += noisyAnalyzer->ProcessNoisyPixels();
 
     // copy this phys obj to temporary dead reference dir to process after noisy search
-    TString fileNameDead = Form("%s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eqId);
+    TString fileNameDead = Form("%s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eq);
     AliITSOnlineSPDphys* physObj = new AliITSOnlineSPDphys(fileNameDead.Data());
     physObj->AddPhys(noisyAnalyzer->GetOnlinePhys());
     if (physObj->GetNrRuns()>0) {
@@ -340,9 +382,9 @@ int main(int argc, char **argv) {
     // remove noisy pixels from dead hitmap
     for (UInt_t hs=0; hs<6; hs++) {
       for (UInt_t chip=0; chip<10; chip++) {
-       for (UInt_t ind=0; ind<handler->GetNrNoisyC(eqId,hs,chip); ind++) {
-         UInt_t col  = handler->GetNoisyColAtC(eqId,hs,chip,ind);
-         UInt_t row  = handler->GetNoisyRowAtC(eqId,hs,chip,ind);
+       for (UInt_t ind=0; ind<handler->GetNrNoisyC(eq,hs,chip); ind++) {
+         UInt_t col  = handler->GetNoisyColAtC(eq,hs,chip,ind);
+         UInt_t row  = handler->GetNoisyRowAtC(eq,hs,chip,ind);
          physObj->AddHits(hs,chip,col,row,-noisyAnalyzer->GetOnlinePhys()->GetHits(hs,chip,col,row));
        }
       }
@@ -352,9 +394,9 @@ int main(int argc, char **argv) {
     delete noisyAnalyzer;
 
 #ifndef SPD_DA_OFF
-    daqDA_progressReport((unsigned int)((eqId+1)*2.5));
+    daqDA_progressReport((unsigned int)((eq+1)*2.5));
 #else
-    printf("progress: %d\n",(unsigned int)(50+(eqId+1)*1.25));
+    printf("progress: %d\n",(unsigned int)(50+(eq+1)*1.25));
 #endif
   }
   // *** *** *** end loop over equipments (eq_id)
@@ -378,32 +420,33 @@ int main(int argc, char **argv) {
   Bool_t eqActiveDead[20];
 
   // *** *** *** start loop over equipments (eq_id)
-  for (UInt_t eqId=0; eqId<20; eqId++) {
-    eqActiveDead[eqId] = kFALSE;
+  for (UInt_t eq=0; eq<20; eq++) {
+    eqActiveDead[eq] = kFALSE;
 
     // setup analyzer for dead search
-    TString fileNameDead = Form("%s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eqId);
+    TString fileNameDead = Form("%s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eq);
     AliITSOnlineSPDphys* physObj = new AliITSOnlineSPDphys(fileNameDead.Data());
     AliITSOnlineSPDphysAnalyzer* deadAnalyzer = new AliITSOnlineSPDphysAnalyzer(physObj,handler);
     // check data in container
-    if (deadAnalyzer->GetEqNr() != eqId) {
+    if (deadAnalyzer->GetEqNr() != eq) {
       if (deadAnalyzer->GetEqNr() != 999) {
        printf("Error: Mismatching EqId in Dead Container data and filename (%d!=%d). Skipping.\n",
-              deadAnalyzer->GetEqNr(),eqId);
+              deadAnalyzer->GetEqNr(),eq);
       }
       delete deadAnalyzer;
+      //!!!      nrDeadChips+=60; // since this eq is inactive...
       continue;
     }
 
     nrEqActiveDead++;
-    eqActiveDead[eqId] = kTRUE;
+    eqActiveDead[eq] = kTRUE;
 
     // configure analyzer with tuning parameters etc:
     for (UInt_t i=0; i<nrTuningParams; i++) {
       deadAnalyzer->SetParam(((TString*)paramNames.At(i))->Data(),((TString*)paramVals.At(i))->Data());
     }
 
-    printf("SPD phys STEP 2: Dead search for eq %d\n",eqId);  
+    printf("SPD phys STEP 2: Dead search for eq %d\n",eq);  
 
     // search for dead pixels:
     nrEnoughStatChips += deadAnalyzer->ProcessDeadPixels();
@@ -413,9 +456,9 @@ int main(int argc, char **argv) {
     delete deadAnalyzer;
 
 #ifndef SPD_DA_OFF
-    daqDA_progressReport((unsigned int)(50+(eqId+1)*2.5));
+    daqDA_progressReport((unsigned int)(50+(eq+1)*2.5));
 #else
-    printf("progress: %d\n",(unsigned int)(75+(eqId+1)*1.25));
+    printf("progress: %d\n",(unsigned int)(75+(eq+1)*1.25));
 #endif
   }
   // *** *** *** end loop over equipments (eq_id)
@@ -423,20 +466,10 @@ int main(int argc, char **argv) {
   
   printf("Dead search finished. %d dead pixels in total.\n%d chips (%d) had enough statistics. %d chips were dead. %d chips were inefficient.\n",handler->GetNrDead(),nrEnoughStatChips,nrEqActiveDead*60,nrDeadChips,nrInefficientChips);
   handler->SetFileLocation(saveDirDead);
-  handler->WriteDeadToFilesAlways();
-
+  handler->WriteSilentToFilesAlways();
   handler->SetFileLocation(saveDirDeadToFXS);
-  handler->WriteDeadToFilesAlways();
-// *** old code (used if not all dead data should be uploaded)
-//  UInt_t nrDeadFilesToTar = 0;
-//  handler->SetFileLocation(saveDirDeadToFXS);
-//  for (UInt_t eqId=0; eqId<20; eqId++) {
-//    if (eqActiveDead[eqId]) {
-//      handler->WriteDeadToFile(eqId);
-//      nrDeadFilesToTar++;
-//    }
-//  }
-//***  
+  handler->WriteSilentToFilesAlways();
+
 
   printf("Opening id list file\n");
   TString idsFXSFileName = Form("%s/FXSids_run_%d.txt",saveDirIdsToFXS,runNr);
@@ -444,26 +477,22 @@ int main(int argc, char **argv) {
   idsFXSfile.open(idsFXSFileName.Data());
 
 
-  // if there is no chip in category "needsMoreStat"
+  // send (dead) reference data for this run to FXS - only if there is no chip in category "needsMoreStat"
   if (nrEnoughStatChips+nrDeadChips+nrInefficientChips == nrEqActiveDead*60) {
-    // calibration is complete
-    printf("Dead calibration is complete.\n");
-
-
-
+    printf("Dead calibration is complete.\n");    // calibration is complete
     printf("Preparing dead reference data\n");
     // send reference data for dead pixels to FXS
     TString tarFiles = "";
-    for (UInt_t eqId=0; eqId<20; eqId++) {
-      if (eqActiveDead[eqId]) {
-       printf("Preparing dead pixels for eq %d\n",eqId);
+    for (UInt_t eq=0; eq<20; eq++) {
+      if (eqActiveDead[eq]) {
+       printf("Preparing dead pixels for eq %d\n",eq);
        // move file to ref dir
-       TString fileName = Form("%s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eqId);
-       TString newFileName = Form("%s/SPDphys_dead_run_%d_%d_eq_%d.root",saveDirDeadRef,firstRunNrDead,runNr,eqId);
+       TString fileName = Form("%s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eq);
+       TString newFileName = Form("%s/SPDphys_dead_run_%d_%d_eq_%d.root",saveDirDeadRef,firstRunNrDead,runNr,eq);
        TString command = Form("mv -f %s %s",fileName.Data(),newFileName.Data());
        system(command.Data());
 
-       tarFiles.Append(Form("SPDphys_dead_run_%d_%d_eq_%d.root ",firstRunNrDead,runNr,eqId));
+       tarFiles.Append(Form("SPDphys_dead_run_%d_%d_eq_%d.root ",firstRunNrDead,runNr,eq));
       }
     }
     TString send_command = Form("cd %s; tar -cf ref_phys_dead.tar %s",saveDirDeadRef,tarFiles.Data());
@@ -478,38 +507,15 @@ int main(int argc, char **argv) {
     }
 #endif
     idsFXSfile << Form("%s\n",id.Data());
-//    for (UInt_t eqId=0; eqId<20; eqId++) { // OLD CODE NOT TARED
-//      if (eqActiveDead[eqId]) {
-//     TString fileName = Form("%s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eqId);
-//     // move file to ref dir
-//     TString newFileName = Form("%s/SPDphys_dead_run_%d_%d_eq_%d.root",saveDirDeadRef,firstRunNrDead,runNr,eqId);
-//     TString command = Form("mv -f %s %s",fileName.Data(),newFileName.Data());
-//     system(command.Data());
-//     // send ref data to FXS
-//     TString id = Form("SPD_ref_phys_dead_%d",eqId);
-//#ifndef SPD_DA_OFF
-//     Int_t status = daqDA_FES_storeFile(newFileName.Data(),id.Data());
-//     if (status!=0) {
-//       printf("Failed to export file %s , status %d\n",newFileName.Data(),status);
-//       return -1;
-//     }
-//#endif
-//     idsFXSfile << Form("%s\n",id.Data());
-//      }
-//      else {
-//     TString command = Form("rm -f %s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eqId);
-//     system(command.Data());
-//      }
-//    }
   }
 
 
+  // send (noisy) reference data for this run to FXS
   printf("Preparing noisy reference data\n");
-  // send reference data for this run to FXS
   TString tarFiles = "";
-  for (UInt_t eqId=0; eqId<20; eqId++) {
-    if (eqActiveNoisy[eqId]) {
-      tarFiles.Append(Form("SPDphys_run_%d_eq_%d.root ",runNr,eqId));
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (eqActiveNoisy[eq]) {
+      tarFiles.Append(Form("SPDphys_run_%d_eq_%d.root ",runNr,eq));
     }
   }
   TString send_command = Form("cd %s; tar -cf ref_phys.tar %s",saveDirNoisyRef,tarFiles.Data());
@@ -526,28 +532,8 @@ int main(int argc, char **argv) {
   idsFXSfile << Form("%s\n",id.Data());
 
 
-//  // send reference data for this run to FXS - OLD CODE NOT TARED
-//  for (UInt_t eqId=0; eqId<20; eqId++) {
-//    if (eqActiveNoisy[eqId]) {
-//      TString fileName = Form("%s/SPDphys_run_%d_eq_%d.root",saveDirNoisyRef,runNr,eqId);
-//      TString id = Form("SPD_ref_phys_%d",eqId);
-//#ifndef SPD_DA_OFF
-//      Int_t status = daqDA_FES_storeFile(fileName.Data(),id.Data());
-//      if (status!=0) {
-//     printf("Failed to export file %s , status %d\n",fileName.Data(),status);
-//     return -1;
-//      }
-//      idsFXSfile << Form("%s\n",id.Data());
-//    }
-//  }
-//#endif
-
-
-
-
-  printf("Preparing dead files\n");
   // send dead pixels to FXS
-  //  if (nrDeadFilesToTar>0) { //*** old code (used if not all dead data should be uploaded)
+  printf("Preparing dead files\n");
   // send a tared file of all the dead files
   send_command = Form("cd %s; tar -cf dead_phys.tar *",saveDirDeadToFXS);
   //  printf("\n\n%s\n\n",command.Data());
@@ -562,7 +548,6 @@ int main(int argc, char **argv) {
   }
 #endif
   idsFXSfile << Form("%s\n",id.Data());
-  //  } //*** old code (used if not all dead data should be uploaded)
 
 
   // send noisy pixels to FXS
@@ -603,4 +588,4 @@ int main(int argc, char **argv) {
 
 
   return 0;
-}
\ No newline at end of file
+}