.___.

     /     \
    | O _ O |
    /  \_/  \
  .' /     \ `.
 / _|       |_ \
(_/ |       | \_)
    \       /
   __\_>-<_/__
   ~;/     \;~

Event/xAOD/xAODTrackCaloCluster/CMakeLists.txt

@@ -32,7 +32,8 @@ atlas_add_library( xAODTrackCaloCluster
 atlas_add_dictionary( xAODTrackCaloClusterDict
    xAODTrackCaloCluster/xAODTrackCaloClusterDict.h
    xAODTrackCaloCluster/selection.xml
-   LINK_LIBRARIES xAODTrackCaloCluster )
+   LINK_LIBRARIES xAODTrackCaloCluster 
+   EXTRA_FILES Root/dict/*.cxx )
 
 # Test(s) in the package:
 #atlas_add_test( xAODTrackCaloCluster_TrackParticle_test

Event/xAOD/xAODTrackCaloCluster/Root/TrackCaloCluster_v1.cxx

@@ -12,7 +12,7 @@
 
 namespace xAOD {
 
-  TrackCaloCluster_v1::TrackCaloCluster_v1() : IParticle(), m_p4(), m_p4Cached( false ) {}
+  TrackCaloCluster_v1::TrackCaloCluster_v1() : IParticle(), m_p4(), m_taste() {}
   
   TrackCaloCluster_v1::~TrackCaloCluster_v1(){}
   
@@ -23,9 +23,11 @@ namespace xAOD {
   double TrackCaloCluster_v1::eta() const {
     return p4().Eta();
   }
-
-  AUXSTORE_PRIMITIVE_GETTER_WITH_CAST(TrackCaloCluster_v1,float,double,phi)
- 
+  
+  double TrackCaloCluster_v1::phi() const {
+    return p4().Phi();
+  }
+  
   double TrackCaloCluster_v1::m() const {
     return p4().M();
   }
@@ -38,22 +40,6 @@ namespace xAOD {
   }
 
   const TrackCaloCluster_v1::FourMom_t& TrackCaloCluster_v1::p4() const {
-    using namespace std;
-  // Check if we need to reset the cached object:
-    if( ! m_p4Cached ) {
-      float p = 1/fabs(qOverP());
-      float thetaT = theta();
-      float phiT = phi();
-      float sinTheta= sin(thetaT);
-      float px = p*sinTheta*cos(phiT);
-      float py = p*sinTheta*sin(phiT);
-      float pz = p*cos(thetaT);
-      float e  =  pow (139.570,2) + /// @todo Get value from somewhere. Also, the TrackParticle took the Pion mass - do we really want to do this? We have ParticleHypo?
-        pow( px,2) + pow( py,2) + pow( pz,2);
-      m_p4.SetPxPyPzE( px, py, pz, sqrt(e) );
-      m_p4Cached = true;
-    }
-  // Return the cached object:
     return m_p4;
   }
 
@@ -79,21 +65,10 @@ namespace xAOD {
   }
   
   /// set the 4-vec
-  void TrackCaloCluster_v1::setP4(float pt, float eta, float phi, float m) {
+  void TrackCaloCluster_v1::setP4(TrackCaloCluster_v1::FourMom_t& p) {
     
-    const static Accessor<float> accPt("pt");
-    accPt(*this) = pt;
-    
-    const static Accessor<float> accEta("eta");
-    accEta(*this) = eta;
-    
-    const static Accessor<float> accPhi("phi");
-    accPhi(*this) = phi;
-    
-    const static Accessor<float> accM("m");
-    accM(*this) = m;
-    
-    m_p4Cached = false;
+    m_p4 = p;
+
   }
     
   TrackCaloCluster_v1::Taste& TrackCaloCluster_v1::getTaste() const {

Event/xAOD/xAODTrackCaloCluster/xAODTrackCaloCluster/selection.xml

@@ -4,17 +4,9 @@
   <!-- TrackCaloCluster_v1 dictionaries: -->
   <class name="xAOD::TrackCaloCluster_v1">
          <field name="m_p4" transient="true"/>
-         <field name="m_p4Cached" transient="true"/>
+         <field name="m_taste" transient="true"/>
   </class>
   
-  <read sourceClass="xAOD::TrackCaloCluster_v1" version="[1-]"
-        targetClass="xAOD::TrackCaloCluster_v1"
-        source="" target="m_p4Cached">
-    <![CDATA[
-      m_p4Cached = false;
-     ]]>
-  </read>
-  
   <class name="xAOD::TrackCaloClusterAuxContainer_v1"
          id="E3492C37-2469-4346-BCBA-7A18CACD46AC"/>
   <class name="xAOD::TrackCaloClusterContainer_v1"

Event/xAOD/xAODTrackCaloCluster/xAODTrackCaloCluster/versions/TrackCaloCluster_v1.h

@@ -74,7 +74,7 @@ namespace xAOD {
     /// Set the taste of the TrackCaloCluster
     void setTaste(Taste&);
     /// set the 4-vec
-    void setP4(float pt, float eta, float phi, float m=0.0);
+    void setP4(FourMom_t&);
     /// Get the taste of the TrackCaloCluster
     Taste& getTaste() const;
     /// @}
@@ -82,8 +82,7 @@ namespace xAOD {
   private:
     /// Cached 4-momentum object.
     mutable FourMom_t m_p4;
-    /// Cache state of the internal 4-momentum (reset from the streamer).
-    mutable bool m_p4Cached;
+
     /// This is caching the Type of TrackCaloCluster - Charged - Neutral - Both
     mutable TrackCaloCluster_v1::Taste m_taste;
     

Reconstruction/RecoAlgs/TrackParticleAssociationAlgs/src/TrackParticleCellAssociationAlg.cxx

@@ -24,6 +24,7 @@ TrackParticleCellAssociationAlg::TrackParticleCellAssociationAlg(const std::stri
   declareProperty("ParticleCaloCellAssociationTool",m_caloCellAssociationTool);
   declareProperty("TrackParticleContainerName",m_trackParticleCollectionName = "InDetTrackParticles" );
   declareProperty("PtCut", m_ptCut = 25000. );
+  declareProperty("OutputCollectionPostFix", m_outputPostFix = "" );
 }
 
 TrackParticleCellAssociationAlg::~TrackParticleCellAssociationAlg()
@@ -34,7 +35,7 @@ TrackParticleCellAssociationAlg::~TrackParticleCellAssociationAlg()
 StatusCode TrackParticleCellAssociationAlg::initialize()
 {
   ATH_CHECK(m_caloCellAssociationTool.retrieve());
-  ATH_CHECK(m_trackSelector.retrieve());
+  // ATH_CHECK(m_trackSelector.retrieve());
 
   return StatusCode::SUCCESS; 
 }
@@ -43,7 +44,7 @@ StatusCode TrackParticleCellAssociationAlg::execute()
 {
 
   // get track particles
-  xAOD::TrackParticleContainer* trackParticles = 0;
+  const xAOD::TrackParticleContainer* trackParticles = 0;
   if(evtStore()->contains<xAOD::TrackParticleContainer>(m_trackParticleCollectionName)) {
     if(evtStore()->retrieve(trackParticles,m_trackParticleCollectionName).isFailure()) {
       ATH_MSG_FATAL( "Unable to retrieve " << m_trackParticleCollectionName );
@@ -55,8 +56,8 @@ StatusCode TrackParticleCellAssociationAlg::execute()
   }
 
   // create strings for locations based on input track collection
-  std::string clusterContainerName = m_trackParticleCollectionName + "AssociatedClusters";
-  std::string associationContainerName = m_trackParticleCollectionName + "ClusterAssociations";
+  std::string clusterContainerName = m_trackParticleCollectionName + "AssociatedClusters" + m_outputPostFix;
+  std::string associationContainerName = m_trackParticleCollectionName + "ClusterAssociations" + m_outputPostFix;
 
   // Create the xAOD container and its auxiliary store:
   xAOD::CaloClusterContainer* xaod = CaloClusterStoreHelper::makeContainer(&(*evtStore()),clusterContainerName,msg());
@@ -80,7 +81,8 @@ StatusCode TrackParticleCellAssociationAlg::execute()
 
     // slect track
     const xAOD::TrackParticle* tp = (*trackParticles)[i];
-    if( !m_trackSelector->decision(*tp) || tp->pt() < m_ptCut ) continue;
+    // if( !m_trackSelector->decision(*tp) || tp->pt() < m_ptCut ) continue;
+    if( tp->pt() < m_ptCut ) continue;
 
     // get ParticleCellAssociation
     ATH_MSG_DEBUG(" Selected track: pt " << tp->pt() << " eta " << tp->eta() << " phi " << tp->phi() );

Reconstruction/RecoAlgs/TrackParticleAssociationAlgs/src/TrackParticleCellAssociationAlg.h

@@ -35,6 +35,7 @@ class TrackParticleCellAssociationAlg : public AthAlgorithm
 
   std::string m_trackParticleCollectionName;
   double m_ptCut;
+  std::string m_outputPostFix;
 };
 
 

Reconstruction/RecoAlgs/TrackParticleAssociationAlgs/src/TrackParticleClusterAssociationAlg.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrackParticleClusterAssociationAlg.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODCaloEvent/CaloClusterContainer.h"
+#include "xAODCaloEvent/CaloClusterAuxContainer.h"
+#include "xAODCaloEvent/CaloCluster.h"
+#include "xAODAssociations/TrackParticleClusterAssociation.h"
+#include "xAODAssociations/TrackParticleClusterAssociationContainer.h"
+#include "xAODAssociations/TrackParticleClusterAssociationAuxContainer.h"
+
+#include "TrkToolInterfaces/ITrackSelectorTool.h"
+#include "RecoToolInterfaces/IParticleCaloClusterAssociationTool.h"
+#include "TrackToCalo/CrossedCaloCellHelper.h"
+#include "CaloUtils/CaloClusterStoreHelper.h"
+
+TrackParticleClusterAssociationAlg::TrackParticleClusterAssociationAlg(const std::string& name, ISvcLocator* pSvcLocator):
+  AthAlgorithm(name,pSvcLocator),
+  m_caloClusterAssociationTool("Rec::ParticleCaloClusterAssociationTool/ParticleCaloClusterAssociationTool"),
+  m_trackSelector("InDet::InDetDetailedTrackSelectorTool/MuonCombinedInDetDetailedTrackSelectorTool") {  
+
+  declareProperty("ParticleCaloClusterAssociationTool",m_caloClusterAssociationTool);
+  declareProperty("TrackParticleContainerName",m_trackParticleCollectionName = "InDetTrackParticles" );
+  declareProperty("PtCut", m_ptCut = 25000. );
+  declareProperty("OutputCollectionPostFix", m_outputPostFix = "" );
+}
+
+TrackParticleClusterAssociationAlg::~TrackParticleClusterAssociationAlg()
+{
+
+}
+
+StatusCode TrackParticleClusterAssociationAlg::initialize()
+{
+  ATH_CHECK(m_caloClusterAssociationTool.retrieve());
+  // ATH_CHECK(m_trackSelector.retrieve());
+
+  return StatusCode::SUCCESS; 
+}
+
+StatusCode TrackParticleClusterAssociationAlg::execute()
+{
+
+  // get track particles
+  const xAOD::TrackParticleContainer* trackParticles = 0;
+  if(evtStore()->contains<xAOD::TrackParticleContainer>(m_trackParticleCollectionName)) {
+    if(evtStore()->retrieve(trackParticles,m_trackParticleCollectionName).isFailure()) {
+      ATH_MSG_FATAL( "Unable to retrieve " << m_trackParticleCollectionName );
+      return StatusCode::FAILURE;
+    }
+  }else{
+    // in case nothing is found return
+    return StatusCode::SUCCESS;
+  }
+
+  // create strings for locations based on input track collection
+  // std::string clusterContainerName = m_trackParticleCollectionName + "AssociatedClusters" + m_outputPostFix;
+  std::string associationContainerName = m_trackParticleCollectionName + "ClusterAssociations" + m_outputPostFix;
+
+/*   // Create the xAOD container and its auxiliary store:
+  xAOD::CaloClusterContainer* xaod = CaloClusterStoreHelper::makeContainer(&(*evtStore()),clusterContainerName,msg());
+  if ( !xaod ) {
+    ATH_MSG_WARNING ("makeContainer failed");
+    return StatusCode::SUCCESS;
+  }
+  ATH_MSG_DEBUG( "Recorded CaloClusterContainer with key: " << clusterContainerName );  */   
+
+  // Create the xAOD container and its auxiliary store:
+  xAOD::TrackParticleClusterAssociationContainer* xaoda = new xAOD::TrackParticleClusterAssociationContainer();
+  ATH_CHECK( evtStore()->record( xaoda, associationContainerName ) );
+
+  xAOD::TrackParticleClusterAssociationAuxContainer* auxa = new xAOD::TrackParticleClusterAssociationAuxContainer();
+  ATH_CHECK( evtStore()->record( auxa, associationContainerName + "Aux." ) );
+  xaoda->setStore( auxa );
+  ATH_MSG_DEBUG( "Recorded TrackParticleClusterAssociationContainer with key: " << associationContainerName );    
+
+  unsigned int ntracks = 0;
+  for( unsigned int i=0;i<trackParticles->size();++i ){
+
+    // slect track
+    const xAOD::TrackParticle* tp = (*trackParticles)[i];
+    // if( !m_trackSelector->decision(*tp) || tp->pt() < m_ptCut ) continue;
+    if( tp->pt() < m_ptCut ) continue;
+
+    // get ParticleCellAssociation
+    ATH_MSG_DEBUG(" Selected track: pt " << tp->pt() << " eta " << tp->eta() << " phi " << tp->phi() );
+    const Rec::ParticleClusterAssociation* association = 0;
+    if( !m_caloClusterAssociationTool->particleClusterAssociation(*tp,association,0.1) ){
+      ATH_MSG_DEBUG("failed to obtain the ParticleClusterAssociation");
+      continue;
+    }
+
+    // require container as it should be there
+    if( !association->container() ){
+      ATH_MSG_WARNING("Failed to obtain CaloClusterContainer from ParticleCellAssociation");
+      continue;
+    }
+    
+    // create element links
+    ElementLink< xAOD::TrackParticleContainer > trackLink(m_trackParticleCollectionName,i);
+    std::vector< ElementLink< xAOD::CaloClusterContainer > > caloClusterLinks;
+    
+    for(auto cluster : association->data())
+    {
+        ElementLink< xAOD::CaloClusterContainer >   clusterLink("CaloCalTopoClusters",cluster->index());
+        // if valid create TrackParticleClusterAssociation
+        if( clusterLink.isValid() ){
+            caloClusterLinks.push_back( clusterLink );
+        }
+        ATH_MSG_DEBUG(" New cluster: eta " << cluster->eta() << " phi " << cluster->phi() );
+    }
+    
+    if( trackLink.isValid() && caloClusterLinks.size()!=0){
+        xAOD::TrackParticleClusterAssociation* trackAssociation = new xAOD::TrackParticleClusterAssociation();
+        xaoda->push_back(trackAssociation);
+        trackAssociation->setTrackParticleLink( trackLink );
+        trackAssociation->setCaloClusterLinks(caloClusterLinks);
+        ATH_MSG_DEBUG("added association");
+        ++ntracks;
+    }
+    else{
+        if( !trackLink.isValid() )   ATH_MSG_WARNING("Failed to create track ElementLink ");
+        if( caloClusterLinks.size()==0 ) ATH_MSG_WARNING("Failed to create cluster ElementLink ");
+    }
+   
+  }
+
+  ATH_MSG_DEBUG(" Total number of selected tracks: " << ntracks );
+
+  // if (CaloClusterStoreHelper::finalizeClusters(&(*evtStore()), xaod,clusterContainerName,msg()).isFailure() ) 
+    // ATH_MSG_WARNING("finalizeClusters failed");
+
+  return StatusCode::SUCCESS;
+}
+
+
+StatusCode TrackParticleClusterAssociationAlg::finalize()
+{
+  return StatusCode::SUCCESS;
+}

