diff --git a/Event/xAOD/xAODTrackingCnv/CMakeLists.txt b/Event/xAOD/xAODTrackingCnv/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..10cdadba0e8f19433b0dcd8c125e671931511056
--- /dev/null
+++ b/Event/xAOD/xAODTrackingCnv/CMakeLists.txt
@@ -0,0 +1,36 @@
+################################################################################
+# Package: xAODTrackingCnv
+################################################################################
+
+# Declare the package name:
+atlas_subdir( xAODTrackingCnv )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+ Event/xAOD/xAODTracking
+ Tracking/TrkEvent/TrkTrack
+ PRIVATE
+ Control/AthenaBaseComps
+ Control/AthenaKernel
+ Event/EventPrimitives
+ GaudiKernel
+ Generators/GeneratorObjects
+ PhysicsAnalysis/MCTruthClassifier
+ Reconstruction/Particle
+ Reconstruction/ParticleTruth
+ Tracking/TrkEvent/TrkLinks
+ Tracking/TrkEvent/TrkParticleBase
+ Tracking/TrkEvent/TrkTrackLink
+ Tracking/TrkEvent/TrkTruthData
+ Tracking/TrkEvent/VxVertex
+ Tracking/TrkTools/TrkToolInterfaces )
+
+# Component(s) in the package:
+atlas_add_component( xAODTrackingCnv
+ src/*.cxx
+ src/components/*.cxx
+ LINK_LIBRARIES xAODTracking TrkTrack AthenaBaseComps AthenaKernel EventPrimitives GaudiKernel GeneratorObjects MCTruthClassifierLib Particle ParticleTruth TrkLinks TrkParticleBase TrkTruthData VxVertex TrkToolInterfaces )
+
+# Install files from the package:
+atlas_install_headers( xAODTrackingCnv )
+
diff --git a/Event/xAOD/xAODTrackingCnv/cmt/requirements b/Event/xAOD/xAODTrackingCnv/cmt/requirements
index 3924f0383dbd6cc8d647cde83e7462684729effe..5ae167e0925c80ed3381c9ad88ee0a6a5a82eb81 100644
--- a/Event/xAOD/xAODTrackingCnv/cmt/requirements
+++ b/Event/xAOD/xAODTrackingCnv/cmt/requirements
@@ -8,6 +8,8 @@ use AtlasPolicy AtlasPolicy-*
public
use AtlasPolicy AtlasPolicy-*
+use TrkTrack TrkTrack-* Tracking/TrkEvent
+use xAODTracking xAODTracking-* Event/xAOD
private
use AthenaBaseComps AthenaBaseComps-* Control
use AthenaKernel AthenaKernel-* Control
@@ -19,11 +21,9 @@ use Particle Particle-* Reconstruction
use ParticleTruth ParticleTruth-* Reconstruction
use TrkParticleBase TrkParticleBase-* Tracking/TrkEvent
use TrkToolInterfaces TrkToolInterfaces-* Tracking/TrkTools
-use TrkTrack TrkTrack-* Tracking/TrkEvent
use TrkTrackLink TrkTrackLink-* Tracking/TrkEvent
use TrkTruthData TrkTruthData-* Tracking/TrkEvent
use VxVertex VxVertex-* Tracking/TrkEvent
-use xAODTracking xAODTracking-* Event/xAOD
use TrkLinks TrkLinks-* Tracking/TrkEvent
end_private
diff --git a/Event/xAOD/xAODTrackingCnv/src/RecTrackParticleContainerCnvTool.cxx b/Event/xAOD/xAODTrackingCnv/src/RecTrackParticleContainerCnvTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..7cc27b0d2954ff346f76770b8f43733968cabad7
--- /dev/null
+++ b/Event/xAOD/xAODTrackingCnv/src/RecTrackParticleContainerCnvTool.cxx
@@ -0,0 +1,81 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id$
+// EDM include(s):
+#include "xAODTracking/TrackParticle.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "Particle/TrackParticleContainer.h"
+
+// Local include(s):
+#include "RecTrackParticleContainerCnvTool.h"
+
+
+
+namespace xAODMaker {
+
+ RecTrackParticleContainerCnvTool::RecTrackParticleContainerCnvTool( const std::string& type,
+ const std::string& name,
+ const IInterface* parent )
+ : AthAlgTool( type, name, parent ),
+ m_particleCreator("Trk::TrackParticleCreatorTool/TrackParticleCreatorTool")
+ {
+
+ // Declare the interface(s) provided by the tool:
+ declareInterface< IRecTrackParticleContainerCnvTool >( this );
+ declareProperty( "TrackParticleCreator" , m_particleCreator );
+ }
+
+ StatusCode RecTrackParticleContainerCnvTool::initialize() {
+ // Greet the user:
+ ATH_MSG_INFO( "Initializing - Package version: " << PACKAGE_VERSION );
+ ATH_CHECK( m_particleCreator.retrieve() );
+
+ return StatusCode::SUCCESS;
+ }
+
+ StatusCode RecTrackParticleContainerCnvTool::convert( const Rec::TrackParticleContainer* aod,
+ xAOD::TrackParticleContainer* xaod ) {
+
+ ATH_MSG_DEBUG( "Sizes of containers before conversion: aod, xaod: " << aod->size() << ", " << xaod->size() );
+ Rec::TrackParticleContainer::const_iterator itr = aod->begin();
+ Rec::TrackParticleContainer::const_iterator end = aod->end();
+
+ for( ;itr!=end;++itr ) {
+ // Create the xAOD object:
+ if (!(*itr)) {
+ ATH_MSG_WARNING("WTaF? Empty element in container!");
+ continue;
+ }
+ xAOD::TrackParticle* particle = createParticle(xaod, aod, *itr);
+
+ if(!particle){
+ ATH_MSG_WARNING("Failed to create a TrackParticle");
+ continue;
+ }
+ }
+
+ ATH_MSG_DEBUG( "Sizes of containers after conversion: aod, xaod: " << aod->size() << ", " << xaod->size() );
+
+ return StatusCode::SUCCESS;
+ }
+
+
+ xAOD::TrackParticle* RecTrackParticleContainerCnvTool::createParticle( xAOD::TrackParticleContainer* xaod,
+ const Rec::TrackParticleContainer* /**container*/,
+ const Rec::TrackParticle* tp)
+ {
+ // create the xAOD::TrackParticle, the pointer is added to the container in the function
+ return m_particleCreator->createParticle( *tp, xaod );
+ } // createParticleAndTruth
+
+ StatusCode RecTrackParticleContainerCnvTool::setParticleCreatorTool(ToolHandle<Trk::ITrackParticleCreatorTool> *tool)
+ {
+ ATH_MSG_DEBUG( "In setParticleCreatorTool" );
+ m_particleCreator = *tool;
+
+ return StatusCode::SUCCESS;
+ }
+
+} // namespace xAODMaker
diff --git a/Event/xAOD/xAODTrackingCnv/src/RecTrackParticleContainerCnvTool.h b/Event/xAOD/xAODTrackingCnv/src/RecTrackParticleContainerCnvTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..42939dd865fa1d24672ebb46abc7288781dde7ce
--- /dev/null
+++ b/Event/xAOD/xAODTrackingCnv/src/RecTrackParticleContainerCnvTool.h
@@ -0,0 +1,51 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id$
+#ifndef XAODTRACKINGCNV_RECTRACKPARTICLECONTAINERCNVTOOL_H
+#define XAODTRACKINGCNV_RECTRACKPARTICLECONTAINERCNVTOOL_H
+
+// Gaudi/Athena include(s):
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+
+// converting tool that will be invoked
+#include "TrkToolInterfaces/ITrackParticleCreatorTool.h"
+
+// Local include(s):
+#include "xAODTrackingCnv/IRecTrackParticleContainerCnvTool.h"
+
+namespace xAODMaker {
+
+ class RecTrackParticleContainerCnvTool : public AthAlgTool,
+ public virtual IRecTrackParticleContainerCnvTool {
+
+ public:
+ /// Regular AlgTool constructor
+ RecTrackParticleContainerCnvTool( const std::string& type, const std::string& name,
+ const IInterface* parent );
+
+ /// Function initialising the tool
+ virtual StatusCode initialize();
+
+ /// Function that fills an existing xAOD::TrackParticleContainer
+ virtual StatusCode convert( const Rec::TrackParticleContainer* aod,
+ xAOD::TrackParticleContainer* xaod );
+
+ /// allow other algorithms to pass the tool in order to preserve initialisation
+ virtual StatusCode setParticleCreatorTool(ToolHandle<Trk::ITrackParticleCreatorTool> *tool);
+
+ private:
+ ToolHandle<Trk::ITrackParticleCreatorTool> m_particleCreator;
+
+ inline xAOD::TrackParticle* createParticle(xAOD::TrackParticleContainer* xaod, const Rec::TrackParticleContainer* container, const Rec::TrackParticle* tp) ;
+
+
+ }; // class RecTrackParticleContainerCnvTool definition
+
+} // xAODMaker namespace
+
+#endif // XAODTRACKINGCNV_RECTRACKPARTICLECONTAINERCNVTOOL_H
diff --git a/Event/xAOD/xAODTrackingCnv/src/TrackCollectionCnvTool.cxx b/Event/xAOD/xAODTrackingCnv/src/TrackCollectionCnvTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..98a3e9a84368ba3f08646a19f5b985071445d0fa
--- /dev/null
+++ b/Event/xAOD/xAODTrackingCnv/src/TrackCollectionCnvTool.cxx
@@ -0,0 +1,81 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// EDM include(s):
+// $Id$
+#include "xAODTracking/TrackParticle.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "TrkTrack/TrackCollection.h"
+
+// Local include(s):
+#include "TrackCollectionCnvTool.h"
+
+namespace xAODMaker {
+
+ TrackCollectionCnvTool::TrackCollectionCnvTool( const std::string& type,
+ const std::string& name,
+ const IInterface* parent )
+ : AthAlgTool( type, name, parent ),
+ m_particleCreator("Trk::TrackParticleCreatorTool/TrackParticleCreatorTool")
+ {
+
+ // Declare the interface(s) provided by the tool:
+ declareInterface< ITrackCollectionCnvTool >( this );
+ declareProperty( "TrackParticleCreator", m_particleCreator );
+ }
+
+ StatusCode TrackCollectionCnvTool::initialize() {
+ // Greet the user:
+ ATH_MSG_INFO( "Initializing - Package version: " << PACKAGE_VERSION );
+ ATH_CHECK( m_particleCreator.retrieve() );
+
+ return StatusCode::SUCCESS;
+ }
+
+ StatusCode TrackCollectionCnvTool::convert( const TrackCollection* aod,
+ xAOD::TrackParticleContainer* xaod ) {
+
+ ATH_MSG_DEBUG( "Sizes of containers before conversion: aod, xaod: " << aod->size() << ", " << xaod->size() );
+
+ TrackCollection::const_iterator itr = aod->begin();
+ TrackCollection::const_iterator end = aod->end();
+
+ for( ;itr!=end;++itr ) {
+ // Create the xAOD object:
+ if (!(*itr)) {
+ ATH_MSG_WARNING("WTaF? Empty element in container!");
+ continue;
+ }
+ xAOD::TrackParticle* particle = createParticle(*xaod, *aod, **itr);
+
+ if(!particle){
+ ATH_MSG_WARNING("Failed to create a TrackParticle");
+ continue;
+ }
+ }
+
+ ATH_MSG_DEBUG( "Sizes of containers after conversion: aod, xaod: " << aod->size() << ", " << xaod->size() );
+
+ return StatusCode::SUCCESS;
+ }
+
+ xAOD::TrackParticle* TrackCollectionCnvTool::createParticle(xAOD::TrackParticleContainer& xaod,
+ const TrackCollection& container,
+ const Trk::Track& tp) {
+ // create the xAOD::TrackParticle, the pointer is added to the container in the function
+ ElementLink<TrackCollection> trackLink( &tp, container );
+ return m_particleCreator->createParticle( trackLink, &xaod );
+ //no! return m_particleCreator->createParticle( tp, &xaod );
+ }
+
+ StatusCode TrackCollectionCnvTool::setParticleCreatorTool(ToolHandle<Trk::ITrackParticleCreatorTool> *tool)
+ {
+ ATH_MSG_DEBUG( "In setParticleCreatorTool" );
+ m_particleCreator = *tool;
+
+ return StatusCode::SUCCESS;
+ }
+
+} // namespace xAODMaker
+
diff --git a/Event/xAOD/xAODTrackingCnv/src/TrackCollectionCnvTool.h b/Event/xAOD/xAODTrackingCnv/src/TrackCollectionCnvTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..d19ffa1e4794340813f4a16327bfd532f8f826dc
--- /dev/null
+++ b/Event/xAOD/xAODTrackingCnv/src/TrackCollectionCnvTool.h
@@ -0,0 +1,51 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id$
+#ifndef XAODTRACKINGCNV_TRACKCOLLECTIONCNVTOOL_H
+#define XAODTRACKINGCNV_TRACKCOLLECTIONCNVTOOL_H
+
+// Gaudi/Athena include(s):
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+
+// converting tool that will be invoked
+#include "TrkToolInterfaces/ITrackParticleCreatorTool.h"
+
+// Local include(s):
+#include "xAODTrackingCnv/ITrackCollectionCnvTool.h"
+
+namespace xAODMaker {
+
+ class TrackCollectionCnvTool : public AthAlgTool,
+ public virtual ITrackCollectionCnvTool {
+
+ public:
+ /// Regular AlgTool constructor
+ TrackCollectionCnvTool( const std::string& type, const std::string& name,
+ const IInterface* parent );
+
+ /// Function initialising the tool
+ virtual StatusCode initialize();
+
+ /// Function that fills an existing xAOD::TrackParticleContainer
+ virtual StatusCode convert( const TrackCollection* aod,
+ xAOD::TrackParticleContainer* xaod );
+
+ /// allow other algorithms to pass the tool in order to preserve initialisation
+ virtual StatusCode setParticleCreatorTool(ToolHandle<Trk::ITrackParticleCreatorTool> *tool);
+
+ private:
+ ToolHandle<Trk::ITrackParticleCreatorTool> m_particleCreator;
+
+ inline xAOD::TrackParticle* createParticle(xAOD::TrackParticleContainer& xaod, const TrackCollection& container, const Trk::Track& tp) ;
+
+
+ }; // class TrackCollectionCnvTool definition
+
+} // xAODMaker namespace
+
+#endif // XAODTRACKINGCNV_TRACKCOLLECTIONCNVTOOL_H
diff --git a/Event/xAOD/xAODTrackingCnv/src/TrackParticleCnvAlg.cxx b/Event/xAOD/xAODTrackingCnv/src/TrackParticleCnvAlg.cxx
index 29666ac4f195c24a8011dbd09b2f95a605093319..f98efaa7b48f4c501062fed85ee63eaa1430c591 100644
--- a/Event/xAOD/xAODTrackingCnv/src/TrackParticleCnvAlg.cxx
+++ b/Event/xAOD/xAODTrackingCnv/src/TrackParticleCnvAlg.cxx
@@ -20,14 +20,19 @@
// Local include(s):
#include "TrackParticleCnvAlg.h"
+#include "xAODTrackingCnv/ITrackCollectionCnvTool.h"
+#include "xAODTrackingCnv/IRecTrackParticleContainerCnvTool.h"
namespace xAODMaker {
TrackParticleCnvAlg::TrackParticleCnvAlg( const std::string& name,
- ISvcLocator* svcLoc )
+ ISvcLocator* svcLoc )
: AthAlgorithm( name, svcLoc ),
m_particleCreator("Trk::TrackParticleCreatorTool/TrackParticleCreatorTool"),
m_truthClassifier("MCTruthClassifier/MCTruthClassifier"),
+ m_TrackCollectionCnvTool( "xAODMaker::TrackCollectionCnvTool/TrackCollectionCnvTool", this ),
+ m_RecTrackParticleContainerCnvTool( "xAODMaker::RecTrackParticleContainerCnvTool/RecTrackParticleContainerCnvTool", this ),
+ m_truthParticleLinkVec(0),
m_numEvents(0),
m_nTracksProcessed(0),
m_nTrackParticlesCreated(0),
@@ -64,7 +69,7 @@ namespace xAODMaker {
m_numberOfSCTSpoiltHits(0),
m_numberOfTRTHoles(0),
m_numberOfTRTDeadStraws(0),
- m_numberOfTRTTubeHits(0)
+ m_numberOfTRTTubeHits(0)
{
declareProperty( "MCTruthClassifier", m_truthClassifier);
declareProperty( "AODContainerName", m_aodContainerName = "TrackParticleCandidate" );
@@ -79,6 +84,8 @@ namespace xAODMaker {
declareProperty( "ConvertTrackParticles", m_convertAODTrackParticles = true );
declareProperty( "ConvertTracks", m_convertTracks = false );
declareProperty( "PrintIDSummaryInfo", m_IdOutputInfo = false );
+ declareProperty( "TrackCollectionCnvTool", m_TrackCollectionCnvTool );
+ declareProperty( "RecTrackParticleContainerCnvTool", m_RecTrackParticleContainerCnvTool );
}
StatusCode TrackParticleCnvAlg::initialize() {
@@ -88,7 +95,14 @@ namespace xAODMaker {
ATH_MSG_DEBUG( "xAODContainerName = " << m_xaodContainerName );
ATH_CHECK(m_particleCreator.retrieve());
ATH_CHECK(m_truthClassifier.retrieve());
- // Return gracefully:
+ ATH_CHECK( m_TrackCollectionCnvTool.retrieve() );
+ ATH_CHECK( m_RecTrackParticleContainerCnvTool.retrieve() );
+ // to preserve the inisialised parameters of the ParticleCreatorTool:
+ ATH_CHECK( m_TrackCollectionCnvTool->setParticleCreatorTool( &m_particleCreator ) );
+ ATH_CHECK( m_RecTrackParticleContainerCnvTool->setParticleCreatorTool( &m_particleCreator ) );
+
+
+ // Return gracefully:
return StatusCode::SUCCESS;
}
@@ -122,7 +136,6 @@ namespace xAODMaker {
const TrackParticleTruthCollection* aodTruth = 0;
const TrackTruthCollection* trackTruth = 0;
- m_truthParticleLinkVec = 0;
if( m_addTruthLink ){
if (m_convertAODTrackParticles){
aodTruth = evtStore()->tryConstRetrieve<TrackParticleTruthCollection>(m_aodTruthContainerName);
@@ -146,42 +159,72 @@ namespace xAODMaker {
}
}
- if (m_convertTracks) convert(*tracks, trackTruth, m_xaodTracksContainerName);
- if (m_convertAODTrackParticles) convert(*aod, aodTruth, m_xaodContainerName);
+ if (m_convertTracks) convert(*tracks, trackTruth, m_xaodTracksContainerName, m_TrackCollectionCnvTool);
+ if (m_convertAODTrackParticles) convert(*aod, aodTruth, m_xaodContainerName, m_RecTrackParticleContainerCnvTool);
return StatusCode::SUCCESS;
}
- template<typename CONT, typename TRUTHCONT>
- void TrackParticleCnvAlg::convert(const CONT& container, const TRUTHCONT& truth, const std::string& xaodName){
+ template<typename CONT, typename TRUTHCONT, typename CONVTOOL>
+ int TrackParticleCnvAlg::convert(const CONT& container, const TRUTHCONT& truth, const std::string& xaodName, CONVTOOL& conv_tool){
// Create the xAOD container and its auxiliary store:
+
xAOD::TrackParticleContainer* xaod = new xAOD::TrackParticleContainer();
- if( evtStore()->record( xaod, xaodName ).isFailure() ){
- ATH_MSG_ERROR("Couldn't record "<<xaodName);
- return;
- }
xAOD::TrackParticleAuxContainer* aux = new xAOD::TrackParticleAuxContainer();
- if( evtStore()->record( aux, xaodName+ "Aux." ).isFailure() ){
- ATH_MSG_ERROR("Couldn't record "<<xaodName<<"Aux.");
- return;
+
+ if (evtStore()->contains<xAOD::TrackParticleContainer> (xaodName)) {
+ CHECK(evtStore()->overwrite(aux, xaodName+"Aux.", true, false));
+ xaod->setStore( aux );
+ CHECK(evtStore()->overwrite(xaod,xaodName, true, false));
+ ATH_MSG_DEBUG( "Overwrote TrackParticles with key: " << xaodName );
+ }
+ else{
+ CHECK(evtStore()->record(aux, xaodName+"Aux."));
+ xaod->setStore(aux);
+ CHECK(evtStore()->record(xaod, xaodName));
+ ATH_MSG_DEBUG( "Recorded TrackParticles with key: " << xaodName );
+ }
+
+ // convert the track containers separately with the converting tools that are also used by TrigHLTtoxAODTool
+ ATH_MSG_DEBUG( "calling the converting tool for " << xaodName );
+ if( conv_tool->convert( &container, xaod ).isFailure() ) {
+ ATH_MSG_ERROR("Couldn't convert aod to xaod (" << xaodName << ") with the converting tool");
+ return -1;
}
- xaod->setStore( aux );
// Create the xAOD objects:
typename CONT::const_iterator itr = container.begin();
typename CONT::const_iterator end = container.end();
+ xAOD::TrackParticleContainer::iterator itr_xaod = xaod->begin();
+ xAOD::TrackParticleContainer::iterator end_xaod = xaod->end();
+
+ // loop over AOD and converted xAOD for summary info and truth links
for( ;itr!=end;++itr ) {
+ //protect if something went wrong and there is no converted xaod equivalent
+ if( itr_xaod == end_xaod ) {
+ ATH_MSG_ERROR("No xAOD equivalent of the AOD track was found");
+ return -1;
+ }
+
m_nTracksProcessed++;
+
// Create the xAOD object:
if (!(*itr)) {
- ATH_MSG_WARNING("WTaF? Empty element in container!");
+ ATH_MSG_WARNING("WTaF? Empty element in AOD container!");
continue;
}
- xAOD::TrackParticle* particle = createParticle(*xaod, container, **itr);
+ if (!(*itr_xaod)) {
+ ATH_MSG_WARNING("WTaF? Empty element in xAOD container!");
+ continue;
+ }
+
+ // xAOD::TrackParticle* particle = createParticle(*xaod, container, **itr);
+ xAOD::TrackParticle* particle = 0;
+ particle = *itr_xaod;
if(!particle){
- ATH_MSG_WARNING("Failed to create a TrackParticle");
+ ATH_MSG_WARNING("Failed to get an xAOD::TrackParticle");
continue;
}
@@ -191,50 +234,50 @@ namespace xAODMaker {
//
if (m_IdOutputInfo) {
- // integer entries in the summary can be -1 or -999, strange I know but that is the design ...
+ // integer entries in the summary can be -1 or -999, strange I know but that is the design ...
uint8_t numberOfBLayerHits=0;
if (particle->summaryValue(numberOfBLayerHits,xAOD::numberOfBLayerHits)) m_numberOfBLayerHits += numberOfBLayerHits;
uint8_t numberOfBLayerSharedHits=0;
if (particle->summaryValue(numberOfBLayerSharedHits,xAOD::numberOfBLayerSharedHits)) m_numberOfBLayerSharedHits += numberOfBLayerSharedHits;
- uint8_t numberOfBLayerOutliers=0;
+ uint8_t numberOfBLayerOutliers=0;
if (particle->summaryValue(numberOfBLayerOutliers,xAOD::numberOfBLayerOutliers)) m_numberOfBLayerOutliers += numberOfBLayerOutliers;
- uint8_t numberOfContribPixelLayers = 0;
+ uint8_t numberOfContribPixelLayers = 0;
if (particle->summaryValue(numberOfContribPixelLayers,xAOD::numberOfContribPixelLayers)) m_numberOfContribPixelLayers += numberOfContribPixelLayers;
- uint8_t numberOfPixelHits = 0;
+ uint8_t numberOfPixelHits = 0;
if (particle->summaryValue(numberOfPixelHits,xAOD::numberOfPixelHits)) m_numberOfPixelHits += numberOfPixelHits;
uint8_t numberOfPixelSharedHits = 0;
if (particle->summaryValue(numberOfPixelSharedHits,xAOD::numberOfPixelSharedHits)) m_numberOfPixelSharedHits += numberOfPixelSharedHits;
- uint8_t numberOfPixelHoles = 0;
+ uint8_t numberOfPixelHoles = 0;
if (particle->summaryValue(numberOfPixelHoles,xAOD::numberOfPixelHoles)) m_numberOfPixelHoles += numberOfPixelHoles;
- uint8_t numberOfGangedPixels = 0;
+ uint8_t numberOfGangedPixels = 0;
if (particle->summaryValue(numberOfGangedPixels,xAOD::numberOfGangedPixels)) m_numberOfGangedPixels += numberOfGangedPixels;
- uint8_t numberOfGangedFlaggedFakes = 0;
+ uint8_t numberOfGangedFlaggedFakes = 0;
if (particle->summaryValue(numberOfGangedFlaggedFakes,xAOD::numberOfGangedFlaggedFakes)) m_numberOfGangedFlaggedFakes += numberOfGangedFlaggedFakes;
- uint8_t numberOfSCTHits = 0;
+ uint8_t numberOfSCTHits = 0;
if (particle->summaryValue(numberOfSCTHits,xAOD::numberOfSCTHits)) m_numberOfSCTHits += numberOfSCTHits;
- uint8_t numberOfSCTSharedHits = 0;
+ uint8_t numberOfSCTSharedHits = 0;
if (particle->summaryValue(numberOfSCTSharedHits,xAOD::numberOfSCTSharedHits)) m_numberOfSCTSharedHits += numberOfSCTSharedHits;
uint8_t numberOfSCTHoles = 0;
if (particle->summaryValue(numberOfSCTHoles,xAOD::numberOfSCTHoles)) m_numberOfSCTHoles += numberOfSCTHoles;
uint8_t numberOfSCTDoubleHoles = 0;
if (particle->summaryValue(numberOfSCTDoubleHoles,xAOD::numberOfSCTDoubleHoles)) m_numberOfSCTDoubleHoles += numberOfSCTDoubleHoles;
- uint8_t numberOfTRTHits = 0;
+ uint8_t numberOfTRTHits = 0;
if (particle->summaryValue(numberOfTRTHits,xAOD::numberOfTRTHits)) m_numberOfTRTHits += numberOfTRTHits;
- uint8_t numberOfTRTXenonHits = 0;
+ uint8_t numberOfTRTXenonHits = 0;
if (particle->summaryValue(numberOfTRTXenonHits,xAOD::numberOfTRTXenonHits)) m_numberOfTRTXenonHits += numberOfTRTXenonHits;
uint8_t numberOfTRTHighThresholdHits = 0;
if (particle->summaryValue(numberOfTRTHighThresholdHits,xAOD::numberOfTRTHighThresholdHits)) m_numberOfTRTHighThresholdHits += numberOfTRTHighThresholdHits;
- uint8_t numberOfTRTOutliers = 0;
+ uint8_t numberOfTRTOutliers = 0;
if (particle->summaryValue(numberOfTRTOutliers,xAOD::numberOfTRTOutliers)) m_numberOfTRTOutliers += numberOfTRTOutliers;
- uint8_t numberOfTRTHighThresholdOutliers = 0;
+ uint8_t numberOfTRTHighThresholdOutliers = 0;
if (particle->summaryValue(numberOfTRTHighThresholdOutliers,xAOD::numberOfTRTHighThresholdOutliers)) m_numberOfTRTHighThresholdOutliers+= numberOfTRTHighThresholdOutliers;
- uint8_t numberOfOutliersOnTrack = 0;
+ uint8_t numberOfOutliersOnTrack = 0;
if (particle->summaryValue(numberOfOutliersOnTrack,xAOD::numberOfOutliersOnTrack)) m_numberOfOutliersOnTrack += numberOfOutliersOnTrack;
- uint8_t numberOfPixelOutliers = 0;
+ uint8_t numberOfPixelOutliers = 0;
if (particle->summaryValue(numberOfPixelOutliers,xAOD::numberOfPixelOutliers)) m_numberOfPixelOutliers += numberOfPixelOutliers;
- uint8_t numberOfPixelDeadSensors = 0;
+ uint8_t numberOfPixelDeadSensors = 0;
if (particle->summaryValue(numberOfPixelDeadSensors,xAOD::numberOfPixelDeadSensors)) m_numberOfPixelDeadSensors +=numberOfPixelDeadSensors ;
- uint8_t numberOfPixelSpoiltHits = 0;
+ uint8_t numberOfPixelSpoiltHits = 0;
if (particle->summaryValue( numberOfPixelSpoiltHits,xAOD::numberOfPixelSpoiltHits)) m_numberOfPixelSpoiltHits += numberOfPixelSpoiltHits;
uint8_t expectBLayerHit = 0;
@@ -274,15 +317,15 @@ namespace xAODMaker {
if( result == truth->end() ){
ATH_MSG_WARNING("Failed find truth associated with Track/TrackParticle");
}else{
- // setTruthLink(link,result->second, type, origin);
+ // setTruthLink(link,result->second, type, origin);
ATH_MSG_VERBOSE("Found track Truth: barcode " << result->second.particleLink().barcode()
- << " evt " << result->second.particleLink().eventIndex());
+ << " evt " << result->second.particleLink().eventIndex());
probability = result->second.probability();
link = m_truthParticleLinkVec->find(result->second.particleLink());
if( link.isValid() ){
ATH_MSG_DEBUG("Found matching xAOD Truth: barcode " << (*link)->barcode() << " pt " << (*link)->pt()
- << " eta " << (*link)->eta() << " phi " << (*link)->phi());
- // if configured also get truth classification
+ << " eta " << (*link)->eta() << " phi " << (*link)->phi());
+ // if configured also get truth classification
if( result->second.particleLink().cptr() && !m_truthClassifier.empty() ){
auto truthClass = m_truthClassifier->particleTruthClassifier(result->second.particleLink().cptr());
type = truthClass.first;
@@ -294,7 +337,7 @@ namespace xAODMaker {
}
ElementLink<xAOD::TruthParticleContainer>& theLink = particle->auxdata<ElementLink<xAOD::TruthParticleContainer> >("truthParticleLink" );
- // set element link
+ // set element link
theLink = link;
float& theProbability = const_cast<xAOD::TrackParticle*>(particle)->auxdata<float>("truthMatchProbability");
theProbability = probability;
@@ -305,123 +348,132 @@ namespace xAODMaker {
theOrigin = static_cast<int>(origin);
}
}
+ ++itr_xaod;
+ }// loop over aod tracks
+
+ ATH_MSG_DEBUG( "Converted [" << container.size() << " -> " << xaod->size() << "] TrackParticles and stored in " << xaodName );
+ if(container.size() != xaod->size()) {
+ ATH_MSG_ERROR( "number of items in the AOD container: "
+ << container.size()
+ << " is not equal to the number of items in its converted xAOD equivalent: "
+ << xaod->size() );
+ return -1;
}
- ATH_MSG_DEBUG( "Converted ["<<container.size()<<"] TrackParticles and stored in " << xaodName );
- return;
+ return 1;
}
xAOD::TrackParticle* TrackParticleCnvAlg::createParticle( xAOD::TrackParticleContainer& xaod,
- const Rec::TrackParticleContainer& /**container*/,
- const Rec::TrackParticle& tp)
+ const Rec::TrackParticleContainer& /**container*/,
+ const Rec::TrackParticle& tp)
{
// create the xAOD::TrackParticle, the pointer is added to the container in the function
return m_particleCreator->createParticle(tp,&xaod);
} // createParticleAndTruth
xAOD::TrackParticle* TrackParticleCnvAlg::createParticle( xAOD::TrackParticleContainer& xaod,
- const TrackCollection& container,
- const Trk::Track& tp)
+ const TrackCollection& container,
+ const Trk::Track& tp)
{
// create the xAOD::TrackParticle, the pointer is added to the container in the function
ElementLink<TrackCollection> trackLink(&tp,container);
return m_particleCreator->createParticle(trackLink,&xaod);
}
-StatusCode TrackParticleCnvAlg::finalize() {
+ StatusCode TrackParticleCnvAlg::finalize() {
- if (m_IdOutputInfo){
+ if (m_IdOutputInfo){
- double nTP = (double)m_nTrackParticlesCreated;
+ double nTP = (double)m_nTrackParticlesCreated;
- msg(MSG::INFO) << std::setiosflags(std::ios::fixed | std::ios::showpoint) << std::setw(9) << std::setprecision(3);
- msg(MSG::INFO) << " --- InDetParticleCreation Summary: " << endreq;
+ msg(MSG::INFO) << std::setiosflags(std::ios::fixed | std::ios::showpoint) << std::setw(9) << std::setprecision(3);
+ msg(MSG::INFO) << " --- InDetParticleCreation Summary: " << endreq;
- msg(MSG::INFO) << " --- Input TrackCollection : \"" << m_aodTrackContainerName << "\" with " << m_nTracksProcessed << " Tracks (";
- msg(MSG::INFO) << ( m_numEvents ? (double)m_nTracksProcessed/(double)m_numEvents : 0 ) << " per event)." << endreq;
+ msg(MSG::INFO) << " --- Input TrackCollection : \"" << m_aodTrackContainerName << "\" with " << m_nTracksProcessed << " Tracks (";
+ msg(MSG::INFO) << ( m_numEvents ? (double)m_nTracksProcessed/(double)m_numEvents : 0 ) << " per event)." << endreq;
- msg(MSG::INFO) << " --- Output TrackParticleContainer : \"" << m_xaodTracksContainerName << "\" with " << nTP << " TrackParticles (";
- msg(MSG::INFO) << (m_numEvents ? nTP/(double)m_numEvents : 0 ) << " per event)." << endreq;
+ msg(MSG::INFO) << " --- Output TrackParticleContainer : \"" << m_xaodTracksContainerName << "\" with " << nTP << " TrackParticles (";
+ msg(MSG::INFO) << (m_numEvents ? nTP/(double)m_numEvents : 0 ) << " per event)." << endreq;
- if (m_nTrackParticlesCreated>0){
- msg(MSG::INFO) << " --- /Track in -----> "
- << " BLayer "
- << " Pixel "
- << " SCT "
- << " TRT "
- << " All (P+S+T)" << endreq;
- msg(MSG::INFO) << " --- Hits "
- << (double)m_numberOfBLayerHits/nTP << " "
- << (double)m_numberOfPixelHits/nTP << " "
- << (double)m_numberOfSCTHits/nTP << " "
- << (double)m_numberOfTRTHits/nTP << " "
- << (double)(m_numberOfPixelHits+m_numberOfSCTHits+m_numberOfTRTHits)/nTP << endreq;
- msg(MSG::INFO) << " --- Shared Hits "
- << (double)m_numberOfBLayerSharedHits/nTP << " "
- << (double)m_numberOfPixelSharedHits/nTP << " "
- << (double)m_numberOfSCTSharedHits/nTP << " "
- << " " << " "
- << " " << (double)(m_numberOfPixelSharedHits+m_numberOfSCTSharedHits)/nTP << endreq;
- msg(MSG::INFO) << " --- Spoiled/Tube Hits "
- << " "
- << (double)m_numberOfPixelSpoiltHits/nTP << " "
- << (double)m_numberOfSCTSpoiltHits/nTP << " "
- << " " << (double)m_numberOfTRTTubeHits/nTP << " "
- << " " << (double)(m_numberOfPixelSpoiltHits+m_numberOfSCTSpoiltHits+m_numberOfTRTTubeHits)/nTP << endreq;
- msg(MSG::INFO) << " --- Outliers "
- << (double)m_numberOfBLayerOutliers/nTP << " "
- << (double)m_numberOfPixelOutliers/nTP << " "
- << (double)m_numberOfSCTOutliers/nTP << " "
- << " " << (double)m_numberOfTRTOutliers/nTP << " "
- << " " << (double)m_numberOfOutliersOnTrack/nTP << endreq;
- msg(MSG::INFO) << " --- Holes "
- << " "
- << (double)m_numberOfPixelHoles/nTP << " "
- << (double)m_numberOfSCTHoles/nTP << " "
- << " " << (double)m_numberOfTRTHoles/nTP << " "
- << " " << (double)(m_numberOfPixelHoles+m_numberOfSCTHoles+m_numberOfTRTHoles)/nTP << endreq;
- msg(MSG::INFO) << " missed (exp) blayer " << (double) m_numberOfBlayersMissed/nTP << endreq;
- msg(MSG::INFO) << " SCT Double Holes "
- << " "
- << " "
- << (double)m_numberOfSCTDoubleHoles/nTP
- << endreq;
- msg(MSG::INFO) << " --- Dead Sensors/Straws "
- << " "
- << (double)m_numberOfPixelDeadSensors/nTP << " "
- << (double)m_numberOfSCTDeadSensors/nTP << " "
- << " " << (double)m_numberOfTRTDeadStraws/nTP << " "
- << " " << (double)(m_numberOfPixelDeadSensors+m_numberOfSCTDeadSensors+m_numberOfTRTDeadStraws)/nTP
- << endreq;
- msg(MSG::INFO) << " --- Add info Pixels " << endreq;
- msg(MSG::INFO) << " contributing layers " << (double)m_numberOfContribPixelLayers/nTP << endreq;
- msg(MSG::INFO) << " ganged pixels " << (double)m_numberOfGangedPixels/nTP << endreq;
- msg(MSG::INFO) << " ganged flagged as fake " << (double)m_numberOfGangedFlaggedFakes/nTP << endreq;
- msg(MSG::INFO) << " --- Add info TRT " << endreq;
- msg(MSG::INFO) << " High Threshold Hits "
- << " "
- << " "
- << " "
- << " " << (double)m_numberOfTRTHighThresholdHits/nTP
- << endreq;
- msg(MSG::INFO) << " High thre. outliers "
- << " "
- << " "
- << " "
- << " " << (double)m_numberOfTRTHighThresholdOutliers/nTP
- << endreq;
- msg(MSG::INFO) << " Xenon hits"
- << " "
- << " "
- << " "
- << " " << (double)m_numberOfTRTXenonHits/nTP
- << endreq;
+ if (m_nTrackParticlesCreated>0){
+ msg(MSG::INFO) << " --- /Track in -----> "
+ << " BLayer "
+ << " Pixel "
+ << " SCT "
+ << " TRT "
+ << " All (P+S+T)" << endreq;
+ msg(MSG::INFO) << " --- Hits "
+ << (double)m_numberOfBLayerHits/nTP << " "
+ << (double)m_numberOfPixelHits/nTP << " "
+ << (double)m_numberOfSCTHits/nTP << " "
+ << (double)m_numberOfTRTHits/nTP << " "
+ << (double)(m_numberOfPixelHits+m_numberOfSCTHits+m_numberOfTRTHits)/nTP << endreq;
+ msg(MSG::INFO) << " --- Shared Hits "
+ << (double)m_numberOfBLayerSharedHits/nTP << " "
+ << (double)m_numberOfPixelSharedHits/nTP << " "
+ << (double)m_numberOfSCTSharedHits/nTP << " "
+ << " " << " "
+ << " " << (double)(m_numberOfPixelSharedHits+m_numberOfSCTSharedHits)/nTP << endreq;
+ msg(MSG::INFO) << " --- Spoiled/Tube Hits "
+ << " "
+ << (double)m_numberOfPixelSpoiltHits/nTP << " "
+ << (double)m_numberOfSCTSpoiltHits/nTP << " "
+ << " " << (double)m_numberOfTRTTubeHits/nTP << " "
+ << " " << (double)(m_numberOfPixelSpoiltHits+m_numberOfSCTSpoiltHits+m_numberOfTRTTubeHits)/nTP << endreq;
+ msg(MSG::INFO) << " --- Outliers "
+ << (double)m_numberOfBLayerOutliers/nTP << " "
+ << (double)m_numberOfPixelOutliers/nTP << " "
+ << (double)m_numberOfSCTOutliers/nTP << " "
+ << " " << (double)m_numberOfTRTOutliers/nTP << " "
+ << " " << (double)m_numberOfOutliersOnTrack/nTP << endreq;
+ msg(MSG::INFO) << " --- Holes "
+ << " "
+ << (double)m_numberOfPixelHoles/nTP << " "
+ << (double)m_numberOfSCTHoles/nTP << " "
+ << " " << (double)m_numberOfTRTHoles/nTP << " "
+ << " " << (double)(m_numberOfPixelHoles+m_numberOfSCTHoles+m_numberOfTRTHoles)/nTP << endreq;
+ msg(MSG::INFO) << " missed (exp) blayer " << (double) m_numberOfBlayersMissed/nTP << endreq;
+ msg(MSG::INFO) << " SCT Double Holes "
+ << " "
+ << " "
+ << (double)m_numberOfSCTDoubleHoles/nTP
+ << endreq;
+ msg(MSG::INFO) << " --- Dead Sensors/Straws "
+ << " "
+ << (double)m_numberOfPixelDeadSensors/nTP << " "
+ << (double)m_numberOfSCTDeadSensors/nTP << " "
+ << " " << (double)m_numberOfTRTDeadStraws/nTP << " "
+ << " " << (double)(m_numberOfPixelDeadSensors+m_numberOfSCTDeadSensors+m_numberOfTRTDeadStraws)/nTP
+ << endreq;
+ msg(MSG::INFO) << " --- Add info Pixels " << endreq;
+ msg(MSG::INFO) << " contributing layers " << (double)m_numberOfContribPixelLayers/nTP << endreq;
+ msg(MSG::INFO) << " ganged pixels " << (double)m_numberOfGangedPixels/nTP << endreq;
+ msg(MSG::INFO) << " ganged flagged as fake " << (double)m_numberOfGangedFlaggedFakes/nTP << endreq;
+ msg(MSG::INFO) << " --- Add info TRT " << endreq;
+ msg(MSG::INFO) << " High Threshold Hits "
+ << " "
+ << " "
+ << " "
+ << " " << (double)m_numberOfTRTHighThresholdHits/nTP
+ << endreq;
+ msg(MSG::INFO) << " High thre. outliers "
+ << " "
+ << " "
+ << " "
+ << " " << (double)m_numberOfTRTHighThresholdOutliers/nTP
+ << endreq;
+ msg(MSG::INFO) << " Xenon hits"
+ << " "
+ << " "
+ << " "
+ << " " << (double)m_numberOfTRTXenonHits/nTP
+ << endreq;
- } else
- msg(MSG::INFO) << " No TrackParticles have been created ... skipping output." << endreq;
- }
+ } else
+ msg(MSG::INFO) << " No TrackParticles have been created ... skipping output." << endreq;
+ }
msg(MSG::DEBUG) << "finalize() success" << endreq;
return StatusCode::SUCCESS;
}
diff --git a/Event/xAOD/xAODTrackingCnv/src/TrackParticleCnvAlg.h b/Event/xAOD/xAODTrackingCnv/src/TrackParticleCnvAlg.h
index 12219ad4f6bb54afe1525102d90e27cdaf892cbd..fe7eaf989b9f7248ab3e52f2f7601ab13e9870d1 100644
--- a/Event/xAOD/xAODTrackingCnv/src/TrackParticleCnvAlg.h
+++ b/Event/xAOD/xAODTrackingCnv/src/TrackParticleCnvAlg.h
@@ -27,118 +27,126 @@ namespace Trk {
class ITrackParticleCreatorTool;
}
class IMCTruthClassifier;
+namespace xAODMaker {
+ class ITrackCollectionCnvTool;
+ class IRecTrackParticleContainerCnvTool;
+}
namespace xAODMaker {
- /**
- * @short Algorithm creating xAOD::TrackParticles from TrackParticles
- *
- * This algorithm can be used to translate the TrackParticles coming
- * from an AOD, and create xAOD::TrackParticle objects out of them
- * for an output xAOD.
- *
- * @author Edward Moyse <Edward.Moyse@cern.ch>
- * @author Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>
- *
- * $Revision: 297747 $
- * $Date: 2013-10-28 16:14:24 +0100 (Mon, 28 Oct 2013) $
- */
- class TrackParticleCnvAlg : public AthAlgorithm {
-
- public:
- /// Regular algorithm constructor
- TrackParticleCnvAlg( const std::string& name, ISvcLocator* svcLoc );
-
- /// Function initialising the algorithm
- virtual StatusCode initialize();
- /// Function executing the algorithm
- virtual StatusCode execute();
-
- virtual StatusCode finalize();
-
- private:
- /// The key of the input TrackParticlesContainer
- std::string m_aodContainerName;
- /// The key for the output xAOD::TrackParticlesContainer
- std::string m_xaodContainerName;
- /// toggle on adding truth links
- bool m_addTruthLink;
- /// The key for the input TrackParticleTruthCollection
- std::string m_aodTruthContainerName;
+ /**
+ * @short Algorithm creating xAOD::TrackParticles from TrackParticles
+ *
+ * This algorithm can be used to translate the TrackParticles coming
+ * from an AOD, and create xAOD::TrackParticle objects out of them
+ * for an output xAOD.
+ *
+ * @author Edward Moyse <Edward.Moyse@cern.ch>
+ * @author Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>
+ *
+ * $Revision: 297747 $
+ * $Date: 2013-10-28 16:14:24 +0100 (Mon, 28 Oct 2013) $
+ */
+ class TrackParticleCnvAlg : public AthAlgorithm {
+
+ public:
+ /// Regular algorithm constructor
+ TrackParticleCnvAlg( const std::string& name, ISvcLocator* svcLoc );
+
+ /// Function initialising the algorithm
+ virtual StatusCode initialize();
+ /// Function executing the algorithm
+ virtual StatusCode execute();
+
+ virtual StatusCode finalize();
+
+ private:
+ /// The key of the input TrackParticlesContainer
+ std::string m_aodContainerName;
+ /// The key for the output xAOD::TrackParticlesContainer
+ std::string m_xaodContainerName;
+ /// toggle on adding truth links
+ bool m_addTruthLink;
+ /// The key for the input TrackParticleTruthCollection
+ std::string m_aodTruthContainerName;
- /// The key for the input DetailedTrackTrackTruthCollection
- std::string m_trackTruthContainerName;
+ /// The key for the input DetailedTrackTrackTruthCollection
+ std::string m_trackTruthContainerName;
- /// The key for the input xAODTruthLinkVector
- std::string m_truthLinkVecName;
-
- /// ToolHandle to particle creator
- ToolHandle<Trk::ITrackParticleCreatorTool> m_particleCreator;
- /// ToolHandle to truth classifier
- ToolHandle<IMCTruthClassifier> m_truthClassifier;
-
- /// The key of the input TracksContainer
- std::string m_aodTrackContainerName;
- /// The key for the output xAOD::TrackParticlesContainer for the Tracks
- std::string m_xaodTracksContainerName;
+ /// The key for the input xAODTruthLinkVector
+ std::string m_truthLinkVecName;
+
+ /// ToolHandle to particle creator
+ ToolHandle<Trk::ITrackParticleCreatorTool> m_particleCreator;
+ /// ToolHandle to truth classifier
+ ToolHandle<IMCTruthClassifier> m_truthClassifier;
+
+ // handles to the converting tools
+ ToolHandle< xAODMaker::ITrackCollectionCnvTool > m_TrackCollectionCnvTool;
+ ToolHandle< xAODMaker::IRecTrackParticleContainerCnvTool > m_RecTrackParticleContainerCnvTool;
+
+ /// The key of the input TracksContainer
+ std::string m_aodTrackContainerName;
+ /// The key for the output xAOD::TrackParticlesContainer for the Tracks
+ std::string m_xaodTracksContainerName;
- /// toggle on converting AOD track particles to xAOD
- bool m_convertAODTrackParticles;
+ /// toggle on converting AOD track particles to xAOD
+ bool m_convertAODTrackParticles;
- /// toggle on converting tracks to xAOD
- bool m_convertTracks;
+ /// toggle on converting tracks to xAOD
+ bool m_convertTracks;
- template <typename CONT, typename TRUTHCONT>
- void convert(const CONT&, const TRUTHCONT&, const std::string& name);
+ template <typename CONT, typename TRUTHCONT, typename CONVTOOL>
+ int convert(const CONT&, const TRUTHCONT&, const std::string& name, CONVTOOL& tool);
- inline xAOD::TrackParticle* createParticle(xAOD::TrackParticleContainer& xaod, const Rec::TrackParticleContainer& container, const Rec::TrackParticle& tp) ;
- inline xAOD::TrackParticle* createParticle( xAOD::TrackParticleContainer& xaod, const TrackCollection& container, const Trk::Track& tp) ;
- const xAODTruthParticleLinkVector* m_truthParticleLinkVec;
+ inline xAOD::TrackParticle* createParticle(xAOD::TrackParticleContainer& xaod, const Rec::TrackParticleContainer& container, const Rec::TrackParticle& tp) ;
+ inline xAOD::TrackParticle* createParticle( xAOD::TrackParticleContainer& xaod, const TrackCollection& container, const Trk::Track& tp) ;
+ const xAODTruthParticleLinkVector* m_truthParticleLinkVec;
- bool m_IdOutputInfo;
+ bool m_IdOutputInfo;
- unsigned int m_numEvents;
- /** the number of Trk::Tracks processed, this is equal to the sum of tracks over all events in the input TrackContainer */
- unsigned long m_nTracksProcessed;
- /** the number of Rec::TrackParticle created, should be the same as Trk::Tracks processed but one never knows! */
- unsigned long m_nTrackParticlesCreated;
+ unsigned int m_numEvents;
+ /** the number of Trk::Tracks processed, this is equal to the sum of tracks over all events in the input TrackContainer */
+ unsigned long m_nTracksProcessed;
+ /** the number of Rec::TrackParticle created, should be the same as Trk::Tracks processed but one never knows! */
+ unsigned long m_nTrackParticlesCreated;
- unsigned int m_numberOfBLayerHits;
- unsigned int m_numberOfBLayerSharedHits;
- unsigned int m_numberOfBLayerOutliers;
+ unsigned int m_numberOfBLayerHits;
+ unsigned int m_numberOfBLayerSharedHits;
+ unsigned int m_numberOfBLayerOutliers;
- unsigned int m_numberOfContribPixelLayers;
- unsigned int m_numberOfPixelHits;
- unsigned int m_numberOfPixelSharedHits;
- unsigned int m_numberOfPixelHoles;
- unsigned int m_numberOfGangedPixels;
- unsigned int m_numberOfGangedFlaggedFakes;
+ unsigned int m_numberOfContribPixelLayers;
+ unsigned int m_numberOfPixelHits;
+ unsigned int m_numberOfPixelSharedHits;
+ unsigned int m_numberOfPixelHoles;
+ unsigned int m_numberOfGangedPixels;
+ unsigned int m_numberOfGangedFlaggedFakes;
- unsigned int m_numberOfSCTHits;
- unsigned int m_numberOfSCTSharedHits;
- unsigned int m_numberOfSCTHoles;
- unsigned int m_numberOfSCTDoubleHoles;
- unsigned int m_numberOfTRTHits;
- unsigned int m_numberOfTRTXenonHits;
- unsigned int m_numberOfTRTHighThresholdHits;
- unsigned int m_numberOfTRTOutliers;
- unsigned int m_numberOfTRTHighThresholdOutliers;
- unsigned int m_numberOfOutliersOnTrack;
+ unsigned int m_numberOfSCTHits;
+ unsigned int m_numberOfSCTSharedHits;
+ unsigned int m_numberOfSCTHoles;
+ unsigned int m_numberOfSCTDoubleHoles;
+ unsigned int m_numberOfTRTHits;
+ unsigned int m_numberOfTRTXenonHits;
+ unsigned int m_numberOfTRTHighThresholdHits;
+ unsigned int m_numberOfTRTOutliers;
+ unsigned int m_numberOfTRTHighThresholdOutliers;
+ unsigned int m_numberOfOutliersOnTrack;
- unsigned int m_numberOfPixelOutliers;
- unsigned int m_numberOfPixelDeadSensors;
- unsigned int m_numberOfPixelSpoiltHits;
- unsigned int m_numberOfBlayersMissed;
+ unsigned int m_numberOfPixelOutliers;
+ unsigned int m_numberOfPixelDeadSensors;
+ unsigned int m_numberOfPixelSpoiltHits;
+ unsigned int m_numberOfBlayersMissed;
- unsigned int m_numberOfSCTOutliers;
- unsigned int m_numberOfSCTDeadSensors;
- unsigned int m_numberOfSCTSpoiltHits;
- unsigned int m_numberOfTRTHoles;
- unsigned int m_numberOfTRTDeadStraws;
- unsigned int m_numberOfTRTTubeHits;
-
- }; // class TrackParticleCnvAlg
-
+ unsigned int m_numberOfSCTOutliers;
+ unsigned int m_numberOfSCTDeadSensors;
+ unsigned int m_numberOfSCTSpoiltHits;
+ unsigned int m_numberOfTRTHoles;
+ unsigned int m_numberOfTRTDeadStraws;
+ unsigned int m_numberOfTRTTubeHits;
+
+ }; // class TrackParticleCnvAlg
+
} // namespace xAODMaker
#endif // XAODCREATORALGS_TRACKPARTICLECREATOR_H
diff --git a/Event/xAOD/xAODTrackingCnv/src/VertexCnvAlg.cxx b/Event/xAOD/xAODTrackingCnv/src/VertexCnvAlg.cxx
index f37d8a908fea2f470c051e729f56b2a6258ad811..a591c214d8b974f5425ab461798c344ccf3a67e1 100644
--- a/Event/xAOD/xAODTrackingCnv/src/VertexCnvAlg.cxx
+++ b/Event/xAOD/xAODTrackingCnv/src/VertexCnvAlg.cxx
@@ -58,11 +58,20 @@ namespace xAODMaker {
// Create the xAOD container and its auxiliary store:
xAOD::VertexContainer* xaod = new xAOD::VertexContainer();
- CHECK( evtStore()->record( xaod, m_xaodContainerName ) );
xAOD::VertexAuxContainer* aux = new xAOD::VertexAuxContainer();
- CHECK( evtStore()->record( aux, m_xaodContainerName + "Aux." ) );
- xaod->setStore( aux );
- ATH_MSG_DEBUG( "Recorded Vertexes with key: " << m_xaodContainerName );
+
+ if (evtStore()->contains<xAOD::VertexContainer>(m_xaodContainerName)) {
+ CHECK( evtStore()->overwrite( aux, m_xaodContainerName + "Aux.",true,false) );
+ CHECK( evtStore()->overwrite( xaod, m_xaodContainerName,true,false) );
+ xaod->setStore( aux );
+ ATH_MSG_DEBUG( "Overwrote Vertexes with key: " << m_xaodContainerName );
+ }
+ else{
+ CHECK( evtStore()->record( aux, m_xaodContainerName + "Aux." ) );
+ CHECK( evtStore()->record( xaod, m_xaodContainerName ) );
+ xaod->setStore( aux );
+ ATH_MSG_DEBUG( "Recorded Vertexes with key: " << m_xaodContainerName );
+ }
// Create the xAOD objects:
auto itr = aod->begin();
diff --git a/Event/xAOD/xAODTrackingCnv/src/components/xAODTrackingCnv_entries.cxx b/Event/xAOD/xAODTrackingCnv/src/components/xAODTrackingCnv_entries.cxx
index 94d94d4a8876f6ab32a361ac53e3f14635c1f8f7..93b22be5b37137dd3499b272a4c404d3809e5bd1 100644
--- a/Event/xAOD/xAODTrackingCnv/src/components/xAODTrackingCnv_entries.cxx
+++ b/Event/xAOD/xAODTrackingCnv/src/components/xAODTrackingCnv_entries.cxx
@@ -4,13 +4,19 @@
#include "GaudiKernel/DeclareFactoryEntries.h"
// Local include(s):
+#include "../TrackCollectionCnvTool.h"
+#include "../RecTrackParticleContainerCnvTool.h"
#include "../TrackParticleCnvAlg.h"
#include "../VertexCnvAlg.h"
+DECLARE_NAMESPACE_TOOL_FACTORY( xAODMaker, RecTrackParticleContainerCnvTool )
+DECLARE_NAMESPACE_TOOL_FACTORY( xAODMaker, TrackCollectionCnvTool )
DECLARE_NAMESPACE_ALGORITHM_FACTORY( xAODMaker, TrackParticleCnvAlg )
DECLARE_NAMESPACE_ALGORITHM_FACTORY( xAODMaker, VertexCnvAlg )
DECLARE_FACTORY_ENTRIES( xAODCreatorAlgs ) {
- DECLARE_NAMESPACE_ALGORITHM( xAODMaker, TrackParticleCnvAlg )
+ DECLARE_NAMESPACE_TOOL( xAODMaker, RecTrackParticleContainerCnvTool )
+ DECLARE_NAMESPACE_TOOL( xAODMaker, TrackCollectionCnvTool )
+ DECLARE_NAMESPACE_ALGORITHM( xAODMaker, TrackParticleCnvAlg )
DECLARE_NAMESPACE_ALGORITHM( xAODMaker, VertexCnvAlg )
-}
+ }
diff --git a/Event/xAOD/xAODTrackingCnv/xAODTrackingCnv/IRecTrackParticleContainerCnvTool.h b/Event/xAOD/xAODTrackingCnv/xAODTrackingCnv/IRecTrackParticleContainerCnvTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..40e16e1637755b4c22aea707b083a60313c316e2
--- /dev/null
+++ b/Event/xAOD/xAODTrackingCnv/xAODTrackingCnv/IRecTrackParticleContainerCnvTool.h
@@ -0,0 +1,54 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id$
+#ifndef XAODTRACKINGCNV_IRECTRACKPARTICLECONTAINERCNVTOOL_H
+#define XAODTRACKINGCNV_IRECTRACKPARTICLECONTAINERCNVTOOL_H
+
+// Gaudi/Athena include(s):
+#include "GaudiKernel/IAlgTool.h"
+
+// EDM include(s):
+#include "xAODTracking/TrackParticleContainer.h"
+//#include "TrkTrack/TrackCollection.h"
+
+// Forward declaration(s):
+namespace Rec {
+class TrackParticleContainer;
+}
+
+namespace Trk {
+ class ITrackParticleCreatorTool;
+}
+
+
+namespace xAODMaker {
+
+ /// The interface provided by IRecTrackParticleContainerCnvTool
+ static const InterfaceID
+ IID_IRecTrackParticleContainerCnvTool( "xAODMaker::IRecTrackParticleContainerCnvTool", 1, 0 );
+
+
+ class IRecTrackParticleContainerCnvTool : public virtual IAlgTool {
+
+ public:
+ /// Function that fills an existing xAOD::TrackParticleContainer
+ virtual StatusCode convert( const Rec::TrackParticleContainer* aod,
+ xAOD::TrackParticleContainer* xaod ) = 0;
+
+ virtual StatusCode setParticleCreatorTool(ToolHandle<Trk::ITrackParticleCreatorTool> *tool) = 0;
+
+ /// Gaudi interface definition
+ static const InterfaceID& interfaceID() {
+ return IID_IRecTrackParticleContainerCnvTool;
+ }
+
+ };//class definition
+
+} // xAODMaker namespace
+
+
+#endif // XAODTRACKINGCNV_IRECTRACKPARTICLECONTAINERCNVTOOL_H
diff --git a/Event/xAOD/xAODTrackingCnv/xAODTrackingCnv/ITrackCollectionCnvTool.h b/Event/xAOD/xAODTrackingCnv/xAODTrackingCnv/ITrackCollectionCnvTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..f57ebb0f0441f18b467d681be91fa378258c2bf1
--- /dev/null
+++ b/Event/xAOD/xAODTrackingCnv/xAODTrackingCnv/ITrackCollectionCnvTool.h
@@ -0,0 +1,50 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id$
+#ifndef XAODTRACKINGCNV_ITRACKCOLLECTIONCNVTOOL_H
+#define XAODTRACKINGCNV_ITRACKCOLLECTIONCNVTOOL_H
+
+// Gaudi/Athena include(s):
+#include "GaudiKernel/IAlgTool.h"
+
+// EDM include(s):
+#include "xAODTracking/TrackParticleContainer.h"
+#include "TrkTrack/TrackCollection.h"
+// Forward declaration(s):
+//class TrackCollection; - no - typedef
+
+namespace Trk {
+ class ITrackParticleCreatorTool;
+}
+
+namespace xAODMaker {
+
+ /// The interface provided by ITrackCollectionCnvTool
+ static const InterfaceID
+ IID_ITrackCollectionCnvTool( "xAODMaker::ITrackCollectionCnvTool", 1, 0 );
+
+
+ class ITrackCollectionCnvTool : public virtual IAlgTool {
+
+ public:
+ /// Function that fills an existing xAOD::TrackParticleContainer
+ virtual StatusCode convert( const TrackCollection* aod,
+ xAOD::TrackParticleContainer* xaod ) = 0;
+
+ virtual StatusCode setParticleCreatorTool(ToolHandle<Trk::ITrackParticleCreatorTool> *tool) = 0;
+
+ /// Gaudi interface definition
+ static const InterfaceID& interfaceID() {
+ return IID_ITrackCollectionCnvTool;
+ }
+
+ };//class definition
+
+} // xAODMaker namespace
+
+
+#endif // XAODTRACKINGCNV_ITRACKCOLLECTIONCNVTOOL_H