OverlapResolver.icc.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <tracking/ckf/general/findlets/OverlapResolver.dcl.h>
 
#include <tracking/ckf/general/utilities/CKFFunctors.h>
 
#include <tracking/trackingUtilities/utilities/Functional.h>
#include <tracking/trackingUtilities/numerics/WeightComperator.h>
#include <tracking/trackingUtilities/utilities/Algorithms.h>
#include <tracking/trackingUtilities/utilities/VectorRange.h>
#include <tracking/trackingUtilities/utilities/StringManipulation.h>
 
#include <framework/core/ModuleParam.h>
#include <framework/logging/Logger.h>
 
namespace Belle2 {
  template<class AFilter>
  OverlapResolver<AFilter>::OverlapResolver() : Super()
  {
    Super::addProcessingSignalListener(&m_filter);
  }

  /// Expose the parameters of the subfindlet
  template<class AFilter>
  void OverlapResolver<AFilter>::exposeParameters(ModuleParamList* moduleParamList, const std::string& prefix)
  {
    m_filter.exposeParameters(moduleParamList, prefix);
 
    moduleParamList->addParameter(TrackingUtilities::prefixed(prefix, "enableOverlapResolving"),
                                  m_param_enableOverlapResolving,
                                  "Enable the overlap resolving.",
                                  m_param_enableOverlapResolving);
    moduleParamList->addParameter(TrackingUtilities::prefixed(prefix, "useBestNInSeed"),
                                  m_param_useBestNInSeed,
                                  "In seed mode, use only the best seeds.",
                                  m_param_useBestNInSeed);
  }
 
  template<class AFilter>
  void OverlapResolver<AFilter>::apply(std::vector<typename AFilter::Object>& results,
                                       std::vector<typename AFilter::Object>& filteredResults)
  {
    if (not m_param_enableOverlapResolving or results.empty()) {
      std::swap(results, filteredResults);
      return;
    }
 
    // Sort results by seed, as it makes the next operations faster
    std::sort(results.begin(), results.end(), TrackingUtilities::LessOf<SeedGetter>());
 
    // resolve overlaps in each seed separately
    const auto& groupedBySeed = TrackingUtilities::adjacent_groupby(results.begin(), results.end(), SeedGetter());
    for (const TrackingUtilities::VectorRange<Object>& resultsWithSameSeed : groupedBySeed) {
 
      m_resultsWithWeight.clear();
      for (Object& result : resultsWithSameSeed) {
        TrackingUtilities::Weight weight = m_filter(result);
        if (std::isnan(weight)) {
          continue;
        }
        m_resultsWithWeight.emplace_back(&result, weight);
      }
 
      if (not m_resultsWithWeight.empty()) {
        // sort results so that 'std::max' below picks path with highest weight if multiple paths have same size
        std::sort(m_resultsWithWeight.begin(), m_resultsWithWeight.end(), TrackingUtilities::GreaterWeight());
 
        const unsigned int useBestNResults = std::min(m_resultsWithWeight.size(), m_param_useBestNInSeed);
        const auto& lastItemToUse = std::next(m_resultsWithWeight.begin(), useBestNResults);
        const auto& longestElement = *(std::max_element(m_resultsWithWeight.begin(), lastItemToUse,
                                                        TrackingUtilities::LessOf<NumberOfHitsGetter>()));
        filteredResults.push_back(*(longestElement));
      }
    }
  }


}