PulseFinder.h

#ifndef PULSEFINDER_H
#define PULSEFINDER_H

//LCIO
#include "lcio.h"
#include "EVENT/LCCollection.h"
#include "EVENT/TrackerData.h"
#include <IMPL/TrackerDataImpl.h>
#include "EVENT/TrackerPulse.h"

#include "PedestalListener.h"
#include "ADCElectronicsListener.h"

//C++
#include <string>

namespace marlintpc
{

  class PulseFinder
  {

    public:

    PulseFinder( float minimumPulseHeight,
                 int minimumPulseLength,
                 float pulseStartPedestalWidthFactor,
                 float pulseEndPedestalWidthFactor,
                 float noiseValuePedestalWidthFactor,
                 PedestalListener const * pedestalListener,
                 ADCElectronicsListener const * adcElectronicsListener,
                 int saveNBinsBeforeStart = 0,
                 int saveNBinsAfterEnd = 0,
                 int timeCalculationMode = INFLEXION_POINT,
                 double timeCalculationParameter = 0.9,
                 int chargeCalculationMode = SUMQ
                 );

    //The modes for charge and time calculation
    static const int INFLEXION_POINT = 0; 
    static const int FIT_PARABOLA = 1;    
    static const int CENTRE_OF_GRAVITY = 2; 
    static const int FIRST_ABOVE_THRESHOLD = 3; 
    static const int AT_MAXIMUM = 4; 
    static const int CONSTANT_FRACTION = 5; 
    static const int GAMMA_FIT = 6; 
    static const int COG_ATMAX = 7; 
    static const int BOX = 8; 
    static const int GAUSSIAN_INFLEXION = 9; 


    static const int SUMQ = 0; 
    // FIT_PARABOLA = 1 already defined in the time section.
    static const int MAXQ = 2; 
    static std::string getRevisionNumber(); 

  protected:

    float _pulseStartPedestalWidthFactor; 
    float _pulseEndPedestalWidthFactor; 
    float _noiseValuePedestalWidthFactor; 

    
    int _timeCalculationMode;  
    int _COGAtMaxParameter;
    double _ConstFracParameter;
    int _chargeCalculationMode; 

    float _minimumPulseHeight; 
    int _minimumPulseLength;   
    int _saveNBinsBeforeStart; 
    int _saveNBinsAfterEnd;    
    
    PedestalListener const * _pedestalListener;
    ADCElectronicsListener const * _adcElectronicsListener;
    
     // override variables

    // A set of variables for which values the override value should be used.
    bool _usePedestalValueOverride;
    bool _usePedestalWidthOverride;
    bool _use_isPedestalSubtractedOverride;
    bool _usePolarityOverride;
    bool _useReadoutFrequencyOverride;
    bool _useMaxADCValueOverride;


    float _maximumADCValueOverride;

    float _readoutFrequencyOverride;
    
    float _pedestalValueOverride;

    float _pedestalWidthOverride;

    bool _isPedestalSubtractedOverride;

    int _polarityOverride;

  
    bool _forceSpectrumSave; 
    bool _switchOffSplitting; 

    int _maxPlateauLength; 


      class PulseTime
      {
        public:
          PulseTime() : _time(0.), _timeError(0.)
          {
            ;
          };
          void setTime(float t)
          {
            _time = t;
          };
          void setTimeError(float e)
          {
            _timeError = e;
          };
          float getTime()
          {
            return _time;
          };
          float getTimeError()
          {
            return _timeError;
          };
        private:
          float _time, _timeError;
      };

      class PulseCharge
      {
        public:
          PulseCharge() : _charge(0.), _chargeError(0.)
          {
            ;
          };
          void setCharge(float t)
          {
            _charge = t;
          };
          void setChargeError(float e)
          {
            _chargeError = e;
          };
          float getCharge()
          {
            return _charge;
          };
          float getChargeError()
          {
            return _chargeError;
          };
        private:
          float _charge, _chargeError;
      };

