WeightedRelationCreator.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/trackingUtilities/findlets/base/Findlet.h>
 
#include <tracking/trackingUtilities/eventdata/utils/ClassMnemomics.h>
 
#include <tracking/trackingUtilities/filters/base/RelationFilterUtil.h>
 
#include <tracking/trackingUtilities/utilities/WeightedRelation.h>
 
#include <tracking/trackingUtilities/utilities/StringManipulation.h>
#include <tracking/trackingUtilities/utilities/Functional.h>
 
#include <framework/core/ModuleParamList.h>
#include <framework/logging/Logger.h>
 
#include <vector>
#include <string>
#include <algorithm>
 
namespace Belle2 {
 
 
  namespace TrackingUtilities {

    template <class AObject, class ARelationFilter>
    class WeightedRelationCreator : public Findlet<AObject* const, WeightedRelation<AObject>> {
 
    private:
      using Super = Findlet<AObject, WeightedRelation<AObject> >;
 
    public:
      WeightedRelationCreator()
      {
        this->addProcessingSignalListener(&m_relationFilter);
      }

      std::string getDescription() final
      {
        return "Constructs geometrically constrained relations between " +
               getClassMnemomicParameterDescription((AObject*)nullptr) +
               " filter by some acceptance criterion.";
      }

      void exposeParameters(ModuleParamList* moduleParamList, const std::string& prefix) final
      {
        m_relationFilter.exposeParameters(moduleParamList, prefix);
        moduleParamList->addParameter(prefixed(prefix, "onlyBest"),
                                      m_param_onlyBest,
                                      "Maximal number of the best relation to keep from each " +
                                      getClassMnemomicParameterDescription((AObject*)nullptr),
                                      m_param_onlyBest);
      }

      void apply(const std::vector<AObject*>& inputObjects,
                 std::vector<WeightedRelation<AObject>>& weightedRelations) final
      {
 
        B2ASSERT("Expected the objects on which relations are constructed to be sorted",
                 std::is_sorted(inputObjects.begin(), inputObjects.end(), LessOf<Deref>()));
 
        RelationFilterUtil::appendUsing(m_relationFilter, inputObjects, weightedRelations);
 
        if (m_param_onlyBest > 0) {
          const int nMaxRepetitions = m_param_onlyBest;
          int nCurrentRepetitions = 1;
          auto sameFrom =
            [&nMaxRepetitions,
             &nCurrentRepetitions](const WeightedRelation<AObject>& relation,
          const WeightedRelation<AObject>& otherRelation) -> bool {
            if (relation.getFrom() == otherRelation.getFrom())
            {
              ++nCurrentRepetitions;
              return nCurrentRepetitions > nMaxRepetitions;
            } else
            {
              // cppcheck-suppress unreadVariable
              nCurrentRepetitions = 1;
              return false;
            }
          };
 
          auto itLast = std::unique(weightedRelations.begin(), weightedRelations.end(), sameFrom);
          weightedRelations.erase(itLast, weightedRelations.end());
        }
      }
 
    private:
      ARelationFilter m_relationFilter;

      int m_param_onlyBest = 0;
    };
  }
}