Index: /trunk/MagicSoft/Mars/msignal/MExtractedSignalBlindPixel.cc
===================================================================
--- /trunk/MagicSoft/Mars/msignal/MExtractedSignalBlindPixel.cc	(revision 4310)
+++ /trunk/MagicSoft/Mars/msignal/MExtractedSignalBlindPixel.cc	(revision 4311)
@@ -28,5 +28,8 @@
 //
 // This is the storage container to hold informations about the extracted signal 
-// (offset) value of the calibration PIN Diode
+// (offset) value of the calibration Blind Pixel. 
+//
+// There is place for various blind pixels set into the camera in  July. Default 
+// is one blind pixel.
 //
 /////////////////////////////////////////////////////////////////////////////
@@ -57,4 +60,13 @@
   fTitle = title ? title : "Container of the Extracted Signals";
 
+  fBlindPixelIdx.Set(1);
+  fExtractedSignal.Set(1);
+  fNumSaturated.Set(1);
+
+  fPed.Set(1);      
+  fPedErr.Set(1);   
+  fPedRms.Set(1);   
+  fPedRmsErr.Set(1);
+
   Clear();
 }
@@ -67,12 +79,14 @@
 {
 
-  fExtractedSignal    = gkSignalInitializer;
-
-  fPed                = gkSignalInitializer;;      
-  fPedErr             = gkSignalInitializer;;   
-  fPedRms             = gkSignalInitializer;;   
-  fPedRmsErr          = gkSignalInitializer;;  
+  for (Int_t i=0;i<fBlindPixelIdx.GetSize();i++)
+    {
+      fNumSaturated   .AddAt(gkSignalInitializer,i);
+      fExtractedSignal.AddAt(gkSignalInitializer,i);
+      fPed            .AddAt(gkSignalInitializer,i);      
+      fPedErr         .AddAt(gkSignalInitializer,i);   
+      fPedRms         .AddAt(gkSignalInitializer,i);   
+      fPedRmsErr      .AddAt(gkSignalInitializer,i);  
+    }
   
-  fNumSaturated       = 0;
 }
 
@@ -84,13 +98,19 @@
 
 
-Bool_t MExtractedSignalBlindPixel::IsValid() const
+Bool_t MExtractedSignalBlindPixel::IsValid( const Int_t i ) const
 {
-    return fExtractedSignal >= 0 && fExtractedSignal <  gkSignalInitializer;
+    return fExtractedSignal.At(i) >= 0 && fExtractedSignal.At(i) <  gkSignalInitializer;
 }
 
 void MExtractedSignalBlindPixel::Print(Option_t *o) const
 {
-  *fLog << " Signal: " << fExtractedSignal
-        << " Nr. Saturation: " <<  fNumSaturated
-        << endl;
+
+  for (Int_t i=0;i<fBlindPixelIdx.GetSize();i++)
+    {
+      
+      *fLog << "Blind Pixel ID: " << fBlindPixelIdx.At(i)
+            << ": Signal: " << fExtractedSignal.At(i)
+            << " Saturated Slices: " <<  fNumSaturated.At(i)
+            << endl;
+    }
 }
Index: /trunk/MagicSoft/Mars/msignal/MExtractedSignalBlindPixel.h
===================================================================
--- /trunk/MagicSoft/Mars/msignal/MExtractedSignalBlindPixel.h	(revision 4310)
+++ /trunk/MagicSoft/Mars/msignal/MExtractedSignalBlindPixel.h	(revision 4311)
@@ -6,5 +6,11 @@
 #endif
 
+#ifndef ROOT_TArrayI
 #include <TArrayI.h>
+#endif
+
+#ifndef ROOT_TArrayF
+#include <TArrayF.h>
+#endif
 
 class MExtractedSignalBlindPixel : public MParContainer
@@ -12,17 +18,19 @@
 private:
 
-  Int_t fExtractedSignal;    // mean value of the extracted signal
+  static const UInt_t gkNumBlindPixels;  //! Current Number of blind pixels in the camera  
+  
+  TArrayI fBlindPixelIdx;                // Array Blind Pixel IDs
+  TArrayF fExtractedSignal;              // Array Extracted signals per Blind Pixel ID
+  TArrayI fNumSaturated;                 // Array Number of saturated slices per Blind Pixel ID 
+  
+  TArrayF fPed;                          // Array Pedestal per Blind Pixel IDs                               
+  TArrayF fPedErr;                       // Array Pedestal Error per Blind Pixel ID          
+  TArrayF fPedRms;                       // Array Pedestal RMS per Blind Pixel ID 
+  TArrayF fPedRmsErr;                    // Array Pedestal RMS Error per Blind Pixel ID 
 
-  Byte_t fFirst;
-  Byte_t fNumFADCSamples;
-  Byte_t fNumSaturated;
+  Byte_t  fFirst;                        // First FADC extraction slice
+  Byte_t  fNumFADCSamples;               // Number of summed FADC slices
 
