PMTPulseRecoBase.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
//
//  PMTPulseRecoBase source
//
////////////////////////////////////////////////////////////////////////

#include "PMTPulseRecoBase.h"

#include <iostream>
#include <numeric>

namespace pmtana{

  //*************************************************************************
  PMTPulseRecoBase::PMTPulseRecoBase(const std::string name) : _name   (name)
                                                             , _status (true)
  //*************************************************************************
  { Reset(); }

  //***********************************************
  const std::string& PMTPulseRecoBase::Name() const
  //***********************************************
  { return _name; }

  //*****************************************
  bool PMTPulseRecoBase::Status() const
  //*****************************************
  { return _status; }

  //******************************************************************
  bool PMTPulseRecoBase::Reconstruct( const Waveform_t& wf,
                                      const PedestalMean_t& mean_v,
                                      const PedestalSigma_t& sigma_v )
  //******************************************************************
  {
    _status = this->RecoPulse(wf,mean_v,sigma_v);
    return _status;
  }

  //*****************************************************************************
  bool CheckIndex(const std::vector<short> &wf, const size_t &begin, size_t &end)
  //*****************************************************************************
  {
    if(begin >= wf.size() || end >= wf.size() || begin > end){

      std::cerr <<"Invalid arguments: waveform length = " << wf.size() << " begin = " << begin << " end = " << end << std::endl;

      return false;
    }

    if(!end) end = wf.size() - 1;

    return true;
  }

  //***************************************************************
  void PMTPulseRecoBase::Reset()
  //***************************************************************
  {
    _pulse.reset_param();

    _pulse_v.clear();

    _pulse_v.reserve(3);
  }

  //***************************************************************
  const pulse_param& PMTPulseRecoBase::GetPulse(size_t index) const
  //***************************************************************
  {

    if(index >= _pulse_v.size()) {

      std::cerr << "\033[93m"
                << "Invalid pulse index: " << index
                << "\033[00m"
                << std::endl;

      throw std::exception();
    }

    else return _pulse_v.at(index);

  }

  //***************************************************************
  const pulse_param_array& PMTPulseRecoBase::GetPulses() const
  //***************************************************************
  {
    return _pulse_v;
  }

  //***************************************************************
  bool PMTPulseRecoBase::Integral(const std::vector<short> &wf,
                                  double &result,
                                  size_t begin,
                                  size_t end) const
  //***************************************************************
  {

    if(!CheckIndex(wf,begin,end)) return false;

    std::vector<short>::const_iterator begin_iter(wf.begin());

    std::vector<short>::const_iterator end_iter(wf.begin());

    begin_iter = begin_iter + begin;

    end_iter = end_iter + end + 1;

    result = (double)(std::accumulate(begin_iter, end_iter, 0));

    return true;
  }

  //***************************************************************
  bool PMTPulseRecoBase::Derivative(const std::vector<short> &wf,
                                    std::vector<int32_t> &diff,
                                    size_t begin,
                                    size_t end) const
  //***************************************************************
  {

    if(CheckIndex(wf,begin,end)){

      diff.clear();
      diff.reserve(end - begin);

      for(size_t index = begin ; index <= end ; ++index)

        diff.push_back(wf.at(index+1) - wf.at(index));

      return true;
    }

    return false;

  }

  //***************************************************************
  size_t PMTPulseRecoBase::Max(const std::vector<short> &wf,
                               double &result,
                               size_t begin,
                               size_t end) const
  //***************************************************************
  {

    size_t target_index = wf.size() + 1;

    result = 0;

    if(CheckIndex(wf,begin,end)) {

      for(size_t index = begin; index <= end; ++index)

        if( result < wf.at(index)) { target_index = index; result = (double)(wf.at(index)); }

    }

    return target_index;

  }

  //***************************************************************
  size_t PMTPulseRecoBase::Min(const std::vector<short> &wf,
                               double &result,
                               size_t begin,
                               size_t end) const
  //***************************************************************
  {

    size_t target_index = wf.size() + 1;

    result = 4096;

    if(CheckIndex(wf,begin,end)) {

      for(size_t index = begin; index <= end; ++index)

        if( result > wf.at(index)) { target_index = index; result = (double)(wf.at(index)); }

    }

    return target_index;

  }
}