// -*- C++/l -*-
//
// Description: Analysis of FGD data quality using dark noise/ped events
//
// Author:      Nick Hastings <hastings@neutrino.kek.jp>
// Created:     Tue May 11 14:54:58 JST 2010
//

#ifndef TFGDDARKNOISEANDPED_H
#define TFGDDARKNOISEANDPED_H

#include <utility>

#include "ICOMETEvent.hxx"
#include "ISOFFVTask.hxx"

#include "IFGDChanNumber.hxx"
#include "IFgdRawDataTask.hxx"

#include "TClonesArray.h"
#include "TH1D.h"

class TF1;
class TFile;
class TTree;

/// Hold and process information on single PE signals for an FGD channel
class IDNChan
{
  public:
    IDNChan(unsigned int miniCrate, unsigned int feb, unsigned int febCh,
      unsigned int bins=4096, float xmin=0.0, float xmax=4096.0 );

    /// Reset the pulse height histogram and fit parameters
    void Reset();

    /// Perform a fit to the dark noise histogram
    void Fit(void);

    /// Return a reference to the dark noise histogram
    TH1D& GetHist(void)
    {
      return fH;
    }
    /// Return a const reference to the dark noise histogram    
    const TH1D& GetHist(void) const
    {
      return fH;
    }

    /// Return a reference to the fit function
    TF1& GetFunc(void)
    {
      return fF;
    }
    /// Return a const reference to the fit function    
    const TF1& GetFunc(void) const
    {
      return fF;
    }

    /// Return mean and mean error from fit
    std::pair<double,double> GetFitMean(void) const;
    /// Return number of entries and error from fit
    std::pair<double,double> GetFitEntries(void) const;
    /// Return mean and error on mean
    std::pair<double,double> GetMean(void) const;
    /// Return the fit status
    int GetFitStatus(void) const;


    const IFGDChanNumber& GetChanNum(void) const
    {
      return fChanNum;
    }

    /// Return the dark noise prediction (may not be set)
    double GetPrediction(void) const
    {
      return fPrediction;
    }
    /// Set the dark noise prediction
    void SetPrediction( double prediction )
    {
      fPrediction = prediction;
    }
  private:
    /// Fit function string
    std::string fString;

    /// Channel number information
    IFGDChanNumber fChanNum;

    /// Pulse height distribution histogram
    TH1D fH;
    /// Pulse height distribution fit function
    TF1  fF;
    /// Status returned by the fit to the pulse height distribution. Non zero
    /// means the fit failed.
    int fFitStatus;
    /// Predicted Single PE pulse height
    double fPrediction;
};
///////////////////////////////////////////////////////////////////////
///
/// Class to hold and process information on single PE signals for FGD channels
class IAdcToPECalibSOff
  : public IFgdRawDataTask
{
  public:
    IAdcToPECalibSOff();
    virtual ~IAdcToPECalibSOff();
    /// Analyse SPE pulse in FGD channels  
    int processEvent(IFgdRawEvent* event);
    //int end(void);
    /// Reset parameter in FGD channels (IDNChan objects)
    void Reset(void);

    /// Return a reference to the vector of FGD channels
    std::vector<IDNChan*>& GetDNChans(void)
    {
      return fDNChans;
    }
    /// Fit the SPE pulse height distributions of all channels
    void Fit(void);

  private:
    /// All FGD channels
    std::vector<IDNChan*> fDNChans;
};
//////////////////////////////////////////////////////////////////////
class IAdc2PePredicted;
class IEdgePulseFinder;

///
/// Analyse Single Photo Electron pulses in FGD data for pedestal triggers
///
class IFGDDarkNoiseAndPed
  : public ISOFFVTask
{
  public:
    IFGDDarkNoiseAndPed( std::string fileName  = "fgd_dn_quality.root" );
    virtual ~IFGDDarkNoiseAndPed();
    /// Set up the FGD raw data tasks and initialize the root file and tree
    int Initialize( void  );
    /// Process the FGD SPE pulses in an event
    int Process( COMET::ICOMETEvent& event );
    /// Clean up and write out root objects and file
    virtual int Finalize( void );
    /// Set the output root file name
    void SetFileName( const std::string& fileName );
    /// Parse command line option
    bool SetOption( std::string option, std::string value );

    /// Reset tree variables
    void StartPeriod(void);

    /// Perform fits to SPE pulse height distributions and write to file.
    /// Add results to tree
    void EndPeriod(void);

  private:
    /// Low level FGD pulse processing
    IFgdRawDataManager *fManager;
    IOnlinePulseProcessor *fTaskOPP;
    IEdgePulseFinder      *fTaskEPF; // Needed for analysing raw data
    IAdcToPECalibSOff     *fTaskAdcToPECalib;

    /// Access to the predicted SPE pulse heights for each channel
    IAdc2PePredicted      *fAdcToPEPredicted;

    /// Root file output file name
    std::string fFileName;

    /// Output root file
    TFile* fFile;


    /// TTree variables
    /// Current run and subrun numbers. Time of first and last triggers
    Int_t fRun, fSubRun, fTfirst, fTlast;

    ///  Number of FGD channels: 48 * 4 * 64 (mincrate*feb*febch)
    unsigned int fNChans;
    
    /// Single PE from dark noise
    /// Number of tirggers
    Int_t fNTriggers;
    /// Inverse of fraction of FGD dark noise events written during data taking
    Int_t fKeepDarkNoise; // ODB setting

    /// SPE pulse height distribution (phd) mean array
    Double_t* fMean;
    /// SPE phd mean error array
    Double_t* fDMean;
    /// SPE phd fit mean array
    Double_t* fFitMean;
    /// SPE phd fit mean error array
    Double_t* fFitDMean;
    /// SPE phd fit area array
    Double_t* fFitEntries;
    /// SPE pulse height expectation array
    Double_t* fPredict;
    /// SPE phd fit reduce chi squared array
    Double_t* fChi2ndf;
    /// SPE phd fit return status
    Int_t* fFitStatus;
    /// SPE phd number of entries array
    Double_t* fEntries;

    /// Mapping of channel index to minicrate number
    Int_t* fMiniCrate;
    /// Mapping of channel index to FEB number
    Int_t* fFeb;
    /// Mapping of channel index to FEB channel bnumber
    Int_t* fFebCh;
    /// Channel indicies
    Int_t* fIndex;

    /// SPE phd results
    TTree* fTree;
    
};
#endif

// Local Variables:
// c-basic-offset: 8
// c-file-offsets: ((access-label . -2)(inclass . 4)(innamespace . 2))
// End: