AssociationUtil.h

Go to the documentation of this file.

#ifndef ASSOCIATIONUTIL_H
#define ASSOCIATIONUTIL_H

// C/C++ standard libraries
#include <vector>
#include <string>
#include <utility> // std::move()

// framework libraries
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"
#include "canvas/Persistency/Common/Assns.h"
#include "canvas/Persistency/Provenance/ProductID.h" 
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Core/EDProducer.h"
#include "canvas/Persistency/Common/FindMany.h" 
#include "canvas/Persistency/Common/FindManyP.h" 
#include "canvas/Persistency/Common/FindOneP.h" 
#include "canvas/Persistency/Common/FindOne.h" 

namespace util {

  // see https://cdcvs.fnal.gov/redmine/projects/art/wiki/Inter-Product_References
  // for information about using art::Assns

  // MARK CreateAssn_01
  template<class PRODUCER, class T, class U>
  bool CreateAssn(PRODUCER const&        prod,
                  art::Event            &evt,
                  std::vector<T>   const&a,
                  art::Ptr<U>      const&b,
                  art::Assns<U,T>       &assn,
                  std::string           a_instance,
                  size_t                indx=UINT_MAX
                  );

  // MARK CreateAssn_02
  template<class PRODUCER, class T, class U> 
  inline bool CreateAssn(PRODUCER const&        prod,
                         art::Event            &evt, 
                         std::vector<T>   const&a,
                         art::Ptr<U>      const&b,
                         art::Assns<U,T>       &assn,
                         size_t                indx=UINT_MAX)
    { return CreateAssn(prod, evt, a, b, assn, std::string(), indx); }
        

  // MARK CreateAssn_03
  template<class PRODUCER, class T, class U>
  bool CreateAssn(
    PRODUCER        const& prod,
    art::Event           & evt,
    art::Ptr<T>     const& a,
    art::Ptr<U>     const& b,
    art::Assns<U,T>      & assn
    );
  
  // MARK CreateAssn_04
  template<class PRODUCER, class T, class U>
  bool CreateAssn(
    PRODUCER          const& prod,
    art::Event             & evt,
    std::vector<T>    const& a,
    art::PtrVector<U> const& b,
    art::Assns<T,U>        & assn,
    size_t                   indx = UINT_MAX
    );

  // method to create a 1 to many association, with the many being of type U
  // indx is the location in the input std::vector<T> of the object you wish to 
  // associate with the art::PtrVector<U>
  // MARK CreateAssn_05
  template<class PRODUCER, class T, class U>
  bool CreateAssn(
    PRODUCER                 const& prod,
    art::Event                    & evt,
    art::Ptr<T>              const& a,
    std::vector<art::Ptr<U>> const& b,
    art::Assns<T,U>               & assn
    );

  // MARK CreateAssn_06
  template<class PRODUCER, class T, class U>
  bool CreateAssn(
    PRODUCER                 const& prod,
    art::Event                    & evt,
    std::vector<T>           const& a,
    std::vector<art::Ptr<U>> const& b,
    art::Assns<T,U>               & assn,
    size_t                          indx = UINT_MAX
    );

  // MARK CreateAssn_07
  template<class PRODUCER, class T, class U>
  bool CreateAssn(
    PRODUCER        const& prod,
    art::Event           & evt,
    std::vector<T>  const& a,
    std::vector<U>  const& b,
    art::Assns<T,U>      & assn,
    size_t                 startU,
    size_t                 endU,
    size_t                 indx = UINT_MAX
    );

  // MARK CreateAssn_07a
  template<class PRODUCER, class T, class U>
  bool CreateAssn(
    PRODUCER        const& prod,
    art::Event           & evt,
    std::vector<T>  const& a,
    std::vector<U>  const& b,
    art::Assns<T,U>      & assn,
    std::vector<size_t> const& indices,
    size_t                 indx = UINT_MAX
    );

  // MARK CreateAssn_08
  template <typename PRODUCER, typename T, typename U, typename Iter>
  bool CreateAssn(
    PRODUCER        const& prod,
    art::Event           & evt,
    art::Assns<T,U>      & assn,
    size_t                 first_index,
    Iter                   from_second_index,
    Iter                   to_second_index
    );


