ClusterParamsAlgBase.h

Go to the documentation of this file.

#ifndef CLUSTERPARAMSALGBASE_H
#define CLUSTERPARAMSALGBASE_H

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

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

namespace util {
  class GeometryUtilities;
}

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>;

    virtual ~ClusterParamsAlgBase() = default;

    virtual void Clear() {}

    virtual void SetHitsFromPointers(util::GeometryUtilities const& gser,
                                     std::vector<recob::Hit const*> const& hits) = 0;

    virtual void SetHits(util::GeometryUtilities const& gser, 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; });
      SetHitsFromPointers(gser, hitptrs);
    }

    virtual void SetVerbose(int level = 1) { verbose = level; }


    virtual Measure_t StartCharge(util::GeometryUtilities const&)
    {
      throw NotImplemented(__func__);
    }
    virtual Measure_t EndCharge(util::GeometryUtilities const&) { 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(util::GeometryUtilities const&) { 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