RemoveIsolatedSpacePoints_module.cc

Go to the documentation of this file.

// LArSoft libraries
#include "larexamples/Algorithms/RemoveIsolatedSpacePoints/SpacePointIsolationAlg.h"
#include "lardataobj/RecoBase/SpacePoint.h"
#include "larcore/Geometry/Geometry.h"

// framework libraries
#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h" // art::ValidHandle
#include "canvas/Utilities/InputTag.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "fhiclcpp/types/Atom.h"
#include "fhiclcpp/types/Table.h"

// C/C++ standard libraries
#include <vector>
#include <memory> // std::make_unique()


namespace lar {
  namespace example {
    
    class RemoveIsolatedSpacePoints: public art::EDProducer {
      
        public:
      
      struct Config {
        
        using Name    = fhicl::Name;
        using Comment = fhicl::Comment;
        
        fhicl::Atom<art::InputTag> spacePoints{
          Name("spacePoints"),
          Comment("the space points to be filtered")
          };
        
        fhicl::Table<SpacePointIsolationAlg::Config> isolation{
          Name("isolation"),
          Comment("settings for the isolation algorithm")
          };
        
      }; // Config
      
      using Parameters = art::EDProducer::Table<Config>;
      
      explicit RemoveIsolatedSpacePoints(Parameters const& config);
      
      
      virtual void produce(art::Event& event) override;
      
      
        private:
      art::InputTag spacePointsLabel; 
      
      SpacePointIsolationAlg isolAlg; 
      
    }; // class RemoveIsolatedSpacePoints
    
    
  } // namespace example
} // namespace lar



//------------------------------------------------------------------------------
//--- RemoveIsolatedSpacePoints
//--- 
lar::example::RemoveIsolatedSpacePoints::RemoveIsolatedSpacePoints
  (Parameters const& config)
  : spacePointsLabel(config().spacePoints())
  , isolAlg(config().isolation())
{
  consumes<std::vector<recob::SpacePoint>>(spacePointsLabel);
  produces<std::vector<recob::SpacePoint>>();
} // lar::example::RemoveIsolatedSpacePoints::RemoveIsolatedSpacePoints()


//------------------------------------------------------------------------------
void lar::example::RemoveIsolatedSpacePoints::produce(art::Event& event) {
  
  //
  // read the input
  //
  auto spacePointHandle
    = event.getValidHandle<std::vector<recob::SpacePoint>>(spacePointsLabel);
  
  //
  // set up the algorithm
  //
  auto const* geom = lar::providerFrom<geo::Geometry>();
  isolAlg.setup(*geom);
  
  //
  // run the algorithm
  //
  
  // the return value is a list of indices of non-isolated space points
  auto const& spacePoints = *spacePointHandle;
  std::vector<size_t> socialPointIndices
    = isolAlg.removeIsolatedPoints(spacePoints);
  
  //
  // extract and save the results
  //
  auto socialSpacePoints = std::make_unique<std::vector<recob::SpacePoint>>();
  
  socialSpacePoints->reserve(socialPointIndices.size()); // preallocate
  for (size_t index: socialPointIndices)
    socialSpacePoints->push_back(spacePoints[index]);
  
  mf::LogInfo("RemoveIsolatedSpacePoints")
    << "Found " << socialSpacePoints->size() << "/" << spacePoints.size()
    << " isolated space points in '" << spacePointsLabel.encode() << "'";
  
  event.put(std::move(socialSpacePoints));
  
} // lar::example::RemoveIsolatedSpacePoints::produce()


//------------------------------------------------------------------------------
DEFINE_ART_MODULE(lar::example::RemoveIsolatedSpacePoints)


//------------------------------------------------------------------------------