#ifndef MARS_MCalibrationChargeBlindPix
#define MARS_MCalibrationChargeBlindPix

#ifndef MARS_MCalibrationChargeCam
#include "MCalibrationChargeCam.h"
#endif

#ifndef MARS_MCalibrationChargePix
#include "MCalibrationChargePix.h"
#endif

class MCalibrationChargeBlindPix : public MCalibrationChargePix
{
private:

  static const Float_t gkBlindPixelArea;        //! The Blind Pixel area in mm^2
  static const Float_t gkBlindPixelAttGreen;    //! Attenuation Filter at 520 nm 
  static const Float_t gkBlindPixelAttBlue ;    //! Attenuation Filter at 460 nm 
  static const Float_t gkBlindPixelAttUV   ;    //! Attenuation Filter at 370 nm 
  static const Float_t gkBlindPixelAttCT1  ;    //! Attenuation Filter at 370 nm
  static const Float_t gkBlindPixelQEGreen;     //! Quantum Efficiency at 520 nm
  static const Float_t gkBlindPixelQEBlue ;     //! Quantum Efficiency at 460 nm
  static const Float_t gkBlindPixelQEUV   ;     //! Quantum Efficiency at 370 nm
  static const Float_t gkBlindPixelQECT1  ;     //! Quantum Efficiency at 370 nm
  static const Float_t gkBlindPixelQEGreenErr;  //! Uncertainty QE at 520 nm 
  static const Float_t gkBlindPixelQEBlueErr ;  //! Uncertainty QE at 460 nm 
  static const Float_t gkBlindPixelQEUVErr   ;  //! Uncertainty QE at 370 nm 
  static const Float_t gkBlindPixelQECT1Err  ;  //! Uncertainty QE at 370 nmu

  Float_t fLambda;                  // Mean Poisson fit
  Float_t fLambdaCheck;             // Mean Pedestal Check (Gauss) fit
  Float_t fLambdaCheckErr;          // Error mean pedestal Check fit
  Float_t fLambdaVar;               // Variance lambda Poisson fit
  Float_t fFluxInsidePlexiglass;    // Number photons in INNER PIXEL inside the plexiglass
  Float_t fFluxInsidePlexiglassVar; // Variance number of photons in INNER PIXEL 
  Float_t fMu0;                     // Position pedestal peak
  Float_t fMu0Err;                  // Error pos. pedestal-peak
  Float_t fMu1;                     // Position first photo-electron peak
  Float_t fMu1Err;                  // Error pos. first photo-electon peak
  Float_t fSigma0;                  // Width pedestal peak
  Float_t fSigma0Err;               // Error width pedestal peak
  Float_t fSigma1;                  // Width first photo-electron peak  
  Float_t fSigma1Err;               // Error width first photo-electron peak  

  enum { kOscillating, kPedestalFitOK, kSinglePheFitOK, kChargeFitValid, 
         kFluxInsidePlexiglassAvailable };

  MCalibrationCam::PulserColor_t fColor;  

  const Float_t GetBlindPixelQEGreenRelVar() const; 
  const Float_t GetBlindPixelQEBlueRelVar () const; 
  const Float_t GetBlindPixelQEUVRelVar   () const; 
  const Float_t GetBlindPixelQECT1RelVar  () const; 

 public:

  MCalibrationChargeBlindPix(const char *name=NULL, const char *title=NULL);
  ~MCalibrationChargeBlindPix() {}
  
  void Clear(Option_t *o="");

  // Setters
  void SetColor            ( const MCalibrationCam::PulserColor_t color ) { fColor  = color; }
  void SetLambda           ( const Float_t f )                    { fLambda         = f;   }
  void SetLambdaVar        ( const Float_t f )                    { fLambdaVar      = f;   }
  void SetLambdaCheck      ( const Float_t f )                    { fLambdaCheck    = f;   }
  void SetLambdaCheckErr   ( const Float_t f )                    { fLambdaCheckErr = f;   }
  void SetMu0              ( const Float_t f )                    { fMu0            = f;   }
  void SetMu0Err           ( const Float_t f )                    { fMu0Err         = f;   }
  void SetMu1              ( const Float_t f )                    { fMu1            = f;   }
  void SetMu1Err           ( const Float_t f )                    { fMu1Err         = f;   }
  void SetSigma0           ( const Float_t f )                    { fSigma0         = f;   }
  void SetSigma0Err        ( const Float_t f )                    { fSigma0Err      = f;   }
  void SetSigma1           ( const Float_t f )                    { fSigma1         = f;   }
  void SetSigma1Err        ( const Float_t f )                    { fSigma1Err      = f;   }

  void SetOscillating      ( const Bool_t  b=kTRUE);
  void SetChargeFitValid   ( const Bool_t  b=kTRUE);
  void SetPedestalFitOK    ( const Bool_t  b=kTRUE);
  void SetSinglePheFitOK   ( const Bool_t  b=kTRUE);
  void SetFluxInsidePlexiglassAvailable( const Bool_t b=kTRUE);
  
  // Getters
  Float_t GetLambda()                     const { return fLambda;               }
  Float_t GetLambdaErr()                  const;
  Float_t GetLambdaRelVar()               const;  
  Float_t GetLambdaCheck()                const { return fLambdaCheck;          }
  Float_t GetLambdaCheckErr()             const { return fLambdaCheckErr;       }
  Float_t GetFluxInsidePlexiglass()       const { return fFluxInsidePlexiglass; }
  Float_t GetFluxInsidePlexiglassErr()    const;
  Float_t GetFluxInsidePlexiglassRelVar() const;  
  Float_t GetMu0()                        const { return fMu0;                  }
  Float_t GetMu0Err()                     const { return fMu0Err;               }
  Float_t GetMu1()                        const { return fMu1;                  }
  Float_t GetMu1Err()                     const { return fMu1Err;               }
  Float_t GetSigma0()                     const { return fSigma0;               }
  Float_t GetSigma0Err()                  const { return fSigma0Err;            } 
  Float_t GetSigma1()                     const { return fSigma1;               }
  Float_t GetSigma1Err()                  const { return fSigma1Err;            }

  Bool_t  IsOscillating()                    const;
  Bool_t  IsChargeFitValid()                 const;
  Bool_t  IsPedestalFitOK()                  const;
  Bool_t  IsSinglePheFitOK()                 const;
  Bool_t  IsFluxInsidePlexiglassAvailable()  const;
  
  Bool_t CalcFluxInsidePlexiglass();

  ClassDef(MCalibrationChargeBlindPix, 1)	// Container Charge Calibration Results Blind Pixel
};

#endif




