diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt
index 4f948521da35acaa0936d8b27c5cb6252693e9eb..a6ff20cdab5cb61d20b97b17290b0224ee6192fc 100644
--- a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt
@@ -7,29 +7,62 @@
atlas_subdir( TrackerEventAthenaPool )
# Component(s) in the package:
-atlas_add_poolcnv_library( TrackerEventAthenaPoolPoolCnv
+
+# Component(s) in the package:
+atlas_add_library( TrackerEventAthenaPool
TrackerEventAthenaPool/*.h src/*.h src/*.cxx
+ PUBLIC_HEADERS TrackerEventAthenaPool
+ LINK_LIBRARIES Identifier GeneratorObjectsTPCnv AthAllocators AthContainers
+ AthenaBaseComps AthenaKernel SGTools StoreGateLib AthenaPoolCnvSvcLib
+ AthenaPoolUtilities AtlasSealCLHEP GaudiKernel TrackerIdentifier
+ TrackerReadoutGeometry TrackerEventTPCnv TrackerRawData TrackerSimData
+ TrackerPrepRawData TrkTrack )
+
+ atlas_add_poolcnv_library( TrackerEventAthenaPoolPoolCnv
FILES TrackerRawData/FaserSCT_RDO_Container.h
TrackerPrepRawData/FaserSCT_ClusterContainer.h
+ src/TrackerTrack.h
TrackerSimData/TrackerSimDataCollection.h
- TrkSpacePoint/SpacePointContainer.h
-# FaserSCT_ConditionsData/FaserSCT_FlaggedCondData.h
LINK_LIBRARIES Identifier GeneratorObjectsTPCnv AthAllocators AthContainers
AthenaBaseComps AthenaKernel SGTools StoreGateLib AthenaPoolCnvSvcLib
AthenaPoolUtilities AtlasSealCLHEP GaudiKernel TrackerIdentifier
- TrackerReadoutGeometry TrackerEventTPCnv
- TrackerRawData TrackerSimData
- TrackerPrepRawData TrkTrack
- TrkSpacePoint
- TrackerSpacePoint
-# FaserSCT_ConditionsData
- )
+ TrackerReadoutGeometry TrackerEventTPCnv TrackerRawData TrackerSimData
+ TrackerPrepRawData TrkTrack TrackerEventAthenaPool )
atlas_add_dictionary( TrackerEventAthenaPoolCnvDict
TrackerEventAthenaPool/TrackerEventAthenaPoolCnvDict.h
TrackerEventAthenaPool/selection.xml
LINK_LIBRARIES Identifier GeneratorObjectsTPCnv )
+
+
+
+
+
+
+# atlas_add_poolcnv_library( TrackerEventAthenaPoolPoolCnv
+# TrackerEventAthenaPool/*.h src/*.h src/*.cxx
+# FILES TrackerRawData/FaserSCT_RDO_Container.h
+# TrackerPrepRawData/FaserSCT_ClusterContainer.h
+# TrackerSimData/TrackerSimDataCollection.h
+# TrkSpacePoint/SpacePointContainer.h
+# # FaserSCT_ConditionsData/FaserSCT_FlaggedCondData.h
+# LINK_LIBRARIES Identifier GeneratorObjectsTPCnv AthAllocators AthContainers
+# AthenaBaseComps AthenaKernel SGTools StoreGateLib AthenaPoolCnvSvcLib
+# AthenaPoolUtilities AtlasSealCLHEP GaudiKernel TrackerIdentifier
+# TrackerReadoutGeometry TrackerEventTPCnv
+# TrackerRawData TrackerSimData
+# TrackerPrepRawData TrkTrack TrackerRIO_OnTrack
+# TrkSpacePoint
+# TrackerSpacePoint
+# # FaserSCT_ConditionsData
+# )
+
+# atlas_add_dictionary( TrackerEventAthenaPoolCnvDict
+# TrackerEventAthenaPool/TrackerEventAthenaPoolCnvDict.h
+# TrackerEventAthenaPool/selection.xml
+# LINK_LIBRARIES Identifier GeneratorObjectsTPCnv )
+
# Install files from the package:
atlas_install_headers( TrackerEventAthenaPool )
#atlas_install_joboptions( share/*.py )
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerTrack.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerTrack.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d08e9a7c1ef70fdbb12dc8c75afa9740dfc010f
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerTrack.h
@@ -0,0 +1,19 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKER_TRACK_H
+#define TRACKER_TRACK_H
+
+
+#include "AthenaKernel/CLASS_DEF.h"
+
+
+class TrackerTrack
+{
+};
+
+
+CLASS_DEF(TrackerTrack, 48647229, 1 )
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerTrackCnv.cxx b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerTrackCnv.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..9f6193b0e9d6f7aa60fe61269643e5b9d82fe61b
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerTrackCnv.cxx
@@ -0,0 +1,53 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "GaudiKernel/MsgStream.h"
+
+#include "TrackerTrackCnv.h"
+#include "TrkTrack/TrackCollection.h"
+
+#include <iostream>
+#include <stdexcept>
+
+TrackerTrackCnv::TrackerTrackCnv(ISvcLocator* svcloc):
+ TrackerTrackCnvBase(svcloc)
+{
+}
+
+
+StatusCode TrackerTrackCnv::initialize()
+{
+ if( !TrackerTrackCnvBase::initialize().isSuccess() )
+ return StatusCode::FAILURE;
+
+
+ // std::cout << " ------->>---- In TrackerTrackCnv::initialize()" << std::endl;
+
+ return StatusCode::SUCCESS;
+}
+
+
+// this method just reads the persistent object - no TP conversion here
+void
+TrackerTrackCnv::readObjectFromPool( const std::string& token )
+{
+ static const pool::Guid p2_guid( "27491695-F64A-43EE-859D-73F33AF3317D" );
+ // static const pool::Guid p2_guid( "4E3778E2-1497-4F10-8746-AA02319FAC83" );
+ // static const pool::Guid p1_guid( "8380F7AC-4A8F-4382-95A5-1234E43D3B08" );
+
+ // set the POOL token which will be used for reading from POOL
+ setToken( token );
+
+ // select the object type based on its GUID
+ if( compareClassGuid( p2_guid ) ) {
+ // read the object using the main TP converter
+ poolReadObject< TrackerTrack_PERS >( m_TPConverter2 );
+// }else if( compareClassGuid( p1_guid ) ) {
+// poolReadObject< InDet::Track_tlp1 >( m_TPConverter1 );
+ }
+ else
+ throw std::runtime_error( "Unsupported version of TrackerTrack_PERS (unknown GUID)" );
+}
+
+
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerTrackCnv.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerTrackCnv.h
new file mode 100644
index 0000000000000000000000000000000000000000..05aff9565ca00594c28ca45409cdc7a936b3594f
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerTrackCnv.h
@@ -0,0 +1,50 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKER_TRACKCNV_H
+#define TRACKER_TRACKCNV_H
+
+#include "AthenaPoolCnvSvc/T_AthenaPoolExtendingCnv.h"
+
+// #include "TrackerEventTPCnv/TrackerTrackCnv_tlp1.h"
+#include "TrackerEventTPCnv/TrackerTrackCnv_tlp2.h"
+
+#include "TrackerTrack.h"
+
+
+//-----------------------------------------------------------------------------
+// Base class definition
+//-----------------------------------------------------------------------------
+typedef Tracker::Track_tlp2 TrackerTrack_PERS;
+typedef T_AthenaPoolExtendingCnv<TrackerTrack, TrackerTrack_PERS> TrackerTrackCnvBase;
+
+//-----------------------------------------------------------------------------
+// Converter for TrackCollection object
+//-----------------------------------------------------------------------------
+class TrackerTrackCnv : public TrackerTrackCnvBase
+{
+friend class CnvFactory<TrackerTrackCnv>;
+
+protected:
+public:
+ TrackerTrackCnv( ISvcLocator *svcloc );
+protected:
+
+ virtual StatusCode initialize();
+
+
+ virtual AthenaPoolTopLevelTPCnvBase* getTopLevelTPCnv() { return &m_TPConverter2; }
+
+ virtual AthenaPoolCnvTPExtension* clone() { return new TrackerTrackCnv(0); }
+
+ virtual void readObjectFromPool( const std::string& );
+
+
+private:
+// InDetTrackCnv_tlp1 m_TPConverter1;
+ TrackerTrackCnv_tlp2 m_TPConverter2;
+};
+
+#endif
+
diff --git a/Tracker/TrackerEventCnv/TrackerEventCnvTools/CMakeLists.txt b/Tracker/TrackerEventCnv/TrackerEventCnvTools/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6053d2790392ae986af95db90127dedf1fc5c0b1
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventCnvTools/CMakeLists.txt
@@ -0,0 +1,10 @@
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+
+# Declare the package name:
+atlas_subdir( TrackerEventCnvTools )
+
+# Component(s) in the package:
+atlas_add_component( TrackerEventCnvTools
+ src/*.cxx
+ src/components/*.cxx
+ LINK_LIBRARIES AthenaBaseComps FaserDetDescr IdDictDetDescr Identifier TrackerIdentifier TrackerReadoutGeometry TrackerPrepRawData TrackerRIO_OnTrack StoreGateLib TrkPrepRawData TrkRIO_OnTrack TrkEventCnvToolsLib )
diff --git a/Tracker/TrackerEventCnv/TrackerEventCnvTools/TrackerEventCnvTools/ATLAS_CHECK_THREAD_SAFETY b/Tracker/TrackerEventCnv/TrackerEventCnvTools/TrackerEventCnvTools/ATLAS_CHECK_THREAD_SAFETY
new file mode 100644
index 0000000000000000000000000000000000000000..0d4c3a9d8b7fbde5eb560fe15628b349ff34a863
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventCnvTools/TrackerEventCnvTools/ATLAS_CHECK_THREAD_SAFETY
@@ -0,0 +1 @@
+Tracker/TrackerEventCnv/TrackerEventCnvTools
\ No newline at end of file
diff --git a/Tracker/TrackerEventCnv/TrackerEventCnvTools/TrackerEventCnvTools/TrackerEventCnvTool.h b/Tracker/TrackerEventCnv/TrackerEventCnvTools/TrackerEventCnvTools/TrackerEventCnvTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..29ef80259242bde365ddf83b6ec8bcff3ada41ac
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventCnvTools/TrackerEventCnvTools/TrackerEventCnvTool.h
@@ -0,0 +1,98 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKEREVENTCNVTOOL_H
+#define TRACKEREVENTCNVTOOL_H
+
+#include "TrkEventCnvTools/ITrkEventCnvTool.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
+#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/ReadHandleKey.h"
+
+#include <utility>
+
+class FaserDetectorID;
+class Identifier;
+class IdentifierHash;
+class IdDictManager;
+class FaserSCT_ID;
+
+namespace Trk {
+ class TrkDetElementBase;
+ class PrepRawData;
+}
+
+
+namespace Tracker {
+ /**Helper tool uses to convert Tracker objects in generic tracking custom convertor TrkEventAthenaPool.
+
+ See "mainpage" for discussion of jobOpts.
+ */
+class TrackerEventCnvTool : public extends<AthAlgTool, Trk::ITrkEventCnvTool>
+{
+ public:
+
+ enum TrackerConcreteType { SCT, Unknown };
+
+ TrackerEventCnvTool(const std::string&,const std::string&,const IInterface*);
+
+ virtual ~TrackerEventCnvTool() = default;
+
+ virtual StatusCode initialize() override;
+
+ virtual void checkRoT( const Trk::RIO_OnTrack& rioOnTrack ) const override;
+
+ /** use the passed identifier to recreate the detector element and PRD links on the passed RIO_OnTrack
+ @param[in] rioOnTrack The RIO_OnTrack we're interested in
+ @return std::pair of the pointers to the two corresponding objects*/
+ virtual std::pair<const Trk::TrkDetElementBase*, const Trk::PrepRawData*>
+ getLinks( Trk::RIO_OnTrack& rioOnTrack ) const override;
+
+ /** @copydoc Trk::ITrkEventCnvTool::prepareRIO_OnTrack( Trk::RIO_OnTrack* rot)*/
+ virtual void prepareRIO_OnTrack( Trk::RIO_OnTrack* rot) const override;
+
+ /** Similar, but just return the EL components rather then
+ changing ROT. */
+ virtual void prepareRIO_OnTrackLink( const Trk::RIO_OnTrack* rot,
+ ELKey_t& key,
+ ELIndex_t& index ) const override;
+
+ /** @copydoc Trk::ITrkEventCnvTool::recreateRIO_OnTrack( Trk::RIO_OnTrack* rot)*/
+ virtual void recreateRIO_OnTrack( Trk::RIO_OnTrack *RoT ) const override;
+
+ /** Return the detectorElement associated with this Identifier*/
+ virtual const Trk::TrkDetElementBase* getDetectorElement(const Identifier& id, const IdentifierHash& idHash) const override;
+
+ /** Return the detectorElement associated with this Identifier*/
+ virtual const Trk::TrkDetElementBase* getDetectorElement(const Identifier& id) const override;
+
+
+ private:
+
+ /** use the passed identifier to recreate the SCT cluster link on the passed RIO_OnTrack*/
+ virtual const Trk::PrepRawData* sctClusterLink( const Identifier& id, const IdentifierHash& idHash ) const;
+
+ /** use the passed IdentifierHash to get SiDetectorElement for SCT*/
+ const TrackerDD::SiDetectorElement* getSCTDetectorElement(const IdentifierHash& waferHash) const;
+
+ bool m_setPrepRawDataLink; //!< if true, attempt to recreate link to PRD
+
+
+ //various id helpers
+ const FaserDetectorID* m_IDHelper;
+ const FaserSCT_ID* m_SCTHelper;
+
+ // added to check TRT existence (SLHC geo check)
+ const IdDictManager* m_idDictMgr;
+
+ SG::ReadHandleKey<FaserSCT_ClusterContainer> m_sctClusContName {this, "SCT_ClusterContainer", "SCT_Clusters", "SCT Cluster container name"}; //!< location of container of sct clusters
+
+ SG::ReadCondHandleKey<TrackerDD::SiDetectorElementCollection> m_SCTDetEleCollKey{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};
+ };
+
+}
+#endif // MOORETOTRACKTOOL_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/TrackerEventCnvTool.cxx b/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/TrackerEventCnvTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..92d62c99790494ae1c0a2b0cb3b62753fe0386fe
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/TrackerEventCnvTool.cxx
@@ -0,0 +1,208 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrackerEventCnvTools/TrackerEventCnvTool.h"
+
+#include "Identifier/Identifier.h"
+#include "Identifier/IdentifierHash.h"
+#include "FaserDetDescr/FaserDetectorID.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+
+#include "TrkRIO_OnTrack/RIO_OnTrack.h"
+#include "TrkPrepRawData/PrepRawData.h"
+
+#include "TrackerReadoutGeometry/SiDetectorElement.h"
+#include "IdDictDetDescr/IdDictManager.h"
+
+#include "TrackerPrepRawData/FaserSCT_ClusterCollection.h"
+#include "TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack.h"
+
+#include <vector>
+#include <cassert>
+#include <iostream>
+
+Tracker::TrackerEventCnvTool::TrackerEventCnvTool(const std::string& t,
+ const std::string& n,
+ const IInterface* p )
+ :
+ base_class(t,n,p),
+ m_setPrepRawDataLink(false),
+ m_IDHelper(nullptr),
+ m_SCTHelper(nullptr),
+ m_idDictMgr(nullptr)
+{
+ declareProperty("RecreatePRDLinks", m_setPrepRawDataLink);
+
+}
+
+StatusCode Tracker::TrackerEventCnvTool::initialize() {
+
+ StatusCode sc = AthAlgTool::initialize();
+ if (sc.isFailure()) return sc;
+
+ // check if SLHC geo is used (TRT not implemented)
+ // if not SLHC, get the TRT Det Descr manager
+ sc = detStore()->retrieve(m_idDictMgr, "IdDict");
+ if (sc.isFailure()) {
+ std::cout << "Could not get IdDictManager !" << std::endl;
+ return StatusCode::FAILURE;
+ }
+ const IdDictDictionary* dict = m_idDictMgr->manager()->find_dictionary("Tracker");
+ if (!dict) {
+ std::cout << " Cannot access Tracker dictionary "<< std::endl;
+ return StatusCode::FAILURE;
+ }
+
+ //retrieving the various ID helpers
+
+ if (detStore()->retrieve(m_IDHelper, "FaserID").isFailure()) {
+ ATH_MSG_FATAL( "Could not get FASER ID helper");
+ return StatusCode::FAILURE;
+ }
+
+ ATH_CHECK( detStore()->retrieve(m_SCTHelper, "FaserSCT_ID") );
+
+ ATH_CHECK( m_sctClusContName.initialize() );
+
+ ATH_CHECK( m_SCTDetEleCollKey.initialize() );
+
+ return sc;
+
+}
+
+void
+Tracker::TrackerEventCnvTool::checkRoT( const Trk::RIO_OnTrack& rioOnTrack ) const {
+ TrackerConcreteType type=Unknown;
+ if (0!=dynamic_cast<const FaserSCT_ClusterOnTrack*>(&rioOnTrack) ) type = SCT;
+ if (type==Unknown) {
+ ATH_MSG_ERROR("Type does not match known concrete type of Tracker! Dumping RoT:"<<rioOnTrack);
+ } else {
+ ATH_MSG_VERBOSE("Type = "<<type);
+ }
+
+ return;
+}
+
+std::pair<const Trk::TrkDetElementBase*, const Trk::PrepRawData*>
+Tracker::TrackerEventCnvTool::getLinks( Trk::RIO_OnTrack& rioOnTrack ) const
+{
+ using namespace Trk;
+ const TrkDetElementBase* detEl = 0;
+ const PrepRawData* prd = 0;
+ const Identifier& id = rioOnTrack.identify();
+
+ if (m_IDHelper->is_sct(id)) {
+ ATH_MSG_DEBUG("Set SCT detector element" );
+ // use IdentifierHash for speed
+ detEl = getSCTDetectorElement( rioOnTrack.idDE() ) ;
+ if (m_setPrepRawDataLink) prd = sctClusterLink( id, rioOnTrack.idDE() );
+ } else {
+ ATH_MSG_WARNING("Unknown type of Tracker detector from identifier :"
+ << id<<", in string form:"
+ << m_IDHelper->show_to_string(id)
+ );
+ }
+ return std::pair<const Trk::TrkDetElementBase*, const Trk::PrepRawData*>(detEl,prd);
+}
+
+void Tracker::TrackerEventCnvTool::prepareRIO_OnTrack( Trk::RIO_OnTrack *RoT ) const {
+
+ Tracker::FaserSCT_ClusterOnTrack* sct = dynamic_cast<Tracker::FaserSCT_ClusterOnTrack*>(RoT);
+ if (sct!=0) {
+ prepareRIO_OnTrackElementLink<const Tracker::FaserSCT_ClusterContainer, Tracker::FaserSCT_ClusterOnTrack>(sct);
+ return;
+ }
+ return;
+}
+
+void
+Tracker::TrackerEventCnvTool::prepareRIO_OnTrackLink( const Trk::RIO_OnTrack *RoT,
+ ELKey_t& key,
+ ELIndex_t& index) const
+{
+ const Tracker::FaserSCT_ClusterOnTrack* sct = dynamic_cast<const Tracker::FaserSCT_ClusterOnTrack*>(RoT);
+ if (sct!=0) {
+ prepareRIO_OnTrackElementLink<const Tracker::FaserSCT_ClusterContainer, Tracker::FaserSCT_ClusterOnTrack>(sct, key, index);
+ return;
+ }
+ return;
+}
+
+void Tracker::TrackerEventCnvTool::recreateRIO_OnTrack( Trk::RIO_OnTrack *RoT ) const {
+ std::pair<const Trk::TrkDetElementBase *, const Trk::PrepRawData *> pair = getLinks( *RoT );
+ Trk::ITrkEventCnvTool::setRoT_Values( pair, RoT );
+ return;
+}
+
+const Trk::TrkDetElementBase*
+Tracker::TrackerEventCnvTool::getDetectorElement(const Identifier& id, const IdentifierHash& idHash) const {
+
+ const Trk::TrkDetElementBase* detEl=0;
+
+ if (m_IDHelper->is_sct(id)) {
+
+ ATH_MSG_DEBUG("Set SCT detector element" );
+ // use IdentifierHash for speed
+ detEl = getSCTDetectorElement( idHash ) ;
+ } else {
+ ATH_MSG_WARNING("Unknown type of Tracker detector from identifier :"
+ << id<<", in string form:"
+ << m_IDHelper->show_to_string(id)
+ );
+ }
+ return detEl;
+}
+
+const Trk::TrkDetElementBase*
+Tracker::TrackerEventCnvTool::getDetectorElement(const Identifier& id) const {
+
+ const Trk::TrkDetElementBase* detEl=0;
+
+ if (m_IDHelper->is_sct(id)) {
+ ATH_MSG_DEBUG("Set SCT detector element" );
+ const Identifier wafer_id = m_SCTHelper->wafer_id(id);
+ const IdentifierHash wafer_hash = m_SCTHelper->wafer_hash(wafer_id);
+ detEl = getSCTDetectorElement( wafer_hash ) ;
+ } else {
+ ATH_MSG_WARNING("Unknown type of Tracker detector from identifier :"<< id<<", in string form:"
+ << m_IDHelper->show_to_string(id) );
+ }
+ return detEl;
+}
+
+const Trk::PrepRawData*
+Tracker::TrackerEventCnvTool::sctClusterLink( const Identifier& id, const IdentifierHash& idHash ) const {
+ using namespace Trk;
+ // need to retrieve pointers to collections
+ // retrieve Pixel cluster container
+
+ // obviously this can be optimised! EJWM
+ SG::ReadHandle<FaserSCT_ClusterContainer> h_sctClusCont(m_sctClusContName);
+ if (!h_sctClusCont.isValid()) {
+ ATH_MSG_ERROR("FaserSCT Cluster container not found at "<<m_sctClusContName);
+ return 0;
+ } else {
+ ATH_MSG_DEBUG("FaserSCT Cluster Container found" );
+ }
+ const FaserSCT_ClusterCollection *ptr = h_sctClusCont->indexFindPtr(idHash);
+ // if we find PRD, then recreate link
+ if (ptr!=nullptr) {
+ //loop though collection to find matching PRD.
+ FaserSCT_ClusterCollection::const_iterator collIt = ptr->begin();
+ FaserSCT_ClusterCollection::const_iterator collItEnd = ptr->end();
+ // there MUST be a faster way to do this!!
+ for ( ; collIt!=collItEnd; collIt++) {
+ if ( (*collIt)->identify()==id ) return *collIt;
+ }
+ }
+ ATH_MSG_DEBUG("No matching PRD found" );
+ return 0;
+}
+
+const TrackerDD::SiDetectorElement* Tracker::TrackerEventCnvTool::getSCTDetectorElement(const IdentifierHash& waferHash) const {
+ SG::ReadCondHandle<TrackerDD::SiDetectorElementCollection> sctDetEle{m_SCTDetEleCollKey};
+ if (not sctDetEle.isValid()) return nullptr;
+ return sctDetEle->getDetectorElement(waferHash);
+}
+
diff --git a/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/components/TrackerEventCnvTool_entries.cxx b/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/components/TrackerEventCnvTool_entries.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..3d7144a021d532b496ba19bcba2422c01936ba11
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/components/TrackerEventCnvTool_entries.cxx
@@ -0,0 +1,6 @@
+#include "TrackerEventCnvTools/TrackerEventCnvTool.h"
+
+using namespace Tracker;
+
+DECLARE_COMPONENT( TrackerEventCnvTool )
+
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txt b/Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txt
index 1a1a269b2e00ce4f4994965408f55141d9186c14..259453c94f261532d0e1054ace7259760fada14f 100644
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txt
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txt
@@ -10,11 +10,13 @@ atlas_subdir( TrackerEventTPCnv )
atlas_add_tpcnv_library( TrackerEventTPCnv
TrackerEventTPCnv/*.h src/*.cxx
TrackerEventTPCnv/TrackerPrepRawData/*.h src/TrackerPrepRawData/*.cxx
+ TrackerEventTPCnv/TrackerRIO_OnTrack/*.h src/TrackerRIO_OnTrack/*.cxx
PUBLIC_HEADERS TrackerEventTPCnv
LINK_LIBRARIES AthAllocators AthLinks DataModelAthenaPoolLib StoreGateLib
AthenaPoolCnvSvcLib AthenaPoolUtilities Identifier GaudiKernel
TrackerIdentifier
TrackerPrepRawData
+ TrackerRIO_OnTrack
TrkEventTPCnv
TrkPrepRawData
TrkSpacePoint
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h
index 11d25251977fdc838dc3bc87499772ed5c98a3b7..1407bd063facddcf4166d72b55c2ce5389adb072 100644
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h
@@ -12,7 +12,7 @@
//-----------------------------------------------------------------------------
// #include "InDetEventTPCnv/InDetTrack_tlp1.h"
-// #include "InDetEventTPCnv/InDetTrack_tlp2.h"
+#include "TrackerEventTPCnv/TrackerTrack_tlp2.h"
// #include "InDetEventTPCnv/PixelClusterContainer_tlp1.h"
#include "TrackerEventTPCnv/TrackerPrepRawData/TrackerCluster_p1.h"
#include "TrackerEventTPCnv/TrackerPrepRawData/TrackerPRD_Collection_p1.h"
@@ -33,6 +33,8 @@
// #include "InDetEventTPCnv/TRT_DriftCircleContainer_tlp1.h"
// #include "InDetEventTPCnv/InDetPrepRawData/PixelGangedClusterAmbiguities_p1.h"
// #include "InDetEventTPCnv/TRT_DriftCircleContainer_tlp1.h"
+#include "TrackerEventTPCnv/TrackerRIO_OnTrack/SiClusterOnTrack_p1.h"
+#include "TrackerEventTPCnv/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack_p2.h"
// #include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingPixelClustersOnTrack_p1.h"
// #include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingSCT_ClustersOnTrack_p1.h"
// #include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingTRT_DriftCirclesOnTrack_p1.h"
@@ -55,6 +57,8 @@ namespace TrackerEventTPCnvDict {
// std::vector< InDet::TRT_DriftCircle_p2 > m_v6a;
std::vector< Tracker::TrackerPRD_Collection_p1 > m_v7;
std::vector< Tracker::TrackerPRD_Container_p1 > m_v8;
+ std::vector< Tracker::SiClusterOnTrack_p1 > m_v9;
+ std::vector< Tracker::FaserSCT_ClusterOnTrack_p2 > m_10;
// std::vector< InDet::CompetingPixelClustersOnTrack_p1> m_v9;
// std::vector< InDet::CompetingSCT_ClustersOnTrack_p1> m_v10;
// std::vector< InDet::CompetingTRT_DriftCirclesOnTrack_p1> m_v11;
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrackCnv_p2.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrackCnv_p2.h
new file mode 100644
index 0000000000000000000000000000000000000000..7b6b1b19d81a9bbdffa7fc728352e65d6b00beee
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrackCnv_p2.h
@@ -0,0 +1,38 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_CLUSTER_ON_TRACK_CNV_p2_H
+#define FASERSCT_CLUSTER_ON_TRACK_CNV_p2_H
+
+#include "TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack.h"
+#include "TrackerEventTPCnv/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack_p2.h"
+
+#include "DataModelAthenaPool/ElementLinkCnv_p1.h"
+#include "AthLinks/ElementLink.h"
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
+
+#include "TrkEventTPCnv/TrkEventPrimitives/ErrorMatrixCnv_p1.h"
+#include "TrkEventTPCnv/TrkEventPrimitives/LocalParametersCnv_p1.h"
+
+#include "GaudiKernel/ToolHandle.h"
+#include "TrkEventCnvTools/IEventCnvSuperTool.h"
+
+class MsgStream;
+
+class FaserSCT_ClusterOnTrackCnv_p2 : public T_AthenaPoolTPPolyCnvBase< Trk::MeasurementBase, Tracker::FaserSCT_ClusterOnTrack, Tracker::FaserSCT_ClusterOnTrack_p2 >{
+public:
+ FaserSCT_ClusterOnTrackCnv_p2(): m_eventCnvTool("Trk::EventCnvSuperTool/EventCnvSuperTool"),
+ m_localParCnv(0), m_errorMxCnv(0) {}
+
+ void persToTrans( const Tracker::FaserSCT_ClusterOnTrack_p2 *persObj, Tracker::FaserSCT_ClusterOnTrack *transObj, MsgStream &log );
+ void transToPers( const Tracker::FaserSCT_ClusterOnTrack *transObj, Tracker::FaserSCT_ClusterOnTrack_p2 *persObj, MsgStream &log );
+
+protected:
+ ToolHandle<Trk::IEventCnvSuperTool> m_eventCnvTool;
+ ElementLinkCnv_p1< ElementLinkToTrackerCFaserSCT_ClusterContainer > m_elCnv;
+ LocalParametersCnv_p1* m_localParCnv;
+ ErrorMatrixCnv_p1* m_errorMxCnv;
+};
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack_p2.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack_p2.h
new file mode 100644
index 0000000000000000000000000000000000000000..b706a61226c6a75d07d9947135e5d087f9291b62
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack_p2.h
@@ -0,0 +1,34 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_CLUSTER_ON_TRACK_p2_TRK_H
+#define FASERSCT_CLUSTER_ON_TRACK_p2_TRK_H
+
+#include "AthenaPoolUtilities/TPObjRef.h"
+#include "Identifier/IdentifierHash.h"
+#include "DataModelAthenaPool/ElementLink_p1.h"
+
+namespace Tracker
+{
+ class FaserSCT_ClusterOnTrack_p2
+ {
+ public:
+ FaserSCT_ClusterOnTrack_p2():m_id{0}, m_idDE{0}, m_isbroad(false), m_positionAlongStrip{0.} {}
+
+
+ unsigned long long m_id;
+ TPObjRef m_localParams;
+ TPObjRef m_localErrMat;
+
+ IdentifierHash::value_type m_idDE;
+ bool m_isbroad;
+
+ ElementLinkInt_p1 m_prdLink;
+
+//element allowing for a calculation of global position
+ float m_positionAlongStrip;
+ };
+}
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/SiClusterOnTrackCnv_p1.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/SiClusterOnTrackCnv_p1.h
new file mode 100644
index 0000000000000000000000000000000000000000..1854137194419e54e9b78784d8f05656ed651eb0
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/SiClusterOnTrackCnv_p1.h
@@ -0,0 +1,41 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef SI_CLUSTER_ON_TRACK_CNV_P1_H
+#define SI_CLUSTER_ON_TRACK_CNV_P1_H
+
+//-----------------------------------------------------------------------------
+//
+// file: SiClusterOnTrackCnv_p1.h
+//
+//-----------------------------------------------------------------------------
+
+#include "TrackerRIO_OnTrack/SiClusterOnTrack.h"
+#include "TrackerEventTPCnv/TrackerRIO_OnTrack/SiClusterOnTrack_p1.h"
+
+#include "TrkEventTPCnv/TrkRIO_OnTrack/RIO_OnTrackCnv_p1.h"
+
+class MsgStream;
+
+class SiClusterOnTrackCnv_p1
+ : public T_AthenaPoolTPAbstractPolyCnvBase< Trk::MeasurementBase,
+ Tracker::SiClusterOnTrack,
+ Tracker::SiClusterOnTrack_p1 >
+{
+public:
+ SiClusterOnTrackCnv_p1() : m_RIOCnv(0) {}
+
+ void persToTrans( const Tracker::SiClusterOnTrack_p1 *persObj,
+ Tracker::SiClusterOnTrack *transObj,
+ MsgStream &log );
+ void transToPers( const Tracker::SiClusterOnTrack *transObj,
+ Tracker::SiClusterOnTrack_p1 *persObj,
+ MsgStream &log );
+
+
+protected:
+ RIO_OnTrackCnv_p1 *m_RIOCnv;
+};
+
+#endif // SI_CLUSTER_ON_TRACK_CNV_P1_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/SiClusterOnTrack_p1.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/SiClusterOnTrack_p1.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a149d94bd24f7ce0986812fd817deedba9eb6f1
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerRIO_OnTrack/SiClusterOnTrack_p1.h
@@ -0,0 +1,31 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef SI_CLUSTER_ON_TRACK_P1_TRK_H
+#define SI_CLUSTER_ON_TRACK_P1_TRK_H
+
+//-----------------------------------------------------------------------------
+//
+// file: SiClusterOnTrack_p1.h
+//
+//-----------------------------------------------------------------------------
+
+#include "AthenaPoolUtilities/TPObjRef.h"
+
+#include "Identifier/IdentifierHash.h"
+
+namespace Tracker
+{
+ class SiClusterOnTrack_p1 {
+ public:
+ SiClusterOnTrack_p1():m_idDE{},m_isbroad(false) {}
+
+ // base RIO_OnTrack_p1
+ TPObjRef m_RIO;
+ IdentifierHash::value_type m_idDE;
+ bool m_isbroad;
+ };
+}
+
+#endif // SI_CLUSTER_ON_TRACK_P1_TRK_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerTrackCnv_tlp2.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerTrackCnv_tlp2.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8ba7264574a798f77eeff99760b05ccbad7c03c
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerTrackCnv_tlp2.h
@@ -0,0 +1,52 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKER_TRACKCNV_tlp2_H
+#define TRACKER_TRACKCNV_tlp2_H
+
+
+#include "AthenaPoolCnvSvc/AthenaPoolTopLevelExtTPConverter.h"
+
+#include "TrackerTrack_tlp2.h"
+
+// #include "TrackerEventTPCnv/InDetRIO_OnTrack/PixelClusterOnTrackCnv_p2.h"
+#include "TrackerEventTPCnv/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrackCnv_p2.h"
+// #include "InDetEventTPCnv/InDetRIO_OnTrack/SiClusterOnTrackCnv_p2.h"
+// #include "InDetEventTPCnv/InDetRIO_OnTrack/TRT_DriftCircleOnTrackCnv_p2.h"
+
+// #include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingPixelClustersOnTrackCnv_p1.h"
+// #include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingSCT_ClustersOnTrackCnv_p1.h"
+// #include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingTRT_DriftCirclesOnTrackCnv_p1.h"
+
+#include <iostream>
+
+class TrackerTrackCnv_tlp2
+ : public AthenaPoolTopLevelExtTPConverter< Tracker::Track_tlp2 >
+{
+public:
+
+ TrackerTrackCnv_tlp2();
+ virtual ~TrackerTrackCnv_tlp2() {}
+
+ virtual unsigned short getConverterID() { return 1; }
+
+ virtual void setPStorage( Tracker::Track_tlp2 *storage );
+
+protected:
+ // PixelClusterOnTrackCnv_p2 m_pixelClustersOTCnv;
+ FaserSCT_ClusterOnTrackCnv_p2 m_sctClustersOTCnv;
+ // TRT_DriftCircleOnTrackCnv_p2 m_trtDriftCirclesOTCnv;
+ // SiClusterOnTrackCnv_p2 m_siClustersOTCnv;
+
+ // CompetingPixelClustersOnTrackCnv_p1 m_pixelCrotCnv;
+ // CompetingSCT_ClustersOnTrackCnv_p1 m_sctCrotCnv;
+ // CompetingTRT_DriftCirclesOnTrackCnv_p1 m_trtCrotCnv;
+
+
+};
+
+
+#endif
+
+
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerTrack_tlp2.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerTrack_tlp2.h
new file mode 100644
index 0000000000000000000000000000000000000000..242e2ab4ceeb6d2b00b9560a504a22f87d3b8363
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerTrack_tlp2.h
@@ -0,0 +1,40 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKER_TRACK_tlp2_H
+#define TRACKER_TRACK_tlp2_H
+
+
+
+//-----------------------------------------------------------------------------
+// TrackerRIO_OnTrack
+//-----------------------------------------------------------------------------
+// #include "TrackerEventTPCnv/InDetRIO_OnTrack/TRT_DriftCircleOnTrack_p2.h"
+// #include "TrackerEventTPCnv/InDetRIO_OnTrack/PixelClusterOnTrack_p2.h"
+#include "TrackerEventTPCnv/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack_p2.h"
+
+
+// Tracker cROTS
+
+// #include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingPixelClustersOnTrack_p1.h"
+// #include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingSCT_ClustersOnTrack_p1.h"
+// #include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingTRT_DriftCirclesOnTrack_p1.h"
+
+namespace Tracker
+{
+ class Track_tlp2
+ {
+ public:
+ Track_tlp2() {}
+
+ // std::vector< InDet::PixelClusterOnTrack_p2 > m_pixelClustersOT;
+ std::vector< Tracker::FaserSCT_ClusterOnTrack_p2 > m_sctClustersOT;
+ // std::vector< InDet::TRT_DriftCircleOnTrack_p2 > m_trtDriftCirclesOT;
+ // std::vector< InDet::CompetingPixelClustersOnTrack_p1> m_pixelCROTs;
+ // std::vector< InDet::CompetingSCT_ClustersOnTrack_p1> m_sctCROTs;
+ // std::vector< InDet::CompetingTRT_DriftCirclesOnTrack_p1> m_trtCROTs;
+ };
+}
+
+#endif
\ No newline at end of file
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/selection.xml b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/selection.xml
index d74ef582b72ea1988e8d188b92ada957340df1d5..efe77176618dbe588024e7bd8df2dcde8867e08d 100644
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/selection.xml
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/selection.xml
@@ -1,11 +1,12 @@
<lcgdict>
- <!-- <class name="InDet::Track_tlp1" id="8380F7AC-4A8F-4382-95A5-1234E43D3B08" />
- <class name="InDet::Track_tlp2" id="4E3778E2-1497-4F10-8746-AA02319FAC83" />
- -->
+ <!-- <class name="InDet::Track_tlp1" id="8380F7AC-4A8F-4382-95A5-1234E43D3B08" /> -->
+ <!-- <class name="Tracker::Track_tlp2" id="4E3778E2-1497-4F10-8746-AA02319FAC83" /> -->
+ <class name="Tracker::Track_tlp2" id="27491695-F64A-43EE-859D-73F33AF3317D" />
+
<!-- InDetRIO_OnTrack -->
- <!-- <class name="InDet::SiClusterOnTrack_p1" />
- <class name="std::vector<InDet::SiClusterOnTrack_p1>" /> -->
+ <class name="Tracker::SiClusterOnTrack_p1" />
+ <class name="std::vector<Tracker::SiClusterOnTrack_p1>" />
<!-- <class name="InDet::SiClusterOnTrack_p2" /> -->
<!-- <class name="std::vector<InDet::SiClusterOnTrack_p2>" /> -->
<!-- <class name="InDet::PixelClusterOnTrack_p1" />
@@ -13,9 +14,10 @@
<class name="InDet::PixelClusterOnTrack_p2" />
<class name="std::vector<InDet::PixelClusterOnTrack_p2>" />
<class name="InDet::SCT_ClusterOnTrack_p1" />
- <class name="std::vector<InDet::SCT_ClusterOnTrack_p1>" />
- <class name="InDet::SCT_ClusterOnTrack_p2" />
- <class name="std::vector<InDet::SCT_ClusterOnTrack_p2>" />
+ <class name="std::vector<InDet::SCT_ClusterOnTrack_p1>" /> -->
+ <class name="Tracker::FaserSCT_ClusterOnTrack_p2" />
+ <class name="std::vector<Tracker::FaserSCT_ClusterOnTrack_p2>" />
+ <!--
<class name="InDet::TRT_DriftCircleOnTrack_p1" />
<class name="std::vector<InDet::TRT_DriftCircleOnTrack_p1>" />
<class name="InDet::TRT_DriftCircleOnTrack_p2" />
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrackCnv_p2.cxx b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrackCnv_p2.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..2a0c03a03cceea1a63edd0e0d66957362f312891
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrackCnv_p2.cxx
@@ -0,0 +1,73 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrackerEventTPCnv/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrackCnv_p2.h"
+
+#include "AthLinks/ElementLink.h"
+#include "Identifier/Identifier.h"
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
+#include "TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack.h"
+#include "TrkEventTPCnv/helpers/EigenHelpers.h"
+
+void FaserSCT_ClusterOnTrackCnv_p2::persToTrans( const Tracker::FaserSCT_ClusterOnTrack_p2 *persObj, Tracker::FaserSCT_ClusterOnTrack *transObj, MsgStream &log ) {
+
+ ElementLinkToTrackerCFaserSCT_ClusterContainer rio;
+ m_elCnv.persToTrans(&persObj->m_prdLink,&rio,log);
+
+ Trk::LocalParameters localParams;
+ fillTransFromPStore( &m_localParCnv, persObj->m_localParams, &localParams, log );
+
+ Trk::ErrorMatrix dummy;
+ Amg::MatrixX localCovariance;
+ fillTransFromPStore( &m_errorMxCnv, persObj->m_localErrMat, &dummy, log );
+ EigenHelpers::vectorToEigenMatrix(dummy.values, localCovariance, "FaserSCT_ClusterOnTrackCnv_p2");
+
+ // When reading in 32-bit id, must cast to unsigned int
+ const Identifier::value_type upper = 0XFFFFFFFF00000000LL;
+ const Identifier::value_type lower = 0X00000000FFFFFFFFLL;
+ const Identifier::value_type testUpper = persObj->m_id & upper;
+ const Identifier::value_type testLower = persObj->m_id & lower;
+ Identifier id;
+ if ( testUpper == 0 && testLower > 0) {
+ Identifier32::value_type id1 = persObj->m_id;
+ id = id1;
+ } else {
+ id = persObj->m_id;
+ }
+
+ *transObj = Tracker::FaserSCT_ClusterOnTrack (rio,
+ localParams,
+ localCovariance,
+ persObj->m_idDE,
+ id,
+ persObj->m_isbroad,
+ persObj->m_positionAlongStrip);
+
+ // Attempt to call supertool to fill in detElements
+ m_eventCnvTool->recreateRIO_OnTrack(transObj);
+ if (transObj->detectorElement()==0) {
+ log << MSG::WARNING<<"Unable to reset DetEl for this RIO_OnTrack, "
+ << "probably because of a problem with the Identifier/IdentifierHash : ("
+ << transObj->identify()<<"/"<<transObj->idDE()<<endmsg;
+ }
+}
+
+void FaserSCT_ClusterOnTrackCnv_p2::transToPers(const Tracker::FaserSCT_ClusterOnTrack* transObj, Tracker::FaserSCT_ClusterOnTrack_p2* persObj, MsgStream& log) {
+ if (transObj==nullptr or persObj==nullptr) return;
+
+ persObj->m_id = transObj->identify().get_compact();
+ persObj->m_localParams = toPersistent( &m_localParCnv, &transObj->localParameters(), log );
+ Trk::ErrorMatrix pMat;
+ EigenHelpers::eigenMatrixToVector(pMat.values, transObj->localCovariance(), "FaserSCT_ClusterOnTrackCnv_p2");
+ persObj->m_localErrMat = toPersistent( &m_errorMxCnv, &pMat, log );
+ persObj->m_idDE = transObj->idDE();
+ persObj->m_isbroad = transObj->isBroadCluster();
+ persObj->m_positionAlongStrip = static_cast<float>(transObj->positionAlongStrip());
+
+ static const SG::InitializedReadHandleKey<Tracker::FaserSCT_ClusterContainer> sctClusContName ("FaserSCT_Clusters");
+ ElementLink<Tracker::FaserSCT_ClusterContainer>::index_type hashAndIndex{0};
+ bool isFound{m_eventCnvTool->getHashAndIndex<Tracker::FaserSCT_ClusterContainer, Tracker::FaserSCT_ClusterOnTrack>(transObj, sctClusContName, hashAndIndex)};
+ persObj->m_prdLink.m_contName = (isFound ? sctClusContName.key() : "");
+ persObj->m_prdLink.m_elementIndex = hashAndIndex;
+}
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/TrackerRIO_OnTrack/SiClusterOnTrackCnv_p1.cxx b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/TrackerRIO_OnTrack/SiClusterOnTrackCnv_p1.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..8193f73a0ba11abdc9b1613171f60c00bab15db8
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/TrackerRIO_OnTrack/SiClusterOnTrackCnv_p1.cxx
@@ -0,0 +1,38 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//-----------------------------------------------------------------------------
+//
+// file: SiClusterOnTrackCnv_p1.cxx
+//
+//-----------------------------------------------------------------------------
+
+#include "TrackerRIO_OnTrack/SiClusterOnTrack.h"
+#include "TrackerEventTPCnv/TrackerRIO_OnTrack/SiClusterOnTrackCnv_p1.h"
+//#include "TrkEventTPCnv/helpers/CLHEPHelpers.h"
+//#include "CLHEP/Geometry/Point3D.h"
+
+
+void SiClusterOnTrackCnv_p1::
+persToTrans( const Tracker::SiClusterOnTrack_p1 *persObj,
+ Tracker::SiClusterOnTrack *transObj,
+ MsgStream &log )
+{
+ transObj->m_idDE = persObj->m_idDE;
+ transObj->m_isbroad = persObj->m_isbroad;
+ fillTransFromPStore( &m_RIOCnv, persObj->m_RIO, transObj, log );
+ // m_globalPosition - transient?
+}
+
+
+void SiClusterOnTrackCnv_p1::
+transToPers( const Tracker::SiClusterOnTrack *transObj,
+ Tracker::SiClusterOnTrack_p1 *persObj,
+ MsgStream &log)
+{
+ persObj->m_RIO = baseToPersistent( &m_RIOCnv, transObj, log );
+ persObj->m_idDE = transObj->m_idDE;
+ persObj->m_isbroad = transObj->m_isbroad;
+ // m_globalPosition - transient?
+}
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/TrackerTrkCnv_tlp2.cxx b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/TrackerTrkCnv_tlp2.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..f9c2e3e11ab2bb9eda7b37cb182473613e515dcd
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/TrackerTrkCnv_tlp2.cxx
@@ -0,0 +1,35 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrackerEventTPCnv/TrackerTrackCnv_tlp2.h"
+
+
+TrackerTrackCnv_tlp2::TrackerTrackCnv_tlp2()
+{
+ // Add all converters defined in this top level converter:
+ // never change the order of adding converters!
+// addTPConverter( &m_pixelClustersOTCnv );
+ addTPConverter( &m_sctClustersOTCnv );
+// addTPConverter( &m_trtDriftCirclesOTCnv );
+
+// addTPConverter( &m_pixelCrotCnv );
+// addTPConverter( &m_sctCrotCnv );
+// addTPConverter( &m_trtCrotCnv );
+
+}
+
+
+
+void TrackerTrackCnv_tlp2::setPStorage( Tracker::Track_tlp2 *storage )
+{
+// m_pixelClustersOTCnv. setPStorage( &storage->m_pixelClustersOT );
+ m_sctClustersOTCnv. setPStorage( &storage->m_sctClustersOT );
+// m_trtDriftCirclesOTCnv. setPStorage( &storage->m_trtDriftCirclesOT );
+
+// m_pixelCrotCnv. setPStorage( &storage->m_pixelCROTs );
+// m_sctCrotCnv. setPStorage( &storage->m_sctCROTs );
+// m_trtCrotCnv. setPStorage( &storage->m_trtCROTs );
+
+}
+
diff --git a/Tracker/TrackerRecAlgs/TrackerClusterFit/CMakeLists.txt b/Tracker/TrackerRecAlgs/TrackerClusterFit/CMakeLists.txt
index 254b5a4054a316406c3d065f4546d80e0b4a8bbd..6275abd108cb7cf1fc17993aea1575c511e97edc 100644
--- a/Tracker/TrackerRecAlgs/TrackerClusterFit/CMakeLists.txt
+++ b/Tracker/TrackerRecAlgs/TrackerClusterFit/CMakeLists.txt
@@ -14,7 +14,7 @@ atlas_add_component( TrackerClusterFit
src/components/*.cxx
INCLUDE_DIRS ${EIGEN_INCLUDE_DIRS}
LINK_LIBRARIES ${EIGEN_LIBRARIES} AthenaBaseComps AthViews StoreGateLib SGtests Identifier GaudiKernel TrackerRawData TrackerPrepRawData FaserDetDescr TrackerIdentifier TrackerReadoutGeometry xAODFaserTrigger
- TrkTrack TrkEventPrimitives TrkRIO_OnTrack )
+ TrkTrack TrkEventPrimitives TrackerRIO_OnTrack TrkRIO_OnTrack TrackerEventTPCnv )
# Install files from the package:
#atlas_install_headers( TrackerPrepRawDataFormation )
diff --git a/Tracker/TrackerRecAlgs/TrackerClusterFit/src/ClusterFitAlg.cxx b/Tracker/TrackerRecAlgs/TrackerClusterFit/src/ClusterFitAlg.cxx
index 8fe463790db2b8e474b911f3fa520f2e257234d0..ab88bf504ec140e847eaed5e39eee664943ad164 100644
--- a/Tracker/TrackerRecAlgs/TrackerClusterFit/src/ClusterFitAlg.cxx
+++ b/Tracker/TrackerRecAlgs/TrackerClusterFit/src/ClusterFitAlg.cxx
@@ -11,6 +11,7 @@
#include "ClusterFitAlg.h"
#include "TrackerPrepRawData/FaserSCT_Cluster.h"
+#include "TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack.h"
#include "FaserDetDescr/FaserDetectorID.h"
#include "TrackerIdentifier/FaserSCT_ID.h"
#include "TrkEventPrimitives/FitQuality.h"
@@ -412,15 +413,17 @@ ClusterFitAlg::GetState( const Eigen::Matrix< double, 4, 1 >& fitResult,
covPar5->block<4,4>(0,0) = covPar;
covPar5->block<1,1>(4,4) = Eigen::Matrix< double, 1, 1 > { (50000.0)*qoverp*qoverp };
- // Trk::RIO_OnTrack* rot = nullptr;
- // if (fitCluster != nullptr)
- // {
- // rot = new Trk::RIO_OnTrack{ Trk::LocalParameters { Trk::DefinedParameter { fitCluster->localPosition()[0], Trk::loc1 },
- // Trk::DefinedParameter { fitCluster->localPosition()[1], Trk::loc2 } },
- // fitCluster->localCovariance(), fitCluster->identify()};
- // }
+ FaserSCT_ClusterOnTrack* rot = nullptr;
+ if (fitCluster != nullptr)
+ {
+ rot = new FaserSCT_ClusterOnTrack{ fitCluster,
+ Trk::LocalParameters { Trk::DefinedParameter { fitCluster->localPosition()[0], Trk::loc1 },
+ Trk::DefinedParameter { fitCluster->localPosition()[1], Trk::loc2 } },
+ fitCluster->localCovariance(),
+ m_idHelper->wafer_hash(fitCluster->detectorElement()->identify())};
+ }
std::unique_ptr<Trk::TrackParameters> p { new Trk::CurvilinearParameters { pos, phi, theta, qoverp, covPar5.release() } };
- return new Trk::TrackStateOnSurface { nullptr, p.release() };
+ return new Trk::TrackStateOnSurface { rot, p.release() };
}
std::tuple<Eigen::Matrix<double, 4, 1>,
diff --git a/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/CMakeLists.txt b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8a50a1048037209c13b4f884aef878c587ea46f6
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS and FASER collaborations
+
+# Declare the package name:
+atlas_subdir( TrackerRIO_OnTrack )
+
+# Component(s) in the package:
+atlas_add_library( TrackerRIO_OnTrack
+ src/*.cxx
+ PUBLIC_HEADERS TrackerRIO_OnTrack
+ LINK_LIBRARIES AthLinks AthenaKernel CxxUtils Identifier GaudiKernel TrackerPrepRawData TrkEventPrimitives TrkRIO_OnTrack
+ PRIVATE_LINK_LIBRARIES TrackerIdentifier TrackerReadoutGeometry TrkSurfaces )
+
+atlas_add_dictionary( TrackerRIO_OnTrackDict
+ TrackerRIO_OnTrack/TrackerRIO_OnTrackDict.h
+ TrackerRIO_OnTrack/selection.xml
+ LINK_LIBRARIES TrackerRIO_OnTrack )
diff --git a/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/ATLAS_CHECK_THREAD_SAFETY b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/ATLAS_CHECK_THREAD_SAFETY
new file mode 100644
index 0000000000000000000000000000000000000000..e58e92a4b5b3104324727d70f9343be25b4491d0
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/ATLAS_CHECK_THREAD_SAFETY
@@ -0,0 +1 @@
+Tracker/TrackerRecEvent/TrackerRIO_OnTrack
\ No newline at end of file
diff --git a/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack.h b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack.h
new file mode 100644
index 0000000000000000000000000000000000000000..b338eb95d263f51afa2b01fcd2ee4829bd775080
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack.h
@@ -0,0 +1,199 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// FaserSCT_ClusterOnTrack.h, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERRIO_ONTRACK_FASERSCTCLUSTERONTRACK_H
+#define TRACKERRIO_ONTRACK_FASERSCTCLUSTERONTRACK_H
+
+// Base classes
+#include "TrackerRIO_OnTrack/SiClusterOnTrack.h"
+
+// for ElementLink to IdentifiableContainer SCT_ClusterContainer
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
+#include "AthLinks/ElementLink.h"
+
+
+class FaserSCT_Cluster;
+
+namespace Trk {
+ class Surface;
+ class LocalParameters;
+ class TrkDetElementBase;
+ class ITrkEventCnvTool;
+}
+
+namespace TrackerDD {
+ class SiDetectorElement;
+}
+
+typedef ElementLink<Tracker::FaserSCT_ClusterContainer> ElementLinkToTrackerCFaserSCT_ClusterContainer;
+
+namespace Tracker{
+
+ /**@class FaserSCT_ClusterOnTrack
+ Specific class to represent the SCT measurements.
+ It does not currently extend the interface of Tracker::SiClusterOnTrack.
+
+ @author Veronique.Boisvert@cern.ch, Edward.Moyse@cern.ch, Andreas.Salzburger@cern.ch, dcasper@uci.edu
+ */
+ class FaserSCT_ClusterOnTrack final : public SiClusterOnTrack {
+
+ public:
+ friend class Trk::ITrkEventCnvTool;
+ /**For POOL only. Do not use*/
+ FaserSCT_ClusterOnTrack();
+ /**Copy constructor*/
+ FaserSCT_ClusterOnTrack(const FaserSCT_ClusterOnTrack &) = default;
+
+ /** Constructor with parameters :
+ RIO/PrepRawData pointer, LocalPosition*, LocalErrorMatrix*, idDE&
+ The base class owns local position, error matrix, this class owns global pos.
+ Everything else is owned elsewhere. */
+ FaserSCT_ClusterOnTrack( const Tracker::FaserSCT_Cluster* RIO,
+ const Trk::LocalParameters* locpars,
+ const Amg::MatrixX* locerr,
+ const IdentifierHash& idDE,
+ bool isbroad=false);
+
+ /** Constructor with parameters :
+ RIO/PrepRawData pointer, LocalPosition*, LocalErrorMatrix*, idDE&,
+ Global Position
+ The base class owns local position, error matrix, this class owns global pos.
+ Everything else is owned elsewhere. */
+ FaserSCT_ClusterOnTrack( const Tracker::FaserSCT_Cluster* RIO,
+ const Trk::LocalParameters* locpars,
+ const Amg::MatrixX* locerr,
+ const IdentifierHash& idDE,
+ const Amg::Vector3D& globalPosition,
+ bool isbroad=false);
+
+ /** Constructor with parameters :
+ RIO/PrepRawData pointer, LocalPosition*, LocalErrorMatrix*, idDE&
+ The base class owns local position, error matrix, this class owns global pos.
+ Everything else is owned elsewhere. */
+ FaserSCT_ClusterOnTrack( const Tracker::FaserSCT_Cluster* RIO,
+ const Trk::LocalParameters& locpars,
+ const Amg::MatrixX& locerr,
+ const IdentifierHash& idDE,
+ bool isbroad=false);
+
+ /** Constructor with parameters :
+ RIO/PrepRawData pointer, LocalPosition*, LocalErrorMatrix*, idDE&,
+ Global Position
+ The base class owns local position, error matrix, this class owns global pos.
+ Everything else is owned elsewhere. */
+ FaserSCT_ClusterOnTrack( const Tracker::FaserSCT_Cluster* RIO,
+ const Trk::LocalParameters& locpars,
+ const Amg::MatrixX& locerr,
+ const IdentifierHash& idDE,
+ const Amg::Vector3D& globalPosition,
+ bool isbroad=false);
+
+ /*
+ * Constuctor used by P->T converter.
+ * The P->T converter calls the
+ * setValues method to complete the object
+ * e.g set/reset the DetectorElement
+ */
+ FaserSCT_ClusterOnTrack( const ElementLinkToTrackerCFaserSCT_ClusterContainer& RIO,
+ const Trk::LocalParameters& locpars,
+ const Amg::MatrixX& locerr,
+ IdentifierHash idDE,
+ const Identifier& id,
+ bool isbroad,
+ double positionAlongStrip);
+
+ /**Assignment operator*/
+ FaserSCT_ClusterOnTrack &operator=(const FaserSCT_ClusterOnTrack &) = default;
+ /**Default move assigment operator*/
+ FaserSCT_ClusterOnTrack &operator=(FaserSCT_ClusterOnTrack &&) = default;
+
+ /** Destructor */
+ virtual ~FaserSCT_ClusterOnTrack() = default;
+
+ /** Pseudo-constructor */
+ virtual FaserSCT_ClusterOnTrack* clone() const override final;
+
+ /** returns the surface for the local to global transformation
+ - fullfills the Trk::MeasurementBase interface
+ */
+ virtual const Trk::Surface& associatedSurface() const override final;
+
+ virtual bool rioType(Trk::RIO_OnTrackType::Type type) const override final
+ {
+ return (type == Trk::RIO_OnTrackType::SCTCluster);
+ }
+
+
+ /** returns the PrepRawData - is a SCT_Cluster in this scope
+ - fullfills the Trk::RIO_OnTrack interface
+ */
+ virtual const Tracker::FaserSCT_Cluster* prepRawData() const override final;
+
+ const ElementLinkToTrackerCFaserSCT_ClusterContainer& prepRawDataLink() const;
+
+
+ /** returns the detector element, assoicated with the PRD of this class
+ - fullfills the Trk::RIO_OnTrack interface
+ */
+ virtual const TrackerDD::SiDetectorElement* detectorElement() const override final;
+
+ /**returns some information about this RIO_OnTrack.*/
+ virtual MsgStream& dump( MsgStream& out ) const override final;
+
+ /**returns some information about this RIO_OnTrack.*/
+ virtual std::ostream& dump( std::ostream& out ) const override final;
+
+ double positionAlongStrip() const;
+
+ private:
+ /** ONLY for use in custom convertor
+ Allows the custom convertor to reset values when persistying/reading
+ back RoTs*/
+ virtual void setValues(const Trk::TrkDetElementBase* detEl,
+ const Trk::PrepRawData* prd) override final;
+
+ /** SCT_Cluster - the RIO (PRD, PrepRawData)*/
+ ElementLinkToTrackerCFaserSCT_ClusterContainer m_rio;
+ /** corresponding detector element*/
+ const TrackerDD::SiDetectorElement* m_detEl;
+
+ double m_positionAlongStrip;
+ };
+
+ inline FaserSCT_ClusterOnTrack* FaserSCT_ClusterOnTrack::clone() const
+ {
+ return new FaserSCT_ClusterOnTrack(*this);
+ }
+
+ inline const FaserSCT_Cluster* FaserSCT_ClusterOnTrack::prepRawData() const
+ {
+ // somehow one has to ask first if it is valid ... otherwise it always returns 0 ...
+ if (m_rio.isValid()) return m_rio.cachedElement();
+ else return 0;
+ }
+
+ inline const ElementLinkToTrackerCFaserSCT_ClusterContainer&
+ FaserSCT_ClusterOnTrack::prepRawDataLink() const
+ {
+ return m_rio;
+ }
+
+ inline const TrackerDD::SiDetectorElement* FaserSCT_ClusterOnTrack::detectorElement() const
+ {
+ return m_detEl;
+ }
+
+ inline double FaserSCT_ClusterOnTrack::positionAlongStrip() const
+ {
+ return m_positionAlongStrip;
+ }
+
+
+}//end of namespace definitions
+
+#endif // TRACKERRIO_ONTRACK_FASERSCTCLUSTERONTRACK_H
diff --git a/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/SiClusterOnTrack.h b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/SiClusterOnTrack.h
new file mode 100644
index 0000000000000000000000000000000000000000..33f5a155d48ec786c60cc75978cdfc6d29221c96
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/SiClusterOnTrack.h
@@ -0,0 +1,120 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS and FASER collaborations
+*/
+
+///////////////////////////////////////////////////////////////////
+// SiClusterOnTrack.h, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERRIO_ONTRACK_SICLUSTERONTRACK_H
+#define TRACKERRIO_ONTRACK_SICLUSTERONTRACK_H
+
+#include "TrkRIO_OnTrack/RIO_OnTrack.h"
+#include "Identifier/IdentifierHash.h"
+
+class SiClusterOnTrackCnv_p1;
+
+namespace Trk
+{
+ class LocalParameters;
+}
+
+namespace TrackerDD
+{
+ class SiDetectorElement;
+}
+
+namespace Tracker {
+
+ class SiCluster;
+
+ /**@class SiClusterOnTrack
+ RIO_OnTrack base class for Silicon detector.
+
+ @author Veronique.Boisvert@cern.ch, Edward.Moyse@cern.ch, Andreas.Salzburger@cern.ch, dcasper@uci.edu
+ */
+ class SiClusterOnTrack : public Trk::RIO_OnTrack{
+
+
+ public:
+ /** Default Constructor - needed for POOL */
+ SiClusterOnTrack();
+ /** Copy constructor */
+ SiClusterOnTrack(const SiClusterOnTrack &);
+ /** Assignment operator */
+ SiClusterOnTrack &operator=(const SiClusterOnTrack &);
+
+
+ /** Constructor with parameters :
+ LocalParameters&,
+ ErrorMatrix&,
+ idDE& */
+ SiClusterOnTrack(const Trk::LocalParameters& locpos,
+ const Amg::MatrixX& locerr,
+ const IdentifierHash& idDE,
+ const Identifier& id,
+ bool isbroad=false);
+
+ /** Constructor with parameters :
+ LocalParameters&,
+ ErrorMatrix&,
+ idDE&,
+ GlobalPosition&,
+ */
+ SiClusterOnTrack( const Trk::LocalParameters& locpos,
+ const Amg::MatrixX& locerr,
+ const IdentifierHash& idDE,
+ const Identifier& id,
+ const Amg::Vector3D& globalPosition,
+ bool isbroad=false);
+
+ /** Destructor:*/
+ virtual ~SiClusterOnTrack();
+
+ /** returns global position (gathered through Surface constraint)
+ - fullfills Trk::MeasurementBase interface */
+ virtual const Amg::Vector3D& globalPosition() const override;
+
+ virtual bool rioType(Trk::RIO_OnTrackType::Type type) const override = 0;
+
+ /** returns the DE hashID*
+ - fullfills Trk::RIO_OnTrack interface*/
+ virtual IdentifierHash idDE() const override;
+
+ bool isBroadCluster() const;
+
+ /**returns some information about this RIO_OnTrack.
+ - fullfills Trk::RIO_OnTrack interface*/
+ virtual MsgStream& dump( MsgStream& out ) const override;
+
+ /**returns some information about this RIO_OnTrack.
+ - fullfills Trk::RIO_OnTrack interface*/
+ virtual std::ostream& dump( std::ostream& out ) const override;
+
+ protected:
+ friend class ::SiClusterOnTrackCnv_p1;
+
+ /** ONLY for use in custom convertor
+ Allows the custom convertor to reset values when persistying/reading back RoTs*/
+ virtual void setValues(const Trk::TrkDetElementBase* detEl,
+ const Trk::PrepRawData* prd) override = 0;
+
+ /** The IdentifierHash - probably not used*/
+ IdentifierHash m_idDE;
+ /** The global position */
+ Amg::Vector3D m_globalPosition;
+ bool m_isbroad;
+ };
+
+ inline IdentifierHash SiClusterOnTrack::idDE() const
+ {
+ return m_idDE;
+ }
+
+ inline bool SiClusterOnTrack::isBroadCluster() const
+ {
+ return m_isbroad;
+ }
+}
+
+#endif // TRACKERRIO_ONTRACK_SICLUSTERONTRACK_H
diff --git a/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/TrackerRIO_OnTrackDict.h b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/TrackerRIO_OnTrackDict.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b7df2fb3f2296cf276a7722db113845ce4f0ad0
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/TrackerRIO_OnTrackDict.h
@@ -0,0 +1,10 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS and FASER collaborations
+*/
+
+#ifndef TRACKERRIOONTRACKDICT_H
+#define TRACKERRIOONTRACKDICT_H
+
+#include "TrackerRIO_OnTrack/SiClusterOnTrack.h"
+#include "TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack.h"
+#endif
diff --git a/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/selection.xml b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/selection.xml
new file mode 100644
index 0000000000000000000000000000000000000000..71aa358ae226df01f3ca69bb48f74a29b45caa81
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/TrackerRIO_OnTrack/selection.xml
@@ -0,0 +1,10 @@
+<lcgdict>
+ <class name="Tracker::SiClusterOnTrack" >
+ <field name="m_globalPosition" transient="true" />
+ </class>
+ <class name="Tracker::FaserSCT_ClusterOnTrack" >
+ <field name="m_detEl" transient="true" />
+ <field name="m_rio" transient="true" />
+ </class>
+ <class name="TrackerDD::SiDetectorElement" />
+ </lcgdict>
diff --git a/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/src/FaserSCT_ClusterOnTrack.cxx b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/src/FaserSCT_ClusterOnTrack.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..7964343741c0dadc9818b4792a8d17e56fe04d33
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/src/FaserSCT_ClusterOnTrack.cxx
@@ -0,0 +1,111 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS and FASER collaborations
+*/
+
+///////////////////////////////////////////////////////////////////
+// FaserSCT_ClusterOnTrack.cxx, (c) ATLAS Detector Software
+///////////////////////////////////////////////////////////////////
+
+#include "TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack.h"
+#include "TrackerReadoutGeometry/SiDetectorElement.h"
+#include "TrackerPrepRawData/FaserSCT_Cluster.h"
+
+#include "GaudiKernel/MsgStream.h"
+#include <ostream>
+#include <limits>
+
+
+// Constructor with parameters - no global position assigned
+Tracker::FaserSCT_ClusterOnTrack::FaserSCT_ClusterOnTrack(const Tracker::FaserSCT_Cluster* RIO,
+ const Trk::LocalParameters& locpars,
+ const Amg::MatrixX& locerr,
+ const IdentifierHash& idDE,
+ bool isbroad) :
+ SiClusterOnTrack(locpars, locerr, idDE, RIO->identify(),isbroad) //call base class constructor
+{
+ m_detEl=RIO->detectorElement();
+ m_positionAlongStrip=std::numeric_limits<double>::quiet_NaN();
+ m_rio.setElement(RIO);
+
+ // Set global position
+ Amg::Vector2D lpos(localParameters().get(Trk::locX), m_positionAlongStrip);
+ m_globalPosition = detectorElement()->surface(identify()).localToGlobalPos(lpos);
+}
+
+// Constructor with parameters
+Tracker::FaserSCT_ClusterOnTrack::FaserSCT_ClusterOnTrack(const Tracker::FaserSCT_Cluster* RIO,
+ const Trk::LocalParameters& locpars,
+ const Amg::MatrixX& locerr,
+ const IdentifierHash& idDE,
+ const Amg::Vector3D& globalPosition,
+ bool isbroad) :
+ SiClusterOnTrack(locpars, locerr, idDE, RIO->identify(), globalPosition, isbroad), //call base class constructor
+ m_detEl( RIO->detectorElement() )
+{
+ m_rio.setElement(RIO);
+
+ //constructing local position provided a global one
+ std::unique_ptr<const Amg::Vector2D>
+ lpos{detectorElement()->surface( identify() ).positionOnSurface(globalPosition)};
+
+ //storing the position along the strip if available
+ m_positionAlongStrip = (lpos) ? (*lpos)[Trk::locY]:0.;
+
+}
+
+Tracker::FaserSCT_ClusterOnTrack::FaserSCT_ClusterOnTrack( const ElementLinkToTrackerCFaserSCT_ClusterContainer& RIO,
+ const Trk::LocalParameters& locpars,
+ const Amg::MatrixX& locerr,
+ IdentifierHash idDE,
+ const Identifier& id,
+ bool isbroad,
+ double positionAlongStrip)
+ : SiClusterOnTrack(locpars,
+ locerr,
+ idDE,
+ id,
+ isbroad),
+ m_rio(RIO),
+ m_detEl(nullptr),
+ m_positionAlongStrip (positionAlongStrip)
+{
+}
+
+
+// Default constructor:
+Tracker::FaserSCT_ClusterOnTrack::FaserSCT_ClusterOnTrack():
+ SiClusterOnTrack(),
+ m_rio(),
+ m_detEl(nullptr),
+ m_positionAlongStrip(std::numeric_limits<double>::quiet_NaN())
+{}
+
+
+const Trk::Surface& Tracker::FaserSCT_ClusterOnTrack::associatedSurface() const
+{
+ return ( detectorElement()->surface());
+}
+
+void Tracker::FaserSCT_ClusterOnTrack::setValues(const Trk::TrkDetElementBase* detEl, const Trk::PrepRawData* )
+{
+ m_detEl = dynamic_cast< const TrackerDD::SiDetectorElement* >(detEl);
+ if (m_detEl) {
+ // Set global position after setting the detector element
+ Amg::Vector2D lpos(localParameters().get(Trk::locX),
+ m_positionAlongStrip);
+ m_globalPosition =
+ detectorElement()->surface(identify()).localToGlobalPos(lpos);
+ }
+}
+
+MsgStream& Tracker::FaserSCT_ClusterOnTrack::dump( MsgStream& sl ) const
+{
+ SiClusterOnTrack::dump(sl);// use dump(...) from SiClusterOnTrack
+ return sl;
+}
+
+std::ostream& Tracker::FaserSCT_ClusterOnTrack::dump( std::ostream& sl ) const
+{
+ SiClusterOnTrack::dump(sl);// use dump(...) from SiClusterOnTrack
+ return sl;
+}
diff --git a/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/src/SiClusterOnTrack.cxx b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/src/SiClusterOnTrack.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..f11a1f8efc91dda6698b121b98211276bb1ea8c1
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerRIO_OnTrack/src/SiClusterOnTrack.cxx
@@ -0,0 +1,121 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS and FASER collaborations
+*/
+
+///////////////////////////////////////////////////////////////////
+// SiClusterOnTrack.cxx, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+
+#include "TrackerRIO_OnTrack/SiClusterOnTrack.h"
+#include "TrkRIO_OnTrack/RIO_OnTrack.h"
+#include "TrkEventPrimitives/LocalParameters.h"
+#include "TrkSurfaces/Surface.h"
+#include "TrackerPrepRawData/TrackerCluster.h"
+#include "GaudiKernel/MsgStream.h"
+#include <memory>
+#include <new>
+#include <ostream>
+#include <typeinfo>
+
+
+// Constructor with parameters - global position not specified here
+Tracker::SiClusterOnTrack::SiClusterOnTrack( const Trk::LocalParameters& locpars,
+ const Amg::MatrixX& locerr,
+ const IdentifierHash& idDE,
+ const Identifier& id,
+ bool isbroad) :
+ RIO_OnTrack(locpars, locerr, id), //call base class constructor
+ m_idDE(idDE),
+ m_globalPosition(), // should be set in constructor of derived class
+ m_isbroad(isbroad)
+{}
+
+// Constructor with parameters - global position specified
+Tracker::SiClusterOnTrack::SiClusterOnTrack( const Trk::LocalParameters& locpars,
+ const Amg::MatrixX& locerr,
+ const IdentifierHash& idDE,
+ const Identifier& id,
+ const Amg::Vector3D& globalPosition,
+ bool isbroad)
+ :
+ RIO_OnTrack(locpars, locerr, id), //call base class constructor
+ m_idDE(idDE),
+ m_globalPosition(globalPosition),
+ m_isbroad(isbroad)
+{}
+
+
+// Destructor:
+Tracker::SiClusterOnTrack::~SiClusterOnTrack()
+{
+}
+
+// Default constructor:
+Tracker::SiClusterOnTrack::SiClusterOnTrack():
+ Trk::RIO_OnTrack(),
+ m_idDE(),
+ m_globalPosition(), // should be set in constructor of derived class
+ m_isbroad(false)
+{}
+
+// copy constructor:
+Tracker::SiClusterOnTrack::SiClusterOnTrack( const SiClusterOnTrack& rot)
+ :
+ RIO_OnTrack(rot),
+ m_idDE(rot.m_idDE),
+ m_globalPosition(rot.m_globalPosition),
+ m_isbroad(rot.m_isbroad)
+{}
+
+// assignment operator:
+Tracker::SiClusterOnTrack& Tracker::SiClusterOnTrack::operator=( const SiClusterOnTrack& rot){
+ if ( &rot != this) {
+ Trk::RIO_OnTrack::operator=(rot);
+ m_idDE = rot.m_idDE;
+ m_globalPosition = rot.m_globalPosition;
+ m_isbroad = rot.m_isbroad;
+ }
+ return *this;
+}
+
+
+
+
+const Amg::Vector3D& Tracker::SiClusterOnTrack::globalPosition() const
+{
+ return m_globalPosition;
+}
+
+MsgStream& Tracker::SiClusterOnTrack::dump( MsgStream& sl ) const
+{
+
+ sl << "SiClusterOnTrack {" << endmsg;
+ Trk::RIO_OnTrack::dump(sl);
+
+ sl << "Global position (x,y,z) = (";
+ sl <<this->globalPosition().x()<<", "
+ <<this->globalPosition().y()<<", "
+ <<this->globalPosition().z()<<")"<<endmsg;
+ sl<<"}"<<endmsg;
+ return sl;
+}
+
+std::ostream& Tracker::SiClusterOnTrack::dump( std::ostream& sl ) const
+{
+ sl << "SiClusterOnTrack {"<<std::endl;
+
+ Trk::RIO_OnTrack::dump(sl);
+
+ sl << "Global position (x,y,z) = (";
+ sl <<this->globalPosition().x()<<", "
+ <<this->globalPosition().y()<<", "
+ <<this->globalPosition().z()<<")"<<std::endl;
+ sl<<"}"<<std::endl;
+ return sl;
+}
+
+
+
+
+
+
diff --git a/Tracking/TrkEventCnv/TrkEventAthenaPool/CMakeLists.txt b/Tracking/TrkEventCnv/TrkEventAthenaPool/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..862d3d9b4320d7803028ba06c248c437c22c1a19
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventAthenaPool/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+
+# Declare the package name:
+atlas_subdir( TrkEventAthenaPool )
+
+# Component(s) in the package:
+atlas_add_poolcnv_library( TrkEventAthenaPoolPoolCnv
+ src/*.h src/*.cxx
+ FILES TrkSpacePoint/SpacePointCollection.h
+ TrkSpacePoint/SpacePointContainer.h TrkTrack/TrackCollection.h
+ LINK_LIBRARIES TrkSpacePoint TrkEventTopLevelCnv TrkEventTPCnv )
+
+# Install files from the package:
+# atlas_install_joboptions( share/*.py )
diff --git a/Tracking/TrkEventCnv/TrkEventAthenaPool/src/TrackCollectionCnv.cxx b/Tracking/TrkEventCnv/TrkEventAthenaPool/src/TrackCollectionCnv.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..828854f3bf42fe6661fc1e2a047cbe579b9c86c6
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventAthenaPool/src/TrackCollectionCnv.cxx
@@ -0,0 +1,141 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+//-----------------------------------------------------------------------------
+//
+// file: TrackCollectionCnv.cxx
+// author: Lukasz Janyst <ljanyst@cern.ch>
+//
+// Ed's converter rewritten and T/P split stuff added
+//
+// TODO: MultiComponentTSoS, integrity checking
+//
+//-----------------------------------------------------------------------------
+#include "TrackCollectionCnv.h"
+
+#include "GaudiKernel/IToolSvc.h"
+#include "StoreGate/StoreGateSvc.h"
+// #include "AtlasDetDescr/AtlasDetectorID.h"
+
+
+//-----------------------------------------------------------------------------
+// Constructor
+//-----------------------------------------------------------------------------
+TrackCollectionCnv::TrackCollectionCnv(ISvcLocator* svcloc):
+ TrackCollectionCnvBase(svcloc),
+ m_msgSvc( msgSvc() ),
+ m_log( m_msgSvc, "TrackCollectionCnv" )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Initializer
+//-----------------------------------------------------------------------------
+StatusCode TrackCollectionCnv::initialize()
+{
+ // leaving empty method for future use
+ return TrackCollectionCnvBase::initialize();
+}
+
+
+// void TrackCollectionCnv::initializeOldExtConverters()
+// {
+// if( m_oldExtCnvInitialized ) return;
+
+// // m_log.setLevel( m_msgSvc->outputLevel() );
+// m_log << MSG::INFO << "TrackCollectionCnv::initializeOldExtConverters()" << endmsg;
+
+// bool doInDet(true);
+// bool doMuon(true);
+// bool doCalo(true);
+
+// IConverter *converter = m_athenaPoolCnvSvc->converter( CLID(17001567) );
+// if(converter != 0) registerExtendingCnv( converter );
+// else doInDet=false;
+
+// converter = m_athenaPoolCnvSvc->converter( CLID(239128586) );
+// if(converter !=0 ) registerExtendingCnv( converter );
+// else doMuon=false;
+
+// converter = m_athenaPoolCnvSvc->converter( CLID(1213853277) );
+// if(converter !=0 ) registerExtendingCnv( converter );
+// else doCalo=false;
+
+// //-------------------------------------------------------------------------
+// // We cannot proceed if none of the tools is present
+// //-------------------------------------------------------------------------
+// if( !doInDet && !doMuon && !doCalo) {
+// m_log << MSG::WARNING << "Could not get any of the extending convertors, and so might have problems later on.";
+// m_log << endmsg;
+// }
+// m_oldExtCnvInitialized = true;
+// }
+
+
+
+TrackCollection_PERS * TrackCollectionCnv::createPersistentWithKey( TrackCollection *transCont,
+ const std::string& key)
+{
+ std::string logname = "TrackCollectionCnv";
+ if (const DataObject* dObj = getDataObject()) {
+ logname += dObj->name();
+ }
+
+ MsgStream log (m_msgSvc, logname );
+
+ return m_TPConverter.createPersistentWithKey ( transCont, key, log );
+}
+
+//-----------------------------------------------------------------------------
+// Create transient collection
+//-----------------------------------------------------------------------------
+TrackCollection *TrackCollectionCnv::createTransientWithKey(const std::string& key)
+{
+ m_log.setLevel( m_msgSvc->outputLevel() );
+ static const pool::Guid p6_guid( "3228B252-2C5D-11E8-B170-0800271C02BC" );
+ // static const pool::Guid p5_guid( "436E4996-9D6E-11E3-AD2A-6C3BE51AB9F1" );
+ // static const pool::Guid p4_guid( "3BEB819F-6ED2-48F6-9F95-E65E1759E781" );
+ // static const pool::Guid p3_guid( "A1E9FDCB-2F4A-4AC8-BF4E-2D70B9C70F8A" );
+ // static const pool::Guid p2_guid( "2D8B19DC-DB2E-4F56-BB94-D7C4544D501A" );
+ // static const pool::Guid p1_guid( "ECB12567-B999-4908-B0C6-C43CF9F9A987" );
+ // static const pool::Guid p0_guid( "70ECEBFC-BE00-46C2-8B35-4CC12D18DE39" );
+
+ TrackCollection *p_collection = 0;
+ if( compareClassGuid( p6_guid )){
+ poolReadObject< TrackCollection_PERS >( m_TPConverter );
+ p_collection = m_TPConverter.createTransientWithKey( key, m_log );
+ }
+ // else if( compareClassGuid( p5_guid )){
+ // initializeOldExtConverters();
+ // poolReadObject< Trk::TrackCollection_tlp5 >( m_TPConverter_tlp5);
+ // p_collection = m_TPConverter_tlp5.createTransientWithKey( key, m_log );
+ // }
+ // else if( compareClassGuid( p4_guid )){
+ // initializeOldExtConverters();
+ // poolReadObject< Trk::TrackCollection_tlp4 >( m_TPConverter_tlp4);
+ // p_collection = m_TPConverter_tlp4.createTransientWithKey( key, m_log );
+ // }
+ // else if( compareClassGuid( p3_guid )){
+ // initializeOldExtConverters();
+ // poolReadObject< Trk::TrackCollection_tlp3 >( m_TPConverter_tlp3);
+ // p_collection = m_TPConverter_tlp3.createTransientWithKey( key, m_log );
+ // }
+ // else if( compareClassGuid( p2_guid ) ) {
+ // initializeOldExtConverters();
+ // poolReadObject< Trk::TrackCollection_tlp2 >( m_TPConverter_tlp2 );
+ // p_collection = m_TPConverter_tlp2.createTransientWithKey( key, m_log );
+ // }
+ // else if( compareClassGuid( p1_guid ) ) {
+ // initializeOldExtConverters();
+ // poolReadObject< Trk::TrackCollection_tlp1 >( m_TPConverter_tlp1 );
+ // p_collection = m_TPConverter_tlp1.createTransientWithKey( key, m_log );
+ // }
+ // else if( compareClassGuid( p0_guid ) ) {
+ // p_collection = poolReadObject< TrackCollection >();
+ // }
+ else
+ throw std::runtime_error( "Unsupported persistent version of Data Collection" );
+ return p_collection;
+}
+
diff --git a/Tracking/TrkEventCnv/TrkEventAthenaPool/src/TrackCollectionCnv.h b/Tracking/TrkEventCnv/TrkEventAthenaPool/src/TrackCollectionCnv.h
new file mode 100644
index 0000000000000000000000000000000000000000..b6ca22eaddb40d2bc9d01caf71b8f1908cb54648
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventAthenaPool/src/TrackCollectionCnv.h
@@ -0,0 +1,77 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+//-----------------------------------------------------------------------------
+//
+// file: TrackCollectionCnv.h
+// author: Lukasz Janyst <ljanyst@cern.ch>
+//
+//-----------------------------------------------------------------------------
+
+#ifndef TRKEVENTATHENAPOOL_TRACKCOLLECTIONCNV_H
+#define TRKEVENTATHENAPOOL_TRACKCOLLECTIONCNV_H
+
+#include "GaudiKernel/MsgStream.h"
+
+#include "TrkEventCnvTools/ITrkEventCnvTool.h"
+#include "FaserDetDescr/FaserDetectorID.h"
+
+#include "AthenaPoolCnvSvc/T_AthenaPoolCustomCnv.h"
+#include "AthenaPoolCnvSvc/AthenaPoolCnvTPExtension.h"
+
+#include "TrkTrack/TrackCollection.h"
+
+// #include "TrkEventTPCnv/TrackCollectionCnv_tlp1.h"
+// #include "TrkEventTPCnv/TrackCollectionCnv_tlp2.h"
+// #include "TrkEventTPCnv/TrackCollectionCnv_tlp3.h"
+// #include "TrkEventTPCnv/TrackCollectionCnv_tlp4.h"
+// #include "TrkEventTPCnv/TrackCollectionCnv_tlp5.h"
+#include "TrkEventTopLevelCnv/TrackCollectionCnv_tlp6.h"
+
+//-----------------------------------------------------------------------------
+// Base class definition - defined which is the to-be-used persistent version
+//-----------------------------------------------------------------------------
+
+typedef Trk::TrackCollection_tlp6 TrackCollection_PERS;
+
+typedef T_AthenaPoolCustomCnvWithKey<TrackCollection, TrackCollection_PERS> TrackCollectionCnvBase;
+
+//-----------------------------------------------------------------------------
+// Converter for TrackCollection object
+//-----------------------------------------------------------------------------
+class TrackCollectionCnv
+ : public TrackCollectionCnvBase,
+ public AthenaPoolCnvTPExtension
+{
+friend class CnvFactory<TrackCollectionCnv>;
+
+public:
+ TrackCollectionCnv( ISvcLocator *svcloc );
+
+protected:
+ virtual StatusCode initialize() override;
+
+ virtual TrackCollection_PERS *createPersistentWithKey( TrackCollection *transCont,
+ const std::string& key) override;
+ virtual TrackCollection *createTransientWithKey (const std::string& key) override;
+
+ virtual AthenaPoolTopLevelTPCnvBase* getTopLevelTPCnv() override { return & m_TPConverter; }
+
+
+private:
+// void initializeOldExtConverters(); //!< setup old extended converters when reading old data
+
+ IMessageSvc* m_msgSvc;
+ MsgStream m_log;
+// bool m_oldExtCnvInitialized = false;
+
+// TrackCollectionCnv_tlp1 m_TPConverter_tlp1;
+// TrackCollectionCnv_tlp2 m_TPConverter_tlp2;
+// TrackCollectionCnv_tlp3 m_TPConverter_tlp3;
+// TrackCollectionCnv_tlp4 m_TPConverter_tlp4;
+// TrackCollectionCnv_tlp5 m_TPConverter_tlp5;
+ TrackCollectionCnv_tlp6 m_TPConverter; // <- the current one
+};
+
+#endif // TRKEVENTATHENAPOOL_TRACKCOLLECTIONCNV_H
diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/CMakeLists.txt b/Tracking/TrkEventCnv/TrkEventCnvTools/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..56f1041de0f224b514c48eb46341a85b773c81fc
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventCnvTools/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+
+# Declare the package name:
+atlas_subdir( TrkEventCnvTools )
+
+atlas_add_library( TrkEventCnvToolsLib
+ TrkEventCnvTools/*.h
+ INTERFACE
+ PUBLIC_HEADERS TrkEventCnvTools
+ LINK_LIBRARIES TrkSurfaces TrkDetDescrUtils TrkParametersBase GeoPrimitives GaudiKernel AthenaBaseComps AthenaPoolUtilities AthLinks StoreGateLib Identifier TrkPrepRawData TrkRIO_OnTrack )
+
+# Component(s) in the package:
+atlas_add_component( TrkEventCnvTools
+ src/*.cxx
+ src/components/*.cxx
+ LINK_LIBRARIES AthenaBaseComps AthenaPoolUtilities FaserDetDescr GaudiKernel TrkEventCnvToolsLib TrkMeasurementBase TrkRIO_OnTrack TrkSurfaces )
+
+# Install files from the package:
+atlas_install_python_modules( python/*.py POST_BUILD_CMD ${ATLAS_FLAKE8} )
diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/ATLAS_CHECK_THREAD_SAFETY b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/ATLAS_CHECK_THREAD_SAFETY
new file mode 100644
index 0000000000000000000000000000000000000000..c57ea6eb810387a34ccabde5cdf48e8fa532f5ce
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/ATLAS_CHECK_THREAD_SAFETY
@@ -0,0 +1,3 @@
+
+Tracking/TrkEventCnv/TrkEventCnvTools
+
diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/DetElementSurface.h b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/DetElementSurface.h
new file mode 100644
index 0000000000000000000000000000000000000000..3f734e18539c905ba35dd824b3f61c18dfb0b42d
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/DetElementSurface.h
@@ -0,0 +1,111 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRKEVENTCNVTOOLS_DETELEMENTSURFACE_H
+#define TRKEVENTCNVTOOLS_DETELEMENTSURFACE_H
+#include "TrkSurfaces/Surface.h"
+#include "TrkDetDescrUtils/Intersection.h"
+#include "TrkSurfaces/RectangleBounds.h"
+#include "TrkSurfaces/DistanceSolution.h"
+#include "TrkParametersBase/ParametersBase.h"
+#include "GeoPrimitives/GeoPrimitives.h"
+#include <cstdlib>//for "abort"
+
+namespace Trk
+{
+
+/** Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
+Only intended for use within the persistency framework.*/
+// template <class SURFACE>
+// class DetElementSurface : public SURFACE
+// {
+// public:
+// DetElementSurface( const DetElementSurface& rhs) : SURFACE(rhs) {}
+// };
+
+
+template<int DIM, class T, class S> class ParametersT;
+
+class DetElementSurface : public Surface
+{
+ public:
+ DetElementSurface() : Surface() {}
+ DetElementSurface(Identifier id) : Surface(), m_id(id) {}
+ DetElementSurface( const Surface& rhs) : Surface(rhs), m_id(rhs.associatedDetectorElementIdentifier()) {}
+// Normally the Surface copy ctor sets the Identifier to be invalid. Store it, to get around this.
+ bool operator==(const Trk::Surface&) const { return false;}
+ Surface * clone () const { return nullptr; }
+ bool insideBounds(const Amg::Vector2D &, double, double) const {return false;}
+ bool insideBoundsCheck(const Amg::Vector2D& /*locpos*/, const BoundaryCheck& /*bchk*/) const { return false;}
+ const Amg::Vector3D * localToGlobal (const Amg::Vector2D &) const { return nullptr; }
+ const Amg::Vector3D * localToGlobal (const LocalParameters &) const { return nullptr; }
+ const Amg::Vector2D * globalToLocal (const Amg::Vector3D &, const double) const { return nullptr; }
+ virtual DistanceSolution straightLineDistanceEstimate (const Amg::Vector3D &, const Amg::Vector3D &) const { return DistanceSolution(); }
+ const SurfaceBounds & bounds () const { std::abort();/*should never be called*/ }
+ MsgStream & dump (MsgStream &sl) const { return sl;}
+ std::ostream & dump (std::ostream &sl) const { return sl;};
+ const Identifier associatedDetectorElementIdentifier() const {return m_id;}
+ bool isFree() {return true;}// To avoid memory leaks
+ Surface::SurfaceType type() const {return Surface::Other;}
+ void localToGlobal(const Amg::Vector2D&, const Amg::Vector3D&, Amg::Vector3D&) const {}
+ bool globalToLocal(const Amg::Vector3D&, const Amg::Vector3D&, Amg::Vector2D&) const {return false;}
+ std::string name() const { return "Trk::DetElementSurface";}
+ // A dummy method required for consistency of the package and
+ virtual std::unique_ptr<ParametersBase<5, Trk::Charged>>
+ createUniqueTrackParameters(double,
+ double,
+ double,
+ double,
+ double,
+ AmgSymMatrix(5) *) const
+ {
+ return nullptr;
+ }
+ virtual std::unique_ptr<ParametersBase<5, Trk::Charged>>
+ createUniqueTrackParameters(const Amg::Vector3D&,
+ const Amg::Vector3D&,
+ double,
+ AmgSymMatrix(5) *) const
+ {
+ return nullptr;
+ }
+
+ virtual std::unique_ptr<ParametersBase<5, Trk::Neutral>>
+ createUniqueNeutralParameters(double,
+ double,
+ double,
+ double,
+ double,
+ AmgSymMatrix(5) *) const
+ {
+ return nullptr;
+ }
+ virtual std::unique_ptr<ParametersBase<5, Trk::Neutral>>
+ createUniqueNeutralParameters(const Amg::Vector3D&,
+ const Amg::Vector3D&,
+ double,
+ AmgSymMatrix(5) *) const
+ {
+ return nullptr;
+ }
+
+ virtual Intersection straightLineIntersection(const Amg::Vector3D&,
+ const Amg::Vector3D&,
+ bool, Trk::BoundaryCheck) const { return Trk::Intersection(Amg::Vector3D(0.,0.,0.),0.,false); }
+
+
+// persistency libraries..
+ virtual Trk::DistanceSolution straightLineDistanceEstimate(const Amg::Vector3D&,
+ const Amg::Vector3D&, bool) const {return 0;}
+
+ virtual bool isOnSurface(const Amg::Vector3D&, Trk::BoundaryCheck, double, double) const {return false;}
+
+private:
+ Identifier m_id;
+};
+
+
+}
+
+#endif
diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/EventCnvSuperTool.h b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/EventCnvSuperTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..3c3255427e19b3b0afca17cecc26a573cdbe83b7
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/EventCnvSuperTool.h
@@ -0,0 +1,80 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRKEVENTCNVTOOLS_EVENTCNVSUPERTOOL
+#define TRKEVENTCNVTOOLS_EVENTCNVSUPERTOOL
+
+#include "TrkEventCnvTools/IEventCnvSuperTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "AthenaPoolUtilities/TPObjRef.h"
+
+#include <atomic>
+
+class Identifier;
+class FaserDetectorID;
+
+namespace Trk
+{
+ class ITrkEventCnvTool;
+ class Surface;
+ class RIO_OnTrack;
+
+ /** Tool to handle TP conversions for Tracking EDM.
+ This tool has sub tools that do the detector-specific conversions*/
+class EventCnvSuperTool : public extends<AthAlgTool, IEventCnvSuperTool>
+ {
+ public:
+
+ EventCnvSuperTool(const std::string& t,
+ const std::string& n,
+ const IInterface* p);
+
+ virtual ~EventCnvSuperTool ();
+
+ virtual StatusCode initialize() override;
+
+ virtual StatusCode finalize() override;
+
+ virtual const Trk::ITrkEventCnvTool* getCnvTool(const Identifier& id) const override;
+
+ /** From passed Identifier*/
+ virtual const Trk::Surface* getSurface(const Identifier& id) const override;
+
+ /** Take the passed RoT and recreate it (i.e. fill missing pointers etc)*/
+ virtual void recreateRIO_OnTrack( RIO_OnTrack *RoT ) const override;
+
+ /** Take the passed RoT and prepare the PRD ElementLink for writing to disc*/
+ virtual void prepareRIO_OnTrack( RIO_OnTrack* Rot) const override;
+
+ /** Take the passed RoT and return the EL components to write to disc */
+ virtual void prepareRIO_OnTrackLink( const RIO_OnTrack* Rot,
+ ELKey_t& key,
+ ELIndex_t& index ) const override;
+
+ // virtual bool canHandleInDet() const override { return m_haveIdCnvTool;}
+ // virtual bool canHandleMuonSpectrometer() const override { return m_haveMuonCnvTool;}
+ virtual int maxNumberOfErrors() const override { return m_maxErrCount;}
+
+ virtual bool noGeometry() const override {return !(m_haveTrackerCnvTool);}
+
+ private:
+ ToolHandle<Trk::ITrkEventCnvTool> m_trackerCnvTool {this, "TrackerCnvTool", "Tracker::TrackerEventCnvTool/TrackerEventCnvTool", "Tool used to handle Tracker RoTs etc"}; //!< Tool used to handle Tracker RoTs etc
+ // ToolHandle<Trk::ITrkEventCnvTool> m_idCnvTool {this, "IdCnvTool", "InDet::InDetEventCnvTool/InDetEventCnvTool", "Tool used to handle ID RoTs etc"}; //!< Tool used to handle ID RoTs etc
+ // ToolHandle<Trk::ITrkEventCnvTool> m_muonCnvTool {this, "MuonCnvTool", "Muon::MuonEventCnvTool/MuonEventCnvTool", "Tool used to handle Muon RoTs etc"}; //!< Tool used to handle Muon RoTs etc
+ const FaserDetectorID* m_detID; // atlas id helper
+
+ bool m_haveTrackerCnvTool;
+ // bool m_haveIdCnvTool; //!< Flag set in intialise, letting us know whether the tool has been found.
+ // bool m_haveMuonCnvTool; //!< Flag set in intialise, letting us know whether the tool has been found.
+
+ // bool m_doMuons; //!< Property deciding whether to attempt Muon conversions
+ // bool m_doID; //!< Property deciding whether to attempt ID conversions
+
+ mutable std::atomic_int m_errCount; //!< Current number of ERROR/WARNING messages sent to output
+ int m_maxErrCount; //!< Maximum number of permissable ERROR/WARNING messages sent to output.
+ };
+ }
+#endif
+
diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/IEventCnvSuperTool.h b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/IEventCnvSuperTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..263186464f37b07ecffae111db6c077bfd386e0a
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/IEventCnvSuperTool.h
@@ -0,0 +1,74 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRKEVENTCNVTOOLS_IEVENTCNVSUPERTOOL
+#define TRKEVENTCNVTOOLS_IEVENTCNVSUPERTOOL
+
+#include "GaudiKernel/IAlgTool.h"
+
+#include "AthLinks/ElementLink.h"
+#include "StoreGate/ReadHandleKey.h"
+
+class Identifier;
+class AtlasDetectorID;
+class TPObjRef;
+
+namespace Trk
+{
+ class ITrkEventCnvTool;
+ class Surface;
+ class RIO_OnTrack;
+
+ static const InterfaceID IID_IIEventCnvSuperTool("Trk::IEventCnvSuperTool", 1, 0);
+
+ class IEventCnvSuperTool : virtual public IAlgTool
+ {
+ public:
+ /// Key and index types used for an EL to IdentifiableContainer.
+ typedef std::string ELKey_t;
+ typedef unsigned int ELIndex_t;
+
+ DeclareInterfaceID( IEventCnvSuperTool, 1, 0 );
+
+ IEventCnvSuperTool() {};
+
+ virtual const Trk::ITrkEventCnvTool* getCnvTool(const Identifier& id) const =0;
+
+ /** From passed Identifier*/
+ virtual const Trk::Surface* getSurface(const Identifier& id) const =0;
+
+ /** Take the passed RoT and recreate it (i.e. fill missing pointers etc)*/
+ virtual void recreateRIO_OnTrack( RIO_OnTrack *RoT ) const =0;
+
+ /** Take the passed RoT and prepare the PRD ElementLink for writing to disc*/
+ virtual void prepareRIO_OnTrack( RIO_OnTrack* Rot) const = 0;
+
+ /** Take the passed RoT and return the EL components to write to disc */
+ virtual void prepareRIO_OnTrackLink( const RIO_OnTrack* Rot,
+ ELKey_t& key,
+ ELIndex_t& index ) const = 0;
+
+ /**This templated method will return the hashAndIndex of the passed RIO_OnTrack.*/
+ template <class CONT, class ROT> bool getHashAndIndex(const ROT* rot,
+ const SG::ReadHandleKey<CONT>& contName,
+ typename ElementLink<CONT>::index_type& hashAndIndex) const;
+
+ /** returns false if e.g. no ID geometry available*/
+ // virtual bool canHandleInDet() const =0;
+
+ /** returns false if e.g. no Muon geometry available*/
+ // virtual bool canHandleMuonSpectrometer() const =0;
+
+ /** returns true if e.g. no Muon+ID geometry available*/
+ virtual bool noGeometry() const =0;
+
+ /** Maximum number of permitted errors. */
+ virtual int maxNumberOfErrors() const =0;
+
+ };
+}
+
+#include "TrkEventCnvTools/IEventCnvSuperTool.icc"
+
+#endif
diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/IEventCnvSuperTool.icc b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/IEventCnvSuperTool.icc
new file mode 100644
index 0000000000000000000000000000000000000000..76f9b3c261b6d35f55ac63640feb507ffb3724de
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/IEventCnvSuperTool.icc
@@ -0,0 +1,14 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrkEventCnvTools/ITrkEventCnvTool.h"
+
+template <class CONT, class ROT>
+bool Trk::IEventCnvSuperTool::getHashAndIndex(const ROT* rot,
+ const SG::ReadHandleKey<CONT>& contName,
+ typename ElementLink<CONT>::index_type& hashAndIndex) const {
+ const Trk::ITrkEventCnvTool* cnvTool{getCnvTool(rot->identify())};
+ if (cnvTool!=nullptr) return cnvTool->getHashAndIndex<CONT, ROT>(rot, contName, hashAndIndex);
+ return false;
+}
diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/ITrkEventCnvTool.h b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/ITrkEventCnvTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..981d2e743539604815e1e2d72276ff27a0de065f
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/ITrkEventCnvTool.h
@@ -0,0 +1,106 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRKEVENTCNVTOOLS_ITRKEVENTCNVTOOL
+#define TRKEVENTCNVTOOLS_ITRKEVENTCNVTOOL
+
+
+#include "GaudiKernel/IAlgTool.h"
+
+#include "AthLinks/ElementLink.h"
+#include "StoreGate/StoreGateSvc.h"
+#include "StoreGate/ReadHandleKey.h"
+
+#include "GaudiKernel/ServiceHandle.h"
+#include "GaudiKernel/IMessageSvc.h"
+#include "GaudiKernel/MsgStream.h"
+
+class Identifier;
+class IdentifierHash;
+
+namespace Trk
+{
+
+class TrkDetElementBase;
+class PrepRawData;
+class RIO_OnTrack;
+
+
+class ITrkEventCnvTool : virtual public IAlgTool
+ {
+ public:
+ /// Key and index types used for an EL to IdentifiableContainer.
+ typedef std::string ELKey_t;
+ typedef unsigned int ELIndex_t;
+
+ DeclareInterfaceID( ITrkEventCnvTool, 1, 0 );
+
+
+ ITrkEventCnvTool():
+ m_storeGate ( "StoreGateSvc", "ITrkEventCnvTool" ),
+ m_msgSvc ( "MessageSvc", "ITrkEventCnvTool" )
+ {
+// m_log(&(*m_msgSvc), name() );
+ }
+
+ /** check the passed RIO_OnTrack to make sure it is correctly filled*/
+ virtual void checkRoT( const Trk::RIO_OnTrack& rioOnTrack ) const =0;
+
+ /**This method must use the passed RIO_OnTrack to recover pointers
+ The PrepRawData pointer will only be filled if the concrete tools are so set
+ @return this is a pair, where the (possibly null) pointers contained represent the missing links from rioOnTrack*
+ @param[in] rioOnTrack the RIO_OnTrack which needs recreating. MUST point to a valid object.*/
+ virtual std::pair<const Trk::TrkDetElementBase*, const Trk::PrepRawData*>
+ getLinks( Trk::RIO_OnTrack& rioOnTrack ) const = 0;
+
+ /**This templated method will set the EL for the passed RIO_OnTrack.*/
+ template <class CONT, class ROT> void prepareRIO_OnTrackElementLink(ROT* rot) const;
+
+ /**This templated method will find EL components for the passed RIO_OnTrack.*/
+ template <class CONT, class ROT>
+ void prepareRIO_OnTrackElementLink(const ROT* rot,
+ ELKey_t& key,
+ ELIndex_t& index) const;
+
+ /**This templated method will return the hashAndIndex of the passed RIO_OnTrack.*/
+ template <class CONT, class ROT> bool getHashAndIndex(const ROT* rot,
+ const SG::ReadHandleKey<CONT>& contName,
+ typename ElementLink<CONT>::index_type& hashAndIndex) const;
+
+ /** Take the passed RoT and prepare the PRD ElementLink for writing to disk.
+ The procedure should be:
+ - Get DataHandles to all IDC containers in the event
+ - See if collection storing the linked PRD is part of the container
+ - If so, check that the pointer of the PRD matches that in the container
+ - Then set strings and index.
+ - If any of the above failed, try the next container.*/
+ virtual void prepareRIO_OnTrack( Trk::RIO_OnTrack* rot) const =0;
+
+ /** Similar, but just return the EL components rather then
+ changing ROT. */
+ virtual void prepareRIO_OnTrackLink( const Trk::RIO_OnTrack* rot,
+ ELKey_t& key,
+ ELIndex_t& index ) const =0;
+
+ /** Take the passed RoT and recreate it (i.e. fill missing pointers etc)*/
+ virtual void recreateRIO_OnTrack( Trk::RIO_OnTrack *RoT ) const =0;
+
+ /** Returns the detectorElement associated with this Identifier & Hash*/
+ virtual const Trk::TrkDetElementBase* getDetectorElement(const Identifier& id, const IdentifierHash& idHash) const =0;
+
+ /** Returns the detectorElement associated with this Identifier*/
+ virtual const Trk::TrkDetElementBase* getDetectorElement(const Identifier& id) const =0;
+
+ virtual void setRoT_Values(std::pair<const Trk::TrkDetElementBase *, const Trk::PrepRawData *>& pair, Trk::RIO_OnTrack *RoT ) const;
+
+ private:
+ ServiceHandle<StoreGateSvc> m_storeGate;
+ ServiceHandle<IMessageSvc> m_msgSvc;
+};
+}
+
+#include "TrkEventCnvTools/ITrkEventCnvTool.icc"
+
+#endif
+
diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/ITrkEventCnvTool.icc b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/ITrkEventCnvTool.icc
new file mode 100644
index 0000000000000000000000000000000000000000..face9619dad8bd49d90d4f313caa90dca21bc48b
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventCnvTools/TrkEventCnvTools/ITrkEventCnvTool.icc
@@ -0,0 +1,113 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "Identifier/IdentifierHash.h"
+#include "TrkPrepRawData/PrepRawData.h"
+#include "TrkRIO_OnTrack/RIO_OnTrack.h"
+#include "StoreGate/ReadHandle.h"
+
+#include <typeinfo>
+
+
+template <class CONT, class ROT>
+void Trk::ITrkEventCnvTool::prepareRIO_OnTrackElementLink(const ROT* rot,
+ ELKey_t& key,
+ ELIndex_t& index) const
+{
+ // verify pointer is ok
+ // assume EL is correct
+ // get data handles to convertors
+
+ key = rot->m_rio.dataID();
+ index = rot->m_rio.index();
+
+ bool isPersistifiable = (rot->m_rio.key() != 0
+ and IdentContIndex(index).isValid());
+
+ if (isPersistifiable) {
+ return; // Already set - bail out.
+ }
+
+ // When doing AOD to AOD copy we expect the PRD links to be zero.
+ if (rot->prepRawData()==nullptr) {
+ MsgStream log(&(*m_msgSvc), name());
+ log<<MSG::DEBUG<<"No PRD for this ROT: "<<(*rot)<<endmsg;
+ return;
+ }
+
+ SG::ConstIterator<CONT> dh, dhEnd;
+ StatusCode sc = m_storeGate->retrieve(dh, dhEnd);
+ if (sc.isFailure()) {
+ MsgStream log(&(*m_msgSvc), name());
+ log << MSG::WARNING <<"No containers found!"<< endmsg;
+ return;
+ }
+
+ // loop over dhs
+ for ( ; dh!=dhEnd; dh++) {
+ const Trk::PrepRawData* prd = rot->prepRawData();
+ unsigned int oindex = prd->getHashAndIndex().objIndex(); // prd index within collection
+ IdentifierHash idHash = prd->getHashAndIndex().collHash(); // idHash of collection
+
+ const CONT& cont = *dh; // container
+ auto coll = cont.indexFindPtr(idHash); //matching collection
+
+ // does coll exist?
+ // check prd exists in collection
+ // check pointer value the same.
+ if ( (coll!=nullptr)&& (coll->size()>oindex) && (prd==(*coll)[oindex]) ) {
+ // okay, so we found the correct PRD in the container.
+ // Return EL components.
+ // dh.key() is the name of the container. oindex is the index within the collection. IdHash????
+ key = dh.key();
+ index = prd->getHashAndIndex().hashAndIndex();
+ return; //exit loop and function. We're done.
+ }
+ }
+ // so, we obviously didn't have the correct container (or something else went wrong)
+ MsgStream log(&(*m_msgSvc), name());
+ log << MSG::ERROR<<"Could not find matching PRD container for this ROT. ROT will be written out in incomplete state. "
+ << "Dumping ROT: "<<*rot<<endmsg;
+
+ return;
+}
+
+template <class CONT, class ROT>
+void Trk::ITrkEventCnvTool::prepareRIO_OnTrackElementLink(ROT* rot) const
+{
+ ELKey_t key;
+ ELIndex_t index;
+ prepareRIO_OnTrackElementLink<CONT> (rot, key, index);
+ rot->m_rio.resetWithKeyAndIndex (key, index);
+}
+
+inline void Trk::ITrkEventCnvTool::setRoT_Values(std::pair<const Trk::TrkDetElementBase *, const Trk::PrepRawData *>& pair, Trk::RIO_OnTrack *RoT) const {
+ RoT->setValues(pair.first, pair.second);
+}
+
+template <class CONT, class ROT>
+bool Trk::ITrkEventCnvTool::getHashAndIndex(const ROT* rot,
+ const SG::ReadHandleKey<CONT>& contName,
+ typename ElementLink<CONT>::index_type& hashAndIndex) const {
+ if (rot==nullptr) return false;
+
+ const Trk::PrepRawData* prd{rot->prepRawData()};
+ if (prd==nullptr) return false;
+
+ SG::ReadHandle<CONT> cont (contName);
+ if (not cont.isValid()) return false;
+
+ const IdentContIndex& idContIndex{prd->getHashAndIndex()};
+ const IdentifierHash& idHash{idContIndex.collHash()}; // idHash of collection
+ auto contItr = cont->indexFindPtr(idHash); //matching collection
+ if (contItr==nullptr) return false;
+
+ unsigned int index{idContIndex.objIndex()}; // prd index within collection
+ if ((contItr->size()>index) and (prd==(*contItr)[index])) {
+ hashAndIndex = idContIndex.hashAndIndex();
+ return true;
+ }
+
+ return false;
+}
diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/python/TrkEventCnvToolsConfig.py b/Tracking/TrkEventCnv/TrkEventCnvTools/python/TrkEventCnvToolsConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..272de9158e9e65da5bbbfe6aa911abaa6c424ed3
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventCnvTools/python/TrkEventCnvToolsConfig.py
@@ -0,0 +1,14 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+# default configuration of TrkEventCnvTools
+# example of a configuration in class deriving from a Configurable
+
+from AthenaCommon.DetFlags import DetFlags
+from AthenaCommon.AppMgr import ToolSvc
+# from RecExConfig import RecFlags as rec
+
+from TrkEventCnvTools.TrkEventCnvToolsConf import Trk__EventCnvSuperTool
+TrkEventCnvSuperTool = Trk__EventCnvSuperTool(name="EventCnvSuperTool")
+ToolSvc+=TrkEventCnvSuperTool
+# TrkEventCnvSuperTool.DoMuons = rec.doMuon() and DetFlags.detdescr.Muon_on()
+# TrkEventCnvSuperTool.DoID = rec.doInDet() and DetFlags.detdescr.ID_on()
diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/src/EventCnvSuperTool.cxx b/Tracking/TrkEventCnv/TrkEventCnvTools/src/EventCnvSuperTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..649b03b828099461237a92523cb88c217af26f54
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventCnvTools/src/EventCnvSuperTool.cxx
@@ -0,0 +1,180 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrkEventCnvTools/EventCnvSuperTool.h"
+#include "FaserDetDescr/FaserDetectorID.h"
+#include "TrkRIO_OnTrack/RIO_OnTrack.h"
+#include "TrkMeasurementBase/MeasurementBase.h"
+#include "TrkEventCnvTools/ITrkEventCnvTool.h"
+#include "TrkSurfaces/Surface.h"
+#include "TrkEventCnvTools/DetElementSurface.h"
+#include <typeinfo>
+
+Trk::EventCnvSuperTool::EventCnvSuperTool(
+ const std::string& t,
+ const std::string& n,
+ const IInterface* p )
+ :
+ base_class(t,n,p),
+ m_detID(0),
+ m_haveTrackerCnvTool(false), // Will be set to true on retrieval
+ m_errCount(0),
+ m_maxErrCount(10)
+{
+ declareProperty("MaxErrorCount", m_maxErrCount, "Maximum number of errors that will be reported");
+}
+
+Trk::EventCnvSuperTool::~EventCnvSuperTool(){
+ if (m_errCount>m_maxErrCount) ATH_MSG_WARNING("Suppressed "<<(m_errCount-m_maxErrCount)<<" WARNING or ERROR messages");
+}
+
+StatusCode
+Trk::EventCnvSuperTool::initialize(){
+ // Try to get FaserID
+ StatusCode sc = detStore()->retrieve( m_detID, "FaserID" );
+ if( sc.isFailure() ) {
+ msg(MSG::WARNING) << "Could not get FaserDetectorID " << endmsg;
+ }
+
+ //Now try to get the tools
+ if ( !m_trackerCnvTool.empty() ) {
+ if (m_trackerCnvTool.retrieve().isFailure() )
+ {
+ msg(MSG::DEBUG) << "Failed to retrieve Tracker helper tool "<< m_trackerCnvTool
+ <<". Will not be able to recreate Tracker Surfaces / Det Elements."<<endmsg;
+ } else {
+ msg(MSG::VERBOSE) << "Retrieved tool " << m_trackerCnvTool << endmsg;
+ m_haveTrackerCnvTool=true;
+ }
+ } else {
+ m_trackerCnvTool.setTypeAndName("");
+ }
+
+ if (!m_haveTrackerCnvTool){
+ msg(MSG::WARNING) << "Failed to retrieve Tracker tool. Will not be able to recreate surfaces / detector elements."<< endmsg;
+ m_maxErrCount=0; // No point in further WARNINGs
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode
+Trk::EventCnvSuperTool::finalize(){
+ msg()<< "Finalize().";
+ if (m_errCount>0) msg()<<" Tried to print "<<m_errCount<<" ERROR/WARNING messages (with maximum permissable = "<<m_maxErrCount<<")";
+ msg()<<endmsg;
+ return StatusCode::SUCCESS;
+}
+
+const Trk::ITrkEventCnvTool*
+Trk::EventCnvSuperTool::getCnvTool(const Identifier& id) const {
+ if (m_detID==0) return 0;
+
+ if (m_haveTrackerCnvTool)
+ {
+ return &(*m_trackerCnvTool);
+ }
+ else
+ {
+ if ( (m_errCount++)<m_maxErrCount) msg(MSG::WARNING)
+ << "Tracker RIO_OnTrack, but have no Tracker cnv tool!"
+ << endmsg;
+ return 0;
+ }
+
+
+ // if(m_detID->is_indet(id))
+ // {
+ // //std::cout<<"Trk::EventCnvSuperTool::getCnvTool = ID"<<std::endl;
+ // if (m_haveIdCnvTool )
+ // {
+ // return &(*m_idCnvTool);
+ // }else{
+ // if ( (m_errCount++)<m_maxErrCount) msg(MSG::WARNING)
+ // << "ID RIO_OnTrack, but have no ID cnv tool!"
+ // << endmsg;
+ // return 0;
+ // }
+ // }else{
+ // if(m_detID->is_muon(id) )
+ // {
+ // //std::cout<<"Trk::EventCnvSuperTool::getCnvTool = Muon"<<std::endl;
+ // if (m_haveMuonCnvTool)
+ // {
+ // return &(*m_muonCnvTool);
+ // }else{
+ // if ( (m_errCount++)<m_maxErrCount) msg(MSG::WARNING)
+ // << "Muon RIO_OnTrack, but have no muon cnv tool. Cannot set check RoT."
+ // << endmsg;
+ // return 0;
+ // }
+ // }
+ // }
+
+ if ( (m_errCount++)<m_maxErrCount){
+ std::string ident = m_detID->show_to_string(id);
+ msg(MSG::WARNING)
+ << "Unknown Identifier: ("<< ident<<"), that is ("<<id<<")"
+ << endmsg;
+ }
+ return 0;
+
+}
+
+const Trk::Surface*
+Trk::EventCnvSuperTool::getSurface(const Identifier& id) const {
+ const Surface* surface = 0;
+ const Trk::ITrkEventCnvTool* cnvTool = getCnvTool(id);
+ if (cnvTool!=0) {
+ const TrkDetElementBase* detEl = cnvTool->getDetectorElement( id );
+ if (detEl!=0)
+ surface = &(detEl->surface(id));
+ else
+ if ( (m_errCount++)<m_maxErrCount) msg(MSG::WARNING)<< "getSurface: could not get detector element from id:"<<id<<" Returning 0." << endmsg;
+ } else {
+ if ( (m_errCount++)<m_maxErrCount) msg(MSG::WARNING)<< "getSurface: could not get cnv tool for Identifier:"<<id<< endmsg;
+ }
+ return surface;
+}
+
+void
+Trk::EventCnvSuperTool::recreateRIO_OnTrack( Trk::RIO_OnTrack *RoT ) const
+{
+ using namespace std;
+ const Trk::ITrkEventCnvTool* cnvTool = getCnvTool(RoT->identify());
+ if (cnvTool!=0) {
+ cnvTool->recreateRIO_OnTrack( RoT );
+ } else {
+ const type_info& info = typeid(*RoT);
+ if ( (m_errCount++)<m_maxErrCount)
+ msg(MSG::WARNING)<< "recreateRIO_OnTrack: could not get cnv tool. Returning without correctly filling ROT of type: "<< info.name()<< endmsg;
+ }
+ return;
+}
+
+void
+Trk::EventCnvSuperTool::prepareRIO_OnTrack( Trk::RIO_OnTrack *RoT ) const
+{
+ const Trk::ITrkEventCnvTool* cnvTool = getCnvTool(RoT->identify());
+ if (cnvTool!=0) {
+ cnvTool->prepareRIO_OnTrack( RoT );
+ } else {
+ if ( (m_errCount++)<m_maxErrCount) msg()<< "prepareRIO_OnTrack could not find appropriate tool to prepare: "<<*RoT<<std::endl;
+ }
+ return;
+}
+
+void
+Trk::EventCnvSuperTool::prepareRIO_OnTrackLink ( const Trk::RIO_OnTrack *RoT,
+ ELKey_t& key,
+ ELIndex_t& index ) const
+{
+ const Trk::ITrkEventCnvTool* cnvTool = getCnvTool(RoT->identify());
+ if (cnvTool!=0) {
+ cnvTool->prepareRIO_OnTrackLink ( RoT, key, index );
+ } else {
+ if ( (m_errCount++)<m_maxErrCount) msg()<< "prepareRIO_OnTrack could not find appropriate tool to prepare: "<<*RoT<<std::endl;
+ }
+ return;
+}
diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/src/components/TrkEventCnvTools_entries.cxx b/Tracking/TrkEventCnv/TrkEventCnvTools/src/components/TrkEventCnvTools_entries.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..85c690d36c1a0db0dc6a75d7d80d3561e2d49adf
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventCnvTools/src/components/TrkEventCnvTools_entries.cxx
@@ -0,0 +1,5 @@
+#include "TrkEventCnvTools/EventCnvSuperTool.h"
+
+
+DECLARE_COMPONENT( Trk::EventCnvSuperTool )
+
diff --git a/Tracking/TrkEventCnv/TrkEventTopLevelCnv/CMakeLists.txt b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d93168761cab1bb13644e4ad7950ba4285f56711
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+
+# Declare the package name:
+atlas_subdir( TrkEventTopLevelCnv )
+
+# Component(s) in the package:
+atlas_add_tpcnv_library( TrkEventTopLevelCnv
+ TrkEventTopLevelCnv/*.h src/*.cxx
+ PUBLIC_HEADERS TrkEventTopLevelCnv
+ LINK_LIBRARIES
+ TrackerEventTPCnv TrkEventTPCnv RecTPCnv TPTools
+ )
+
+atlas_add_dictionary( TrkEventTopLevelCnvDict
+ TrkEventTopLevelCnv/TrkEventTopLevelCnvDict.h
+ TrkEventTopLevelCnv/selection.xml
+ LINK_LIBRARIES TrkEventTopLevelCnv
+ )
+
diff --git a/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/TrackCollectionCnv_tlp6.h b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/TrackCollectionCnv_tlp6.h
new file mode 100644
index 0000000000000000000000000000000000000000..637c9b9a468b316fc3a62acc5dc8f82c8e1838fd
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/TrackCollectionCnv_tlp6.h
@@ -0,0 +1,89 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACK_COLLECTION_CNV_TLP6_TRK_H
+#define TRACK_COLLECTION_CNV_TLP6_TRK_H
+
+
+#include "TPTools/TopLevelTPConverter.h"
+
+#include "TrackCollection_tlp6.h"
+
+#include "TrkEventTPCnv/TrkTrack/TrackCollectionCnv_p4.h"
+#include "TrkEventTPCnv/TrkTrack/TrackCnv_p4.h"
+#include "TrkEventTPCnv/TrkTrack/TrackStateOnSurfaceCnv_p3.h"
+
+#include "TrkEventTPCnv/TrkPseudoMeasurementOnTrack/PseudoMeasurementOnTrackCnv_p2.h"
+// #include "TrkEventTPCnv/TrkVertexOnTrack/VertexOnTrackCnv_p1.h"
+
+// #include "TrkEventTPCnv/TrkCompetingRIOsOnTrack/CompetingRIOsOnTrackCnv_p1.h"
+#include "TrkEventTPCnv/TrkParameters/TrackParametersCnv_p2.h" // Also takes care of surfaces now, for these objects
+
+#include "TrkEventTPCnv/TrkSurfaces/SurfaceCnv_p2.h"
+#include "TrkEventTPCnv/TrkDetElementSurface/DetElementSurfaceCnv_p1.h"
+
+#include "TrkEventTPCnv/TrkEventPrimitives/ErrorMatrixCnv_p1.h"
+#include "TrkEventTPCnv/TrkMaterialOnTrack/MaterialEffectsBaseCnv_p2.h"
+#include "TrkEventTPCnv/TrkMaterialOnTrack/EnergyLossCnv_p1.h"
+#include "TrkEventTPCnv/TrkMaterialOnTrack/MaterialEffectsOnTrackCnv_p2.h"
+#include "TrkEventTPCnv/TrkMaterialOnTrack/EstimatedBremOnTrackCnv_p1.h"
+#include "TrkEventTPCnv/TrkEventPrimitives/LocalDirectionCnv_p1.h"
+#include "TrkEventTPCnv/TrkEventPrimitives/LocalPositionCnv_p1.h"
+#include "TrkEventTPCnv/TrkEventPrimitives/LocalParametersCnv_p1.h"
+
+// #include "MuonEventTPCnv/MuonMeasurementsCnv_tlp2.h"
+#include "TrackerEventTPCnv/TrackerTrackCnv_tlp2.h"
+// #include "RecTPCnv/MuonCaloEnergyContainerCnv_tlp1.h"
+
+
+typedef TopLevelTPConverter< TrackCollectionCnv_p4, Trk::TrackCollection_tlp6 > BaseTrackCollectionCnv;
+
+class TrackCollectionCnv_tlp6 : public BaseTrackCollectionCnv
+{
+ public:
+
+ TrackCollectionCnv_tlp6();
+
+ virtual void setPStorage( PERS *storage ) override;
+ virtual PERS* createPersistentWithKey(const TRANS* transObj,
+ const std::string& key,
+ MsgStream &log) override;
+
+// all TP converters for types used in the Track package
+protected:
+ TrackCnv_p4 m_tracksCnv;
+ TrackStateOnSurfaceCnv_p3 m_trackStatesCnv;
+
+ ErrorMatrixCnv_p1 m_errorMatricesCnv;
+
+ PseudoMeasurementOnTrackCnv_p2 m_pseudoMeasurementOnTrackCnv;
+// VertexOnTrackCnv_p1 m_vertexOnTrackCnv;
+// CompetingRIOsOnTrackCnv_p1 m_crotCnv;
+
+ TrackParametersCnv_p2 m_parametersCnv;
+
+ ConeSurfaceCnv_p2 m_coneSurfacesCnv ;
+ CylinderSurfaceCnv_p2 m_cylSurfacesCnv ;
+ DiscSurfaceCnv_p2 m_discSurfacesCnv ;
+ PerigeeSurfaceCnv_p2 m_perigeeSurfacesCnv ;
+ PlaneSurfaceCnv_p2 m_planeSurfacesCnv ;
+ StraightLineSurfaceCnv_p2 m_lineSurfacesCnv ;
+ SaggedLineSurfaceCnv_p2 m_saggedLineSurfacesCnv ;
+
+ FitQualityCnv_p1 m_fitQualitiesCnv;
+ MaterialEffectsBaseCnv_p2 m_matEffectsBaseCnv;
+ EnergyLossCnv_p1 m_energyLossCnv;
+ MaterialEffectsOnTrackCnv_p2 m_materialEffectsCnv;
+ EstimatedBremOnTrackCnv_p1 m_estimatedBremCnv;
+
+ LocalDirectionCnv_p1 m_localDirectionsCnv;
+ LocalPositionCnv_p1 m_localPositionsCnv;
+ LocalParametersCnv_p1 m_localParametersCnv;
+
+ // TLP converters for extending TLP objects
+// MuonMeasurementsCnv_tlp2 m_muonMeasurementsCnv;
+ TrackerTrackCnv_tlp2 m_trackerTrackCnv;
+// MuonCaloEnergyContainerCnv_tlp1 m_muonCaloEnergiesCnv;
+};
+#endif
diff --git a/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/TrackCollection_tlp6.h b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/TrackCollection_tlp6.h
new file mode 100644
index 0000000000000000000000000000000000000000..25a035e5ab8c739faa7007f7308ca43b30709b1d
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/TrackCollection_tlp6.h
@@ -0,0 +1,104 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACK_COLLECTION_TLP6_TRK_H
+#define TRACK_COLLECTION_TLP6_TRK_H
+
+
+//-----------------------------------------------------------------------------
+// TrkTrack
+//-----------------------------------------------------------------------------
+#include "TrkEventTPCnv/TrkTrack/TrackCollection_p1.h"
+#include "TrkEventTPCnv/TrkTrack/Track_p4.h"
+#include "TrkEventTPCnv/TrkTrack/TrackStateOnSurface_p3.h"
+
+//-----------------------------------------------------------------------------
+// TrkEventPrimitives
+//-----------------------------------------------------------------------------
+#include "TrkEventTPCnv/TrkEventPrimitives/FitQuality_p1.h"
+#include "TrkEventTPCnv/TrkEventPrimitives/LocalPosition_p1.h"
+#include "TrkEventTPCnv/TrkEventPrimitives/LocalDirection_p1.h"
+#include "TrkEventTPCnv/TrkEventPrimitives/LocalParameters_p1.h"
+#include "TrkEventTPCnv/TrkEventPrimitives/HepSymMatrix_p1.h"
+
+//-----------------------------------------------------------------------------
+// TrkMaterialOnTrack
+//-----------------------------------------------------------------------------
+#include "TrkEventTPCnv/TrkMaterialOnTrack/MaterialEffectsBase_p1.h"
+#include "TrkEventTPCnv/TrkMaterialOnTrack/EnergyLoss_p1.h"
+#include "TrkEventTPCnv/TrkMaterialOnTrack/MaterialEffectsOnTrack_p2.h"
+#include "TrkEventTPCnv/TrkMaterialOnTrack/EstimatedBremOnTrack_p1.h"
+
+//-----------------------------------------------------------------------------
+// TrkSurfaces
+//-----------------------------------------------------------------------------
+#include "TrkEventTPCnv/TrkSurfaces/Surface_p2.h"
+
+//-----------------------------------------------------------------------------
+// Trk Parameters
+//-----------------------------------------------------------------------------
+#include "TrkEventTPCnv/TrkParameters/TrackParameters_p2.h"
+
+//-----------------------------------------------------------------------------
+// TrkRIO_OnTrack
+//-----------------------------------------------------------------------------
+// #include "TrkEventTPCnv/TrkCompetingRIOsOnTrack/CompetingRIOsOnTrack_p1.h"
+#include "TrkEventTPCnv/TrkPseudoMeasurementOnTrack/PseudoMeasurementOnTrack_p2.h"
+// #include "TrkEventTPCnv/TrkVertexOnTrack/VertexOnTrack_p1.h"
+
+//-----------------------------------------------------------------------------
+// Top Level Pers Objects from InnerDetector and MuonSpectrometer
+// Previously stored as separate Extening TP objects, now integrated
+// including full declarations for dictionary's sake
+
+#include "TrackerEventTPCnv/TrackerTrack_tlp2.h"
+// #include "MuonEventTPCnv/MuonMeasurements_tlp2.h"
+// #include "RecTPCnv/MuonCaloEnergyContainerCnv_tlp1.h"
+
+namespace Trk
+{
+ class TrackCollection_tlp6
+ {
+ public:
+ TrackCollection_tlp6() { }
+
+ ~TrackCollection_tlp6() {
+ delete m_trackerTrackExt;
+ }
+
+ TrackCollection_tlp6 (const TrackCollection_tlp6&) = delete;
+ TrackCollection_tlp6& operator= (const TrackCollection_tlp6&) = delete;
+
+ std::vector< Trk::TrackCollection_p1 > m_trackCollections;
+ std::vector< Trk::Track_p4 > m_tracks;
+ std::vector< Trk::TrackStateOnSurface_p3 > m_trackStates;
+
+ // std::vector< Trk::CompetingRIOsOnTrack_p1 > m_competingRotsOnTrack;
+ std::vector< Trk::PseudoMeasurementOnTrack_p2 > m_pseudoMeasurementOnTrack;
+ // std::vector< Trk::VertexOnTrack_p1 > m_vertexOnTrack;
+
+ std::vector< Trk::TrackParameters_p2 > m_parameters;
+
+ std::vector< Trk::Surface_p2 > m_surfaces;
+
+ std::vector< Trk::HepSymMatrix_p1 > m_hepSymMatrices;
+ std::vector< Trk::MaterialEffectsBase_p1 > m_matEffectsBases;
+ std::vector< Trk::EnergyLoss_p1 > m_energyLosses;
+ std::vector< Trk::MaterialEffectsOnTrack_p2 > m_materialEffects;
+ std::vector< Trk::EstimatedBremOnTrack_p1 > m_estimatedBrems;
+
+ std::vector< Trk::FitQuality_p1 > m_fitQualities;
+ std::vector< Trk::LocalDirection_p1 > m_localDirections;
+ std::vector< Trk::LocalPosition_p1 > m_localPositions;
+ std::vector< Trk::LocalParameters_p1 > m_localParameters;
+
+ // TLP converters from other packages
+ // for subclass types found in Tracking polymorphic collections
+ Tracker::Track_tlp2 *m_trackerTrackExt = nullptr;
+ // TPCnv::MuonMeasurements_tlp2 *m_muonMeasurementsExt = nullptr;
+ // MuonCaloEnergyContainer_tlp1 *m_muonCaloEnergiesExt = nullptr;
+ };
+}
+
+#endif // TRACK_COLLECTION_P6_TRK_H
diff --git a/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnvDict.h b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnvDict.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2feba79d7dc11ac0c8986dd51b70ecf85999166
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnvDict.h
@@ -0,0 +1,10 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRKEVENTTOPLEVELCNV_DICT_H
+#define TRKEVENTTOPLEVELCNV_DICT_H
+
+#include "TrkEventTopLevelCnv/TrackCollection_tlp6.h"
+
+#endif
diff --git a/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/selection.xml b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/selection.xml
new file mode 100644
index 0000000000000000000000000000000000000000..c28c7eb4a208f927f3626ad25d45aea695d0892c
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/TrkEventTopLevelCnv/selection.xml
@@ -0,0 +1,6 @@
+<lcgdict>
+
+ <class name="Trk::TrackCollection_tlp6" id="3228B252-2C5D-11E8-B170-0800271C02BC" />
+
+</lcgdict>
+
diff --git a/Tracking/TrkEventCnv/TrkEventTopLevelCnv/src/TrackCollectionCnv_tlp6.cxx b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/src/TrackCollectionCnv_tlp6.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..0803ec704aa757bf524b32534cc1dd573ec00e7e
--- /dev/null
+++ b/Tracking/TrkEventCnv/TrkEventTopLevelCnv/src/TrackCollectionCnv_tlp6.cxx
@@ -0,0 +1,116 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrkEventTopLevelCnv/TrackCollectionCnv_tlp6.h"
+
+/*
+ Converter for TrackCollection v TLP6.
+ Direct copy of TLP5 but with MuonMeasurements and InDet::Track tlp converters
+ integrated directly
+*/
+
+TrackCollectionCnv_tlp6::TrackCollectionCnv_tlp6( )
+{
+// Add all converters defined in this top level converter:
+// never change the order of adding converters!
+
+ addMainTPConverter();
+
+ addTPConverter( &m_tracksCnv );
+ addTPConverter( &m_trackStatesCnv );
+
+ addTPConverter( &m_errorMatricesCnv );
+
+ // Measurements
+ addTPConverter( &m_pseudoMeasurementOnTrackCnv );
+// addTPConverter( &m_crotCnv );
+// addTPConverter( &m_vertexOnTrackCnv );
+ // Other measurements are stored in the other tlp objects, i.e. the InDetTrack, and MuonMeasurements
+
+ // Parameters
+ addTPConverter( &m_parametersCnv );
+
+ // Surfaces
+ addTPConverter( &m_coneSurfacesCnv );
+ addTPConverter( &m_cylSurfacesCnv );
+ addTPConverter( &m_discSurfacesCnv );
+ addTPConverter( &m_perigeeSurfacesCnv );
+ addTPConverter( &m_planeSurfacesCnv );
+ addTPConverter( &m_lineSurfacesCnv );
+ addTPConverter( &m_saggedLineSurfacesCnv );
+
+ addTPConverter( &m_matEffectsBaseCnv );
+ addTPConverter( &m_energyLossCnv );
+ addTPConverter( &m_materialEffectsCnv );
+ addTPConverter( &m_estimatedBremCnv );
+
+ addTPConverter( &m_fitQualitiesCnv );
+ addTPConverter( &m_localDirectionsCnv );
+ addTPConverter( &m_localPositionsCnv );
+ addTPConverter( &m_localParametersCnv );
+
+ // adding extending TLP converters,
+ // they don't interfere with the order of adding regular converters (above)
+// m_muonMeasurementsCnv.addTPConvertersTo( this );
+ m_trackerTrackCnv.addTPConvertersTo( this );
+// m_muonCaloEnergiesCnv.addTPConvertersTo( this );
+}
+
+
+void TrackCollectionCnv_tlp6::setPStorage( PERS *storage )
+{
+ setMainCnvPStorage( &storage->m_trackCollections );
+
+// for all converters defined in this top level converter
+ m_tracksCnv. setPStorage( &storage->m_tracks );
+ m_trackStatesCnv. setPStorage( &storage->m_trackStates );
+
+ m_errorMatricesCnv. setPStorage( &storage->m_hepSymMatrices );
+
+ m_pseudoMeasurementOnTrackCnv.setPStorage( &storage->m_pseudoMeasurementOnTrack );
+// m_crotCnv. setPStorage( &storage->m_competingRotsOnTrack );
+// m_vertexOnTrackCnv. setPStorage( &storage->m_vertexOnTrack );
+
+ m_parametersCnv. setPStorage( &storage->m_parameters );
+
+ m_coneSurfacesCnv .setPStorage( &storage->m_surfaces );
+ m_cylSurfacesCnv .setPStorage( &storage->m_surfaces );
+ m_discSurfacesCnv .setPStorage( &storage->m_surfaces );
+ m_perigeeSurfacesCnv .setPStorage( &storage->m_surfaces );
+ m_planeSurfacesCnv .setPStorage( &storage->m_surfaces );
+ m_lineSurfacesCnv .setPStorage( &storage->m_surfaces );
+ m_saggedLineSurfacesCnv .setPStorage( &storage->m_surfaces );
+
+ m_matEffectsBaseCnv. setPStorage( &storage->m_matEffectsBases );
+ m_energyLossCnv. setPStorage( &storage->m_energyLosses );
+ m_materialEffectsCnv. setPStorage( &storage->m_materialEffects );
+ m_estimatedBremCnv. setPStorage( &storage->m_estimatedBrems );
+
+ m_fitQualitiesCnv. setPStorage( &storage->m_fitQualities );
+ m_localDirectionsCnv. setPStorage( &storage->m_localDirections );
+ m_localPositionsCnv. setPStorage( &storage->m_localPositions );
+ m_localParametersCnv. setPStorage( &storage->m_localParameters );
+
+ // when reading (createTrans) these will be non-null if extension is present
+ // when writing, they will be null at first end set afterwards in createPersistentWithKey()
+ if( storage->m_trackerTrackExt ) m_trackerTrackCnv .setPStorage( storage->m_trackerTrackExt );
+// if( storage->m_muonMeasurementsExt ) m_muonMeasurementsCnv.setPStorage( storage->m_muonMeasurementsExt );
+// if( storage->m_muonCaloEnergiesExt ) m_muonCaloEnergiesCnv.setPStorage( storage->m_muonCaloEnergiesExt );
+}
+
+
+BaseTrackCollectionCnv::PERS*
+TrackCollectionCnv_tlp6::createPersistentWithKey(const TRANS* transObj,
+ const std::string& key,
+ MsgStream &log)
+{
+ PERS *pers = BaseTrackCollectionCnv::createPersistentWithKey(transObj, key, log);
+
+ // get extending objects (nullptr if there was no extending data types)
+// pers->m_muonMeasurementsExt = m_muonMeasurementsCnv.releaseTLPersObject();
+ pers->m_trackerTrackExt = m_trackerTrackCnv.releaseTLPersObject();
+// pers->m_muonCaloEnergiesExt = m_muonCaloEnergiesCnv.releaseTLPersObject();
+
+ return pers;
+}