Reconstruction/RecoAlgs/TrackParticleAssociationAlgs/src/TrackParticleClusterAssociationAlg.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKPARTICLEASSOCIATIONALGS_TRACKPARTICLECLUSTERASSOCIATIONALG_H
+#define TRACKPARTICLEASSOCIATIONALGS_TRACKPARTICLECLUSTERASSOCIATIONALG_H
+
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "GaudiKernel/ToolHandle.h"
+#include <string>
+
+
+namespace Rec {
+  class IParticleCaloClusterAssociationTool;
+}
+namespace Trk {
+  class ITrackSelectorTool;
+}
+
+class TrackParticleClusterAssociationAlg : public AthAlgorithm
+{
+ public:
+  TrackParticleClusterAssociationAlg(const std::string& name, ISvcLocator* pSvcLocator);
+
+  ~TrackParticleClusterAssociationAlg();
+
+  StatusCode initialize();
+  StatusCode execute();
+  StatusCode finalize();
+
+ private:
+
+  ToolHandle<Rec::IParticleCaloClusterAssociationTool> m_caloClusterAssociationTool;
+  ToolHandle <Trk::ITrackSelectorTool>              m_trackSelector; //!< Tool to select tracks
+
+  std::string m_trackParticleCollectionName;
+  double m_ptCut;
+  std::string m_outputPostFix;
+};
+
+
+#endif

