diff --git a/Event/xAOD/xAODPFlow/xAODPFlow/xAODPFlowDict.h b/Event/xAOD/xAODPFlow/xAODPFlow/xAODPFlowDict.h
index 11b944665f6ac200060c4a6b054cda7b846fc840..4829da63e9a1e00cf26ee9c14a1062233c1f556a 100644
--- a/Event/xAOD/xAODPFlow/xAODPFlow/xAODPFlowDict.h
+++ b/Event/xAOD/xAODPFlow/xAODPFlow/xAODPFlowDict.h
@@ -43,12 +43,11 @@ namespace {
XAOD_INSTANTIATE_NS_CONTAINER_TYPES( xAOD, IParticleContainer );
// Weird/bad types used by the PFO reconstruction as attributes on
// xAOD::PFO objects. :-(
- std::pair< ElementLink< xAOD::CaloClusterContainer >, double > dummy1;
- std::vector< std::pair< ElementLink< xAOD::CaloClusterContainer >, double > >
- dummy2;
- std::vector< std::vector< std::pair< ElementLink< xAOD::CaloClusterContainer >, double > > >
- dummy3;
- std::vector< xAOD::PFODetails::PFOLeptonType > dummy4;
+ std::pair< ElementLink< xAOD::CaloClusterContainer >, double > FlowElemdummy1;
+ std::vector< std::pair< ElementLink< xAOD::CaloClusterContainer >, double > > FlowElemdummy2;
+ std::vector< std::vector< std::pair< ElementLink< xAOD::CaloClusterContainer >, double > > > FlowElemdummy3;
+ std::vector< xAOD::PFODetails::PFOLeptonType > FlowElemdummy4;
+
};
}
diff --git a/Reconstruction/eflowRec/eflowRec/PFEGamFlowElementAssoc.h b/Reconstruction/eflowRec/eflowRec/PFEGamFlowElementAssoc.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c95a5121f2c0361962e2629dcd104612186bbbf
--- /dev/null
+++ b/Reconstruction/eflowRec/eflowRec/PFEGamFlowElementAssoc.h
@@ -0,0 +1,80 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+/*
+ * PFEGamFlowElementAssoc.h
+ * Header file for class PFEGamFlowElementAssoc
+ *
+ * Created on: 13.03.19
+ * Author: J. C. MacDonald & Upgraded by M.T. Anthony
+ */
+
+#ifndef PFEGAMFLOWELEMENTASSOC_H
+#define PFEGAMFLOWELEMENTASSOC_H
+
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "StoreGate/DataHandle.h"
+
+#include "xAODEgamma/ElectronContainer.h"
+#include "xAODEgamma/PhotonContainer.h"
+
+#include "StoreGate/WriteDecorHandle.h"
+#include "xAODPFlow/FlowElementContainer.h"
+/**
+This is the algorithm, which inherits from AthReentrantAlgorithm, that adds element links between particle flow objects (Flow Elements) and Egamma objects. The algorithm associates charged (c) Flow Elements to all electron and converted photon tracks, and neutral (n) Flow Elements to all electron and photon clusters.
+
+This is done by adding decorations to the "Electron" and "Photon" container, for charged Charged Flow Elements and Neutral Flow Elements separately, in the form of vectors of element links to the associated Flow Elements.
+The algorithm also adds decorations to the "JetETMissNeutralFlowElements" and
+"JetETMissChargedParticleFlowElements" containers, in the form of vectors of element links to the associated electrons and photons.
+
+**/
+class PFEGamFlowElementAssoc : public AthReentrantAlgorithm {
+
+public:
+ using AthReentrantAlgorithm::AthReentrantAlgorithm;
+
+ PFEGamFlowElementAssoc(const std::string& name, ISvcLocator* pSvcLocator);
+
+ virtual ~PFEGamFlowElementAssoc();
+
+ virtual StatusCode initialize();
+ virtual StatusCode execute(const EventContext & ctx) const;
+ virtual StatusCode finalize();
+
+private:
+ //instantiate ReadHandle for the Photon/Electron
+ SG::ReadHandleKey<xAOD::ElectronContainer>m_electronReadHandleKey{this,"ElectronContainer","Electrons","ReadHandleKey for ElectronContainer"};
+
+ SG::ReadHandleKey<xAOD::PhotonContainer>m_photonReadHandleKey{this,"PhotonContainer","Photons","ReadHandleKey for PhotonContainer"};
+
+ //Readhandles for FlowElements.
+ SG::ReadHandleKey<xAOD::FlowElementContainer> m_neutralFEReadHandleKey{this,"JetEtMissNeutralFlowElementContainer","JetETMissNeutralFlowElements","ReadHandleKey for neutral FlowElements"};
+
+ SG::ReadHandleKey<xAOD::FlowElementContainer> m_chargedFEReadHandleKey{this,"JetEtMissChargedFlowElementContainer","JetETMissChargedFlowElements","ReadHandleKey for charged FlowElements"};
+
+
+ /** The write key for adding Neutral Flow Element element link decorations to electrons */
+ SG::WriteDecorHandleKey<xAOD::ElectronContainer> m_electronNeutralFEWriteDecorKey;
+ /** The write key for adding Charged Flow Element element link decorations to electrons */
+ SG::WriteDecorHandleKey<xAOD::ElectronContainer> m_electronChargedFEWriteDecorKey;
+ /** The write key for adding electron element link decorations to Neutral Flow Elements */
+ SG::WriteDecorHandleKey<xAOD::FlowElementContainer> m_neutralFEElectronWriteDecorKey;
+ /** The write key for adding electron element link decorations to Charged Flow Elements */
+ SG::WriteDecorHandleKey<xAOD::FlowElementContainer> m_chargedFEElectronWriteDecorKey;
+
+ /** The write key for adding Neutral Flow Element element link decorations to photons */
+ SG::WriteDecorHandleKey<xAOD::PhotonContainer> m_photonNeutralFEWriteDecorKey;
+ /** The write key for adding Charged Flow Element element link decorations to photons */
+ SG::WriteDecorHandleKey<xAOD::PhotonContainer> m_photonChargedFEWriteDecorKey;
+ /** The write key for adding photon element link decorations to Neutral Flow Elements */
+ SG::WriteDecorHandleKey<xAOD::FlowElementContainer> m_neutralFEPhotonWriteDecorKey;
+ /** The write key for adding photon element link decorations to Charged Flow Elements */
+ SG::WriteDecorHandleKey<xAOD::FlowElementContainer> m_chargedFEPhotonWriteDecorKey;
+
+
+};
+
+#endif // PFEGamFlowElementAssoc
diff --git a/Reconstruction/eflowRec/share/PFlowMTConfig.py b/Reconstruction/eflowRec/share/PFlowMTConfig.py
index bf6780e54b77664f55577eb354d67adfb6119ea8..edd98bf0749f3fb7f105888d0a1d6d295059910e 100644
--- a/Reconstruction/eflowRec/share/PFlowMTConfig.py
+++ b/Reconstruction/eflowRec/share/PFlowMTConfig.py
@@ -13,7 +13,7 @@ TrackCaloExtensionTool=eflowTrackCaloExtensionTool(TrackCaloExtensionTool=pcExte
#If reading from ESD we not create a cache of extrapolations to the calorimeter, so we should signify this by setting the cache key to a null string
from RecExConfig.RecFlags import rec
-if True == rec.readESD:
+if rec.readESD==True:
TrackCaloExtensionTool.PFParticleCache = ""
PFTrackSelector.trackExtrapolatorTool = TrackCaloExtensionTool
@@ -243,15 +243,18 @@ if True == jobproperties.eflowRecFlags.provideShowerSubtractedClusters:
PFONeutralCreatorAlgorithm.AddShowerSubtractedClusters = True
topSequence += PFONeutralCreatorAlgorithm
+from eflowRec.eflowRecFlags import jobproperties # set reco flags for eFlowRec algorithms
+jobproperties.eflowRecFlags.usePFEGammaPFOAssoc.set_Value_and_Lock(True)
+jobproperties.eflowRecFlags.useFlowElements.set_Value_and_Lock(True)
if jobproperties.eflowRecFlags.usePFEGammaPFOAssoc:
-
+
from eflowRec.eflowRecConf import PFEGammaPFOAssoc
PFEGammaPFOAssoc=PFEGammaPFOAssoc("PFEGammaPFOAssoc")
topSequence += PFEGammaPFOAssoc
#Add new FlowElement creators
-if jobproperties.eflowRecFlags.useFlowElements:
+if jobproperties.eflowRecFlags.useFlowElements:
from eflowRec.eflowRecConf import PFChargedFlowElementCreatorAlgorithm
PFChargedFlowElementCreatorAlgorithm = PFChargedFlowElementCreatorAlgorithm("PFChargedFlowElementCreatorAlgorithm")
topSequence += PFChargedFlowElementCreatorAlgorithm
@@ -263,3 +266,7 @@ if jobproperties.eflowRecFlags.useFlowElements:
from eflowRec.eflowRecConf import PFLCNeutralFlowElementCreatorAlgorithm
PFLCNeutralFlowElementCreatorAlgorithm = PFLCNeutralFlowElementCreatorAlgorithm("PFLCNeutralFlowElementCreatorAlgorithm")
topSequence += PFLCNeutralFlowElementCreatorAlgorithm
+
+ from eflowRec.eflowRecConf import PFEGamFlowElementAssoc
+ PFEGamFlowElementAssoc=PFEGamFlowElementAssoc("PFEGamFlowElementAssoc")
+ topSequence +=PFEGamFlowElementAssoc
diff --git a/Reconstruction/eflowRec/src/PFEGamFlowElementAssoc.cxx b/Reconstruction/eflowRec/src/PFEGamFlowElementAssoc.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d4f91632eb5f3e910fca2718e6633abf892e9050
--- /dev/null
+++ b/Reconstruction/eflowRec/src/PFEGamFlowElementAssoc.cxx
@@ -0,0 +1,258 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "StoreGate/WriteDecorHandle.h"
+// Flow Element EDM
+#include "xAODPFlow/FlowElementContainer.h"
+#include "xAODPFlow/FlowElement.h"
+#include "xAODEgamma/ElectronContainer.h"
+#include "xAODEgamma/PhotonContainer.h"
+#include "xAODEgamma/Electron.h"
+#include "xAODEgamma/Photon.h"
+#include "xAODEgamma/ElectronxAODHelpers.h"
+#include "xAODEgamma/EgammaxAODHelpers.h"
+
+
+#include "eflowRec/PFEGamFlowElementAssoc.h"
+
+
+typedef ElementLink<xAOD::ElectronContainer> ElectronLink_t;
+typedef ElementLink<xAOD::PhotonContainer> PhotonLink_t;
+typedef ElementLink<xAOD::FlowElementContainer> FlowElementLink_t;
+
+PFEGamFlowElementAssoc::PFEGamFlowElementAssoc(
+const std::string& name,
+ ISvcLocator* pSvcLocator
+ ):
+ AthReentrantAlgorithm(name,pSvcLocator)
+{
+// Class initializer
+declareProperty ("ElectronNeutralFEDecorKey", m_electronNeutralFEWriteDecorKey = "Electrons.neutralFELinks");
+declareProperty ("ElectronChargedFEDecorKey", m_electronChargedFEWriteDecorKey = "Electrons.chargedFELinks");
+
+declareProperty ("NeutralFEElectronDecorKey", m_neutralFEElectronWriteDecorKey = "JetETMissNeutralFlowElements.FE_ElectronLinks");
+
+declareProperty ("ChargedFEElectronDecorKey", m_chargedFEElectronWriteDecorKey = "JetETMissChargedFlowElements.FE_ElectronLinks");
+
+declareProperty ("PhotonNeutralFEDecorKey", m_photonNeutralFEWriteDecorKey = "Photons.neutralFELinks");
+declareProperty ("PhotonChargedFEDecorKey", m_photonChargedFEWriteDecorKey = "Photons.chargedFELinks");
+declareProperty ("NeutralFEPhotonDecorKey", m_neutralFEPhotonWriteDecorKey = "JetETMissNeutralFlowElements.FE_PhotonLinks");
+declareProperty ("ChargedFEPhotonDecorKey", m_chargedFEPhotonWriteDecorKey = "JetETMissChargedFlowElements.FE_PhotonLinks");
+}
+
+// Class destructor
+PFEGamFlowElementAssoc::~PFEGamFlowElementAssoc(){}
+
+StatusCode PFEGamFlowElementAssoc::initialize()
+{
+
+ ATH_MSG_DEBUG("Initializing "<<name() << "...");
+ ATH_CHECK(m_electronNeutralFEWriteDecorKey.initialize());
+ ATH_CHECK(m_electronChargedFEWriteDecorKey.initialize());
+ ATH_CHECK(m_neutralFEElectronWriteDecorKey.initialize());
+ ATH_CHECK(m_chargedFEElectronWriteDecorKey.initialize());
+
+ ATH_CHECK(m_photonNeutralFEWriteDecorKey.initialize());
+ ATH_CHECK(m_photonChargedFEWriteDecorKey.initialize());
+ ATH_CHECK(m_neutralFEPhotonWriteDecorKey.initialize());
+ ATH_CHECK(m_chargedFEPhotonWriteDecorKey.initialize());
+
+ //Init ReadHandleKeys
+ ATH_CHECK(m_photonReadHandleKey.initialize());
+ ATH_CHECK(m_electronReadHandleKey.initialize());
+ ATH_CHECK(m_chargedFEReadHandleKey.initialize());
+ ATH_CHECK(m_neutralFEReadHandleKey.initialize());
+
+ ATH_MSG_DEBUG("Initialization completed successfully");
+
+return StatusCode::SUCCESS;
+}
+
+StatusCode PFEGamFlowElementAssoc::finalize(){
+return StatusCode::SUCCESS;
+}
+/**
+ This algorithm does the following:
+ 1) Read the Input containers for Flow Elements, Electrons and Photons
+ 2) Match the Clusters in the flow elements to the relevant E/Photon clusters (Neutral) or match tracks to relevant Electron/Photon tracks (Charged)
+ 3) Link them
+ 4) output the Electron/Photon containers with the linkers to the Flow element containers
+**/
+StatusCode PFEGamFlowElementAssoc::execute(const EventContext &ctx) const
+{
+ // write decoration handles for the electron, photon and FE containers -- these are the OUTPUT handles
+ //Electron Write Handle
+ SG::WriteDecorHandle<xAOD::ElectronContainer, std::vector<FlowElementLink_t> > electronNeutralFEWriteDecorHandle (m_electronNeutralFEWriteDecorKey,ctx);
+ SG::WriteDecorHandle<xAOD::ElectronContainer, std::vector<FlowElementLink_t> > electronChargedFEWriteDecorHandle (m_electronChargedFEWriteDecorKey,ctx);
+ SG::WriteDecorHandle<xAOD::FlowElementContainer, std::vector<ElectronLink_t> > neutralFEElectronWriteDecorHandle (m_neutralFEElectronWriteDecorKey,ctx);
+ SG::WriteDecorHandle<xAOD::FlowElementContainer, std::vector<ElectronLink_t> > chargedFEElectronWriteDecorHandle (m_chargedFEElectronWriteDecorKey,ctx);
+
+ //Photon Write Handle
+ SG::WriteDecorHandle<xAOD::PhotonContainer, std::vector<FlowElementLink_t> > photonNeutralFEWriteDecorHandle (m_photonNeutralFEWriteDecorKey,ctx);
+ SG::WriteDecorHandle<xAOD::PhotonContainer, std::vector<FlowElementLink_t> > photonChargedFEWriteDecorHandle (m_photonChargedFEWriteDecorKey,ctx);
+ SG::WriteDecorHandle<xAOD::FlowElementContainer, std::vector<PhotonLink_t> > neutralFEPhotonWriteDecorHandle (m_neutralFEPhotonWriteDecorKey,ctx);
+ SG::WriteDecorHandle<xAOD::FlowElementContainer, std::vector<PhotonLink_t> > chargedFEPhotonWriteDecorHandle (m_chargedFEPhotonWriteDecorKey,ctx);
+
+
+ // This is the READ handles (so the input containers for electron, photon, FE)
+
+ SG::ReadHandle<xAOD::ElectronContainer>electronReadHandle (m_electronReadHandleKey,ctx);
+ SG::ReadHandle<xAOD::PhotonContainer> photonReadHandle (m_photonReadHandleKey,ctx);
+
+ // Charged and Neutral PFlow "Flow elements"
+ SG::ReadHandle<xAOD::FlowElementContainer> neutralFEReadHandle (m_neutralFEReadHandleKey,ctx);
+ SG::ReadHandle<xAOD::FlowElementContainer> chargedFEReadHandle (m_chargedFEReadHandleKey,ctx);
+
+ // now initialise some Flow element link containers
+ std::vector<std::vector<FlowElementLink_t>> electronNeutralFEVec(electronReadHandle->size());
+ std::vector<std::vector<FlowElementLink_t>> electronChargedFEVec(electronReadHandle->size());
+
+ std::vector<std::vector<FlowElementLink_t>> photonNeutralFEVec(photonReadHandle->size());
+ std::vector<std::vector<FlowElementLink_t>> photonChargedFEVec(photonReadHandle->size());
+ //////////////////////////////////////////////////////////////////////////
+ //// DO MATCHING/LINKING
+ //////////////////////////////////////////////////////////////////////////
+
+
+ ///////////////////////////
+ // Loop over neutral flow elements (FEs)
+ ///////////////////////////
+ for (const xAOD::FlowElement* FE: *neutralFEElectronWriteDecorHandle){
+ //Obtain the index of the FE calo-cluster
+ size_t FEClusterIndex=FE->otherObjects().at(0)->index();
+
+ // init the linkers
+ std::vector<ElectronLink_t> FEElectronLinks;
+ std::vector<PhotonLink_t> FEPhotonLinks;
+
+ //Loop over electrons:
+ for (const xAOD::Electron* electron: *electronNeutralFEWriteDecorHandle){
+ // get the calo clusters from the electron
+
+ const std::vector<const xAOD::CaloCluster*> electronTopoClusters = xAOD::EgammaHelpers::getAssociatedTopoClusters(electron->caloCluster());
+
+
+ for(const xAOD::CaloCluster* cluster : electronTopoClusters){
+ // obtain the index of the electron seed topocluster
+ size_t electronClusterIndex=cluster->index();
+ //match the indices: Cluster match between Flow Element (FE) and electron
+ if(electronClusterIndex==FEClusterIndex){
+ FEElectronLinks.push_back( ElectronLink_t(*electronReadHandle,electron->index()) );
+ //Add Flow Element (FE) link to a vector
+ //index() is the unique index of the Flow Element in the container
+ electronNeutralFEVec.at(electron->index()).push_back(FlowElementLink_t(*neutralFEReadHandle, FE->index()) );
+ }// end of matching block
+
+ } // end loop over cluster
+
+ } // end Electron loop
+
+ // now loop over photons
+ for (const xAOD::Photon* photon: *photonNeutralFEWriteDecorHandle){
+ // retrieve clusters from the photon container
+ const std::vector<const xAOD::CaloCluster*> photonTopoClusters = xAOD::EgammaHelpers::getAssociatedTopoClusters(photon->caloCluster());
+ //loop over clusters, and do the matching
+ for (const xAOD::CaloCluster* cluster: photonTopoClusters){
+ //retrieve index of the cluster
+ size_t photonClusterIndex=cluster->index();
+ //do the matching
+ if(photonClusterIndex==FEClusterIndex){
+ // Add flow element (FE) links to photon
+ FEPhotonLinks.push_back( PhotonLink_t(*photonReadHandle,photon->index()) );
+ //Add Flow Element (FE) link to a vector
+ //index() is the unique index of the Flow Element in the container
+ photonNeutralFEVec.at(photon->index()).push_back(FlowElementLink_t(*neutralFEReadHandle, FE->index()) );
+ }// end of matching block
+ } // end of neutral loop
+
+
+ }// end of photon loop
+
+ //Add vector of electron element links as decoration to FlowElement container
+ neutralFEElectronWriteDecorHandle (*FE)=FEElectronLinks;
+ neutralFEPhotonWriteDecorHandle (*FE)=FEPhotonLinks;
+
+ } // end neutral FE loop
+
+ ////////////////////////////////////////////////////////
+ // Loop over charged Flow Elements (FEs)
+ ////////////////////////////////////////////////////////
+ for (const xAOD::FlowElement* FE: *chargedFEElectronWriteDecorHandle){
+ // retrieve the track from the Flow element
+ size_t FETrackIndex=FE->chargedObjects().at(0)->index();
+ // Initialise a vector of element links to electrons/Photons
+ std::vector<ElectronLink_t> FEElectronLinks;
+ std::vector<PhotonLink_t> FEPhotonLinks;
+
+ //loop over electrons
+ for (const xAOD::Electron* electron: *electronChargedFEWriteDecorHandle){
+ //obtain the clusters
+ const std::vector<const xAOD::TrackParticle*> electronTrackParticles = xAOD::EgammaHelpers::getTrackParticlesVec(electron, true, true); // useBremAssoc = true (get original non-GSF track), allParticles = true (include all track particles)
+ // loop over tracks
+ for (const xAOD::TrackParticle* electronTrack: electronTrackParticles){
+ size_t electronTrackIndex = electronTrack->index();
+
+ //link to FE if track indices match
+ if(electronTrackIndex==FETrackIndex){
+ // Add electron element link to a vector
+ // index() is the unique index of the electron in the electron container
+ FEElectronLinks.push_back( ElectronLink_t(*electronReadHandle, electron->index()) );
+ // Add FE element link to a vector
+ // index() is the unique index of the cFE in the cFE container
+ electronChargedFEVec.at(electron->index()).push_back( FlowElementLink_t(*chargedFEReadHandle, FE->index()) );
+
+ }//end of matching block
+
+ }//end of loop on clusters
+ } // end of loop on electrons
+
+ for(const xAOD::Photon* photon: *photonChargedFEWriteDecorHandle){
+ //obtain indices of the converted photon's original tracks
+ const std::set<const xAOD::TrackParticle*> photonTrackParticles = xAOD::EgammaHelpers::getTrackParticles(photon, true);
+ // loop over the tracks
+ for (const xAOD::TrackParticle* photonTrack: photonTrackParticles){
+ size_t photonTrackIndex=photonTrack->index();
+
+ // Link the photon to the Flow Element (FE) if the track indices match
+ if (photonTrackIndex==FETrackIndex){
+ // Add photon element link to a vector
+ // index() is the unique index of the photon in the photon container
+ FEPhotonLinks.push_back( PhotonLink_t(*photonReadHandle, photon->index()) );
+ // Add FE element link to a vector
+ // index() is the unique index of the cFE in the cFE container
+ photonChargedFEVec.at(photon->index()).push_back( FlowElementLink_t(*chargedFEReadHandle, FE->index()) );
+ }// end of matching block
+
+ }// end of loop on tracks
+
+ }//end of loop on photons
+
+
+ // Add vector of electron element links as decoration to FE container
+ chargedFEElectronWriteDecorHandle (*FE) = FEElectronLinks;
+ // Add vector of photon element links as decoration to FE container
+ chargedFEPhotonWriteDecorHandle (*FE) = FEPhotonLinks;
+
+ } // end of charged FE loop
+
+
+
+ ////////////////////////////////////////////////////
+ // WRITE OUTPUT: ADD HANDLES TO EL/PHOT CONTAINERS
+ ////////////////////////////////////////////////////
+ // Add the vectors of the Flow Element (FE) Links as decorations to the electron container
+ for (const xAOD::Electron* electron : *electronNeutralFEWriteDecorHandle){
+ electronNeutralFEWriteDecorHandle (*electron) = electronNeutralFEVec.at(electron->index());
+ electronChargedFEWriteDecorHandle (*electron) = electronChargedFEVec.at(electron->index());
+ } //end of photon loop
+ // Add the vectors of the Flow Element (FE) Links as decorations to the photon container
+ for (const xAOD::Photon* photon: *photonNeutralFEWriteDecorHandle){
+ photonNeutralFEWriteDecorHandle (*photon) = photonNeutralFEVec.at(photon->index());
+ photonChargedFEWriteDecorHandle (*photon) = photonChargedFEVec.at(photon->index());
+ } // end of loop on photons
+
+ ATH_MSG_DEBUG("Execute completed successfully");
+
+ return StatusCode::SUCCESS;
+}
diff --git a/Reconstruction/eflowRec/src/components/eflowRec_entries.cxx b/Reconstruction/eflowRec/src/components/eflowRec_entries.cxx
index 3667e06ebd952faaeb247cbb3c36ba60d78f67af..f0ad355de1ce65f121457a6512f8facc179252d7 100644
--- a/Reconstruction/eflowRec/src/components/eflowRec_entries.cxx
+++ b/Reconstruction/eflowRec/src/components/eflowRec_entries.cxx
@@ -20,6 +20,7 @@
#include "eflowRec/PFOChargedCreatorAlgorithm.h"
#include "eflowRec/PFONeutralCreatorAlgorithm.h"
#include "eflowRec/PFEGammaPFOAssoc.h"
+#include "eflowRec/PFEGamFlowElementAssoc.h"
DECLARE_COMPONENT( eflowOverlapRemoval )
DECLARE_COMPONENT( PFLeptonSelector )
@@ -43,3 +44,4 @@ DECLARE_COMPONENT( PFTrackClusterMatchingTool )
DECLARE_COMPONENT( eflowCellEOverPTool_mc12_JetETMiss)
DECLARE_COMPONENT( eflowCellEOverPTool_mc12_HLLHC)
DECLARE_COMPONENT( eflowCellEOverPTool_mc12_LC)
+DECLARE_COMPONENT( PFEGamFlowElementAssoc )