SdSignalRecovery.h

Go to the documentation of this file.

#ifndef _SdSignalRecoveryKLT_SdSignalRecovery_h_
#define _SdSignalRecoveryKLT_SdSignalRecovery_h_

#include <fwk/VModule.h>
#include <utl/Trace.h>


namespace evt {
  class Event;
}

namespace sevt {
  class PMT;
  class Station;
}

namespace SdSignalRecoveryKLT {

  class SignalRecovery : public fwk::VModule {

  public:
    SignalRecovery() { }
    ~SignalRecovery() { }

    fwk::VModule::ResultFlag Init();
    fwk::VModule::ResultFlag Run(evt::Event& event);
    fwk::VModule::ResultFlag Finish() { return eSuccess; }

    struct SaturationFitInterface {
      SaturationFitInterface() { }
      // fitting vars
      double fSigma = 0;
      double fSigmaErr = 0;
      double fAmpl = 0;
      double fAmplErr = 0;
      double fx0 = 0;
      double fx0Err = 0;
      double fChi2 = 0;
      int fNdof = 0;

      // "phys" vars
      double fSignal = 0;
      double fSignalErr = 0;
      double fSignalErrNL = 0; //uncertainty from the Nl

      // init variables
      double fMaximum = 0;
      unsigned int fFirstBin = 0;
      unsigned int fFirstSatBin = 0;
      unsigned int fLastSatBin = 0;
      double fVEMPeak = 0;
      double fVEMCharge = 0;
      double fGainRatio = 0;

      double fUndershootValue = 0;
    };

    SignalRecovery(sevt::Station& station, const double distance, const double alt, const int satflag);

  private:
    struct NonLinearity {
      std::vector<double> fSignalLimits;
      std::vector<double> fAlpha;
      std::vector<double> fBeta;
    };

    bool RecoverSignal();
    double SaturationFitDriver(SaturationFitInterface& sfi) const;
    static void SaturationFitFnc(int& nPar, double* const grad,
                                 double& value, double* par, const int flag);
    double ComputeAmplitude(SaturationFitInterface& sfi) const;

    double RecoverSignalUndershoot(const utl::TraceI& dynodeTrace,  // high gain, low gain
                                   const utl::TraceI& anodeTrace,
                                   const int saturationValue) const;

    bool RecoverSignal(const sevt::PMT& pmt, SaturationFitInterface& sfi,
                       const int saturationValue);

    bool SetNonLinearityCurve(const NonLinearity& nL);

    static double fgVEMTrace[768];
    int fRecoverUnsaturatedSignal;

    NonLinearity fNonLinearity;
    NonLinearity fNonLinearityPlusSigma;
    NonLinearity fNonLinearityMinusSigma;

    REGISTER_MODULE("SdSignalRecoveryKLT", SignalRecovery);

  };

}


#endif