  // MARK CreateAssnD_01
  // MARK CreateAssnD_01a
  template <typename PRODUCER, typename T, typename U, typename D>
  bool CreateAssnD(
    PRODUCER                      const& prod,
    art::Event                         & evt,
    art::Assns<T,U,D>                  & assn,
    size_t                               first_index,
    size_t                               second_index,
    typename art::Assns<T,U,D>::data_t&& data
    );
  // MARK CreateAssnD_01b
  template <typename PRODUCER, typename T, typename U, typename D>
  bool CreateAssnD(
    PRODUCER                           const& prod,
    art::Event                              & evt,
    art::Assns<T,U,D>                       & assn,
    size_t                                    first_index,
    size_t                                    second_index,
    typename art::Assns<T,U,D>::data_t const& data
    );

  
  // method to return all objects of type U that are not associated to 
  // objects of type T. Label is the module label that would have produced
  // the associations and likely the objects of type T
  // this method assumes there is a one to many relationship between T and U
  // for example if you want to get all recob::Hits
  // that are not associated to recob::Clusters
  // std::vector<const recob::Hit*> hits = FindUNotAssociatedToU<recob::Cluster>(art::Handle<recob::Hit>, ...);
  template<class T, class U> std::vector<const U*> FindUNotAssociatedToT(art::Handle<U>     b, 
                                                                                art::Event  const& evt,
                                                                                std::string const& label);

  // method to return all objects of type U that are not associated to 
  // objects of type T. Label is the module label that would have produced
  // the associations and likely the objects of type T
  // this method assumes there is a one to many relationship between T and U
  // for example if you want to get all recob::Hits
  // that are not associated to recob::Clusters
  // std::vector< art::Ptr<recob::Hit> > hits = FindUNotAssociatedToTP<recob::Cluster>(art::Handle<recob::Hit>, ...);
  template<class T, class U> std::vector< art::Ptr<U> > FindUNotAssociatedToTP(art::Handle<U>     b, 
                                                                                      art::Event  const& evt,
                                                                                      std::string const& label);

  // Methods make getting simple ART-independent association information.
  // --- GetAssociatedVectorOneI takes in a handle to an association, and a handle to a product on the event.
  //     The ouput is a vector of with the same number of entries as the handle to the product, containing an index
  //     to the location of one associated product in that product's collection.
  // --- GetAssociatedVectorOneP takes in a handle to an association, and a handle to a product on the event.
  //     The ouput is a vector of with the same number of entries as the handle to the product, containing a pointer
  //     to one associated product.
  // --- GetAssociatedVectorManyI takes in a handle to an association, and a handle to a product on the event.
  //     The ouput is a vector of with the same number of entries as the handle to the product, containing a vector 
  //     of indices that give the locations of all associated products in those products' collection.
  // --- GetAssociatedVectorManyP takes in a handle to an association, and a handle to a product on the event.
  //     The ouput is a vector of with the same number of entries as the handle to the product, containing a vector 
  //     of pointers to all associated products.

  template<class T,class U> std::vector<size_t> GetAssociatedVectorOneI(art::Handle< art::Assns<T,U> > h,
                                                                              art::Handle< std::vector<T> > index_p);
  template<class T,class U> std::vector<const U*> GetAssociatedVectorOneP(art::Handle< art::Assns<T,U> > h,
                                                                                 art::Handle< std::vector<T> > index_p);

  template<class T,class U> std::vector< std::vector<size_t> > GetAssociatedVectorManyI(art::Handle< art::Assns<T,U> > h,
                                                                                               art::Handle< std::vector<T> > index_p);
  template<class T,class U> std::vector< std::vector<const U*> > GetAssociatedVectorManyP(art::Handle< art::Assns<T,U> > h,
                                                                                                 art::Handle< std::vector<T> > index_p);


}// end namespace

//----------------------------------------------------------------------
// MARK CreateAssn_01
template<class PRODUCER, class T, class U>
bool util::CreateAssn(
  PRODUCER        const& prod,
  art::Event           & evt,
  std::vector<T>  const& a,
  art::Ptr<U>     const& b,
  art::Assns<U,T>      & assn,
  std::string            a_instance,
  size_t                 indx /* = UINT_MAX */
  )
{
  if (indx == UINT_MAX) indx = a.size()-1;
  
  try{
    art::ProductID aid = prod.template getProductID< std::vector<T>>( a_instance);
    art::Ptr<T> aptr(aid, indx, evt.productGetter(aid));
    assn.addSingle(b, aptr);
    return true;
  }
  catch(cet::exception &e){
    mf::LogWarning("AssociationUtil")
      << "unable to create requested art:Assns, exception thrown: " << e;
    return false;
  }
  
} // util::CreateAssn() [01]