-  Float_t fPed;
-  Float_t fPedErr;
-  Float_t fPedRms;
-  Float_t fPedRmsErr;
-
-  Int_t fBlindPixelIdx;
-
+  
 public:
 
@@ -32,30 +40,51 @@
   void Print(Option_t *o="") const;
   
+  // Getters
+  Int_t   GetBlindPixelIdx   ( const Int_t i=0 )  const { return fBlindPixelIdx.At(i)  ; }  
+  Float_t GetExtractedSignal ( const Int_t i=0 )  const { return fExtractedSignal.At(i); }
+  Int_t   GetNumSaturated    ( const Int_t i=0 )  const { return fNumSaturated.At(i)   ; }
+  Byte_t  GetNumFADCSamples  ()                   const { return fNumFADCSamples      ; }
+
+  Bool_t IsValid       ( const Int_t i=0 )  const;   
+
+  Float_t GetPed       ( const Int_t i=0 )  const { return fPed.At(i);       }
+  Float_t GetPedErr    ( const Int_t i=0 )  const { return fPedErr.At(i);    }
+  Float_t GetPedRms    ( const Int_t i=0 )  const { return fPedRms.At(i);    }
+  Float_t GetPedRmsErr ( const Int_t i=0 )  const { return fPedRmsErr.At(i); }
+
   // Setter
-  void SetExtractedSignal(const Int_t sig    )    { fExtractedSignal = sig;     }
-  void SetNumSaturated(   const Byte_t numsat )    { fNumSaturated    = numsat;  }
   void SetUsedFADCSlices( const Byte_t first, const Byte_t num);
-  void SetNumFADCSamples( const Byte_t num    )    { fNumFADCSamples  = num;     }    
+  void SetNumFADCSamples( const Byte_t num )    { fNumFADCSamples  = num;     }    
 
-  void SetPed(      const Float_t f )     { fPed       = f; }
-  void SetPedErr(   const Float_t f )     { fPedErr    = f; }
-  void SetPedRms(   const Float_t f )     { fPedRms    = f; }
-  void SetPedRmsErr(const Float_t f )     { fPedRmsErr = f; }
+  void SetBlindPixelIdx  ( const Int_t i,   const Int_t nr=0)      {
+    if (nr>fBlindPixelIdx.GetSize()-1)
+      fBlindPixelIdx.Set(nr+1);
+    fBlindPixelIdx.AddAt(i,nr); }
+  void SetExtractedSignal( const Float_t f, const Int_t nr=0 )     {
+    if (nr>fExtractedSignal.GetSize()-1)
+      fExtractedSignal.Set(nr+1);
+    fExtractedSignal.AddAt(f,nr); }
+  void SetNumSaturated   ( const Int_t i,   const Int_t nr=0 )     {
+    if (nr>fNumSaturated.GetSize()-1)
+      fNumSaturated.Set(nr+1);
+    fNumSaturated.AddAt(i,nr); }
+  void SetPed            ( const Float_t f, const Int_t nr=0 )     {
+    if (nr>fPed.GetSize()-1)
+      fPed.Set(nr+1);
+    fPed.AddAt(f,nr); }
+  void SetPedErr         ( const Float_t f, const Int_t nr=0 )     {
+    if (nr>fPedErr.GetSize()-1)
+      fPedErr.Set(nr+1);
+    fPedErr.AddAt(f,nr); }
+  void SetPedRms         ( const Float_t f, const Int_t nr=0 )     {
+    if (nr>fPedRms.GetSize()-1)
+      fPedRms.Set(nr+1);
+    fPedRms.AddAt(f,nr); }
+  void SetPedRmsErr      ( const Float_t f, const Int_t nr=0 )     {
+    if (nr>fPedRmsErr.GetSize()-1)
+      fPedRmsErr.Set(nr+1);
+    fPedRmsErr.AddAt(f,nr); }
 
-  void SetBlindPixelIdx( const Int_t i)   { fBlindPixelIdx = i; }
-
-    // Getter
-  Int_t  GetExtractedSignal()    const { return fExtractedSignal; }
-  Byte_t GetNumFADCSamples()     const { return fNumFADCSamples;  }
-  Int_t  GetBlindPixelIdx()      const { return fBlindPixelIdx; }  
-
-  Bool_t IsValid() const;   
-
-  Float_t GetPed()       const { return fPed;       }
-  Float_t GetPedErr()    const { return fPedErr;    }
-  Float_t GetPedRms()    const { return fPedRms;    }
-  Float_t GetPedRmsErr() const { return fPedRmsErr; }
-
-  ClassDef(MExtractedSignalBlindPixel, 1)	// Storage Container for Extracted Signal of the blind pixel
+  ClassDef(MExtractedSignalBlindPixel, 2)	// Storage Container for extracted signal of Blind Pixel
 };