TrigNavigationThinningSvc.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGNAVTOOLS_TRIGNAVIGATIONTHINNINGSVC_H
#define TRIGNAVTOOLS_TRIGNAVIGATIONTHINNINGSVC_H
 
#include "GaudiKernel/IIncidentListener.h"
#include "TrigNavigation/TriggerElement.h"
#include "TrigDecisionTool/TrigDecisionTool.h"
#include "AthenaBaseComps/AthService.h"
#include "AthenaKernel/ITrigNavigationThinningSvc.h"
 
namespace HLT {
  class NavigationCore;
}
 

class TrigNavigationThinningSvc : public extends<AthService, ITrigNavigationThinningSvc>
{
public:
  TrigNavigationThinningSvc( const std::string& name, ISvcLocator* pSvcLocator );
 
  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;
  
  virtual StatusCode doSlimming( const EventContext& /*ctx*/,
                                 std::vector<uint32_t>& slimmed_and_serialized ) const override;
  
 
private:
  ToolHandle<Trig::TrigDecisionTool> m_trigDecisionTool;
     
  std::vector<std::string> m_featureInclusionList;
  std::vector<std::string> m_featureExclusionList;
  std::set<std::string>    m_featureKeepSet; 
  std::set<std::string>    m_featureDropSet; 
 
  struct State
  {
    State (const EventContext& the_ctx,
           HLT::NavigationCore& the_navigation,
           std::vector<uint32_t>& the_destinationNavigation)
      : ctx (the_ctx),
        navigation (the_navigation),
        destinationNavigation (the_destinationNavigation)
    {}
    const EventContext& ctx;
    HLT::NavigationCore& navigation;
    std::vector<uint32_t>& destinationNavigation;
    std::vector<uint32_t> originalNavigation;
    std::set<HLT::te_id_type> tesToProtect;
  };
 
  std::vector<std::string> m_actions;
  typedef StatusCode (TrigNavigationThinningSvc::*Action)(State& state) const;
  std::map<std::string, Action> m_actionsMap;    
  std::string m_chainsRegex;
     
     
  bool m_report; 

  StatusCode lateFillConfiguration(State& state) const;
 

  StatusCode drop(State& state) const;
  StatusCode reload(State& state) const;

  StatusCode restore(State& state) const;

 
  StatusCode save(State& state) const;
 
  StatusCode print(State& state) const;
  StatusCode squeeze(State& state) const;

  StatusCode dropFeatures(State& state) const;
  StatusCode dropRoIs(State& state) const;
  StatusCode dropEmptyRoIs(State& state) const;
  StatusCode dropFeatureless(State& state) const;
  StatusCode dropInactive();
   
  StatusCode syncThinning(State& state) const;

  StatusCode dropChains(State& state) const;

  StatusCode removeTriggerElement(State& state,
                                  HLT::TriggerElement *te,
                                  bool propagateFeatures = true) const;
 

  StatusCode removeGhostTriggerElements(HLT::TriggerElement *te = 0);

  StatusCode removeFeaturelessTriggerElements(State& state, HLT::TriggerElement *te = 0);

  class TriggerElementFind {
  public:
    TriggerElementFind(const HLT::TriggerElement *te);
    bool operator()( const HLT::TriggerElement* te );
 
  private:
    unsigned int m_id;
    const HLT::TriggerElement *m_RoI;
  };

  StatusCode recursivelyRemoveNodesFromNavigation(HLT::TriggerElement *te);

  StatusCode removeFeatures( State& state,
                             const std::set<std::pair<CLID, uint16_t> >& doDelete) const;

  StatusCode retainFeatures(State& state,
                            const std::set<std::pair<CLID, uint16_t> >& toRetain) const;

  StatusCode removeTriggerElementFromVector(HLT::TriggerElement *te, std::vector<HLT::TriggerElement*>& v) const;

  bool toBeIncluded(State& state, HLT::TriggerElement *te, std::vector<std::string> *inclusionList, 
                    std::vector<std::string> *exclusionList);
  bool toBeIncluded(State& state, HLT::TriggerElement *te, std::vector<HLT::TriggerElement*> *inclusionList, 
                    std::vector<HLT::TriggerElement*> *exclusionList);

  StatusCode propagateFeaturesToChildren(const HLT::TriggerElement *te) const;
 
  // store the CLID and subtype ids of all the of the deleted features so we can
  // remove their holders from the navigation structure.
  //std::vector<std::pair<CLID, uint16_t> > *m_deletedFeatures;
 
  // internal functions
  //     virtual std::vector<HLT::TriggerElement*> *getTEsFromFailedChains();
  //     virtual std::vector<HLT::TriggerElement*> *getTEsFromChainGroup(const Trig::ChainGroup *cg);
  // internal data
};
 
 
#endif