OverriddenClusterParamsAlg.h

Go to the documentation of this file.

#ifndef OVERRIDDENCLUSTERPARAMSALG_H
#define OVERRIDDENCLUSTERPARAMSALG_H

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

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



namespace cluster {
  
  namespace details {
    class MultiValue {
        public:
      using Measure_t = cluster::details::Measure_t<float>;
      
      // I can't believe I am writing this shit
      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;
    
    typedef enum {
      cpStartAngle,          
      cpEndAngle,            
      cpStartCharge,         
      cpEndCharge,           
      cpStartOpeningAngle,   
      cpEndOpeningAngle,     
      cpIntegral,            
      cpIntegralStdDev,      
      cpSummedADC,           
      cpSummedADCStdDev,     
      cpNHits,               
      cpMultipleHitDensity,    
      cpWidth,               
      NParameters            
    } ParameterType_t; 
    
    template <typename... Args>
    explicit OverriddenClusterParamsAlg(Args&&... args):
      algo(std::forward<Args>(args)...),
      values(NParameters)
      {}
    
    virtual ~OverriddenClusterParamsAlg() = default;
    
    
    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); }
    
    
    
    virtual void Clear() override { algo.Clear(); }
    
    
    virtual void SetHits(std::vector<recob::Hit const*> const& hits) override
      { algo.SetHits(hits); }
    
    virtual void SetHits(std::vector<recob::Hit> const& hits) override
      { algo.SetHits(hits); }
    
    
    virtual void SetVerbose(int level = 1) override
      { ClusterParamsAlgBase::SetVerbose(level); algo.SetVerbose(level); }
    
    
    

    virtual Measure_t StartCharge() override
      { return ReturnValue(cpStartCharge, &Algo_t::StartCharge); }
    virtual Measure_t EndCharge() override
      { return ReturnValue(cpEndCharge, &Algo_t::EndCharge); }
    

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

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

    virtual Measure_t Integral() override
      { return ReturnValue(cpIntegral, &Algo_t::Integral); }
    
    virtual Measure_t IntegralStdDev() override
      { return ReturnValue(cpIntegralStdDev, &Algo_t::IntegralStdDev); }
    
    virtual Measure_t SummedADC() override
      { return ReturnValue(cpSummedADC, &Algo_t::SummedADC); }
    
    virtual Measure_t SummedADCStdDev() override
      { return ReturnValue(cpSummedADCStdDev, &Algo_t::SummedADCStdDev); }
    
    
    
    virtual size_t NHits() override
      { return ReturnValue(cpNHits, &Algo_t::NHits); }
    
    
    virtual float MultipleHitDensity() override
      { return ReturnValue(cpMultipleHitDensity, &Algo_t::MultipleHitDensity); }
    
    virtual float Width() override
      { return ReturnValue(cpWidth, &Algo_t::Width); }
    
    
    
      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>
    auto ReturnValue(ParameterType_t param, Func func)
      -> decltype((algo.*func)())
      {
        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)();
      } // 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