RelationFilterUtil.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/utilities/WeightedRelation.h>
#include <tracking/trackFindingCDC/utilities/Relation.h>
#include <tracking/trackFindingCDC/numerics/Weight.h>
 
#include <framework/datastore/StoreObjPtr.h>
#include <mdst/dataobjects/EventLevelTrackingInfo.h>
 
#include <tracking/ckf/pxd/entities/CKFToPXDState.h>
#include <tracking/ckf/svd/entities/CKFToSVDState.h>
 
#include <tracking/vxdHoughTracking/entities/VXDHoughState.h>
 
#include <framework/logging/Logger.h>
 
#include <vector>
#include <limits>
#include <algorithm>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    struct RelationFilterUtil {
      /* *@{*/
      template <class AObject, class ARelationFilter>
      static void appendUsing(ARelationFilter& relationFilter,
                              const std::vector<AObject*>& froms,
                              const std::vector<AObject*>& tos,
                              std::vector<WeightedRelation<AObject>>& weightedRelations,
                              unsigned int maximumNumberOfRelations = std::numeric_limits<unsigned int>::max())
      {
        for (AObject* from : froms) {
          StoreObjPtr<EventLevelTrackingInfo> m_eventLevelTrackingInfo;
 
          std::vector<AObject*> possibleTos = relationFilter.getPossibleTos(from, tos);
 
          for (AObject* to : possibleTos) {
            if (from == to) continue;
            Relation<AObject> relation(from, to);
            Weight weight = relationFilter(relation);
            if (std::isnan(weight)) continue;
            weightedRelations.emplace_back(from, weight, to);
 
            if (weightedRelations.size() == maximumNumberOfRelations) {
              B2WARNING("Relations Creator reached maximal number of items: skipping the event.");
              if (m_eventLevelTrackingInfo.isValid()) {
                if (std::is_base_of<AObject, CKFToPXDState>::value) {
                  m_eventLevelTrackingInfo->setPXDCKFAbortionFlag();
                } else if (std::is_base_of<AObject, CKFToSVDState>::value) {
                  m_eventLevelTrackingInfo->setSVDCKFAbortionFlag();
                } else if (std::is_base_of<AObject, vxdHoughTracking::VXDHoughState>::value) {
                  B2INFO("Skipping processing VXDHoughTracking track candidate, not setting AbortionFlag.");
                } else {
                  B2WARNING("Undefined class used for CKFStates. Could not set AbortionFlag.");
                }
              }
 
              weightedRelations.clear();
              return;
            }
          }
        }
        // sort everything afterwards
        std::sort(std::begin(weightedRelations), std::end(weightedRelations));
      }
      /* *@}*/
 
      template <class AObject, class ARelationFilter>
      static void appendUsing(ARelationFilter& relationFilter,
                              const std::vector<AObject*>& objects,
                              std::vector<WeightedRelation<AObject>>& weightedRelations)
      {
        appendUsing(relationFilter, objects, objects, weightedRelations);
      };
    };
  }
}