#ifndef MARS_MExtractedSignalBlindPixel
#define MARS_MExtractedSignalBlindPixel

#ifndef MARS_MParContainer
#include "MParContainer.h"
#endif

#ifndef ROOT_TArrayI
#include <TArrayI.h>
#endif

#ifndef ROOT_TArrayF
#include <TArrayF.h>
#endif

#ifndef MARS_MExtractBlindPixel
#include <MExtractBlindPixel.h>
#endif

class MExtractedSignalBlindPixel : public MParContainer
{
private:

  static const Int_t gkSignalInitializer; //! Initializer for variables

  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;                         // First FADC extraction slice
  Byte_t  fNumFADCSamples;                // Number of summed FADC slices
  Byte_t  fExtractionType;                // What extraction type has been chosen?
  
public:

  MExtractedSignalBlindPixel(const char* name=NULL, const char* title=NULL);

  void Clear(Option_t *o="");
  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   GetNumBlindPixels  ()                   const { return fBlindPixelIdx.GetSize(); }
  Int_t   GetNumSaturated    ( const Int_t i=0 )  const { return fNumSaturated.At(i)     ; }
  Byte_t  GetNumFADCSamples  ()                   const { return fNumFADCSamples         ; }

  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)        ; }

  Bool_t  IsExtractionType   ( const MExtractBlindPixel::ExtractionType_t typ );
  Bool_t  IsValid            ( const Int_t i=0 )  const;   

  // Setter
  void SetExtractionType( const Byte_t b=0 )            { fExtractionType  = b           ; }
  void SetNumFADCSamples( const Byte_t num )            { fNumFADCSamples  = num         ; }    
  void SetUsedFADCSlices( const Byte_t first, const Byte_t num );

  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); }

  ClassDef(MExtractedSignalBlindPixel, 3)	// Storage Container for extracted signal of Blind Pixel
};

#endif








