FastReducer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGHLTJETHYPO_FASTREDUCER_H
#define TRIGHLTJETHYPO_FASTREDUCER_H
 
#include "./RepeatedConditionsDefs.h"
#include "./Tree.h"
#include "./JetGroupProduct.h"
#include "./xAODJetCollector.h"
#include "./ITrigJetHypoInfoCollector.h"
#include "./JetGroupRegister.h"
#include "./PointerPreds.h"
#include "./IHypoJetVectorFilter.h"
 
#include <string>
#include <map>
 
using TreeVec = std::vector<std::size_t>;
using IDJetGroup = std::map<std::size_t, HypoJetVector>;
typedef std::unique_ptr<ITrigJetHypoInfoCollector> Collector;
 
using JetGroupInd2ElemInds = std::map<int, std::vector<std::size_t>>;
 
using  ConditionFilters =
  std::vector<std::unique_ptr<IHypoJetVectorFilter>>;
 
using  ConditionFilterInds = std::vector<int>;
 
class FastReducer {
 public:
 
  FastReducer(const HypoJetVector& jv,
              const ConditionPtrs& conditionObjects,
          const ConditionFilters& conditionFilters,
          const ConditionFilterInds& conditionFilterInds,
              const Tree& conditionsTree,
              xAODJetCollector& jetCollector,
              const Collector& collector);
 
 
  bool pass() const;
 
  std::string toString() const;
 
 private:
 
  // conditions owned by the matcher
  const ConditionPtrs& m_conditions;
  std::vector<std::size_t> m_conditionMult;
  std::vector<unsigned int> m_conditionCap;
  std::vector<int> m_conditionClique;
 
  // conditionFilters owned by the matcher
  const ConditionFilters& m_conditionFilters;
  ConditionFilterInds m_conditionFilterInds;
 
  Tree m_tree;
 
  // map Condition index onto a list of indices of satisfying jet groups.
  CondInd2JetGroupsInds m_satisfiedBy;
 
  std::map<std::size_t, std::set<std::size_t>> m_testedBy;
 
  std::map<std::size_t, HypoJetVector> m_indJetGroup;
 
  JetGroupInd2ElemInds m_jg2elemjgs;
 
 
  bool m_pass{false};
 
  HypoJetVector m_passingJets;
 
  JetGroupRegister m_jgRegister;
  bool findInitialJetGroups(const HypoJetVector& jv,
                const Collector& collector);
  
  
  bool propagateJetGroups(const Collector& collector);
  
  
  bool propagate_(std::size_t child,
          const std::vector<std::size_t>& siblings,
          const Collector&);
  
  std::string dataStructuresToStr() const;
 
  void dumpDataStructures(const Collector&) const;
  
  void recordJetGroup(std::size_t ind,
              const HypoJetVector& jg,
              const Collector& collector) const;
 
  void recordFiltering(std::size_t leaf_ind,
               std::size_t n_inputjets,
               int n_filteredjets,
               const Collector& collector) const;
 
  void collectLeafJets(xAODJetCollector& jetCollector,
               const Collector& collector) const;
 
  bool capacitySatisfied(std::size_t ind,
             const Collector& collector) const;
};
#endif