FindAllP.h

Go to the documentation of this file.

#ifndef FINDALLP_H
#define FINDALLP_H 1

// C/C++ standard libraries
#include <climits>    // CHAR_BIT
#include <functional> // std::hash<>
#include <stdexcept>  // std::out_of_range
#include <unordered_map>
#include <vector>

// framework libraries
#include "art/Framework/Principal/Event.h"
#include "canvas/Persistency/Common/Assns.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Provenance/ProductID.h"
#include "canvas/Utilities/Exception.h"
#include "canvas/Utilities/InputTag.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

namespace lar {

  namespace util {

    namespace details {

      template <typename T>
      struct hash {
        using result_type = size_t;
        using argument_type = T;

        result_type operator()(argument_type const& v) const;

      }; // class hash<>

      template <typename Source, typename Dest>
      class UniqueAssociationCache {
      public:
        using Source_t = Source;
        using Dest_t = Dest;

        using SourcePtr_t = art::Ptr<Source_t>;
        using DestPtr_t = art::Ptr<Dest_t>;

        using InProductCache_t = std::vector<DestPtr_t>;

        using Hash_t = details::hash<art::ProductID>;

        using Cache_t = std::unordered_map<art::ProductID, InProductCache_t, Hash_t>;

        Cache_t AssnCache; 

        UniqueAssociationCache() = default;

        DestPtr_t operator[](SourcePtr_t const& src) const
        {
          return AssnCache[src.id()][src.key()];
        }

        void clear() { AssnCache.clear(); }

        size_t NProductIDs() const { return AssnCache.size(); }

      }; // class UniqueAssociationCache<>

      template <typename Source, typename Dest>
      class FindAllP {
      public:
        using Source_t = Source;
        using Dest_t = Dest;

        FindAllP() = default;

        FindAllP(art::Event& event) : FindAllP() { Read(event); }

        FindAllP(art::Event& event, art::InputTag assnTag) : FindAllP() { Read(event, assnTag); }

        art::Ptr<Dest_t> const& operator[](art::Ptr<Dest_t> const& src) const;

        bool hasProduct(art::ProductID const& id) const;

        bool hasProduct(art::Ptr<Source_t> const& ptr) const;

        unsigned int Read(art::Event& event);

        unsigned int Read(art::Event& event, art::InputTag const& assnTag);

        unsigned int Add(art::Event& event, art::InputTag const& assnTag);

      protected:
        using Assns_t = art::Assns<Source_t, Dest_t>;

        using Cache_t = UniqueAssociationCache<Source_t, Dest_t>;

        Cache_t cache; 

        unsigned int Merge(art::Handle<Assns_t>& handle);
      }; // class FindAllP<>

      template <typename T>
      void ResizeToPower2(std::vector<T>& v, size_t min_size);

    } // namespace details
  }   // namespace util
} // namespace lar

//******************************************************************************
//***  Template implementation
//******************************************************************************

namespace lar {
  namespace util {
    namespace details {
      //------------------------------------------------------------------------
      //---  FindAllP

      template <typename Source, typename Dest>
      auto FindAllP<Source, Dest>::operator[](art::Ptr<Dest_t> const& src) const
        -> art::Ptr<Dest_t> const&
      {
        // we expect a missing match to be exceptional
        try {
          return cache.AssnCache.at(src.id()).at(src.key());
        }
        catch (std::out_of_range) {
          return {};
        }
      } // FindAllP<>::operator[]

      template <typename Source, typename Dest>
      inline bool FindAllP<Source, Dest>::hasProduct(art::ProductID const& id) const
      {
        return cache.AssnCache.count(id) > 0;
      }

      template <typename Source, typename Dest>
      inline bool FindAllP<Source, Dest>::hasProduct(art::Ptr<Source_t> const& ptr) const
      {
        return hasProduct(ptr.id());
      }

      template <typename Source, typename Dest>
      unsigned int FindAllP<Source, Dest>::Read(art::Event& event)
      {

        // read all the associations between source and destination class types
        //std::vector<art::Handle<Assns_t>> assns_list;
        //event.getManyByType(assns_list);
        auto assns_list = event.getMany<Assns_t>();

        MF_LOG_DEBUG("FindAllP") << "Read(): read " << assns_list.size() << " association sets";

        unsigned int count = 0;
        // parse all the associations, and translate them into a local cache
        for (art::Handle<Assns_t> handle : assns_list)
          count += Merge(handle);

        MF_LOG_DEBUG("FindAllP") << "Read " << count << " associations for " << cache.NProductIDs()
                                 << " product IDs";

        return count;
      } // FindAllP::Read(Event)

