SpacePointIsolationAlg.h

Go to the documentation of this file.

#ifndef LAREXAMPLES_ALGORITHMS_REMOVEISOLATEDSPACEPOINTS_SPACEPOINTISOLATIONALG_H
#define LAREXAMPLES_ALGORITHMS_REMOVEISOLATEDSPACEPOINTS_SPACEPOINTISOLATIONALG_H


// LArSoft libraries
#include "larexamples/Algorithms/RemoveIsolatedSpacePoints/PointIsolationAlg.h"
#include "lardataobj/RecoBase/SpacePoint.h"


// infrastructure and utilities
#include "cetlib/pow.h" // cet::square()
#include "fhiclcpp/types/Comment.h"
#include "fhiclcpp/types/Name.h"
#include "fhiclcpp/types/Atom.h"
#include "fhiclcpp/types/Table.h"
#include "fhiclcpp/ParameterSet.h"

// C/C++ standard libraries
#include <vector>
#include <type_traits> // std::decay_t<>, std::is_base_of<>
#include <memory> // std::unique_ptr<>


// forward declarations
namespace geo { class GeometryCore; }


namespace lar {
  namespace example {
    
    // BEGIN RemoveIsolatedSpacePoints group -----------------------------------

    class SpacePointIsolationAlg {
      
        public:
      using Coord_t = std::decay_t<decltype(recob::SpacePoint().XYZ()[0])>;
      
      
      struct Config {
        
        using Name = fhicl::Name;
        using Comment = fhicl::Comment;
        
        fhicl::Atom<double> radius{
          Name("radius"),
          Comment("the radius for the isolation [cm]")
        };
        
      }; // Config
      
      
      
      SpacePointIsolationAlg(Config const& config)
        : radius2(cet::square(config.radius()))
        {}
      
      SpacePointIsolationAlg(fhicl::ParameterSet const& pset)
        : SpacePointIsolationAlg(fhicl::Table<Config>(pset, {})())
        {}
      
      
      
      void setup(geo::GeometryCore const& geometry)
        { geom = &geometry; initialize(); }
      
      
      
      template <typename PointIter>
      std::vector<size_t> removeIsolatedPoints
        (PointIter begin, PointIter end) const
        {
          static_assert(
            std::is_base_of<recob::SpacePoint, std::decay_t<decltype(*begin)>>::value,
            "iterator does not point to recob::SpacePoint"
            );
          return isolationAlg->removeIsolatedPoints(begin, end);
        }
      
      
      std::vector<size_t> removeIsolatedPoints
        (std::vector<recob::SpacePoint> const& points) const
        { return removeIsolatedPoints(points.begin(), points.end()); }
      
      
      
        private:
      using PointIsolationAlg_t = PointIsolationAlg<Coord_t>;
      
      geo::GeometryCore const* geom = nullptr;
      
      Coord_t radius2; 
      
      std::unique_ptr<PointIsolationAlg_t> isolationAlg;
      
      void initialize();
      
      void fillAlgConfigFromGeometry
        (PointIsolationAlg_t::Configuration_t& config);
      
    }; // class SpacePointIsolationAlg
    
    
    //--------------------------------------------------------------------------
    //--- PositionExtractor<recob::SpacePoint>
    
    template <>
    struct PositionExtractor<recob::SpacePoint> {
      
      static double x(recob::SpacePoint const& p) { return p.XYZ()[0]; }
      
      static double y(recob::SpacePoint const& p) { return p.XYZ()[1]; }
      
      static double z(recob::SpacePoint const& p) { return p.XYZ()[2]; }
      
    }; // PositionExtractor<recob::SpacePoint>
    
    // END RemoveIsolatedSpacePoints group -------------------------------------
    
  } // namespace example
} // namespace lar
    




#endif // LAREXAMPLES_ALGORITHMS_REMOVEISOLATEDSPACEPOINTS_SPACEPOINTISOLATIONALG_H