ClusterParamsAlgBase.h

Go to the documentation of this file.

#ifndef CLUSTERPARAMSALGBASE_H
#define CLUSTERPARAMSALGBASE_H

// C/C++ standard libraries
#include <stdexcept> // std::logic_error
#include <vector>
#include <algorithm> // std::transform()

// LArSoft libraries
#include "lardataobj/RecoBase/Hit.h"

namespace cluster {
  
  namespace details {
    
    template <typename T>
    class Measure_t: public std::pair<T, T> {
      using Base_t = std::pair<T, T>;
        public:
      using Data_t = T;
      
      Measure_t(): Base_t(Data_t(0), Data_t(0)) {}
      
      Measure_t(Data_t value): Base_t(value, Data_t(0)) {}
      
      Measure_t(Data_t value, Data_t error): Base_t(value, error) {}
      
      Data_t value() const { return Base_t::first; }
      Data_t& value() { return Base_t::first; }
      
      Data_t error() const { return Base_t::second; }
      Data_t& error() { return Base_t::second; }
    }; // Measure_t
    
  } // namespace details
  
  
  class ClusterParamsAlgBase {
      public:
    
    using Measure_t = details::Measure_t<float>;
    
    // no constructor provided for the abstract class
    
    virtual ~ClusterParamsAlgBase() {}
    
    
    virtual void Clear() {}
    
    
    virtual void SetHits(std::vector<recob::Hit const*> const& hits) = 0;
    
    virtual void SetHits(std::vector<recob::Hit> const& hits)
      {
        std::vector<recob::Hit const*> hitptrs;
        hitptrs.reserve(hits.size());
        std::transform(hits.begin(), hits.end(), std::back_inserter(hitptrs),
          [] (recob::Hit const& hit) { return &hit; });
        SetHits(hitptrs);
      }
    
    
    virtual void SetVerbose(int level = 1) { verbose = level; }
    
    

    virtual Measure_t StartCharge()       { throw NotImplemented(__func__); }
    virtual Measure_t EndCharge()         { throw NotImplemented(__func__); }
    

    virtual Measure_t StartAngle()        { throw NotImplemented(__func__); }
    virtual Measure_t EndAngle()          { throw NotImplemented(__func__); }
    

    virtual Measure_t StartOpeningAngle() { throw NotImplemented(__func__); }
    virtual Measure_t EndOpeningAngle()   { throw NotImplemented(__func__); }
    
    

    virtual Measure_t Integral()          { throw NotImplemented(__func__); }
    
    virtual Measure_t IntegralStdDev()    { throw NotImplemented(__func__); }
    
    virtual Measure_t SummedADC()         { throw NotImplemented(__func__); }
    
    virtual Measure_t SummedADCStdDev()   { throw NotImplemented(__func__); }
    
    
    
    virtual size_t NHits()                { throw NotImplemented(__func__); }
    
    
    virtual float MultipleHitDensity()      { throw NotImplemented(__func__); }
    
    virtual float Width()                 { throw NotImplemented(__func__); }
    
    
      protected:
    
    int verbose = 0; 
    
    static std::logic_error NotImplemented(std::string function_name)
      { return std::logic_error(function_name + "() not implemented."); }
    
  }; //class ClusterParamsAlgBase
  
} //namespace cluster

#endif // CLUSTERPARAMSALGBASE_H