diff --git a/Reconstruction/eflowRec/eflowRec/PFLeptonSelector.h b/Reconstruction/eflowRec/eflowRec/PFLeptonSelector.h
new file mode 100644
index 0000000000000000000000000000000000000000..c26746ebe9cdf892fc5dbbfb34b4716fe41ef961
--- /dev/null
+++ b/Reconstruction/eflowRec/eflowRec/PFLeptonSelector.h
@@ -0,0 +1,68 @@
+#ifndef PFLEPTONSELECTOR_H
+#define PFLEPTONSELECTOR_H
+
+/** Algorithm which will select leptons for downstream algorithms to use within eflowRec */
+
+#include "AthContainers/ConstDataVector.h"
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "StoreGate/DataHandle.h"
+
+#include "xAODEgamma/ElectronContainer.h"
+#include "xAODMuon/MuonContainer.h"
+
+class CaloCellContainer;
+
+class PFLeptonSelector : public AthAlgorithm {
+
+public:
+  /** Default constructor */
+  PFLeptonSelector(const std::string& name, ISvcLocator* pSvcLocator);
+  /** Default destructor */
+  ~PFLeptonSelector() {};
+
+  /** Gaudi AthAlgorithm hooks */
+  StatusCode initialize();
+  StatusCode execute();
+  StatusCode finalize();
+
+private:
+
+  /** Select electrons to use */
+  StatusCode selectElectrons();
+
+  /** store the cells of the electrons */
+  void storeElectronCells(const xAOD::Egamma& electron);
+
+  /** select  muons to use */
+  StatusCode selectMuons();
+
+  /** store the cells of the muons */
+  void storeMuonCells(const xAOD::Muon& muon);
+
+  /** puts set of lepton cells into the lepton container */
+  void storeLeptonCells(const xAOD::CaloCluster& theCluster);
+
+  /** Put lepton containers and list of lepton cells into Storegate */
+  StatusCode recordLeptonContainers();
+  
+  /** ReadHandle for the ElectronContainer to be used as input */
+  SG::ReadHandle<xAOD::ElectronContainer> m_electronsReadHandle;
+
+  /** ReadHandle for the MuonContainer to be used as input */
+  SG::ReadHandle<xAOD::MuonContainer> m_muonsReadHandle;
+
+  /** WriteHandle for the ElectronContainer, that will be filled with electrons passing the electron ID in PFLeptonSelector::selectElectrons */
+  SG::WriteHandle<xAOD::ElectronContainer> m_selectedElectronsWriteHandle;
+
+  /** WriteHandle for the MuonContainer, that will be filled with muons passing the muon ID in PFLeptonSelector::selectMuons */
+  SG::WriteHandle<xAOD::MuonContainer> m_selectedMuonsWriteHandle;
+
+  /** WriteHandle for the CaloCellContainer, that will store calorimeter cells associated to leptons */
+  SG::WriteHandle<ConstDataVector<CaloCellContainer> > m_leptonCaloCellsWriteHandle;
+
+  /** bool to toggle storage of lepton CaloCells */
+  bool m_storeLeptonCells;
+
+  
+};
+#endif
diff --git a/Reconstruction/eflowRec/eflowRec/PFTrackSelector.h b/Reconstruction/eflowRec/eflowRec/PFTrackSelector.h
new file mode 100644
index 0000000000000000000000000000000000000000..0dc89bab9d21cf05b02acfa967d202a04df7c09d
--- /dev/null
+++ b/Reconstruction/eflowRec/eflowRec/PFTrackSelector.h
@@ -0,0 +1,63 @@
+#ifndef PFTRACKSELECTOR_H
+#define PFTRACKSELECTOR_H
+
+/** Algorithm which will select tracks for downstream algorithms to use within eflowRec */
+
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "StoreGate/DataHandle.h"
+
+#include "eflowRec/eflowRecTrack.h"
+#include "Particle/TrackParticleContainer.h"
+#include "xAODEgamma/ElectronContainer.h"
+#include "xAODMuon/MuonContainer.h"
+
+class eflowTrackExtrapolatorBaseAlgTool;
+namespace InDet { class IInDetTrackSelectionTool; }
+
+class PFTrackSelector : public AthAlgorithm {
+
+public:
+  /** Default constructor */
+  PFTrackSelector(const std::string& name, ISvcLocator* pSvcLocator);
+  /** Default destructor */
+  ~PFTrackSelector() {};
+
+  /** Gaudi AthAlgorithm hooks */
+  StatusCode initialize();
+  StatusCode execute();
+  StatusCode finalize();
+
+private:
+  /** This applys a selection criteria to the track using the tracking CP track selection tool */
+  bool selectTrack(const xAOD::TrackParticle& track);
+
+  /** check if track belongs to an electron */
+  bool isElectron(const xAOD::TrackParticle* track);
+
+  /** check if track belongs to an muon */
+  bool isMuon(const xAOD::TrackParticle* track);
+
+  /** ReadHandle for the TrackParticleContainer to be used as input */
+  SG::ReadHandle<xAOD::TrackParticleContainer> m_tracksReadHandle;
+
+  /** ReadHandle for the ElectronContainer to be used as input */
+  SG::ReadHandle<xAOD::ElectronContainer> m_electronsReadHandle;
+
+  /** ReadHandle for the MuonContainer to be used as input */
+  SG::ReadHandle<xAOD::MuonContainer> m_muonsReadHandle;
+
+  /** WriteHandle for the eflowRecTrackContainer to write out: */
+  SG::WriteHandle<eflowRecTrackContainer> m_eflowRecTracksWriteHandle;
+
+  /** Handle to interface on TrackToCalo tool. */
+  ToolHandle<eflowTrackExtrapolatorBaseAlgTool> m_theTrackExtrapolatorTool;
+
+  /** New track selection tool */
+  ToolHandle<InDet::IInDetTrackSelectionTool> m_selTool;
+
+  /** Upper limit on track Pt for input tracks */
+  float m_upperTrackPtCut;
+
+  
+};
+#endif
diff --git a/Reconstruction/eflowRec/python/eflowCaloSetup.py b/Reconstruction/eflowRec/python/eflowCaloSetup.py
index 834663b1afb5375ada96e129cfe103bb218e4668..efe3c995ec2994afd3e43ab40d19f32d17a8cdea 100644
--- a/Reconstruction/eflowRec/python/eflowCaloSetup.py
+++ b/Reconstruction/eflowRec/python/eflowCaloSetup.py
@@ -21,8 +21,8 @@ def setup_eflowCaloObjectCreator(Configured, nameModifier,mlog):
     Configured._eflowPreparationHandle = eflowPreparationAlgorithm
 
     try:
