//////////////////////////////////////////////////////////////////////
//  Extracts individual PMT noise rates, average noise rate,
//  and charge distribution characteristics
//
//  Author: Constantin Weisser <weissercn@gmail.com>
//  Contact: Ed Callaghan <ejc3@berkeley.edu>
//
//  REVISION HISTORY:
//      31 July 2015 : Kevin Nuckolls - Revisions to data structure,
//                                      Add charge analysis features
//      14 August 2017 : Ed Callaghan - Change trigger selection to reject
//                                      blacklisted triggers,
//                                      Add "perpmt_pgt" field to output
//                                      NOISE_RUN_LEVEL ratdb file
//      18 Dec 2017 : Logan Lebanowski - Subtract cross-talk hits from
//                                      noise hits
//      11 January 2018 : Ed Callaghan - Guard against NaN's in 0-PGT runs
//
//  This processor analyzes events with only the Pulsed
//  Global Trigger (PGT) in the trigger word to extract hits in PMTs
//  caused by dark current. It then calculates the average noise rate
//  across the detector, average noise rate per PMT, and extracts the
//  Peak Bin Value, Threshold Level, and High Half Point from both
//  QHS and QHL charge distributions.
//
//////////////////////////////////////////////////////////////////////

#ifndef __RAT_PMTNoiseProc__
#define __RAT_PMTNoiseProc__

#include <vector>
#include <string>

#include <TH1F.h>
#include <TFile.h>
#include <TGraph.h>

#include <RAT/DB.hh>
#include <RAT/Processor.hh>
#include <RAT/DS/Entry.hh>
#include <RAT/DS/EV.hh>
#include <RAT/DS/PMT.hh>
#include <RAT/DU/Utility.hh>
#include <RAT/DU/ChanHWStatus.hh>
#include <RAT/DU/PMTInfo.hh>
#include <RAT/Log.hh>
#include <RAT/DB.hh>

namespace RAT
{
  class PMTNoiseProc : public Processor
  {
  public:
    PMTNoiseProc();
    virtual Processor::Result DSEvent( DS::Run& run, DS::Entry& ds );

    virtual ~PMTNoiseProc() { }

    virtual void BeginOfRun( DS::Run& );
    virtual void EndOfRun( DS::Run& );

    // @param[in] param should be outname
    // @param[in] value should be the name of output file
    // @throws ParamUnknown if the param is not outname
    virtual void SetS( const std::string& param, const std::string& value );

    // @param[in] param should be simulation, average_min, or average_max
    // @param[in] value should be 0 or 1 (simulation) or >= 0 (average bound)
    // @throws ParamUnknown if the param is not simulation
    // @throws ParamInvalid if the value is not 0 or 1
    virtual void SetI( const std::string& param, const int value );

  protected:
    std::string fID; // Option Id for this processor
    // Extract charge spectrum QHS and QHL peak, threshold and hhp values.
    int GainFitPoints(int PMTNum,          // PMT ID
                      int chargeFlag,      // 0 = QHS, 1 = QHL
                      double &peakBinVal,  // Return the position of the peak
                      double &threshVal,   // Return the position of the threshold
                      double &hhpVal);     // Return the position of the high-half point

    // Number of events with only PulseGT and non-blacklisted bits
    // in the trigger word
    int fPGTCounter;
    int fPMTCount;

    // PMT Noise Vectors
    std::vector<int> fHitCounter;        // PGT hit counter for every PMT

    unsigned int fPGTMask;   // Mask for PulseGT
    unsigned int fBlacklist; // Mask for triggers excluded from noise rate
    std::string fBlacklistTriggers;      // Comma-separated list of excluded triggers
    std::vector<std::string> includeTriggers; // User force-allow triggers
    std::vector<std::string> excludeTriggers; // User excluded triggers

    // QHS and QHL Charge Distribution Vectors
    std::vector< std::vector<double> > fQHSArray;
    std::vector< std::vector<double> > fQHLArray;
    std::vector<double> fQHSMin;
    std::vector<double> fQHSMax;
    std::vector<double> fQHLMin;
    std::vector<double> fQHLMax;

    int fSimulationFlag;
    int fAverageMinBound;
    int fAverageMaxBound;

    std::string fFilename;
    TFile *fFile;
  };
} // namespace RAT

#endif