//----------------------------------------------------------------------
// MARK CreateAssn_03
template<class PRODUCER, class T, class U>
bool util::CreateAssn(
  PRODUCER        const& /* prod */,
  art::Event           & /* evt */,
  art::Ptr<T>     const& a,
  art::Ptr<U>     const& b,
  art::Assns<U,T>      & assn
) {
  
  try{
    assn.addSingle(b, a);
  }
  catch(cet::exception &e){
    mf::LogWarning("AssociationUtil")
      << "unable to create requested art:Assns, exception thrown: " << e;
    return false;
  }
  
  return true;
} // util::CreateAssn() [03]


//----------------------------------------------------------------------
// MARK CreateAssn_04
template<class PRODUCER, class T, class U>
bool util::CreateAssn(
  PRODUCER          const& prod,
  art::Event             & evt,
  std::vector<T>    const& a,
  art::PtrVector<U> const& b,
  art::Assns<T,U>        & assn,
  size_t                   indx /* = UINT_MAX */
) {
  if(indx == UINT_MAX) indx = a.size() - 1;
  
  try{
    art::ProductID aid = prod.template getProductID< std::vector<T> >();
    art::Ptr<T> aptr(aid, indx, evt.productGetter(aid));
    for(art::Ptr<U> const& b_item: b) assn.addSingle(aptr, b_item);
  }
  catch(cet::exception &e){
    mf::LogWarning("AssociationUtil")
      << "unable to create requested art:Assns, exception thrown: " << e;
    return false;
  }
  
  return true;
} // util::CreateAssn() [04]

//----------------------------------------------------------------------
// MARK CreateAssn_05
template<class PRODUCER, class T, class U>
bool util::CreateAssn(
  PRODUCER                 const& /* prod */,
  art::Event                    & /* evt */,
  art::Ptr<T>              const& a,
  std::vector<art::Ptr<U>> const& b,
  art::Assns<T,U>               & assn
) {
  
  try{
    for (art::Ptr<U> const& b_item: b) assn.addSingle(a, b_item);
  }
  catch(cet::exception const& e){
    mf::LogWarning("AssociationUtil")
      << "unable to create requested art:Assns, exception thrown: " << e;
    return false;
  }
  
  return true;
} // util::CreateAssn() [05]

//----------------------------------------------------------------------
// MARK CreateAssn_06
template<class PRODUCER, class T, class U>
bool util::CreateAssn(
  PRODUCER                 const& prod,
  art::Event                    & evt,
  std::vector<T>           const& a,
  std::vector<art::Ptr<U>> const& b,
  art::Assns<T,U>               & assn,
  size_t                          indx /* = UINT_MAX */
) {
  
  if (indx == UINT_MAX) indx = a.size() - 1;
  
  try{
    art::ProductID aid = prod.template getProductID< std::vector<T> >();
    art::Ptr<T> aptr(aid, indx, evt.productGetter(aid));
    for (art::Ptr<U> const& b_item: b) assn.addSingle(aptr, b_item);
  }
  catch(cet::exception &e){
    mf::LogWarning("AssociationUtil")
      << "unable to create requested art:Assns, exception thrown: " << e;
    return false;
  }
  
  return true;
} // util::CreateAssn() [06]

//----------------------------------------------------------------------
// MARK CreateAssn_07
template<class PRODUCER, class T, class U>
bool util::CreateAssn(
  PRODUCER        const& prod,
  art::Event           & evt,
  std::vector<T>  const& a,
  std::vector<U>  const& /* b */,
  art::Assns<T,U>      & assn,
  size_t                 startU,
  size_t                 endU,
  size_t                 indx /* = UINT_MAX */
) {
  
  if(indx == UINT_MAX) indx = a.size() - 1;
  
  try{
    art::ProductID aid = prod.template getProductID< std::vector<T> >();
    art::ProductID bid = prod.template getProductID< std::vector<U> >();
    art::Ptr<T> aptr(aid, indx, evt.productGetter(aid));
    auto const* getter = evt.productGetter(bid); // I don't want to know what it is
    for(size_t i = startU; i < endU; ++i){
      art::Ptr<U> bptr(bid, i, getter);
      assn.addSingle(aptr, bptr);
    }
  }
  catch(cet::exception &e){
    mf::LogWarning("AssociationUtil")
      << "unable to create requested art:Assns, exception thrown: " << e;
    return false;
  }
  
  return true;
} // util::CreateAssn() [07]