Reconstruction/RecoAlgs/TrackParticleAssociationAlgs/src/components/TrackParticleAssociationAlgs_entries.cxx

 #include "GaudiKernel/DeclareFactoryEntries.h"
 #include "../TrackParticleCellAssociationAlg.h"
+#include "../TrackParticleClusterAssociationAlg.h"
 
 DECLARE_ALGORITHM_FACTORY( TrackParticleCellAssociationAlg )
+DECLARE_ALGORITHM_FACTORY( TrackParticleClusterAssociationAlg )
 
 DECLARE_FACTORY_ENTRIES( TrackParticleAssociationAlgs )
 {
   DECLARE_ALGORITHM( TrackParticleCellAssociationAlg )
+  DECLARE_ALGORITHM( TrackParticleClusterAssociationAlg )
 }

Reconstruction/RecoEvent/ParticleCaloExtension/ParticleCaloExtension/ParticleClusterAssociation.h

@@ -16,7 +16,7 @@ namespace Trk {
 namespace Rec {
   
   /** class storing calorimeter cell association with IParticle objects */
-  class ParticleClusterAssociation  : public ParticleCaloAssociation< ElementLink<xAOD::CaloClusterContainer> > {
+  class ParticleClusterAssociation  : public ParticleCaloAssociation< const xAOD::CaloCluster* > {
   public:
     /** constructor taking CaloExtension, a vector of cells and a cone size as arguments */
     ParticleClusterAssociation( const Trk::CaloExtension& caloExtension, Data&& clusters, float coneSize, const xAOD::CaloClusterContainer* container = 0);

Reconstruction/RecoEvent/ParticleCaloExtension/src/ParticleClusterAssociation.cxx

@@ -9,7 +9,7 @@ namespace Rec {
 
   ParticleClusterAssociation::ParticleClusterAssociation( const Trk::CaloExtension& caloExtension, Data&& clusters, 
                                                           float coneSize, const xAOD::CaloClusterContainer* container ) :
-    ParticleCaloAssociation< ElementLink<xAOD::CaloClusterContainer> >(caloExtension,std::move(clusters),coneSize),
+    ParticleCaloAssociation< const xAOD::CaloCluster* >(caloExtension,std::move(clusters),coneSize),
     m_container(container) {
   }
 

Reconstruction/RecoTools/TrackToCalo/CMakeLists.txt

@@ -14,6 +14,7 @@ atlas_depends_on_subdirs( PUBLIC
                           GaudiKernel
                           Reconstruction/RecoEvent/ParticleCaloExtension
                           Reconstruction/RecoTools/RecoToolInterfaces
+                          Reconstruction/TrackCaloClusterRec/TrackCaloClusterRecInterfaces
                           Tracking/TrkEvent/TrkCaloExtension
                           Tracking/TrkEvent/TrkParametersIdentificationHelpers
                           PRIVATE

Reconstruction/RecoTools/TrackToCalo/src/ParticleCaloCellAssociationTool.cxx

@@ -4,8 +4,6 @@
 
 #include "ParticleCaloCellAssociationTool.h"
 // forward declares
-#include "RecoToolInterfaces/IParticleCaloExtensionTool.h"
-
 #include "ParticleCaloExtension/ParticleCellAssociationCollection.h"
 
 #include "TrackToCalo/CaloCellHelpers.h"
@@ -298,7 +296,7 @@ namespace Rec {
 
     // get the extrapolation into the calo
     const Trk::CaloExtension* caloExtension = 0;
-    if( !m_caloExtensionTool->caloExtension(particle,caloExtension) ) {
+    if( !m_caloExtensionTool->particleToCaloExtrapolate(particle,caloExtension) ) {
       ATH_MSG_DEBUG("Failed to get calo extension");      
       return false;
     }

Reconstruction/RecoTools/TrackToCalo/src/ParticleCaloCellAssociationTool.h

@@ -20,8 +20,9 @@ authors : Niels van Eldik (CERN PH-ATC)
 
 #include "PathLengthUtils.h"
 
+#include "TrackCaloClusterRecInterfaces/IParticleExtrapolationTool.h"
+
 namespace Trk {
-  class IParticleCaloExtensionTool;
   class CaloExtension;
 }
 
@@ -65,7 +66,7 @@ namespace Rec {
     void associateCells( const CaloCellContainer& container, const Trk::CaloExtension& caloExtension, float dr,
                          std::vector<const CaloCell*>& cells ) const;
 
-    ToolHandle< Trk::IParticleCaloExtensionTool >  m_caloExtensionTool;
+    ToolHandle< IParticleExtrapolationTool >  m_caloExtensionTool;
     std::string m_cellContainerName;
     double      m_coneSize;
     mutable Trk::CaloCellSelectorLayerdR m_defaultSelector;

Reconstruction/RecoTools/TrackToCalo/src/ParticleCaloClusterAssociationTool.cxx

@@ -4,7 +4,6 @@
 
 #include "ParticleCaloClusterAssociationTool.h"
 // forward declares
-#include "RecoToolInterfaces/IParticleCaloExtensionTool.h"
 
 #include "ParticleCaloExtension/ParticleClusterAssociationCollection.h"
 #include "ParticlesInConeTools/ICaloClustersInConeTool.h"
@@ -19,7 +18,8 @@ namespace Rec {
   ParticleCaloClusterAssociationTool::ParticleCaloClusterAssociationTool(const std::string& t, const std::string& n, const IInterface*  p )
     : AthAlgTool(t,n,p),
       m_caloExtensionTool("Trk::ParticleCaloExtensionTool/ParticleCaloExtensionTool"),
-      m_clustersInConeTool("xAOD::CaloClustersInConeTool/CaloClustersInConeTool")
+      m_clustersInConeTool("xAOD::CaloClustersInConeTool/CaloClustersInConeTool"),
+      m_containerName("CaloCalTopoClusters")
   {
 
     declareInterface<IParticleCaloClusterAssociationTool>(this);
@@ -50,7 +50,7 @@ namespace Rec {
                                                                        const xAOD::CaloClusterContainer* container, bool useCaching ) const {
 
 
-    ATH_MSG_DEBUG(" particleCellAssociation: ptr " << &particle << " dr " << dr << " useCaching " << useCaching);
+    ATH_MSG_DEBUG(" particleClusterAssociation: ptr " << &particle << " dr " << dr << " useCaching " << useCaching);
 
     // reset pointer
     association = 0;
@@ -80,7 +80,7 @@ namespace Rec {
 
     // get the extrapolation into the calo
     const Trk::CaloExtension* caloExtension = 0;
-    if( !m_caloExtensionTool->caloExtension(particle,caloExtension) ) {
+    if( !m_caloExtensionTool->particleToCaloExtrapolate(particle,caloExtension) ) {
       ATH_MSG_DEBUG("Failed to get calo extension");      
       return false;
     }
@@ -89,7 +89,12 @@ namespace Rec {
       return false;
     }
     
-
+    //retrieve the cluster container if not provided, return false it retrieval failed
+    if( !container && !(container = getClusterContainer()) ) {
+      ATH_MSG_DEBUG("Failed to get calo cluster container");      
+      return false;
+    }
+    
     // update cone size in case it is smaller than the default
     if( dr < m_coneSize ) dr = m_coneSize;
     ParticleClusterAssociation::Data clusters;
@@ -146,14 +151,26 @@ namespace Rec {
         float dPhi = P4Helpers::deltaPhi( (*container)[i]->phi(), phi);
         float dEta = (*container)[i]->eta()-eta;
         float dr2  = dPhi*dPhi+ dEta*dEta;
-        if( dr2 < dr2Cut ) clusters.push_back( ElementLink<xAOD::CaloClusterContainer>(*container,i) );
+        if( dr2 < dr2Cut ) clusters.push_back( (*container)[i]);
       }
     }else{
       if( !m_clustersInConeTool->particlesInCone(eta,phi,dr,clusters) ) {
         ATH_MSG_WARNING("Failed to get clusters");
       }
     }
-    ATH_MSG_DEBUG("associated cells " << clusters.size() << " using cone " << dr );
+    ATH_MSG_DEBUG("associated clusters " << clusters.size() << " using cone " << dr );
+  }
+  
+  const xAOD::CaloClusterContainer* ParticleCaloClusterAssociationTool::getClusterContainer() const {
+
+    const xAOD::CaloClusterContainer* container = 0;
+    //retrieve the cell container
+    if( evtStore()->retrieve(container, m_containerName).isFailure() || !container ) {
+      ATH_MSG_WARNING( "Unable to retrieve the cluster container  " << m_containerName << " container ptr " << container );
+      return 0;
+    }
+    if( container ) ATH_MSG_DEBUG("Retrieved cluster container " << container->size());
+    return container;
   }
 
 } // end of namespace Trk

Reconstruction/RecoTools/TrackToCalo/src/ParticleCaloClusterAssociationTool.h

@@ -17,8 +17,9 @@ authors : Niels van Eldik (CERN PH-ATC)
 
 #include "ParticleCaloExtension/ParticleClusterAssociation.h"
 
+#include "TrackCaloClusterRecInterfaces/IParticleExtrapolationTool.h"
+
 namespace Trk {
-  class IParticleCaloExtensionTool;
   class CaloExtension;
 }
 namespace xAOD {
@@ -61,8 +62,10 @@ namespace Rec {
                             const Trk::CaloExtension& caloExtension,
                             float dr,
                             ParticleClusterAssociation::Data& clusters ) const;
+    
+    const xAOD::CaloClusterContainer* getClusterContainer() const;
 
-    ToolHandle< Trk::IParticleCaloExtensionTool >  m_caloExtensionTool;
+    ToolHandle< IParticleExtrapolationTool >  m_caloExtensionTool;
     // FIXME: mutable
     mutable ToolHandle< xAOD::ICaloClustersInConeTool >     m_clustersInConeTool;
     std::string m_containerName;

Reconstruction/RecoTools/TrackToCalo/src/TrackParticleCaloExtensionAlg.cxx

@@ -3,7 +3,6 @@
 */
 
 #include "TrackParticleCaloExtensionAlg.h"
-#include "RecoToolInterfaces/IParticleCaloExtensionTool.h"
 #include "RecoToolInterfaces/IParticleCaloCellAssociationTool.h"
 #include "TrkToolInterfaces/ITrackSelectorTool.h"
 #include "xAODTracking/TrackParticleContainer.h"

Reconstruction/RecoTools/TrackToCalo/src/TrackParticleCaloExtensionAlg.h

@@ -17,9 +17,10 @@
 #include "AthenaBaseComps/AthAlgorithm.h"
 #include "GaudiKernel/ToolHandle.h"
 
+#include "TrackCaloClusterRecInterfaces/IParticleExtrapolationTool.h"
+
 namespace Trk {
   class ITrackSelectorTool;
-  class IParticleCaloExtensionTool;
 }
 namespace Rec {
   class IParticleCaloCellAssociationTool;
@@ -38,7 +39,7 @@ public:
   StatusCode finalize();
 
 private:
-  ToolHandle <Trk::IParticleCaloExtensionTool>       m_caloExtensionTool; //!< Tool to make the step-wise extrapolation
+  ToolHandle < IParticleExtrapolationTool>       m_caloExtensionTool; //!< Tool to make the step-wise extrapolation
   ToolHandle <Rec::IParticleCaloCellAssociationTool> m_caloCellAssociationTool; //!< Tool to make the step-wise extrapolation
   ToolHandle <Trk::ITrackSelectorTool>               m_trackSelector; //!< Tool to select tracks
 

Reconstruction/TrackCaloClusterRec/TrackCaloClusterRecAlgs/CMakeLists.txt

 ################################################################################
-# Package: TrackCaloClusterAlgs
+# Package: TrackCaloClusterRecAlgs
 ################################################################################
 
 # Declare the package name:
-atlas_subdir( TrackCaloClusterAlgs )
+atlas_subdir( TrackCaloClusterRecAlgs )
 
 # Declare the package's dependencies:
 atlas_depends_on_subdirs( PRIVATE
@@ -15,13 +15,12 @@ atlas_depends_on_subdirs( PRIVATE
                           Event/xAOD/xAODBase
                           Event/xAOD/xAODTracking
                           Event/xAOD/xAODAssociations
-                          Event/xAOD/xAODTrackCaloCluster
-                          Reconstruction/TrackCaloClusterRec/TrackCaloClusterRecInterfaces                    )
+                          Event/xAOD/xAODTrackCaloCluster                )
 
 # Component(s) in the package:
-atlas_add_component( TrackCaloClusterAlgs
+atlas_add_component( TrackCaloClusterRecAlgs
                      src/*.cxx
                      src/components/*.cxx
                      INCLUDE_DIRS 
                      LINK_LIBRARIES AthenaBaseComps GaudiKernel AtlasDetDescr xAODBase xAODTracking xAODAssociations xAODTrackCaloCluster TrkParametersIdentificationHelpers )
-
+                     
\ No newline at end of file

Reconstruction/TrackCaloClusterRec/TrackCaloClusterRecAlgs/TrackCaloClusterRecAlgs/TrackCaloClusterRecAlg.h

@@ -24,6 +24,9 @@ private:
     
   ///TrackParticle container's name
   std::string m_trkParticleName;
+  
+  ///Output Collection container's name postfix
+  std::string m_outputPostFix;
     
 };