-        from eflowRec.eflowRecConf import eflowTrackCaloDummyExtensionTool
-        TrackCaloExtensionTool=eflowTrackCaloDummyExtensionTool()
+        from eflowRec.eflowRecConf import eflowTrackCaloExtensionTool
+        TrackCaloExtensionTool=eflowTrackCaloExtensionTool()
     except:
         mlog.error("could not import eflowRec.eflowTrackCaloExtensionTool")
         print traceback.format_exc()
diff --git a/Reconstruction/eflowRec/src/PFLeptonSelector.cxx b/Reconstruction/eflowRec/src/PFLeptonSelector.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..64057dfc8ef35bb1c9e4c9ea2a1fa547c6d91758
--- /dev/null
+++ b/Reconstruction/eflowRec/src/PFLeptonSelector.cxx
@@ -0,0 +1,190 @@
+#include "eflowRec/PFLeptonSelector.h"
+
+PFLeptonSelector::PFLeptonSelector(const std::string& name, ISvcLocator* pSvcLocator):
+  AthAlgorithm(name, pSvcLocator),
+  m_electronsReadHandle("Electrons"),
+  m_muonsReadHandle("Muons"),
+  m_selectedElectronsWriteHandle("eflowRec_selectedElectrons"),
+  m_selectedMuonsWriteHandle("eflowRec_selectedMuons"),
+  m_leptonCaloCellsWriteHandle("eflowRec_leptonCellContainer"),
+  m_storeLeptonCells(false)
+{
+  declareProperty("inputElectronsName", m_electronsReadHandle);
+  declareProperty("inputMuonsName",  m_muonsReadHandle);
+  declareProperty("outputElectronsName", m_selectedElectronsWriteHandle);
+  declareProperty("outputMuonsName", m_selectedMuonsWriteHandle);
+  declareProperty("outputLeptonCellsName", m_leptonCaloCellsWriteHandle);
+  declareProperty("storeLeptonCells", m_storeLeptonCells);
+}
+
+StatusCode PFLeptonSelector::initialize(){
+  ATH_CHECK( m_electronsReadHandle.initialize() );
+  ATH_CHECK( m_muonsReadHandle.initialize() );
+
+  ATH_CHECK( m_selectedElectronsWriteHandle.initialize() );
+  ATH_CHECK( m_selectedMuonsWriteHandle.initialize() );
+
+  ATH_CHECK( m_leptonCaloCellsWriteHandle.initialize() );
+  
+  return StatusCode::SUCCESS;
+}
+
+StatusCode PFLeptonSelector::execute(){
+
+  if (recordLeptonContainers().isFailure()) {
+      return StatusCode::SUCCESS;
+    }
+
+  /* Select electrons */
+  StatusCode sc = this->selectElectrons();
+  if (sc.isFailure()) {
+    if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << " Problem selecting electrons " << endmsg;
+  }
+
+  /* Select  muons */
+  sc = this->selectMuons();
+  if (sc.isFailure()) {
+    //won't mask out the tracks, but issue WARNING
+    if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << " Problem selecting muons " << endmsg;
+  }
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode PFLeptonSelector::finalize(){ return StatusCode::SUCCESS; }
+
+StatusCode PFLeptonSelector::selectElectrons(){
+
+  if (!m_electronsReadHandle.isValid()){
+    if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Invalid read handle to electron container with name: " <<   m_electronsReadHandle.key() << endmsg;
+    return StatusCode::FAILURE;
+  }
+
+  xAOD::ElectronContainer::const_iterator firstElectron = m_electronsReadHandle->begin();
+  xAOD::ElectronContainer::const_iterator lastElectron = m_electronsReadHandle->end();
+
+  for (; firstElectron != lastElectron; ++firstElectron){
+
+    const xAOD::Electron* theElectron = *firstElectron;
+    if (theElectron){
+      if (theElectron->pt() > 10000){
+        bool val_med = false;
+	bool gotID = theElectron->passSelection(val_med, "LHMedium");
+	if (!gotID) {
+	  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Could not get Electron ID " << endmsg;
+	  continue;
+	}
+	if (true == val_med){
+	  if (m_selectedElectronsWriteHandle.isValid()) m_selectedElectronsWriteHandle->push_back(const_cast<xAOD::Electron*>(theElectron));
+	  else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Do not have valid WriteHandle for ElectronContainer with name: " << m_selectedElectronsWriteHandle.key() << endmsg;
+	  if (true == m_storeLeptonCells) this->storeElectronCells(*theElectron);
+	}//mediumPP
+      }//10GeV pt cut
+    }//valid egamma pointer
+    else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "This electron is a NULL pointer " << endmsg;
+    
+  }//electron loop
+
+  return StatusCode::SUCCESS;
+}
+
+void PFLeptonSelector::storeElectronCells(const xAOD::Egamma& electron){
+
+  const xAOD::CaloCluster* electronCluster = electron.caloCluster(); 
+  if (electronCluster){
+    this->storeLeptonCells(*electronCluster);      
+  }
+  else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "This electron has an invalid pointer to its cluster " << endmsg;
+
+}
+
+StatusCode PFLeptonSelector::selectMuons() {
+
+  if (!m_muonsReadHandle.isValid()) {
+    if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Invalid read handle to muon container with name: " << m_muonsReadHandle.key() << endmsg;    
+    return StatusCode::FAILURE;
+  }
+
+  xAOD::MuonContainer::const_iterator firstMuon = m_muonsReadHandle->begin();
+  xAOD::MuonContainer::const_iterator lastMuon = m_muonsReadHandle->end();
+
+  for (; firstMuon != lastMuon; ++firstMuon) {
+    const xAOD::Muon* theMuon = *firstMuon;
+
+    //Details of medium muons are here:
+    //https://twiki.cern.ch/twiki/bin/view/Atlas/MuonSelectionTool
+    //No need to ask for combined muon, by construction other muons will not have ID track - we just ask for medium muons
+    
+    xAOD::Muon::Quality muonQuality = theMuon->quality();
+    if( muonQuality <= xAOD::Muon::Medium) {   
+      if (m_selectedMuonsWriteHandle.isValid()) m_selectedMuonsWriteHandle->push_back(const_cast<xAOD::Muon*>(theMuon));
+      else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Do not have valid WriteHandle for MuonContainer with name: " << m_selectedMuonsWriteHandle.key() << endmsg;
+      if (true == m_storeLeptonCells) this->storeMuonCells(*theMuon);
+    }//Medium muons
+  } //muon loop
+
+  return StatusCode::SUCCESS;
+}
+
+void PFLeptonSelector::storeMuonCells(const xAOD::Muon& muon){
+
+  const ElementLink<xAOD::CaloClusterContainer> theLink = muon.clusterLink(); 
+  if (theLink.isValid()){
+    const xAOD::CaloCluster* muonCluster = *theLink;
+    if (muonCluster){
+      this->storeLeptonCells(*muonCluster);
+    }
+    else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "This muon has an invalid pointer to its cluster " << endmsg;
+  }
+  else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "This muon has an invalid element link to its cluster " << endmsg;
+
+}
+
+void PFLeptonSelector::storeLeptonCells(const xAOD::CaloCluster& theCluster){
+
+  const CaloClusterCellLink* theCellLink = theCluster.getCellLinks();
+
+  if (theCellLink){
+  
+    CaloClusterCellLink::const_iterator firstCell = theCellLink->begin();
+    CaloClusterCellLink::const_iterator lastCell = theCellLink->end();
+    
+    for (; firstCell != lastCell; ++firstCell){
+      if (m_leptonCaloCellsWriteHandle.isValid()) m_leptonCaloCellsWriteHandle->push_back(*firstCell);
+      else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << " Do not have valid WriteHandle for CaloCellContaienr with name: " << m_leptonCaloCellsWriteHandle.key() << endmsg;
+    }//cell loop
+  }
+ else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "This cluster has an invalid pointer to its cells, in storeLeptonCells " << endmsg;
+
+}
+
+StatusCode PFLeptonSelector::recordLeptonContainers(){
+
+  StatusCode sc = m_selectedElectronsWriteHandle.record(std::make_unique<xAOD::ElectronContainer>(SG::VIEW_ELEMENTS));
+  
+  if (sc.isFailure()) {
+    if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Could not record electron WriteHandle with key: " << m_selectedElectronsWriteHandle.key() << endmsg;
+    return sc;
+  }
+
+  sc = m_selectedMuonsWriteHandle.record(std::make_unique<xAOD::MuonContainer>(SG::VIEW_ELEMENTS));
+  
+  if (sc.isFailure()) {
+    if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Could not record muon WriteHandle with key: " << m_selectedMuonsWriteHandle.key() << endmsg;
+    return sc;
+  }
+
+  if (true == m_storeLeptonCells) {
+
+    //record the cell container
+    sc =  m_leptonCaloCellsWriteHandle.record(std::make_unique<ConstDataVector<CaloCellContainer> >(SG::VIEW_ELEMENTS));
+
+    if (sc.isFailure()) {
+      if (msgLvl(MSG::WARNING))msg(MSG::WARNING) << "Could not record CaloCell WriteHandle with key: " << m_leptonCaloCellsWriteHandle << endmsg;
+      return sc;
+    }
+  }
+
+  return StatusCode::SUCCESS;
+
+}
diff --git a/Reconstruction/eflowRec/src/PFTrackSelector.cxx b/Reconstruction/eflowRec/src/PFTrackSelector.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..0d0a37759c6cf5d22196137c47de1ce7f6dd25fa
--- /dev/null
+++ b/Reconstruction/eflowRec/src/PFTrackSelector.cxx
@@ -0,0 +1,145 @@
+#include "eflowRec/eflowTrackExtrapolatorBaseAlgTool.h"
+#include "eflowRec/PFTrackSelector.h"
+#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
+#include "xAODEgamma/ElectronxAODHelpers.h"
+
+
+PFTrackSelector::PFTrackSelector(const std::string& name, ISvcLocator* pSvcLocator):
+  AthAlgorithm(name, pSvcLocator),
+  m_tracksReadHandle("InDetTrackParticles"),
+  m_electronsReadHandle("eflowRec_selectedElectrons"),
+  m_muonsReadHandle("eflowRec_selectedMuons"),
+  m_eflowRecTracksWriteHandle("eflowRecTracks"),
+  m_theTrackExtrapolatorTool("Trk::ParticleCaloExtensionTool",this),
+  m_upperTrackPtCut(100.0)
+{
+  declareProperty("tracksName", m_tracksReadHandle);
+  declareProperty("electronsName", m_electronsReadHandle);  
+  declareProperty("muonsName",  m_muonsReadHandle);
+  declareProperty("eflowRecTracksOutputName",  m_eflowRecTracksWriteHandle);
+  declareProperty("trackExtrapolatorTool", m_theTrackExtrapolatorTool, "AlgTool to use for track extrapolation");
+  declareProperty("trackSelectionTool", m_selTool);
+  declareProperty("upperTrackPtCut",m_upperTrackPtCut);
+}
+
+StatusCode PFTrackSelector::initialize(){
+
+  ATH_CHECK(m_theTrackExtrapolatorTool.retrieve());  
+  ATH_CHECK(m_selTool.retrieve());
+
+  ATH_CHECK(m_tracksReadHandle.initialize());
+  ATH_CHECK(m_electronsReadHandle.initialize());
+  ATH_CHECK(m_muonsReadHandle.initialize());
+
+  ATH_CHECK(m_eflowRecTracksWriteHandle.initialize());
+  
+  return StatusCode::SUCCESS;
+
+}
+
+StatusCode PFTrackSelector::execute(){
+
+  ATH_CHECK(m_eflowRecTracksWriteHandle.record(std::make_unique<eflowRecTrackContainer>()));
+
+  /* Verify the read handle has a valid pointer, and if not return */
+  if (!m_tracksReadHandle.isValid()){
+    if (msgLvl(MSG::WARNING)) { msg(MSG::WARNING) << "Can not retrieve xAOD::TrackParticleContainer with name: " << m_tracksReadHandle.key() << endmsg; }
+    return StatusCode::FAILURE;
+  }
+
+  /* Do the track selection for tracks to be used in all of the following steps: */
+  xAOD::TrackParticleContainer::const_iterator itTrackParticle = m_tracksReadHandle->begin();
+  int trackIndex = 0;
+  for (; itTrackParticle != m_tracksReadHandle->end(); ++itTrackParticle, ++trackIndex) {
+    const xAOD::TrackParticle* track = (*itTrackParticle);
+    if (!track){
+      if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Have invalid pointer to xAOD::TrackParticle " << endmsg;
+      continue;	
+    }
+
+    bool rejectTrack(!selectTrack(*track));
+
+    bool isElectron = this->isElectron(track);
+    bool isMuon = this->isMuon(track);
+    if (true == isElectron || true == isMuon) rejectTrack = true;
+
+    if (!rejectTrack) {
+      /* Create the eflowRecCluster and put it in the container */
+      std::unique_ptr<eflowRecTrack> thisEFRecTrack  = std::make_unique<eflowRecTrack>(ElementLink<xAOD::TrackParticleContainer>(*m_tracksReadHandle, trackIndex), m_theTrackExtrapolatorTool);
+      thisEFRecTrack->setTrackId(trackIndex);
+      m_eflowRecTracksWriteHandle->push_back(std::move(thisEFRecTrack));
+    }
+  }
+
+  std::sort(m_eflowRecTracksWriteHandle->begin(), m_eflowRecTracksWriteHandle->end(), eflowRecTrack::SortDescendingPt());
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode PFTrackSelector::finalize(){return StatusCode::SUCCESS;}
+
+bool PFTrackSelector::selectTrack(const xAOD::TrackParticle& track) {
+  if (track.pt()*0.001 < m_upperTrackPtCut) return m_selTool->accept(track, track.vertex());
+  else return false;
+}
+
+bool PFTrackSelector::isElectron(const xAOD::TrackParticle* track){
+
+  if (m_electronsReadHandle.isValid()){
+
+    xAOD::ElectronContainer::const_iterator firstElectron = m_electronsReadHandle->begin();
+    xAOD::ElectronContainer::const_iterator lastElectron = m_electronsReadHandle->end();
+    
+    for (; firstElectron != lastElectron; ++firstElectron){
+      const xAOD::Electron* this_egamma = *firstElectron;
+      if (this_egamma){
+	unsigned int nTrack = this_egamma->nTrackParticles();
+	
+	if (0 != nTrack){	  
+	  const xAOD::TrackParticle* origTrack = xAOD::EgammaHelpers::getOriginalTrackParticle(this_egamma);	  
+	  if (origTrack){
+	    if (track == origTrack) {
+	      return true;
+	    }
+	  }//if valid track pointer
+	  else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Electron object map has NULL pointer to original TrackParticle " << endmsg;
+	}//if has a track
+	else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Electron object has " << nTrack << " tracks " << endmsg;
+      }//if valid pointer
+      else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Electron is a NULL pointer " << endmsg;
+    }//electron loop    
+  }
+  else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << " Invalid ReadHandle for electrons with key: " << m_electronsReadHandle.key() << endmsg;
+
+  return false;
+
+}
+
+bool PFTrackSelector::isMuon(const xAOD::TrackParticle* track){
+
+  if (m_muonsReadHandle.isValid()){
+
+    xAOD::MuonContainer::const_iterator firstMuon = m_muonsReadHandle->begin();
+    xAOD::MuonContainer::const_iterator lastMuon = m_muonsReadHandle->end();
+    
+    for (; firstMuon != lastMuon ; ++firstMuon){
+      const xAOD::Muon* theMuon = *firstMuon;
+      if (theMuon){
+	const ElementLink< xAOD::TrackParticleContainer > theLink = theMuon->inDetTrackParticleLink();
+	if (theLink.isValid()){
+	  const xAOD::TrackParticle* ID_track = *theLink;
+	  if (ID_track){
+	    if (track == ID_track) return true;
+	    return false;
+	  }
+	  else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "This muon has a NULL pointer to the track " << endmsg;
+	}
+	else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "This muon has an invalid link to the track " << endmsg;
+      }//if muon pointer is valid
+      else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "This muon is a NULL pointer " << endmsg;
+    }//muon loop
+  }
+   else if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << " Invalid ReadHandle for muons with key: " << m_muonsReadHandle.key() << endmsg;
+
+  return false;
+}
diff --git a/Reconstruction/eflowRec/src/components/eflowRec_entries.cxx b/Reconstruction/eflowRec/src/components/eflowRec_entries.cxx
index 726664ede9157bcbad373d92b5461e0e45102462..04b1cda55ebaacf737e82adf935165227280bcb2 100644
--- a/Reconstruction/eflowRec/src/components/eflowRec_entries.cxx
+++ b/Reconstruction/eflowRec/src/components/eflowRec_entries.cxx
@@ -15,6 +15,8 @@
 #include "eflowRec/eflowObjectCreatorTool.h"
 #include "eflowRec/eflowOverlapRemoval.h"
 #include "eflowRec/eflowVertexInformationSetter.h"
+#include "eflowRec/PFLeptonSelector.h"
+#include "eflowRec/PFTrackSelector.h"
 #include "GaudiKernel/DeclareFactoryEntries.h"
 
 DECLARE_ALGORITHM_FACTORY( eflowBuilder )
@@ -23,6 +25,8 @@ DECLARE_ALGORITHM_FACTORY( eflowCaloObjectBuilder )
 DECLARE_ALGORITHM_FACTORY( eflowObjectBuilder )
 DECLARE_ALGORITHM_FACTORY( eflowOverlapRemoval )
 DECLARE_ALGORITHM_FACTORY( eflowVertexInformationSetter )
+DECLARE_ALGORITHM_FACTORY( PFLeptonSelector )
+DECLARE_ALGORITHM_FACTORY( PFTrackSelector )
 DECLARE_TOOL_FACTORY( eflowRecoverSplitShowersTool )
 DECLARE_TOOL_FACTORY( eflowCellLevelSubtractionTool )
 DECLARE_TOOL_FACTORY( eflowLCCalibTool )
@@ -42,6 +46,8 @@ DECLARE_FACTORY_ENTRIES(eflowRec) {
     DECLARE_ALGORITHM( eflowObjectBuilder )
     DECLARE_ALGORITHM (eflowOverlapRemoval )
     DECLARE_ALGORITHM ( eflowVertexInformationSetter )
+    DECLARE_ALGORITHM( PFLeptonSelector )
+    DECLARE_ALGORITHM( PFTrackSelector )
     DECLARE_TOOL ( eflowRecoverSplitShowersTool )
     DECLARE_TOOL ( eflowCellLevelSubtractionTool )
     DECLARE_TOOL ( eflowMomentCalculatorTool )