//----------------------------------------------------------------------
// MARK CreateAssn_07a
template<class PRODUCER, class T, class U>
bool util::CreateAssn(
  PRODUCER        const& prod,
  art::Event           & evt,
  std::vector<T>  const& a,
  std::vector<U>  const& /* b */,
  art::Assns<T,U>      & assn,
  std::vector<size_t> const& indices,
  size_t                 indx /* = UINT_MAX */
) {
  
  if(indx == UINT_MAX) indx = a.size() - 1;
  
  try{
    art::ProductID aid = prod.template getProductID< std::vector<T> >();
    art::ProductID bid = prod.template getProductID< std::vector<U> >();
    art::Ptr<T> aptr(aid, indx, evt.productGetter(aid));
    auto const* getter = evt.productGetter(bid); // I don't want to know what it is
    for(size_t index: indices){
      art::Ptr<U> bptr(bid, index, getter);
      assn.addSingle(aptr, bptr);
    }
  }
  catch(cet::exception &e){
    mf::LogWarning("AssociationUtil")
      << "unable to create requested art:Assns, exception thrown: " << e;
    return false;
  }
  
  return true;
} // util::CreateAssn() [07a]

//----------------------------------------------------------------------
// MARK CreateAssn_08
template <typename PRODUCER, typename T, typename U, typename Iter>
bool util::CreateAssn(
  PRODUCER        const& prod,
  art::Event           & evt,
  art::Assns<T,U>      & assn,
  size_t                 first_index,
  Iter                   from_second_index,
  Iter                   to_second_index
) {
  
  try{
    // We need the "product ID" of what is going to become a data product.
    // The data product ID is unique for the combination of process, producer,
    // data type and product (instance) label.
    // 
    art::ProductID first_id = prod.template getProductID< std::vector<T> >();
    art::ProductID second_id = prod.template getProductID< std::vector<U> >();
    
    // we declare here that we want to associate the element first_index of the
    // (only) data product of type std::vector<T> with other objects.
    // This is the pointer to that element:
    art::Ptr<T> first_ptr(first_id, first_index, evt.productGetter(first_id));
    
    // we are going to associate that element in a with a number of elements
    // of the only data product of type std::vector<U>
    auto const* getter = evt.productGetter(second_id); // auto, spare me the details
    while (from_second_index != to_second_index) {
      art::Ptr<U> second_ptr(second_id, *from_second_index, getter);
      assn.addSingle(first_ptr, second_ptr);
      ++from_second_index;
    } // while
  }
  catch(cet::exception &e){
    mf::LogWarning("AssociationUtil")
      << "unable to create requested art:Assns, exception thrown: " << e;
    return false;
  }
  
  return true;
} // util::CreateAssn() [08]


//----------------------------------------------------------------------
// MARK CreateAssnD_01a
template <typename PRODUCER, typename T, typename U, typename D>
bool util::CreateAssnD(
  PRODUCER                      const& prod,
  art::Event                         & evt,
  art::Assns<T,U,D>                  & assn,
  size_t                               first_index,
  size_t                               second_index,
  typename art::Assns<T,U,D>::data_t&& data
) {
  
  try{
    // We need the "product ID" of what is going to become a data product.
    // The data product ID is unique for the combination of process, producer,
    // data type and product (instance) label.
    // 
    // we declare here that we want to associate the element first_index of the
    // (only) data product of type std::vector<T> with the other object
    art::ProductID first_id = prod.template getProductID< std::vector<T> >();
    art::Ptr<T> first_ptr(first_id, first_index, evt.productGetter(first_id));
    
    // the same to associate the element second_index of the (only)
    // data product of type std::vector<U> with the first object.
    art::ProductID second_id = prod.template getProductID< std::vector<U> >();
    art::Ptr<U> second_ptr
      (second_id, second_index, evt.productGetter(second_id));
    
    assn.addSingle(first_ptr, second_ptr, std::move(data));
  }
  catch(cet::exception &e){
    mf::LogWarning("AssociationUtil")
      << "unable to create requested art:Assns, exception thrown: " << e;
    return false;
  }
  
  return true;
} // util::CreateAssnD() [01a]

