From 198bba89726811c220b8ec139bba70c4b587e250 Mon Sep 17 00:00:00 2001
From: Will Leight <wleight@cern.ch>
Date: Fri, 11 Sep 2020 11:53:33 +0200
Subject: [PATCH] Use unique_ptr for tracks in MuonTrackSteeringTools
Switching to using unique_ptr for Track and MuPatTrack objects. In particular, MuPatTrack now stores a unique_ptr to the Track, rather than an (unnecessarily) const bare pointer.
This should simplify the memory management for tracks and eliminates the need for some const_casts.
Additionally, MuonTrackSelectorTool is moved to MuonTrackSteeringTools, as it is only used there.
---
.../IMuonSegmentTrackBuilder.h | 8 +-
.../MuonRecToolInterfaces/IMuonTrackBuilder.h | 2 +-
.../MuonRecToolInterfaces/IMuonTrackRefiner.h | 2 +-
.../MuonTrackFinderTools_entries.cxx | 2 -
.../src/MooCandidateMatchingTool.cxx | 10 +-
.../src/MooTrackBuilder.cxx | 332 +++++++----------
.../src/MooTrackBuilder.h | 44 +--
.../src/MooTrackFitter.cxx | 139 +++----
.../src/MooTrackFitter.h | 16 +-
.../src/MuPatCandidateTool.cxx | 77 +---
.../src/MuPatCandidateTool.h | 20 +-
.../MuonTrackSteeringTools/src/MuPatTrack.cxx | 45 +--
.../MuonTrackSteeringTools/src/MuPatTrack.h | 32 +-
.../src/MuonTrackSelectorTool.cxx | 10 +-
.../src/MuonTrackSelectorTool.h | 17 +-
.../src/MuonTrackSteering.cxx | 343 +++++-------------
.../src/MuonTrackSteering.h | 16 +-
.../MuonTrackSteeringTools_entries.cxx | 3 +-
18 files changed, 370 insertions(+), 748 deletions(-)
rename MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/{MuonTrackFinderTools => MuonTrackSteeringTools}/src/MuonTrackSelectorTool.cxx (97%)
rename MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/{MuonTrackFinderTools => MuonTrackSteeringTools}/src/MuonTrackSelectorTool.h (86%)
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonSegmentTrackBuilder.h b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonSegmentTrackBuilder.h
index 867787e4b7b5..57bac061e8eb 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonSegmentTrackBuilder.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonSegmentTrackBuilder.h
@@ -37,7 +37,7 @@ namespace Muon {
@param track the track
@return a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.
*/
- virtual Trk::Track* refit( Trk::Track& track ) const = 0;
+ virtual std::unique_ptr<Trk::Track> refit( Trk::Track& track ) const = 0;
/** recalibrate hits on track, does not refit
@param track the track
@@ -45,7 +45,7 @@ namespace Muon {
@param doCompetingClusters flag to indicate whether to redo competing ROTs
@return a pointer to the resulting track, will return zero if calibration failed. Ownership passed to user.
*/
- virtual Trk::Track* recalibrateHitsOnTrack( const Trk::Track& track, bool doMdts, bool doCompetingClusters ) const = 0;
+ virtual std::unique_ptr<Trk::Track> recalibrateHitsOnTrack( const Trk::Track& track, bool doMdts, bool doCompetingClusters ) const = 0;
/** @brief combine two segments to a super segment
@param seg1 the first segment
@@ -62,7 +62,7 @@ namespace Muon {
@param externalPhiHits if provided, the external phi hits will be used instead of the phi hits on the segment
@return a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.
*/
- virtual Trk::Track* combine( const MuonSegment& seg1, const MuonSegment& seg2,
+ virtual std::unique_ptr<Trk::Track> combine( const MuonSegment& seg1, const MuonSegment& seg2,
const PrepVec* patternPhiHits = 0 ) const = 0;
/** @brief combine a track with a segment
@@ -71,7 +71,7 @@ namespace Muon {
@param externalPhiHits if provided, the external phi hits will be used instead of the phi hits on the segment
@return a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.
*/
- virtual Trk::Track* combine( const Trk::Track& track, const MuonSegment& seg,
+ virtual std::unique_ptr<Trk::Track> combine( const Trk::Track& track, const MuonSegment& seg,
const PrepVec* patternPhiHits = 0 ) const = 0;
/** @brief find closest TrackParameters to the position. Closest is defined as closest in z in the endcap and
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonTrackBuilder.h b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonTrackBuilder.h
index 89b4c832942f..59ac1cd14fa1 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonTrackBuilder.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonTrackBuilder.h
@@ -43,7 +43,7 @@ namespace Muon {
The ownership of the tracks is passed to the client calling the tool.
*/
- virtual std::vector<MuPatTrack*>* find( MuPatCandidateBase& candidate, const std::vector<MuPatSegment*>& segments ) const = 0;
+ virtual std::vector<std::unique_ptr<MuPatTrack> > find( MuPatCandidateBase& candidate, const std::vector<MuPatSegment*>& segments ) const = 0;
};
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonTrackRefiner.h b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonTrackRefiner.h
index f1226dbd5b55..7c4199faf3e6 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonTrackRefiner.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonTrackRefiner.h
@@ -38,7 +38,7 @@ namespace Muon {
@param track input track
@return new refined track. Pointer could be zero, ownership passed to caller
*/
- virtual MuPatTrack* refine( MuPatTrack& track ) const = 0;
+ virtual void refine( MuPatTrack& track ) const = 0;
};
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/components/MuonTrackFinderTools_entries.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/components/MuonTrackFinderTools_entries.cxx
index 82829fabadb3..f3410bc96f11 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/components/MuonTrackFinderTools_entries.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/components/MuonTrackFinderTools_entries.cxx
@@ -2,7 +2,6 @@
#include "../MuonChamberHoleRecoveryTool.h"
#include "../MuonSegmentRegionRecoveryTool.h"
#include "../MuonTrackToSegmentTool.h"
-#include "../MuonTrackSelectorTool.h"
#include "../MuonSeededSegmentFinder.h"
#include "../MuonTrackScoringTool.h"
#include "../MuonTrackExtrapolationTool.h"
@@ -15,7 +14,6 @@ DECLARE_COMPONENT( MuonTrackCleaner )
DECLARE_COMPONENT( MuonChamberHoleRecoveryTool )
DECLARE_COMPONENT( MuonSegmentRegionRecoveryTool )
DECLARE_COMPONENT( MuonTrackToSegmentTool )
-DECLARE_COMPONENT( MuonTrackSelectorTool )
DECLARE_COMPONENT( MuonSeededSegmentFinder )
DECLARE_COMPONENT( MuonTrackScoringTool )
DECLARE_COMPONENT( MuonTrackExtrapolationTool )
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooCandidateMatchingTool.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooCandidateMatchingTool.cxx
index d6132b68c720..9d601f878366 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooCandidateMatchingTool.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooCandidateMatchingTool.cxx
@@ -250,26 +250,22 @@ namespace Muon {
ATH_MSG_DEBUG("Match track/segment: useTightCuts " << useTightCuts);
// convert segment and track
- MuPatTrack* candidate = m_candidateTool->createCandidate(&track);
+ std::unique_ptr<Trk::Track> inTrack=std::make_unique<Trk::Track>(track);
+ std::unique_ptr<MuPatTrack> candidate = m_candidateTool->createCandidate(inTrack);
if( !candidate ) {
ATH_MSG_VERBOSE("Failed to create track candidate");
return false;
}
- MuPatSegment* segInfo = m_candidateTool->createSegInfo(segment);
+ std::unique_ptr<MuPatSegment> segInfo(m_candidateTool->createSegInfo(segment));
if( !segInfo ) {
ATH_MSG_VERBOSE("Failed to create segment candidate");
- candidate->releaseTrack();
- delete candidate;
return false;
}
// call match
bool ok = match(*candidate,*segInfo,useTightCuts);
ATH_MSG_DEBUG("Match track/segment: result " << ok);
- candidate->releaseTrack();
- delete candidate;
- delete segInfo;
// return result
return ok;
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackBuilder.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackBuilder.cxx
index 9e11681eec6c..cfcdbfdefc4c 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackBuilder.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackBuilder.cxx
@@ -72,7 +72,7 @@ namespace Muon {
return StatusCode::SUCCESS;
}
- Trk::Track* MooTrackBuilder::refit(Trk::Track& track ) const {
+ std::unique_ptr<Trk::Track> MooTrackBuilder::refit(Trk::Track& track ) const {
// use slFitter for straight line fit, or toroid off, otherwise use normal Fitter
@@ -87,7 +87,7 @@ namespace Muon {
if (fieldCondObj == nullptr) {
ATH_MSG_ERROR("refit: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
- return nullptr;
+ return std::unique_ptr<Trk::Track>();
}
fieldCondObj->getInitializedCache (fieldCache);
if( !fieldCache.toroidOn() ) return m_slFitter->refit(track);
@@ -95,16 +95,14 @@ namespace Muon {
// if not refit tool specified do a pure refit
if( m_errorOptimisationTool.empty() ) return m_fitter->refit(track);
std::unique_ptr<Trk::Track> optTrack=m_errorOptimisationTool->optimiseErrors(&track);
- //have to use release until the whole tool uses unique_ptr
- return optTrack.release();
+ return optTrack;
}
- MuPatTrack* MooTrackBuilder::refine( MuPatTrack& track ) const {
+ void MooTrackBuilder::refine( MuPatTrack& track ) const {
- Trk::Track* finalTrack = m_hitRecoverTool->recover(track.track());
+ std::unique_ptr<Trk::Track> finalTrack(m_hitRecoverTool->recover(track.track()));
if( !finalTrack ) {
ATH_MSG_WARNING(" final track lost, this should not happen " );
- return nullptr;
}
ATH_MSG_VERBOSE("refine: after recovery " << std::endl
<< m_printer->print(*finalTrack) << std::endl
@@ -117,53 +115,44 @@ namespace Muon {
bool recalibrateMDTHits = m_recalibrateMDTHits;
bool recreateCompetingROTs = true;
- Trk::Track* recalibratedTrack = recalibrateHitsOnTrack(*finalTrack,recalibrateMDTHits,
+ std::unique_ptr<Trk::Track> recalibratedTrack = recalibrateHitsOnTrack(*finalTrack,recalibrateMDTHits,
recreateCompetingROTs);
if( !recalibratedTrack ){
ATH_MSG_WARNING(" failed to recalibrate hits on track " << std::endl
<< m_printer->print(*finalTrack) );
- }else{
- if( finalTrack != &track.track() ) delete finalTrack;
- finalTrack = recalibratedTrack;
}
+ else finalTrack.swap(recalibratedTrack);
- Trk::Track* refittedTrack = refit(*finalTrack);
+ std::unique_ptr<Trk::Track> refittedTrack = refit(*finalTrack);
if( !refittedTrack ){
ATH_MSG_VERBOSE(" failed to refit track " << std::endl
<< m_printer->print(*finalTrack) << std::endl
<< m_printer->printStations(*finalTrack) );
- }else{
- if( finalTrack != &track.track() ) delete finalTrack;
- finalTrack = refittedTrack;
}
+ else finalTrack.swap(refittedTrack);
// redo holes as they are dropped in the fitter
- Trk::Track* finalTrackWithHoles = m_muonChamberHoleRecoverTool->recover(*finalTrack);
+ std::unique_ptr<Trk::Track> finalTrackWithHoles(m_muonChamberHoleRecoverTool->recover(*finalTrack));
if( !finalTrackWithHoles ) {
ATH_MSG_WARNING(" failed to add holes to final track, this should not happen " );
- }else{
- if( finalTrack != &track.track() ) delete finalTrack;
- finalTrack = finalTrackWithHoles;
}
+ else finalTrack.swap(finalTrackWithHoles);
- Trk::Track* entryRecordTrack = m_trackExtrapolationTool->extrapolate( *finalTrack );
+ std::unique_ptr<Trk::Track> entryRecordTrack(m_trackExtrapolationTool->extrapolate( *finalTrack ));
if( entryRecordTrack ){
- if( finalTrack != &track.track() ) delete finalTrack;
- finalTrack = entryRecordTrack;
+ finalTrack.swap(entryRecordTrack);
ATH_MSG_VERBOSE(" track at muon entry record " << std::endl
<< m_printer->print(*finalTrack) );
}
- if( finalTrack != &track.track() ) m_candidateHandler->updateTrack( track, finalTrack );
-
- return &track;
+ m_candidateHandler->updateTrack( track, finalTrack );
}
MuonSegment* MooTrackBuilder::combineToSegment( const MuonSegment& seg1, const MuonSegment& seg2,
const PrepVec* externalPhiHits) const {
// try to get track
- Trk::Track* track = combine( seg1, seg2, externalPhiHits );
+ std::unique_ptr<Trk::Track> track = combine( seg1, seg2, externalPhiHits );
if( !track ) return nullptr;
@@ -173,13 +162,10 @@ namespace Muon {
ATH_MSG_WARNING( " conversion of track failed!! " );
}
- // delete track
- delete track;
-
return seg;
}
- Trk::Track* MooTrackBuilder::combine( const MuonSegment& seg1, const MuonSegment& seg2, const PrepVec* externalPhiHits ) const {
+ std::unique_ptr<Trk::Track> MooTrackBuilder::combine( const MuonSegment& seg1, const MuonSegment& seg2, const PrepVec* externalPhiHits ) const {
// convert segments
MuPatSegment* segInfo1 = m_candidateHandler->createSegInfo(seg1);
if( !segInfo1 ) return nullptr;
@@ -187,11 +173,11 @@ namespace Muon {
MuPatSegment* segInfo2 = m_candidateHandler->createSegInfo(seg2);
if( !segInfo2 ) {
delete segInfo1;
- return nullptr;
+ return std::unique_ptr<Trk::Track>();
}
// call fit()
- Trk::Track* track = combine(*segInfo1,*segInfo2,externalPhiHits);
+ std::unique_ptr<Trk::Track> track = combine(*segInfo1,*segInfo2,externalPhiHits);
delete segInfo1;
delete segInfo2;
@@ -202,7 +188,7 @@ namespace Muon {
MuonSegment* MooTrackBuilder::combineToSegment( const MuPatCandidateBase& firstCandidate, const MuPatCandidateBase& secondCandidate, const PrepVec* externalPhiHits ) const {
// try to get track
- Trk::Track* track = combine( firstCandidate, secondCandidate, externalPhiHits );
+ std::unique_ptr<Trk::Track> track = combine( firstCandidate, secondCandidate, externalPhiHits );
if( !track ) return nullptr;
@@ -212,21 +198,18 @@ namespace Muon {
ATH_MSG_WARNING( " conversion of track failed!! " );
}
- // delete track
- delete track;
-
return seg;
}
- Trk::Track* MooTrackBuilder::combine( const MuPatCandidateBase& firstCandidate, const MuPatCandidateBase& secondCandidate,
- const PrepVec* externalPhiHits ) const {
+ std::unique_ptr<Trk::Track> MooTrackBuilder::combine( const MuPatCandidateBase& firstCandidate, const MuPatCandidateBase& secondCandidate,
+ const PrepVec* externalPhiHits ) const {
++m_ncalls;
if (m_doTimeOutChecks && Athena::Timeout::instance().reached() ) {
ATH_MSG_DEBUG("Timeout reached. Aborting sequence." );
++m_nTimedOut;
- return nullptr;
+ return std::unique_ptr<Trk::Track>();
}
@@ -273,7 +256,7 @@ namespace Muon {
esit != candidate->excludedSegments().end(); ++esit ) {
if(*esit == segment) {
ATH_MSG_DEBUG(" Rejected segment based on exclusion list" );
- return nullptr;
+ return std::unique_ptr<Trk::Track>();
}
}
}
@@ -292,7 +275,6 @@ namespace Muon {
std::vector<MuPatSegment*>::const_iterator tsit_end = candidate->segments().end();
for( ;tsit != tsit_end;++tsit ) segments.insert(*tsit);
}
- //ATH_MSG_INFO(" Evaluating history, combination size " << segments.size() );
// now loop over the segments and check if any of them is associated with a track that contains all of the segments
std::set<const MuPatSegment*>::iterator sit = segments.begin();
std::set<const MuPatSegment*>::iterator sit_end = segments.end();
@@ -310,7 +292,6 @@ namespace Muon {
for( ;tsit != tsit_end ; ++ tsit ) {
if( segments.count(*tsit) ) foundSegments.insert(*tsit);
}
- //ATH_MSG_INFO(" Comparing segments with track: found segments " << foundSegments.size() );
// if all segments are already part of an existing track, don't perform the fit
if( foundSegments.size() == segments.size() ){
@@ -356,13 +337,11 @@ namespace Muon {
}
}
}
- //ATH_MSG_INFO(" Performing fit" );
}
// use slFitter for straight line fit, or toroid off, otherwise use normal Fitter
-
- if( slFit ) return m_slFitter->fit(firstCandidate,secondCandidate,externalPhiHits);
+ if( slFit ) return std::unique_ptr<Trk::Track>(m_slFitter->fit(firstCandidate,secondCandidate,externalPhiHits));
EventContext ctx = Gaudi::Hive::currentContext();
MagField::AtlasFieldCache fieldCache;
@@ -372,56 +351,48 @@ namespace Muon {
if (fieldCondObj == nullptr) {
ATH_MSG_ERROR("combine: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
- return nullptr;
+ return std::unique_ptr<Trk::Track>();
}
fieldCondObj->getInitializedCache (fieldCache);
- if( !fieldCache.toroidOn() ) return m_slFitter->fit(firstCandidate,secondCandidate,externalPhiHits);
+ if( !fieldCache.toroidOn() ) return std::unique_ptr<Trk::Track>(m_slFitter->fit(firstCandidate,secondCandidate,externalPhiHits));
return m_fitter->fit(firstCandidate,secondCandidate,externalPhiHits);
}
- Trk::Track* MooTrackBuilder::combine( const Trk::Track& track, const MuonSegment& seg,
+ std::unique_ptr<Trk::Track> MooTrackBuilder::combine( const Trk::Track& track, const MuonSegment& seg,
const PrepVec* externalPhiHits ) const {
// convert segments
- MuPatTrack* candidate = m_candidateHandler->createCandidate(new Trk::Track(track));
- if( !candidate ) return nullptr;
+ std::unique_ptr<Trk::Track> inTrack=std::make_unique<Trk::Track>(track);
+ std::unique_ptr<MuPatTrack> candidate(m_candidateHandler->createCandidate(inTrack));
+ if( !candidate ) return std::unique_ptr<Trk::Track>();
- MuPatSegment* segInfo = m_candidateHandler->createSegInfo(seg);
+ std::unique_ptr<MuPatSegment> segInfo(m_candidateHandler->createSegInfo(seg));
if( !segInfo ) {
- delete candidate;
- return nullptr;
+ return std::unique_ptr<Trk::Track>();
}
// call fit()
- Trk::Track* newTrack = combine(*candidate,*segInfo,externalPhiHits);
- delete candidate;
- delete segInfo;
+ std::unique_ptr<Trk::Track> newTrack = combine(*candidate,*segInfo,externalPhiHits);
// return result
return newTrack;
}
- std::vector<Trk::Track*>* MooTrackBuilder::combineWithSegmentFinding( const Trk::Track& track, const MuonSegment& seg,
- const PrepVec* externalPhiHits ) const {
+ std::vector<std::unique_ptr<Trk::Track> > MooTrackBuilder::combineWithSegmentFinding( const Trk::Track& track, const MuonSegment& seg,
+ const PrepVec* externalPhiHits ) const {
// convert segments
- MuPatTrack* candidate = m_candidateHandler->createCandidate(new Trk::Track(track));
- if( !candidate ) return nullptr;
+ std::vector<std::unique_ptr<Trk::Track> > emptyVec;
+ std::unique_ptr<Trk::Track> inTrack=std::make_unique<Trk::Track>(track);
+ std::unique_ptr<MuPatTrack> candidate = m_candidateHandler->createCandidate(inTrack);
+ if( !candidate ) return emptyVec;
- MuPatSegment* segInfo = m_candidateHandler->createSegInfo(seg);
- if( !segInfo ) {
- delete candidate;
- return nullptr;
- }
+ std::unique_ptr<MuPatSegment> segInfo(m_candidateHandler->createSegInfo(seg));
+ if( !segInfo ) return emptyVec;
// call fit()
- std::vector<Trk::Track*>* tracks = combineWithSegmentFinding(*candidate,*segInfo,externalPhiHits);
- delete candidate;
- delete segInfo;
-
- // return result
- return tracks;
+ return combineWithSegmentFinding(*candidate,*segInfo,externalPhiHits);
}
@@ -506,23 +477,24 @@ namespace Muon {
}
- std::vector<Trk::Track*>* MooTrackBuilder::combineWithSegmentFinding( const Trk::Track& track,
- const Trk::TrackParameters& pars,
- const std::set<Identifier>& chIds,
- const PrepVec* patternPhiHits ) const {
+ std::vector<std::unique_ptr<Trk::Track> > MooTrackBuilder::combineWithSegmentFinding( const Trk::Track& track,
+ const Trk::TrackParameters& pars,
+ const std::set<Identifier>& chIds,
+ const PrepVec* patternPhiHits ) const {
// convert track
- MuPatTrack* can = m_candidateHandler->createCandidate(new Trk::Track(track));
- if( !can ) return nullptr;
+ std::unique_ptr<Trk::Track> inTrack=std::make_unique<Trk::Track>(track);
+ std::unique_ptr<MuPatTrack> can = m_candidateHandler->createCandidate(inTrack);
+ if( !can ){
+ return std::vector<std::unique_ptr<Trk::Track> >();
+ }
- std::vector<Trk::Track*>* tracks = combineWithSegmentFinding(*can,pars,chIds,patternPhiHits);
- delete can;
- return tracks;
+ return combineWithSegmentFinding(*can,pars,chIds,patternPhiHits);
}
- std::vector<Trk::Track*>* MooTrackBuilder::combineWithSegmentFinding( const MuPatTrack& candidate,
- const MuPatSegment& segInfo,
- const PrepVec* externalPhiHits ) const {
+ std::vector<std::unique_ptr<Trk::Track> > MooTrackBuilder::combineWithSegmentFinding( const MuPatTrack& candidate,
+ const MuPatSegment& segInfo,
+ const PrepVec* externalPhiHits ) const {
/** second stage segment matching:
- estimate segment parameters at segment position using fit of track + segment position
@@ -531,23 +503,22 @@ namespace Muon {
*/
const MuonSegment& seg = *segInfo.segment;
+ std::vector<std::unique_ptr<Trk::Track> > newTracks;
// get chamber Id of segment
std::set<Identifier> chIds = m_edmHelperSvc->chamberIds(seg);
- if( chIds.empty() ) return nullptr;
+ if( chIds.empty() ) return newTracks;
// for now do not redo segment making for CSCs
if( m_idHelperSvc->isCsc( *chIds.begin() ) ){
if( m_candidateMatchingTool->match(candidate,segInfo,true) ) {
- Trk::Track* newtrack = m_fitter->fit(candidate,segInfo,externalPhiHits);
- if( !newtrack ) return nullptr;
- std::vector<Trk::Track*>* newTracks = new std::vector<Trk::Track*>;
- newTracks->push_back(newtrack);
+ std::unique_ptr<Trk::Track> newtrack(m_fitter->fit(candidate,segInfo,externalPhiHits));
+ if(newtrack) newTracks.push_back(std::move(newtrack));
return newTracks;
}else{
- return nullptr;
+ return newTracks;
}
}
@@ -556,33 +527,27 @@ namespace Muon {
ATH_MSG_VERBOSE(" segment " << m_printer->print(seg) );
// find track parameters on segment surface
- Trk::TrackParameters* closestPars = findClosestParameters(track,seg.globalPosition());
+ std::unique_ptr<Trk::TrackParameters> closestPars(findClosestParameters(track,seg.globalPosition()));
if( !closestPars ) {
ATH_MSG_WARNING( " unable to find closest TrackParameters " );
- return nullptr;
+ return newTracks;
}
ATH_MSG_VERBOSE(" closest parameter " << m_printer->print(*closestPars) );
// propagate to segment surface
- const Trk::TrackParameters* exPars = m_propagator->propagate(*closestPars,seg.associatedSurface(),Trk::anyDirection,
- false,m_magFieldProperties);
-
- // free memory
- delete closestPars;
+ std::unique_ptr<Trk::TrackParameters> exPars(m_propagator->propagate(*closestPars,seg.associatedSurface(),Trk::anyDirection,
+ false,m_magFieldProperties));
if( !exPars ) {
ATH_MSG_WARNING( " Propagation failed!! " );
- return nullptr;
+ return newTracks;
}
ATH_MSG_VERBOSE(" extrapolated parameter " << m_printer->print(*exPars) );
- std::vector<Trk::Track*>* tracks = combineWithSegmentFinding(candidate,*exPars,chIds,externalPhiHits);
- delete exPars;
-
- return tracks;
+ return combineWithSegmentFinding(candidate,*exPars,chIds,externalPhiHits);
}
@@ -649,16 +614,17 @@ namespace Muon {
}
- std::vector<Trk::Track*>* MooTrackBuilder::combineWithSegmentFinding( const MuPatTrack& candidate,
- const Trk::TrackParameters& pars,
- const std::set<Identifier>& chIds,
- const PrepVec* externalPhiHits ) const {
+ std::vector<std::unique_ptr<Trk::Track> > MooTrackBuilder::combineWithSegmentFinding( const MuPatTrack& candidate,
+ const Trk::TrackParameters& pars,
+ const std::set<Identifier>& chIds,
+ const PrepVec* externalPhiHits ) const {
+ std::vector<std::unique_ptr<Trk::Track> > newTracks;
- if( chIds.empty() ) return nullptr;
+ if( chIds.empty() ) return newTracks;
if( !m_idHelperSvc->isMdt(*chIds.begin()) ) {
ATH_MSG_WARNING("combineWithSegmentFinding called with CSC hits!! retuning zero pointer");
- return nullptr;
+ return newTracks;
}
// redo segment finding
@@ -667,11 +633,11 @@ namespace Muon {
// check whether we got segments
if( !segments ) {
ATH_MSG_DEBUG(" failed to find new segments " );
- return nullptr;
+ return newTracks;
}
if( segments->empty() ){
ATH_MSG_DEBUG(" got empty vector!! " );
- return nullptr;
+ return newTracks;
}
unsigned int nseg=segments->size();
@@ -689,11 +655,8 @@ namespace Muon {
<< nseg - segments->size() << " total " << segments->size() << endmsg;
}
- std::vector<Trk::Track*>* newTracks = 0;
if( !segments->empty() ){
- newTracks = new std::vector<Trk::Track*>;
-
// loop over segments
Trk::SegmentCollection::iterator sit = segments->begin();
Trk::SegmentCollection::iterator sit_end = segments->end();
@@ -721,33 +684,28 @@ namespace Muon {
continue;
}
- Trk::Track* segTrack = m_fitter->fit(candidate,*segInfo,externalPhiHits);
+ std::unique_ptr<Trk::Track> segTrack=m_fitter->fit(candidate,*segInfo,externalPhiHits);
delete segInfo;
if( !segTrack ) continue;
ATH_MSG_DEBUG(" found new track " << m_printer->print(*segTrack) );
- newTracks->push_back(segTrack);
+ newTracks.push_back(std::move(segTrack));
}
}
- if( !newTracks || newTracks->empty() ){
- delete newTracks;
- return nullptr;
- }
-
- ATH_MSG_DEBUG(" found new tracks for segment " << newTracks->size() );
+ if(!newTracks.empty()) ATH_MSG_DEBUG(" found new tracks for segment " << newTracks.size() );
return newTracks;
}
- Trk::Track* MooTrackBuilder::recalibrateHitsOnTrack( const Trk::Track& track, bool doMdts, bool doCompetingClusters ) const {
+ std::unique_ptr<Trk::Track> MooTrackBuilder::recalibrateHitsOnTrack( const Trk::Track& track, bool doMdts, bool doCompetingClusters ) const {
// loop over track and calculate residuals
const DataVector<const Trk::TrackStateOnSurface>* states = track.trackStateOnSurfaces();
if( !states ){
ATH_MSG_DEBUG(" track without states, discarding track " );
- return nullptr;
+ return std::unique_ptr<Trk::Track>();
}
if( msgLvl(MSG::DEBUG) ) {
msg(MSG::DEBUG) << MSG::DEBUG << " recalibrating hits on track " << std::endl
@@ -851,18 +809,9 @@ namespace Muon {
for( ;nit!=nit_end;++nit ){
// add states. If nit->first is true we have a new state. If it is false the state is from the old track and has to be cloned
trackStateOnSurfaces->push_back( nit->first ? nit->second : nit->second->clone() );
-
- // // check whether state is a measurement
- // const Trk::MeasurementBase* meas = (nit)->second->measurementOnTrack();
- // if( !meas ) {
- // continue;
- // }
-
- // Identifier id = m_edmHelperSvc->getIdentifier(*meas);
}
- Trk::Track* newTrack = new Trk::Track( track.info(), trackStateOnSurfaces, track.fitQuality() ? track.fitQuality()->clone():0 );
+ return std::make_unique<Trk::Track>( track.info(), trackStateOnSurfaces, track.fitQuality() ? track.fitQuality()->clone():0 );
- return newTrack;
}
@@ -1045,7 +994,7 @@ namespace Muon {
return --tsit;
}
- std::pair<Trk::Track*,Trk::Track*> MooTrackBuilder::splitTrack( const Trk::Track& track ) const {
+ std::pair<std::unique_ptr<Trk::Track>,std::unique_ptr<Trk::Track> > MooTrackBuilder::splitTrack( const Trk::Track& track ) const {
// use slFitter for straight line fit, or toroid off, otherwise use normal Fitter
@@ -1059,7 +1008,7 @@ namespace Muon {
if (fieldCondObj == nullptr) {
ATH_MSG_ERROR("splitTrack: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
- std::pair<Trk::Track*,Trk::Track*> emptyPair;
+ std::pair<std::unique_ptr<Trk::Track>,std::unique_ptr<Trk::Track> > emptyPair;
return emptyPair;
}
fieldCondObj->getInitializedCache (fieldCache);
@@ -1070,12 +1019,12 @@ namespace Muon {
}
- std::vector<MuPatTrack*>* MooTrackBuilder::find( MuPatCandidateBase& candidate, const std::vector<MuPatSegment*>& segVec ) const {
+ std::vector<std::unique_ptr<MuPatTrack> > MooTrackBuilder::find( MuPatCandidateBase& candidate, const std::vector<MuPatSegment*>& segVec ) const {
+ std::vector<std::unique_ptr<MuPatTrack> > candidates;
// check whether we have segments
- if( segVec.empty() ) return nullptr;
+ if( segVec.empty() ) return candidates;
- std::vector<MuPatTrack*>* candidates = new std::vector<MuPatTrack*>();
std::set<MuPatSegment*> usedSegments;
std::map<MuPatSegment*,MuPatSegment*> slSegments;
@@ -1087,7 +1036,7 @@ namespace Muon {
// store whether segment was added to at least one candidates
// vector to store candidate extensions
- std::vector< std::pair<MuPatSegment*,Trk::Track*> > extensions;
+ std::vector< std::pair<MuPatSegment*,std::unique_ptr<Trk::Track> > > extensions;
extensions.reserve( segVec.size() );
// loop over segments
@@ -1113,7 +1062,7 @@ namespace Muon {
ATH_MSG_VERBOSE("combining: " << m_printer->print(*(*sit)->segment) );
// try to combine track with segment
- Trk::Track* track = combine(candidate,**sit,0);
+ std::unique_ptr<Trk::Track> track = combine(candidate,**sit,0);
// additional check in case the candidate is a MuPatTrack
MuPatTrack* trkCan = dynamic_cast<MuPatTrack*>(&candidate);
@@ -1129,7 +1078,6 @@ namespace Muon {
SortTracksByHitNumber sortTracks;
if( !sortTracks(*track,trkCan->track()) ){
ATH_MSG_VERBOSE(" rejecting track as new segment results in worse fit" );
- delete track;
continue;
}
@@ -1162,7 +1110,6 @@ namespace Muon {
if( !hasAllLayers ) {
ATH_MSG_VERBOSE(" rejecting track as one of the chamber layers of the candidate was removed " );
- delete track;
continue;
}
}
@@ -1178,7 +1125,7 @@ namespace Muon {
// first check that segment is not an overlap segment
if( !(*sit)->hasSLOverlap() ){
- MuPatTrack* newCandidate = 0;
+ std::unique_ptr<MuPatTrack> newCandidate;
// loop over segments
std::vector<MuPatSegment*>::const_iterator sit1 = segVec.begin();
std::vector<MuPatSegment*>::const_iterator sit1_end = segVec.end();
@@ -1188,12 +1135,13 @@ namespace Muon {
if( (*sit)->chIndex == (*sit1)->chIndex ) continue;
if( !newCandidate ) {
+ std::unique_ptr<Trk::Track> trkTrkCan=std::make_unique<Trk::Track>(*track);
if( trkCan ){
// copy candidate and add segment
- newCandidate = new MuPatTrack(*trkCan);
- m_candidateHandler->extendWithSegment(*newCandidate,**sit,track);
+ newCandidate = std::make_unique<MuPatTrack>(*trkCan);
+ m_candidateHandler->extendWithSegment(*newCandidate,**sit,trkTrkCan);
}else if( segCan ){
- newCandidate = m_candidateHandler->createCandidate( *segCan,**sit,track );
+ newCandidate = m_candidateHandler->createCandidate( *segCan,**sit,trkTrkCan);
}
if( !newCandidate ) break;
}
@@ -1204,84 +1152,72 @@ namespace Muon {
continue;
}
ATH_MSG_VERBOSE("adding SL overlap " << m_printer->print(*(*sit1)->segment) );
- Trk::Track* slOverlapTrack = combine( *track, *(*sit1)->segment );
+ std::unique_ptr<Trk::Track> slOverlapTrack = combine( *track, *(*sit1)->segment );
if( !slOverlapTrack ) continue;
// is the new track better
SortTracksByHitNumber sortTracks;
if( !sortTracks(*slOverlapTrack,*track) ){
ATH_MSG_VERBOSE(" rejecting track as new segment results in worse fit" );
- delete slOverlapTrack;
+ slOverlapTrack.reset();
continue;
}
ATH_MSG_VERBOSE("adding SL overlap ok, new track" << m_printer->print(*slOverlapTrack) << std::endl << m_printer->printStations(*slOverlapTrack) );
- // delete candidate, this will also delete 'track'
- delete newCandidate;
- newCandidate = 0;
- track = slOverlapTrack;
+ track.swap(slOverlapTrack);
usedSegments.insert(*sit1);
slSegments[*sit] = *sit1;
break;
}
- if( newCandidate ){
- newCandidate->releaseTrack();
- delete newCandidate;
- }
}
ATH_MSG_VERBOSE(" Track found " << m_printer->print(*track) );
// add new solution
- extensions.push_back( std::make_pair(*sit,track) );
+ extensions.push_back( std::make_pair(*sit,std::move(track)) );
} // for (sit)
// loop over solutions and add them
if ( extensions.size() >= 1 ) {
- candidates->reserve(extensions.size());
+ candidates.reserve(extensions.size());
// additional check in case the candidate is a MuPatTrack
MuPatTrack* trkCan = dynamic_cast<MuPatTrack*>(&candidate);
MuPatSegment* segCan = dynamic_cast<MuPatSegment*>(&candidate);
- std::vector< std::pair<MuPatSegment*,Trk::Track*> >::iterator eit = extensions.begin();
+ std::vector< std::pair<MuPatSegment*,std::unique_ptr<Trk::Track> > >::iterator eit = extensions.begin();
// if more than 1 extensions are found, first add the copies
- std::vector< std::pair<MuPatSegment*,Trk::Track*> >::iterator eit_end = extensions.end();
+ std::vector< std::pair<MuPatSegment*,std::unique_ptr<Trk::Track> > >::iterator eit_end = extensions.end();
// start from the second one to make copies based on the existing candidates
for( ; eit!=eit_end; ++eit ){
- MuPatTrack* newCandidate = 0;
+ std::unique_ptr<MuPatTrack> newCandidate;
+ //std::unique_ptr<Trk::Track> inTrack=std::make_unique<Trk::Track>(*eit->second);
if( trkCan ){
// copy candidate and add segment
- newCandidate = new MuPatTrack(*trkCan);
+ newCandidate = std::make_unique<MuPatTrack>(*trkCan);
m_candidateHandler->extendWithSegment(*newCandidate,*eit->first,eit->second);
}else if( segCan ){
- newCandidate = m_candidateHandler->createCandidate( *segCan,*eit->first,eit->second );
+ newCandidate = m_candidateHandler->createCandidate( *segCan,*eit->first,eit->second);
}
ATH_MSG_DEBUG(" " << m_printer->print(*eit->first->segment) );
MuPatSegment* slOverlap = slSegments[eit->first];
if( slOverlap ){
ATH_MSG_DEBUG("SLOverlap " << m_printer->print(*slOverlap->segment) );
- // hack to allow me to add a second segment without copying the track
- // Coverity 13708 keep this 0 call with 0 pointer
- newCandidate->addSegment(slOverlap,0);
+ // hack to allow me to add a second segment without changing the track
+ std::unique_ptr<Trk::Track> nullTrack;
+ newCandidate->addSegment(slOverlap,nullTrack);
}
- candidates->push_back(newCandidate);
+ candidates.push_back(std::move(newCandidate));
if( msgLvl(MSG::DEBUG) ) {
- msg(MSG::DEBUG) << " creating new candidate " << newCandidate
- << std::endl << m_printer->print(newCandidate->track())
- << std::endl << m_printer->printStations(newCandidate->track()) << endmsg;
+ msg(MSG::DEBUG) << " creating new candidate " << candidates.back().get()
+ << std::endl << m_printer->print(candidates.back()->track())
+ << std::endl << m_printer->printStations(candidates.back()->track()) << endmsg;
}
- } // for( ; eit!=eit_end; ++eit )
- }else{
- //ATH_MSG_INFO("Failed extension" );
- }
- if( candidates->empty() ) {
- delete candidates;
- candidates = 0;
+ }
}
return candidates;
}
@@ -1406,10 +1342,8 @@ namespace Muon {
}
double dist = distAlongPars( *parsRef, *parsOther );
- //std::cout << " distance between pars " << dist << std::endl;
if( dist > 0. ){
- //std::cout << " moving reference " << m_printer->print(*(*refTSOS)->trackParameters()) << std::endl;
prevDist = dist;
prevPars = parsRef;
++refTSOS;
@@ -1418,7 +1352,6 @@ namespace Muon {
const Trk::TrackParameters* closestPars = 0;
if( prevPars && fabs(prevDist) < fabs(dist) ){
- //std::cout << " using previous parameters " << std::endl;
closestPars = prevPars;
}else{
closestPars = parsRef;
@@ -1472,7 +1405,6 @@ namespace Muon {
double halfTubeLen = 0.5*mdt->detectorElement()->getActiveTubeLength(layer,tube);
if( msgLvl(MSG::VERBOSE) ) msg(MSG::VERBOSE) << " range " << halfTubeLen;
}
- //tol1 = 0;
}
inBounds = meas->associatedSurface().insideBounds(locPos,tol1,tol2);
if( msgLvl(MSG::VERBOSE) ){
@@ -1498,7 +1430,6 @@ namespace Muon {
}
- //std::cout << " moving other forward " << std::endl;
prevDist = dist;
prevPars = parsRef;
++otherTSOS;
@@ -1515,7 +1446,7 @@ namespace Muon {
TrackCollection* MooTrackBuilder::mergeSplitTracks( const TrackCollection& tracks ) const {
// vector to store good track, boolean is used to identify whether the track was created in this routine or is from the collection
- std::vector< std::pair<bool,const Trk::Track*> > goodTracks;
+ std::vector< std::pair<bool,std::unique_ptr<Trk::Track> > > goodTracks;
goodTracks.reserve(tracks.size());
bool foundSplitTracks = false;
@@ -1527,23 +1458,23 @@ namespace Muon {
for( ;tit!=tit_end;++tit ){
// pointer to merged track
- Trk::Track* mergedTrack = 0;
+ std::unique_ptr<Trk::Track> mergedTrack;
// compare them to all good tracks and look for split tracks
- std::vector< std::pair<bool,const Trk::Track*> >::iterator git = goodTracks.begin();
- std::vector< std::pair<bool,const Trk::Track*> >::iterator git_end = goodTracks.end();
+ std::vector< std::pair<bool,std::unique_ptr<Trk::Track> > >::iterator git = goodTracks.begin();
+ std::vector< std::pair<bool,std::unique_ptr<Trk::Track> > >::iterator git_end = goodTracks.end();
for( ;git!=git_end;++git ){
// check whether track is split
bool isSplit = isSplitTrack( *git->second, **tit );
if( isSplit ){
// if we found a potential split track, try to combine them
- MuPatTrack* can1 = m_candidateHandler->createCandidate(new Trk::Track(*git->second));
- MuPatTrack* can2 = m_candidateHandler->createCandidate(new Trk::Track(**tit));
+ std::unique_ptr<Trk::Track> track1=std::make_unique<Trk::Track>(*git->second);
+ std::unique_ptr<Trk::Track> track2=std::make_unique<Trk::Track>(**tit);
+ std::unique_ptr<MuPatTrack> can1 = m_candidateHandler->createCandidate(track1);
+ std::unique_ptr<MuPatTrack> can2 = m_candidateHandler->createCandidate(track2);
mergedTrack = combine(*can1,*can2);
- delete can1;
- delete can2;
// we have found a split track and have successfully merged it
// replace the track in goodTracks with the new one
@@ -1555,12 +1486,8 @@ namespace Muon {
<< m_printer->print(*mergedTrack) << std::endl << m_printer->printStations(*mergedTrack) );
foundSplitTracks = true;
// check whether this is a new track, if so delete the old one before overwriting it
- if( git->first ) {
- ATH_MSG_VERBOSE(" input track already result of a merge, deleting it" );
- delete git->second;
- }
git->first = true;
- git->second = mergedTrack;
+ git->second.swap(mergedTrack);
break;
}else{
ATH_MSG_VERBOSE(" failed to merge tracks " << std::endl
@@ -1572,7 +1499,8 @@ namespace Muon {
// if this track was not merged with another track insert it into goodTracks
if( !mergedTrack ){
- goodTracks.push_back( std::make_pair(false,*tit) );
+ std::unique_ptr<Trk::Track> newTrack=std::make_unique<Trk::Track>(**tit);
+ goodTracks.push_back( std::make_pair(false,std::move(newTrack)) );
}
}
@@ -1581,17 +1509,11 @@ namespace Muon {
// loop over the new track vector and create a new TrackCollection
TrackCollection* newTracks = new TrackCollection();
newTracks->reserve(goodTracks.size());
- std::vector< std::pair<bool,const Trk::Track*> >::iterator git = goodTracks.begin();
- std::vector< std::pair<bool,const Trk::Track*> >::iterator git_end = goodTracks.end();
+ std::vector< std::pair<bool,std::unique_ptr<Trk::Track> > >::iterator git = goodTracks.begin();
+ std::vector< std::pair<bool,std::unique_ptr<Trk::Track> > >::iterator git_end = goodTracks.end();
for( ;git!=git_end;++git ){
- // check whether we are dealing with a newly created track
- if( git->first ) {
- // cast away constness before inserting track
- Trk::Track* theTrack = const_cast<Trk::Track*>(git->second);
- newTracks->push_back(theTrack);
- }else{
- newTracks->push_back( new Trk::Track(*git->second));
- }
+ //TrackCollection will take ownership
+ newTracks->push_back(std::move(git->second));
}
return newTracks;
}
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackBuilder.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackBuilder.h
index e8510f4add42..cb0243f379c6 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackBuilder.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackBuilder.h
@@ -106,7 +106,7 @@ namespace Muon {
@param track the track
@return a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.
*/
- virtual Trk::Track* refit( Trk::Track& track ) const override;
+ virtual std::unique_ptr<Trk::Track> refit( Trk::Track& track ) const override;
/** @brief combine two MCTBCandidateEntries
@param firstEntry the first entry
@@ -114,7 +114,7 @@ namespace Muon {
@param externalPhiHits if provided, the external phi hits will be used instead of the phi hits on the segment
@return a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.
*/
- Trk::Track* combine( const MuPatCandidateBase& firstEntry, const MuPatCandidateBase& secondEntry,
+ std::unique_ptr<Trk::Track> combine( const MuPatCandidateBase& firstEntry, const MuPatCandidateBase& secondEntry,
const PrepVec* patternPhiHits = 0 ) const;
/** @brief combine two MCTBCandidateEntries
@@ -141,7 +141,7 @@ namespace Muon {
@param externalPhiHits if provided, the external phi hits will be used instead of the phi hits on the segment
@return a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.
*/
- virtual Trk::Track* combine( const MuonSegment& seg1, const MuonSegment& seg2,
+ virtual std::unique_ptr<Trk::Track> combine( const MuonSegment& seg1, const MuonSegment& seg2,
const PrepVec* patternPhiHits = 0 ) const override;
/** @brief combine a track with a segment
@@ -150,25 +150,25 @@ namespace Muon {
@param externalPhiHits if provided, the external phi hits will be used instead of the phi hits on the segment
@return a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.
*/
- virtual Trk::Track* combine( const Trk::Track& track, const MuonSegment& seg,
- const PrepVec* patternPhiHits = 0 ) const override;
+ virtual std::unique_ptr<Trk::Track> combine( const Trk::Track& track, const MuonSegment& seg,
+ const PrepVec* patternPhiHits = 0 ) const override;
/** @brief find tracks by redoing the segment finding in the chamber of the segment
@param track a reference to a Track
@param seg a reference to a MuonSegment
@return a pointer to vector of tracks, the ownership of the vector and the tracks is passed to the client calling the tool.
*/
- std::vector<Trk::Track*>* combineWithSegmentFinding( const Trk::Track& track, const MuonSegment& seg,
- const PrepVec* patternPhiHits = 0 ) const;
+ std::vector<std::unique_ptr<Trk::Track> > combineWithSegmentFinding( const Trk::Track& track, const MuonSegment& seg,
+ const PrepVec* patternPhiHits = 0 ) const;
/** @brief find tracks by redoing the segment finding in the chamber of the segment
@param candidate a reference to a MuPatTrack
@param segInfo a reference to a MuPatSegment
@return a pointer to vector of tracks, the ownership of the vector and the tracks is passed to the client calling the tool.
*/
- std::vector<Trk::Track*>* combineWithSegmentFinding( const MuPatTrack& candidate,
- const MuPatSegment& segInfo,
- const PrepVec* patternPhiHits = 0 ) const;
+ std::vector<std::unique_ptr<Trk::Track> > combineWithSegmentFinding( const MuPatTrack& candidate,
+ const MuPatSegment& segInfo,
+ const PrepVec* patternPhiHits = 0 ) const;
/** @brief find tracks by redoing the segment finding in the chamber of the segment
@@ -177,10 +177,10 @@ namespace Muon {
@param chIds identifiers of the chambers in which the search should be performed (should be in same station layer)
@return a pointer to vector of tracks, the ownership of the vector and the tracks is passed to the client calling the tool.
*/
- std::vector<Trk::Track*>* combineWithSegmentFinding( const MuPatTrack& candidate,
- const Trk::TrackParameters& pars,
- const std::set<Identifier>& chIds,
- const PrepVec* patternPhiHits = 0 ) const;
+ std::vector<std::unique_ptr<Trk::Track> > combineWithSegmentFinding( const MuPatTrack& candidate,
+ const Trk::TrackParameters& pars,
+ const std::set<Identifier>& chIds,
+ const PrepVec* patternPhiHits = 0 ) const;
/** @brief find tracks by redoing the segment finding in the chamber of the segment
@param track a reference to a Track
@@ -188,10 +188,10 @@ namespace Muon {
@param chIds identifiers of the chambers in which the search should be performed (should be in same station layer)
@return a pointer to vector of tracks, the ownership of the vector and the tracks is passed to the client calling the tool.
*/
- std::vector<Trk::Track*>* combineWithSegmentFinding( const Trk::Track& track,
- const Trk::TrackParameters& pars,
- const std::set<Identifier>& chIds,
- const PrepVec* patternPhiHits = 0 ) const;
+ std::vector<std::unique_ptr<Trk::Track> > combineWithSegmentFinding( const Trk::Track& track,
+ const Trk::TrackParameters& pars,
+ const std::set<Identifier>& chIds,
+ const PrepVec* patternPhiHits = 0 ) const;
/** @brief find closest TrackParameters to the position. Closest is defined as closest in z in the endcap and
closest in r in the barrel.
@@ -218,12 +218,12 @@ namespace Muon {
/** recalibrate hits on track */
- virtual Trk::Track* recalibrateHitsOnTrack( const Trk::Track& track, bool doMdts, bool doCompetingClusters ) const override;
+ virtual std::unique_ptr<Trk::Track> recalibrateHitsOnTrack( const Trk::Track& track, bool doMdts, bool doCompetingClusters ) const override;
/** split given track if it crosses the calorimeter volume, code assumes that the track was already extrapolated to the
muon entry record using the MuonTrackExtrapolationTool. It uses the double perigee to spot the tracks to be split.
*/
- std::pair<Trk::Track*,Trk::Track*> splitTrack( const Trk::Track& track ) const;
+ std::pair<std::unique_ptr<Trk::Track>,std::unique_ptr<Trk::Track> > splitTrack( const Trk::Track& track ) const;
/** @brief identify whether two track are split */
bool isSplitTrack( const Trk::Track& track1, const Trk::Track& track2 ) const;
@@ -238,13 +238,13 @@ namespace Muon {
The ownership of the tracks is passed to the client calling the tool.
*/
- virtual std::vector<MuPatTrack*>* find( MuPatCandidateBase& candidate, const std::vector<MuPatSegment*>& segments ) const override;
+ virtual std::vector<std::unique_ptr<MuPatTrack> > find( MuPatCandidateBase& candidate, const std::vector<MuPatSegment*>& segments ) const override;
/** @brief interface for tools which refine the hit content of a given track
@param track input track
@return new refined track. Pointer could be zero, ownership passed to caller
*/
- virtual MuPatTrack* refine( MuPatTrack& track ) const override;
+ virtual void refine( MuPatTrack& track ) const override;
private:
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackFitter.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackFitter.cxx
index 1aeb506fc9ac..7312cbb6cafc 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackFitter.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackFitter.cxx
@@ -130,7 +130,7 @@ namespace Muon {
}
- Trk::Track* MooTrackFitter::refit( const MuPatTrack& trkCan ) const {
+ std::unique_ptr<Trk::Track> MooTrackFitter::refit( const MuPatTrack& trkCan ) const {
GarbageCan localGarbage;
@@ -141,24 +141,20 @@ namespace Muon {
fitterData.hitList = trkCan.hitList();
// extract hits from hit list and add them to fitterData
- if( !extractData( fitterData, true ) ) return 0;
+ if( !extractData( fitterData, true ) ) return std::unique_ptr<Trk::Track>();
// create start parameters
const Trk::Perigee* pp = trkCan.track().perigeeParameters();
- if( !pp ) return 0;
+ if( !pp ) return std::unique_ptr<Trk::Track>();
// fit track
- Trk::Track* track = fit(*pp,fitterData.measurements,localGarbage);
+ std::unique_ptr<Trk::Track> track = fit(*pp,fitterData.measurements,localGarbage);
if( track ){
// clean and evaluate track
std::set<Identifier> excludedChambers;
std::unique_ptr<Trk::Track> cleanTrack = cleanAndEvaluateTrack( *track, excludedChambers );
- if( cleanTrack && !(*cleanTrack->perigeeParameters() == *track->perigeeParameters()) ){
- delete track;
- //using release until the entire code can be migrated to use smart pointers
- track = cleanTrack.release();
- }
+ if( cleanTrack && !(*cleanTrack->perigeeParameters() == *track->perigeeParameters()) ) track.swap(cleanTrack);
}else{
ATH_MSG_DEBUG(" Fit failed " );
}
@@ -169,7 +165,7 @@ namespace Muon {
}
- Trk::Track* MooTrackFitter::refit( const Trk::Track& track ) const {
+ std::unique_ptr<Trk::Track> MooTrackFitter::refit( const Trk::Track& track ) const {
if ( msgLvl(MSG::DEBUG) ) {
const DataVector<const Trk::TrackStateOnSurface>* states = track.trackStateOnSurfaces();
@@ -182,7 +178,7 @@ namespace Muon {
msg(MSG::DEBUG) << endmsg;
}
// fit track
- Trk::Track* newTrack = m_trackFitter->fit(track,false,m_ParticleHypothesis);
+ std::unique_ptr<Trk::Track> newTrack(m_trackFitter->fit(track,false,m_ParticleHypothesis));
if( newTrack ){
@@ -192,15 +188,10 @@ namespace Muon {
if( cleanTrack ){
// check whether cleaner returned same track, if not delete old track
- if( !(*cleanTrack->perigeeParameters() == *newTrack->perigeeParameters()) ){
- delete newTrack;
- //using release until the entire code can be migrated to use smart pointers
- newTrack = cleanTrack.release();
- }
+ if( !(*cleanTrack->perigeeParameters() == *newTrack->perigeeParameters()) ) newTrack.swap(cleanTrack);
}else{
ATH_MSG_DEBUG(" Refit failed, rejected by cleaner " );
- delete newTrack;
- newTrack = 0;
+ newTrack.reset();
}
}else{
ATH_MSG_DEBUG(" Refit failed " );
@@ -210,7 +201,7 @@ namespace Muon {
}
- Trk::Track* MooTrackFitter::fit( const MuPatCandidateBase& entry1, const MuPatCandidateBase& entry2, const PrepVec* externalPhiHits ) const {
+ std::unique_ptr<Trk::Track> MooTrackFitter::fit( const MuPatCandidateBase& entry1, const MuPatCandidateBase& entry2, const PrepVec* externalPhiHits ) const {
GarbageCan localGarbage;
@@ -223,7 +214,7 @@ namespace Muon {
if( !extractData(entry1,entry2,fitterData, localGarbage) ) {
ATH_MSG_DEBUG(" Failed to extract data for initial fit" );
localGarbage.cleanUp();
- return 0;
+ return std::unique_ptr<Trk::Track>();
}
++m_nfailedExtractInital;
@@ -231,7 +222,7 @@ namespace Muon {
if( !m_cosmics && !getMinMaxPhi( fitterData ) ) {
ATH_MSG_DEBUG(" Phi range check failed, candidate stations not pointing. Will not fit track" );
localGarbage.cleanUp();
- return 0;
+ return std::unique_ptr<Trk::Track>();
}
++m_nfailedMinMaxPhi;
@@ -242,7 +233,7 @@ namespace Muon {
if( !startPars ) {
ATH_MSG_DEBUG(" Creation of start parameters failed " );
localGarbage.cleanUp();
- return 0;
+ return std::unique_ptr<Trk::Track>();
}
++m_nfailedParsInital;
@@ -254,7 +245,7 @@ namespace Muon {
if( !extractData( fitterData, usePrecise ) ) {
ATH_MSG_DEBUG(" Failed to extract data after phi hit cleaning" );
localGarbage.cleanUp();
- return 0;
+ return std::unique_ptr<Trk::Track>();
}
}
++m_nfailedExtractCleaning;
@@ -263,7 +254,7 @@ namespace Muon {
if( !addFakePhiHits(fitterData,startPars,localGarbage) ) {
ATH_MSG_DEBUG(" Failed to add fake phi hits for precise fit" );
localGarbage.cleanUp();
- return 0;
+ return std::unique_ptr<Trk::Track>();
}
++m_nfailedFakeInitial;
@@ -274,13 +265,13 @@ namespace Muon {
if( fitterData.firstHasMomentum || fitterData.secondHasMomentum ) doPreFit = false;
if( !doPreFit ) particleType = Trk::muon;
- Trk::Track* track = fit(*startPars,fitterData.measurements,localGarbage,particleType,doPreFit);
+ std::unique_ptr<Trk::Track> track = fit(*startPars,fitterData.measurements,localGarbage,particleType,doPreFit);
if( !track ) {
ATH_MSG_DEBUG(" Fit failed " );
localGarbage.cleanUp();
- return 0;
+ return std::unique_ptr<Trk::Track>();
}
++m_nfailedTubeFit;
@@ -288,17 +279,15 @@ namespace Muon {
const Trk::Perigee* pp = track->perigeeParameters();
if( !pp ) {
ATH_MSG_DEBUG(" Track without perigee parameters, exit " );
- delete track;
localGarbage.cleanUp();
- return 0;
+ return std::unique_ptr<Trk::Track>();
}
++m_noPerigee;
if( !m_slFit && !validMomentum( *pp ) ){
ATH_MSG_DEBUG(" Low momentum, rejected " );
- delete track;
localGarbage.cleanUp();
- return 0;
+ return std::unique_ptr<Trk::Track>();
}
++m_nlowMomentum;
@@ -323,9 +312,8 @@ namespace Muon {
// extract hits from hit list and add them to fitterData
if( !extractData( fitterDataRefit, true ) ) {
ATH_MSG_DEBUG(" Failed to extract data for precise fit" );
- delete track;
localGarbage.cleanUp();
- return 0;
+ return std::unique_ptr<Trk::Track>();
}
++m_nfailedExtractPrecise;
@@ -333,21 +321,17 @@ namespace Muon {
if( !addFakePhiHits(fitterDataRefit,startPars,localGarbage) ) {
ATH_MSG_DEBUG(" Failed to add fake phi hits for precise fit" );
localGarbage.cleanUp();
- delete track;
- return 0;
+ return std::unique_ptr<Trk::Track>();
}
++m_nfailedFakePrecise;
// fit track
- Trk::Track* newTrack = fit(*pp,fitterDataRefit.measurements,localGarbage);
- if( newTrack ){
- delete track;
- track = newTrack;
- }else if( !m_allowFirstFit ){
+ std::unique_ptr<Trk::Track> newTrack = fit(*pp,fitterDataRefit.measurements,localGarbage);
+ if( newTrack ) track.swap(newTrack);
+ else if( !m_allowFirstFit ){
ATH_MSG_DEBUG(" Precise fit failed " );
- delete track;
localGarbage.cleanUp();
- return 0;
+ return std::unique_ptr<Trk::Track>();
}else{
ATH_MSG_DEBUG(" Precise fit failed, keep fit with broad errors" );
}
@@ -369,20 +353,9 @@ namespace Muon {
}
std::unique_ptr<Trk::Track> cleanTrack = cleanAndEvaluateTrack( *track, excludedChambers );
if( cleanTrack ) {
- if( !(*cleanTrack->perigeeParameters() == *track->perigeeParameters()) ){
- delete track;
- //using release until the entire code can be migrated to use smart pointers
- track = cleanTrack.release();
-
- }
- }else {
- delete track;
- track = 0;
+ if( !(*cleanTrack->perigeeParameters() == *track->perigeeParameters()) ) track.swap(cleanTrack);
}
-
-
- }else{
-// ATH_MSG_DEBUG(" Refit failed " );
+ else track.reset();
}
if( track ) ++m_nsuccess;
@@ -1202,24 +1175,24 @@ namespace Muon {
return nphiConstraints;
}
- unsigned int MooTrackFitter::hasPhiConstrain( const Trk::Track& track ) const {
+ unsigned int MooTrackFitter::hasPhiConstrain( Trk::Track* track ) const {
std::map<MuonStationIndex::StIndex,StationPhiData> stationDataMap;
// Get a MuonTrackSummary.
- const Trk::TrackSummary* summary = track.trackSummary();
+ const Trk::TrackSummary* summary = track->trackSummary();
Trk::MuonTrackSummary muonSummary;
if( summary ){
if( summary->muonTrackSummary() ) {
muonSummary = *summary->muonTrackSummary();
} else {
Trk::TrackSummary tmpSum(*summary);
- m_trackSummaryTool->addDetailedTrackSummary(track,tmpSum);
+ m_trackSummaryTool->addDetailedTrackSummary(*track,tmpSum);
if( tmpSum.muonTrackSummary() ) muonSummary = *(tmpSum.muonTrackSummary());
}
}else{
Trk::TrackSummary tmpSummary;
- m_trackSummaryTool->addDetailedTrackSummary(track,tmpSummary);
+ m_trackSummaryTool->addDetailedTrackSummary(*track,tmpSummary);
if( tmpSummary.muonTrackSummary() ) muonSummary = *(tmpSummary.muonTrackSummary());
}
@@ -1854,10 +1827,10 @@ namespace Muon {
- Trk::Track* MooTrackFitter::fit( const Trk::Perigee& startPars, MooTrackFitter::MeasVec& hits, GarbageCan& garbage,
+ std::unique_ptr<Trk::Track> MooTrackFitter::fit( const Trk::Perigee& startPars, MooTrackFitter::MeasVec& hits, GarbageCan& garbage,
Trk::ParticleHypothesis partHypo, bool prefit ) const {
- if( hits.empty() ) return 0;
+ if( hits.empty() ) return std::unique_ptr<Trk::Track>();
if( msgLvl(MSG::VERBOSE) ) {
@@ -1883,7 +1856,7 @@ namespace Muon {
pars = perigee;
}else{
ATH_MSG_DEBUG(" failed to move start pars, failing fit " );
- return 0;
+ return std::unique_ptr<Trk::Track>();
}
}
}
@@ -1896,20 +1869,20 @@ namespace Muon {
}
msg(MSG::DEBUG) << endmsg;
}
- Trk::Track* track = prefit ?
- m_trackFitterPrefit->fit(hits,*pars,m_runOutlier,partHypo) :
- m_trackFitter->fit(hits,*pars,m_runOutlier,partHypo);
+ std::unique_ptr<Trk::Track> track = prefit ?
+ std::unique_ptr<Trk::Track>(m_trackFitterPrefit->fit(hits,*pars,m_runOutlier,partHypo)) :
+ std::unique_ptr<Trk::Track>(m_trackFitter->fit(hits,*pars,m_runOutlier,partHypo));
// 'sign' track
if( track ) track->info().setPatternRecognitionInfo(m_patRecInfo);
return track;
}
- Trk::Track* MooTrackFitter::fitWithRefit( const Trk::Perigee& startPars, MooTrackFitter::MeasVec& hits ) const {
+ std::unique_ptr<Trk::Track> MooTrackFitter::fitWithRefit( const Trk::Perigee& startPars, MooTrackFitter::MeasVec& hits ) const {
GarbageCan localGarbage;
- Trk::Track* track = fit(startPars,hits,localGarbage);
+ std::unique_ptr<Trk::Track> track = fit(startPars,hits,localGarbage);
// exceptions that are not refitted
if( m_slFit ) return track;
@@ -1932,10 +1905,9 @@ namespace Muon {
}
msg(MSG::DEBUG) << endmsg;
}
- Trk::Track* refittedTrack = m_trackFitter->fit(hits,*pp,false,m_ParticleHypothesis);
+ std::unique_ptr<Trk::Track> refittedTrack(m_trackFitter->fit(hits,*pp,false,m_ParticleHypothesis));
if( refittedTrack ){
- delete track;
- track = refittedTrack;
+ track.swap(refittedTrack);
if( msgLvl(MSG::DEBUG) ) {
const Trk::Perigee* pp = track->perigeeParameters();
@@ -2324,13 +2296,13 @@ namespace Muon {
}
}
- std::pair<Trk::Track*,Trk::Track*> MooTrackFitter::splitTrack( const Trk::Track& track ) const {
+ std::pair<std::unique_ptr<Trk::Track>,std::unique_ptr<Trk::Track> > MooTrackFitter::splitTrack( const Trk::Track& track ) const {
GarbageCan localGarbage;
// access TSOS of track
const DataVector<const Trk::TrackStateOnSurface>* oldTSOT = track.trackStateOnSurfaces();
- if( !oldTSOT ) return std::make_pair<Trk::Track*,Trk::Track*>(0,0);
+ if( !oldTSOT ) return std::make_pair<std::unique_ptr<Trk::Track>,std::unique_ptr<Trk::Track> >(nullptr,nullptr);
// check whether the perigee is expressed at the point of closes approach or at muon entry
@@ -2339,7 +2311,7 @@ namespace Muon {
bool atIP = fabs(perigee->position().dot(perigee->momentum().unit())) < 10 ? true : false;
if( atIP ){
ATH_MSG_DEBUG(" track extressed at perigee, cannot split it " );
- return std::make_pair<Trk::Track*,Trk::Track*>(0,0);
+ return std::make_pair<std::unique_ptr<Trk::Track>,std::unique_ptr<Trk::Track> >(nullptr,nullptr);
}
}
@@ -2354,14 +2326,14 @@ namespace Muon {
}
if( nperigees != 2 ) {
ATH_MSG_DEBUG(" Number of perigees is not one, cannot split it " << nperigees );
- return std::make_pair<Trk::Track*,Trk::Track*>(0,0);
+ return std::make_pair<std::unique_ptr<Trk::Track>,std::unique_ptr<Trk::Track> >(nullptr,nullptr);
}
struct TrackContent {
- TrackContent() : firstParameters(0),tsos(0),track(0) {}
+ TrackContent() : firstParameters(nullptr),tsos(),track() {}
const Trk::TrackParameters* firstParameters;
std::vector<const Trk::TrackStateOnSurface*> tsos;
- Trk::Track* track;
+ std::unique_ptr<Trk::Track> track;
std::set<MuonStationIndex::StIndex> stations;
};
@@ -2480,8 +2452,7 @@ namespace Muon {
ATH_MSG_DEBUG(" failed to fit second track " );
// delete first track
- delete firstTrack.track;
- firstTrack.track = 0;
+ firstTrack.track.reset();
}
}else{
ATH_MSG_DEBUG(" failed to fit first track " );
@@ -2491,10 +2462,10 @@ namespace Muon {
localGarbage.cleanUp();
- return std::make_pair(firstTrack.track,secondTrack.track);
+ return std::make_pair<std::unique_ptr<Trk::Track>,std::unique_ptr<Trk::Track> >(std::move(firstTrack.track),std::move(secondTrack.track));
}
- Trk::Track* MooTrackFitter::fitSplitTrack( const Trk::TrackParameters& startPars, const std::vector<const Trk::TrackStateOnSurface*>& tsos, GarbageCan& garbage ) const {
+ std::unique_ptr<Trk::Track> MooTrackFitter::fitSplitTrack( const Trk::TrackParameters& startPars, const std::vector<const Trk::TrackStateOnSurface*>& tsos, GarbageCan& garbage ) const {
// first create track out of the constituent
double phi=startPars.momentum().phi();
@@ -2513,9 +2484,9 @@ namespace Muon {
for( ;tit!=tit_end;++tit ) trackStateOnSurfaces->push_back( (*tit)->clone() );
Trk::TrackInfo trackInfo(Trk::TrackInfo::Unknown,Trk::muon);
- Trk::Track* track = new Trk::Track( trackInfo, trackStateOnSurfaces, 0);
+ std::unique_ptr<Trk::Track> track = std::make_unique<Trk::Track>( trackInfo, trackStateOnSurfaces, nullptr);
- unsigned int nphi = hasPhiConstrain(*track);
+ unsigned int nphi = hasPhiConstrain(track.get());
if( nphi > 1 ){
ATH_MSG_DEBUG("Track has sufficient phi constraints, fitting " );
@@ -2586,7 +2557,6 @@ namespace Muon {
}
// clean up previous track and create new one with fake hits
- delete track;
perigee = new Trk::Perigee(0,0,phi,theta,qoverp,persurf);
trackStateOnSurfaces = new DataVector<const Trk::TrackStateOnSurface>();
trackStateOnSurfaces->reserve(tsos.size()+3);
@@ -2645,12 +2615,11 @@ namespace Muon {
}
Trk::TrackInfo trackInfo(Trk::TrackInfo::Unknown,Trk::muon);
- track = new Trk::Track( trackInfo, trackStateOnSurfaces, 0);
+ track.reset(new Trk::Track( trackInfo, trackStateOnSurfaces, 0));
}
// refit track
- Trk::Track* refittedTrack = refit(*track);
- delete track;
+ std::unique_ptr<Trk::Track> refittedTrack = refit(*track);
if( refittedTrack ) refittedTrack->info().setPatternRecognitionInfo(m_patRecInfo);
return refittedTrack;
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackFitter.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackFitter.h
index 0771b8c6867a..70edaf1e8d52 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackFitter.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MooTrackFitter.h
@@ -183,13 +183,13 @@ namespace Muon {
@param externalPhiHits if provided, the external phi hits will be used instead of the phi hits on the segment
@return a pointer to the resulting track, will return zero if the fit failed.
*/
- Trk::Track* fit( const MuPatCandidateBase& firstEntry, const MuPatCandidateBase& secondEntry, const PrepVec* externalPhiHits ) const;
+ std::unique_ptr<Trk::Track> fit( const MuPatCandidateBase& firstEntry, const MuPatCandidateBase& secondEntry, const PrepVec* externalPhiHits ) const;
/** refit a MuPatTrack */
- Trk::Track* refit( const MuPatTrack& trkCan ) const;
+ std::unique_ptr<Trk::Track> refit( const MuPatTrack& trkCan ) const;
/** refit a track */
- Trk::Track* refit( const Trk::Track& track ) const;
+ std::unique_ptr<Trk::Track> refit( const Trk::Track& track ) const;
/** impose upper and lower bound on momentum */
double restrictedMomentum( double momentum ) const;
@@ -198,18 +198,18 @@ namespace Muon {
Trk::Perigee* createPerigee( const Trk::TrackParameters& firstPars, const Trk::MeasurementBase& firstMeas ) const;
/** fit track */
- Trk::Track* fit( const Trk::Perigee& startPars, MeasVec& hits, GarbageCan& garbage, Trk::ParticleHypothesis partHypo = Trk::muon, bool prefit = false ) const;
+ std::unique_ptr<Trk::Track> fit( const Trk::Perigee& startPars, MeasVec& hits, GarbageCan& garbage, Trk::ParticleHypothesis partHypo = Trk::muon, bool prefit = false ) const;
/** fit track, refit if needed */
- Trk::Track* fitWithRefit( const Trk::Perigee& startPars, MeasVec& hits ) const;
+ std::unique_ptr<Trk::Track> fitWithRefit( const Trk::Perigee& startPars, MeasVec& hits ) const;
/** split given track if it crosses the calorimeter volume, code assumes that the track was already extrapolated to the
muon entry record using the MuonTrackExtrapolationTool. It uses the double perigee to spot the tracks to be split.
*/
- std::pair<Trk::Track*,Trk::Track*> splitTrack( const Trk::Track& track ) const;
+ std::pair<std::unique_ptr<Trk::Track>,std::unique_ptr<Trk::Track> > splitTrack( const Trk::Track& track ) const;
/** construct a track from a list of TSOS and a start parameters */
- Trk::Track* fitSplitTrack( const Trk::TrackParameters& startPars, const std::vector<const Trk::TrackStateOnSurface*>& tsos, GarbageCan& garbage ) const;
+ std::unique_ptr<Trk::Track> fitSplitTrack( const Trk::TrackParameters& startPars, const std::vector<const Trk::TrackStateOnSurface*>& tsos, GarbageCan& garbage ) const;
private:
/** clean and evaluate the track,
@@ -243,7 +243,7 @@ namespace Muon {
unsigned int hasPhiConstrain( FitterData& inputData) const;
/** check whether data has sufficient phi constraints */
- unsigned int hasPhiConstrain( const Trk::Track& track ) const;
+ unsigned int hasPhiConstrain( Trk::Track* track ) const;
/** create fake phi hit on the surface of the give measurement */
const Trk::MeasurementBase* createFakePhiForMeasurement( const Trk::MeasurementBase& measurement, const Amg::Vector3D* overlapPos,
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.cxx
index 10bb2098dd76..b3364b7abc58 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.cxx
@@ -33,9 +33,6 @@
#include <set>
#include <cstdlib> // for std::abs( int )
-#define BETTER_BOOKKEEPING
-
-
namespace Muon {
MuPatCandidateTool::MuPatCandidateTool(const std::string& t, const std::string& n, const IInterface* p)
@@ -109,96 +106,50 @@ namespace Muon {
}
- bool MuPatCandidateTool::extendWithSegment( MuPatTrack& can, MuPatSegment& segInfo, const Trk::Track* track ) const {
+ bool MuPatCandidateTool::extendWithSegment( MuPatTrack& can, MuPatSegment& segInfo, std::unique_ptr<Trk::Track>& track ) const {
// add segment to candidate
can.addSegment(&segInfo,track);
return recalculateCandidateSegmentContent( can );
}
- MuPatTrack* MuPatCandidateTool::copyCandidate( MuPatTrack& canIn ) const {
+ std::unique_ptr<MuPatTrack> MuPatCandidateTool::copyCandidate( MuPatTrack* canIn ) const {
// copy and update hits
- MuPatTrack* can = new MuPatTrack(canIn);
-#ifdef BETTER_BOOKKEEPING
- // nothing needed here
-#else
- updateHits(*can,can->track().measurementsOnTrack()->stdcont());
-#endif
- return can;
- }
-
- MuPatTrack* MuPatCandidateTool::copyCandidateAndTransferTrack( MuPatTrack& canIn ) const {
- MuPatTrack* can = copyCandidate( canIn ); // does not copy track (lazy copy)
- // transfer ownership of track (to avoid copy of track if possible)
- if ( canIn.ownsTrack() ) {
- // canIn owns it, can transfer ownership
- can->updateTrack( &canIn.releaseTrack() );
- } else {
- // someone else owns it. Have to make a copy.
- can->updateTrack( new Trk::Track(canIn.track()) );
- }
+ std::unique_ptr<MuPatTrack> can = std::make_unique<MuPatTrack>(*canIn);
return can;
}
-
- MuPatTrack* MuPatCandidateTool::createCandidate( MuPatSegment& segInfo, const Trk::Track* track ) const {
+ std::unique_ptr<MuPatTrack> MuPatCandidateTool::createCandidate( MuPatSegment& segInfo, std::unique_ptr<Trk::Track>& track ) const {
// create the new candidate
- MuPatTrack* candidate = new MuPatTrack(&segInfo,track);
-
-#ifdef BETTER_BOOKKEEPING
+ std::unique_ptr<MuPatTrack> candidate(new MuPatTrack(&segInfo,track));
recalculateCandidateSegmentContent( *candidate );
-#else
- m_hitHandler->create( candidate->track(),candidate->hitList() );
-
- // update the hit summary
- updateHits(*candidate,candidate->track().measurementsOnTrack()->stdcont());
-#endif
-
return candidate;
}
- bool MuPatCandidateTool::updateTrack( MuPatTrack& candidate, const Trk::Track* track ) const {
+ bool MuPatCandidateTool::updateTrack( MuPatTrack& candidate, std::unique_ptr<Trk::Track>& track ) const {
candidate.updateTrack( track );
return recalculateCandidateSegmentContent( candidate );
}
- MuPatTrack* MuPatCandidateTool::createCandidate( MuPatSegment& segInfo1, MuPatSegment& segInfo2,
- const Trk::Track* track ) const {
+ std::unique_ptr<MuPatTrack> MuPatCandidateTool::createCandidate( MuPatSegment& segInfo1, MuPatSegment& segInfo2,
+ std::unique_ptr<Trk::Track>& track ) const {
// create the new candidate
- MuPatTrack* candidate = new MuPatTrack(&segInfo1,&segInfo2,track);
-
-#ifdef BETTER_BOOKKEEPING
+ std::unique_ptr<MuPatTrack> candidate(new MuPatTrack(&segInfo1,&segInfo2,track));
recalculateCandidateSegmentContent( *candidate );
-#else
- m_hitHandler->create( candidate->track(),candidate->hitList() );
-
- // update the hit summary
- updateHits(*candidate,candidate->track().measurementsOnTrack()->stdcont());
-#endif
-
return candidate;
}
- MuPatTrack* MuPatCandidateTool::createCandidate( const Trk::Track* track ) const {
+ std::unique_ptr<MuPatTrack> MuPatCandidateTool::createCandidate( std::unique_ptr<Trk::Track>& track ) const {
// create a dummy segment vector
std::vector<MuPatSegment*> segments;
// create the new candidate
- MuPatTrack* candidate = new MuPatTrack(segments,track);
-
-#ifdef BETTER_BOOKKEEPING
+ std::unique_ptr<MuPatTrack> candidate(new MuPatTrack(segments,track));
recalculateCandidateSegmentContent( *candidate );
-#else
- m_hitHandler->create( candidate->track(), candidate->hitList() );
-
- // update the hit summary
- updateHits(*candidate,candidate->track().measurementsOnTrack()->stdcont());
-#endif
-
return candidate;
}
@@ -623,11 +574,11 @@ namespace Muon {
return oss.str();
}
- std::string MuPatCandidateTool::print( const std::vector<MuPatTrack*>& tracks, int level ) const{
+ std::string MuPatCandidateTool::print( const std::vector<std::unique_ptr<MuPatTrack> >& tracks, int level ) const{
std::ostringstream oss;
oss << "MuPatTracks " << tracks.size() << std::endl;
- std::vector<MuPatTrack*>::const_iterator tit = tracks.begin();
- std::vector<MuPatTrack*>::const_iterator tit_end = tracks.end();
+ std::vector<std::unique_ptr<MuPatTrack> >::const_iterator tit = tracks.begin();
+ std::vector<std::unique_ptr<MuPatTrack> >::const_iterator tit_end = tracks.end();
for( ;tit!=tit_end;++tit ) oss << " " << print(**tit,level) << std::endl;
return oss.str();
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.h
index 51d735f92f12..94a615c5821f 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.h
@@ -83,7 +83,7 @@ namespace Muon {
@param[in] seg the MuPatSegment to be added, ownership is NOT passed!
@param[out] true if any segment was removed from the track, false if not
*/
- bool extendWithSegment( MuPatTrack& can, MuPatSegment& segInfo, const Trk::Track* track ) const;
+ bool extendWithSegment( MuPatTrack& can, MuPatSegment& segInfo, std::unique_ptr<Trk::Track>& track ) const;
/** @brief create a track candidate from one segment
@param[in] seg1 the first MuPatSegment to be added, ownership is NOT passed!
@@ -91,7 +91,7 @@ namespace Muon {
@param[in] track the new track, ownership is passed to the candidate
@param[out] the new candidate, ownership is passed to caller
*/
- MuPatTrack* createCandidate( MuPatSegment& segInfo, const Trk::Track* track ) const;
+ std::unique_ptr<MuPatTrack> createCandidate( MuPatSegment& segInfo, std::unique_ptr<Trk::Track>& track ) const;
/** @brief create a track candidate from two segments
@param[in] seg1 the first MuPatSegment to be added, ownership is NOT passed!
@@ -99,18 +99,18 @@ namespace Muon {
@param[in] track the new track, ownership is passed to the candidate
@param[out] the new candidate, ownership is passed to caller
*/
- MuPatTrack* createCandidate( MuPatSegment& segInfo1, MuPatSegment& segInfo2, const Trk::Track* track ) const;
+ std::unique_ptr<MuPatTrack> createCandidate( MuPatSegment& segInfo1, MuPatSegment& segInfo2, std::unique_ptr<Trk::Track>& track ) const;
/** @brief create a track candidate from a track
@param[in] track the new track, ownership is passed to the candidate
@param[out] the new candidate, ownership is passed to caller
*/
- MuPatTrack* createCandidate( const Trk::Track* track ) const;
+ std::unique_ptr<MuPatTrack> createCandidate( std::unique_ptr<Trk::Track>& track ) const;
/** @brief set the new track in the candidate, and update candidate contents. Candidate takes ownership of track.
Returns whether segments have been removed compared to the pre-existing list of segments. */
- bool updateTrack( MuPatTrack& candidate, const Trk::Track* track ) const;
+ bool updateTrack( MuPatTrack& candidate, std::unique_ptr<Trk::Track>& track ) const;
/** @brief recalculate the chamber indices on the candidate and reset them. Return whether segment has been removed. */
bool recalculateCandidateSegmentContent( MuPatTrack& candidate ) const;
@@ -119,13 +119,7 @@ namespace Muon {
@param[in] can the MuPatTrack to be copied
@param[out] the new candidate, ownership is passed to caller. The new candidate will not own the track (lazy pointer copy)
*/
- MuPatTrack* copyCandidate( MuPatTrack& canIn ) const;
-
- /** @brief copy a candidate and transfer the track ownwership from the old to the new candidate.
- @param[in] can the MuPatTrack to be copied. After the copy, it will no longer own the track (but keeps pointer to it)
- @param[out] the new candidate, ownership is passed to caller. The new candidate will own the track.
- */
- MuPatTrack* copyCandidateAndTransferTrack( MuPatTrack& canIn ) const;
+ std::unique_ptr<MuPatTrack> copyCandidate( MuPatTrack* canIn ) const;
/** @brief create a MuPatSegment object from a segment
@param[in] segment input segment
@@ -155,7 +149,7 @@ namespace Muon {
std::string print( const MuPatTrack& track, int level = 0 ) const;
- std::string print( const std::vector<MuPatTrack*>& tracks, int level = 0 ) const;
+ std::string print( const std::vector<std::unique_ptr<MuPatTrack> >& tracks, int level = 0 ) const;
private:
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatTrack.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatTrack.cxx
index 0e6667cc5699..3ba21ef00424 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatTrack.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatTrack.cxx
@@ -72,22 +72,20 @@ namespace Muon {
// member functions
- MuPatTrack::MuPatTrack( const std::vector<MuPatSegment*>& segments, const Trk::Track* track , MuPatSegment* seedSeg )
+ MuPatTrack::MuPatTrack( const std::vector<MuPatSegment*>& segments, std::unique_ptr<Trk::Track>& track , MuPatSegment* seedSeg )
: MuPatCandidateBase()
, created(Unknown)
, lastSegmentChange(Unknown)
, m_segments(segments)
- , m_track(track)
, m_seedSeg(0)
- , m_ownTrack(true)
, mboyInfo(0)
{
#ifdef MCTB_OBJECT_POINTERS
std::cout << " new track " << this << std::endl;
#endif
+ m_track.swap(track);
// increase segment counters
modifySegmentCounters(+1);
-// m_hasMomentum = hasMomentum(*track);
m_hasMomentum = hasMomentum();
#ifdef MCTB_OBJECT_COUNTERS
addInstance();
@@ -100,15 +98,14 @@ namespace Muon {
else if (segments.size()) m_seedSeg = segments[0];
}
- MuPatTrack::MuPatTrack( MuPatSegment* segment, const Trk::Track* track )
+ MuPatTrack::MuPatTrack( MuPatSegment* segment, std::unique_ptr<Trk::Track>& track )
: MuPatCandidateBase()
, created(Unknown)
, lastSegmentChange(Unknown)
- , m_track(track)
, m_seedSeg(0)
- , m_ownTrack(true)
, mboyInfo(0)
{
+ m_track.swap(track);
#ifdef MCTB_OBJECT_POINTERS
std::cout << " new track " << this << std::endl;
#endif
@@ -116,7 +113,6 @@ namespace Muon {
m_segments.push_back(segment);
// increase segment counters
modifySegmentCounters(+1);
-// m_hasMomentum = hasMomentum(*track);
m_hasMomentum = hasMomentum();
#ifdef MCTB_OBJECT_COUNTERS
addInstance();
@@ -127,15 +123,14 @@ namespace Muon {
m_excludedSegments.clear();
}
- MuPatTrack::MuPatTrack( MuPatSegment* segment1, MuPatSegment* segment2, const Trk::Track* track , MuPatSegment* seedSeg )
+ MuPatTrack::MuPatTrack( MuPatSegment* segment1, MuPatSegment* segment2, std::unique_ptr<Trk::Track>& track , MuPatSegment* seedSeg )
: MuPatCandidateBase()
, created(Unknown)
, lastSegmentChange(Unknown)
- , m_track(track)
, m_seedSeg(0)
- , m_ownTrack(true)
, mboyInfo(0)
{
+ m_track.swap(track);
#ifdef MCTB_OBJECT_POINTERS
std::cout << " new track " << this << std::endl;
#endif
@@ -144,7 +139,6 @@ namespace Muon {
m_segments.push_back(segment2);
// increase segment counters
modifySegmentCounters(+1);
-// m_hasMomentum = hasMomentum(*track);
m_hasMomentum = hasMomentum();
#ifdef MCTB_OBJECT_COUNTERS
addInstance();
@@ -163,7 +157,6 @@ namespace Muon {
std::cout << " delete trackcan " << this << std::endl;
#endif
modifySegmentCounters(-1);
- if (m_ownTrack) delete m_track;
if (mboyInfo) delete mboyInfo;
#ifdef MCTB_OBJECT_COUNTERS
removeInstance();
@@ -178,13 +171,12 @@ namespace Muon {
, lastSegmentChange(can.lastSegmentChange)
, m_segments(can.m_segments)
, m_excludedSegments(can.m_excludedSegments)
- , m_track(can.m_track)
, m_seedSeg(can.m_seedSeg)
- , m_ownTrack(false)
{
#ifdef MCTB_OBJECT_POINTERS
std::cout << " ctor track " << this << std::endl;
#endif
+ m_track=std::make_unique<Trk::Track>(can.track());
m_hasMomentum = can.m_hasMomentum;
// increase segment counters
modifySegmentCounters(+1);
@@ -246,11 +238,9 @@ namespace Muon {
m_segments = can.m_segments;
m_excludedSegments = can.m_excludedSegments;
- if (m_ownTrack) delete m_track;
- m_track = can.m_track;
+ m_track = std::make_unique<Trk::Track>(can.track());
m_chambers = can.m_chambers;
m_stations = can.m_stations;
- m_ownTrack = false;
m_hasMomentum = can.m_hasMomentum;
m_seedSeg = can.m_seedSeg;
@@ -327,22 +317,15 @@ namespace Muon {
return hasMom;
}
- void MuPatTrack::updateTrack( const Trk::Track* track ) {
- if (m_ownTrack && m_track != track) delete m_track;
- m_track = track;
- m_ownTrack = true;
- }
-
- const Trk::Track& MuPatTrack::releaseTrack() {
- m_ownTrack = false;
- return *m_track;
+ void MuPatTrack::updateTrack( std::unique_ptr<Trk::Track>& track ) {
+ m_track.swap(track);
}
void MuPatTrack::addExcludedSegment( MuPatSegment* segment ) {
m_excludedSegments.push_back(segment);
}
- void MuPatTrack::addSegment( MuPatSegment* segment, const Trk::Track* newTrack ) {
+ void MuPatTrack::addSegment( MuPatSegment* segment, std::unique_ptr<Trk::Track>& newTrack ) {
// add segment and increase counter
m_segments.push_back(segment);
segment->addTrack(this);
@@ -353,11 +336,8 @@ namespace Muon {
if( newTrack ){
// delete old track, assign new
- if ( m_ownTrack && m_track != newTrack ) delete m_track;
- m_track = newTrack;
- m_ownTrack = true;
+ m_track.swap(newTrack);
}
-// m_hasMomentum = hasMomentum(*newTrack);
m_hasMomentum = hasMomentum();
}
@@ -366,7 +346,6 @@ namespace Muon {
std::vector<MuPatSegment*>::iterator it = m_segments.begin();
std::vector<MuPatSegment*>::iterator it_end = m_segments.end();
for( ;it!=it_end; ++it ) {
- //std::cout << " modifying " << *it << std::endl;
std::set<MuonStationIndex::ChIndex>::const_iterator chit = (*it)->chambers().begin();
std::set<MuonStationIndex::ChIndex>::const_iterator chit_end = (*it)->chambers().end();
for( ;chit!=chit_end;++chit ) addChamber( *chit );
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatTrack.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatTrack.h
index 2bfd9c8bc1f3..73f607fef806 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatTrack.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatTrack.h
@@ -66,15 +66,15 @@ namespace Muon {
/** @brief constructor taking a vector of MuPatSegment object, the candidate takes ownership of the track
It will increase the usedInFit counter of the MuPatSegment objects by one. */
- MuPatTrack( const std::vector<MuPatSegment*>& segments, const Trk::Track* track , MuPatSegment* seedSeg=0 );
+ MuPatTrack( const std::vector<MuPatSegment*>& segments, std::unique_ptr<Trk::Track>& track , MuPatSegment* seedSeg=0 );
/** @brief constructor taking a MuPatSegment object, the candidate takes ownership of the track
It will increase the usedInFit counter of the MuPatSegment objects by one. */
- MuPatTrack( MuPatSegment* segment, const Trk::Track* track );
+ MuPatTrack( MuPatSegment* segment, std::unique_ptr<Trk::Track>& track );
/** @brief constructor taking two MuPatSegment objects, the candidate takes ownership of the track
It will increase the usedInFit counter of the MuPatSegment objects by one. */
- MuPatTrack( MuPatSegment* segment1, MuPatSegment* segment2, const Trk::Track* track , MuPatSegment* seedSeg=0 );
+ MuPatTrack( MuPatSegment* segment1, MuPatSegment* segment2, std::unique_ptr<Trk::Track>& track , MuPatSegment* seedSeg=0 );
/** @brief destructor, decrease the usedInFit counter of all MuPatSegment objects by one */
~MuPatTrack();
@@ -86,13 +86,7 @@ namespace Muon {
MuPatTrack& operator=( const MuPatTrack& can );
/** @brief access to track */
- const Trk::Track& track() const;
-
- /** @brief Candidate no longer owns the memory of its track (but keeps the pointer). Return current track. */
- const Trk::Track& releaseTrack();
-
- /** Does this candidate own the memory of its track? */
- bool ownsTrack() const;
+ Trk::Track& track() const;
/** @brief access to segments */
const std::vector<MuPatSegment*>& segments() const;
@@ -104,7 +98,7 @@ namespace Muon {
const std::vector<MuPatSegment*>& excludedSegments() const;
/** @brief add segment + the associated new track. Takes ownership of the track. */
- void addSegment( MuPatSegment* segment, const Trk::Track* newTrack );
+ void addSegment( MuPatSegment* segment, std::unique_ptr<Trk::Track>& newTrack );
/** @brief add segment that does not match the track */
void addExcludedSegment( MuPatSegment* segment );
@@ -152,7 +146,7 @@ namespace Muon {
// private member functions
//
/** @brief update track. Candidate takes ownership of track. */
- void updateTrack( const Trk::Track* newTrack );
+ void updateTrack( std::unique_ptr<Trk::Track>& newTrack );
/** @brief update segment/track association, if add == true ,will add track to segments else remove it */
void updateSegments( bool add );
@@ -189,13 +183,11 @@ namespace Muon {
bool hasMomentum( const Trk::Track& track ) const;
- std::vector<MuPatSegment*> m_segments; //<! list of associated segments
- std::vector<MuPatSegment*> m_excludedSegments; //<! list of associated segments
- const Trk::Track* m_track; //<! associated track
+ std::vector<MuPatSegment*> m_segments; //<! list of associated segments
+ std::vector<MuPatSegment*> m_excludedSegments; //<! list of associated segments
+ std::unique_ptr<Trk::Track> m_track; //<! associated track
MuPatSegment* m_seedSeg; //!< The special segment for this track
- bool m_ownTrack;
-
public:
/** @brief Mboy data members */
struct MboyInfo {
@@ -301,14 +293,10 @@ namespace Muon {
return m_excludedSegments;
}
- inline const Trk::Track& MuPatTrack::track() const {
+ inline Trk::Track& MuPatTrack::track() const {
return *m_track;
}
- inline bool MuPatTrack::ownsTrack() const {
- return m_ownTrack;
- }
-
inline const Trk::TrackParameters& MuPatTrack::entryPars() const {
const Trk::Perigee* pp = m_track->perigeeParameters();
if( pp ){
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonTrackSelectorTool.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSelectorTool.cxx
similarity index 97%
rename from MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonTrackSelectorTool.cxx
rename to MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSelectorTool.cxx
index cf0ee994ecc0..ae5bd5d443c1 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonTrackSelectorTool.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSelectorTool.cxx
@@ -33,7 +33,6 @@ namespace Muon {
m_failedMaxMDTHoleCut(0),
m_failedMaxHoleCut(0)
{
- declareInterface<ITrackSelectorTool>(this);
declareProperty("Chi2NDofCut", m_chi2NDofCut = 20. );
declareProperty("RemoveSingleStationTracks", m_removeSingleStationTracks = false );
declareProperty("MinimumNumberOfMdtHitsPerStation", m_minMdtHitsPerStation = 3 );
@@ -96,7 +95,7 @@ namespace Muon {
return StatusCode::SUCCESS;
}
- bool MuonTrackSelectorTool::decision( const Trk::Track& track, const Trk::Vertex* ) const {
+ bool MuonTrackSelectorTool::decision( Trk::Track& track ) const {
// loop over track and calculate residuals
const DataVector<const Trk::TrackStateOnSurface>* states = track.trackStateOnSurfaces();
@@ -182,14 +181,13 @@ namespace Muon {
unsigned int nmeasPhi = 0;
std::map<MuonStationIndex::StIndex,StationData> stations;
- const Trk::TrackSummary* summary = track.trackSummary();
+ Trk::TrackSummary* summary = track.trackSummary();
Trk::MuonTrackSummary muonSummary;
if( summary ){
if( summary->muonTrackSummary() ) muonSummary = *summary->muonTrackSummary();
else{
- Trk::TrackSummary* tmpSum = const_cast<Trk::TrackSummary*>(summary);
- if( tmpSum ) m_trackSummaryTool->addDetailedTrackSummary(track,*tmpSum);
- if( tmpSum->muonTrackSummary() ) muonSummary = *tmpSum->muonTrackSummary();
+ m_trackSummaryTool->addDetailedTrackSummary(track,*summary);
+ if( summary->muonTrackSummary() ) muonSummary = *summary->muonTrackSummary();
}
}else{
Trk::TrackSummary tmpSummary;
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonTrackSelectorTool.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSelectorTool.h
similarity index 86%
rename from MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonTrackSelectorTool.h
rename to MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSelectorTool.h
index 3bae5316b8de..2a0a1dc282bd 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonTrackSelectorTool.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSelectorTool.h
@@ -8,20 +8,18 @@
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
-#include "TrkToolInterfaces/ITrackSelectorTool.h"
#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
#include "MuonRecHelperTools/MuonEDMPrinterTool.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "TrkToolInterfaces/ITrackSummaryHelperTool.h"
#include "TrkParameters/TrackParameters.h"
+#include "TrkTrack/Track.h"
#include <atomic>
#include <string>
#include <set>
#include <vector>
-static const InterfaceID IID_MuonTrackSelectorTool("Muon::MuonTrackSelectorTool",1,0);
-
namespace Trk {
class Track;
}
@@ -32,7 +30,7 @@ namespace Muon {
@brief tool to select tracks
*/
- class MuonTrackSelectorTool : virtual public Trk::ITrackSelectorTool, public AthAlgTool {
+ class MuonTrackSelectorTool : public AthAlgTool {
public:
/** @brief constructor */
MuonTrackSelectorTool(const std::string&,const std::string&,const IInterface*);
@@ -46,9 +44,6 @@ namespace Muon {
/** @brief AlgTool finalize */
StatusCode finalize();
- /** @brief access to tool interface */
- static const InterfaceID& interfaceID() { return IID_MuonTrackSelectorTool; }
-
/** @brief calculate holes in a given chamber using local straight line extrapolation
@param pars TrackParameters in the chamber
@param chId Identifier of the chamber
@@ -58,13 +53,7 @@ namespace Muon {
std::vector<Identifier> holesInChamber( const Trk::TrackParameters& pars, const Identifier& chId, const std::set<Identifier>& tubeIds ) const;
/** @brief returns true if the track satisfies the selection criteria else false */
- bool decision( const Trk::Track& track, const Trk::Vertex* = 0 ) const;
-
- /** @brief always returns false */
- bool decision( const Trk::TrackParticleBase&, const Trk::Vertex* ) const { return false; }
-
- /** @brief always returns false */
- bool decision(const xAOD::TrackParticle&,const xAOD::Vertex* ) const { return false; }
+ bool decision( Trk::Track& track ) const;
private:
ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSteering.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSteering.cxx
index 9af4d72efbc2..8f48e5efb22c 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSteering.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSteering.cxx
@@ -124,8 +124,7 @@ namespace Muon {
SegColIt sit_end = m_segmentsToDelete.end();
for( ;sit!=sit_end;++sit ){
if( !(*sit)->tracks().empty() ) {
- ATH_MSG_WARNING("Detected segment/track association issue for segment ");// << std::endl
- // << m_candidateTool->print(**sit) );
+ ATH_MSG_WARNING("Detected segment/track association issue for segment ");
std::set<MuPatTrack*>::const_iterator tit = (*sit)->tracks().begin();
std::set<MuPatTrack*>::const_iterator tit_end = (*sit)->tracks().end();
for( ;tit!=tit_end; ++tit ){
@@ -384,7 +383,7 @@ namespace Muon {
ATH_MSG_DEBUG("List of all strategies: " << m_strategies.size() );
for (unsigned int i=0;i<m_strategies.size();++i) ATH_MSG_DEBUG((*(m_strategies[i])));
- std::vector<MuPatTrack*>* resultAll = new std::vector<MuPatTrack*>();
+ std::vector<std::unique_ptr<MuPatTrack> > resultAll;
// Outermost loop over strategies!
for (unsigned int i=0;i<m_strategies.size();++i){
@@ -392,15 +391,13 @@ namespace Muon {
const MuonTrackSteeringStrategy& strategy = *m_strategies[i];
- std::vector<MuPatTrack*>* result = new std::vector<MuPatTrack*>();
+ std::vector<std::unique_ptr<MuPatTrack> > result;
// Segments that will be looped over...
SegColVec mySegColVec( strategy.getAll().size() );
- //db+
ATH_MSG_VERBOSE("Segments to be looped on: " << mySegColVec.size() );
- //-
std::set<MuonStationIndex::StIndex> stations;
// Preprocessing : loop over layers
@@ -496,7 +493,6 @@ namespace Muon {
} else {
seeds = strategy.seeds();
if (0==seeds.size()){
- //cutSeeds = false; // If there are no seed layers, then we will loop through all layers and not cut seeds
for (unsigned int j=0;j<mySegColVec.size();++j) seeds.push_back(j);
}
}
@@ -546,80 +542,32 @@ namespace Muon {
if ( segsInCone > m_segThreshold && seedSeg->quality<m_segQCut[0]+1 ) continue;
- std::vector<MuPatTrack*>* found = findTrackFromSeed( *seedSeg , *(m_strategies[i]) , seeds[lin] , mySegColVec );
+ std::vector<std::unique_ptr<MuPatTrack> > found = findTrackFromSeed( *seedSeg , *(m_strategies[i]) , seeds[lin] , mySegColVec );
- if(found) {
- ATH_MSG_VERBOSE(" Tracks for seed: " << std::endl << " --- " << m_candidateTool->print(*result) );
- result->insert( result->end() , found->begin() , found->end() );
- delete found;
+ ATH_MSG_VERBOSE(" Tracks for seed: " << std::endl << " --- " << m_candidateTool->print(result) );
+ if(!found.empty()) {
+ result.insert( result.end() , std::make_move_iterator(found.begin()) , std::make_move_iterator(found.end()) );
}
} // End of loop over segments in a layer
} // Done with loop over seed layers
// Post-processing : refinement
- if( result && !result->empty()){
- std::vector<MuPatTrack*>* refined = strategy.option(MuonTrackSteeringStrategy::DoRefinement) ? refineTracks( *result ) : 0;
- if(refined) {
- // if the refinement was ran and produced new candidates, loop over existing ones and delete those that are
- // not in the refined collection. Once done delete the old result and replace it with the refined tracks
- std::vector<MuPatTrack*>::iterator tit = result->begin();
- std::vector<MuPatTrack*>::iterator tit_end = result->end();
- for( ;tit!=tit_end;++tit ){
- std::vector<MuPatTrack*>::iterator pos = std::find(refined->begin(),refined->end(),*tit);
- if( pos == refined->end() ) delete *tit;
- }
- delete result;
- result = refined;
- }
- }
+ if(!result.empty() && strategy.option(MuonTrackSteeringStrategy::DoRefinement)) refineTracks( result );
+
// Post-processing : ambiguity resolution
- if(msgLvl(MSG::DEBUG) && result && !result->empty()){
+ if(msgLvl(MSG::DEBUG) && !result.empty()){
msg(MSG::DEBUG) << "Initial track collection for strategy: " << strategy.getName()
- << " " << m_candidateTool->print(*result) << endmsg;
+ << " " << m_candidateTool->print(result) << endmsg;
}
- if( result && !result->empty()){
- std::vector<MuPatTrack*>* resolved = strategy.option(MuonTrackSteeringStrategy::DoAmbiSolving) ? solveAmbiguities( *result ) : 0;
- if(resolved) {
- // if the refinement was ran and produced new candidates, loop over existing ones and delete those that are
- // not in the refined collection. Once done delete the old result and replace it with the refined tracks
- std::vector<MuPatTrack*>::iterator tit = result->begin();
- std::vector<MuPatTrack*>::iterator tit_end = result->end();
- for( ;tit!=tit_end;++tit ){
- std::vector<MuPatTrack*>::iterator pos = std::find(resolved->begin(),resolved->end(),*tit);
- if( pos == resolved->end() ) delete *tit;
- }
- delete result;
- result = resolved;
- }
- }
- if( result && !result->empty()) resultAll->insert(resultAll->end(),result->begin(),result->end());
+ if( !result.empty() && strategy.option(MuonTrackSteeringStrategy::DoAmbiSolving)) solveAmbiguities( result );
- delete result;
+ if( !result.empty()) resultAll.insert(resultAll.end(),std::make_move_iterator(result.begin()),std::make_move_iterator(result.end()));
} // Done with loop over strategies
- if( resultAll && !resultAll->empty()){
- std::vector<MuPatTrack*>* resolved = solveAmbiguities( *resultAll );
-
- if(resolved) {
- if( m_doSummary ) ATH_MSG_INFO("Ambiguity solving: input " << resultAll->size() << " after ambi solving " << resolved->size() );
- else ATH_MSG_DEBUG("Ambiguity solving: input " << resultAll->size() << " after ambi solving " << resolved->size() );
- // if the refinement was ran and produced new candidates, loop over existing ones and delete those that are
- // not in the refined collection. Once done delete the old result and replace it with the refined tracks
- std::vector<MuPatTrack*>::iterator tit = resultAll->begin();
- std::vector<MuPatTrack*>::iterator tit_end = resultAll->end();
-
- for( ;tit!=tit_end;++tit ){
- std::vector<MuPatTrack*>::iterator pos = std::find(resolved->begin(),resolved->end(),*tit);
- if( pos == resolved->end() ) delete *tit;
- }
- } else {
- for (auto trk : *resultAll) delete trk;
- }
- delete resultAll;
- resultAll = resolved;
-
+ if( !resultAll.empty()){
+ solveAmbiguities( resultAll );
}
if( m_outputSingleStationTracks ){
@@ -636,28 +584,20 @@ namespace Muon {
if( (*sit)->quality < 2 ) continue;
// fit segment and add the track if fit ok
- Trk::Track* segmentTrack = m_segmentFitter->fit(*(*sit)->segment);
+ std::unique_ptr<Trk::Track> segmentTrack(m_segmentFitter->fit(*(*sit)->segment));
if( segmentTrack ) {
//Try to recover hits on the track
- Trk::Track* recoveredTrack = m_muonHoleRecoverTool->recover(*segmentTrack);
- if(recoveredTrack){
- delete segmentTrack;
- segmentTrack = recoveredTrack;
- }
+ std::unique_ptr<Trk::Track> recoveredTrack(m_muonHoleRecoverTool->recover(*segmentTrack));
+ if(recoveredTrack) segmentTrack.swap(recoveredTrack);
// generate a track summary for this track
if (m_trackSummaryTool.isEnabled()) {
m_trackSummaryTool->computeAndReplaceTrackSummary(*segmentTrack, nullptr, false);
}
- MuPatTrack* can = m_candidateTool->createCandidate( **sit, segmentTrack );
- if( can ) {
- if( !resultAll ) resultAll = new std::vector<MuPatTrack*>();
- resultAll->push_back(can);
- }else{
- ATH_MSG_WARNING("Failed to create MuPatTrack");
- delete segmentTrack;
- }
+ std::unique_ptr<MuPatTrack> can = m_candidateTool->createCandidate( **sit, segmentTrack );
+ if( can ) resultAll.push_back(std::move(can));
+ else ATH_MSG_WARNING("Failed to create MuPatTrack");
}
}
}
@@ -665,45 +605,22 @@ namespace Muon {
// Output all the tracks that we are ending with
- if( resultAll && !resultAll->empty()){
- if( m_doSummary ) ATH_MSG_INFO("Final Output : " << m_candidateTool->print(*resultAll) << endmsg);
- else ATH_MSG_DEBUG("Final Output : " << m_candidateTool->print(*resultAll) << endmsg);
+ if( !resultAll.empty()){
+ if( m_doSummary ) ATH_MSG_INFO("Final Output : " << m_candidateTool->print(resultAll) << endmsg);
+ else ATH_MSG_DEBUG("Final Output : " << m_candidateTool->print(resultAll) << endmsg);
}
- TrackCollection* finalTrack = 0;
- if( resultAll && !resultAll->empty()){
- finalTrack = selectTracks(*resultAll,true);
-
- // clean up candidates
- std::for_each( resultAll->begin(),resultAll->end(),MuonDeleteObject<MuPatTrack>() );
+ TrackCollection* finalTrack = nullptr;
+ if( !resultAll.empty()){
+ finalTrack = selectTracks(resultAll);
}
- delete resultAll;
+
return finalTrack;
}
//-----------------------------------------------------------------------------------------------------------
- //const MuonTrackSteering::SegColVec* mmm__segColVec = 0;
-
std::string print( const MuPatSegment& /* seg */ ){
return "";
- /*
- if( !mmm__segColVec ) return "";
- const MuonTrackSteering::SegColVec& segs = *mmm__segColVec;
- int index = -1;
- for(unsigned int i=0;i<segs.size();++i ){
- for(unsigned int j=0;j<segs[i].size();++j ){
- if( &seg == segs[i][j] ){
- index = j;
- break;
- }
- }
- if( index != -1 ) break;
- }
-
- std::ostringstream s;
- s << "Seg:" << Muon::MuonStationIndex::chName(seg.chIndex) << "_" << index;
- return s.str();
- */
}
std::string print( const std::vector<MuPatSegment*>& segVec ){
@@ -722,22 +639,21 @@ namespace Muon {
return s.str();
}
- std::string print( const std::vector<MuPatTrack*>& tracks ){
+ std::string print( const std::vector<std::unique_ptr<MuPatTrack> >& tracks ){
std::ostringstream s;
- std::vector<MuPatTrack*>::const_iterator tit = tracks.begin();
- std::vector<MuPatTrack*>::const_iterator tit_end = tracks.end();
+ std::vector<std::unique_ptr<MuPatTrack> >::const_iterator tit = tracks.begin();
+ std::vector<std::unique_ptr<MuPatTrack> >::const_iterator tit_end = tracks.end();
for( ;tit!=tit_end;++tit ) s << std::endl << print(**tit);
return s.str();
}
- std::vector<MuPatTrack*> * MuonTrackSteering::findTrackFromSeed( MuPatSegment& seedSeg , const MuonTrackSteeringStrategy & strat , const unsigned int layer , const SegColVec& segs ) const {
+ std::vector<std::unique_ptr<MuPatTrack> > MuonTrackSteering::findTrackFromSeed( MuPatSegment& seedSeg , const MuonTrackSteeringStrategy & strat ,
+ const unsigned int layer , const SegColVec& segs ) const {
//the resulting vector of tracks to be returned
- std::vector<MuPatTrack*> *result = new std::vector<MuPatTrack*>();
+ std::vector<std::unique_ptr<MuPatTrack> > result;
ATH_MSG_DEBUG("Working on seed: " << std::endl << " --- " << m_candidateTool->print(seedSeg) );
- //mmm__segColVec = &segs;
- //std::cout << "Working on seed: " << std::endl << " --- " << print(seedSeg) << " layer " << layer << " max " << strat.getAll().size() << std::endl;
m_findingDepth = 0;
m_seedCombinatorics = 0;
const unsigned int endLayer = strat.getAll().size();
@@ -787,38 +703,22 @@ namespace Muon {
}
}
- std::vector<MuPatTrack*> *tracks=0;
+ std::vector<std::unique_ptr<MuPatTrack> > tracks;
- if (matchedSegs.size()!=0 && m_useTightMatching)
- {
- tracks = m_trackBTool->find(seedSeg, matchedSegs);
-
- //ATH_MSG_DEBUG( std::setw(m_findingDepth) << " " << " Adding layer: " << ilayer << " with "
- // << matchedSegs.size() << " matched segments " << m_candidateTool->print(matchedSegs) );
- }
- else{
- tracks = m_trackBTool->find(seedSeg, segs[ilayer]);
- // ATH_MSG_DEBUG( std::setw(m_findingDepth) << " " << " Adding layer: " << ilayer << " with "
- // << segs[ilayer].size() << " segments " << m_candidateTool->print(segs[ilayer]) );
-
- //std::cout<< std::setw(m_findingDepth) << " " << " Adding layer: " << ilayer << " with " << segs[ilayer].size() << " segments " << print(segs[ilayer]) << std::endl;
- }
+ if (matchedSegs.size()!=0 && m_useTightMatching) tracks = m_trackBTool->find(seedSeg, matchedSegs);
+ else tracks = m_trackBTool->find(seedSeg, segs[ilayer]);
++m_seedCombinatorics;
++m_findingDepth;
- if( tracks && !tracks->empty() )
+ if( !tracks.empty() )
{
-
// if we reached the end of the sequence, we should save what we have else continue to next layer
if( ilayer+1==strat.getAll().size()){
- result->insert(result->end(),tracks->begin(),tracks->end());
- delete tracks;
+ result.insert(result.end(),std::make_move_iterator(tracks.begin()),std::make_move_iterator(tracks.end()));
break;
}
- std::vector<MuPatTrack*>::iterator cit = tracks->begin();
- std::vector<MuPatTrack*>::iterator cit_end = tracks->end();
- //std::cout << std::setw(m_findingDepth) << " " << "found tracks " << tracks->size() << print(*tracks) << std::endl;
-
+ std::vector<std::unique_ptr<MuPatTrack> >::iterator cit = tracks.begin();
+ std::vector<std::unique_ptr<MuPatTrack> >::iterator cit_end = tracks.end();
//loop on found tracks
for( ; cit!=cit_end; ++cit )
@@ -828,91 +728,52 @@ namespace Muon {
if ( nextLayer < strat.getAll().size() )
{
int cutLevel = tightCuts ? 1 : 0;
- std::vector<MuPatTrack*>* nextTracks = extendWithLayer(**cit,segs,nextLayer,endLayer,cutLevel);
- if (nextTracks && !nextTracks->empty()) {
- //std::cout << std::setw(m_findingDepth) << " " << "found tracks ( " << nextLayer << ") " << nextTracks->size() << print(*nextTracks) << std::endl;
- //ATH_MSG_DEBUG( std::setw(m_findingDepth) << " " << " extension successful adding new candidates " << nextTracks->size() );
- result->insert(result->end(),nextTracks->begin(),nextTracks->end());
- //std::vector<MuPatTrack*>::iterator ssit = nextTracks->begin();
- //for( ;ssit!=nextTracks->end(); ++ssit ) //std::cout << " adding track can " << *ssit << std::endl;
- std::vector<MuPatTrack*>::const_iterator pos = std::find(result->begin(),result->end(),*cit );
- if( pos == result->end() ) delete *cit;
+ std::vector<std::unique_ptr<MuPatTrack> > nextTracks = extendWithLayer(**cit,segs,nextLayer,endLayer,cutLevel);
+ if (!nextTracks.empty()) {
+ result.insert(result.end(),std::make_move_iterator(nextTracks.begin()),std::make_move_iterator(nextTracks.end()));
}else{
- std::vector<MuPatTrack*>::const_iterator pos = std::find(result->begin(),result->end(),*cit );
- if( pos == result->end() ){
- //std::cout << std::setw(m_findingDepth) << " " << "extension failed (" << nextLayer << ") for candidate " << *cit << print(**cit) << std::endl;
- result->push_back(*cit);
- }else{
- ATH_MSG_WARNING("Candidate already included in result");
- }
+ result.push_back(std::move(*cit));
}
- delete nextTracks;
}
}
}
- delete tracks;
}
- //std::cout << "Result for seed: " << std::endl << " --- " << m_candidateTool->print(*result) <<std::endl;
- ATH_MSG_DEBUG("Constructed " << result->size() << " tracks with strategy " << strat.getName() );
+ ATH_MSG_DEBUG("Constructed " << result.size() << " tracks with strategy " << strat.getName() );
return result;
}
- std::vector<MuPatTrack*> * MuonTrackSteering::extendWithLayer(MuPatTrack& candidate, const SegColVec& segs,unsigned int nextlayer, const unsigned int endlayer, int cutLevel ) const
+ std::vector<std::unique_ptr<MuPatTrack> > MuonTrackSteering::extendWithLayer(MuPatTrack& candidate, const SegColVec& segs, unsigned int nextlayer,
+ const unsigned int endlayer, int cutLevel ) const
{
++m_findingDepth;
- //std::cout << std::setw(m_findingDepth) << " " << "extendWithLayer " << m_seedCombinatorics << " "
- //<< nextlayer << " end " << endlayer << " " << print(candidate) << std::endl;
- std::vector<MuPatTrack*> *result = new std::vector<MuPatTrack*>();
+ std::vector<std::unique_ptr<MuPatTrack> > result;
if ( nextlayer < endlayer )
{
for (;nextlayer!=endlayer;nextlayer++)
{
if (segs[nextlayer].empty()) continue;
- // ATH_MSG_DEBUG(std::setw(m_findingDepth) << " " << " Extending track with layer " << nextlayer
- // << " segments " << m_candidateTool->print(segs[nextlayer]) );
- //std::cout << std::setw(m_findingDepth) << " " << " Extending track with layer " << nextlayer << " segments " << print(segs[nextlayer]) << std::endl;
- std::vector<MuPatTrack*> *nextTracks=0;
+ std::vector<std::unique_ptr<MuPatTrack> > nextTracks;
nextTracks = m_trackBTool->find(candidate, segs[nextlayer] );
++m_seedCombinatorics;
- if (nextTracks && !nextTracks->empty())
+ if (!nextTracks.empty())
{
- // ATH_MSG_DEBUG( std::setw(m_findingDepth) << " " << " extension successful continuing to layer " << nextlayer
- // << " " << nextTracks->size() );
- //std::cout << std::setw(m_findingDepth) << " " << " extension successful continuing to layer " << nextlayer << " " << nextTracks->size() << std::endl;
- std::vector<MuPatTrack*>::iterator cit = nextTracks->begin();
- std::vector<MuPatTrack*>::iterator cit_end = nextTracks->end();
+ std::vector<std::unique_ptr<MuPatTrack> >::iterator cit = nextTracks.begin();
+ std::vector<std::unique_ptr<MuPatTrack> >::iterator cit_end = nextTracks.end();
for(; cit!=cit_end; ++cit )
{
- std::vector<MuPatTrack*>* nextTracks2 = extendWithLayer((**cit), segs, nextlayer+1, endlayer, cutLevel);
- if (nextTracks2 && !nextTracks2->empty()) {
- // ATH_MSG_DEBUG( std::setw(m_findingDepth) << " " << " extension successful adding new candidates " << nextTracks->size() );
- //std::cout << std::setw(m_findingDepth) << " " << " extension successful adding new candidates " << nextTracks->size() << print(*nextTracks) << std::endl;
- //std::vector<MuPatTrack*>::iterator ssit = nextTracks2->begin();
- //for( ;ssit!=nextTracks2->end(); ++ssit ) //std::cout << " adding track can " << *ssit << std::endl;
- result->insert(result->end(),nextTracks2->begin(),nextTracks2->end());
- std::vector<MuPatTrack*>::const_iterator pos = std::find(result->begin(),result->end(),*cit );
- if( pos == result->end() ) delete *cit;
-
- }else{
- std::vector<MuPatTrack*>::const_iterator pos = std::find(result->begin(),result->end(),*cit );
- if( pos == result->end() ){
-
- // ATH_MSG_DEBUG( std::setw(m_findingDepth) << " " << " extension failed, adding original" );
- //std::cout << std::setw(m_findingDepth) << " " << " extension failed, adding original " << *cit << print(**cit) << std::endl;
- result->push_back(*cit);
- }else{
- ATH_MSG_WARNING("Candidate already included in result");
- }
-
+ std::vector<std::unique_ptr<MuPatTrack> > nextTracks2 = extendWithLayer((**cit), segs, nextlayer+1, endlayer, cutLevel);
+ if (!nextTracks2.empty()) {
+ result.insert(result.end(),std::make_move_iterator(nextTracks2.begin()),std::make_move_iterator(nextTracks2.end()));
+ }
+ else{
+ result.push_back(std::move(*cit));
}
- delete nextTracks2;
}
}
- delete nextTracks;
}
}
--m_findingDepth;
@@ -920,99 +781,75 @@ namespace Muon {
}
//-----------------------------------------------------------------------------------------------------------
- TrackCollection* MuonTrackSteering::selectTracks(std::vector<MuPatTrack*>& candidates, bool takeOwnership ) const {
+ TrackCollection* MuonTrackSteering::selectTracks(std::vector<std::unique_ptr<MuPatTrack> >& candidates, bool takeOwnership ) const {
TrackCollection* result = takeOwnership ? new TrackCollection() : new TrackCollection(SG::VIEW_ELEMENTS);
result->reserve(candidates.size());
- std::vector<MuPatTrack*>::iterator cit = candidates.begin();
- std::vector<MuPatTrack*>::iterator cit_end = candidates.end();
+ std::vector<std::unique_ptr<MuPatTrack> >::iterator cit = candidates.begin();
+ std::vector<std::unique_ptr<MuPatTrack> >::iterator cit_end = candidates.end();
for( ; cit!=cit_end; ++cit ){
// if track selector is configured, use it and remove bad tracks
if(!m_trackSelector.empty() && !m_trackSelector->decision((*cit)->track())) continue;
- if( takeOwnership ) {
- // To remove warning. It seems, that is thread-safe
- // It is very bad way to use const_cast
- Trk::Track* track ATLAS_THREAD_SAFE = const_cast<Trk::Track*>( &(*cit)->releaseTrack() );
- // add track summary to this track
- if (m_trackSummaryTool.isEnabled()) {
- m_trackSummaryTool->computeAndReplaceTrackSummary(*track, nullptr, false);
- }
- result->push_back( track );
- }
- else {
- Trk::Track* track ATLAS_THREAD_SAFE = const_cast<Trk::Track*>( &(*cit)->track() );
- // add track summary to this track
- if (m_trackSummaryTool.isEnabled()) {
- m_trackSummaryTool->computeAndReplaceTrackSummary(*track, nullptr, false);
- }
- result->push_back( track );
+ Trk::Track* track;
+ if(takeOwnership) track=new Trk::Track((*cit)->track());
+ else track=&(*cit)->track();
+ // add track summary to this track
+ if (m_trackSummaryTool.isEnabled()) {
+ m_trackSummaryTool->computeAndReplaceTrackSummary(*track, nullptr, false);
}
+ result->push_back( track );
}
return result;
}
- std::vector<MuPatTrack*> * MuonTrackSteering::refineTracks(std::vector<MuPatTrack*>& candidates) const {
- std::vector<MuPatTrack*> * result = new std::vector<MuPatTrack*>();
+ void MuonTrackSteering::refineTracks(std::vector<std::unique_ptr<MuPatTrack> >& candidates) const {
- std::vector<MuPatTrack*>::iterator cit = candidates.begin();
- std::vector<MuPatTrack*>::iterator cit_end = candidates.end();
+ std::vector<std::unique_ptr<MuPatTrack> >::iterator cit = candidates.begin();
+ std::vector<std::unique_ptr<MuPatTrack> >::iterator cit_end = candidates.end();
for( ; cit!=cit_end; ++cit )
{
- MuPatTrack *refinedMuPatTrack=0;
- refinedMuPatTrack = m_trackRefineTool->refine(**cit);
-
- if (refinedMuPatTrack) {
- //std::cout << std::endl << " after " << m_candidateTool->print(*refinedMuPatTrack) << std::endl;
- result->push_back(refinedMuPatTrack);
- }
+ m_trackRefineTool->refine(**cit);
}
- return result;
}
//-----------------------------------------------------------------------------------------------------------
- std::vector<MuPatTrack*> * MuonTrackSteering::solveAmbiguities( std::vector< MuPatTrack* >& tracks , const MuonTrackSteeringStrategy* /*strat*/ ) const {
+ void MuonTrackSteering::solveAmbiguities( std::vector< std::unique_ptr<MuPatTrack> >& tracks , const MuonTrackSteeringStrategy* /*strat*/ ) const {
//the resulting vector of tracks to be returned
-
- TrackCollection* trkColl = selectTracks(tracks,false);
+ std::unique_ptr<TrackCollection> trkColl(selectTracks(tracks,false));
if( !trkColl || trkColl->empty() ){
- delete trkColl;
- return 0;
+ return;
}
- TrackCollection* resolvedTracks = m_ambiTool->process(trkColl);
+ std::unique_ptr<TrackCollection> resolvedTracks(m_ambiTool->process(trkColl.get()));
if( !resolvedTracks ){
- delete trkColl;
- return 0;
+ return;
}
ATH_MSG_DEBUG(" resolved track candidates: old size " << trkColl->size()
<< " new size " << resolvedTracks->size() );
- std::vector<MuPatTrack*> *result = new std::vector<MuPatTrack*>();
-
- TrackCollection::iterator tit = resolvedTracks->begin();
+ TrackCollection::iterator tit;
TrackCollection::iterator tit_end = resolvedTracks->end();
- std::vector<MuPatTrack*>::iterator pat = tracks.begin();
- std::vector<MuPatTrack*>::iterator pat_end = tracks.end();
- for( ;tit!=tit_end;++tit ){
- MuPatTrack* can = 0;
- for( pat=tracks.begin(); pat!=pat_end;++pat ){
+ std::vector<std::unique_ptr<MuPatTrack> >::iterator pat = tracks.begin();
+ for(;pat!=tracks.end();){
+ bool found=false;
+ for(tit=resolvedTracks->begin();tit!=tit_end;++tit ){
if ( &(*pat)->track() == *tit ) {
- can = *pat;
+ found=true;
break;
}
}
- if( can ) result->push_back( can );
- else {
- delete *pat;
+ if(!found){
+ pat=tracks.erase(pat);
+ }
+ else{
+ ++pat;
}
}
- delete resolvedTracks;
- delete trkColl;
- return result;
+ return;
}
//-----------------------------------------------------------------------------------------------------------
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSteering.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSteering.h
index 3ce035874f57..2190d3613253 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSteering.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuonTrackSteering.h
@@ -29,9 +29,9 @@
#include "MuonRecToolInterfaces/IMuonHoleRecoveryTool.h"
#include "MuPatCandidateTool.h"
#include "TrkToolInterfaces/ITrackAmbiguityProcessorTool.h"
-#include "TrkToolInterfaces/ITrackSelectorTool.h"
#include "MooTrackBuilder.h"
#include "MooCandidateMatchingTool.h"
+#include "MuonTrackSelectorTool.h"
#include "TrkTrack/Track.h"
#include "TrkToolInterfaces/IExtendedTrackSummaryTool.h"
@@ -100,7 +100,7 @@ namespace Muon {
TrackCollection* find( const MuonSegmentCollection& coll ) const override;
private:
- TrackCollection *selectTracks(std::vector<MuPatTrack*> & candidates, bool takeOwnership = true ) const;
+ TrackCollection *selectTracks(std::vector<std::unique_ptr<MuPatTrack> > & candidates, bool takeOwnership = true ) const;
/** actual find method */
TrackCollection* findTracks( SegColVec& chamberSegments, SegColVec& stationSegments ) const;
@@ -112,22 +112,22 @@ namespace Muon {
const MuonTrackSteeringStrategy* decodeStrategy(const std::string& strategy) const;
bool decodeList(const std::string& input, std::vector<std::string>& list) const;
- std::vector<MuPatTrack*> *extendWithLayer(MuPatTrack& candidate, const SegColVec& segcol, unsigned int nextlayer, const unsigned int endlayer, int cutLevel = 0 ) const;
+ std::vector<std::unique_ptr<MuPatTrack> > extendWithLayer(MuPatTrack& candidate, const SegColVec& segcol, unsigned int nextlayer, const unsigned int endlayer, int cutLevel = 0 ) const;
/** @brief Find tracks starting from a good segment
@param seedSeg the seeding MuonSegment pointer
@param strat the current track finding strategy
@param layer the current layer for the seed
*/
- std::vector< MuPatTrack* > * findTrackFromSeed( MuPatSegment& seedSeg , const MuonTrackSteeringStrategy & strat , const unsigned int layer , const SegColVec& segs ) const;
+ std::vector< std::unique_ptr<MuPatTrack> > findTrackFromSeed( MuPatSegment& seedSeg , const MuonTrackSteeringStrategy & strat , const unsigned int layer , const SegColVec& segs ) const;
- std::vector<MuPatTrack*> * refineTracks(std::vector<MuPatTrack*>& candidates) const;
+ void refineTracks(std::vector<std::unique_ptr<MuPatTrack> >& candidates) const;
/** @brief Resolve ambiguities among tracks for a single strategy
This allows a strategy-specific ambiguity solving (with some options per strategy)
@param vector of tracks that were found
@param strat the steering strategy
*/
- std::vector<MuPatTrack*> *solveAmbiguities( std::vector< MuPatTrack* >& tracks , const MuonTrackSteeringStrategy* strat = 0 ) const;
+ void solveAmbiguities( std::vector< std::unique_ptr<MuPatTrack> >& tracks , const MuonTrackSteeringStrategy* strat = 0 ) const;
void combineOverlapSegments( std::vector< MuPatSegment*>& ch1, std::vector< MuPatSegment*>& ch2, SegColVec& stationSegments, StSet& stationsWithSegments ) const;
@@ -143,7 +143,7 @@ namespace Muon {
ToolHandle<IMuonTrackBuilder> m_trackBTool
{this, "TrackBuilderTool", "Muon::MooTrackBuilder/MooMuonTrackBuilder"};
ToolHandle<Trk::ITrackAmbiguityProcessorTool> m_ambiTool
- {this, "AmbiguityTool", "Trk::TrackSelectionProcessorTool/MuonAmbiProcessor"}; // FIXME - remove mutable once MR27716 goes in.
+ {this, "AmbiguityTool", "Trk::TrackSelectionProcessorTool/MuonAmbiProcessor"};
ToolHandle<MooTrackBuilder> m_mooBTool
{this, "MooBuilderTool", "Muon::MooTrackBuilder/MooMuonTrackBuilder"};//<! Temporary tool for helping to combine two segments
ToolHandle<MooCandidateMatchingTool> m_candidateMatchingTool
@@ -154,7 +154,7 @@ namespace Muon {
{this, "MuonSegmentFittingTool", "Muon::MuonSegmentFittingTool/MuonSegmentFittingTool"};//<! segment fitting tool
ToolHandle<IMuonSegmentMerger> m_segmentMerger
{this, "MuonSegmentMerger", ""};//<! segment merger
- ToolHandle<Trk::ITrackSelectorTool> m_trackSelector
+ ToolHandle<Muon::MuonTrackSelectorTool> m_trackSelector
{this, "MuonTrackSelector", "Muon::MuonTrackSelectorTool/MuonTrackSelectorTool"};//<! track selector
ToolHandle<IMuonHoleRecoveryTool> m_muonHoleRecoverTool
{this, "HoleRecoveryTool", "Muon::MuonChamberHoleRecoveryTool/MuonChamberHoleRecoveryTool"};//<! track selector
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/components/MuonTrackSteeringTools_entries.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/components/MuonTrackSteeringTools_entries.cxx
index e51dc358bff6..11ce2714ea73 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/components/MuonTrackSteeringTools_entries.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/components/MuonTrackSteeringTools_entries.cxx
@@ -4,6 +4,7 @@
#include "../MooCandidateMatchingTool.h"
#include "../MooTrackFitter.h"
#include "../MooTrackBuilder.h"
+#include "../MuonTrackSelectorTool.h"
using namespace Muon;
@@ -13,4 +14,4 @@ DECLARE_COMPONENT( MuPatCandidateTool )
DECLARE_COMPONENT( MooCandidateMatchingTool )
DECLARE_COMPONENT( MooTrackFitter )
DECLARE_COMPONENT( MooTrackBuilder )
-
+DECLARE_COMPONENT( MuonTrackSelectorTool )
--
GitLab