SingleMatchSelector.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/trackFindingCDC/findlets/base/Findlet.h>
 
#include <tracking/trackFindingCDC/numerics/WeightComperator.h>
 
#include <tracking/trackFindingCDC/utilities/WeightedRelation.h>
#include <tracking/trackFindingCDC/utilities/StringManipulation.h>
 
#include <framework/core/ModuleParamList.h>
#include <framework/logging/Logger.h>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    template <class ACollectorItem, class ACollectionItem, class AComparer = std::less<const ACollectionItem*>>
    class SingleMatchSelector :
      public Findlet<WeightedRelation<ACollectorItem, const ACollectionItem>> {
    public:
      using WeightedRelationItem = WeightedRelation<ACollectorItem, const ACollectionItem>;
 
      using Super = Findlet<WeightedRelation<ACollectorItem, const ACollectionItem>>;
 
      void exposeParameters(ModuleParamList* moduleParamList, const std::string& prefix) override
      {
        Super::exposeParameters(moduleParamList, prefix);
 
        moduleParamList->addParameter(prefixed(prefix, "useOnlySingleBestCandidate"), m_param_useOnlySingleBestCandidate,
                                      "Use only the found candidate, if it is the only one. Otherwise, use the best one.",
                                      m_param_useOnlySingleBestCandidate);
      }
 
      void apply(std::vector<WeightedRelationItem>& weightedRelations) override
      {
        B2ASSERT("The relations need to be sorted for this selector!",
                 std::is_sorted(weightedRelations.begin(), weightedRelations.end()));
 
        // Build a map from collectionItem -> matched collectionItems with weight
        std::map<const ACollectionItem*, std::vector<WeightedRelationItem>, AComparer> collectionItemToMatchedMap;
 
        for (const WeightedRelationItem& relation : weightedRelations) {
          collectionItemToMatchedMap[relation.getTo()].push_back(relation);
        }
 
        // Clear all relations and start filling in only the ones which are valid
        weightedRelations.clear();
 
        for (const auto& collectionItemToMatches : collectionItemToMatchedMap) {
          const auto& matches = collectionItemToMatches.second;
 
          const auto& bestMatch = std::min_element(matches.begin(), matches.end(), GreaterWeight());
 
          const bool addBestMatch = matches.size() == 1 or not m_param_useOnlySingleBestCandidate;
 
          if (addBestMatch) {
            weightedRelations.push_back(*bestMatch);
          }
        }
 
        std::sort(weightedRelations.begin(), weightedRelations.end());
      }
 
      void setUseOnlySingleBestCandidate(bool useOnlySingleBestCandidate)
      {
        m_param_useOnlySingleBestCandidate = useOnlySingleBestCandidate;
      }
 
    private:
      bool m_param_useOnlySingleBestCandidate = true;
    };
  }
}