diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/ConfigAccumulator.py b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/ConfigAccumulator.py
index 2fe87717a5a8ae2b88b0c868704ff2d7f126dfe9..fd1178a73dd2db24014efc9a1622887f44ac1314 100644
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/ConfigAccumulator.py
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/ConfigAccumulator.py
@@ -150,14 +150,16 @@ class ConfigAccumulator :
return self._containerConfig[containerName].currentName()
- def wantCopy (self, containerName) :
+ def wantCopy (self, containerName, sourceName=None) :
"""ask whether we want/need a copy of the container
This usually only happens if no copy of the container has been
made yet and the copy is needed to allow modifications, etc.
"""
if containerName not in self._containerConfig :
- raise Exception ("unknown container: " + containerName)
+ if not sourceName :
+ raise Exception ("no source container for: " + containerName)
+ self._containerConfig[containerName] = ContainerConfig (containerName, sourceName)
return self._containerConfig[containerName].index == 0
diff --git a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithmsDict.h b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithmsDict.h
index 3d5a18672afb53b045895859459dd134211444b3..1e9853e213de38d2cd29d1bdee41982b0417d8fa 100644
--- a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithmsDict.h
+++ b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithmsDict.h
@@ -18,6 +18,7 @@
#include <AsgAnalysisAlgorithms/AsgLeptonTrackSelectionAlg.h>
#include <AsgAnalysisAlgorithms/AsgOriginalObjectLinkAlg.h>
#include <AsgAnalysisAlgorithms/AsgSelectionAlg.h>
+#include <AsgAnalysisAlgorithms/AsgShallowCopyAlg.h>
#include <AsgAnalysisAlgorithms/AsgUnionSelectionAlg.h>
#include <AsgAnalysisAlgorithms/AsgViewFromSelectionAlg.h>
#include <AsgAnalysisAlgorithms/AsgxAODNTupleMakerAlg.h>
diff --git a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgSelectionAlg.h b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgSelectionAlg.h
index f904499fdff221e6f4b738aefbf44e065babd92a..fb606c908dc14428f014db3d3e4f8bb28b4a6cbf 100644
--- a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgSelectionAlg.h
+++ b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgSelectionAlg.h
@@ -13,8 +13,9 @@
#include <PATCore/IAsgSelectionTool.h>
#include <SelectionHelpers/SysReadSelectionHandle.h>
#include <SelectionHelpers/SysWriteSelectionHandle.h>
-#include <SystematicsHandles/SysCopyHandle.h>
+#include <SystematicsHandles/SysReadHandle.h>
#include <SystematicsHandles/SysListHandle.h>
+#include <xAODBase/IParticleContainer.h>
namespace CP
{
@@ -73,7 +74,7 @@ namespace CP
/// \brief the particle continer we run on
private:
- SysCopyHandle<xAOD::IParticleContainer> m_particlesHandle {
+ SysReadHandle<xAOD::IParticleContainer> m_particlesHandle {
this, "particles", "", "the asg collection to run on"};
/// \brief the preselection we apply to our input
diff --git a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgShallowCopyAlg.h b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgShallowCopyAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..404f9deaa6309fd48ebd4d2bd8e1e410b6ad5945
--- /dev/null
+++ b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgShallowCopyAlg.h
@@ -0,0 +1,71 @@
+/*
+ Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+*/
+
+/// @author Nils Krumnack
+
+
+
+#ifndef ASG_ANALYSIS_ALGORITHMS__ASG_SHALLOW_COPY_ALG_H
+#define ASG_ANALYSIS_ALGORITHMS__ASG_SHALLOW_COPY_ALG_H
+
+#include <AnaAlgorithm/AnaAlgorithm.h>
+#include <xAODBase/IParticleContainer.h>
+#include <SystematicsHandles/SysReadHandle.h>
+#include <SystematicsHandles/SysWriteHandle.h>
+#include <SystematicsHandles/SysListHandle.h>
+#include <limits>
+
+namespace CP
+{
+ /// \brief create a shallow copy of an input contsainer
+ ///
+ /// This is a generic algorithm that works for all object types to
+ /// create a shallow copy (or one per systematic). This avoids the
+ /// need for every CP algorithm to be able to shallow copy its
+ /// inputs, just in case it happens to be first in the sequence...
+
+ class AsgShallowCopyAlg final : public EL::AnaAlgorithm
+ {
+ /// \brief the standard constructor
+ public:
+ AsgShallowCopyAlg (const std::string& name,
+ ISvcLocator* pSvcLocator);
+
+
+ public:
+ StatusCode initialize () override;
+
+ public:
+ StatusCode execute () override;
+
+
+ /// \brief the systematics list we run
+ private:
+ SysListHandle m_systematicsList {this};
+
+ /// \brief the input collection we run on
+ private:
+ SysReadHandle<xAOD::IParticleContainer> m_inputHandle {
+ this, "input", "", "the input collection to run on"};
+
+ /// \brief the output view container we produce
+ private:
+ SysWriteHandle<xAOD::IParticleContainer> m_outputHandle {
+ this, "output", "", "the output view container to produce"};
+
+ /// \brief the templated version of execute for a single systematic
+ private:
+ template<typename Type> StatusCode
+ executeTemplate (const CP::SystematicSet& sys);
+
+ /// \brief the version of execute to find the type
+ private:
+ StatusCode executeFindType (const CP::SystematicSet& sys);
+
+ private:
+ StatusCode (AsgShallowCopyAlg::* m_function) (const CP::SystematicSet& sys) {&AsgShallowCopyAlg::executeFindType};
+ };
+}
+
+#endif
diff --git a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/selection.xml b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/selection.xml
index 2fdabe51a0439e2de18ed27bd63db38e7b9c2f95..d01e7e8f1ffd8dad45c9a12c16f33a2715322253 100644
--- a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/selection.xml
+++ b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/selection.xml
@@ -10,6 +10,7 @@
<class name="CP::AsgLeptonTrackSelectionAlg" />
<class name="CP::AsgOriginalObjectLinkAlg" />
<class name="CP::AsgPriorityDecorationAlg" />
+ <class name="CP::AsgShallowCopyAlg" />
<class name="CP::AsgSelectionAlg" />
<class name="CP::AsgUnionSelectionAlg" />
<class name="CP::AsgViewFromSelectionAlg" />
diff --git a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgSelectionAlg.cxx b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgSelectionAlg.cxx
index d62c1c6b59cff1abbf51405119d4b1d84c260b02..c9fbfe3de137f8d495d1953d1387361514cdc1de 100644
--- a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgSelectionAlg.cxx
+++ b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgSelectionAlg.cxx
@@ -70,7 +70,7 @@ namespace CP
ANA_CHECK (m_systematicsTool->applySystematicVariation (sys));
const xAOD::IParticleContainer *particles = nullptr;
- ANA_CHECK (m_particlesHandle.getCopy (particles, sys));
+ ANA_CHECK (m_particlesHandle.retrieve (particles, sys));
for (const xAOD::IParticle *particle : *particles)
{
if (m_preselection.getBool (*particle, sys))
diff --git a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgShallowCopyAlg.cxx b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgShallowCopyAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d2df0cc2ed32f736e888e075a74dd1f0c7e47744
--- /dev/null
+++ b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgShallowCopyAlg.cxx
@@ -0,0 +1,141 @@
+/*
+ Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+*/
+
+/// @author Nils Krumnack
+
+
+
+//
+// includes
+//
+
+#include <AsgAnalysisAlgorithms/AsgShallowCopyAlg.h>
+
+#include <CxxUtils/fpcompare.h>
+#include <xAODCore/AuxContainerBase.h>
+#include <xAODEgamma/PhotonContainer.h>
+#include <xAODEgamma/ElectronContainer.h>
+#include <xAODJet/JetContainer.h>
+#include <xAODMuon/MuonContainer.h>
+#include <xAODTau/TauJetContainer.h>
+#include <xAODTau/DiTauJetContainer.h>
+#include <xAODTracking/TrackParticleContainer.h>
+#include <xAODTruth/TruthParticleContainer.h>
+#include <SystematicsHandles/CopyHelpers.h>
+
+//
+// method implementations
+//
+
+namespace CP
+{
+ template<typename Type> StatusCode AsgShallowCopyAlg ::
+ executeTemplate (const CP::SystematicSet& sys)
+ {
+ const Type *input = nullptr;
+ ANA_CHECK (evtStore()->retrieve (input, m_inputHandle.getName (sys)));
+
+ const auto& name = m_outputHandle.getName(sys);
+ Type *output = nullptr;
+ ANA_CHECK (detail::ShallowCopy<Type>::getCopy
+ (msg(), *evtStore(), output, input,
+ name, name + "Aux."));
+
+ // suppress compiler warning about unused variable
+ (void) output;
+
+ return StatusCode::SUCCESS;
+ }
+
+
+
+
+ StatusCode AsgShallowCopyAlg ::
+ executeFindType (const CP::SystematicSet& sys)
+ {
+ const xAOD::IParticleContainer *input = nullptr;
+ ANA_CHECK (m_inputHandle.retrieve (input, sys));
+
+ if (dynamic_cast<const xAOD::ElectronContainer*> (input))
+ {
+ m_function =
+ &AsgShallowCopyAlg::executeTemplate<xAOD::ElectronContainer>;
+ }
+ else if (dynamic_cast<const xAOD::PhotonContainer*> (input))
+ {
+ m_function =
+ &AsgShallowCopyAlg::executeTemplate<xAOD::PhotonContainer>;
+ }
+ else if (dynamic_cast<const xAOD::JetContainer*> (input))
+ {
+ m_function =
+ &AsgShallowCopyAlg::executeTemplate<xAOD::JetContainer>;
+ }
+ else if (dynamic_cast<const xAOD::MuonContainer*> (input)) {
+ m_function =
+ &AsgShallowCopyAlg::executeTemplate<xAOD::MuonContainer>;
+ }
+ else if (dynamic_cast<const xAOD::TauJetContainer*> (input))
+ {
+ m_function =
+ &AsgShallowCopyAlg::executeTemplate<xAOD::TauJetContainer>;
+ }
+ else if (dynamic_cast<const xAOD::DiTauJetContainer*> (input))
+ {
+ m_function =
+ &AsgShallowCopyAlg::executeTemplate<xAOD::DiTauJetContainer>;
+ }
+ else if (dynamic_cast<const xAOD::TrackParticleContainer*> (input))
+ {
+ m_function =
+ &AsgShallowCopyAlg::executeTemplate<xAOD::TrackParticleContainer>;
+ }
+ else if (dynamic_cast<const xAOD::TruthParticleContainer*> (input))
+ {
+ m_function =
+ &AsgShallowCopyAlg::executeTemplate<xAOD::TruthParticleContainer>;
+ }
+ else
+ {
+ ANA_MSG_ERROR ("unknown type contained in AsgShallowCopyAlg, please extend it");
+ return StatusCode::FAILURE;
+ }
+
+ return (this->*m_function) (sys);
+ }
+
+
+
+ AsgShallowCopyAlg ::
+ AsgShallowCopyAlg (const std::string& name,
+ ISvcLocator* pSvcLocator)
+ : AnaAlgorithm (name, pSvcLocator)
+ {
+ }
+
+
+
+ StatusCode AsgShallowCopyAlg ::
+ initialize ()
+ {
+ ANA_CHECK (m_systematicsList.service().registerCopy (m_inputHandle.getNamePattern(), m_outputHandle.getNamePattern()));
+ ANA_CHECK (m_inputHandle.initialize (m_systematicsList));
+ ANA_CHECK (m_outputHandle.initialize (m_systematicsList));
+ ANA_CHECK (m_systematicsList.initialize());
+
+ return StatusCode::SUCCESS;
+ }
+
+
+
+ StatusCode AsgShallowCopyAlg ::
+ execute ()
+ {
+ for (const auto& sys : m_systematicsList.systematicsVector())
+ {
+ ANA_CHECK ((this->*m_function) (sys));
+ }
+ return StatusCode::SUCCESS;
+ }
+}
diff --git a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/src/components/AsgAnalysisAlgorithms_entries.cxx b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/src/components/AsgAnalysisAlgorithms_entries.cxx
index c0a485dd32c6e80c07192e61b558259c95d39860..5dd756ee991220001a49f57d4924f61e8cc517ae 100644
--- a/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/src/components/AsgAnalysisAlgorithms_entries.cxx
+++ b/PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/src/components/AsgAnalysisAlgorithms_entries.cxx
@@ -17,6 +17,7 @@
#include <AsgAnalysisAlgorithms/AsgLeptonTrackSelectionAlg.h>
#include <AsgAnalysisAlgorithms/AsgOriginalObjectLinkAlg.h>
#include <AsgAnalysisAlgorithms/AsgSelectionAlg.h>
+#include <AsgAnalysisAlgorithms/AsgShallowCopyAlg.h>
#include <AsgAnalysisAlgorithms/AsgUnionSelectionAlg.h>
#include <AsgAnalysisAlgorithms/AsgViewFromSelectionAlg.h>
#include <AsgAnalysisAlgorithms/AsgxAODNTupleMakerAlg.h>
@@ -43,6 +44,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, AsgShallowCopyAlg)
DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgUnionSelectionAlg)
DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgViewFromSelectionAlg)
DECLARE_NAMESPACE_ALGORITHM_FACTORY (CP, AsgxAODNTupleMakerAlg)
@@ -70,6 +72,7 @@ DECLARE_FACTORY_ENTRIES(AsgAnalysisAlgorithms) {
DECLARE_NAMESPACE_ALGORITHM (CP, AsgLeptonTrackSelectionAlg)
DECLARE_NAMESPACE_ALGORITHM (CP, AsgOriginalObjectLinkAlg)
DECLARE_NAMESPACE_ALGORITHM (CP, AsgSelectionAlg)
+ DECLARE_NAMESPACE_ALGORITHM (CP, AsgShallowCopyAlg)
DECLARE_NAMESPACE_ALGORITHM (CP, AsgUnionSelectionAlg)
DECLARE_NAMESPACE_ALGORITHM (CP, AsgViewFromSelectionAlg)
DECLARE_NAMESPACE_ALGORITHM (CP, AsgxAODNTupleMakerAlg)
diff --git a/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/ElectronAnalysisSequence.py b/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/ElectronAnalysisSequence.py
index 3beeab478d75600470004691aa0779bcffdf70ca..f4366dc00ca65b9928f299af567900754810e3a7 100644
--- a/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/ElectronAnalysisSequence.py
+++ b/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/ElectronAnalysisSequence.py
@@ -104,6 +104,12 @@ def makeElectronCalibrationSequence( seq, dataType, postfix = '',
if dataType not in [ 'data', 'mc', 'afii' ]:
raise ValueError( 'Invalid data type: %s' % dataType )
+ # Set up a shallow copy to decorate
+ alg = createAlgorithm( 'CP::AsgShallowCopyAlg', 'ElectronShallowCopyAlg' + postfix )
+ seq.append( alg, inputPropName = 'input',
+ outputPropName = 'output',
+ stageName = 'prepare')
+
# Set up the eta-cut on all electrons prior to everything else
alg = createAlgorithm( 'CP::AsgSelectionAlg', 'ElectronEtaCutAlg' + postfix )
alg.selectionDecoration = 'selectEta' + postfix + ',as_bits'
@@ -114,7 +120,6 @@ def makeElectronCalibrationSequence( seq, dataType, postfix = '',
alg.selectionTool.etaGapHigh = 1.52
alg.selectionTool.useClusterEta = True
seq.append( alg, inputPropName = 'particles',
- outputPropName = 'particlesOut',
stageName = 'calibration',
metaConfig = {'selectionDecorNames' : [alg.selectionDecoration],
'selectionDecorNamesOutput' : [alg.selectionDecoration],
diff --git a/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/PhotonAnalysisSequence.py b/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/PhotonAnalysisSequence.py
index cdf64109444183846d55c1dc6fcbf72320f50279..aeb733097d892b541f8585bd259de91fe6319fb6 100644
--- a/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/PhotonAnalysisSequence.py
+++ b/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/PhotonAnalysisSequence.py
@@ -110,6 +110,12 @@ def makePhotonCalibrationSequence( seq, dataType,
cleaningWP = 'NoTime' if cleaningAllowLate else ''
+ # Set up a shallow copy to decorate
+ alg = createAlgorithm( 'CP::AsgShallowCopyAlg', 'PhotonShallowCopyAlg' + postfix )
+ seq.append( alg, inputPropName = 'input',
+ outputPropName = 'output',
+ stageName = 'prepare')
+
# Set up the eta-cut on all photons prior to everything else
alg = createAlgorithm( 'CP::AsgSelectionAlg', 'PhotonEtaCutAlg' + postfix )
alg.selectionDecoration = 'selectEta' + postfix + ',as_bits'
@@ -120,7 +126,6 @@ def makePhotonCalibrationSequence( seq, dataType,
alg.selectionTool.etaGapHigh = 1.52
alg.selectionTool.useClusterEta = True
seq.append( alg, inputPropName = 'particles',
- outputPropName = 'particlesOut',
stageName = 'calibration',
metaConfig = {'selectionDecorNames' : [alg.selectionDecoration],
'selectionDecorNamesOutput' : [alg.selectionDecoration],
diff --git a/PhysicsAnalysis/Algorithms/MetAnalysisAlgorithms/python/MetAnalysisAlgorithmsTest.py b/PhysicsAnalysis/Algorithms/MetAnalysisAlgorithms/python/MetAnalysisAlgorithmsTest.py
index 9c203b96ab93092037cc1680d539a928eac8440b..c51ad766950e9d3a31c63ac05822b9547bea13dc 100644
--- a/PhysicsAnalysis/Algorithms/MetAnalysisAlgorithms/python/MetAnalysisAlgorithmsTest.py
+++ b/PhysicsAnalysis/Algorithms/MetAnalysisAlgorithms/python/MetAnalysisAlgorithmsTest.py
@@ -21,15 +21,21 @@ def makeSequence (dataType) :
# Set up a selection alg for demonstration purposes
# Also to avoid warnings from building MET with very soft electrons
+
+ # We need to copy here, because w/o an output container, it's assumed
+ # that the input container is non-const
+ eleCopyAlg = createAlgorithm( 'CP::AsgShallowCopyAlg', 'MetEleCopyAlg' )
+ eleCopyAlg.input = 'Electrons'
+ eleCopyAlg.output = 'DecorElectrons_%SYS%'
+ algSeq += eleCopyAlg
+
+
selalg = createAlgorithm( 'CP::AsgSelectionAlg', 'METEleSelAlg' )
addPrivateTool( selalg, 'selectionTool', 'CP::AsgPtEtaSelectionTool' )
selalg.selectionTool.minPt = 10e3
selalg.selectionTool.maxEta = 2.47
selalg.selectionDecoration = 'selectPtEta'
- selalg.particles = 'Electrons'
- # We need to copy here, because w/o an output container, it's assumed
- # that the input container is non-const
- selalg.particlesOut = 'DecorElectrons_%SYS%'
+ selalg.particles = 'DecorElectrons_%SYS%'
algSeq += selalg
# Now make a view container holding only the electrons for the MET calculation
diff --git a/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisConfig.py b/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisConfig.py
index 502ac0acc0b4fccc1f187f102efae9aa5bb730c4..d53dff2b75c93fd89336f9eb6d4d6825c8d8c1b4 100644
--- a/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisConfig.py
+++ b/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisConfig.py
@@ -15,6 +15,12 @@ class MuonCalibrationConfig (ConfigBlock):
self.ptSelectionOutput = False
def makeAlgs (self, config) :
+ # Set up a shallow copy to decorate
+ if config.wantCopy (self.containerName, 'Muons') :
+ alg = config.createAlgorithm( 'CP::AsgShallowCopyAlg', 'MuonShallowCopyAlg' + self.postfix )
+ alg.input = config.readName (self.containerName, "Muons")
+ alg.output = config.copyName (self.containerName)
+
# Set up the eta-cut on all muons prior to everything else
alg = config.createAlgorithm( 'CP::AsgSelectionAlg',
'MuonEtaCutAlg' + self.postfix )
@@ -22,8 +28,6 @@ class MuonCalibrationConfig (ConfigBlock):
alg.selectionTool.maxEta = 2.5
alg.selectionDecoration = 'selectEta' + self.postfix + ',as_bits'
alg.particles = config.readName (self.containerName, "Muons")
- if config.wantCopy (self.containerName) :
- alg.particlesOut = config.copyName (self.containerName)
alg.preselection = config.getSelection (self.containerName, '')
config.addSelection (self.containerName, '', alg.selectionDecoration, 2)
config.addSelection (self.containerName, 'output', alg.selectionDecoration, 2)
diff --git a/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisSequence.py b/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisSequence.py
index 8d1f64b419fb025bbf2bdb6e84d98871bf98de44..b85ef9451b9e06562ea40c97fdf8471039cfac84 100644
--- a/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisSequence.py
+++ b/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisSequence.py
@@ -87,6 +87,12 @@ def makeMuonCalibrationSequence( seq, dataType,
if dataType not in ["data", "mc", "afii"] :
raise ValueError ("invalid data type: " + dataType)
+ # Set up a shallow copy to decorate
+ alg = createAlgorithm( 'CP::AsgShallowCopyAlg', 'MuonShallowCopyAlg' + postfix )
+ seq.append( alg, inputPropName = 'input',
+ outputPropName = 'output',
+ stageName = 'prepare')
+
# Set up the eta-cut on all muons prior to everything else
alg = createAlgorithm( 'CP::AsgSelectionAlg',
'MuonEtaCutAlg' + postfix )
@@ -94,7 +100,6 @@ def makeMuonCalibrationSequence( seq, dataType,
alg.selectionTool.maxEta = 2.5
alg.selectionDecoration = 'selectEta' + postfix + ',as_bits'
seq.append( alg, inputPropName = 'particles',
- outputPropName = 'particlesOut',
stageName = 'selection',
metaConfig = {'selectionDecorNames' : [alg.selectionDecoration],
'selectionDecorNamesOutput' : [alg.selectionDecoration],
diff --git a/PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AnaAlgorithmMeta.py b/PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AnaAlgorithmMeta.py
index 4e843312778903e9f62b82a9ac538237aec096c4..4f52d516a9e9c546ecbb04f8b4e88d82777c7cfe 100644
--- a/PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AnaAlgorithmMeta.py
+++ b/PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AnaAlgorithmMeta.py
@@ -47,6 +47,6 @@ class AnaAlgorithmMeta ( object ):
@staticmethod
def allowedStageNames():
- return ["calibration", "selection", "efficiency", "undefined"]
+ return ["prepare", "calibration", "selection", "efficiency", "undefined"]
pass