WeightedRelationCreator.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Oliver Frost                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/findlets/base/Findlet.h>
 
#include <tracking/trackFindingCDC/eventdata/utils/ClassMnemomics.h>
 
#include <tracking/trackFindingCDC/filters/base/RelationFilterUtil.h>
 
#include <tracking/trackFindingCDC/utilities/WeightedRelation.h>
 
#include <tracking/trackFindingCDC/utilities/StringManipulation.h>
#include <tracking/trackFindingCDC/utilities/Functional.h>
 
#include <framework/core/ModuleParamList.h>
#include <framework/logging/Logger.h>
 
#include <vector>
#include <string>
#include <algorithm>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    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;
    };
  }
}