      template <typename Source, typename Dest>
      unsigned int FindAllP<Source, Dest>::Read(art::Event& event, art::InputTag const& assnTag)
      {
        cache.clear();
        return Add(event, assnTag);
      } // FindAllP::Read(Event, InputTag)

      template <typename Source, typename Dest>
      unsigned int FindAllP<Source, Dest>::Add(art::Event& event, art::InputTag const& assnTag)
      {

        // read the association between source and destination class types
        art::Handle<Assns_t> handle;
        if (!event.getByLabel(assnTag, handle)) {
          throw art::Exception(art::errors::ProductNotFound)
            << "no association found with input tag '" << assnTag << "'";
        }

        return Merge(handle);
      } // FindAllP::Add(Event, InputTag)

      template <typename Source, typename Dest>
      unsigned int FindAllP<Source, Dest>::Merge(art::Handle<Assns_t>& handle)
      {
        // product ID of the last source object; initialized invalid
        art::ProductID LastProductID = art::Ptr<Source_t>().id();
        typename Cache_t::InProductCache_t const* AssnsList = nullptr;

        unsigned int count = 0;

        MF_LOG_DEBUG("FindAllP") << "Merge(): importing " << handle->size() << " associations from "
                                 << handle.provenance();

        for (auto const& assn : *handle) {
          // assn is a std::pair<art::Ptr<Source_t>, art::Ptr<Dest_t>>
          art::Ptr<Source_t> const& src = assn.first;

          if (src.isNull()) {
            MF_LOG_ERROR("FindAllP")
              << "Empty pointer found in association " << handle.provenance();
            continue; // this should not happen
          }

          art::Ptr<Dest_t> const& dest = assn.second;

          // if we have changed product (that should be fairly rare),
          // update the running pointers
          if (src.id() != LastProductID) {
            LastProductID = src.id();
            AssnsList = &(cache.AssnCache[LastProductID]);

            // if the list is empty, it means we have just created it!
            if (AssnsList->empty()) {
              // allocate enough space to accomodate all the associations,
              // (provided that source IDs are sequencial);
              // in fact typically all the associations in the same handle
              // have the same product ID
              ResizeToPower2(*AssnsList, handle->size());
            }
          } // if different product ID

          // make sure there is enough room in the vector
          typename art::Ptr<Source_t>::key_type key = src.key();
          if (key >= AssnsList->size()) ResizeToPower2(*AssnsList, key + 1);

          // store the association to dest
          art::Ptr<Dest_t>& dest_cell = (*AssnsList)[key];
          if (dest_cell.isNonnull() && (dest_cell != dest)) {
            throw art::Exception(art::errors::InvalidNumber)
              << "Object Ptr" << src << " is associated with at least two objects: " << dest
              << " and " << dest_cell;
          }
          dest_cell = dest;
          ++count;
        } // for all associations in a list

        MF_LOG_DEBUG("FindAllP") << "Merged " << count << " associations from "
                                 << handle.provenance();
        return count;
      } // FindAllP::Merge()

      //------------------------------------------------------------------------
      template <>
      auto hash<art::ProductID>::operator()(argument_type const& id) const -> result_type
      {
        // make sure we have enough bits in result_type;
        // if not, we need a more clever algorithm
        //static_assert(
        //  sizeof(id.processIndex()) + sizeof(id.productIndex())
        //    <= sizeof(result_type),
        //  "hash return type not large enough for hashing art::ProductID"
        //);
        // stack the process and product IDs in one integer
        //return result_type(
        //(id.processIndex() << sizeof(id.productIndex() * CHAR_BIT))
        //+ id.productIndex()
        //);
        return result_type(id.value());
      } // hash<art::ProductID>::operator()

      //------------------------------------------------------------------------
      template <typename T>
      void ResizeToPower2(std::vector<T>& v, size_t min_size)
      {
        if (min_size == 0) {
          v.clear();
          return;
        }
        size_t new_size = 1;
        while (new_size < min_size)
          new_size *= 2;

        v.resize(new_size);
      } // ResizeToPower2()

    } // namespace details
  }   // namespace util
} // namespace lar

//------------------------------------------------------------------------------
#endif // FINDALLP_H 1