      class Pulse : public PulseCharge, public PulseTime
      {
        public:
          Pulse() : PulseCharge(), PulseTime()
          {
            ;
          };
          void set(PulseCharge c)
          {
            setCharge(c.getCharge());
            setChargeError(c.getChargeError());
          };
          void set(PulseTime t)
          {
            setTime(t.getTime());
            setTimeError(t.getTimeError());
          };
      };

      struct InternalSplitPulse
      {
        InternalSplitPulse(std::vector<float>::const_iterator s, 
                           std::vector<float>::const_iterator e, bool f)
        {
          startBin = s;
          endBin = e;
          isSplit = f;
        }
        std::vector<float>::const_iterator startBin;
        std::vector<float>::const_iterator endBin;
        bool isSplit;

        InternalSplitPulse()
        {
          ;
        };
      };

  public:
      std::vector<TrackerPulse *> findPulses(TrackerData* inputData);
      
      Pulse calculatePulseTimeAndCharge(const EVENT::TrackerData *tracker_data);


      // the internal functions
  protected:
      void findPulseCandidates(lcio::TrackerData* thisData, 
                               std::vector<std::pair<lcio::TrackerDataImpl*, int> >* tempPulse);



      void brutePulseSearch(TrackerData const * inputTrackerData,
                            std::vector<std::pair<std::vector<float>::const_iterator,
                            std::vector<float>::const_iterator> >* theCandidatePulses);



      std::vector<InternalSplitPulse> splitMultiplePulses(
                std::vector< std::pair< std::vector<float>::const_iterator,
                                        std::vector<float>::const_iterator> >* theCandidatePulses,
                float noiseThreshold);


   

      Pulse calculatePulseWithFit(const EVENT::TrackerData *tracker_data);

      PulseTime calcPulseTimeWithGammaFit(const lcio::TrackerData *thisPulse);

      PulseTime calcPulseTimeInflexionPoint(const lcio::TrackerData* thisPulse);

      PulseTime calcPulseTimeAtMaximum(const lcio::TrackerData* thisPulse);

      PulseTime calcPulseTimeAtConstantFraction(const lcio::TrackerData* thisPulse);

      PulseTime calcPulseTimeCentreOfGravity(const lcio::TrackerData* thisPulse);

      PulseTime calcPulseTimeCOGAtMaximum(const lcio::TrackerData* thisPulse);

      PulseTime calcPulseTimeFirstBinAboveThreshold(const lcio::TrackerData* thisPulse);

      PulseTime calcPulseTimeBoxMethod(const lcio::TrackerData* thisPulse);

      PulseTime  calcuPulseTimeGaussianInflexion(const lcio::TrackerData* thisPulse);
      PulseCharge calcPulseChargeSumQ(const lcio::TrackerData* thisPulse);

      PulseCharge calcPulseChargeMaxQ(const lcio::TrackerData* thisPulse);


      float getPedestalValue(const int hardware_channel, const int readout_group);



      float getPedestalWidth(const int hardware_channel, const int readout_group);



      bool isPedestalSubtracted(const int readout_group);



      int getPolarity(const int readout_group);



      float getReadoutFrequency(const int readout_group);



      float getMaxADCValue(const int readout_group);
  public:

      void setMaxADCValueOverride(float maxADCValue);

      void setPedestalValueOverride(float pedestalValue);

      void setPedestalWidthOverride(float pedestalWidth);
      
      void setReadoutFrequencyOverride(float readoutFrequency);

      void set_isPedestalSubtractedOverride(bool isPedestalSubtracted);

      void setPolarityOverride(int polarity);

      void setForceSpectrumSave(bool doSave = true);
 
      void setSwitchOffSplitting(bool doNotSplit = false);

      void setPlateauCutOff(int maxPlateauLength);

 // declare the tester as friend so we can unit-test the protected member functions
      friend class PulseFinderTester;
  };
}
#endif // PULSEFINDER_H