Add CP::AsgUnionSelectionAlg

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithmsDict.h

@@ -17,6 +17,7 @@
 #include <AsgAnalysisAlgorithms/AsgLeptonTrackSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/AsgOriginalObjectLinkAlg.h>
 #include <AsgAnalysisAlgorithms/AsgSelectionAlg.h>
+#include <AsgAnalysisAlgorithms/AsgUnionSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/AsgViewFromSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/AsgxAODNTupleMakerAlg.h>
 #include <AsgAnalysisAlgorithms/EventFlagSelectionAlg.h>

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgUnionSelectionAlg.h

+/*
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+*/
+
+/// @author Tadej Novak
+
+#ifndef ASG_ANALYSIS_ALGORITHMS__UNION_SELECTION_ALG_H
+#define ASG_ANALYSIS_ALGORITHMS__UNION_SELECTION_ALG_H
+
+#include <AnaAlgorithm/AnaAlgorithm.h>
+#include <SelectionHelpers/SysReadSelectionHandle.h>
+#include <SelectionHelpers/ISelectionWriteAccessor.h>
+#include <SystematicsHandles/SysReadHandle.h>
+#include <SystematicsHandles/SysListHandle.h>
+#include <xAODBase/IParticleContainer.h>
+
+
+namespace CP
+{
+  /// \brief an algorithm for selection an union of objects that pass
+  /// at least one systematics
+
+  class AsgUnionSelectionAlg final : public EL::AnaAlgorithm
+  {
+    /// \brief the standard constructor
+  public:
+    AsgUnionSelectionAlg (const std::string& name,
+                          ISvcLocator* pSvcLocator);
+
+
+  public:
+    virtual StatusCode initialize () override;
+
+  public:
+    virtual StatusCode execute () override;
+    
+
+
+    /// \brief the systematics list we run and have containers
+  private:
+    SysListHandle m_systematicsList {this};
+
+    /// \brief the particle continer we run on
+  private:
+    SysReadHandle<xAOD::IParticleContainer> m_particlesHandle {
+      this, "particles", "", "the asg collection to run on"};
+
+    /// \brief the preselection we apply to our input
+  private:
+    SysReadSelectionHandle m_preselection {
+      this, "preselection", "", "the preselection to apply"};
+
+    /// \brief the decoration of the selection
+  private:
+    std::string m_selectionDecoration;
+
+    /// \brief the accessor for \ref m_selectionDecoration
+  private:
+    std::unique_ptr<ISelectionWriteAccessor> m_selectionAccessor;
+  };
+
+} // namespace CP
+
+#endif

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/selection.xml

@@ -10,6 +10,7 @@
    <class name="CP::AsgLeptonTrackSelectionAlg" />
    <class name="CP::AsgOriginalObjectLinkAlg" />
    <class name="CP::AsgSelectionAlg" />
+   <class name="CP::AsgUnionSelectionAlg" />
    <class name="CP::AsgViewFromSelectionAlg" />
    <class name="CP::AsgxAODNTupleMakerAlg" />
    <class name="CP::EventFlagSelectionAlg" />

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgSelectionAlg.cxx

@@ -33,22 +33,28 @@ namespace CP
 
   StatusCode AsgSelectionAlg ::
   initialize ()
+  {
+    if (!m_selectionTool.empty())
     {
       ANA_CHECK (m_selectionTool.retrieve());
       m_systematicsTool = dynamic_cast<ISystematicsTool*>(&*m_selectionTool);
       if (m_systematicsTool)
         ANA_CHECK (m_systematicsList.addSystematics (*m_systematicsTool));
+    }
       
     ANA_CHECK (m_particlesHandle.initialize (m_systematicsList));
     ANA_CHECK (m_preselection.initialize (m_systematicsList, m_particlesHandle, SG::AllowEmpty));
     ANA_CHECK (m_selectionHandle.initialize (m_systematicsList, m_particlesHandle));
     ANA_CHECK (m_systematicsList.initialize());
 
+    if (!m_selectionTool.empty())
+    {
       Root::TAccept blankAccept = m_selectionTool->getTAccept();
       // Just in case this isn't initially set up as a failure clear it this one
       // time. This only calls reset on the bitset
       blankAccept.clear();
       m_setOnFail = selectionFromAccept(blankAccept);
+    }
 
     return StatusCode::SUCCESS;
   }
