IDC_OverlayCommon.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 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 <algorithm>
#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 sortCollections, 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;
 
  if constexpr(sortCollections) {
    sortCollection(bkgCollection);
    sortCollection(signalCollection);
  }
 
  // 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
 
  if constexpr(sortCollections) {
    if (!std::is_sorted(outputCollection->begin(), outputCollection->end(), [](const Datum *a, const Datum *b) {
      return a->identify() < b->identify();
    })) {
      algorithm->msg(MSG::ERROR) << "Output collection not sorted" << endmsg;
      throw std::runtime_error("mergeCollections<>(): output collection not sorted");
    }
  }
}
 
template <typename Collection, typename Alg>
void mergeCollections(Collection *bkgCollection, Collection *signalCollection,
                      Collection *outputCollection, const Alg *algorithm) {
  return mergeCollectionsImpl<false, 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<false, true>(bkgCollection, signalCollection,
                                    outputCollection, algorithm, &dataItems);
}
 
template <typename Type, typename Collection, typename Alg>
void mergeSortedCollections(Collection *bkgCollection, Collection *signalCollection,
                            Collection *outputCollection, const Alg *algorithm,
                            DataPool<Type> &dataItems) {
  return mergeCollectionsImpl<true, true>(bkgCollection, signalCollection,
                                    outputCollection, algorithm, &dataItems);
}
 
} // namespace Overlay