template <typename PRODUCER, typename T, typename U, typename D>
bool util::CreateAssnD(
  PRODUCER                           const& prod,
  art::Event                              & evt,
  art::Assns<T,U,D>                       & assn,
  size_t                                    first_index,
  size_t                                    second_index,
  typename art::Assns<T,U,D>::data_t const& data
) {
  
  try{
    // We need the "product ID" of what is going to become a data product.
    // The data product ID is unique for the combination of process, producer,
    // data type and product (instance) label.
    // 
    // we declare here that we want to associate the element first_index of the
    // (only) data product of type std::vector<T> with the other object
    art::ProductID first_id = prod.template getProductID< std::vector<T> >();
    art::Ptr<T> first_ptr(first_id, first_index, evt.productGetter(first_id));
    
    // the same to associate the element second_index of the (only)
    // data product of type std::vector<U> with the first object.
    art::ProductID second_id = prod.template getProductID< std::vector<U> >();
    art::Ptr<U> second_ptr
      (second_id, second_index, evt.productGetter(second_id));
    
    assn.addSingle(first_ptr, second_ptr, data);
  }
  catch(cet::exception &e){
    mf::LogWarning("AssociationUtil")
      << "unable to create requested art:Assns, exception thrown: " << e;
    return false;
  }
  
  return true;
} // util::CreateAssnD() [01b]


//----------------------------------------------------------------------
template<class T, class U> inline std::vector<const U*> util::FindUNotAssociatedToT(art::Handle<U>     b,
                                                                                    art::Event  const& evt,
                                                                                    std::string const& label)
{

  // Do a FindOne for type T for each object of type U
  // If the FindOne returns an invalid maybe ref, add the pointer
  // of object type U to the return vector

  std::vector<const U*> notAssociated;

  art::FindOne<T> fa(b, evt, label);

  for(size_t u = 0; u < b->size(); ++u){
    cet::maybe_ref<T const> t(fa.at(u));
    if( !t.isValid() ){
      art::Ptr<U> ptr(b, u);
      notAssociated.push_back(ptr.get());
    }
  }
//   
  return notAssociated;
}

//----------------------------------------------------------------------
template<class T, class U> inline std::vector< art::Ptr<U> > util::FindUNotAssociatedToTP(art::Handle<U>     b,
                                                                                          art::Event  const& evt,
                                                                                          std::string const& label)
{

  // Do a FindOneP for type T for each object of type U
  // If the FindOne returns an invalid maybe ref, add the pointer
  // of object type U to the return vector

  std::vector< art::Ptr<U> > notAssociated;

  art::FindOneP<T> fa(b, evt, label);

  for(size_t u = 0; u < b->size(); ++u){
    cet::maybe_ref<T const> t(fa.at(u));
    if( !t.isValid() ){
      art::Ptr<U> ptr(b, u);
      notAssociated.push_back(ptr);
    }
  }
  
  return notAssociated;
}



template<class T,class U> inline std::vector<size_t> util::GetAssociatedVectorOneI(art::Handle< art::Assns<T,U> > h,
                                                                                   art::Handle< std::vector<T> > index_p)
{
  std::vector<size_t> associated_index(index_p->size());
  for(auto const& pair : *h)
    associated_index.at(pair.first.key()) = pair.second.key();
  return associated_index;
}

template<class T,class U> inline std::vector<const U*> util::GetAssociatedVectorOneP(art::Handle< art::Assns<T,U> > h,
                                                                                     art::Handle< std::vector<T> > index_p)
{
  std::vector<const U*> associated_pointer(index_p->size());
  for(auto const& pair : *h)
    associated_pointer.at(pair.first.key()) = &(*(pair.second));
  return associated_pointer;
}

template<class T,class U> inline std::vector< std::vector<size_t> > util::GetAssociatedVectorManyI(art::Handle< art::Assns<T,U> > h,
                                                                                                   art::Handle< std::vector<T> > index_p)
{
  std::vector< std::vector<size_t> > associated_indices(index_p->size());
  for(auto const& pair : *h)
    associated_indices.at(pair.first.key()).push_back(pair.second.key());
  return associated_indices;
}

template<class T,class U> inline std::vector< std::vector<const U*> > util::GetAssociatedVectorManyP(art::Handle< art::Assns<T,U> > h,
                                                                                                     art::Handle< std::vector<T> > index_p)
{
  std::vector< std::vector<const U*> > associated_pointers(index_p->size());
  for(auto const& pair : *h)
    associated_pointers.at(pair.first.key()).push_back( &(*(pair.second)) );
  return associated_pointers;
}


#endif  //ASSOCIATIONUTIL_H