@@ -68,14 +74,28 @@ namespace CP
       for (const xAOD::IParticle *particle : *particles)
       {
         if (m_preselection.getBool (*particle, sys))
+        {
+          if (!m_selectionTool.empty())
           {
             m_selectionHandle.setBits
               (*particle, selectionFromAccept (m_selectionTool->accept (particle)), sys);
           }
           else
+          {
+            m_selectionHandle.setBool (*particle, true, sys);
+          }
+        }
+        else
+        {
+          if (!m_selectionTool.empty())
           {
             m_selectionHandle.setBits (*particle, m_setOnFail, sys);
           }
+          else
+          {
+            m_selectionHandle.setBool (*particle, false, sys);
+          }
+        }
       }
     }
     return StatusCode::SUCCESS;

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgUnionSelectionAlg.cxx

+/*
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+*/
+
+/// @author Tadej Novak
+
+//
+// includes
+//
+
+#include <AsgAnalysisAlgorithms/AsgUnionSelectionAlg.h>
+
+#include <xAODBase/IParticle.h>
+
+//
+// method implementations
+//
+
+namespace CP
+{
+  AsgUnionSelectionAlg ::
+  AsgUnionSelectionAlg (const std::string& name, 
+                        ISvcLocator* pSvcLocator)
+    : AnaAlgorithm (name, pSvcLocator)
+  {
+    declareProperty ("selectionDecoration", m_selectionDecoration, "the decoration for the union selection");
+  }
+
+
+
+  StatusCode AsgUnionSelectionAlg ::
+  initialize ()
+  {
+    if (m_selectionDecoration.empty())
+    {
+      ANA_MSG_ERROR("Selection decoration can not be empty.");
+      return StatusCode::FAILURE;
+    }
+
+    ANA_CHECK (makeSelectionWriteAccessor (m_selectionDecoration, m_selectionAccessor));
+
+    ANA_CHECK (m_particlesHandle.initialize(m_systematicsList));
+    ANA_CHECK (m_preselection.initialize (m_systematicsList, m_particlesHandle));
+    ANA_CHECK (m_systematicsList.initialize());
+
+    return StatusCode::SUCCESS;
+  }
+
+
+
+  StatusCode AsgUnionSelectionAlg ::
+  execute ()
+  {
+    std::vector<bool> selections;
+
+    // first loop through systematics and define if particle passes each of them
+    for (const auto& sys : m_systematicsList.systematicsVector())
+    {
+      const xAOD::IParticleContainer *particles{};
+      ANA_CHECK (m_particlesHandle.retrieve (particles, sys));
+
+      if (selections.empty())
+      {
+        selections.resize(particles->size(), false);
+      }
+      else if (selections.size() != particles->size())
+      {
+        ANA_MSG_ERROR("All input containers should have the same size.");
+        return StatusCode::FAILURE;
+      }
+
+      for (size_t i{}; i < particles->size(); i++)
+      {
+        selections[i] = selections[i] || m_preselection.getBool (*particles->at(i), sys);
+      }
+    }
+
+    // Now decorate the selection decoration
+    // Looping over systematics is needed to ensure all containers are processed
+    for (const auto& sys : m_systematicsList.systematicsVector())
+    {
+      const xAOD::IParticleContainer *particles{};
+      ANA_CHECK (m_particlesHandle.retrieve (particles, sys));
+
+      for (size_t i{}; i < particles->size(); i++)
+      {
+        m_selectionAccessor->setBool (*particles->at(i), selections[i]);
+      }
+    }
+
+    return StatusCode::SUCCESS;
+  }
+
+} // namespace CP

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

@@ -16,6 +16,7 @@
 #include <AsgAnalysisAlgorithms/AsgLeptonTrackSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/AsgOriginalObjectLinkAlg.h>
 #include <AsgAnalysisAlgorithms/AsgSelectionAlg.h>
