OverriddenClusterParamsAlg.h

Go to the documentation of this file.

#ifndef OVERRIDDENCLUSTERPARAMSALG_H
#define OVERRIDDENCLUSTERPARAMSALG_H

// C/C++ standard library
#include <bitset>
#include <type_traits> // std::is_base_of<>
#include <utility>     // std::forward<>
#include <vector>

// LArSoft libraries
#include "larreco/RecoAlg/ClusterRecoUtil/ClusterParamsAlgBase.h"

namespace cluster {
  namespace details {
    class MultiValue {
    public:
      using Measure_t = cluster::details::Measure_t<float>;

      union {
        Measure_t measure_value;
        float float_value;
        size_t size_t_value;
      };

      MultiValue() {}

      template <typename T>
      MultiValue& operator=(T);

      template <typename T>
      operator T() const;

    }; // MultiValue

  } // namespace details

  template <typename AlgoBase>
  class OverriddenClusterParamsAlg : public ClusterParamsAlgBase {
    static_assert(std::is_base_of<ClusterParamsAlgBase, AlgoBase>::value,
                  "OverriddenClusterParamsAlg template parameter must derive"
                  " from ClusterParamsAlgBase");

  public:
    using Algo_t = AlgoBase;
    using This_t = OverriddenClusterParamsAlg<AlgoBase>;
    using Measure_t = typename AlgoBase::Measure_t;

    enum ParameterType_t {
      cpStartAngle,         
      cpEndAngle,           
      cpStartCharge,        
      cpEndCharge,          
      cpStartOpeningAngle,  
      cpEndOpeningAngle,    
      cpIntegral,           
      cpIntegralStdDev,     
      cpSummedADC,          
      cpSummedADCStdDev,    
      cpNHits,              
      cpMultipleHitDensity, 
      cpWidth,              
      NParameters           
    };                      

    template <typename... Args>
    explicit OverriddenClusterParamsAlg(Args&&... args)
      : algo(std::forward<Args>(args)...), values(NParameters)
    {}

    This_t& OverrideParameter(ParameterType_t param, Measure_t value)
    {
      overridden_set.set((size_t)param);
      values[(size_t)param] = value;
      return *this;
    } // OverrideParameter()

    This_t& ReleaseParameter(ParameterType_t param)
    {
      overridden_set.set((size_t)param);
      return *this;
    }

    bool isOverridden(ParameterType_t param) const { return overridden_set.test((size_t)param); }


    void Clear() override { algo.Clear(); }

    void SetHitsFromPointers(util::GeometryUtilities const& gser,
                             std::vector<recob::Hit const*> const& hits) override
    {
      algo.SetHitsFromPointers(gser, hits);
    }

    void SetHits(util::GeometryUtilities const& gser, std::vector<recob::Hit> const& hits) override
    {
      algo.SetHits(gser, hits);
    }

    void SetVerbose(int level = 1) override
    {
      ClusterParamsAlgBase::SetVerbose(level);
      algo.SetVerbose(level);
    }



    Measure_t StartCharge(util::GeometryUtilities const& gser) override
    {
      return ReturnValue(cpStartCharge, &Algo_t::StartCharge, gser);
    }
    Measure_t EndCharge(util::GeometryUtilities const& gser) override
    {
      return ReturnValue(cpEndCharge, &Algo_t::EndCharge, gser);
    }


    Measure_t StartAngle() override { return ReturnValue(cpStartAngle, &Algo_t::StartAngle); }

    Measure_t EndAngle() override { return ReturnValue(cpEndAngle, &Algo_t::EndAngle); }


    Measure_t StartOpeningAngle() override
    {
      return ReturnValue(cpStartOpeningAngle, &Algo_t::StartOpeningAngle);
    }
    Measure_t EndOpeningAngle() override
    {
      return ReturnValue(cpEndOpeningAngle, &Algo_t::EndOpeningAngle);
    }


    Measure_t Integral() override { return ReturnValue(cpIntegral, &Algo_t::Integral); }

    Measure_t IntegralStdDev() override
    {
      return ReturnValue(cpIntegralStdDev, &Algo_t::IntegralStdDev);
    }

    Measure_t SummedADC() override { return ReturnValue(cpSummedADC, &Algo_t::SummedADC); }

    Measure_t SummedADCStdDev() override
    {
      return ReturnValue(cpSummedADCStdDev, &Algo_t::SummedADCStdDev);
    }


    size_t NHits() override { return ReturnValue(cpNHits, &Algo_t::NHits); }

    float MultipleHitDensity() override
    {
      return ReturnValue(cpMultipleHitDensity, &Algo_t::MultipleHitDensity);
    }

    float Width(util::GeometryUtilities const& gser) override
    {
      return ReturnValue(cpWidth, &Algo_t::Width, gser);
    }



  protected:
    using ValueFunction_t = float (Algo_t::*)();
    using MeasureFunction_t = Measure_t (Algo_t::*)();

    Algo_t algo; 

    std::vector<details::MultiValue> values; 
    std::bitset<NParameters> overridden_set; 

    template <typename Func, typename... Args>
    auto ReturnValue(ParameterType_t param, Func func, Args&&... args)
      -> decltype((algo.*func)(args...))
    {
      if (isOverridden(param)) {
        // convert here to the return type of the function
        // (even if we are not using that function, it still defines the type)
        return values[(size_t)param];
      }
      else
        return (algo.*func)(args...);
    } // ReturnValue()

  }; // class OverriddenClusterParamsAlg

} // namespace cluster

//==============================================================================
//===  Template implementation
//==============================================================================

namespace cluster {

  namespace details {

    // specialization: size_t
    template <>
    MultiValue& MultiValue::operator=(size_t value)
    {
      size_t_value = value;
      return *this;
    }

    template <>
    MultiValue::operator size_t() const
    {
      return size_t_value;
    }

    // specialization: float
    template <>
    MultiValue& MultiValue::operator=(float value)
    {
      float_value = value;
      return *this;
    }

    template <>
    MultiValue::operator float() const
    {
      return float_value;
    }

    // specialization: Measure_t
    template <>
    MultiValue& MultiValue::operator=(Measure_t value)
    {
      measure_value = value;
      return *this;
    }

    template <>
    MultiValue::operator MultiValue::Measure_t() const
    {
      return measure_value;
    }

  } // namespace details
} // namespace cluster

#endif // OVERRIDDENCLUSTERPARAMSALG_H