IDC_OverlayCommon.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
/// Generic overlaying code for Identifiable Containers.
 
/// @author Tadej Novak
/// @author Andrei Gaponenko <agaponenko@lbl.gov>, 2006-2009
 
#include <string>
#include <typeinfo>
 
 
namespace Overlay
{
 
template <class Datum, class Alg>
void mergeChannelData(Datum &/* baseDatum */,
                      const Datum &/* additionalDatum */,
                      const Alg* /* algorithm */)
{
  throw std::logic_error("Merging of data on the same channel is not implemented for "
                 + std::string(typeid(Datum).name()));
}
 
 
template <bool usePool, typename Type, typename Collection, typename Alg>
void mergeCollectionsImpl(Collection *bkgCollection,
                      Collection *signalCollection,
                      Collection *outputCollection,
                      const Alg *algorithm,
                      DataPool<Type>* /*nothing*/)
{
  if (bkgCollection->identify() != signalCollection->identify()) {
    throw std::runtime_error("mergeCollections<>(): collection Id mismatch");
  }
 
  typedef typename Collection::base_value_type Datum;
  typedef typename Collection::size_type size_type;
 
  // Merge by copying ptrs from background and signal to output collection
  size_type ibkg = 0, isig = 0;
  while ((ibkg < bkgCollection->size()) || (isig < signalCollection->size())) {
    // The Datum that goes to the output at the end of this step.
    Datum *tmp{};
 
    if (isig == signalCollection->size()) {
      // just copy the remaining background digits
      bkgCollection->swapElement(ibkg++, nullptr, tmp);
    } else if (ibkg == bkgCollection->size()) {
      // just copy the remaining signal digits
      signalCollection->swapElement(isig++, nullptr, tmp);
    } else {
      // Need to decide which one goes first.
      // See comments in TRTDigitization.cxx about the assumption that id1<id2
      // <=> hash1<hash2
      if (signalCollection->at(isig)->identify() < bkgCollection->at(ibkg)->identify()) {
        signalCollection->swapElement(isig++, nullptr, tmp);
      } else if (bkgCollection->at(ibkg)->identify() < signalCollection->at(isig)->identify()) {
        bkgCollection->swapElement(ibkg++, nullptr, tmp);
      } else {
        // The hits are on the same channel.
        Datum *tmpBkg{};
        bkgCollection->swapElement(ibkg++, nullptr, tmpBkg);
        signalCollection->swapElement(isig++, nullptr, tmp);
        Overlay::mergeChannelData(*tmp, *tmpBkg, algorithm);
        if constexpr(!usePool){
          //If we use a pool it owns the elements
          delete tmpBkg;
        }
      }
    }
 
    outputCollection->push_back(tmp);
  } // <= while
}
 
template <typename Collection, typename Alg>
void mergeCollections(Collection *bkgCollection, Collection *signalCollection,
                      Collection *outputCollection, const Alg *algorithm) {
  return mergeCollectionsImpl<false, void>(
      bkgCollection, signalCollection, outputCollection, algorithm, nullptr);
}
 
template <typename Type, typename Collection, typename Alg>
void mergeCollections(Collection *bkgCollection, Collection *signalCollection,
                      Collection *outputCollection, const Alg *algorithm,
                      DataPool<Type> &dataItems) {
  return mergeCollectionsImpl<true>(bkgCollection, signalCollection,
                                    outputCollection, algorithm, &dataItems);
}
 
} // namespace Overlay