+#include <AsgAnalysisAlgorithms/AsgUnionSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/AsgViewFromSelectionAlg.h>
 #include <AsgAnalysisAlgorithms/AsgxAODNTupleMakerAlg.h>
 #include <AsgAnalysisAlgorithms/EventFlagSelectionAlg.h>
@@ -40,6 +41,7 @@ DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgEventScaleFactorAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgLeptonTrackSelectionAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgOriginalObjectLinkAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgSelectionAlg)
+DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgUnionSelectionAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgViewFromSelectionAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgxAODNTupleMakerAlg)
 DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, EventFlagSelectionAlg)
@@ -64,6 +66,7 @@ DECLARE_FACTORY_ENTRIES(AsgAnalysisAlgorithms) {
   DECLARE_NAMESPACE_ALGORITHM (CP, AsgLeptonTrackSelectionAlg)
   DECLARE_NAMESPACE_ALGORITHM (CP, AsgOriginalObjectLinkAlg)
   DECLARE_NAMESPACE_ALGORITHM (CP, AsgSelectionAlg)
+  DECLARE_NAMESPACE_ALGORITHM (CP, AsgUnionSelectionAlg)
   DECLARE_NAMESPACE_ALGORITHM (CP, AsgViewFromSelectionAlg)
   DECLARE_NAMESPACE_ALGORITHM (CP, AsgxAODNTupleMakerAlg)
   DECLARE_NAMESPACE_ALGORITHM (CP, EventFlagSelectionAlg)

PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/ElectronAnalysisSequence.py

@@ -290,7 +290,6 @@ def makeElectronWorkingPointSequence( seq, dataType, workingPoint,
     # Set up an algorithm used for decorating baseline electron selection:
     alg = createAlgorithm( 'CP::AsgSelectionAlg',
                            'ElectronSelectionSummary' + postfix )
-    addPrivateTool( alg, 'selectionTool', 'CP::AsgFlagSelectionTool' )
     alg.selectionDecoration = 'baselineSelection' + postfix + ',as_char'
     seq.append( alg, inputPropName = 'particles',
                 stageName = 'selection',

PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/PhotonAnalysisSequence.py

@@ -287,7 +287,6 @@ def makePhotonWorkingPointSequence( seq, dataType, workingPoint, postfix = '',
     # Set up an algorithm used for decorating baseline photon selection:
     alg = createAlgorithm( 'CP::AsgSelectionAlg',
                            'PhotonSelectionSummary' + postfix )
-    addPrivateTool( alg, 'selectionTool', 'CP::AsgFlagSelectionTool' )
     alg.selectionDecoration = 'baselineSelection' + postfix + ',as_char'
     seq.append( alg, inputPropName = 'particles',
                 stageName = 'selection',

PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisSequence.py

@@ -239,7 +239,6 @@ def makeMuonWorkingPointSequence( seq, dataType, workingPoint, postfix = '',
     # Set up an algorithm used for decorating baseline muon selection:
     alg = createAlgorithm( 'CP::AsgSelectionAlg',
                            'MuonSelectionSummary' + postfix )
-    addPrivateTool( alg, 'selectionTool', 'CP::AsgFlagSelectionTool' )
     alg.selectionDecoration = 'baselineSelection' + postfix + ',as_char'
     seq.append( alg, inputPropName = 'particles',
                 stageName = 'selection',

PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/python/TauAnalysisSequence.py

@@ -178,10 +178,9 @@ def makeTauWorkingPointSequence( seq, dataType, workingPoint, postfix = '',
     # Set up an algorithm used for decorating baseline tau selection:
     alg = createAlgorithm( 'CP::AsgSelectionAlg',
                            'TauSelectionSummary' + postfix )
-    addPrivateTool( alg, 'selectionTool', 'CP::AsgFlagSelectionTool' )
     alg.selectionDecoration = 'baselineSelection' + postfix + ',as_char'
     seq.append( alg, inputPropName = 'particles',
                 stageName = 'selection',
-                dynConfig = {'selectionTool.selectionFlags' : lambda meta : meta["selectionDecorNames"][:]} )
+                dynConfig = {'preselection' : lambda meta : "&&".join (meta["selectionDecorNames"])} )
 
     pass