ChargedSpacePoints.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_CHARGEDSPACEPOINTS_H
#define LARDATA_RECOBASEPROXY_CHARGEDSPACEPOINTS_H

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

// 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