Merge branch 'analysis/event' into '21.2'

Add EventSelectionAnalysisSequence

See merge request atlas/athena!20254

DataQuality/GoodRunsLists/Root/GRLSelectorAlg.cxx

@@ -8,7 +8,7 @@
 #include "xAODEventInfo/EventInfo.h"
 
 GRLSelectorAlg::GRLSelectorAlg( const std::string& name, ISvcLocator* pSvcLocator ) : AnaAlgorithm( name, pSvcLocator )
-										    , m_grlTool("GoodRunsListSelectionTool")
+										    , m_grlTool("GoodRunsListSelectionTool", this)
 {
 
   declareProperty( "Tool", m_grlTool , "The GoodRunsListSelectionTool" );
@@ -48,5 +48,3 @@ StatusCode GRLSelectorAlg::execute() {
 
   return StatusCode::SUCCESS;
 }
-
-

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithmsDict.h

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /// @author Nils Krumnack
@@ -14,6 +14,7 @@
 #include <AsgAnalysisAlgorithms/AsgSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/AsgViewFromSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/AsgxAODNTupleMakerAlg.h>
+#include <AsgAnalysisAlgorithms/EventFlagSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/IsolationCloseByCorrectionAlg.h>
 #include <AsgAnalysisAlgorithms/KinematicHistAlg.h>
 #include <AsgAnalysisAlgorithms/ObjectCutFlowHistAlg.h>

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/EventFlagSelectionAlg.h

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/// @author Tadej Novak
+
+#ifndef ASG_ANALYSIS_ALGORITHMS__EVENT_FLAG_SELECTION_ALG_H
+#define ASG_ANALYSIS_ALGORITHMS__EVENT_FLAG_SELECTION_ALG_H
+
+#include <AnaAlgorithm/AnaAlgorithm.h>
+#include <SelectionHelpers/ISelectionAccessor.h>
+
+namespace CP
+{
+  /// \brief an algorithm for selecting events by flag
+  class EventFlagSelectionAlg final : public EL::AnaAlgorithm
+  {
+  public:
+    EventFlagSelectionAlg(const std::string &name,
+                          ISvcLocator *svcLoc = nullptr);
+
+    virtual StatusCode initialize() final;
+    virtual StatusCode execute() final;
+    virtual StatusCode finalize() final;
+
+  private:
+    /// \brief flags that we want to select events with
+    std::vector<std::string> m_selFlags;
+    
+    /// \brief invert flags
+    std::vector<bool> m_invertFlags;
+    
+    /// \brief a vector of accessors to read the flags
+    std::vector<std::unique_ptr<ISelectionAccessor>> m_accessors;
+
+    /// \brief counter for passed events
+    long long m_passed = 0;
+    
+    /// \brief counter for total events
+    long long m_total = 0;
+
+  };
+}
+
+#endif

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/selection.xml

@@ -6,6 +6,7 @@
    <class name="CP::AsgSelectionAlg" />
    <class name="CP::AsgViewSelectionAlg" />
    <class name="CP::AsgxAODNTupleMakerAlg" />
+   <class name="CP::EventFlagSelectionAlg" />
    <class name="CP::IsolationCloseByCorrectionAlg" />
    <class name="CP::KinematicHistAlg" />
    <class name="CP::ObjectCutFlowHistAlg" />

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/CMakeLists.txt

@@ -52,18 +52,31 @@ atlas_install_joboptions( share/*_jobOptions.py )
 atlas_install_scripts( share/*_eljob.py )
 
 if( XAOD_STANDALONE )
-   atlas_add_test( OverlapRemovalTestJobData
-      SCRIPT OverlapAlgorithmsTest_eljob.py --data-type data --unit-test
-      PROPERTIES TIMEOUT 300 )
-   atlas_add_test( OverlapRemovalTestJobFullSim
-      SCRIPT OverlapAlgorithmsTest_eljob.py --data-type mc --unit-test
-      PROPERTIES TIMEOUT 300 )
-   atlas_add_test( OverlapRemovalTestJobFastSim
-      SCRIPT OverlapAlgorithmsTest_eljob.py --data-type afii --unit-test
-      PROPERTIES TIMEOUT 300 )
+  atlas_add_test( EventAlgsTestJobData
+     SCRIPT EventAlgorithmsTest_eljob.py --data-type data --unit-test
+     PROPERTIES TIMEOUT 300 )
+  atlas_add_test( EventAlgsTestJobFullSim
+     SCRIPT EventAlgorithmsTest_eljob.py --data-type mc --unit-test
+     PROPERTIES TIMEOUT 300 )
+  atlas_add_test( EventAlgsTestJobFastSim
+     SCRIPT EventAlgorithmsTest_eljob.py --data-type afii --unit-test
+     PROPERTIES TIMEOUT 300 )
+  atlas_add_test( OverlapRemovalTestJobData
+     SCRIPT OverlapAlgorithmsTest_eljob.py --data-type data --unit-test
+     PROPERTIES TIMEOUT 400 )
+  atlas_add_test( OverlapRemovalTestJobFullSim
+     SCRIPT OverlapAlgorithmsTest_eljob.py --data-type mc --unit-test
+     PROPERTIES TIMEOUT 400 )
+  atlas_add_test( OverlapRemovalTestJobFastSim
+     SCRIPT OverlapAlgorithmsTest_eljob.py --data-type afii --unit-test
+     PROPERTIES TIMEOUT 400 )
 else()
+   atlas_add_test( EventAlgsTestJob
+      SCRIPT athena.py
+             AsgAnalysisAlgorithms/EventAlgorithmsTest_jobOptions.py
+      PROPERTIES TIMEOUT 300 )
    atlas_add_test( OverlapRemovalTestJob
       SCRIPT athena.py
              AsgAnalysisAlgorithms/OverlapAlgorithmsTest_jobOptions.py
-      PROPERTIES TIMEOUT 300 )
+      PROPERTIES TIMEOUT 400 )
 endif()

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/EventFlagSelectorAlg.cxx

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/// @author Tadej Novak
+
+#include <AsgAnalysisAlgorithms/EventFlagSelectionAlg.h>
+#include <xAODEventInfo/EventInfo.h>
+
+CP::EventFlagSelectionAlg::EventFlagSelectionAlg(const std::string &name,
+                                             ISvcLocator *svcLoc)
+  : EL::AnaAlgorithm(name, svcLoc)
+{
+  declareProperty ("selectionFlags", m_selFlags, "list of flags to use as selection criteria");
+  declareProperty ("invertFlags",    m_invertFlags, "toggles for inverting the selection (index-parallel to selectionFlags)");
+}
+
+StatusCode CP::EventFlagSelectionAlg::initialize()
+{
+  if (m_invertFlags.size() != m_selFlags.size() && !m_invertFlags.empty()) {
+    ATH_MSG_ERROR("Property invertFlags has different size to selectionFlags. Please check your configuration");
+    return StatusCode::FAILURE;
+  }
+
+  for (size_t index = 0; index < m_selFlags.size(); ++index) {
+    const std::string& thisflag = m_selFlags[index];
+    if (thisflag.empty()) {
+      ATH_MSG_ERROR("Empty string passed as selection flag!");
+      return StatusCode::FAILURE;
+    } else {
+      // Extend m_invertFlags until the size matches m_selectionFlags
+      // Only done in the case that m_invert was empty
+      if (m_invertFlags.size() < index + 1) { m_invertFlags.push_back(false); }
+
+      std::unique_ptr<ISelectionAccessor> accessor;
+      ANA_CHECK (makeSelectionAccessor (m_selFlags[index], accessor));
+      m_accessors.push_back(std::move(accessor));
+    }
+  }
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode CP::EventFlagSelectionAlg::execute()
+{
+  m_total++;
+
+  const xAOD::EventInfo *evtInfo = 0;
+  ANA_CHECK(evtStore()->retrieve(evtInfo, "EventInfo"));
+
+  bool passed = true;
+
+  for (size_t index = 0; index < m_selFlags.size(); ++index) {
+    // Test against the opposite of the invert value
+    bool testval = !m_invertFlags[index];
+    ATH_MSG_VERBOSE("Now testing flag \"" << m_selFlags[index] << "\" requiring value " << testval);
+
+    passed = passed && m_accessors[index]->getBool(*evtInfo) == testval;
+    if (!passed) {
+      ATH_MSG_VERBOSE("Event failed.");
+      setFilterPassed(false);
+      return StatusCode::SUCCESS;
+    }
+  }
+
+  m_passed++;
+  ATH_MSG_VERBOSE("Event passed all flags.");
+  setFilterPassed(true);
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode CP::EventFlagSelectionAlg::finalize()
+{
+  ATH_MSG_INFO("Events passing selection: " << m_passed << " / " << m_total);
+
+  return StatusCode::SUCCESS;
+}

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/python/EventSelectionAnalysisSequence.py

+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+#
+# @author Tadej Novak
+
+# AnaAlgorithm import(s):
+from AnaAlgorithm.AnaAlgSequence import AnaAlgSequence
+from AnaAlgorithm.DualUseConfig import createAlgorithm, addPrivateTool
+
+
+def makeEventSelectionAnalysisSequence( dataType,
+                                        runPrimaryVertexSelection = True,
+                                        runEventCleaning = False,
+                                        userGRLFiles = []):
+    """Create a basic event selection analysis algorithm sequence
+
+    Keyword arguments:
+      dataType -- The data type to run on ("data", "mc" or "afii")
+      runPrimaryVertexSelection -- whether to run primary vertex selection
+      runEventCleaning -- wether to run event cleaning
+      userGRLFiles -- a list of GRL files to select data from
+    """
+
+    if not dataType in ["data", "mc", "afii"] :
+        raise ValueError ("invalid data type: " + dataType)
+
+    # Create the analysis algorithm sequence object:
+    seq = AnaAlgSequence( "EventSelectionAnalysisSequence" )
+
+    if dataType == 'data':
+        grlFiles = userGRLFiles[:]
+
+        # Set up the GRL selection:
+        alg = createAlgorithm( 'GRLSelectorAlg', 'GRLSelectorAlg' )
+        addPrivateTool( alg, 'Tool', 'GoodRunsListSelectionTool' )
+        alg.Tool.GoodRunsListVec = grlFiles
+
+        seq.append( alg, inputPropName = None )
+
+    # Skip events with no primary vertex:
+    if runPrimaryVertexSelection:
+        alg = createAlgorithm( 'CP::VertexSelectionAlg',
+                               'PrimaryVertexSelectorAlg' )
+        alg.VertexContainer = 'PrimaryVertices'
+        alg.MinVertices = 1
+
+        seq.append( alg, inputPropName = None )
+
+    # Set up the event cleaning selection:
+    if runEventCleaning:
+        alg = createAlgorithm( 'CP::EventFlagSelectionAlg', 'EventFlagSelectorAlg' )
+        alg.selectionFlags = ['DFCommonJets_eventClean_LooseBad,as_char']
+
+        seq.append( alg, inputPropName = None )
+
+    # Return the sequence:
+    return seq

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/share/EventAlgorithmsTest_eljob.py

+#!/usr/bin/env python
+#
+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+#
+# @author Tadej Novak
+
+
+# Read the submission directory as a command line argument. You can
+# extend the list of arguments with your private ones later on.
+import optparse
+parser = optparse.OptionParser()
+parser.add_option( '-d', '--data-type', dest = 'data_type',
+                   action = 'store', type = 'string', default = 'data',
+                   help = 'Type of data to run over. Valid options are data, mc, afii' )
+parser.add_option( '-s', '--submission-dir', dest = 'submission_dir',
+                   action = 'store', type = 'string', default = 'submitDir',
+                   help = 'Submission directory for EventLoop' )
+parser.add_option( '-u', '--unit-test', dest='unit_test',
+                   action = 'store_true', default = False,
+                   help = 'Run the job in "unit test mode"' )
+( options, args ) = parser.parse_args()
+
+# Set up (Py)ROOT.
+import ROOT
+import os
+ROOT.xAOD.Init().ignore()
+
+# ideally we'd run over all of them, but we don't have a mechanism to
+# configure per-sample right now
+
+dataType = options.data_type
+
+inputfile = {"data": 'ASG_TEST_FILE_DATA',
+             "mc":   'ASG_TEST_FILE_MC',
+             "afii": 'ASG_TEST_FILE_MC_AFII'}
+
+if not dataType in ["data", "mc", "afii"] :
+    raise ValueError ("invalid data type: " + dataType)
+
+# Set up the sample handler object. See comments from the C++ macro
+# for the details about these lines.
+import os
+sh = ROOT.SH.SampleHandler()
+sh.setMetaString( 'nc_tree', 'CollectionTree' )
+sample = ROOT.SH.SampleLocal (dataType)
+sample.add (os.getenv (inputfile[dataType]))
+sh.add (sample)
+sh.printContent()
+
+# Create an EventLoop job.
+job = ROOT.EL.Job()
+job.sampleHandler( sh )
+job.options().setDouble( ROOT.EL.Job.optMaxEvents, 500 )
+
+# Config:
+GRLFiles = ['GoodRunsLists/data16_13TeV/20180129/data16_13TeV.periodAllYear_DetStatus-v89-pro21-01_DQDefects-00-02-04_PHYS_StandardGRL_All_Good_25ns.xml']
+
+# Import(s) needed for the job configuration.
+from AnaAlgorithm.AlgSequence import AlgSequence
+from AnaAlgorithm.DualUseConfig import createAlgorithm
+
+# Set up the main analysis algorithm sequence.
+algSeq = AlgSequence( 'AnalysisSequence' )
+
+# Set up the systematics loader/handler algorithm:
+algSeq += createAlgorithm( 'CP::SysListLoaderAlg', 'SysLoaderAlg' )
+algSeq.SysLoaderAlg.sigmaRecommended = 1
+
+# Include, and then set up the pileup analysis sequence:
+from AsgAnalysisAlgorithms.EventSelectionAnalysisSequence import \
+    makeEventSelectionAnalysisSequence
+eventSelectionSequence = \
+    makeEventSelectionAnalysisSequence( dataType, userGRLFiles=GRLFiles )
+algSeq += eventSelectionSequence
+
+# Set up an ntuple to check the job with:
+ntupleMaker = createAlgorithm( 'CP::AsgxAODNTupleMakerAlg', 'NTupleMaker' )
+ntupleMaker.TreeName = 'events'
+ntupleMaker.Branches = [
+    'EventInfo.runNumber   -> runNumber',
+    'EventInfo.eventNumber -> eventNumber',
+]
+ntupleMaker.systematicsRegex = '.*'
+algSeq += ntupleMaker
+
+# For debugging.
+print( algSeq )
+
+# Add all algorithms from the sequence to the job.
+for alg in algSeq:
+    job.algsAdd( alg )
+    pass
+
+# Set up an output file for the job:
+job.outputAdd( ROOT.EL.OutputStream( 'ANALYSIS' ) )
+
+# Find the right output directory:
+submitDir = options.submission_dir
+if options.unit_test:
+    import os
+    import tempfile
+    submitDir = tempfile.mkdtemp( prefix = 'evenTest_', dir = os.getcwd() )
+    os.rmdir( submitDir )
+    pass
+
+# Run the job using the direct driver.
+driver = ROOT.EL.DirectDriver()
+driver.submit( job, submitDir )

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/share/EventAlgorithmsTest_jobOptions.py

+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+#
+# @author Tadej Novak
+
+# Ideally we'd run over all of them, but we don't have a mechanism to
+# configure per-sample right now
+dataType = "data"
+#dataType = "mc"
+#dataType = "afii"
+inputfile = {"data": 'ASG_TEST_FILE_DATA',
+             "mc":   'ASG_TEST_FILE_MC',
+             "afii": 'ASG_TEST_FILE_MC_AFII'}
+
+# Set up the reading of the input file:
+import AthenaRootComps.ReadAthenaxAODHybrid
+theApp.EvtMax = 500
+testFile = os.getenv ( inputfile[dataType] )
+svcMgr.EventSelector.InputCollections = [testFile]
+
+# Config:
+GRLFiles = ['GoodRunsLists/data16_13TeV/20180129/data16_13TeV.periodAllYear_DetStatus-v89-pro21-01_DQDefects-00-02-04_PHYS_StandardGRL_All_Good_25ns.xml']
+
+# Import(s) needed for the job configuration.
+from AnaAlgorithm.AlgSequence import AlgSequence
+from AnaAlgorithm.DualUseConfig import createAlgorithm
+
+# Set up the main analysis algorithm sequence.
+algSeq = AlgSequence( 'AnalysisSequence' )
+
+# Set up the systematics loader/handler algorithm:
+algSeq += createAlgorithm( 'CP::SysListLoaderAlg', 'SysLoaderAlg' )
+algSeq.SysLoaderAlg.sigmaRecommended = 1
+
+# Include, and then set up the pileup analysis sequence:
+from AsgAnalysisAlgorithms.EventSelectionAnalysisSequence import \
+    makeEventSelectionAnalysisSequence
+eventSelectionSequence = \
+    makeEventSelectionAnalysisSequence( dataType, userGRLFiles=GRLFiles )
+algSeq += eventSelectionSequence
+
+# Set up an ntuple to check the job with:
+ntupleMaker = createAlgorithm( 'CP::AsgxAODNTupleMakerAlg', 'NTupleMaker' )
+ntupleMaker.TreeName = 'events'
+ntupleMaker.Branches = [
+    'EventInfo.runNumber   -> runNumber',
+    'EventInfo.eventNumber -> eventNumber',
+]
+ntupleMaker.systematicsRegex = '.*'
+algSeq += ntupleMaker
+
+# For debugging.
+print( algSeq )
+
+# Add all algorithms from the sequence to the job.
+athAlgSeq += algSeq
+
+# Set up a histogram output file for the job:
+ServiceMgr += CfgMgr.THistSvc()
+ServiceMgr.THistSvc.Output += [
+    "ANALYSIS DATAFILE='EventAlgorithmsTest.root' OPT='RECREATE'"
+    ]
+
+# Reduce the printout from Athena:
+include( "AthAnalysisBaseComps/SuppressLogging.py" )

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/src/components/AsgAnalysisAlgorithms_entries.cxx

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /// @author Nils Krumnack
@@ -13,6 +13,7 @@
 #include <AsgAnalysisAlgorithms/AsgSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/AsgViewFromSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/AsgxAODNTupleMakerAlg.h>
+#include <AsgAnalysisAlgorithms/EventFlagSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/IsolationCloseByCorrectionAlg.h>
 #include <AsgAnalysisAlgorithms/KinematicHistAlg.h>
 #include <AsgAnalysisAlgorithms/ObjectCutFlowHistAlg.h>
@@ -26,6 +27,7 @@ DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgLeptonTrackSelectionAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgSelectionAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgViewFromSelectionAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgxAODNTupleMakerAlg)
+DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, EventFlagSelectionAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, IsolationCloseByCorrectionAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, KinematicHistAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, ObjectCutFlowHistAlg)
@@ -40,6 +42,7 @@ DECLARE_FACTORY_ENTRIES(AsgAnalysisAlgorithms) {
   DECLARE_NAMESPACE_ALGORITHM (CP, AsgSelectionAlg)
   DECLARE_NAMESPACE_ALGORITHM (CP, AsgViewFromSelectionAlg)
   DECLARE_NAMESPACE_ALGORITHM (CP, AsgxAODNTupleMakerAlg)
+  DECLARE_NAMESPACE_ALGORITHM (CP, EventFlagSelectionAlg)
   DECLARE_NAMESPACE_ALGORITHM (CP, IsolationCloseByCorrectionAlg)
   DECLARE_NAMESPACE_ALGORITHM (CP, KinematicHistAlg)
   DECLARE_NAMESPACE_ALGORITHM (CP, ObjectCutFlowHistAlg)

PhysicsAnalysis/Algorithms/SelectionHelpers/Root/SelectionAccessorBits.cxx

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /// @author Nils Krumnack
@@ -25,37 +25,37 @@ namespace CP
 
 
   SelectionType SelectionAccessorBits ::
-  getBits (const xAOD::IParticle& particle) const
+  getBits (const SG::AuxElement& element) const
   {
-    return m_accessor (particle);
+    return m_accessor (element);
   }
 
 
 
   void SelectionAccessorBits ::
-  setBits (xAOD::IParticle& particle,
+  setBits (SG::AuxElement& element,
            SelectionType selection) const
   {
-    m_accessor (particle) = selection;
+    m_accessor (element) = selection;
   }
 
 
 
   bool SelectionAccessorBits ::
-  getBool (const xAOD::IParticle& particle) const
+  getBool (const SG::AuxElement& element) const
   {
-    return m_accessor (particle) == selectionAccept();
+    return m_accessor (element) == selectionAccept();
   }
 
 
 
   void SelectionAccessorBits ::
-  setBool (xAOD::IParticle& particle,
+  setBool (SG::AuxElement& element,
            bool selection) const
   {
     if (selection)
-      m_accessor (particle) = selectionAccept();
+      m_accessor (element) = selectionAccept();
     else
-      m_accessor (particle) = selectionAccept() ^ 0x1;
+      m_accessor (element) = selectionAccept() ^ 0x1;
   }
 }

PhysicsAnalysis/Algorithms/SelectionHelpers/Root/SelectionAccessorChar.cxx

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /// @author Nils Krumnack
@@ -25,9 +25,9 @@ namespace CP
 
 
   SelectionType SelectionAccessorChar ::
-  getBits (const xAOD::IParticle& particle) const
+  getBits (const SG::AuxElement& element) const
   {
-    if (m_accessor (particle))
+    if (m_accessor (element))
       return selectionAccept();
     else
       return 0;
@@ -36,29 +36,29 @@ namespace CP
 
 
   void SelectionAccessorChar ::
-  setBits (xAOD::IParticle& particle,
+  setBits (SG::AuxElement& element,
            SelectionType selection) const
   {
     if (selection == selectionAccept())
-      m_accessor (particle) = 1;
+      m_accessor (element) = 1;
     else
-      m_accessor (particle) = 0;
+      m_accessor (element) = 0;
   }
 
 
 
   bool SelectionAccessorChar ::
-  getBool (const xAOD::IParticle& particle) const
+  getBool (const SG::AuxElement& element) const
   {
-    return m_accessor (particle);
+    return m_accessor (element);
   }
 
 
 
   void SelectionAccessorChar ::
-  setBool (xAOD::IParticle& particle,
+  setBool (SG::AuxElement& element,
            bool selection) const
   {
-    m_accessor (particle) = selection;
+    m_accessor (element) = selection;
   }
 }

PhysicsAnalysis/Algorithms/SelectionHelpers/SelectionHelpers/ISelectionAccessor.h

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /// @author Nils Krumnack
@@ -8,8 +8,8 @@
 #ifndef SELECTION_HELPERS__I_SELECTION_ACCESSOR_H
 #define SELECTION_HELPERS__I_SELECTION_ACCESSOR_H
 
+#include <AthContainers/AuxElement.h>
 #include <SelectionHelpers/SelectionHelpers.h>
-#include <xAODBase/IParticle.h>
 #include <memory>
 
 class StatusCode;
@@ -43,20 +43,20 @@ namespace CP
     /// \brief get the selection decoration
   public:
     virtual SelectionType
-    getBits (const xAOD::IParticle& particle) const = 0;
+    getBits (const SG::AuxElement& element) const = 0;
 
     /// \brief set the selection decoration
   public:
-    virtual void setBits (xAOD::IParticle& particle,
+    virtual void setBits (SG::AuxElement& element,
                           SelectionType selection) const = 0;
 
     /// \brief get the selection decoration
   public:
-    virtual bool getBool (const xAOD::IParticle& particle) const = 0;
+    virtual bool getBool (const SG::AuxElement& element) const = 0;
 
     /// \brief set the selection decoration
   public:
-    virtual void setBool (xAOD::IParticle& particle,
+    virtual void setBool (SG::AuxElement& element,
                           bool selection) const = 0;
   };
 

PhysicsAnalysis/Algorithms/SelectionHelpers/SelectionHelpers/SelectionAccessorBits.h

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /// @author Nils Krumnack
@@ -26,18 +26,18 @@ namespace CP
 
   public:
     virtual SelectionType
-    getBits (const xAOD::IParticle& particle) const override;
+    getBits (const SG::AuxElement& element) const override;
 
   public:
-    virtual void setBits (xAOD::IParticle& particle,
+    virtual void setBits (SG::AuxElement& element,
                           SelectionType selection) const override;
 
   public:
     virtual bool
-    getBool (const xAOD::IParticle& particle) const override;
+    getBool (const SG::AuxElement& element) const override;
 
   public:
-    virtual void setBool (xAOD::IParticle& particle,
+    virtual void setBool (SG::AuxElement& element,
                           bool selection) const override;
 
 

PhysicsAnalysis/Algorithms/SelectionHelpers/SelectionHelpers/SelectionAccessorChar.h

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /// @author Nils Krumnack
@@ -26,18 +26,18 @@ namespace CP
 
   public:
     virtual SelectionType
-    getBits (const xAOD::IParticle& particle) const override;
+    getBits (const SG::AuxElement& element) const override;
 
   public:
-    virtual void setBits (xAOD::IParticle& particle,
+    virtual void setBits (SG::AuxElement& element,
                           SelectionType selection) const override;
 
   public:
     virtual bool
-    getBool (const xAOD::IParticle& particle) const override;
+    getBool (const SG::AuxElement& element) const override;
 
   public:
-    virtual void setBool (xAOD::IParticle& particle,
+    virtual void setBool (SG::AuxElement& element,
                           bool selection) const override;