PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/Root/EgammaIsolationSelectionAlg.cxx

@@ -58,9 +58,9 @@ namespace CP
   {
     for (const auto& sys : m_systematicsList.systematicsVector())
     {
-      xAOD::EgammaContainer *egammas = nullptr;
-      ANA_CHECK (m_egammasHandle.getCopy (egammas, sys));
-      for (xAOD::Egamma *egamma : *egammas)
+      const xAOD::EgammaContainer *egammas = nullptr;
+      ANA_CHECK (m_egammasHandle.retrieve (egammas, sys));
+      for (const xAOD::Egamma *egamma : *egammas)
       {
         if (m_preselection.getBool (*egamma))
         {

PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/PhotonAnalysisSequence.py

@@ -94,7 +94,6 @@ def makePhotonAnalysisSequence( dataType, workingPoint,
     addPrivateTool( alg, 'selectionTool', 'CP::EgammaIsGoodOQSelectionTool' )
     alg.selectionTool.Mask = xAOD.EgammaParameters.BADCLUSPHOTON
     seq.append( alg, inputPropName = 'particles',
-                outputPropName = 'particlesOut',
                 stageName = 'calibration',
                 metaConfig = {'selectionDecorNames' : [alg.selectionDecoration],
                               'selectionDecorCount' : [1]},
@@ -154,7 +153,7 @@ def makePhotonAnalysisSequence( dataType, workingPoint,
     alg.selectionDecoration = 'isolated' + postfix
     addPrivateTool( alg, 'selectionTool', 'CP::IsolationSelectionTool' )
     alg.selectionTool.PhotonWP = isolationWP
-    seq.append( alg, inputPropName = 'egammas', outputPropName = 'egammasOut',
+    seq.append( alg, inputPropName = 'egammas',
                 stageName = 'selection',
                 metaConfig = {'selectionDecorNames' : [alg.selectionDecoration],
                               'selectionDecorCount' : [1]} )

PhysicsAnalysis/Algorithms/FTagAnalysisAlgorithms/python/FTagAnalysisSequence.py

@@ -84,15 +84,14 @@ def makeFTagAnalysisSequence( seq, dataType, jetCollection,
         addPrivateTool( alg, 'selectionTool', 'CP::AsgPtEtaSelectionTool' )
         alg.selectionTool.minPt = minPt
         alg.selectionTool.maxEta = 2.5
-        alg.selectionDecoration = 'ftag_kin_select'
-        seq.append( alg, inputPropName = 'particles',
-                    outputPropName = 'particlesOut' )
+        alg.selectionDecoration = 'ftag_kin_select_' + btagger + '_' + btagWP
+        seq.append( alg, inputPropName = 'particles' )
 
         # Set up an algorithm that makes a view container using the selections
         # performed previously:
         alg = createAlgorithm( 'CP::AsgViewFromSelectionAlg',
                                'FTagKinViewFromSelectionAlg'+postfix )
-        alg.selection = [ 'ftag_kin_select' ]
+        alg.selection = [ 'ftag_kin_select_' + btagger + '_' + btagWP ]
         seq.append( alg, inputPropName = 'input', outputPropName = 'output',
                     stageName = 'selection' )
 
@@ -108,7 +107,6 @@ def makeFTagAnalysisSequence( seq, dataType, jetCollection,
         alg.preselection = preselection
     alg.selectionDecoration = 'ftag_select_' + btagger + '_' + btagWP + ',as_char'
     seq.append( alg, inputPropName = 'particles',
-                outputPropName = 'particlesOut',
                 stageName = 'selection' )
 
     if not noEfficiency and dataType != 'data':

PhysicsAnalysis/Algorithms/JetAnalysisAlgorithms/JetAnalysisAlgorithms/JetSelectionAlg.h

@@ -12,8 +12,8 @@
 #include <JetInterface/IJetSelector.h>
 #include <SelectionHelpers/ISelectionAccessor.h>
 #include <SelectionHelpers/SelectionReadHandle.h>
-#include <SystematicsHandles/SysCopyHandle.h>
 #include <SystematicsHandles/SysListHandle.h>
+#include <SystematicsHandles/SysReadHandle.h>
 #include <xAODJet/JetContainer.h>
 
 namespace CP
@@ -46,7 +46,7 @@ namespace CP
 
     /// \brief the jet collection we run on
   private:
-    SysCopyHandle<xAOD::JetContainer> m_jetHandle {
+    SysReadHandle<xAOD::JetContainer> m_jetHandle {
       this, "jets", "AntiKt4EMTopoJets", "the jet collection to run on"};
 
     /// \brief the preselection we apply to our input

PhysicsAnalysis/Algorithms/JetAnalysisAlgorithms/Root/JetSelectionAlg.cxx

@@ -56,9 +56,9 @@ namespace CP
   {
     for (const auto& sys : m_systematicsList.systematicsVector())
     {
-      xAOD::JetContainer *jets = nullptr;
-      ANA_CHECK (m_jetHandle.getCopy (jets, sys));
-      for (xAOD::Jet *jet : *jets)
+      const xAOD::JetContainer *jets = nullptr;
+      ANA_CHECK (m_jetHandle.retrieve (jets, sys));
+      for (const xAOD::Jet *jet : *jets)
       {
         if (m_preselection.getBool (*jet))
         {

PhysicsAnalysis/Algorithms/JetAnalysisAlgorithms/python/JetJvtAnalysisSequence.py

@@ -5,6 +5,8 @@ from AnaAlgorithm.AnaAlgSequence import AnaAlgSequence
 from AnaAlgorithm.DualUseConfig import createAlgorithm
 
 def makeJetJvtAnalysisSequence( dataType, jetCollection,
+                                preselection = '',
+                                systematicsAwarePreselection = '',
                                 enableFJvt = False,
                                 globalSF = True,
                                 runSelection = True,
@@ -37,6 +39,8 @@ def makeJetJvtAnalysisSequence( dataType, jetCollection,
     # Set up the per-event jet efficiency scale factor calculation algorithm
     if dataType != 'data' and globalSF:
         alg = createAlgorithm( 'CP::AsgEventScaleFactorAlg', 'JvtEventScaleFactorAlg' )
+        alg.preselection = preselection + '&&no_jvt' if preselection else 'no_jvt'
+        alg.inputSelectionDecoration = systematicsAwarePreselection
         alg.scaleFactorInputDecoration = 'jvt_effSF_%SYS%'
         alg.scaleFactorOutputDecoration = 'jvt_effSF_%SYS%'
 
@@ -47,6 +51,8 @@ def makeJetJvtAnalysisSequence( dataType, jetCollection,
 
         if enableFJvt:
             alg = createAlgorithm( 'CP::AsgEventScaleFactorAlg', 'ForwardJvtEventScaleFactorAlg' )
+            alg.preselection = preselection + '&&no_fjvt' if preselection else 'no_fjvt'
+            alg.inputSelectionDecoration = systematicsAwarePreselection
             alg.scaleFactorInputDecoration = 'fjvt_effSF_%SYS%'
             alg.scaleFactorOutputDecoration = 'fjvt_effSF_%SYS%'
 

PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/MuonAnalysisAlgorithms/MuonIsolationAlg.h

@@ -13,8 +13,8 @@
 #include <IsolationSelection/IIsolationSelectionTool.h>
 #include <SelectionHelpers/ISelectionAccessor.h>
 #include <SelectionHelpers/SelectionReadHandle.h>
-#include <SystematicsHandles/SysCopyHandle.h>
 #include <SystematicsHandles/SysListHandle.h>
+#include <SystematicsHandles/SysReadHandle.h>
 #include <xAODMuon/MuonContainer.h>
 
 namespace CP
@@ -47,7 +47,7 @@ namespace CP
 
     /// \brief the muon collection we run on
   private:
-    SysCopyHandle<xAOD::MuonContainer> m_muonHandle {
+    SysReadHandle<xAOD::MuonContainer> m_muonHandle {
       this, "muons", "Muons", "the muon collection to run on"};
 
     /// \brief the preselection we apply to our input

PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/MuonAnalysisAlgorithms/MuonSelectionAlg.h

@@ -11,8 +11,8 @@
 #include <MuonAnalysisInterfaces/IMuonSelectionTool.h>
 #include <SelectionHelpers/ISelectionAccessor.h>
 #include <SelectionHelpers/SelectionReadHandle.h>
-#include <SystematicsHandles/SysCopyHandle.h>
 #include <SystematicsHandles/SysListHandle.h>
+#include <SystematicsHandles/SysReadHandle.h>
 #include <xAODMuon/MuonContainer.h>
 
 namespace CP
@@ -50,7 +50,7 @@ namespace CP
 
     /// \brief the particle continer we run on
   private:
-    SysCopyHandle<xAOD::MuonContainer> m_muonsHandle {
+    SysReadHandle<xAOD::MuonContainer> m_muonsHandle {
       this, "muons", "Muons", "the muons collection to run on"};
 
     /// \brief the decoration for the quality selection

PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/Root/MuonIsolationAlg.cxx

@@ -60,9 +60,9 @@ namespace CP
   {
     for (const auto& sys : m_systematicsList.systematicsVector())
     {
-      xAOD::MuonContainer *muons = nullptr;
-      ANA_CHECK (m_muonHandle.getCopy (muons, sys));
-      for (xAOD::Muon *muon : *muons)
+      const xAOD::MuonContainer *muons = nullptr;
+      ANA_CHECK (m_muonHandle.retrieve (muons, sys));
+      for (const xAOD::Muon *muon : *muons)
       {
         if (m_preselection.getBool (*muon))
         {

PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/Root/MuonSelectionAlg.cxx

@@ -65,9 +65,9 @@ namespace CP
   {
     for (const auto& sys : m_systematicsList.systematicsVector())
     {
-      xAOD::MuonContainer *muons = nullptr;
-      ANA_CHECK (m_muonsHandle.getCopy (muons, sys));
-      for (xAOD::Muon *muon : *muons)
+      const xAOD::MuonContainer *muons = nullptr;
+      ANA_CHECK (m_muonsHandle.retrieve (muons, sys));
+      for (const xAOD::Muon *muon : *muons)
       {
         if (m_preselection.getBool (*muon))
         {

PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisAlgorithmsTest.py

@@ -58,6 +58,9 @@ def makeSequence (dataType) :
     ntupleMaker.Branches = [ 'AnalysisMuons_NOSYS.eta -> mu_eta',
                              'AnalysisMuons_NOSYS.phi -> mu_phi',
                              'AnalysisMuons_%SYS%.pt  -> mu_%SYS%_pt', ]
+    if dataType != 'data':
+        ntupleMaker.Branches += [ 'AnalysisMuons_%SYS%.muon_effSF_tight_%SYS% -> mu_%SYS%_effSF' ]
+    ntupleMaker.OutputLevel = 2  # For output validation
     algSeq += ntupleMaker
     treeFiller = createAlgorithm( 'CP::TreeFillerAlg', 'TreeFiller' )
     treeFiller.TreeName = 'muons'

PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisSequence.py

@@ -152,7 +152,7 @@ def makeMuonAnalysisSequence( dataType, workingPoint,
                                'MuonIsolationAlg' + postfix )
         addPrivateTool( alg, 'isolationTool', 'CP::IsolationSelectionTool' )
         alg.isolationDecoration = 'isolated_muon' + postfix + ',as_bits'
-        seq.append( alg, inputPropName = 'muons', outputPropName = 'muonsOut',
+        seq.append( alg, inputPropName = 'muons',
                     stageName = 'selection',
                     metaConfig = {'selectionDecorNames' : [alg.isolationDecoration],
                                   'selectionDecorNamesOutput' : [alg.isolationDecoration],

PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/Root/DiTauEfficiencyCorrectionsAlg.cxx

@@ -25,7 +25,6 @@ namespace CP
     , m_efficiencyCorrectionsTool ("TauAnalysisTools::DiTauEfficiencyCorrectionsTool", this)
   {
     declareProperty ("efficiencyCorrectionsTool", m_efficiencyCorrectionsTool, "the calibration and smearing tool we apply");
-    declareProperty ("scaleFactorDecoration", m_scaleFactorDecoration, "the decoration for the tau scale factor");
   }
 
 
@@ -38,10 +37,10 @@ namespace CP
       ANA_MSG_ERROR ("no scale factor decoration name set");
       return StatusCode::FAILURE;
     }
-    m_scaleFactorAccessor = std::make_unique<SG::AuxElement::Accessor<float> > (m_scaleFactorDecoration);
 
     ANA_CHECK (m_efficiencyCorrectionsTool.retrieve());
     ANA_CHECK (m_tauHandle.initialize (m_systematicsList));
+    ANA_CHECK (m_scaleFactorDecoration.initialize (m_systematicsList, m_tauHandle));
     ANA_CHECK (m_systematicsList.addSystematics (*m_efficiencyCorrectionsTool));
     ANA_CHECK (m_systematicsList.initialize());
     ANA_CHECK (m_preselection.initialize());
@@ -57,15 +56,17 @@ namespace CP
     for (const auto& sys : m_systematicsList.systematicsVector())
     {
       ANA_CHECK (m_efficiencyCorrectionsTool->applySystematicVariation (sys));
-      xAOD::DiTauJetContainer *taus = nullptr;
-      ANA_CHECK (m_tauHandle.getCopy (taus, sys));
-      for (xAOD::DiTauJet *tau : *taus)
+      const xAOD::DiTauJetContainer *taus = nullptr;
+      ANA_CHECK (m_tauHandle.retrieve (taus, sys));
+      for (const xAOD::DiTauJet *tau : *taus)
       {
         if (m_preselection.getBool (*tau))
         {
           double sf = 0;
           ANA_CHECK_CORRECTION (m_outOfValidity, *tau, m_efficiencyCorrectionsTool->getEfficiencyScaleFactor (*tau, sf));
-          (*m_scaleFactorAccessor) (*tau) = sf;
+          m_scaleFactorDecoration.set (*tau, sf, sys);
+        } else {
+          m_scaleFactorDecoration.set (*tau, invalidScaleFactor(), sys);
         }
       }
     }

PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/Root/DiTauTruthMatchingAlg.cxx

@@ -46,9 +46,9 @@ namespace CP
   {
     for (const auto& sys : m_systematicsList.systematicsVector())
     {
-      xAOD::DiTauJetContainer *taus = nullptr;
-      ANA_CHECK (m_tauHandle.getCopy (taus, sys));
-      for (xAOD::DiTauJet *tau : *taus)
+      const xAOD::DiTauJetContainer *taus = nullptr;
+      ANA_CHECK (m_tauHandle.retrieve (taus, sys));
+      for (const xAOD::DiTauJet *tau : *taus)
       {
         if (m_preselection.getBool (*tau))
         {

PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/Root/TauTruthMatchingAlg.cxx

@@ -46,9 +46,9 @@ namespace CP
   {
     for (const auto& sys : m_systematicsList.systematicsVector())
     {
-      xAOD::TauJetContainer *taus = nullptr;
-      ANA_CHECK (m_tauHandle.getCopy (taus, sys));
-      for (xAOD::TauJet *tau : *taus)
+      const xAOD::TauJetContainer *taus = nullptr;
+      ANA_CHECK (m_tauHandle.retrieve (taus, sys));
+      for (const xAOD::TauJet *tau : *taus)
       {
         if (m_preselection.getBool (*tau))
         {

PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/TauAnalysisAlgorithms/DiTauEfficiencyCorrectionsAlg.h

@@ -12,9 +12,9 @@
 #include <TauAnalysisTools/IDiTauEfficiencyCorrectionsTool.h>
 #include <SelectionHelpers/OutOfValidityHelper.h>
 #include <SelectionHelpers/SelectionReadHandle.h>
-#include <SystematicsHandles/SysCopyHandle.h>
 #include <SystematicsHandles/SysListHandle.h>
 #include <SystematicsHandles/SysReadHandle.h>
+#include <SystematicsHandles/SysWriteDecorHandle.h>
 #include <xAODTau/DiTauJetContainer.h>
 
 namespace CP
@@ -47,7 +47,7 @@ namespace CP
 
     /// \brief the tau collection we run on
   private:
-    SysCopyHandle<xAOD::DiTauJetContainer> m_tauHandle {
+    SysReadHandle<xAOD::DiTauJetContainer> m_tauHandle {
       this, "taus", "DiTauJets", "the tau collection to run on"};
 
     /// \brief the preselection we apply to our input
@@ -59,13 +59,10 @@ namespace CP
   private:
     OutOfValidityHelper m_outOfValidity {this};
 
-    /// \brief the decoration for the tau scale factor
+    /// \brief the decoration for the muon scale factor
   private:
-    std::string m_scaleFactorDecoration;
-
-    /// \brief the accessor for \ref m_scaleFactorDecoration
-  private:
-    std::unique_ptr<const SG::AuxElement::Accessor<float> > m_scaleFactorAccessor;
+    SysWriteDecorHandle<float> m_scaleFactorDecoration {
+      this, "scaleFactorDecoration", "", "the decoration for the di-tau efficiency scale factor"};
   };
 }
 

PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/TauAnalysisAlgorithms/DiTauTruthMatchingAlg.h

@@ -12,8 +12,8 @@
 #include <AnaAlgorithm/AnaAlgorithm.h>
 #include <TauAnalysisTools/IDiTauTruthMatchingTool.h>
 #include <SelectionHelpers/SelectionReadHandle.h>
-#include <SystematicsHandles/SysCopyHandle.h>
 #include <SystematicsHandles/SysListHandle.h>
+#include <SystematicsHandles/SysReadHandle.h>
 #include <xAODTau/DiTauJetContainer.h>
 
 namespace CP
@@ -46,7 +46,7 @@ namespace CP
 
     /// \brief the tau collection we run on
   private:
-    SysCopyHandle<xAOD::DiTauJetContainer> m_tauHandle {
+    SysReadHandle<xAOD::DiTauJetContainer> m_tauHandle {
       this, "taus", "DiTauJets", "the tau collection to run on"};
 
     /// \brief the preselection we apply to our input

PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/TauAnalysisAlgorithms/TauTruthMatchingAlg.h

@@ -12,8 +12,8 @@
 #include <AnaAlgorithm/AnaAlgorithm.h>
 #include <TauAnalysisTools/ITauTruthMatchingTool.h>
 #include <SelectionHelpers/SelectionReadHandle.h>
-#include <SystematicsHandles/SysCopyHandle.h>
 #include <SystematicsHandles/SysListHandle.h>
+#include <SystematicsHandles/SysReadHandle.h>
 #include <xAODTau/TauJetContainer.h>
 
 namespace CP
@@ -46,7 +46,7 @@ namespace CP
 
     /// \brief the tau collection we run on
   private:
-    SysCopyHandle<xAOD::TauJetContainer> m_tauHandle {
+    SysReadHandle<xAOD::TauJetContainer> m_tauHandle {
       this, "taus", "TauJets", "the tau collection to run on"};
 
     /// \brief the preselection we apply to our input

PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/python/DiTauAnalysisSequence.py

@@ -71,7 +71,7 @@ def makeDiTauAnalysisSequence( dataType, workingPoint,
     alg.scaleFactorDecoration = 'tau_effSF' + postfix
     # alg.outOfValidity = 2 #silent
     # alg.outOfValidityDeco = "bad_eff"
-    seq.append( alg, inputPropName = 'taus', outputPropName = 'tausOut',
+    seq.append( alg, inputPropName = 'taus',
                 stageName = 'efficiency' )
 
     # Set up the tau truth matching algorithm:
@@ -81,7 +81,7 @@ def makeDiTauAnalysisSequence( dataType, workingPoint,
         addPrivateTool( alg, 'matchingTool',
                         'TauAnalysisTools::DiTauTruthMatchingTool' )
         alg.matchingTool.WriteTruthTaus = 1
-        seq.append( alg, inputPropName = 'taus', outputPropName = 'tausOut',
+        seq.append( alg, inputPropName = 'taus',
                     stageName = 'selection' )
         pass
 

PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/python/TauAnalysisSequence.py

@@ -75,7 +75,7 @@ def makeTauAnalysisSequence( dataType, workingPoint, postfix = '',
         addPrivateTool( alg, 'matchingTool',
                         'TauAnalysisTools::TauTruthMatchingTool' )
         alg.matchingTool.WriteTruthTaus = 1
-        seq.append( alg, inputPropName = 'taus', outputPropName = 'tausOut',
+        seq.append( alg, inputPropName = 'taus',
                     stageName = 'selection' )
         pass