ChargedSpacePoints.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_CHARGEDSPACEPOINTS_H
#define LARDATA_RECOBASEPROXY_CHARGEDSPACEPOINTS_H


// LArSoft libraries
#include "lardata/RecoBaseProxy/ProxyBase.h" // proxy namespace
#include "lardataobj/RecoBase/SpacePoint.h"
#include "lardataobj/RecoBase/PointCharge.h"
#include "larcorealg/Geometry/geo_vectors_utils.h" // geo::vect namespace

// framework libraries


namespace proxy {
  
  //----------------------------------------------------------------------------
  
  struct ChargedSpacePoints {
    
    using SpacePointDataProduct_t = std::vector<recob::SpacePoint>;
    
    using ChargeTag = recob::PointCharge;
    
  }; // struct ChargedSpacePoints
  
  
  
  //--------------------------------------------------------------------------
  template <typename CollProxy>
  struct SpacePointWithCharge: public CollectionProxyElement<CollProxy> {
    
    using base_t = CollectionProxyElement<CollProxy>; 
    using base_t::base_t; // inherit constructors
    
      public:
    
    // --- BEGIN data object access --------------------------------------------
        
    recob::SpacePoint const& point() const { return base_t::operator*(); }
    
    // --- END data object access ----------------------------------------------
    
    recob::PointCharge const& chargeInfo() const
      { return base_t::template get<ChargedSpacePoints::ChargeTag>(); }
    
    // --- BEGIN space point access --------------------------------------------
    
    auto ID() const { return point().ID(); }
    
    geo::Point_t position() const
      { return geo::vect::makePointFromCoords(point().XYZ()); }
    
    // --- END space point access ----------------------------------------------
    
    
    // --- BEGIN charge access -------------------------------------------------
    
    recob::PointCharge::Charge_t charge() const
      { return chargeInfo().charge(); }
    
    bool hasCharge() const { return chargeInfo().hasCharge(); }
    
    // --- END charge access ---------------------------------------------------
    
    
  }; // SpacePointWithCharge<>
  
  
  //----------------------------------------------------------------------------
  template <typename MainColl, typename... AuxColl>
  class ChargedSpacePointsCollectionProxy
    : public CollectionProxyBase<SpacePointWithCharge, MainColl, AuxColl...>
  {
    using base_t
      = CollectionProxyBase<SpacePointWithCharge, MainColl, AuxColl...>;
    using base_t::base_t;
    
      public:
    
    auto const& spacePoints() const
      { return base_t::main(); }
    
    auto const& charges() const
      {
        return base_t::template get<ChargedSpacePoints::ChargeTag>().dataRef();
      }
    
  }; // ChargedSpacePointsCollectionProxy
  
  
  //----------------------------------------------------------------------------
  template <typename Tag = proxy::ChargedSpacePoints::ChargeTag>
  auto withCharge(art::InputTag inputTag)
    { return proxy::withParallelDataAs<recob::PointCharge, Tag>(inputTag); }
  
  
  template <typename Event, typename... Args>
  auto getChargedSpacePoints
    (Event const& event, art::InputTag inputTag, Args&&... withArgs)
    {
      return proxy::getCollection<ChargedSpacePoints>(
        event, inputTag, withCharge(inputTag), std::forward<Args>(withArgs)...
        );
    } // getChargedSpacePoints()
  
  
  //----------------------------------------------------------------------------
  template <>
  struct CollectionProxyMakerTraits<ChargedSpacePoints>
    : public
      CollectionProxyMakerTraits<ChargedSpacePoints::SpacePointDataProduct_t>
  {
    template <typename... Args>
    using collection_proxy_impl_t = ChargedSpacePointsCollectionProxy<Args...>;
  };
  
  //----------------------------------------------------------------------------
  
  
} // namespace proxy


#endif // LARDATA_RECOBASEPROXY_CHARGEDSPACEPOINTS_H