From 374a678b8ac00be1789c8238b0adecf6018f5fed Mon Sep 17 00:00:00 2001
From: William Axel Leight <william.axel.leight@cern.ch>
Date: Fri, 14 Dec 2018 17:44:24 +0000
Subject: [PATCH] Better memory managment in combined muon algorithms
Former-commit-id: 4776c7f247b22c8a9f5b1e77d214ba7ca2f2eb24
---
.../IMuonRecoValidationTool.h | 2 +-
.../src/MuonDetailedTrackTruthMaker.cxx | 48 ++++-
.../src/MuonRecoValidationTool.cxx | 7 +-
.../src/MuonRecoValidationTool.h | 16 +-
.../MuGirl/src/MuGirlRecoTool.cxx | 17 +-
.../MuidInterfaces/IMuidMuonRecovery.h | 4 +-
.../MuidTrackBuilder/MuidMuonRecovery.h | 4 +-
.../MuidTrackBuilder/src/MuidMuonRecovery.cxx | 5 +-
.../MuonCombinedAlgs/src/MuonCombinedAlg.cxx | 11 +-
.../MuonCombinedAlgs/src/MuonCombinedAlg.h | 3 +
.../src/MuonCombinedInDetExtensionAlg.cxx | 52 ++++--
.../src/MuonCombinedInDetExtensionAlg.h | 5 +
.../src/MuonCombinedMuonCandidateAlg.cxx | 5 +-
.../src/MuonCombinedMuonCandidateAlg.h | 3 +-
.../MuonCombinedAlgs/src/MuonCreatorAlg.cxx | 25 ---
.../MuonCombinedAlgs/src/MuonCreatorAlg.h | 6 +-
.../src/MuGirlTagTool.cxx | 12 +-
.../MuonCombinedBaseTools/src/MuGirlTagTool.h | 8 +-
.../src/MuonCaloTagTool.cxx | 14 +-
.../src/MuonCaloTagTool.h | 8 +-
.../src/MuonCandidateTool.cxx | 35 ++--
.../src/MuonCandidateTool.h | 2 +-
.../src/MuonCombinedFitTagTool.cxx | 165 ++++++++++--------
.../src/MuonCombinedFitTagTool.h | 20 ++-
.../src/MuonCombinedStacoTagTool.cxx | 5 +-
.../src/MuonCombinedStacoTagTool.h | 3 +-
.../src/MuonCombinedTool.cxx | 5 +-
.../src/MuonCombinedTool.h | 3 +-
.../src/MuonCreatorTool.cxx | 159 ++++++-----------
.../src/MuonCreatorTool.h | 12 +-
.../MuonCombinedEvent/CombinedFitTag.h | 58 ++----
.../InDetCandidateToTagMap.h | 5 +-
.../MuonCombinedEvent/MuGirlLowBetaTag.h | 76 +++-----
.../MuonCombinedEvent/MuGirlTag.h | 79 +++------
.../MuonCombinedEvent/MuonCandidate.h | 15 +-
.../MuonCombinedEvent/src/CombinedFitTag.cxx | 8 +-
.../src/InDetCandidateToTagMap.cxx | 18 +-
.../src/MuGirlLowBetaTag.cxx | 13 +-
.../MuonCombinedEvent/src/MuGirlTag.cxx | 11 +-
.../MuonCombinedEvent/src/MuonCandidate.cxx | 8 +-
.../python/MuGirlTagTool.py | 9 +-
.../python/MuonCombinedAlgs.py | 10 +-
.../python/MuonCombinedKeys.py | 57 +++++-
.../share/MuonCombinedRec_postprocessing.py | 14 +-
.../share/MuonCombined_OutputItemsAOD.py | 2 +
.../share/MuonCombined_OutputItemsESD.py | 6 +
.../IMuonCandidateTool.h | 3 +-
.../IMuonCandidateTrackBuilderTool.h | 2 +-
.../IMuonCombinedInDetExtensionTool.h | 20 ++-
.../IMuonCombinedTagTool.h | 4 +-
.../IMuonCombinedTool.h | 4 +-
.../IMuonCreatorTool.h | 15 +-
.../src/MuonCandidateTrackBuilderTool.cxx | 2 +-
.../src/MuonCandidateTrackBuilderTool.h | 2 +-
.../src/MuonInsideOutRecoTool.cxx | 98 ++++++-----
.../src/MuonInsideOutRecoTool.h | 23 ++-
.../src/MuonStauRecoTool.cxx | 66 ++++---
.../src/MuonStauRecoTool.h | 14 +-
.../TrigMuSuperEF/src/TrigMuSuperEF.cxx | 137 +++++++++------
.../TrigMuSuperEF/src/TrigMuSuperEF.h | 18 +-
.../src/TrigMuonEFStandaloneTrackTool.cxx | 21 +--
.../src/TrigMuonEFStandaloneTrackTool.h | 3 +
.../ITrigMuonStandaloneTrackTool.h | 1 +
63 files changed, 793 insertions(+), 693 deletions(-)
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonRecoValidationTool.h b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonRecoValidationTool.h
index 1afbad978f6..33fface4a89 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonRecoValidationTool.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonRecoValidationTool.h
@@ -60,7 +60,7 @@ namespace Muon {
/** add new MuonCandidate */
virtual bool addMuonCandidate( const xAOD::TrackParticle& indetTrackParticle, const MuonCandidate* candidate,
- const Trk::Track* combinedTrack, int ntimes, float beta, float chi2ndof, int stage ) = 0;
+ Trk::Track* combinedTrack, int ntimes, float beta, float chi2ndof, int stage ) = 0;
/** add StauHits to ntuple */
virtual bool addTimeMeasurements( const xAOD::TrackParticle& indetTrackParticle, const MuGirlNS::StauHits& stauHits ) = 0;
diff --git a/MuonSpectrometer/MuonTruthAlgs/src/MuonDetailedTrackTruthMaker.cxx b/MuonSpectrometer/MuonTruthAlgs/src/MuonDetailedTrackTruthMaker.cxx
index 6ec4245861a..b9ba6ed927d 100755
--- a/MuonSpectrometer/MuonTruthAlgs/src/MuonDetailedTrackTruthMaker.cxx
+++ b/MuonSpectrometer/MuonTruthAlgs/src/MuonDetailedTrackTruthMaker.cxx
@@ -7,6 +7,7 @@
#include "MuonTruthAlgs/MuonDetailedTrackTruthMaker.h"
#include <iterator>
+#include <map>
//================================================================
MuonDetailedTrackTruthMaker::MuonDetailedTrackTruthMaker(const std::string &name, ISvcLocator *pSvcLocator) :
@@ -33,10 +34,17 @@ StatusCode MuonDetailedTrackTruthMaker::initialize()
if(m_useNSW) m_PRD_TruthNames={"sTGC_TruthMap","MM_TruthMap","RPC_TruthMap","TGC_TruthMap","MDT_TruthMap"};
- m_detailedTrackTruthNames.reserve ( m_trackCollectionNames.size());
- for(unsigned int i=0;i<m_trackCollectionNames.size();i++){
- m_detailedTrackTruthNames.emplace_back(m_trackCollectionNames.at(i).key()+"DetailedTruth");
- ATH_MSG_INFO("process "<<m_trackCollectionNames.at(i).key()<<" for detailed truth collection "<<m_detailedTrackTruthNames.at(i).key());
+ if(m_detailedTrackTruthNames.empty()){
+ m_detailedTrackTruthNames.reserve ( m_trackCollectionNames.size());
+ for(unsigned int i=0;i<m_trackCollectionNames.size();i++){
+ m_detailedTrackTruthNames.emplace_back(m_trackCollectionNames.at(i).key()+"DetailedTruth");
+ ATH_MSG_INFO("process "<<m_trackCollectionNames.at(i).key()<<" for detailed truth collection "<<m_detailedTrackTruthNames.at(i).key());
+ }
+ }
+ else{
+ for(unsigned int i=0;i<m_detailedTrackTruthNames.size();i++){
+ m_detailedTrackTruthNames.at(i)=m_detailedTrackTruthNames.at(i).key()+"DetailedTruth";
+ }
}
ATH_CHECK(m_trackCollectionNames.initialize());
@@ -72,6 +80,21 @@ StatusCode MuonDetailedTrackTruthMaker::execute() {
//----------------------------------------------------------------
// Retrieve track collections
+
+ std::map<std::string,DetailedTrackTruthCollection*> dttcMap;
+ for(SG::WriteHandle<DetailedTrackTruthCollection>& h_dttc : m_detailedTrackTruthNames.makeHandles()){
+ ATH_CHECK(h_dttc.record(std::make_unique<DetailedTrackTruthCollection>()));
+ if(h_dttc.key().find("ExtrapolatedMuonTracks")!=std::string::npos) dttcMap.insert(std::pair<std::string,DetailedTrackTruthCollection*>("METracks",h_dttc.ptr()));
+ else if(h_dttc.key().find("CombinedMuonTracks")!=std::string::npos) dttcMap.insert(std::pair<std::string,DetailedTrackTruthCollection*>("CombinedTracks",h_dttc.ptr()));
+ else if(h_dttc.key().find("MSOnlyExtrapolated")!=std::string::npos) dttcMap.insert(std::pair<std::string,DetailedTrackTruthCollection*>("MSOnlyExtrapolated",h_dttc.ptr()));
+ else{
+ std::string cname=h_dttc.key();
+ int pos=cname.find("DetailedTruth");
+ cname.erase(pos,cname.length()-pos);
+ dttcMap.insert(std::pair<std::string,DetailedTrackTruthCollection*>(cname,h_dttc.ptr()));
+ }
+ }
+
int i=0;
for(SG::ReadHandle<TrackCollection>& tcol : m_trackCollectionNames.makeHandles()){
if(!tcol.isValid()){
@@ -83,10 +106,19 @@ StatusCode MuonDetailedTrackTruthMaker::execute() {
//----------------------------------------------------------------
// Produce and store the output.
- SG::WriteHandle<DetailedTrackTruthCollection> dttc(m_detailedTrackTruthNames.at(i));
- ATH_CHECK(dttc.record(std::make_unique<DetailedTrackTruthCollection>()));
- dttc->setTrackCollection(tcol.cptr());
- m_truthTool->buildDetailedTrackTruth(dttc.ptr(), *(tcol.cptr()), prdCollectionVector);
+ DetailedTrackTruthCollection* dttc=0;
+ for(auto entry : dttcMap){
+ if(tcol.key().find(entry.first)!=std::string::npos){
+ dttc=entry.second;
+ break;
+ }
+ }
+ if(!dttc){
+ ATH_MSG_WARNING("no detailed track collection found!");
+ continue;
+ }
+ if(!dttc->trackCollectionLink().isValid()) dttc->setTrackCollection(tcol.cptr());
+ m_truthTool->buildDetailedTrackTruth(dttc, *(tcol.cptr()), prdCollectionVector);
i++;
}
return StatusCode::SUCCESS;
diff --git a/MuonSpectrometer/MuonValidation/MuonRecValidation/MuonTrackPerformance/src/MuonRecoValidationTool.cxx b/MuonSpectrometer/MuonValidation/MuonRecValidation/MuonTrackPerformance/src/MuonRecoValidationTool.cxx
index bf65ff87672..2fd46a55f61 100644
--- a/MuonSpectrometer/MuonValidation/MuonRecValidation/MuonTrackPerformance/src/MuonRecoValidationTool.cxx
+++ b/MuonSpectrometer/MuonValidation/MuonRecValidation/MuonTrackPerformance/src/MuonRecoValidationTool.cxx
@@ -198,7 +198,7 @@ namespace Muon {
auto pos = std::find(m_trackParticles.begin(),m_trackParticles.end(),&indetTrackParticle);
if( pos == m_trackParticles.end() ) {
- ATH_MSG_WARNING("addMuonCandidate: indetTrackParticle not found ");
+ ATH_MSG_WARNING("addTimeMeasurement: indetTrackParticle not found ");
return false;
}
int index = std::distance(m_trackParticles.begin(),pos);
@@ -502,7 +502,7 @@ namespace Muon {
}
bool MuonRecoValidationTool::addMuonCandidate( const xAOD::TrackParticle& indetTrackParticle, const MuonCandidate* candidate,
- const Trk::Track* combinedTrack, int ntimes, float beta, float chi2ndof, int stage ) {
+ Trk::Track* combinedTrack, int ntimes, float beta, float chi2ndof, int stage ) {
auto pos = std::find(m_trackParticles.begin(),m_trackParticles.end(),&indetTrackParticle);
if( pos == m_trackParticles.end() ) {
@@ -515,8 +515,9 @@ namespace Muon {
int ntrigPhi = 0;
int ntrigEta = 0;
int nseg = candidate ? candidate->layerIntersections.size() : 0;
+ const Trk::Track* track=combinedTrack;
if( combinedTrack ){
- IMuonHitSummaryTool::CompactSummary summary = m_hitSummaryTool->summary(*combinedTrack);
+ IMuonHitSummaryTool::CompactSummary summary = m_hitSummaryTool->summary(*track);
nprec = summary.nprecisionLayers;
ntrigPhi = summary.nphiLayers;
ntrigEta = summary.ntrigEtaLayers;
diff --git a/MuonSpectrometer/MuonValidation/MuonRecValidation/MuonTrackPerformance/src/MuonRecoValidationTool.h b/MuonSpectrometer/MuonValidation/MuonRecValidation/MuonTrackPerformance/src/MuonRecoValidationTool.h
index ad783a29498..0051f79b2c8 100644
--- a/MuonSpectrometer/MuonValidation/MuonRecValidation/MuonTrackPerformance/src/MuonRecoValidationTool.h
+++ b/MuonSpectrometer/MuonValidation/MuonRecValidation/MuonTrackPerformance/src/MuonRecoValidationTool.h
@@ -58,30 +58,30 @@ namespace Muon {
StatusCode finalize();
/** add a new TrackParticle with it's muon system extension */
- bool addTrackParticle( const xAOD::TrackParticle& indetTrackParticle, const MuonSystemExtension& muonSystemExtention );
+ bool addTrackParticle( const xAOD::TrackParticle& indetTrackParticle, const MuonSystemExtension& muonSystemExtention ) override;
/** add a new segment */
- bool add( const MuonSystemExtension::Intersection& intersection, const MuonSegment& segment, int stage );
+ bool add( const MuonSystemExtension::Intersection& intersection, const MuonSegment& segment, int stage ) override;
/** add a new hough maximum */
- bool add( const MuonSystemExtension::Intersection& intersection, const MuonHough::MuonLayerHough::Maximum& maximum );
+ bool add( const MuonSystemExtension::Intersection& intersection, const MuonHough::MuonLayerHough::Maximum& maximum ) override;
/** add a new prd */
- bool add( const MuonSystemExtension::Intersection& intersection, const Trk::PrepRawData& prd, float expos, float expos_err );
+ bool add( const MuonSystemExtension::Intersection& intersection, const Trk::PrepRawData& prd, float expos, float expos_err ) override;
/** add a new time measurement */
- bool addTimeMeasurement( const MuonSystemExtension::Intersection& intersection, const Trk::MeasurementBase& meas );
+ bool addTimeMeasurement( const MuonSystemExtension::Intersection& intersection, const Trk::MeasurementBase& meas ) override;
/** add a new time measurement */
bool addTimeMeasurement( const MuonSystemExtension::Intersection& intersection, const Identifier& id,
- const Amg::Vector3D& gpos, float time, float errorTime );
+ const Amg::Vector3D& gpos, float time, float errorTime ) override;
/** add StauHits to ntuple */
- bool addTimeMeasurements( const xAOD::TrackParticle& indetTrackParticle, const MuGirlNS::StauHits& stauHits );
+ bool addTimeMeasurements( const xAOD::TrackParticle& indetTrackParticle, const MuGirlNS::StauHits& stauHits ) override;
/** add a new muon candidate */
bool addMuonCandidate( const xAOD::TrackParticle& indetTrackParticle, const MuonCandidate* candidate,
- const Trk::Track* combinedTrack, int ntimes, float beta, float chi2ndof, int stage );
+ Trk::Track* combinedTrack, int ntimes, float beta, float chi2ndof, int stage ) override;
/** incident service handle for EndEvent */
void handle(const Incident& inc);
diff --git a/Reconstruction/MuonIdentification/MuGirl/src/MuGirlRecoTool.cxx b/Reconstruction/MuonIdentification/MuGirl/src/MuGirlRecoTool.cxx
index 379665da764..3a5469f1cbe 100644
--- a/Reconstruction/MuonIdentification/MuGirl/src/MuGirlRecoTool.cxx
+++ b/Reconstruction/MuonIdentification/MuGirl/src/MuGirlRecoTool.cxx
@@ -474,7 +474,7 @@ bool MuGirlRecoTool::RunFromID(MuGirlNS::CandidateSummaryList& summaryList) {
std::vector<const Muon::MuonSegment*> stauSegmentList = *m_pStauTool->newMdtSegments();
m_pSegmentManager->setInStore(stauSegmentList, true);
-
+ /*
std::unique_ptr<MuonCombined::MuGirlLowBetaTag> lowbetatag{new MuonCombined::MuGirlLowBetaTag(stauRefittedTrack,
stauSegmentList)};
@@ -483,7 +483,7 @@ bool MuGirlRecoTool::RunFromID(MuGirlNS::CandidateSummaryList& summaryList) {
lowbetatag->setMuBeta(Beta);
lowbetatag->setStauSummary(stauSummary.release());
lowbetatag->setStauExtras(stauExtras.release());
-
+ */
//pParticle->pInDetCandidate->addTag(*lowbetatag);
} else {
ATH_MSG_DEBUG("stauRefittedTrack is NULL");
@@ -509,10 +509,11 @@ bool MuGirlRecoTool::RunFromID(MuGirlNS::CandidateSummaryList& summaryList) {
ATH_MSG_DEBUG("RunFromID: doRH == true");
std::unique_ptr<MuGirlNS::RHExtras> rhExtras(new MuGirlNS::RHExtras);
if (m_pStauTool->fillRHExtras(rhExtras.get()).isFailure()) ATH_MSG_DEBUG("RunFromID: Cannot fill rhExtras");
- if (rhExtras->numCaloCells > 0) {
+ if (rhExtras->numCaloCells > 0) {/*
std::unique_ptr<MuonCombined::MuGirlLowBetaTag> lowbetatag
{new MuonCombined::MuGirlLowBetaTag(pTrackParticle->track(), std::vector<const Muon::MuonSegment*>())};
lowbetatag->setRHExtras(rhExtras.release());
+ */
//pParticle->pInDetCandidate->addTag(*lowbetatag);
}
ATH_MSG_DEBUG("RunFromID: doRH == true - done");
@@ -527,7 +528,7 @@ bool MuGirlRecoTool::RunFromID(MuGirlNS::CandidateSummaryList& summaryList) {
//Generate the MuGirlTag according to the new running schema: MuGirlTag will delete the segments
//Otherwise put the list of MuGirl Segments into Storegate: Storegate will delete the segments
-
+ /*
ATH_MSG_DEBUG("RunFromID: delivering the muon pTrkRefitted track to the MuGirl tag");
std::vector<const Muon::MuonSegment*> muonSegmentList = summary->muonSegmentList;
std::unique_ptr<MuonCombined::MuGirlTag> tag{};
@@ -536,9 +537,10 @@ bool MuGirlRecoTool::RunFromID(MuGirlNS::CandidateSummaryList& summaryList) {
tag.reset(new MuonCombined::MuGirlTag(muonSegmentList));
} else tag.reset(new MuonCombined::MuGirlTag(summary->pTrkRefitted, muonSegmentList));
tag->setUpdatedExtrapolatedTrack(std::move(summary->pTrkMSRefitted));
+ */
//pParticle->pInDetCandidate->addTag(*tag);
//set the segment into SegmentManager undeletable
- m_pSegmentManager->setInStore(muonSegmentList, true);
+ //m_pSegmentManager->setInStore(muonSegmentList, true);
summary->saveStau = 0;
//m_pCandidate->releaseMuonSegments(false); //the segments released from Candidate ownership
//summaryList.push_back(summary.release());
@@ -547,14 +549,15 @@ bool MuGirlRecoTool::RunFromID(MuGirlNS::CandidateSummaryList& summaryList) {
// m_pCandidate->releaseMuonSegments(true);
//Generate the MuGirlTag according to the new running schema: MuGirlTag will delete the segments
-
+ /*
ATH_MSG_DEBUG("RunFromID: delivering the pTrkLowBeta to the MuGirl tag");
std::vector<const Muon::MuonSegment*> muonSegmentList = summary->muonSegmentList;
MuonCombined::MuGirlTag* tag = new MuonCombined::MuGirlTag(summary->pTrkLowBeta, muonSegmentList);
tag->setUpdatedExtrapolatedTrack(nullptr);
+ */
//pParticle->pInDetCandidate->addTag(*tag);
//set the segment into SegmentManager undeletable
- m_pSegmentManager->setInStore(muonSegmentList, true);
+ //m_pSegmentManager->setInStore(muonSegmentList, true);
}
if (m_doNTuple) {
diff --git a/Reconstruction/MuonIdentification/MuidInterfaces/MuidInterfaces/IMuidMuonRecovery.h b/Reconstruction/MuonIdentification/MuidInterfaces/MuidInterfaces/IMuidMuonRecovery.h
index b0ff4fc4294..c980ebe33e3 100644
--- a/Reconstruction/MuonIdentification/MuidInterfaces/MuidInterfaces/IMuidMuonRecovery.h
+++ b/Reconstruction/MuonIdentification/MuidInterfaces/MuidInterfaces/IMuidMuonRecovery.h
@@ -45,8 +45,8 @@ public:
/**IMuidMuonRecovery interface:
algorithmic code for recovering muon spectrometer using the inner detector track */
- virtual const Trk::Track* recoverableMatch (const Trk::Track& indetTrack,
- const Trk::Track& spectrometerTrack) const = 0;
+ virtual Trk::Track* recoverableMatch (const Trk::Track& indetTrack,
+ const Trk::Track& spectrometerTrack) const = 0;
};
} // end of namespace
diff --git a/Reconstruction/MuonIdentification/MuidTrackBuilder/MuidTrackBuilder/MuidMuonRecovery.h b/Reconstruction/MuonIdentification/MuidTrackBuilder/MuidTrackBuilder/MuidMuonRecovery.h
index be605a4efa7..9e5ed941f9a 100644
--- a/Reconstruction/MuonIdentification/MuidTrackBuilder/MuidTrackBuilder/MuidMuonRecovery.h
+++ b/Reconstruction/MuonIdentification/MuidTrackBuilder/MuidTrackBuilder/MuidMuonRecovery.h
@@ -54,8 +54,8 @@ public:
/**IMuidMuonRecovery interface:
algorithmic code for recovering muon spectrometer using the inner detector track */
- const Trk::Track* recoverableMatch (const Trk::Track& indetTrack,
- const Trk::Track& spectrometerTrack) const;
+ Trk::Track* recoverableMatch (const Trk::Track& indetTrack,
+ const Trk::Track& spectrometerTrack) const;
private:
// helpers, managers, tools
diff --git a/Reconstruction/MuonIdentification/MuidTrackBuilder/src/MuidMuonRecovery.cxx b/Reconstruction/MuonIdentification/MuidTrackBuilder/src/MuidMuonRecovery.cxx
index ba0cd2ec2d4..15115425928 100644
--- a/Reconstruction/MuonIdentification/MuidTrackBuilder/src/MuidMuonRecovery.cxx
+++ b/Reconstruction/MuonIdentification/MuidTrackBuilder/src/MuidMuonRecovery.cxx
@@ -36,6 +36,7 @@
#include "TrkToolInterfaces/IResidualPullCalculator.h"
#include "TrkTrack/Track.h"
#include "TrkTrackSummary/TrackSummary.h"
+#include "TrkSegment/SegmentCollection.h"
namespace Rec
{
@@ -147,7 +148,7 @@ MuidMuonRecovery::finalize()
}
-const Trk::Track*
+Trk::Track*
MuidMuonRecovery::recoverableMatch (const Trk::Track& indetTrack,
const Trk::Track& spectrometerTrack) const
{
@@ -390,7 +391,7 @@ if (msgLvl(MSG::DEBUG))
}
// fit the combined track
- const Trk::Track* combinedTrack = 0;
+ Trk::Track* combinedTrack = 0;
if (! m_trackBuilder.empty())
{
combinedTrack = m_trackBuilder->indetExtension(indetTrack,
diff --git a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedAlg.cxx b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedAlg.cxx
index badea7d2eb6..2815d4a3cbf 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedAlg.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedAlg.cxx
@@ -16,6 +16,8 @@ StatusCode MuonCombinedAlg::initialize()
ATH_CHECK(m_indetCandidateCollectionName.initialize());
ATH_CHECK(m_muonCandidateCollectionName.initialize());
ATH_CHECK(m_combTagMaps.initialize());
+ ATH_CHECK(m_muidCombinedTracks.initialize());
+ ATH_CHECK(m_muidMETracks.initialize());
return StatusCode::SUCCESS;
}
@@ -50,9 +52,16 @@ StatusCode MuonCombinedAlg::execute()
maps.push_back(h.ptr());
}
+ SG::WriteHandle<TrackCollection> muidCombTracks(m_muidCombinedTracks);
+ ATH_CHECK(muidCombTracks.record(std::make_unique<TrackCollection>()));
+
+ SG::WriteHandle<TrackCollection> muidMETracks(m_muidMETracks);
+ ATH_CHECK(muidMETracks.record(std::make_unique<TrackCollection>()));
+
if(inDetCandidateCollection->empty() || muonCandidateCollection->empty()) return StatusCode::SUCCESS;
- m_muonCombinedTool->combine(*muonCandidateCollection,*inDetCandidateCollection,maps);
+ //note that STACO does not create new Trk::Tracks so it doesn't need collections here
+ m_muonCombinedTool->combine(*muonCandidateCollection,*inDetCandidateCollection,maps,muidCombTracks.ptr(),muidMETracks.ptr());
return StatusCode::SUCCESS;
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedAlg.h b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedAlg.h
index 4af8c52449b..aa2e6a60687 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedAlg.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedAlg.h
@@ -14,6 +14,7 @@
#include "MuonCombinedEvent/MuonCandidate.h"
#include "MuonCombinedEvent/InDetCandidateToTagMap.h"
#include "MuonCombinedToolInterfaces/IMuonCombinedTool.h"
+#include "TrkTrack/TrackCollection.h"
#include <string>
#include <vector>
@@ -39,6 +40,8 @@ class MuonCombinedAlg : public AthAlgorithm
SG::ReadHandleKey<InDetCandidateCollection> m_indetCandidateCollectionName{this,"InDetCandidateLocation","InDetCandidates","name of ID candidate collection"};
SG::ReadHandleKey<MuonCandidateCollection> m_muonCandidateCollectionName{this,"MuonCandidateLocation","MuonCandidates","name of muon candidate collection"};
SG::WriteHandleKeyArray<MuonCombined::InDetCandidateToTagMap> m_combTagMaps{this,"CombinedTagMaps",{"muidcoTagMap","stacoTagMap"},"combined muon tag maps"};
+ SG::WriteHandleKey<TrackCollection> m_muidCombinedTracks{this,"MuidCombinedTracksLocation","MuidCombinedTracks","Muidco combined Tracks"};
+ SG::WriteHandleKey<TrackCollection> m_muidMETracks{this,"MuidMETracksLocation","MuidMETracks","Muidco ME Tracks"};
};
diff --git a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedInDetExtensionAlg.cxx b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedInDetExtensionAlg.cxx
index 213cc00ab4e..99e513cd5b0 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedInDetExtensionAlg.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedInDetExtensionAlg.cxx
@@ -28,6 +28,9 @@ StatusCode MuonCombinedInDetExtensionAlg::initialize()
ATH_CHECK(m_sTGC_ContainerName.initialize(m_usePRDs && m_useNSW));
ATH_CHECK(m_MM_ContainerName.initialize(m_usePRDs && m_useNSW));
ATH_CHECK(m_tagMap.initialize());
+ ATH_CHECK(m_combTracks.initialize(m_combTracks.key()!=""));
+ ATH_CHECK(m_METracks.initialize(m_METracks.key()!=""));
+ ATH_CHECK(m_segments.initialize(m_segments.key()!=""));
return StatusCode::SUCCESS;
}
@@ -44,23 +47,50 @@ StatusCode MuonCombinedInDetExtensionAlg::execute()
SG::WriteHandle<MuonCombined::InDetCandidateToTagMap> tagMap(m_tagMap);
ATH_CHECK( tagMap.record (std::make_unique<MuonCombined::InDetCandidateToTagMap>()) );
+ TrackCollection* combTracks=nullptr;
+ TrackCollection* meTracks=nullptr;
+ Trk::SegmentCollection* segments=nullptr;
+
+ if(m_combTracks.key()!=""){
+ SG::WriteHandle<TrackCollection> wh_combTracks(m_combTracks);
+ ATH_CHECK(wh_combTracks.record(std::make_unique<TrackCollection>()));
+ combTracks=wh_combTracks.ptr();
+ }
+ if(m_METracks.key()!=""){
+ SG::WriteHandle<TrackCollection> wh_meTracks(m_METracks);
+ ATH_CHECK(wh_meTracks.record(std::make_unique<TrackCollection>()));
+ meTracks=wh_meTracks.ptr();
+ }
+
+ if(m_segments.key()!=""){
+ SG::WriteHandle<Trk::SegmentCollection> wh_segs(m_segments);
+ ATH_CHECK(wh_segs.record(std::make_unique<Trk::SegmentCollection>()));
+ segments=wh_segs.ptr();
+ }
+
if(m_usePRDs){
+ MuonCombined::IMuonCombinedInDetExtensionTool::MuonPrdData prdData;
SG::ReadHandle<Muon::MdtPrepDataContainer> mdtPRDContainer(m_MDT_ContainerName);
- SG::ReadHandle<Muon::CscPrepDataContainer> cscPRDContainer(m_CSC_ContainerName);
- SG::ReadHandle<Muon::RpcPrepDataContainer> rpcPRDContainer(m_RPC_ContainerName);
- SG::ReadHandle<Muon::TgcPrepDataContainer> tgcPRDContainer(m_TGC_ContainerName);
- if (m_useNSW) {
+ prdData.mdtPrds=mdtPRDContainer.cptr();
+ if(!m_useNSW){
+ SG::ReadHandle<Muon::CscPrepDataContainer> cscPRDContainer(m_CSC_ContainerName);
+ prdData.cscPrds=cscPRDContainer.cptr();
+ }
+ else{
SG::ReadHandle<Muon::sTgcPrepDataContainer> stgcPRDContainer(m_sTGC_ContainerName);
SG::ReadHandle<Muon::MMPrepDataContainer> mmPRDContainer(m_MM_ContainerName);
- for(auto& tool : m_muonCombinedInDetExtensionTools)
- tool->extendWithPRDs(*indetCandidateCollection,tagMap.ptr(),mdtPRDContainer.cptr(),cscPRDContainer.cptr(),rpcPRDContainer.cptr(),tgcPRDContainer.cptr(),stgcPRDContainer.cptr(),mmPRDContainer.cptr());
- } else {
- for(auto& tool : m_muonCombinedInDetExtensionTools)
- tool->extendWithPRDs(*indetCandidateCollection,tagMap.ptr(),mdtPRDContainer.cptr(),cscPRDContainer.cptr(),rpcPRDContainer.cptr(),tgcPRDContainer.cptr(),0,0);
- }
+ prdData.stgcPrds=stgcPRDContainer.cptr();
+ prdData.mmPrds=mmPRDContainer.cptr();
+ }
+ SG::ReadHandle<Muon::RpcPrepDataContainer> rpcPRDContainer(m_RPC_ContainerName);
+ prdData.rpcPrds=rpcPRDContainer.cptr();
+ SG::ReadHandle<Muon::TgcPrepDataContainer> tgcPRDContainer(m_TGC_ContainerName);
+ prdData.tgcPrds=tgcPRDContainer.cptr();
+ for(auto& tool : m_muonCombinedInDetExtensionTools)
+ tool->extendWithPRDs(*indetCandidateCollection,tagMap.ptr(),prdData,combTracks,meTracks,segments);
} else{
for(auto& tool : m_muonCombinedInDetExtensionTools)
- tool->extend(*indetCandidateCollection,tagMap.ptr());
+ tool->extend(*indetCandidateCollection,tagMap.ptr(),combTracks,meTracks,segments);
}
return StatusCode::SUCCESS;
diff --git a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedInDetExtensionAlg.h b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedInDetExtensionAlg.h
index a3854bbc5ab..8782d9c11ba 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedInDetExtensionAlg.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedInDetExtensionAlg.h
@@ -13,6 +13,8 @@
#include "MuonPrepRawData/MuonPrepDataContainer.h"
#include "MuonPrepRawData/MMPrepDataContainer.h"
#include "MuonPrepRawData/sTgcPrepDataContainer.h"
+#include "TrkTrack/TrackCollection.h"
+#include "TrkSegment/SegmentCollection.h"
#include <string>
namespace MuonCombined {
@@ -40,6 +42,9 @@ class MuonCombinedInDetExtensionAlg : public AthAlgorithm
SG::ReadHandleKey<Muon::sTgcPrepDataContainer> m_sTGC_ContainerName{this,"sTGCPrepDataLocation","sTGC_Clusters","sTGC prep data"};
SG::ReadHandleKey<Muon::MMPrepDataContainer> m_MM_ContainerName{this,"MMPrepDataLocation","MM_Clusters","MM prep data"};
SG::WriteHandleKey<MuonCombined::InDetCandidateToTagMap> m_tagMap{this,"TagMap","muGirlTagMap","tag map"};
+ SG::WriteHandleKey<TrackCollection> m_combTracks{this,"CombinedTrackCollection","MuGirlCombinedTracks","combined track collection"};
+ SG::WriteHandleKey<TrackCollection> m_METracks{this,"METrackCollection","MuGirlMETracks","ME track collection"};
+ SG::WriteHandleKey<Trk::SegmentCollection> m_segments{this,"SegmentCollection","MuGirlSegments","Segment collection"};
bool m_usePRDs;
bool m_useNSW;
};
diff --git a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedMuonCandidateAlg.cxx b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedMuonCandidateAlg.cxx
index 2ef3ad4f3c5..c9e5a802efb 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedMuonCandidateAlg.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedMuonCandidateAlg.cxx
@@ -16,6 +16,7 @@ StatusCode MuonCombinedMuonCandidateAlg::initialize()
ATH_CHECK(m_muonCandidateTool.retrieve());
ATH_CHECK(m_muonTrackParticleLocation.initialize());
ATH_CHECK(m_candidateCollectionName.initialize());
+ ATH_CHECK(m_msOnlyTracks.initialize());
return StatusCode::SUCCESS;
}
@@ -35,7 +36,9 @@ StatusCode MuonCombinedMuonCandidateAlg::execute()
SG::WriteHandle<MuonCandidateCollection> muonCandidates(m_candidateCollectionName);
ATH_CHECK(muonCandidates.record(std::make_unique<MuonCandidateCollection>()));
- m_muonCandidateTool->create(*muonTrackParticles,*muonCandidates);
+ SG::WriteHandle<TrackCollection> msOnlyTracks(m_msOnlyTracks);
+ ATH_CHECK(msOnlyTracks.record(std::make_unique<TrackCollection>()));
+ m_muonCandidateTool->create(*muonTrackParticles,*muonCandidates,*msOnlyTracks);
return StatusCode::SUCCESS;
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedMuonCandidateAlg.h b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedMuonCandidateAlg.h
index ea07afe1334..2a89ba830b0 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedMuonCandidateAlg.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCombinedMuonCandidateAlg.h
@@ -12,6 +12,7 @@
#include "xAODTracking/TrackParticleContainer.h"
#include "MuonCombinedEvent/MuonCandidateCollection.h"
#include "MuonCombinedToolInterfaces/IMuonCandidateTool.h"
+#include "TrkTrack/TrackCollection.h"
#include <string>
namespace MuonCombined {
@@ -33,7 +34,7 @@ class MuonCombinedMuonCandidateAlg : public AthAlgorithm
ToolHandle<MuonCombined::IMuonCandidateTool> m_muonCandidateTool{this,"MuonCandidateTool","MuonCombined::MuonCandidateTool/MuonCandidateTool","Muon Candidate Tool"};
SG::ReadHandleKey<xAOD::TrackParticleContainer> m_muonTrackParticleLocation{this,"MuonSpectrometerTrackParticleLocation","MuonSpectrometerTrackParticles","MS Track Particle collection"};
SG::WriteHandleKey<MuonCandidateCollection> m_candidateCollectionName{this,"MuonCandidateLocation","MuonCandidates","Muon candidate collection"};
-
+ SG::WriteHandleKey<TrackCollection> m_msOnlyTracks{this,"MSOnlyExtrapolatedTrackLocation","MSOnlyExtrapolatedMuonTracks","MS extrapolated muon tracks"};
};
diff --git a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCreatorAlg.cxx b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCreatorAlg.cxx
index 2832188d7c6..cb3e6227860 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCreatorAlg.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCreatorAlg.cxx
@@ -40,22 +40,13 @@ StatusCode MuonCreatorAlg::initialize()
ATH_CHECK(m_muonCandidateCollectionName.initialize(!m_buildSlowMuon));
//Can't use a flag in intialize for an array of keys
if(!m_doSA) ATH_CHECK(m_tagMaps.initialize());
- m_segTrkContainerName = "Trk"+m_segContainerName.key();
- m_segContainerName = "xaod"+m_segContainerName.key();
ATH_CHECK(m_segContainerName.initialize());
- ATH_CHECK(m_segTrkContainerName.initialize());
- m_combinedTrkCollectionName = m_combinedCollectionName.key()+"Tracks";
m_combinedCollectionName = m_combinedCollectionName.key()+"TrackParticles";
ATH_CHECK(m_combinedCollectionName.initialize());
- ATH_CHECK(m_combinedTrkCollectionName.initialize());
- m_extrapolatedTrkCollectionName = m_extrapolatedCollectionName.key()+"Tracks";
m_extrapolatedCollectionName = m_extrapolatedCollectionName.key()+"TrackParticles";
ATH_CHECK(m_extrapolatedCollectionName.initialize());
- ATH_CHECK(m_extrapolatedTrkCollectionName.initialize());
- m_msOnlyExtrapolatedTrkCollectionName = m_msOnlyExtrapolatedCollectionName.key()+"Tracks";
m_msOnlyExtrapolatedCollectionName = m_msOnlyExtrapolatedCollectionName.key()+"TrackParticles";
ATH_CHECK(m_msOnlyExtrapolatedCollectionName.initialize());
- ATH_CHECK(m_msOnlyExtrapolatedTrkCollectionName.initialize());
ATH_CHECK(m_clusterContainerName.initialize(m_makeClusters));
m_clusterContainerLinkName = m_clusterContainerName.key()+"_links";
ATH_CHECK(m_clusterContainerLinkName.initialize(m_makeClusters));
@@ -88,43 +79,27 @@ StatusCode MuonCreatorAlg::execute()
MuonCombined::IMuonCreatorTool::OutputData output(*(wh_muons.ptr()));
-
-
// Create and record track particles:
//combined tracks
SG::WriteHandle<xAOD::TrackParticleContainer> wh_combtp(m_combinedCollectionName);
- SG::WriteHandle<TrackCollection> wh_combtrk(m_combinedTrkCollectionName);
ATH_CHECK(wh_combtp.record(std::make_unique<xAOD::TrackParticleContainer>(), std::make_unique<xAOD::TrackParticleAuxContainer>()));
- ATH_CHECK(wh_combtrk.record(std::make_unique<TrackCollection>()));
output.combinedTrackParticleContainer = wh_combtp.ptr();
- output.combinedTrackCollection = wh_combtrk.ptr();
//extrapolated tracks
SG::WriteHandle<xAOD::TrackParticleContainer> wh_extrtp(m_extrapolatedCollectionName);
- SG::WriteHandle<TrackCollection> wh_extrtrk(m_extrapolatedTrkCollectionName);
ATH_CHECK(wh_extrtp.record(std::make_unique<xAOD::TrackParticleContainer>(), std::make_unique<xAOD::TrackParticleAuxContainer>()));
- ATH_CHECK(wh_extrtrk.record(std::make_unique<TrackCollection>()));
output.extrapolatedTrackParticleContainer = wh_extrtp.ptr();
- output.extrapolatedTrackCollection = wh_extrtrk.ptr();
//msonly tracks
SG::WriteHandle<xAOD::TrackParticleContainer> wh_msextrtp(m_msOnlyExtrapolatedCollectionName);
- SG::WriteHandle<TrackCollection> wh_msextrtrk(m_msOnlyExtrapolatedTrkCollectionName);
ATH_CHECK(wh_msextrtp.record(std::make_unique<xAOD::TrackParticleContainer>(), std::make_unique<xAOD::TrackParticleAuxContainer>()));
- ATH_CHECK(wh_msextrtrk.record(std::make_unique<TrackCollection>()));
output.msOnlyExtrapolatedTrackParticleContainer = wh_msextrtp.ptr();
- output.msOnlyExtrapolatedTrackCollection = wh_msextrtrk.ptr();
-
//segments
SG::WriteHandle<xAOD::MuonSegmentContainer> wh_segment(m_segContainerName);
ATH_CHECK(wh_segment.record(std::make_unique<xAOD::MuonSegmentContainer>(),std::make_unique<xAOD::MuonSegmentAuxContainer>()));
output.xaodSegmentContainer=wh_segment.ptr();
- SG::WriteHandle<Trk::SegmentCollection> wh_segmentTrk(m_segTrkContainerName);
- ATH_CHECK(wh_segmentTrk.record(std::make_unique<Trk::SegmentCollection>()));
- output.muonSegmentCollection=wh_segmentTrk.ptr();
-
// calo clusters
SG::WriteHandle<xAOD::CaloClusterContainer> wh_clusters;
SG::WriteHandle<CaloClusterCellLinkContainer> wh_clusterslink;
diff --git a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCreatorAlg.h b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCreatorAlg.h
index 1e7e2323a3b..e568d04b98c 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCreatorAlg.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedAlgs/src/MuonCreatorAlg.h
@@ -42,16 +42,12 @@ class MuonCreatorAlg : public AthAlgorithm
SG::WriteHandleKey<xAOD::MuonContainer> m_muonCollectionName{this,"MuonContainerLocation", "Muons", "Muon Container"};
SG::WriteHandleKey<xAOD::SlowMuonContainer> m_slowMuonCollectionName{this, "SlowMuonContainerLocation", "SlowMuons", "Slow Muon Container"};
SG::WriteHandleKey<xAOD::TrackParticleContainer> m_combinedCollectionName{this, "CombinedLocation", "CombinedMuon", "Combined muons"};
- SG::WriteHandleKey<TrackCollection> m_combinedTrkCollectionName{this,"CombinedTrackLocation","CombinedMuon","Combined muon tracks"};
SG::WriteHandleKey<xAOD::TrackParticleContainer> m_extrapolatedCollectionName{this, "ExtrapolatedLocation", "ExtrapolatedMuon", "Extrapolated muons"};
- SG::WriteHandleKey<TrackCollection> m_extrapolatedTrkCollectionName{this,"ExtrapolatedTrackLocation","ExtrapolatedMuon","Extrapolated muon tracks"};
SG::WriteHandleKey<xAOD::TrackParticleContainer> m_msOnlyExtrapolatedCollectionName{this, "MSOnlyExtrapolatedLocation", "MSOnlyExtrapolatedMuon", "MS Extrapolated muons"};
- SG::WriteHandleKey<TrackCollection> m_msOnlyExtrapolatedTrkCollectionName{this,"MSOnlyExtrapolatedTrackLocation","MSOnlyExtrapolatedMuon","MS extrapolated muon tracks"};
SG::ReadHandleKey<InDetCandidateCollection> m_indetCandidateCollectionName{this,"InDetCandidateLocation","InDetCandidates","ID candidates"};
SG::ReadHandleKey<MuonCandidateCollection> m_muonCandidateCollectionName{this,"MuonCandidateLocation","MuonCandidates","Muon candidates"};
SG::ReadHandleKeyArray<MuonCombined::InDetCandidateToTagMap> m_tagMaps{this,"TagMaps",{"muidcoTagMap","stacoTagMap","muGirlTagMap","caloTagMap","segmentTagMap"},"ID candidate to tag maps"};
- SG::WriteHandleKey<xAOD::MuonSegmentContainer> m_segContainerName{this, "SegmentContainerName", "MuonSegments", "Segments"};
- SG::WriteHandleKey<Trk::SegmentCollection> m_segTrkContainerName{this,"TrackSegmentContainerName","MuonSegments","Track segments"};
+ SG::WriteHandleKey<xAOD::MuonSegmentContainer> m_segContainerName{this, "SegmentContainerName", "MuGirlMuonSegments", "New segments"};
SG::WriteHandleKey<xAOD::CaloClusterContainer> m_clusterContainerName{this, "ClusterContainerName", "MuonClusterCollection", "Clusters"};
SG::WriteHandleKey<CaloClusterCellLinkContainer> m_clusterContainerLinkName{this,"CaloClusterCellLinkName","MuonClusterCollection","Cluster links"};
bool m_buildSlowMuon;
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuGirlTagTool.cxx b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuGirlTagTool.cxx
index 1cdd08a8612..774277391ff 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuGirlTagTool.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuGirlTagTool.cxx
@@ -50,18 +50,18 @@ namespace MuonCombined {
return StatusCode::SUCCESS;
}
- void MuGirlTagTool::extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap ) {
- if(!tagMap) ATH_MSG_DEBUG("We don't run this tool any more anyway");
+ void MuGirlTagTool::extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks, TrackCollection* meTracks,
+ Trk::SegmentCollection* segments ) {
+ if(!tagMap || !combTracks || !meTracks || !segments) ATH_MSG_DEBUG("We don't run this tool any more anyway");
if (m_pMuGirlReconstruction->MuGirlReco(inDetCandidates).isFailure()) {
ATH_MSG_ERROR("MuGirl reconstruction failed!");
}
}
- void MuGirlTagTool::extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap,
- const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpcPRDs,
- const Muon::TgcPrepDataContainer *tgcPRDs, const Muon::sTgcPrepDataContainer* stgcPRDs, const Muon::MMPrepDataContainer* mmPRDs ) {
+ void MuGirlTagTool::extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) {
//This is just a placeholder to ensure compilation until this tool is removed from the release: it is already deprecated
- if(mdtPRDs && cscPRDs && rpcPRDs && tgcPRDs && stgcPRDs && mmPRDs && tagMap){
+ if(prdData.mdtPrds && tagMap && combTracks && meTracks && segments){
if (m_pMuGirlReconstruction->MuGirlReco(inDetCandidates).isFailure()) {
ATH_MSG_ERROR("MuGirl reconstruction failed!");
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuGirlTagTool.h b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuGirlTagTool.h
index 28bdb47b5c4..77c7a2e3ed6 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuGirlTagTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuGirlTagTool.h
@@ -26,11 +26,11 @@ namespace MuonCombined {
virtual StatusCode finalize() override;
/**IMuonCombinedInDetExtensionTool interface: extend ID candidate */
- virtual void extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap ) override;
+ virtual void extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) override;
- virtual void extendWithPRDs(const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap,
- const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpdPRDs,
- const Muon::TgcPrepDataContainer* tgcPRDs, const Muon::sTgcPrepDataContainer* sTGCPRDs, const Muon::MMPrepDataContainer* mmPRDs) override;
+ virtual void extendWithPRDs(const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) override;
private:
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCaloTagTool.cxx b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCaloTagTool.cxx
index 0d8e32d90bf..487ac24e114 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCaloTagTool.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCaloTagTool.cxx
@@ -128,15 +128,17 @@ namespace MuonCombined {
}
- void MuonCaloTagTool::extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap,
- const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpcPRDs,
- const Muon::TgcPrepDataContainer *tgcPRDs, const Muon::sTgcPrepDataContainer* stgcPRDs, const Muon::MMPrepDataContainer* mmPRDs ) {
+ void MuonCaloTagTool::extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) {
//shouldn't need this interface for this tool, I don't think
- if(!mdtPRDs || !cscPRDs || !rpcPRDs || !tgcPRDs || !stgcPRDs || !mmPRDs) ATH_MSG_DEBUG("calo-tagging doesn't need PRDs");
- extend(inDetCandidates, tagMap);
+ if(!prdData.mdtPrds) ATH_MSG_DEBUG("calo-tagging doesn't need PRDs");
+ extend(inDetCandidates, tagMap, combTracks, meTracks, segments);
}
- void MuonCaloTagTool::extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap ) {
+ void MuonCaloTagTool::extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks, TrackCollection* meTracks,
+ Trk::SegmentCollection* segments) {
+
+ if(combTracks || meTracks || segments) ATH_MSG_DEBUG("track collections passed to MuonCaloTagTool?");
const xAOD::CaloClusterContainer* caloClusterCont=0;
const CaloCellContainer* caloCellCont=0;
if(m_doCaloLR){ //retrieve the xAOD::CaloClusterContainer
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCaloTagTool.h b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCaloTagTool.h
index 7031f81c703..ac21f9bcd54 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCaloTagTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCaloTagTool.h
@@ -49,16 +49,16 @@ namespace MuonCombined {
/**IMuonCombinedInDetExtensionTool interface: extend ID candidate */
virtual
- void extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap ) override;
+ void extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks, TrackCollection* meTracks,
+ Trk::SegmentCollection* segments ) override;
virtual
void extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap,
const CaloCellContainer* caloCellContainer,
const xAOD::CaloClusterContainer* caloClusterContainer) override;
- virtual void extendWithPRDs(const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap,
- const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpdPRDs,
- const Muon::TgcPrepDataContainer* tgcPRDs, const Muon::sTgcPrepDataContainer* sTGCPRDs, const Muon::MMPrepDataContainer* mmPRDs) override;
+ virtual void extendWithPRDs(const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) override;
private:
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCandidateTool.cxx b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCandidateTool.cxx
index 969db192e99..c4f7e6d9677 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCandidateTool.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCandidateTool.cxx
@@ -55,7 +55,7 @@ namespace MuonCombined {
return StatusCode::SUCCESS;
}
- void MuonCandidateTool::create( const xAOD::TrackParticleContainer& tracks, MuonCandidateCollection& outputCollection ) {
+ void MuonCandidateTool::create( const xAOD::TrackParticleContainer& tracks, MuonCandidateCollection& outputCollection, TrackCollection& outputTracks ) {
ATH_MSG_DEBUG("Producing MuonCandidates for " << tracks.size() );
unsigned int ntracks = 0;
SG::ReadHandle<xAOD::EventInfo> eventInfo(m_evInfo);
@@ -69,13 +69,11 @@ namespace MuonCombined {
beamSpotZ = eventInfo->beamPosZ();
}
ATH_MSG_DEBUG( " Beamspot position bs_x " << beamSpotX << " bs_y " << beamSpotY << " bs_z " << beamSpotZ);
-
// Temporary collection for extrapolated tracks and links with correspondent MS tracks
- std::map<const Trk::Track*, std::pair<ElementLink<xAOD::TrackParticleContainer>, const Trk::Track*> > trackLinks;
- TrackCollection* extrapTracks = new TrackCollection(SG::VIEW_ELEMENTS);
+ std::map<const Trk::Track*, std::pair<ElementLink<xAOD::TrackParticleContainer>, Trk::Track*> > trackLinks;
+ std::unique_ptr<TrackCollection> extrapTracks(new TrackCollection(SG::VIEW_ELEMENTS));
- // keep track of track to be deleted
std::set<const Trk::Track*> tracksToBeDeleted;
unsigned int index = 0;
@@ -103,17 +101,17 @@ namespace MuonCombined {
if( !standaloneTrack->perigeeParameters() ) ATH_MSG_WARNING(" Track without perigee " << standaloneTrack);
else if( !standaloneTrack->perigeeParameters()->covariance() ) ATH_MSG_WARNING(" Track with perigee without covariance " << standaloneTrack);
trackLinks[ standaloneTrack ] = std::make_pair(trackLink,standaloneTrack);
- extrapTracks->push_back( standaloneTrack );
- tracksToBeDeleted.insert( standaloneTrack ); // insert track for deletion
}else{
- trackLinks[ &msTrack ] = std::make_pair(trackLink,standaloneTrack);
- extrapTracks->push_back( const_cast<Trk::Track*>(&msTrack) );
+ standaloneTrack=new Trk::Track(msTrack);
+ trackLinks[ standaloneTrack ] = std::make_pair(trackLink,nullptr);
}
+ extrapTracks->push_back( standaloneTrack );
+ tracksToBeDeleted.insert( standaloneTrack ); // insert track for deletion
}
ATH_MSG_DEBUG("Finished back-tracking, total number of successfull fits " << ntracks);
// Resolve ambiguity between extrapolated tracks (where available)
- TrackCollection* resolvedTracks = m_ambiguityProcessor->process(extrapTracks);
+ std::unique_ptr<TrackCollection> resolvedTracks(m_ambiguityProcessor->process(extrapTracks.get()));
ATH_MSG_DEBUG("Finished ambiguity solving: "<<extrapTracks->size()<<" track(s) in -> "<<resolvedTracks->size()<<" track(s) out");
@@ -124,12 +122,17 @@ namespace MuonCombined {
if(tLink == trackLinks.end()) {
ATH_MSG_WARNING("Unable to find internal link between MS and SA tracks!");
continue;
- }
+ }
auto tpair = tLink->second;
-
- outputCollection.push_back( new MuonCandidate(tpair.first, tpair.second) );
- // remove track from set so it is not deleted
- tracksToBeDeleted.erase(tpair.second);
+
+ if(tpair.second){
+ outputTracks.push_back(tpair.second);
+ ElementLink<TrackCollection> saLink(outputTracks,outputTracks.size()-1);
+ outputCollection.push_back( new MuonCandidate(tpair.first, saLink) );
+ // remove track from set so it is not deleted
+ tracksToBeDeleted.erase(tpair.second);
+ }
+ else outputCollection.push_back( new MuonCandidate(tpair.first, ElementLink<TrackCollection>()));
}
if( extrapTracks->size() != resolvedTracks->size() + tracksToBeDeleted.size() )
@@ -138,7 +141,5 @@ namespace MuonCombined {
// delete all remaining tracks in the set
for( auto it = tracksToBeDeleted.begin();it!=tracksToBeDeleted.end();++it ) delete *it;
- delete extrapTracks;
- delete resolvedTracks;
}
} // end of namespace
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCandidateTool.h b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCandidateTool.h
index 27505db94f9..f397951c4cf 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCandidateTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCandidateTool.h
@@ -39,7 +39,7 @@ namespace MuonCombined {
/**IMuonCandidateTool interface: build a MuonCandidateCollection from a TrackCollection of spectrometer tracks */
virtual
- void create( const xAOD::TrackParticleContainer& tracks, MuonCandidateCollection& outputCollection ) override;
+ void create( const xAOD::TrackParticleContainer& tracks, MuonCandidateCollection& outputCollection, TrackCollection& outputTracks ) override;
private:
ToolHandle<Muon::MuonEDMPrinterTool> m_printer;
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedFitTagTool.cxx b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedFitTagTool.cxx
index c2c31db8950..ad0a2d28b22 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedFitTagTool.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedFitTagTool.cxx
@@ -110,11 +110,17 @@ namespace MuonCombined {
return StatusCode::SUCCESS;
}
- void MuonCombinedFitTagTool::combine( const MuonCandidate& muonCandidate, const std::vector<const InDetCandidate*>& indetCandidates, InDetCandidateToTagMap& tagMap) const {
+ void MuonCombinedFitTagTool::combine( const MuonCandidate& muonCandidate, const std::vector<const InDetCandidate*>& indetCandidates, InDetCandidateToTagMap& tagMap,
+ TrackCollection* combTracks, TrackCollection* METracks) const {
ATH_MSG_DEBUG("muon candidate: "<<muonCandidate.toString());
- CombinedFitTag* bestTag=0;
+ std::unique_ptr<CombinedFitTag> bestTag=0;
+ std::unique_ptr<Trk::Track> bestCombTrack=0;
+ std::unique_ptr<Trk::Track> bestMETrack=0;
+ std::unique_ptr<Trk::Track> combinedTrack;
+ std::unique_ptr<Trk::Track> METrack;
+ std::unique_ptr<CombinedFitTag> currentTag;
const InDetCandidate* bestCandidate=0;
std::multimap<double,const InDetCandidate*> sortedInDetCandidates; //map of ID candidates by max probability of match (based on match chi2 at IP and MS entrance)
float probCut=.00001; //cut on max probability: below this cut, we don't attempt to form a combined track unless no combined track has yet been successfully created
@@ -138,7 +144,7 @@ namespace MuonCombined {
ATH_MSG_DEBUG("in det candidate prob: "<<(*rit).first);
if((*rit).first<probCut && !fitBadMatches){
- if(!bestCandidate){ ATH_MSG_DEBUG("no combined track yet, keep fitting"); fitBadMatches=true;}
+ if(!bestCombTrack){ ATH_MSG_DEBUG("no combined track yet, keep fitting"); fitBadMatches=true;}
else{ ATH_MSG_DEBUG("combined track found, we're done here"); break;}
}
@@ -151,16 +157,16 @@ namespace MuonCombined {
}
// fit the combined ID-MS track
- const Trk::Track* combinedTrack = buildCombinedTrack (*((*rit).second->indetTrackParticle().track()),
- muonCandidate.muonSpectrometerTrack(),
- muonCandidate.extrapolatedTrack());
+ combinedTrack.reset(buildCombinedTrack (*((*rit).second->indetTrackParticle().track()),
+ muonCandidate.muonSpectrometerTrack(),
+ muonCandidate.extrapolatedTrack()));
if( !combinedTrack ) {
ATH_MSG_DEBUG("Combination fit failed");
continue;
}
if(msgLevel() >= MSG::DEBUG) {
- dumpCaloEloss(combinedTrack, "Combined Track ");
+ dumpCaloEloss(combinedTrack.get(), "Combined Track ");
dumpCaloEloss(muonCandidate.extrapolatedTrack(), "Extrapolated Track ");
}
@@ -168,19 +174,18 @@ namespace MuonCombined {
Trk::TrackScore score = m_trackScoringTool->score(*combinedTrack,true);
// add fit info into tag object
- CombinedFitTag* currentTag = new CombinedFitTag(xAOD::Muon::MuidCo, muonCandidate, *combinedTrack, score);
+ currentTag.reset(new CombinedFitTag(xAOD::Muon::MuidCo, muonCandidate, score));
// re-fit standalone track (if needed) and store output into tag object
- evaluateMatchProperties(*currentTag, *((*rit).second->indetTrackParticle().track()), (*rit).second->indetTrackParticle());
+ METrack.reset(evaluateMatchProperties(combinedTrack.get(), *currentTag, *((*rit).second->indetTrackParticle().track()), (*rit).second->indetTrackParticle()));
// select the best combined track
- if(!bestCandidate || bestMatchChooser(*((*rit).second), *currentTag,
- *bestCandidate, *bestTag)) {
- if( bestTag ) delete bestTag;
+ if(!bestCandidate || bestMatchChooser(*((*rit).second), *currentTag, *combinedTrack, METrack.get(),
+ *bestCandidate, *bestTag, *bestCombTrack, bestMETrack.get())) {
bestCandidate = (*rit).second;
- bestTag = currentTag;
- }else{
- delete currentTag;
+ bestTag.swap(currentTag);
+ bestCombTrack.swap(combinedTrack);
+ bestMETrack.swap(METrack);
}
}
if(!bestCandidate){
@@ -188,7 +193,7 @@ namespace MuonCombined {
if (! m_muonRecovery.empty()){
//for(auto& sidTP : sortedInDetCandidates){
for(rit=sortedInDetCandidates.rbegin();rit!=sortedInDetCandidates.rend();++rit){
- const Trk::Track* combinedTrack = m_muonRecovery->recoverableMatch(*((*rit).second->indetTrackParticle().track()),muonCandidate.muonSpectrometerTrack());
+ combinedTrack.reset(m_muonRecovery->recoverableMatch(*((*rit).second->indetTrackParticle().track()),muonCandidate.muonSpectrometerTrack()));
if (combinedTrack && combinedTrackQualityCheck(*combinedTrack,*((*rit).second->indetTrackParticle().track()))){
combinedTrack->info().addPatternReco((*rit).second->indetTrackParticle().track()->info());
combinedTrack->info().addPatternReco(muonCandidate.muonSpectrometerTrack().info());
@@ -198,24 +203,23 @@ namespace MuonCombined {
Trk::TrackScore score = m_trackScoringTool->score(*combinedTrack,true);
// add fit info into tag object
- CombinedFitTag* currentTag = new CombinedFitTag(xAOD::Muon::MuidCo, muonCandidate, *combinedTrack, score);
+ currentTag.reset(new CombinedFitTag(xAOD::Muon::MuidCo, muonCandidate, score));
if(msgLevel() >= MSG::DEBUG) {
- dumpCaloEloss(combinedTrack, "Recovery Combined Track ");
+ dumpCaloEloss(combinedTrack.get(), "Recovery Combined Track ");
dumpCaloEloss(muonCandidate.extrapolatedTrack(), "Recovery Extrapolated Track ");
}
// re-fit standalone track (if needed) and store output into tag object
- evaluateMatchProperties(*currentTag, *((*rit).second->indetTrackParticle().track()), (*rit).second->indetTrackParticle());
+ METrack.reset(evaluateMatchProperties(combinedTrack.get(), *currentTag, *((*rit).second->indetTrackParticle().track()), (*rit).second->indetTrackParticle()));
// select the best combined track
- if(!bestCandidate || bestMatchChooser(*((*rit).second), *currentTag,
- *bestCandidate, *bestTag)) {
- if( bestTag ) delete bestTag;
+ if(!bestCandidate || bestMatchChooser(*((*rit).second), *currentTag, *combinedTrack, METrack.get(),
+ *bestCandidate, *bestTag, *bestCombTrack, bestMETrack.get())) {
bestCandidate = (*rit).second;
- bestTag = currentTag;
- }else{
- delete currentTag;
+ bestTag.swap(currentTag);
+ bestCombTrack.swap(combinedTrack);
+ bestMETrack.swap(METrack);
}
}
}
@@ -225,24 +229,38 @@ namespace MuonCombined {
if( bestCandidate ){
double outerMatchChi2 = 1e19;
// take the best MS Track, first the update extrapolated, than the extrapolated, last the spectrometer track
- const Trk::Track* extrapolatedTrack = bestTag->updatedExtrapolatedTrack();
- if( !extrapolatedTrack ) extrapolatedTrack = muonCandidate.extrapolatedTrack();
- if( !extrapolatedTrack ) extrapolatedTrack = &muonCandidate.muonSpectrometerTrack();
+ bool haveME=true;
+ if( !bestMETrack ){
+ if(muonCandidate.extrapolatedTrack()) bestMETrack.reset(new Trk::Track(*muonCandidate.extrapolatedTrack()));
+ else bestMETrack.reset(new Trk::Track(muonCandidate.muonSpectrometerTrack()));
+ haveME=false;
+ }
- if( bestCandidate->indetTrackParticle().trackLink().isValid() && extrapolatedTrack ){
- outerMatchChi2 = m_tagTool->chi2(*bestCandidate->indetTrackParticle().track(),*extrapolatedTrack);
+ if( bestCandidate->indetTrackParticle().trackLink().isValid() && bestMETrack ){
+ outerMatchChi2 = m_tagTool->chi2(*bestCandidate->indetTrackParticle().track(),*bestMETrack);
if(msgLevel() >= MSG::DEBUG) {
- dumpCaloEloss(&(bestTag->combinedTrack()), " bestCandidate Combined Track ");
- dumpCaloEloss(extrapolatedTrack, " bestCandidate Extrapolated Track ");
+ dumpCaloEloss(bestCombTrack.get(), " bestCandidate Combined Track ");
+ dumpCaloEloss(bestMETrack.get(), " bestCandidate Extrapolated Track ");
}
}
- ATH_MSG_DEBUG("Final combined muon: "<<m_printer->print(bestTag->combinedTrack()));
- ATH_MSG_DEBUG(m_printer->printStations(bestTag->combinedTrack()));
+ ATH_MSG_DEBUG("Final combined muon: "<<m_printer->print(*bestCombTrack));
+ ATH_MSG_DEBUG(m_printer->printStations(*bestCombTrack));
ATH_MSG_DEBUG("Combined Muon with ID " << m_printer->print(bestCandidate->indetTrackParticle().perigeeParameters())
<< " match chi2 " << bestTag->matchChi2() << " outer match " << outerMatchChi2 );
- tagMap.addEntry(bestCandidate,bestTag);
+ combTracks->push_back(bestCombTrack.release());
+ ElementLink<TrackCollection> comblink( *combTracks,combTracks->size()-1);
+ bestTag->setCombinedTrackLink(comblink);
+ if(haveME){
+ METracks->push_back(bestMETrack.release());
+ ElementLink<TrackCollection> melink( *METracks,METracks->size()-1);
+ bestTag->setUpdatedExtrapolatedTrackLink(melink);
+ }
+ else{
+ bestTag->setUpdatedExtrapolatedTrackLink(ElementLink<TrackCollection>());
+ }
+ tagMap.addEntry(bestCandidate,bestTag.release());
}
}
@@ -250,7 +268,7 @@ namespace MuonCombined {
- const Trk::Track* MuonCombinedFitTagTool::buildCombinedTrack(const Trk::Track& indetTrack,
+ Trk::Track* MuonCombinedFitTagTool::buildCombinedTrack(const Trk::Track& indetTrack,
const Trk::Track& spectrometerTrack,
const Trk::Track* extrapolatedTrack) const
{
@@ -258,7 +276,7 @@ namespace MuonCombined {
if(!extrapolatedTrack) extrapolatedTrack = &spectrometerTrack;
// build and fit the combined track
- const Trk::Track* combinedTrack = 0;
+ Trk::Track* combinedTrack = 0;
double combinedFitChi2 = 9999.;
if (! m_trackBuilder.empty()) {
combinedTrack = m_trackBuilder->combinedFit(indetTrack,
@@ -271,7 +289,7 @@ namespace MuonCombined {
}
}
if (combinedFitChi2 > m_badFitChi2 && ! m_outwardsBuilder.empty()) {
- const Trk::Track* outwardsTrack = m_outwardsBuilder->combinedFit(indetTrack,
+ Trk::Track* outwardsTrack = m_outwardsBuilder->combinedFit(indetTrack,
*extrapolatedTrack,
spectrometerTrack);
if (outwardsTrack &&
@@ -299,7 +317,7 @@ namespace MuonCombined {
}
- bool MuonCombinedFitTagTool::combinedTrackQualityCheck(const Trk::Track& combinedTrack,
+ bool MuonCombinedFitTagTool::combinedTrackQualityCheck(Trk::Track& combinedTrack,
const Trk::Track& indetTrack) const
{
// require calo correctly associated to track
@@ -343,11 +361,13 @@ namespace MuonCombined {
}
- void MuonCombinedFitTagTool::evaluateMatchProperties(CombinedFitTag& tag, const Trk::Track& idTrack, const xAOD::TrackParticle& idTrackParticle) const
+ Trk::Track* MuonCombinedFitTagTool::evaluateMatchProperties(Trk::Track* combinedTrack, CombinedFitTag& tag,
+ const Trk::Track& idTrack, const xAOD::TrackParticle& idTrackParticle) const
{
// evaluate field integral and momentum balance significance for combined track
- tag.fieldIntegral(m_trackQuery->fieldIntegral(tag.combinedTrack()));
- tag.momentumBalanceSignificance(m_momentumBalanceTool->momentumBalanceSignificance(tag.combinedTrack()));
+ const Trk::Track* combTrack=combinedTrack;
+ tag.fieldIntegral(m_trackQuery->fieldIntegral(*combTrack));
+ tag.momentumBalanceSignificance(m_momentumBalanceTool->momentumBalanceSignificance(*combTrack));
// keep original SA fit if no change to MS or Calo TSOS
/*bool alwaysRefit = true;
@@ -378,7 +398,7 @@ namespace MuonCombined {
}
// refit extrapolated from combined track (i.e. after cleaning)
- const Trk::Track* refittedExtrapolatedTrack = 0;
+ Trk::Track* refittedExtrapolatedTrack = 0;
bool dorefit = true;
// no SA refit for Toroid off
@@ -420,8 +440,8 @@ namespace MuonCombined {
ATH_MSG_DEBUG( " refit SA track " << dorefit);
if(dorefit) {
- if (! m_trackBuilder.empty()) refittedExtrapolatedTrack = m_trackBuilder->standaloneRefit(tag.combinedTrack(), bs_x, bs_y, bs_z);
- if (! refittedExtrapolatedTrack && ! m_outwardsBuilder.empty()) refittedExtrapolatedTrack = m_outwardsBuilder->standaloneRefit(tag.combinedTrack(), bs_x, bs_y, bs_z);
+ if (! m_trackBuilder.empty()) refittedExtrapolatedTrack = m_trackBuilder->standaloneRefit(*combTrack, bs_x, bs_y, bs_z);
+ if (! refittedExtrapolatedTrack && ! m_outwardsBuilder.empty()) refittedExtrapolatedTrack = m_outwardsBuilder->standaloneRefit(*combTrack, bs_x, bs_y, bs_z);
}
// include vertex region pseudo for extrapolation failure
unsigned numberPseudo = tag.muonCandidate().extrapolatedTrack() ?
@@ -430,12 +450,10 @@ namespace MuonCombined {
// get track quality and store
if (refittedExtrapolatedTrack) {
- // store the refit track in the tag object
- tag.setUpdatedExtrapolatedTrack(refittedExtrapolatedTrack);
-
- double matchChi2 = m_matchQuality->innerMatchChi2(idTrack, *refittedExtrapolatedTrack);
- int matchDoF = m_matchQuality->innerMatchDOF(idTrack, *refittedExtrapolatedTrack);
- double matchProb = m_matchQuality->innerMatchProbability(idTrack, *refittedExtrapolatedTrack);
+ const Trk::Track* METrack=refittedExtrapolatedTrack;
+ double matchChi2 = m_matchQuality->innerMatchChi2(idTrack, *METrack);
+ int matchDoF = m_matchQuality->innerMatchDOF(idTrack, *METrack);
+ double matchProb = m_matchQuality->innerMatchProbability(idTrack, *METrack);
// store the inner matching quality in the tag object
tag.innerMatch(matchChi2, matchDoF, matchProb);
@@ -458,17 +476,24 @@ namespace MuonCombined {
// failed re-evaluation of match chi2
ATH_MSG_WARNING( " evaluateMatchProperties: fail re-evaluation of match chi2");
}
+ return refittedExtrapolatedTrack;
+ }
+
+ void MuonCombinedFitTagTool::dumpCaloEloss(Trk::Track* track, std::string txt ) const
+ {
+ const Trk::Track* inTrack=track;
+ dumpCaloEloss(inTrack,txt);
}
- void MuonCombinedFitTagTool::dumpCaloEloss(const Trk::Track* track, std::string txt ) const
+ void MuonCombinedFitTagTool::dumpCaloEloss(const Trk::Track* inTrack, std::string txt ) const
{
// will refit if extrapolated track was definitely bad
- if (! track) return;
- if (! m_trackQuery->isCaloAssociated(*track)) {
+ if (! inTrack) return;
+ if (! m_trackQuery->isCaloAssociated(*inTrack)) {
ATH_MSG_DEBUG( txt << " no TSOS in Calorimeter ");
return;
}
- const Trk::Track& originalTrack = *track;
+ const Trk::Track& originalTrack = *inTrack;
const CaloEnergy* caloEnergy = m_trackQuery->caloEnergy(originalTrack);
if(caloEnergy) {
ATH_MSG_DEBUG( txt << " Calorimeter Eloss " << caloEnergy->deltaE());
@@ -476,7 +501,7 @@ namespace MuonCombined {
ATH_MSG_DEBUG( txt << " No Calorimeter Eloss");
}
- const DataVector <const Trk::TrackStateOnSurface>* trackTSOS = track->trackStateOnSurfaces();
+ const DataVector <const Trk::TrackStateOnSurface>* trackTSOS = inTrack->trackStateOnSurfaces();
double Eloss = 0.;
double idEloss = 0.;
@@ -630,15 +655,15 @@ namespace MuonCombined {
}
- bool MuonCombinedFitTagTool::bestMatchChooser(const InDetCandidate& curCandidate, const CombinedFitTag& curTag,
- const InDetCandidate& /*bestCandidate*/, const CombinedFitTag& bestTag) const
+ bool MuonCombinedFitTagTool::bestMatchChooser(const InDetCandidate& curCandidate, const CombinedFitTag& curTag, Trk::Track& curTrack, Trk::Track* curMETrack,
+ const InDetCandidate& /*bestCandidate*/, const CombinedFitTag& bestTag, Trk::Track& bestTrack, Trk::Track* bestMETrack) const
{
// pointers to extrapolated track
- const Trk::Track* curExtrTrack = curTag.updatedExtrapolatedTrack() ?
- curTag.updatedExtrapolatedTrack() : curTag.muonCandidate().extrapolatedTrack();
- const Trk::Track* bestExtrTrack = bestTag.updatedExtrapolatedTrack() ?
- bestTag.updatedExtrapolatedTrack() : bestTag.muonCandidate().extrapolatedTrack();
+ const Trk::Track* curExtrTrack = curMETrack ?
+ curMETrack : curTag.muonCandidate().extrapolatedTrack();
+ const Trk::Track* bestExtrTrack = bestMETrack ?
+ bestMETrack : bestTag.muonCandidate().extrapolatedTrack();
// 1 current
// 2 best
@@ -646,8 +671,8 @@ namespace MuonCombined {
double matchChiSq1 = curTag.matchChi2();
double matchChiSq2 = bestTag.matchChi2();
- const Trk::TrackSummary* summary1 = curTag.combinedTrack().trackSummary();
- const Trk::TrackSummary* summary2 = bestTag.combinedTrack().trackSummary();
+ const Trk::TrackSummary* summary1 = curTrack.trackSummary();
+ const Trk::TrackSummary* summary2 = bestTrack.trackSummary();
ATH_MSG_VERBOSE("bestMatchChooser: matchChiSq " << matchChiSq1 << " " << matchChiSq2);
if (summary1 && summary2)
{
@@ -667,12 +692,12 @@ namespace MuonCombined {
}
// selection when only one match has a good combined fit
- double fitChiSq1 = curTag.combinedTrack().fitQuality()->chiSquared() /
- curTag.combinedTrack().fitQuality()->doubleNumberDoF();
- int numberDoF1 = curTag.combinedTrack().fitQuality()->numberDoF();
- double fitChiSq2 = bestTag.combinedTrack().fitQuality()->chiSquared() /
- bestTag.combinedTrack().fitQuality()->doubleNumberDoF();
- int numberDoF2 = bestTag.combinedTrack().fitQuality()->numberDoF();
+ double fitChiSq1 = curTrack.fitQuality()->chiSquared() /
+ curTrack.fitQuality()->doubleNumberDoF();
+ int numberDoF1 = curTrack.fitQuality()->numberDoF();
+ double fitChiSq2 = bestTrack.fitQuality()->chiSquared() /
+ bestTrack.fitQuality()->doubleNumberDoF();
+ int numberDoF2 = bestTrack.fitQuality()->numberDoF();
ATH_MSG_VERBOSE("bestMatchChooser: fitChiSq " << fitChiSq1 << " " << fitChiSq2);
if (fabs(fitChiSq1 - fitChiSq2) > m_badFitChi2) {
if (fitChiSq1 < m_badFitChi2) {
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedFitTagTool.h b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedFitTagTool.h
index 6d86c51842a..b0c05ec4e0e 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedFitTagTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedFitTagTool.h
@@ -59,24 +59,28 @@ namespace MuonCombined {
/**IMuonCombinedTagTool interface: build combined muons from a muon and a vector of indet candidates */
virtual
- void combine( const MuonCandidate& muonCandidate, const std::vector<const InDetCandidate*>& indetCandidates, InDetCandidateToTagMap& tagMap ) const override;
+ void combine( const MuonCandidate& muonCandidate, const std::vector<const InDetCandidate*>& indetCandidates, InDetCandidateToTagMap& tagMap,
+ TrackCollection* combTracks, TrackCollection* METracks) const override;
private:
- const Trk::Track* buildCombinedTrack(const Trk::Track& indetTrack,
- const Trk::Track& spectrometerTrack,
- const Trk::Track* extrapolatedTrack) const;
+ Trk::Track* buildCombinedTrack(const Trk::Track& indetTrack,
+ const Trk::Track& spectrometerTrack,
+ const Trk::Track* extrapolatedTrack) const;
- bool combinedTrackQualityCheck(const Trk::Track& combinedTrack,
+ bool combinedTrackQualityCheck(Trk::Track& combinedTrack,
const Trk::Track& indetTrack) const;
- void evaluateMatchProperties(CombinedFitTag& tag, const Trk::Track& idTrack, const xAOD::TrackParticle& idTrackParticle) const;
+ Trk::Track* evaluateMatchProperties(Trk::Track* combinedTrack, CombinedFitTag& tag,
+ const Trk::Track& idTrack, const xAOD::TrackParticle& idTrackParticle) const;
bool extrapolatedNeedsRefit(const Trk::Track& combTrack,
const Trk::Track* extrTrack) const;
- bool bestMatchChooser(const InDetCandidate& curCandidate, const CombinedFitTag& curTag,
- const InDetCandidate& bestCandidate, const CombinedFitTag& bestTag) const;
+ bool bestMatchChooser(const InDetCandidate& curCandidate, const CombinedFitTag& curTag, Trk::Track& curTrack, Trk::Track* curMETrack,
+ const InDetCandidate& bestCandidate, const CombinedFitTag& bestTag, Trk::Track& bestTrack, Trk::Track* bestMETrack) const;
+
+ void dumpCaloEloss(Trk::Track* track, std::string txt ) const;
void dumpCaloEloss(const Trk::Track* track, std::string txt ) const;
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedStacoTagTool.cxx b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedStacoTagTool.cxx
index 06947b75091..65b24990ca8 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedStacoTagTool.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedStacoTagTool.cxx
@@ -55,7 +55,10 @@ namespace MuonCombined {
return StatusCode::SUCCESS;
}
- void MuonCombinedStacoTagTool::combine( const MuonCandidate& muonCandidate, const std::vector<const InDetCandidate*>& indetCandidates, InDetCandidateToTagMap& tagMap ) const {
+ void MuonCombinedStacoTagTool::combine( const MuonCandidate& muonCandidate, const std::vector<const InDetCandidate*>& indetCandidates, InDetCandidateToTagMap& tagMap,
+ TrackCollection* combTracks, TrackCollection* METracks) const {
+
+ if(!combTracks || !METracks) ATH_MSG_WARNING("No TrackCollection passed");
// only combine if the back extrapolation was successfull
if( !muonCandidate.extrapolatedTrack() ||
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedStacoTagTool.h b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedStacoTagTool.h
index feea6d941e5..0bc7e2be2bd 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedStacoTagTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedStacoTagTool.h
@@ -44,7 +44,8 @@ namespace MuonCombined {
/**IMuonCombinedTagTool interface: build combined muons from a muon and a vector of indet candidates */
virtual
- void combine( const MuonCandidate& muonCandidate, const std::vector<const InDetCandidate*>& indetCandidates, InDetCandidateToTagMap& tagMap ) const override;
+ void combine( const MuonCandidate& muonCandidate, const std::vector<const InDetCandidate*>& indetCandidates, InDetCandidateToTagMap& tagMap,
+ TrackCollection* combTracks, TrackCollection* METracks) const override;
private:
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedTool.cxx b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedTool.cxx
index be60144bdd4..77f05cd1bb8 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedTool.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedTool.cxx
@@ -61,7 +61,8 @@ namespace MuonCombined {
return StatusCode::SUCCESS;
}
- void MuonCombinedTool::combine( const MuonCandidateCollection& muonCandidates, const InDetCandidateCollection& inDetCandidates, std::vector<InDetCandidateToTagMap*> tagMaps) const {
+ void MuonCombinedTool::combine( const MuonCandidateCollection& muonCandidates, const InDetCandidateCollection& inDetCandidates, std::vector<InDetCandidateToTagMap*> tagMaps,
+ TrackCollection* combinedTracks, TrackCollection* METracks) const {
// check that there are tracks in both systems
if( inDetCandidates.empty() ) return;
@@ -88,7 +89,7 @@ namespace MuonCombined {
// build combined muons
int count=0;
for(auto& tool : m_muonCombinedTagTools){
- tool->combine(*muonCandidate,associatedIdCandidates,*(tagMaps.at(count)));
+ tool->combine(*muonCandidate,associatedIdCandidates,*(tagMaps.at(count)),combinedTracks,METracks);
count++;
}
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedTool.h b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedTool.h
index ad24457cba0..951fd91cdd9 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCombinedTool.h
@@ -32,7 +32,8 @@ namespace MuonCombined {
StatusCode initialize();
StatusCode finalize();
- void combine(const MuonCandidateCollection& muonCandidates,const InDetCandidateCollection& inDetCandidates, std::vector<InDetCandidateToTagMap*> tagMaps) const;
+ void combine(const MuonCandidateCollection& muonCandidates,const InDetCandidateCollection& inDetCandidates, std::vector<InDetCandidateToTagMap*> tagMaps,
+ TrackCollection* combinedTracks, TrackCollection* METracks) const;
private:
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCreatorTool.cxx b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCreatorTool.cxx
index 61b258b01fe..31c056b9298 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCreatorTool.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCreatorTool.cxx
@@ -660,9 +660,8 @@ namespace MuonCombined {
if( outputData.combinedTrackParticleContainer ){
// create element link from the track, const_cast for now until we sort out the constness of the tags
- ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( std::unique_ptr<const Trk::Track>(const_cast<CombinedFitTag&>(*tag).releaseCombinedTrack()),
- *outputData.combinedTrackParticleContainer,
- outputData.combinedTrackCollection );
+ ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( tag->combinedTrackLink(),
+ *outputData.combinedTrackParticleContainer);
if( link.isValid() ) {
//link.toPersistent();
@@ -674,9 +673,7 @@ namespace MuonCombined {
}
// add muon candidate
- const Trk::Track* updatedExtrapolatedTrack = m_useUpdatedExtrapolatedTrack ? const_cast<CombinedFitTag&>(*tag).releaseUpdatedExtrapolatedTrack() : 0;
-
- addMuonCandidate(tag->muonCandidate(),muon,outputData,updatedExtrapolatedTrack);
+ addMuonCandidate(tag->muonCandidate(),muon,outputData,tag->updatedExtrapolatedTrackLink());
// Add inner match chi^2
muon.setParameter(static_cast<int>(tag->matchDoF()), xAOD::Muon::msInnerMatchDOF);
@@ -752,14 +749,13 @@ namespace MuonCombined {
slowMuon->auxdata< std::vector<float> >("hitPropagationTime") = propagationTimeVec;
}
- if( !muon.combinedTrackParticleLink().isValid() && tag->getCombinedTrack()){
+ if( !muon.combinedTrackParticleLink().isValid() && tag->combinedTrack()){
// if the combined track particle is part of a container set the link
if( outputData.combinedTrackParticleContainer ){
// create element link
- ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( std::unique_ptr<const Trk::Track>(const_cast<MuGirlLowBetaTag&>(*tag).releaseCombinedTrack()),
- *outputData.combinedTrackParticleContainer,
- outputData.combinedTrackCollection );
+ ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( tag->combinedTrackLink(),
+ *outputData.combinedTrackParticleContainer );
if( link.isValid() ) {
//link.toPersistent();
@@ -787,25 +783,23 @@ namespace MuonCombined {
}
*/
- if (outputData.muonSegmentCollection){
+ if (outputData.xaodSegmentContainer){
ATH_MSG_DEBUG( "Adding MuGirlLowBeta muonSegmentColection");
std::vector< ElementLink< xAOD::MuonSegmentContainer > > segments;
- for( const auto& segs : tag->segments() ){
+ for( const auto& seglink : tag->segments() ){
- ElementLink<xAOD::MuonSegmentContainer> link = createMuonSegmentElementLink(*segs,
- *outputData.xaodSegmentContainer,
- outputData.muonSegmentCollection);
-
+ ElementLink<xAOD::MuonSegmentContainer> link = createMuonSegmentElementLink(seglink,
+ *outputData.xaodSegmentContainer);
if( link.isValid() ) {
//link.toPersistent();
segments.push_back(link);
ATH_MSG_DEBUG("Adding MuGirlLowBeta: xaod::MuonSegment px " << (*link)->px() << " py " << (*link)->py() << " pz " << (*link)->pz() );
}
else ATH_MSG_WARNING("Creating of MuGirlLowBeta segment Link failed");
- }
- const_cast<MuGirlLowBetaTag&>(*tag).releaseSegments();
- }
+ }
+ muon.setMuonSegmentLinks(segments);
+ }
}
void MuonCreatorTool::addMuGirl( xAOD::Muon& muon, const MuGirlTag* tag, OutputData& outputData ) const {
@@ -817,14 +811,13 @@ namespace MuonCombined {
ATH_MSG_DEBUG("Adding MuGirl Muon " << tag->author() << " type " << tag->type());
- if( !muon.combinedTrackParticleLink().isValid() && tag->getCombinedTrack()){
+ if( !muon.combinedTrackParticleLink().isValid() && tag->combinedTrack()){
// if the combined track particle is part of a container set the link
if( outputData.combinedTrackParticleContainer ){
// create element link
- ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( std::unique_ptr<const Trk::Track>(const_cast<MuGirlTag&>(*tag).releaseCombinedTrack()),
- *outputData.combinedTrackParticleContainer,
- outputData.combinedTrackCollection );
+ ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( tag->combinedTrackLink(),
+ *outputData.combinedTrackParticleContainer );
if( link.isValid() ) {
//link.toPersistent();
@@ -836,9 +829,8 @@ namespace MuonCombined {
if( outputData.extrapolatedTrackParticleContainer && tag->updatedExtrapolatedTrack()){
// create element link
- ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( std::unique_ptr<const Trk::Track>(const_cast<MuGirlTag&>(*tag).releaseUpdatedExtrapolatedTrack()),
- *outputData.extrapolatedTrackParticleContainer,
- outputData.extrapolatedTrackCollection );
+ ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( tag->updatedExtrapolatedTrackLink(),
+ *outputData.extrapolatedTrackParticleContainer );
if( link.isValid() ) {
//link.toPersistent();
@@ -850,15 +842,13 @@ namespace MuonCombined {
}
if (outputData.xaodSegmentContainer){
- ATH_MSG_DEBUG( "Adding MuGirl muonSegmentColection");
+ ATH_MSG_DEBUG( "Adding MuGirl muonSegmentCollection");
std::vector< ElementLink< xAOD::MuonSegmentContainer > > segments;
- for( const auto& segs : tag->segments() ){
+ for( const auto& segLink : tag->segments() ){
- ElementLink<xAOD::MuonSegmentContainer> link = createMuonSegmentElementLink(*segs,
- *outputData.xaodSegmentContainer,
- outputData.muonSegmentCollection);
-
+ ElementLink<xAOD::MuonSegmentContainer> link = createMuonSegmentElementLink(segLink,
+ *outputData.xaodSegmentContainer);
if( link.isValid() ) {
//link.toPersistent();
segments.push_back(link);
@@ -866,9 +856,8 @@ namespace MuonCombined {
}
else ATH_MSG_WARNING("Creating of MuGirl segment Link failed");
}
+ muon.setMuonSegmentLinks(segments);
}
- const_cast<MuGirlTag&>(*tag).releaseSegments();
-
ATH_MSG_DEBUG("Done Adding MuGirl Muon " << tag->author() << " type " << tag->type());
}
@@ -937,55 +926,29 @@ namespace MuonCombined {
// FIXME - calo deposits
}
- ElementLink<xAOD::TrackParticleContainer> MuonCreatorTool::createTrackParticleElementLink( std::unique_ptr<const Trk::Track> track,
- xAOD::TrackParticleContainer& trackParticleContainer,
- TrackCollection* trackCollection ) const {
+ ElementLink<xAOD::TrackParticleContainer> MuonCreatorTool::createTrackParticleElementLink( ElementLink<TrackCollection> trackLink,
+ xAOD::TrackParticleContainer& trackParticleContainer) const {
const xAOD::TrackParticle* tp = 0;
- const Trk::Track* track_ref = track.get();
- if( trackCollection ) {
- // if a track collection is provided add the track to the collection and create the TP using the element link
- trackCollection->push_back(const_cast<Trk::Track*>(track.release()));
- ElementLink<TrackCollection> link( *trackCollection,trackCollection->size()-1);
- if( link.isValid() ) {
- //link.toPersistent();
- tp = m_particleCreator->createParticle( link, &trackParticleContainer, 0, xAOD::muon );
- } else ATH_MSG_WARNING("Track Collection link invalid, creating TrackParticle from track");
- }
- if( !tp ){
- // create extrapolated track particle without a link to the track
- tp = m_particleCreator->createParticle( *track_ref, &trackParticleContainer, 0, xAOD::muon );
- }
+ if( trackLink.isValid() ) tp = m_particleCreator->createParticle( trackLink, &trackParticleContainer, 0, xAOD::muon );
+ else ATH_MSG_WARNING("Track Collection link invalid, no TrackParticle created");
+
if( tp ){
ElementLink<xAOD::TrackParticleContainer> link( trackParticleContainer,trackParticleContainer.size()-1);
- //link.toPersistent();
return link;
}
return ElementLink<xAOD::TrackParticleContainer>();
}
- ElementLink<xAOD::MuonSegmentContainer> MuonCreatorTool::createMuonSegmentElementLink( const Muon::MuonSegment & muonSegment,
- xAOD::MuonSegmentContainer& xaodSegmentContainer,
- Trk::SegmentCollection* muonSegmentCollection
- ) const {
+ ElementLink<xAOD::MuonSegmentContainer> MuonCreatorTool::createMuonSegmentElementLink( ElementLink<Trk::SegmentCollection> segLink,
+ xAOD::MuonSegmentContainer& xaodSegmentContainer) const {
const xAOD::MuonSegment* ms = 0;
- if( muonSegmentCollection ) {
- // if a muon segment collection is provided create the MS using the element link
- muonSegmentCollection->push_back(const_cast<Muon::MuonSegment*>(&muonSegment));
-
- ElementLink<Trk::SegmentCollection> link( *muonSegmentCollection,muonSegmentCollection->size()-1);
- if( link.isValid() ) {
- link.toPersistent();
- ms = m_muonSegmentConverterTool->convert(link, &xaodSegmentContainer);
- } else ATH_MSG_WARNING("Segment Collection link invalid");
- }
+ if( segLink.isValid() ) {
+ segLink.toPersistent();
+ ms = m_muonSegmentConverterTool->convert(segLink, &xaodSegmentContainer);
+ } else ATH_MSG_WARNING("Segment Collection link invalid");
- if( !ms ){
- // create muon segments without a link to the track
- ms = m_muonSegmentConverterTool->convert( muonSegment, &xaodSegmentContainer);
- }
- if( !muonSegmentCollection ) delete &muonSegment;
if( ms ){
ElementLink<xAOD::MuonSegmentContainer> link( xaodSegmentContainer,xaodSegmentContainer.size()-1);
link.toPersistent();
@@ -994,11 +957,10 @@ namespace MuonCombined {
return ElementLink<xAOD::MuonSegmentContainer>();
}
- void MuonCreatorTool::addMuonCandidate( const MuonCandidate& candidate, xAOD::Muon& muon, OutputData& outputData, const Trk::Track* updatedExtrapolatedTrack ) const {
+ void MuonCreatorTool::addMuonCandidate( const MuonCandidate& candidate, xAOD::Muon& muon, OutputData& outputData, ElementLink<TrackCollection> meLink ) const {
// only set once
if( muon.muonSpectrometerTrackParticleLink().isValid() ) {
- delete updatedExtrapolatedTrack;
return;
}
@@ -1010,13 +972,11 @@ namespace MuonCombined {
muon.setTrackParticleLink(xAOD::Muon::MuonSpectrometerTrackParticle, candidate.muonSpectrometerTrackLink() );
// we need both the container and the extrapolated muon track to add the link
- if( !outputData.extrapolatedTrackParticleContainer || (!candidate.extrapolatedTrack() && !updatedExtrapolatedTrack) ) {
- delete updatedExtrapolatedTrack;
+ if( !outputData.extrapolatedTrackParticleContainer || (!candidate.extrapolatedTrack() && !meLink.isValid()) ) {
return;
}
- // now a bit of nasty logic to ensure the extrapolated track of the candidate is always released so the candidate is flagged as 'used'
- const Trk::Track* extrapolatedTrack = const_cast<MuonCandidate&>(candidate).releaseExtrapolatedTrack();
+ const Trk::Track* extrapolatedTrack = candidate.extrapolatedTrack();
if (! extrapolatedTrack || !extrapolatedTrack->perigeeParameters()) {
ATH_MSG_DEBUG("Something is wrong with this track.");
@@ -1028,11 +988,10 @@ namespace MuonCombined {
//Now we just add the original extrapolated track itself
//but not for SA muons, for consistency they will still have extrapolatedTrackParticle
if(muon.muonType()!=xAOD::Muon::MuonStandAlone){
- if(updatedExtrapolatedTrack){ //add ME track and MS-only extrapolated track
+ if(meLink.isValid()){ //add ME track and MS-only extrapolated track
if(outputData.msOnlyExtrapolatedTrackParticleContainer){ //add un-refitted extrapolated track as MS-only extrapolated track
- ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( std::unique_ptr<const Trk::Track>(extrapolatedTrack),
- *outputData.msOnlyExtrapolatedTrackParticleContainer,
- outputData.msOnlyExtrapolatedTrackCollection );
+ ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( candidate.extrapolatedTrackLink(),
+ *outputData.msOnlyExtrapolatedTrackParticleContainer );
if( link.isValid() ) {
ATH_MSG_DEBUG("Adding MS-only extrapolated track: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi() );
@@ -1040,22 +999,18 @@ namespace MuonCombined {
muon.setTrackParticleLink(xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle, link );
}
else ATH_MSG_WARNING("failed to create MS-only extrapolated track particle");
- } else {
- //original extrapolatedTrack is not needed anymore:
- delete extrapolatedTrack;
}
//now add refitted track as ME track
- ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( std::unique_ptr<const Trk::Track>(updatedExtrapolatedTrack),
- *outputData.extrapolatedTrackParticleContainer,
- outputData.extrapolatedTrackCollection );
+ ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( meLink,
+ *outputData.extrapolatedTrackParticleContainer );
if( link.isValid() ) {
ATH_MSG_DEBUG("Adding standalone fit (refitted): pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi() );
//link.toPersistent();
muon.setTrackParticleLink(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, link );
- float fieldInt=m_trackQuery->fieldIntegral(*updatedExtrapolatedTrack).betweenSpectrometerMeasurements();
+ float fieldInt=m_trackQuery->fieldIntegral(**meLink).betweenSpectrometerMeasurements();
muon.setParameter(fieldInt,xAOD::Muon::spectrometerFieldIntegral);
//TrackSummary* tsum=updatedExtrapolatedTrack->trackSummary();
- int nunspoiled=updatedExtrapolatedTrack->trackSummary()->get(Trk::numberOfCscUnspoiltEtaHits);
+ int nunspoiled=(*meLink)->trackSummary()->get(Trk::numberOfCscUnspoiltEtaHits);
muon.auxdata<int>("nUnspoiledCscHits")=nunspoiled;
}
}
@@ -1063,44 +1018,41 @@ namespace MuonCombined {
if(muon.author()==xAOD::Muon::MuGirl && muon.extrapolatedMuonSpectrometerTrackParticleLink().isValid()){
//MuGirl case: ME track is already set, but now we have the extrapolated track from the STACO tag
//add this as the MS-only extrapolated track instead
- ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( std::unique_ptr<const Trk::Track>(extrapolatedTrack),
- *outputData.msOnlyExtrapolatedTrackParticleContainer,
- outputData.msOnlyExtrapolatedTrackCollection );
+ ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( candidate.extrapolatedTrackLink(),
+ *outputData.msOnlyExtrapolatedTrackParticleContainer );
if( link.isValid() ) {
ATH_MSG_DEBUG("Adding MS-only extrapolated track to MuGirl muon: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi() );
//link.toPersistent();
muon.setTrackParticleLink(xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle, link );
- float fieldInt=m_trackQuery->fieldIntegral(*extrapolatedTrack).betweenSpectrometerMeasurements();
+ float fieldInt=m_trackQuery->fieldIntegral(**candidate.extrapolatedTrackLink()).betweenSpectrometerMeasurements();
muon.setParameter(fieldInt,xAOD::Muon::spectrometerFieldIntegral);
}
}
else{
- ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( std::unique_ptr<const Trk::Track>(extrapolatedTrack),
- *outputData.extrapolatedTrackParticleContainer,
- outputData.extrapolatedTrackCollection );
+ ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( candidate.extrapolatedTrackLink(),
+ *outputData.extrapolatedTrackParticleContainer );
if( link.isValid() ) {
ATH_MSG_DEBUG("Adding standalone fit (un-refitted): pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi() );
//link.toPersistent();
muon.setTrackParticleLink(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, link );
- float fieldInt=m_trackQuery->fieldIntegral(*extrapolatedTrack).betweenSpectrometerMeasurements();
+ float fieldInt=m_trackQuery->fieldIntegral(**candidate.extrapolatedTrackLink()).betweenSpectrometerMeasurements();
muon.setParameter(fieldInt,xAOD::Muon::spectrometerFieldIntegral);
}
}
}
}
else{ //SA tracks only get un-refitted track as ME track
- // create element link from the track, const_cast for now until we sort out the constness of the MuonCandidates
- ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( std::unique_ptr<const Trk::Track>(extrapolatedTrack),
- *outputData.extrapolatedTrackParticleContainer,
- outputData.extrapolatedTrackCollection );
+ // create element link from the track
+ ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink( candidate.extrapolatedTrackLink(),
+ *outputData.extrapolatedTrackParticleContainer );
if( link.isValid() ) {
ATH_MSG_DEBUG("Adding standalone fit: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi() );
//link.toPersistent();
muon.setTrackParticleLink(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, link );
- float fieldInt=m_trackQuery->fieldIntegral(*extrapolatedTrack).betweenSpectrometerMeasurements();
+ float fieldInt=m_trackQuery->fieldIntegral(**candidate.extrapolatedTrackLink()).betweenSpectrometerMeasurements();
muon.setParameter(fieldInt,xAOD::Muon::spectrometerFieldIntegral);
int nunspoiled=extrapolatedTrack->trackSummary()->get(Trk::numberOfCscUnspoiltEtaHits);
muon.auxdata<int>("nUnspoiledCscHits")=nunspoiled;
@@ -1436,7 +1388,8 @@ namespace MuonCombined {
if( m_fillTimingInformationOnMuon ) addRpcTiming(muon);
- if( !m_trackSegmentAssociationTool.empty() && muon.author()!=xAOD::Muon::MuTagIMO && (muon.author()!=xAOD::Muon::MuGirlLowBeta || m_segLowBeta)) addSegmentsOnTrack(muon);
+ if( !m_trackSegmentAssociationTool.empty() && muon.author()!=xAOD::Muon::MuTagIMO && muon.author()!=xAOD::Muon::MuGirl &&
+ (muon.author()!=xAOD::Muon::MuGirlLowBeta || m_segLowBeta)) addSegmentsOnTrack(muon);
addMSIDScatteringAngles(muon);
if(muon.combinedTrackParticleLink().isValid()) addMSIDScatteringAngles(**(muon.combinedTrackParticleLink()));
diff --git a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCreatorTool.h b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCreatorTool.h
index 404f2eb9327..485b6ea0b7c 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCreatorTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedBaseTools/src/MuonCreatorTool.h
@@ -103,19 +103,17 @@ namespace MuonCombined {
/** add muon candidate info to a muon, if an updateExtrapolatedTrack is provided, the routine takes ownership of the track.
The track will be used instead of the extrapolatedTrack of the MuonCandidate. The extrapolatedTrack of the MuonCandidate will be release during the operation.
*/
- void addMuonCandidate( const MuonCandidate& candidate, xAOD::Muon& muon, OutputData& outputData, const Trk::Track* updatedExtrapolatedTrack = 0 ) const;
+ void addMuonCandidate( const MuonCandidate& candidate, xAOD::Muon& muon, OutputData& outputData, ElementLink<TrackCollection> meLink=ElementLink<TrackCollection>() ) const;
/// function creates an element link to a track particle from the track and the TrackParticle collection.
/// if a TrackCollection is also provided, the element link to the track will also be set
/// takes ownership of the track
ElementLink<xAOD::TrackParticleContainer>
- createTrackParticleElementLink( std::unique_ptr<const Trk::Track> track,
- xAOD::TrackParticleContainer& trackParticleContainer,
- TrackCollection* trackCollection = 0 ) const ;
+ createTrackParticleElementLink( ElementLink<TrackCollection> trackLink,
+ xAOD::TrackParticleContainer& trackParticleContainer) const ;
- ElementLink<xAOD::MuonSegmentContainer> createMuonSegmentElementLink( const Muon::MuonSegment & muonSegment,
- xAOD::MuonSegmentContainer& xaodSegments,
- Trk::SegmentCollection* muonSegmentCollection = 0 ) const ;
+ ElementLink<xAOD::MuonSegmentContainer> createMuonSegmentElementLink( ElementLink<Trk::SegmentCollection> segLink,
+ xAOD::MuonSegmentContainer& xaodSegments) const ;
private:
void resolveOverlaps( const InDetCandidateCollection* inDetCandidates, const MuonCandidateCollection* muonCandidates, std::vector<const InDetCandidateToTagMap*> tagMaps,
diff --git a/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/CombinedFitTag.h b/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/CombinedFitTag.h
index e1cfb796dad..170a0444e19 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/CombinedFitTag.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/CombinedFitTag.h
@@ -9,6 +9,7 @@
#include "MuidEvent/FieldIntegral.h"
#include "MuonCombinedEvent/TagBase.h"
#include "TrkEventPrimitives/TrackScore.h"
+#include "TrkTrack/TrackCollection.h"
#include <vector>
namespace Trk {
@@ -23,24 +24,24 @@ namespace MuonCombined {
class CombinedFitTag : public TagBase {
public:
- /** Constructor taking a MuonCandidate and a combined track as input
+ /** Constructor taking a MuonCandidate as input
Users should ensure that the life time of the MuonCandidate
- The class takes ownership of the combined track and the track score
+ The class takes ownership of the track score
*/
CombinedFitTag( xAOD::Muon::Author author, const MuonCandidate& muonCandidate,
- const Trk::Track& combinedTrack, const Trk::TrackScore& score );
+ const Trk::TrackScore& score );
/** destructor */
~CombinedFitTag();
/** access combined track */
- const Trk::Track& combinedTrack() const;
+ const Trk::Track* combinedTrack() const;
- /** set combined track */
- void setCombinedTrack(const Trk::Track& combinedTrack, const Trk::TrackScore& score );
+ /*ElementLink to combined track*/
+ ElementLink<TrackCollection> combinedTrackLink() const {return m_combLink;}
- /** release combined track, user gets ownership */
- const Trk::Track* releaseCombinedTrack();
+ /** set combined track ElementLink*/
+ void setCombinedTrackLink(ElementLink<TrackCollection> combLink){m_combLink=combLink;}
/** access to MuonCandidate */
const MuonCandidate& muonCandidate() const;
@@ -48,11 +49,11 @@ namespace MuonCombined {
/** access update extrapolated track, returns zero if none are available */
const Trk::Track* updatedExtrapolatedTrack() const;
- /** set update extrapolated track, takes ownership */
- void setUpdatedExtrapolatedTrack(const Trk::Track* track);
+ /* ElementLink to ME track*/
+ ElementLink<TrackCollection> updatedExtrapolatedTrackLink() const {return m_MELink;}
- /** release combined track, user gets ownership */
- const Trk::Track* releaseUpdatedExtrapolatedTrack();
+ /** set update extrapolated track ElementLink */
+ void setUpdatedExtrapolatedTrackLink(ElementLink<TrackCollection> MELink){m_MELink=MELink;}
/** store inner match quality info */
void innerMatch(double chi2, int dof, double prob);
@@ -97,9 +98,9 @@ namespace MuonCombined {
/** data content */
const MuonCandidate* m_muonCandidate; /// MuonCandidate
- const Trk::Track* m_combinedTrack; /// combined track
+ ElementLink<TrackCollection> m_combLink; //link to combined track
Trk::TrackScore m_trackScore;
- const Trk::Track* m_updatedExtrapolatedTrack; /// updated extrapolated track
+ ElementLink<TrackCollection> m_MELink; //link to ME track
Rec::FieldIntegral m_fieldIntegral;
@@ -114,35 +115,12 @@ namespace MuonCombined {
return t1.trackScore() < t2.trackScore();
}
- inline const Trk::Track& CombinedFitTag::combinedTrack() const { return *m_combinedTrack; }
+ inline const Trk::Track* CombinedFitTag::combinedTrack() const { return m_combLink.isValid() ? *m_combLink : nullptr; }
- inline void CombinedFitTag::setCombinedTrack(const Trk::Track& combinedTrack, const Trk::TrackScore& score) {
- delete m_combinedTrack;
- m_combinedTrack = &combinedTrack;
- m_trackScore = score;
- }
-
- inline const Trk::Track* CombinedFitTag::releaseCombinedTrack() {
- const Trk::Track* tmp = m_combinedTrack;
- m_combinedTrack=0;
- return tmp;
- }
-
inline const MuonCandidate& CombinedFitTag::muonCandidate() const { return *m_muonCandidate; }
- inline const Trk::Track* CombinedFitTag::updatedExtrapolatedTrack() const { return m_updatedExtrapolatedTrack; }
+ inline const Trk::Track* CombinedFitTag::updatedExtrapolatedTrack() const { return m_MELink.isValid() ? *m_MELink : nullptr; }
- inline void CombinedFitTag::setUpdatedExtrapolatedTrack(const Trk::Track* track) {
- delete m_updatedExtrapolatedTrack;
- m_updatedExtrapolatedTrack = track;
- }
-
- inline const Trk::Track* CombinedFitTag::releaseUpdatedExtrapolatedTrack() {
- const Trk::Track* tmp = m_updatedExtrapolatedTrack;
- m_updatedExtrapolatedTrack = 0;
- return tmp;
- }
-
inline void CombinedFitTag::innerMatch(double chi2, int dof, double prob)
{
m_matchChi2=chi2;
@@ -151,7 +129,7 @@ namespace MuonCombined {
}
inline const Trk::Track* CombinedFitTag::primaryTrack() const {
- return &combinedTrack();
+ return combinedTrack();
}
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/InDetCandidateToTagMap.h b/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/InDetCandidateToTagMap.h
index 00264aedb21..633a3b3f947 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/InDetCandidateToTagMap.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/InDetCandidateToTagMap.h
@@ -22,10 +22,11 @@ namespace MuonCombined{
void addEntry(const InDetCandidate* idcand, TagBase* tag);
const TagBase* getTag(const InDetCandidate* idcand) const;
unsigned int size() const;
- std::map<const InDetCandidate*,TagBase*> getMap() const;
+ std::map<const InDetCandidate*,std::unique_ptr<TagBase> >::iterator mapBegin() {return m_tagMap.begin();}
+ std::map<const InDetCandidate*,std::unique_ptr<TagBase> >::iterator mapEnd() {return m_tagMap.end();}
private:
- std::map<const InDetCandidate*,TagBase*> m_tagMap;
+ std::map<const InDetCandidate*,std::unique_ptr<TagBase> > m_tagMap;
};
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuGirlLowBetaTag.h b/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuGirlLowBetaTag.h
index 28b1cb6ab34..9a057412dc8 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuGirlLowBetaTag.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuGirlLowBetaTag.h
@@ -11,6 +11,9 @@
#include "MuonCombinedEvent/CandidateSummary.h"
+#include "TrkTrack/TrackCollection.h"
+#include "TrkSegment/SegmentCollection.h"
+
namespace Trk {
class Track;
}
@@ -26,42 +29,30 @@ namespace MuonCombined {
public:
/** Constructor a combined track and a list of segments as input
- The class takes ownership of the combined track and the segments
*/
- MuGirlLowBetaTag( const Trk::Track* combinedTrack, const std::vector<const Muon::MuonSegment*>& segments );
+ MuGirlLowBetaTag( ElementLink<TrackCollection> combLink, const std::vector<ElementLink<Trk::SegmentCollection> >& segments );
- /** Constructor taking a list of
- Users should ensure that the life time of the MuonCandidate
- The class takes ownership of the combined track
+ /** Constructor taking a list of segments
*/
- MuGirlLowBetaTag( const std::vector<const Muon::MuonSegment*>& segments );
+ MuGirlLowBetaTag( const std::vector<ElementLink<Trk::SegmentCollection> >& segments );
/** destructor */
~MuGirlLowBetaTag();
/** access combined track */
- const Trk::Track* getCombinedTrack() const;
- const Trk::Track& combinedTrack() const;
+ const Trk::Track* combinedTrack() const;
- /** release combined track, user gets ownership */
- const Trk::Track* releaseCombinedTrack();
+ /*ElementLink to the combined track*/
+ ElementLink<TrackCollection> combinedTrackLink() const {return m_combLink;}
/** access update extrapolated track, returns zero if none are available */
const Trk::Track* updatedExtrapolatedTrack() const;
- /** set update extrapolated track, takes ownership */
- void setUpdatedExtrapolatedTrack(const Trk::Track* track);
-
- /** release combined track, user gets ownership */
- const Trk::Track* releaseUpdatedExtrapolatedTrack();
+ /** set update extrapolated track*/
+ void setUpdatedExtrapolatedTrack(ElementLink<TrackCollection> meLink);
/** access segments */
- const std::vector<const Muon::MuonSegment*>& segments() const ;
-
- /** release segments, user gets ownership */
- void releaseSegments( std::vector<const Muon::MuonSegment*>& segments );
-
- void releaseSegments();
+ const std::vector<ElementLink<Trk::SegmentCollection> >& segments() const ;
/* stau Dressing */
void setMuBeta(float muBeta);
@@ -91,9 +82,9 @@ namespace MuonCombined {
MuGirlLowBetaTag& operator=(const MuGirlLowBetaTag&) = delete;
/** data content */
- const Trk::Track* m_combinedTrack; /// combined track
- const Trk::Track* m_updatedExtrapolatedTrack; /// updated extrapolated track
- std::vector<const Muon::MuonSegment*> m_segments; /// list of segments
+ ElementLink<TrackCollection> m_combLink;
+ ElementLink<TrackCollection> m_meLink;
+ std::vector<ElementLink<Trk::SegmentCollection> > m_segments; /// list of segments
//dressing
float m_muBeta;
@@ -102,8 +93,8 @@ namespace MuonCombined {
MuGirlNS::RHExtras* m_rhExtras;
};
inline bool operator<( const MuGirlLowBetaTag& t1, const MuGirlLowBetaTag& t2 ){
- const Trk::FitQuality* t1FQ = (t1.getCombinedTrack()!=NULL)? t1.getCombinedTrack()->fitQuality() : 0;
- const Trk::FitQuality* t2FQ = (t2.getCombinedTrack()!=NULL)? t2.getCombinedTrack()->fitQuality() : 0;
+ const Trk::FitQuality* t1FQ = (t1.combinedTrack()!=nullptr)? t1.combinedTrack()->fitQuality() : 0;
+ const Trk::FitQuality* t2FQ = (t2.combinedTrack()!=nullptr)? t2.combinedTrack()->fitQuality() : 0;
if (t1FQ!=NULL && t2FQ!=NULL)
{
return t1FQ->chiSquared() < t2FQ->chiSquared();
@@ -111,39 +102,16 @@ namespace MuonCombined {
return t1.segments().size() < t2.segments().size();
}
- inline const Trk::Track* MuGirlLowBetaTag::getCombinedTrack() const { return m_combinedTrack; }
+ inline const Trk::Track* MuGirlLowBetaTag::combinedTrack() const { return m_combLink.isValid() ? *m_combLink : nullptr; }
- inline const Trk::Track& MuGirlLowBetaTag::combinedTrack() const { return *m_combinedTrack; }
-
- inline const Trk::Track* MuGirlLowBetaTag::releaseCombinedTrack() {
- const Trk::Track* tmp = m_combinedTrack;
- m_combinedTrack=0;
- return tmp;
- }
-
- inline const Trk::Track* MuGirlLowBetaTag::updatedExtrapolatedTrack() const { return m_updatedExtrapolatedTrack; }
+ inline const Trk::Track* MuGirlLowBetaTag::updatedExtrapolatedTrack() const { return m_meLink.isValid() ? *m_meLink : nullptr; }
- inline void MuGirlLowBetaTag::setUpdatedExtrapolatedTrack(const Trk::Track* track) { m_updatedExtrapolatedTrack = track; }
+ inline void MuGirlLowBetaTag::setUpdatedExtrapolatedTrack(ElementLink<TrackCollection> meLink) { m_meLink=meLink;}
- inline const Trk::Track* MuGirlLowBetaTag::releaseUpdatedExtrapolatedTrack() {
- const Trk::Track* tmp = m_updatedExtrapolatedTrack;
- m_updatedExtrapolatedTrack = 0;
- return tmp;
- }
-
- inline void MuGirlLowBetaTag::releaseSegments() {
- m_segments.clear();
- }
-
-
- inline const std::vector<const Muon::MuonSegment*>& MuGirlLowBetaTag::segments() const { return m_segments; }
-
- inline void MuGirlLowBetaTag::releaseSegments( std::vector<const Muon::MuonSegment*>& segments ) {
- std::swap(m_segments,segments);
- }
+ inline const std::vector<ElementLink<Trk::SegmentCollection> >& MuGirlLowBetaTag::segments() const { return m_segments; }
inline const Trk::Track* MuGirlLowBetaTag::primaryTrack() const {
- return &combinedTrack();
+ return combinedTrack();
}
//stau dressing
diff --git a/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuGirlTag.h b/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuGirlTag.h
index 14d5b6273d3..4c348344391 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuGirlTag.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuGirlTag.h
@@ -24,43 +24,34 @@ namespace MuonCombined {
class MuGirlTag : public TagBase {
public:
- /** Constructor a combined track and a list of segments as input
- The class takes ownership of the combined track and the segments
+ /** Constructor a link to a combined track and a list of segment ElementLinks as input
*/
- MuGirlTag( const Trk::Track* combinedTrack, const std::vector<const Muon::MuonSegment*>& segments );
+ MuGirlTag( ElementLink<TrackCollection> comblink, const std::vector<ElementLink<Trk::SegmentCollection> >& segLinks );
- /** Constructor taking a list of
- Users should ensure that the life time of the MuonCandidate
- The class takes ownership of the combined track
+ /** Constructor taking a list of segments
*/
- MuGirlTag( const std::vector<const Muon::MuonSegment*>& segments );
+ MuGirlTag( const std::vector<ElementLink<Trk::SegmentCollection> >& segLinks );
/** destructor */
~MuGirlTag();
/** access combined track */
- const Trk::Track* getCombinedTrack() const;
- const Trk::Track& combinedTrack() const;
+ const Trk::Track* combinedTrack() const;
- /** release combined track, user gets ownership */
- const Trk::Track* releaseCombinedTrack();
+ /*Element Link to the combined track*/
+ ElementLink<TrackCollection> combinedTrackLink() const {return m_combLink;}
/** access update extrapolated track, returns zero if none are available */
const Trk::Track* updatedExtrapolatedTrack() const;
- /** set update extrapolated track, takes ownership */
- void setUpdatedExtrapolatedTrack(std::unique_ptr<const Trk::Track> track);
+ /* ElementLink to ME track*/
+ ElementLink<TrackCollection> updatedExtrapolatedTrackLink() const {return m_meLink;}
- /** release combined track, user gets ownership */
- std::unique_ptr<const Trk::Track> releaseUpdatedExtrapolatedTrack();
+ /** set update extrapolated track*/
+ void setUpdatedExtrapolatedTrack(ElementLink<TrackCollection> melink) {m_meLink=melink;}
- /** access segments */
- const std::vector<const Muon::MuonSegment*>& segments() const ;
-
- /** release segments, user gets ownership */
- void releaseSegments( std::vector<const Muon::MuonSegment*>& segments );
-
- void releaseSegments();
+ /** access segment ElementLinks */
+ const std::vector<ElementLink<Trk::SegmentCollection> >& segments() const ;
/** name string */
std::string name() const { return "MuGirlTag"; }
@@ -77,14 +68,14 @@ namespace MuonCombined {
MuGirlTag& operator=(const MuGirlTag&) = delete;
/** data content */
- const Trk::Track* m_combinedTrack; /// combined track
- std::unique_ptr<const Trk::Track> m_updatedExtrapolatedTrack; /// updated extrapolated track
- std::vector<const Muon::MuonSegment*> m_segments; /// list of segments
+ ElementLink<TrackCollection> m_combLink;
+ ElementLink<TrackCollection> m_meLink;
+ std::vector<ElementLink<Trk::SegmentCollection> > m_segments; /// list of segments
};
inline bool operator<( const MuGirlTag& t1, const MuGirlTag& t2 ){
- const Trk::FitQuality* t1FQ = (t1.getCombinedTrack()!=NULL)? t1.getCombinedTrack()->fitQuality() : 0;
- const Trk::FitQuality* t2FQ = (t2.getCombinedTrack()!=NULL)? t2.getCombinedTrack()->fitQuality() : 0;
+ const Trk::FitQuality* t1FQ = (t1.combinedTrack()!=nullptr)? t1.combinedTrack()->fitQuality() : 0;
+ const Trk::FitQuality* t2FQ = (t2.combinedTrack()!=nullptr)? t2.combinedTrack()->fitQuality() : 0;
if (t1FQ!=NULL && t2FQ!=NULL)
{
return t1FQ->chiSquared() < t2FQ->chiSquared();
@@ -92,39 +83,15 @@ namespace MuonCombined {
return t1.segments().size() < t2.segments().size();
}
- inline const Trk::Track* MuGirlTag::getCombinedTrack() const { return m_combinedTrack; }
+ inline const Trk::Track* MuGirlTag::combinedTrack() const {
+ return m_combLink.isValid() ? *m_combLink : nullptr; }
- inline const Trk::Track& MuGirlTag::combinedTrack() const { return *m_combinedTrack; }
+ inline const Trk::Track* MuGirlTag::updatedExtrapolatedTrack() const { return m_meLink.isValid() ? *m_meLink : nullptr; }
- inline const Trk::Track* MuGirlTag::releaseCombinedTrack() {
- const Trk::Track* tmp = m_combinedTrack;
- m_combinedTrack=0;
- return tmp;
- }
-
- inline const Trk::Track* MuGirlTag::updatedExtrapolatedTrack() const { return m_updatedExtrapolatedTrack.get(); }
- inline void MuGirlTag::setUpdatedExtrapolatedTrack(std::unique_ptr<const Trk::Track> track)
- {
- m_updatedExtrapolatedTrack = std::move(track);
- }
-
- inline std::unique_ptr<const Trk::Track> MuGirlTag::releaseUpdatedExtrapolatedTrack() {
- return std::move(m_updatedExtrapolatedTrack);
- }
-
- inline void MuGirlTag::releaseSegments() {
- m_segments.clear();
- }
-
-
- inline const std::vector<const Muon::MuonSegment*>& MuGirlTag::segments() const { return m_segments; }
-
- inline void MuGirlTag::releaseSegments( std::vector<const Muon::MuonSegment*>& segments ) {
- std::swap(m_segments,segments);
- }
+ inline const std::vector<ElementLink<Trk::SegmentCollection> >& MuGirlTag::segments() const { return m_segments; }
inline const Trk::Track* MuGirlTag::primaryTrack() const {
- return &combinedTrack();
+ return combinedTrack();
}
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuonCandidate.h b/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuonCandidate.h
index bf45a000ac9..08f4f943293 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuonCandidate.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuonCandidate.h
@@ -47,11 +47,8 @@ namespace MuonCombined {
*/
MuonCandidate( const ElementLink<xAOD::TrackParticleContainer>& msTrackLink, const Trk::Track* extrapolatedTrack );
- /** constructor taking an const reference for the MS track and an
- ElementLink to an xAOD::TrackParticle for the extrapolated track.
- Use this function when you don't want MuonCandidate to take ownership of the extrapolated track
- */
- MuonCandidate( const Trk::Track& msTrack, const ElementLink<xAOD::TrackParticleContainer>& saTrackLink );
+ /*Constructor taking two ElementLinks, should be the new default (second may be empty)*/
+ MuonCandidate( const ElementLink<xAOD::TrackParticleContainer>& msTrackLink, const ElementLink<TrackCollection>& saTrackLink );
/** destructor */
~MuonCandidate();
@@ -71,8 +68,8 @@ namespace MuonCombined {
/** access extrapolated track, can be zero if back extrapolation failed */
const Trk::Track* releaseExtrapolatedTrack();
- /** access extrapolated track element link, will not point to anything if we own the Track */
- const ElementLink<xAOD::TrackParticleContainer>& extrapolatedTrackLink() const;
+ /** access extrapolated track element link*/
+ const ElementLink<TrackCollection>& extrapolatedTrackLink() const;
/** ask if the MuonCandidate owns the extrapolated track */
bool ownsExtrapolatedTrack() const;
@@ -85,7 +82,7 @@ namespace MuonCombined {
const ElementLink<xAOD::TrackParticleContainer> m_muonSpectrometerTrackLink;
/** element link to extrapolated track */
- const ElementLink<xAOD::TrackParticleContainer> m_extrapolatedTrackLink;
+ const ElementLink<TrackCollection> m_extrapolatedTrackLink;
/** pointer to extrapolated track, may be owned */
const Trk::Track* m_extrapolatedTrack;
@@ -117,7 +114,7 @@ namespace MuonCombined {
inline bool MuonCandidate::ownsExtrapolatedTrack() const { return m_ownsExtrapolatedTrack; }
- inline const ElementLink<xAOD::TrackParticleContainer>& MuonCandidate::extrapolatedTrackLink() const { return m_extrapolatedTrackLink; }
+ inline const ElementLink<TrackCollection>& MuonCandidate::extrapolatedTrackLink() const { return m_extrapolatedTrackLink; }
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedEvent/src/CombinedFitTag.cxx b/Reconstruction/MuonIdentification/MuonCombinedEvent/src/CombinedFitTag.cxx
index 0e46a287a75..dbf046b8dac 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedEvent/src/CombinedFitTag.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedEvent/src/CombinedFitTag.cxx
@@ -9,10 +9,10 @@
namespace MuonCombined {
CombinedFitTag::CombinedFitTag( xAOD::Muon::Author author, const MuonCandidate& muonCandidate,
- const Trk::Track& combinedTrack, const Trk::TrackScore& score ) :
+ const Trk::TrackScore& score ) :
TagBase(author,TagBase::Type::Combined), m_muonCandidate(&muonCandidate),
- m_combinedTrack(&combinedTrack), m_trackScore(score),
- m_updatedExtrapolatedTrack(0),
+ m_trackScore(score),
+ m_MELink(ElementLink<TrackCollection>()),
m_matchChi2(0.0),
m_matchDoF(0),
m_matchProb(0.0),
@@ -20,8 +20,6 @@ namespace MuonCombined {
{}
CombinedFitTag::~CombinedFitTag() {
- delete m_combinedTrack;
- delete m_updatedExtrapolatedTrack;
}
std::string CombinedFitTag::toString() const {
diff --git a/Reconstruction/MuonIdentification/MuonCombinedEvent/src/InDetCandidateToTagMap.cxx b/Reconstruction/MuonIdentification/MuonCombinedEvent/src/InDetCandidateToTagMap.cxx
index 544037b1df5..65a2169ef0c 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedEvent/src/InDetCandidateToTagMap.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedEvent/src/InDetCandidateToTagMap.cxx
@@ -6,33 +6,31 @@
namespace MuonCombined{
- InDetCandidateToTagMap::InDetCandidateToTagMap(){
- m_tagMap.clear();
- }
+ InDetCandidateToTagMap::InDetCandidateToTagMap(){}
InDetCandidateToTagMap::InDetCandidateToTagMap(InDetCandidateToTagMap& oldMap){
- m_tagMap=oldMap.getMap();
+ m_tagMap.clear();
+ for(std::map<const InDetCandidate*,std::unique_ptr<TagBase> >::iterator it=oldMap.mapBegin(); it!=oldMap.mapEnd(); ++it){
+ m_tagMap.insert(std::pair<const InDetCandidate*,std::unique_ptr<TagBase> >((*it).first,std::move((*it).second)));
+ }
}
-
+
InDetCandidateToTagMap::~InDetCandidateToTagMap(){
m_tagMap.clear();
}
void InDetCandidateToTagMap::addEntry(const InDetCandidate* idcand,TagBase* tag){
- m_tagMap.insert(std::pair<const InDetCandidate*,TagBase*>(idcand,tag));
+ m_tagMap.insert(std::pair<const InDetCandidate*,std::unique_ptr<TagBase> >(idcand,std::unique_ptr<TagBase>(tag)));
}
const TagBase* InDetCandidateToTagMap::getTag(const InDetCandidate* idcand) const{
auto pos=m_tagMap.find(idcand);
if(pos==m_tagMap.end()) return 0;
- else return pos->second;
+ else return pos->second.get();
}
unsigned int InDetCandidateToTagMap::size() const{
return m_tagMap.size();
}
- std::map<const InDetCandidate*,TagBase*> InDetCandidateToTagMap::getMap() const{
- return m_tagMap;
- }
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuGirlLowBetaTag.cxx b/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuGirlLowBetaTag.cxx
index 6a11b0a0b70..a25bd32d96e 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuGirlLowBetaTag.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuGirlLowBetaTag.cxx
@@ -8,20 +8,19 @@
namespace MuonCombined {
- MuGirlLowBetaTag::MuGirlLowBetaTag( const Trk::Track* combinedTrack, const std::vector<const Muon::MuonSegment*>& segments ) :
- TagBase(TagBase::Author::MuGirlLowBeta,TagBase::Type::Combined), m_combinedTrack(combinedTrack),m_updatedExtrapolatedTrack(0),m_segments(segments),
+ MuGirlLowBetaTag::MuGirlLowBetaTag( ElementLink<TrackCollection> combLink, const std::vector<ElementLink<Trk::SegmentCollection> >& segments ) :
+ TagBase(TagBase::Author::MuGirlLowBeta,TagBase::Type::Combined), m_combLink(combLink), m_meLink(ElementLink<TrackCollection>()),m_segments(segments),
m_muBeta(-9999.),m_stauSummary(0),m_stauExtras(0),m_rhExtras(0) {}
- MuGirlLowBetaTag::MuGirlLowBetaTag( const std::vector<const Muon::MuonSegment*>& segments ) :
- TagBase(TagBase::Author::MuGirlLowBeta,TagBase::Type::SegmentTagged), m_combinedTrack(0),m_updatedExtrapolatedTrack(0),m_segments(segments),
- m_muBeta(-9999.),m_stauSummary(0),m_stauExtras(0),m_rhExtras(0) {}
+ MuGirlLowBetaTag::MuGirlLowBetaTag( const std::vector<ElementLink<Trk::SegmentCollection> >& segments ) :
+ TagBase(TagBase::Author::MuGirlLowBeta,TagBase::Type::SegmentTagged), m_combLink(ElementLink<TrackCollection>()),m_meLink(ElementLink<TrackCollection>()),
+ m_segments(segments),m_muBeta(-9999.),m_stauSummary(0),m_stauExtras(0),m_rhExtras(0) {}
MuGirlLowBetaTag::~MuGirlLowBetaTag() {
- delete m_combinedTrack;
delete m_stauSummary;
delete m_stauExtras;
delete m_rhExtras;
- for( auto x : m_segments ) delete x;
+ m_segments.clear();
}
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuGirlTag.cxx b/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuGirlTag.cxx
index 0fcb0d40dd5..ad81b307780 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuGirlTag.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuGirlTag.cxx
@@ -8,15 +8,14 @@
namespace MuonCombined {
- MuGirlTag::MuGirlTag( const Trk::Track* combinedTrack, const std::vector<const Muon::MuonSegment*>& segments ) :
- TagBase(TagBase::Author::MuGirl,TagBase::Type::Combined), m_combinedTrack(combinedTrack),m_segments(segments) {}
+ MuGirlTag::MuGirlTag( ElementLink<TrackCollection> comblink, const std::vector<ElementLink<Trk::SegmentCollection> >& segments ) :
+ TagBase(TagBase::Author::MuGirl,TagBase::Type::Combined), m_combLink(comblink), m_meLink(ElementLink<TrackCollection>()), m_segments(segments) {}
- MuGirlTag::MuGirlTag( const std::vector<const Muon::MuonSegment*>& segments ) :
- TagBase(TagBase::Author::MuGirl,TagBase::Type::SegmentTagged), m_combinedTrack(0),m_segments(segments) {}
+ MuGirlTag::MuGirlTag( const std::vector<ElementLink<Trk::SegmentCollection> >& segments ) :
+ TagBase(TagBase::Author::MuGirl,TagBase::Type::SegmentTagged), m_combLink(ElementLink<TrackCollection>()),m_meLink(ElementLink<TrackCollection>()),m_segments(segments) {}
MuGirlTag::~MuGirlTag() {
- delete m_combinedTrack;
- for( auto x : m_segments ) delete x;
+ m_segments.clear();
}
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuonCandidate.cxx b/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuonCandidate.cxx
index adee09114dd..bb9107f4585 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuonCandidate.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedEvent/src/MuonCandidate.cxx
@@ -30,11 +30,11 @@ namespace MuonCombined {
m_muonSpectrometerTrack((*m_muonSpectrometerTrackLink)->track()),
m_ownsExtrapolatedTrack(true){}
- MuonCandidate::MuonCandidate( const Trk::Track& msTrack, const ElementLink<xAOD::TrackParticleContainer>& saTrackLink ) :
- m_muonSpectrometerTrackLink(),
+ MuonCandidate::MuonCandidate(const ElementLink<xAOD::TrackParticleContainer>& trackLink, const ElementLink<TrackCollection>& saTrackLink ) :
+ m_muonSpectrometerTrackLink(trackLink),
m_extrapolatedTrackLink(saTrackLink),
- m_extrapolatedTrack((*saTrackLink)->track()),
- m_muonSpectrometerTrack(&msTrack),
+ m_extrapolatedTrack(saTrackLink.getDataPtr()!=nullptr ? *saTrackLink : nullptr),
+ m_muonSpectrometerTrack((*m_muonSpectrometerTrackLink)->track()),
m_ownsExtrapolatedTrack(false) {}
MuonCandidate::~MuonCandidate() {
diff --git a/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py b/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py
index 8cf4920ee27..0fb2e5210d5 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py
+++ b/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py
@@ -15,6 +15,8 @@ from MuonCombinedRecExample.MuonCombinedRecFlags import muonCombinedRecFlags
from MuonRecExample.MooreTools import MuonSeededSegmentFinder, MuonChamberHoleRecoveryTool
from MuonRecExample.MuonRecTools import DCMathSegmentMaker
+from MuonRecExample.MuonRecFlags import muonRecFlags
+
###logfile
from AthenaCommon.Logging import log
@@ -65,6 +67,12 @@ def MuonStauSeededSegmentFinder( name="MuonStauSeededSegmentFinder", **kwargs ):
kwargs.setdefault("MdtRotCreator", getPublicTool("MdtDriftCircleOnTrackCreatorStau") )
kwargs.setdefault("SegmentMaker", getPublicTool("DCMathStauSegmentMaker") )
kwargs.setdefault("SegmentMakerNoHoles", getPublicTool("DCMathStauSegmentMaker") )
+ if muonRecFlags.doNSWNewThirdChain():
+ kwargs.setdefault("CscPrepDataContainer","")
+ else:
+ kwargs.setdefault("sTgcPrepDataContainer","")
+ kwargs.setdefault("MMPrepDataContainer","")
+
return MuonSeededSegmentFinder(name,**kwargs)
def MuonStauSegmentRegionRecoveryTool(name="MuonStauSegmentRegionRecoveryTool",**kwargs ):
@@ -88,7 +96,6 @@ def MuonStauCandidateTrackBuilderTool( name="MuonStauCandidateTrackBuilderTool",
return CfgMgr.Muon__MuonCandidateTrackBuilderTool(name,**kwargs)
def MuonStauInsideOutRecoTool( name="MuonStauInsideOutRecoTool", **kwargs ):
-
kwargs.setdefault("MuonCandidateTrackBuilderTool", getPublicTool("MuonStauCandidateTrackBuilderTool") )
return CfgMgr.MuonCombined__MuonInsideOutRecoTool(name,**kwargs )
diff --git a/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuonCombinedAlgs.py b/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuonCombinedAlgs.py
index b9a86aeb700..e5befec9507 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuonCombinedAlgs.py
+++ b/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuonCombinedAlgs.py
@@ -29,7 +29,10 @@ def MuGirlAlg(name="MuGirlAlg",**kwargs):
def MuonCaloTagAlg(name="MuonCaloTagAlg",**kwargs):
tools = [getPublicTool("MuonCaloTagTool")]
kwargs.setdefault("MuonCombinedInDetExtensionTools", tools )
- kwargs.setdefault("TagMap","caloTagMap");
+ kwargs.setdefault("TagMap","caloTagMap")
+ kwargs.setdefault("CombinedTrackCollection","")
+ kwargs.setdefault("METrackCollection","")
+ kwargs.setdefault("SegmentCollection","")
return CfgMgr.MuonCombinedInDetExtensionAlg(name,**kwargs)
def MuonSegmentTagAlg( name="MuonSegmentTagAlg", **kwargs ):
@@ -40,6 +43,7 @@ def MuonInsideOutRecoAlg( name="MuonInsideOutRecoAlg", **kwargs ):
tools = [getPublicTool("MuonInsideOutRecoTool") ]
kwargs.setdefault("MuonCombinedInDetExtensionTools", tools )
kwargs.setdefault("usePRDs",True)
+ kwargs.setdefault("useNSW", muonRecFlags.dosTGCs() and muonRecFlags.doMicromegas() )
kwargs.setdefault("TagMap","muGirlTagMap")
return CfgMgr.MuonCombinedInDetExtensionAlg(name,**kwargs)
@@ -47,6 +51,10 @@ def MuGirlStauAlg(name="MuGirlStauAlg",**kwargs):
tools = [getPublicTool("MuonStauRecoTool")]
kwargs.setdefault("MuonCombinedInDetExtensionTools", tools )
kwargs.setdefault("TagMap","stauTagMap")
+ kwargs.setdefault("useNSW", muonRecFlags.dosTGCs() and muonRecFlags.doMicromegas() )
+ kwargs.setdefault("CombinedTrackCollection","MuGirlStauCombinedTracks")
+ kwargs.setdefault("METrackCollection","")
+ kwargs.setdefault("SegmentCollection","MuGirlStauSegments")
return CfgMgr.MuonCombinedInDetExtensionAlg(name,**kwargs)
def MuonCombinedInDetCandidateAlg( name="MuonCombinedInDetCandidateAlg",**kwargs ):
diff --git a/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuonCombinedKeys.py b/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuonCombinedKeys.py
index 2a9e0540934..2d6122674b4 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuonCombinedKeys.py
+++ b/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuonCombinedKeys.py
@@ -48,16 +48,34 @@ class SpectrometerTracks(JobProperty): # clarify with MS if to be replaced by jo
StoredValue = 'MuonSpectrometerTracks'
class ExtrapolatedMSTracks(JobProperty):
- """StoreGate key for tracks from MS standalone tracking expressed at IP and eventually refined using IP constraint"""
+ """StoreGate key for tracks from MS standalone tracking expressed at IP and eventually refined using IP constraint from MuidCo"""
statusOn = True
allowedTypes = ['str']
- StoredValue = 'ExtrapolatedMuonTracks'
+ StoredValue = 'MuidMETracks'
class CombinedFitTracks(JobProperty):
- """StoreGate key for tracks from ID+Calo+MS combined fit"""
+ """StoreGate key for tracks from MuidCo combined fit"""
statusOn = True
allowedTypes = ['str']
- StoredValue = 'CombinedMuonTracks'
+ StoredValue = 'MuidCombinedTracks'
+
+class MuGirlCombinedFitTracks(JobProperty):
+ """StoreGate key for tracks from MuGirl combined fit"""
+ statusOn = True
+ allowedTypes = ['str']
+ StoredValue = 'MuGirlCombinedTracks'
+
+class MuGirlExtrapolatedTracks(JobProperty):
+ """StoreGate key for ME tracks from MuGirl combined fit"""
+ statusOn = True
+ allowedTypes = ['str']
+ StoredValue = 'MuGirlMETracks'
+
+class MuGirlStauCombinedFitTracks(JobProperty):
+ """StoreGate key for tracks from MuGirl combined fit"""
+ statusOn = True
+ allowedTypes = ['str']
+ StoredValue = 'MuGirlStauCombinedTracks'
class RefittedExtrapolatedMSTracks(JobProperty):
"""StoreGate key for tracks with refitted extrapolation using the MS part of the combined track"""
@@ -90,6 +108,12 @@ class ExtrapolatedMSOnlyParticles(JobProperty):
allowedTypes = ['str']
StoredValue = 'MSOnlyExtrapolatedMuonTrackParticles'
+class ExtrapolatedMSOnlyTracks(JobProperty):
+ """StoreGate key for trackparticles from MS standalone tracking, expressed at IP"""
+ statusOn = True
+ allowedTypes = ['str']
+ StoredValue = 'MSOnlyExtrapolatedMuonTracks'
+
class CombinedFitParticles(JobProperty):
"""StoreGate key for trackparticles from combined muon track fit """
statusOn = True
@@ -108,6 +132,24 @@ class StatCombinedParticles(JobProperty):
allowedTypes = ['str']
StoredValue = 'StatCombinedMuonParticles'
+class MuGirlSegments(JobProperty):
+ """StoreGate key for segments created by MuGirl"""
+ statusOn = True
+ allowedTypes = ['str']
+ StoredValue = 'MuGirlSegments'
+
+class MuGirlStauSegments(JobProperty):
+ """StoreGate key for segments created by MuGirlStau"""
+ statusOn = True
+ allowedTypes = ['str']
+ StoredValue = 'MuGirlStauSegments'
+
+class MuGirlxAODSegments(JobProperty):
+ """StoreGate key for xAOD::MuonSegments created by MuGirl and MuGirlStau"""
+ statusOn = True
+ allowedTypes = ['str']
+ StoredValue = 'MuGirlMuonSegments'
+
## classes for internal helper objects
class MuidInternalMatches(JobProperty):
@@ -254,6 +296,13 @@ jobproperties.MuonCombinedContainerKeys.add_JobProperty(SegmentTagTrackParticles
jobproperties.MuonCombinedContainerKeys.add_JobProperty(SegmentTagMuons)
jobproperties.MuonCombinedContainerKeys.add_JobProperty(SegmentTagMuonSegments)
jobproperties.MuonCombinedContainerKeys.add_JobProperty(InternalMuTagTracksContainer)
+jobproperties.MuonCombinedContainerKeys.add_JobProperty(ExtrapolatedMSOnlyTracks)
+jobproperties.MuonCombinedContainerKeys.add_JobProperty(MuGirlCombinedFitTracks)
+jobproperties.MuonCombinedContainerKeys.add_JobProperty(MuGirlExtrapolatedTracks)
+jobproperties.MuonCombinedContainerKeys.add_JobProperty(MuGirlStauCombinedFitTracks)
+jobproperties.MuonCombinedContainerKeys.add_JobProperty(MuGirlSegments)
+jobproperties.MuonCombinedContainerKeys.add_JobProperty(MuGirlStauSegments)
+jobproperties.MuonCombinedContainerKeys.add_JobProperty(MuGirlxAODSegments)
##-----------------------------------------------------------------------------
## 5th step
diff --git a/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombinedRec_postprocessing.py b/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombinedRec_postprocessing.py
index f631a008c03..9af202aff01 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombinedRec_postprocessing.py
+++ b/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombinedRec_postprocessing.py
@@ -19,19 +19,21 @@ if rec.doTruth() and muonCombinedRecFlags.doxAOD() and rec.doMuonCombined():
from TrkTruthAlgs.TrkTruthAlgsConf import TrackTruthSelector
colsTP = [ "ExtrapolatedMuonTrackParticles", "CombinedMuonTrackParticles", "MSOnlyExtrapolatedMuonTrackParticles" ]
- cols = [ "ExtrapolatedMuonTracks", "CombinedMuonTracks", "MSOnlyExtrapolatedMuonTracks" ]
+ fcols = [ "ExtrapolatedMuonTracks", "CombinedMuonTracks", "MSOnlyExtrapolatedMuonTracks" ]
+ cols = ["MuidMETracks","MuidCombinedTracks","MSOnlyExtrapolatedMuonTracks","MuGirlCombinedTracks","MuGirlMETracks","MuGirlStauCombinedTracks"]
topSequence+= MuonDetailedTrackTruthMaker("MuonCombinedDetailedTrackTruthMaker")
topSequence.MuonCombinedDetailedTrackTruthMaker.TrackCollectionNames = cols
+ topSequence.MuonCombinedDetailedTrackTruthMaker.DetailedTrackTruthNames = fcols
if muonRecFlags.doNSWNewThirdChain():
topSequence.MuonCombinedDetailedTrackTruthMaker.doNSW=True
from TrkTruthAlgs.TrkTruthAlgsConf import TrackParticleTruthAlg
- for i in range(0, len(cols)):
+ for i in range(0, len(fcols)):
topSequence += TrackTruthSelector(name= cols[i] + "Selector",
- DetailedTrackTruthName = cols[i] + "DetailedTruth",
- OutputName = cols[i] + "Truth" )
- topSequence += TrackParticleTruthAlg(name = cols[i]+"TruthAlg",
- TrackTruthName=cols[i]+"Truth",
+ DetailedTrackTruthName = fcols[i] + "DetailedTruth",
+ OutputName = fcols[i] + "Truth" )
+ topSequence += TrackParticleTruthAlg(name = fcols[i]+"TruthAlg",
+ TrackTruthName=fcols[i]+"Truth",
TrackParticleName = colsTP[i] )
from MuonTruthAlgs.MuonTruthAlgsConf import MuonTruthAssociationAlg
diff --git a/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombined_OutputItemsAOD.py b/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombined_OutputItemsAOD.py
index d8ce9dfba4d..3ce00b8a6b7 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombined_OutputItemsAOD.py
+++ b/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombined_OutputItemsAOD.py
@@ -24,6 +24,8 @@ if DetFlags.detdescr.Muon_on():
MuonCombinedAODList+=[ "xAOD::MuonContainer#Muons" ]
MuonCombinedAODList+=[ "xAOD::MuonAuxContainer#MuonsAux." ]
MuonCombinedAODList+=["MuonCaloEnergyContainer#MuonCaloEnergyCollection"]
+ MuonCombinedAODList+=["xAOD::MuonSegmentContainer#"+MuonCbKeys.MuGirlxAODSegments()]
+ MuonCombinedAODList+=["xAOD::MuonSegmentAuxContainer#"+MuonCbKeys.MuGirlxAODSegments()+"Aux."]
### stau
MuonCombinedAODList+=[ "xAOD::TrackParticleContainer#CombinedStauTrackParticles"]
diff --git a/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombined_OutputItemsESD.py b/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombined_OutputItemsESD.py
index 8bacf45aaab..8e8cce48b17 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombined_OutputItemsESD.py
+++ b/Reconstruction/MuonIdentification/MuonCombinedRecExample/share/MuonCombined_OutputItemsESD.py
@@ -12,6 +12,12 @@ if DetFlags.detdescr.Muon_on():
# ========================Muons===============================================
MuonCombinedESDList+=["TrackCollection#"+MuonCbKeys.ExtrapolatedMSTracks()]
MuonCombinedESDList+=["TrackCollection#"+MuonCbKeys.CombinedFitTracks()]
+ MuonCombinedESDList+=["TrackCollection#"+MuonCbKeys.ExtrapolatedMSOnlyTracks()]
+ MuonCombinedESDList+=["TrackCollection#"+MuonCbKeys.MuGirlCombinedFitTracks()]
+ MuonCombinedESDList+=["TrackCollection#"+MuonCbKeys.MuGirlExtrapolatedTracks()]
+ MuonCombinedESDList+=["TrackCollection#"+MuonCbKeys.MuGirlStauCombinedFitTracks()]
+ MuonCombinedESDList+=["Trk::SegmentCollection#"+MuonCbKeys.MuGirlSegments()]
+ MuonCombinedESDList+=["Trk::SegmentCollection#"+MuonCbKeys.MuGirlStauSegments()]
# Calo
MuonCombinedESDList+=["MuonCaloEnergyContainer#MuonCaloEnergyCollection"]
diff --git a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCandidateTool.h b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCandidateTool.h
index 35d37fcf667..538dbf66fb8 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCandidateTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCandidateTool.h
@@ -11,6 +11,7 @@
#include "GaudiKernel/IAlgTool.h"
#include "MuonCombinedEvent/MuonCandidateCollection.h"
#include "xAODTracking/TrackParticleContainer.h"
+#include "TrkTrack/TrackCollection.h"
namespace MuonCombined {
@@ -28,7 +29,7 @@ namespace MuonCombined {
/**IMuonCandidateTool interface: build a MuonCandidateCollection from a TrackCollection of spectrometer tracks */
- virtual void create( const xAOD::TrackParticleContainer& tracks, MuonCandidateCollection& outputCollection ) = 0;
+ virtual void create( const xAOD::TrackParticleContainer& tracks, MuonCandidateCollection& outputCollection, TrackCollection& outputTracks ) = 0;
};
diff --git a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCandidateTrackBuilderTool.h b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCandidateTrackBuilderTool.h
index 5a28f350d2d..9027023c02c 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCandidateTrackBuilderTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCandidateTrackBuilderTool.h
@@ -26,7 +26,7 @@ namespace Muon {
static const InterfaceID& interfaceID();
/** @brief build a track out of a MuonCandidate */
- virtual const Trk::Track* buildCombinedTrack( const Trk::Track& idTrack, const MuonCandidate& candidate ) const = 0;
+ virtual Trk::Track* buildCombinedTrack( const Trk::Track& idTrack, const MuonCandidate& candidate ) const = 0;
};
diff --git a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedInDetExtensionTool.h b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedInDetExtensionTool.h
index c942b80487a..c1fb1c04bc0 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedInDetExtensionTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedInDetExtensionTool.h
@@ -14,6 +14,8 @@
#include "MuonPrepRawData/MuonPrepDataContainer.h"
#include "MuonPrepRawData/MMPrepDataContainer.h"
#include "MuonPrepRawData/sTgcPrepDataContainer.h"
+#include "TrkTrack/TrackCollection.h"
+#include "TrkSegment/SegmentCollection.h"
namespace MuonCombined {
@@ -27,16 +29,26 @@ namespace MuonCombined {
class IMuonCombinedInDetExtensionTool : virtual public IAlgTool {
public:
+ struct MuonPrdData{
+ MuonPrdData() : mdtPrds(0), rpcPrds(0), tgcPrds(0), cscPrds(0), stgcPrds(0), mmPrds(0) {}
+ const Muon::MdtPrepDataContainer* mdtPrds;
+ const Muon::RpcPrepDataContainer* rpcPrds;
+ const Muon::TgcPrepDataContainer* tgcPrds;
+ const Muon::CscPrepDataContainer* cscPrds;
+ const Muon::sTgcPrepDataContainer* stgcPrds;
+ const Muon::MMPrepDataContainer* mmPrds;
+ };
+
static const InterfaceID& interfaceID( ) ;
/**IMuonCombinedInDetExtensionTool interface: build combined muons from ID candidates */
- virtual void extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap) = 0;
+ virtual void extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks, TrackCollection* meTracks,
+ Trk::SegmentCollection* segments) = 0;
/*New interface including PRDs for MuGirl segment-finding*/
- virtual void extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap,
- const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpdPRDs,
- const Muon::TgcPrepDataContainer* tgcPRDs, const Muon::sTgcPrepDataContainer* sTGCPRDs, const Muon::MMPrepDataContainer* mmPRDs) =0;
+ virtual void extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) =0;
};
diff --git a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedTagTool.h b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedTagTool.h
index 4bf2a44d809..bdb76be9f9b 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedTagTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedTagTool.h
@@ -9,6 +9,7 @@
#define IRECMUONCOMBINEDTAGTOOL_H
#include "GaudiKernel/IAlgTool.h"
+#include "TrkTrack/TrackCollection.h"
#include <vector>
@@ -31,7 +32,8 @@ namespace MuonCombined {
/**IMuonCombinedTagTool interface: build combined muons from a muon and a vector of indet candidates */
- virtual void combine( const MuonCandidate& muonCandidate, const std::vector<const InDetCandidate*>& indetCandidates, InDetCandidateToTagMap& tagMap ) const = 0;
+ virtual void combine( const MuonCandidate& muonCandidate, const std::vector<const InDetCandidate*>& indetCandidates, InDetCandidateToTagMap& tagMap,
+ TrackCollection* combTracks, TrackCollection* METracks) const = 0;
};
diff --git a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedTool.h b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedTool.h
index 8c1a5c4a377..23b1fcd5313 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCombinedTool.h
@@ -12,6 +12,7 @@
#include "MuonCombinedEvent/MuonCandidateCollection.h"
#include "MuonCombinedEvent/InDetCandidateCollection.h"
#include "MuonCombinedEvent/InDetCandidateToTagMap.h"
+#include "TrkTrack/TrackCollection.h"
#include <vector>
namespace MuonCombined {
@@ -30,7 +31,8 @@ namespace MuonCombined {
/**IMuonCombinedTool interface: build combined muons from ID and MS candidates */
- virtual void combine( const MuonCandidateCollection& muonCandidates, const InDetCandidateCollection& inDetCandidates, std::vector<InDetCandidateToTagMap*> tagMaps ) const = 0;
+ virtual void combine( const MuonCandidateCollection& muonCandidates, const InDetCandidateCollection& inDetCandidates, std::vector<InDetCandidateToTagMap*> tagMaps,
+ TrackCollection* combTracks, TrackCollection* METracks) const = 0;
};
diff --git a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCreatorTool.h b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCreatorTool.h
index a47a561ec35..e992339e8ca 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCreatorTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedToolInterfaces/MuonCombinedToolInterfaces/IMuonCreatorTool.h
@@ -18,6 +18,7 @@
#include "TrkTrack/TrackCollection.h"
#include "xAODCaloEvent/CaloClusterContainer.h"
#include <vector>
+#include <string>
namespace MuonCombined {
@@ -40,9 +41,8 @@ namespace MuonCombined {
public:
struct OutputData {
OutputData(xAOD::MuonContainer& container) : muonContainer(&container),
- combinedTrackParticleContainer(0),combinedTrackCollection(0),
- extrapolatedTrackParticleContainer(0), extrapolatedTrackCollection(0),
- msOnlyExtrapolatedTrackParticleContainer(0), msOnlyExtrapolatedTrackCollection(0),
+ combinedTrackParticleContainer(0),extrapolatedTrackParticleContainer(0),
+ msOnlyExtrapolatedTrackParticleContainer(0),
xaodSegmentContainer(0), muonSegmentCollection(0),
slowMuonContainer(0), clusterContainer(0) {
}
@@ -52,21 +52,12 @@ namespace MuonCombined {
/** container for the combined track particles */
xAOD::TrackParticleContainer* combinedTrackParticleContainer;
- /** container for the combined tracks */
- TrackCollection* combinedTrackCollection;
-
/** container for the extrapolated track particles */
xAOD::TrackParticleContainer* extrapolatedTrackParticleContainer;
- /** container for the extrapolated tracks */
- TrackCollection* extrapolatedTrackCollection;
-
/** container for the extrapolated track particles */
xAOD::TrackParticleContainer* msOnlyExtrapolatedTrackParticleContainer;
- /** container for the extrapolated tracks */
- TrackCollection* msOnlyExtrapolatedTrackCollection;
-
/** container for the xAOD segments from MuGirl */
xAOD::MuonSegmentContainer* xaodSegmentContainer;
diff --git a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonCandidateTrackBuilderTool.cxx b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonCandidateTrackBuilderTool.cxx
index 0e66309b35e..494d5381aff 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonCandidateTrackBuilderTool.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonCandidateTrackBuilderTool.cxx
@@ -51,7 +51,7 @@ namespace Muon {
return StatusCode::SUCCESS;
}
- const Trk::Track* MuonCandidateTrackBuilderTool::buildCombinedTrack( const Trk::Track& idTrack, const MuonCandidate& candidate ) const {
+ Trk::Track* MuonCandidateTrackBuilderTool::buildCombinedTrack( const Trk::Track& idTrack, const MuonCandidate& candidate ) const {
ATH_MSG_DEBUG("Building track from candidate with " << candidate.layerIntersections.size() << " layers ");
diff --git a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonCandidateTrackBuilderTool.h b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonCandidateTrackBuilderTool.h
index eab4f692d48..d3e55eee99a 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonCandidateTrackBuilderTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonCandidateTrackBuilderTool.h
@@ -74,7 +74,7 @@ namespace Muon {
StatusCode finalize();
/**IMuonCandidateTrackBuilderTool interface: buildCombinedTrack */
- const Trk::Track* buildCombinedTrack( const Trk::Track& idTrack, const MuonCandidate& candidate ) const;
+ Trk::Track* buildCombinedTrack( const Trk::Track& idTrack, const MuonCandidate& candidate ) const;
private:
diff --git a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonInsideOutRecoTool.cxx b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonInsideOutRecoTool.cxx
index 72e459d38c9..ec7322c6c08 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonInsideOutRecoTool.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonInsideOutRecoTool.cxx
@@ -39,7 +39,7 @@ namespace MuonCombined {
m_candidateTrackBuilder("Muon::MuonCandidateTrackBuilderTool/MuonCandidateTrackBuilderTool"),
m_recoValidationTool(""),
m_trackFitter("Rec::CombinedMuonTrackBuilder/CombinedMuonTrackBuilder"),
- m_trackAmbibuityResolver("Trk::SimpleAmbiguityProcessorTool/MuonAmbiProcessor"),
+ m_trackAmbiguityResolver("Trk::SimpleAmbiguityProcessorTool/MuonAmbiProcessor"),
m_layerHashProvider("Muon::MuonLayerHashProviderTool")
{
declareInterface<IMuonCombinedInDetExtensionTool>(this);
@@ -53,7 +53,7 @@ namespace MuonCombined {
declareProperty("MuonCandidateTrackBuilderTool",m_candidateTrackBuilder );
declareProperty("MuonRecoValidationTool",m_recoValidationTool );
declareProperty("MuonTrackBuilder", m_trackFitter );
- declareProperty("TrackAmbiguityProcessor",m_trackAmbibuityResolver );
+ declareProperty("TrackAmbiguityProcessor",m_trackAmbiguityResolver );
declareProperty("IDTrackMinPt", m_idTrackMinPt = 2500.0 );
declareProperty("IgnoreSiAssociatedCandidates", m_ignoreSiAssocated = true );
}
@@ -74,31 +74,31 @@ namespace MuonCombined {
ATH_CHECK(m_candidateTrackBuilder.retrieve());
if( !m_recoValidationTool.empty() ) ATH_CHECK(m_recoValidationTool.retrieve());
ATH_CHECK(m_trackFitter.retrieve());
- ATH_CHECK(m_trackAmbibuityResolver.retrieve());
+ ATH_CHECK(m_trackAmbiguityResolver.retrieve());
ATH_CHECK(m_vertexKey.initialize());
return StatusCode::SUCCESS;
}
- void MuonInsideOutRecoTool::extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap ) {
+ void MuonInsideOutRecoTool::extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks, TrackCollection* meTracks,
+ Trk::SegmentCollection* segments) {
ATH_MSG_WARNING("This version is deprecated, please use extendWithPRDs for MuGirl");
- extendWithPRDs(inDetCandidates,tagMap,0,0,0,0,0,0);
+ IMuonCombinedInDetExtensionTool::MuonPrdData prdData;
+ extendWithPRDs(inDetCandidates,tagMap,prdData,combTracks,meTracks,segments);
}
- void MuonInsideOutRecoTool::extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap,
- const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpcPRDs,
- const Muon::TgcPrepDataContainer* tgcPRDs, const Muon::sTgcPrepDataContainer* stgcPRDs, const Muon::MMPrepDataContainer* mmPRDs ) {
+ void MuonInsideOutRecoTool::extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) {
ATH_MSG_DEBUG(" extending " << inDetCandidates.size() );
InDetCandidateCollection::const_iterator it = inDetCandidates.begin();
InDetCandidateCollection::const_iterator it_end = inDetCandidates.end();
for( ; it!=it_end;++it ){
- handleCandidate( **it,tagMap,mdtPRDs,cscPRDs,rpcPRDs,tgcPRDs,stgcPRDs,mmPRDs );
+ handleCandidate( **it,tagMap,prdData,combTracks,meTracks,segments );
}
}
- void MuonInsideOutRecoTool::handleCandidate( const InDetCandidate& indetCandidate, InDetCandidateToTagMap* tagMap,
- const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpcPRDs,
- const Muon::TgcPrepDataContainer* tgcPRDs, const Muon::sTgcPrepDataContainer* stgcPRDs, const Muon::MMPrepDataContainer* mmPRDs ) {
+ void MuonInsideOutRecoTool::handleCandidate( const InDetCandidate& indetCandidate, InDetCandidateToTagMap* tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) {
if( m_ignoreSiAssocated && indetCandidate.isSiliconAssociated() ) {
ATH_MSG_DEBUG(" skip silicon associated track for extension ");
@@ -133,7 +133,7 @@ namespace MuonCombined {
// find segments for intersection
Muon::MuonLayerPrepRawData layerPrepRawData;
- if(!getLayerData( (*it).layerSurface.sector, (*it).layerSurface.regionIndex, (*it).layerSurface.layerIndex,layerPrepRawData,mdtPRDs,cscPRDs,rpcPRDs,tgcPRDs,stgcPRDs,mmPRDs )){
+ if(!getLayerData( (*it).layerSurface.sector, (*it).layerSurface.regionIndex, (*it).layerSurface.layerIndex,layerPrepRawData,prdData)){
ATH_MSG_WARNING("Failed to get layer data");
continue;
}
@@ -170,17 +170,17 @@ namespace MuonCombined {
}
// find best candidate and exit if none found
- std::pair<std::unique_ptr<const Muon::MuonCandidate>,std::unique_ptr<const Trk::Track> > bestCandidate = findBestCandidate(indetTrackParticle,allLayers);
+ std::pair<std::unique_ptr<const Muon::MuonCandidate>,Trk::Track*> bestCandidate = findBestCandidate(indetTrackParticle,allLayers);
if( !bestCandidate.first.get() ){
return;
}
// add candidate to indet candidate
- addTag(indetCandidate,tagMap,*bestCandidate.first.get(),bestCandidate.second);
+ addTag(indetCandidate,tagMap,*bestCandidate.first.get(),bestCandidate.second,combTracks,meTracks,segments);
}
- std::pair<std::unique_ptr<const Muon::MuonCandidate>,std::unique_ptr<const Trk::Track> >
+ std::pair<std::unique_ptr<const Muon::MuonCandidate>,Trk::Track*>
MuonInsideOutRecoTool::findBestCandidate( const xAOD::TrackParticle& indetTrackParticle, const std::vector< Muon::MuonLayerRecoData >& allLayers) {
// resolve ambiguities
@@ -191,40 +191,42 @@ namespace MuonCombined {
TrackCollection tracks;
std::map<const Trk::Track*,const Muon::MuonCandidate*> trackCandidateLookup;
for( const auto& candidate : resolvedCandidates ){
- const Trk::Track* track = m_candidateTrackBuilder->buildCombinedTrack(*indetTrackParticle.track(),candidate);
+ Trk::Track* track = m_candidateTrackBuilder->buildCombinedTrack(*indetTrackParticle.track(),candidate);
if( track ){
- tracks.push_back(const_cast<Trk::Track*>(track));
+ tracks.push_back(track);
trackCandidateLookup[track] = &candidate;
}
}
+ ATH_MSG_DEBUG("found "<<tracks.size()<<" combined tracks");
+
// first handle easy cases of zero or one track
- if( tracks.empty() ) return std::pair<std::unique_ptr<const Muon::MuonCandidate>,std::unique_ptr<const Trk::Track> >(nullptr,nullptr);
+ if( tracks.empty() ) return std::pair<std::unique_ptr<const Muon::MuonCandidate>,Trk::Track*>(nullptr,nullptr);
- const Trk::Track* selectedTrack = 0;
+ Trk::Track* selectedTrack = 0;
if( tracks.size() == 1 ){
selectedTrack = tracks.front();
}else{
// more than 1 track call ambiguity solver and select first track
- const TrackCollection* resolvedTracks = m_trackAmbibuityResolver->process(&tracks);
+ TrackCollection* resolvedTracks = m_trackAmbiguityResolver->process(&tracks);
selectedTrack = resolvedTracks->front();
delete resolvedTracks;
-
}
// get candidate
const Muon::MuonCandidate* candidate = trackCandidateLookup[selectedTrack];
if( !candidate ){
ATH_MSG_WARNING("candidate lookup failed, this should not happen");
- return std::pair<std::unique_ptr<const Muon::MuonCandidate>,std::unique_ptr<const Trk::Track> >(nullptr,nullptr);
+ return std::pair<std::unique_ptr<const Muon::MuonCandidate>,Trk::Track* >(nullptr,nullptr);
}
return std::make_pair( std::unique_ptr<const Muon::MuonCandidate>(new Muon::MuonCandidate(*candidate)),
- std::unique_ptr<const Trk::Track>(new Trk::Track(*selectedTrack)) );
+ new Trk::Track(*selectedTrack) );
}
void MuonInsideOutRecoTool::addTag( const InDetCandidate& indetCandidate, InDetCandidateToTagMap* tagMap,
- const Muon::MuonCandidate& candidate, std::unique_ptr<const Trk::Track>& selectedTrack ) const {
+ const Muon::MuonCandidate& candidate, Trk::Track* selectedTrack,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) const {
const xAOD::TrackParticle& idTrackParticle = indetCandidate.indetTrackParticle();
float bs_x = 0.;
@@ -265,27 +267,45 @@ namespace MuonCombined {
ATH_MSG_DEBUG( " NO matched vertex take track perigee x " << bs_x << " y " << bs_y << " z " << bs_z);
}
+ ATH_MSG_DEBUG("selectedTrack:");
+ DataVector<const Trk::TrackStateOnSurface>::const_iterator it = selectedTrack->trackStateOnSurfaces()->begin();
+ DataVector<const Trk::TrackStateOnSurface>::const_iterator it_end = selectedTrack->trackStateOnSurfaces()->end();
+ int tsos = 0;
+ for (; it!=it_end; ++it) {
+ tsos++;
+ if((*it)->trackParameters()) {
+ ATH_MSG_VERBOSE("check tsos "<<tsos<< " r "<<(*it)->trackParameters()->position().perp()<<" z "<<(*it)->trackParameters()->position().z()<<" p "<<(*it)->trackParameters()->momentum().mag());
+ }
+ }
+
// get segments
- std::vector<const Muon::MuonSegment*> segments;
+ std::vector<ElementLink<Trk::SegmentCollection> > segLinks;
for( const auto& layer : candidate.layerIntersections ){
- segments.push_back( new Muon::MuonSegment(*layer.segment) );
+ segments->push_back( new Muon::MuonSegment(*layer.segment) );
+ ElementLink<Trk::SegmentCollection> sLink(*segments,segments->size()-1);
+ segLinks.push_back(sLink);
}
// perform standalone refit
- const Trk::Track* standaloneRefit = m_trackFitter->standaloneRefit(*selectedTrack.get(), bs_x, bs_y, bs_z);
+ Trk::Track* standaloneRefit = m_trackFitter->standaloneRefit(*selectedTrack, bs_x, bs_y, bs_z);
+
+ combTracks->push_back(selectedTrack);
+ ElementLink<TrackCollection> comblink( *combTracks,combTracks->size()-1);
// create tag and set SA refit
- MuGirlTag* tag = new MuGirlTag(selectedTrack.release(),segments);
- if( standaloneRefit ) tag->setUpdatedExtrapolatedTrack(std::unique_ptr<const Trk::Track>(standaloneRefit));
+ MuGirlTag* tag = new MuGirlTag(comblink,segLinks);
+ if( standaloneRefit ){
+ meTracks->push_back(standaloneRefit);
+ ElementLink<TrackCollection> melink( *meTracks,meTracks->size()-1);
+ tag->setUpdatedExtrapolatedTrack(melink);
+ }
// add tag to IndetCandidateToTagMap
tagMap->addEntry(&indetCandidate,tag);
}
bool MuonInsideOutRecoTool::getLayerData( int sector, Muon::MuonStationIndex::DetectorRegionIndex regionIndex,
- Muon::MuonStationIndex::LayerIndex layerIndex, Muon::MuonLayerPrepRawData& layerPrepRawData, const Muon::MdtPrepDataContainer* mdtPRDs,
- const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpcPRDs, const Muon::TgcPrepDataContainer* tgcPRDs,
- const Muon::sTgcPrepDataContainer* stgcPRDs, const Muon::MMPrepDataContainer* mmPRDs ) {
+ Muon::MuonStationIndex::LayerIndex layerIndex, Muon::MuonLayerPrepRawData& layerPrepRawData, IMuonCombinedInDetExtensionTool::MuonPrdData prdData){
// get technologies in the given layer
Muon::MuonStationIndex::StIndex stIndex = Muon::MuonStationIndex::toStationIndex( regionIndex, layerIndex );
@@ -300,12 +320,12 @@ namespace MuonCombined {
for( std::vector<Muon::MuonStationIndex::TechnologyIndex>::iterator it=technologiesInStation.begin();it!=technologiesInStation.end();++it ){
// get collections, keep track of failures
- if(*it == Muon::MuonStationIndex::MDT) isok = !getLayerDataTech<Muon::MdtPrepDataCollection>(sector,*it,regionIndex,layerIndex,mdtPRDs,layerPrepRawData.mdts) ? false : isok;
- else if(*it == Muon::MuonStationIndex::RPC) isok = !getLayerDataTech<Muon::RpcPrepDataCollection>(sector,*it,regionIndex,layerIndex,rpcPRDs,layerPrepRawData.rpcs) ? false : isok;
- else if(*it == Muon::MuonStationIndex::TGC) isok = !getLayerDataTech<Muon::TgcPrepDataCollection>(sector,*it,regionIndex,layerIndex,tgcPRDs,layerPrepRawData.tgcs) ? false : isok;
- else if(*it == Muon::MuonStationIndex::CSCI) isok = !getLayerDataTech<Muon::CscPrepDataCollection>(sector,*it,regionIndex,layerIndex,cscPRDs,layerPrepRawData.cscs) ? false : isok;
- else if(*it == Muon::MuonStationIndex::STGC) isok = !getLayerDataTech<Muon::sTgcPrepDataCollection>(sector,*it,regionIndex,layerIndex,stgcPRDs,layerPrepRawData.stgcs) ? false : isok;
- else if(*it == Muon::MuonStationIndex::MM) isok = !getLayerDataTech<Muon::MMPrepDataCollection>(sector,*it,regionIndex,layerIndex,mmPRDs,layerPrepRawData.mms) ? false : isok;
+ if(*it == Muon::MuonStationIndex::MDT) isok = !getLayerDataTech<Muon::MdtPrepDataCollection>(sector,*it,regionIndex,layerIndex,prdData.mdtPrds,layerPrepRawData.mdts) ? false : isok;
+ else if(*it == Muon::MuonStationIndex::RPC) isok = !getLayerDataTech<Muon::RpcPrepDataCollection>(sector,*it,regionIndex,layerIndex,prdData.rpcPrds,layerPrepRawData.rpcs) ? false : isok;
+ else if(*it == Muon::MuonStationIndex::TGC) isok = !getLayerDataTech<Muon::TgcPrepDataCollection>(sector,*it,regionIndex,layerIndex,prdData.tgcPrds,layerPrepRawData.tgcs) ? false : isok;
+ else if(*it == Muon::MuonStationIndex::CSCI) isok = !getLayerDataTech<Muon::CscPrepDataCollection>(sector,*it,regionIndex,layerIndex,prdData.cscPrds,layerPrepRawData.cscs) ? false : isok;
+ else if(*it == Muon::MuonStationIndex::STGC) isok = !getLayerDataTech<Muon::sTgcPrepDataCollection>(sector,*it,regionIndex,layerIndex,prdData.stgcPrds,layerPrepRawData.stgcs) ? false : isok;
+ else if(*it == Muon::MuonStationIndex::MM) isok = !getLayerDataTech<Muon::MMPrepDataCollection>(sector,*it,regionIndex,layerIndex,prdData.mmPrds,layerPrepRawData.mms) ? false : isok;
}
if( msgLvl(MSG::DEBUG) ){
diff --git a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonInsideOutRecoTool.h b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonInsideOutRecoTool.h
index a34733c607b..2e5b49038dc 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonInsideOutRecoTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonInsideOutRecoTool.h
@@ -56,32 +56,29 @@ namespace MuonCombined {
static const InterfaceID& interfaceID() { return IID_MuonInsideOutRecoTool; }
/**IMuonCombinedInDetExtensionTool interface: extend ID candidate with PRDs for segment-finding */
- virtual void extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap,
- const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpdPRDs,
- const Muon::TgcPrepDataContainer* tgcPRDs, const Muon::sTgcPrepDataContainer* stgcPRDs, const Muon::MMPrepDataContainer* mmPRDs) override;
+ virtual void extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) override;
/**IMuonCombinedInDetExtensionTool interface: deprecated*/
- virtual void extend(const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap) override;
+ virtual void extend(const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks, TrackCollection* meTracks,
+ Trk::SegmentCollection* segments) override;
/** find the best candidate for a given set of segments */
- std::pair<std::unique_ptr<const Muon::MuonCandidate>,std::unique_ptr<const Trk::Track> >
+ std::pair<std::unique_ptr<const Muon::MuonCandidate>,Trk::Track*>
findBestCandidate( const xAOD::TrackParticle& indetTrackParticle, const std::vector< Muon::MuonLayerRecoData >& allLayers);
private:
/** handle a single candidate */
- void handleCandidate( const InDetCandidate& inDetCandidate, InDetCandidateToTagMap* tagMap,
- const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpdPRDs,
- const Muon::TgcPrepDataContainer* tgcPRDs, const Muon::sTgcPrepDataContainer* stgcPRDs, const Muon::MMPrepDataContainer* mmPRDs );
+ void handleCandidate( const InDetCandidate& inDetCandidate, InDetCandidateToTagMap* tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments);
/** add muon candidate to indet candidate */
void addTag( const InDetCandidate& indetCandidate, InDetCandidateToTagMap* tagMap,
- const Muon::MuonCandidate& candidate, std::unique_ptr<const Trk::Track>& selectedTrack ) const;
+ const Muon::MuonCandidate& candidate, Trk::Track* selectedTrack, TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments ) const;
/** access data in layer */
bool getLayerData( int sector, Muon::MuonStationIndex::DetectorRegionIndex regionIndex, Muon::MuonStationIndex::LayerIndex layerIndex,
- Muon::MuonLayerPrepRawData& layerPrepRawData, const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs,
- const Muon::RpcPrepDataContainer* rpdPRDs, const Muon::TgcPrepDataContainer* tgcPRDs, const Muon::sTgcPrepDataContainer* stgcPRDs,
- const Muon::MMPrepDataContainer* mmPRDs );
+ Muon::MuonLayerPrepRawData& layerPrepRawData, IMuonCombinedInDetExtensionTool::MuonPrdData prdData);
/** access data in layer for a given technology */
template<class COL>
@@ -97,7 +94,7 @@ namespace MuonCombined {
ToolHandle<Muon::IMuonCandidateTrackBuilderTool> m_candidateTrackBuilder;
ToolHandle<Muon::IMuonRecoValidationTool> m_recoValidationTool;
ToolHandle<Rec::ICombinedMuonTrackBuilder> m_trackFitter;
- ToolHandle<Trk::ITrackAmbiguityProcessorTool> m_trackAmbibuityResolver;
+ ToolHandle<Trk::ITrackAmbiguityProcessorTool> m_trackAmbiguityResolver;
ToolHandle<Muon::MuonLayerHashProviderTool> m_layerHashProvider;
/** id pt cut */
double m_idTrackMinPt;
diff --git a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.cxx b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.cxx
index a95c33f19cc..40b47c36d21 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.cxx
@@ -153,21 +153,24 @@ namespace MuonCombined {
return StatusCode::SUCCESS;
}
- void MuonStauRecoTool::extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap,
- const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpcPRDs,
- const Muon::TgcPrepDataContainer *tgcPRDs, const Muon::sTgcPrepDataContainer* stgcPRDs, const Muon::MMPrepDataContainer* mmPRDs ) {
+ void MuonStauRecoTool::extendWithPRDs( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) {
//Maybe we'll need this later, I wouldn't be surprised if the PRDs are retrieved somewhere down the chain
//For now it's just a placeholder though
- if(mdtPRDs && cscPRDs && rpcPRDs && tgcPRDs && stgcPRDs && mmPRDs) extend(inDetCandidates, tagMap);
+ if(!prdData.mdtPrds) ATH_MSG_DEBUG("empty PRDs passed");
+ extend(inDetCandidates, tagMap, combTracks, meTracks, segments);
}
- void MuonStauRecoTool::extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap ) {
+ void MuonStauRecoTool::extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks, TrackCollection* meTracks,
+ Trk::SegmentCollection* segments) {
ATH_MSG_DEBUG(" extending " << inDetCandidates.size() );
+ if(meTracks) ATH_MSG_DEBUG("Not currently creating ME tracks for staus");
+
InDetCandidateCollection::const_iterator it = inDetCandidates.begin();
InDetCandidateCollection::const_iterator it_end = inDetCandidates.end();
for( ; it!=it_end;++it ){
- handleCandidate( **it, tagMap );
+ handleCandidate( **it, tagMap, combTracks, segments );
}
}
@@ -184,7 +187,7 @@ namespace MuonCombined {
}
- void MuonStauRecoTool::handleCandidate( const InDetCandidate& indetCandidate, InDetCandidateToTagMap* tagMap ) {
+ void MuonStauRecoTool::handleCandidate( const InDetCandidate& indetCandidate, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks, Trk::SegmentCollection* segments ) {
if( m_ignoreSiAssocated && indetCandidate.isSiliconAssociated() ) {
ATH_MSG_DEBUG(" skip silicon associated track for extension ");
@@ -299,7 +302,7 @@ namespace MuonCombined {
/** STAGE 6
create tag
*/
- addTag( indetCandidate, *candidates.front(), tagMap );
+ addTag( indetCandidate, *candidates.front(), tagMap, combTracks, segments );
}
@@ -396,7 +399,7 @@ namespace MuonCombined {
void MuonStauRecoTool::extractTimeMeasurementsFromTrack( MuonStauRecoTool::Candidate& candidate ) {
- const Trk::Track* combinedTrack = candidate.combinedTrack.get();
+ Trk::Track* combinedTrack = candidate.combinedTrack.get();
if( !combinedTrack ) return;
// select around seed
@@ -805,19 +808,23 @@ namespace MuonCombined {
candidate.finalBetaFitResult = betaFitResult;
}
- void MuonStauRecoTool::addTag( const InDetCandidate& indetCandidate, MuonStauRecoTool::Candidate& candidate, InDetCandidateToTagMap* tagMap ) const {
+ void MuonStauRecoTool::addTag( const InDetCandidate& indetCandidate, MuonStauRecoTool::Candidate& candidate, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks,
+ Trk::SegmentCollection* segments) const {
// get combined track and the segments
- const Trk::Track* combinedTrack = candidate.combinedTrack.release();
- std::vector<const Muon::MuonSegment*> segments;
+ combTracks->push_back(candidate.combinedTrack.release());
+ ElementLink<TrackCollection> comblink( *combTracks,combTracks->size()-1);
+ std::vector<ElementLink<Trk::SegmentCollection> > segmentLinks;
for( const auto& layer : candidate.allLayers ) {
for( const auto& segment : layer.segments ){
- segments.push_back(segment->clone());
+ segments->push_back(segment->clone());
+ ElementLink<Trk::SegmentCollection> segLink(*segments,segments->size()-1);
+ segmentLinks.push_back(segLink);
}
}
// create tag
- MuonCombined::MuGirlLowBetaTag* tag = new MuonCombined::MuGirlLowBetaTag(combinedTrack,segments);
+ MuonCombined::MuGirlLowBetaTag* tag = new MuonCombined::MuGirlLowBetaTag(comblink,segmentLinks);
// add additional info
tag->setMuBeta(candidate.betaFitResult.beta);
@@ -848,10 +855,10 @@ namespace MuonCombined {
if( m_doSummary || msgLvl(MSG::DEBUG) ) {
msg(MSG::INFO) << " Summary::addTag ";
msg(MSG::INFO) << std::endl << " candidate: beta fit result: beta " << candidate.betaFitResult.beta << " chi2/ndof " << candidate.betaFitResult.chi2PerDOF()
- << " segments" << segments.size();
- for( const auto& segment : segments ) msg(MSG::INFO) << std::endl << " " << m_printer->print(*segment);
- if( combinedTrack ) msg(MSG::INFO) << std::endl << " track " << m_printer->print(*combinedTrack)
- << std::endl << m_printer->printStations(*combinedTrack);
+ << " segments" << segmentLinks.size();
+ for( const auto& segment : segmentLinks ) msg(MSG::INFO) << std::endl << " " << m_printer->print(**segment);
+ if( *comblink ) msg(MSG::INFO) << std::endl << " track " << m_printer->print(**comblink)
+ << std::endl << m_printer->printStations(**comblink);
msg(MSG::INFO) << endmsg;
}
@@ -867,11 +874,11 @@ namespace MuonCombined {
// push tracks into a collection and run ambi-solver
TrackCollection tracks(SG::VIEW_ELEMENTS);
- std::map<const Trk::Track*, std::shared_ptr<Candidate> > trackCandidateLookup;
+ std::map<Trk::Track*, std::shared_ptr<Candidate> > trackCandidateLookup;
for( const auto& candidate : candidates ){
- const Trk::Track* track = candidate->combinedTrack.get();
+ Trk::Track* track = candidate->combinedTrack.get();
if( track ){
- tracks.push_back(const_cast<Trk::Track*>(track));
+ tracks.push_back(track);
trackCandidateLookup[track] = candidate;
}
}
@@ -881,8 +888,8 @@ namespace MuonCombined {
if( tracks.size() == 1 ) return true;
// more than 1 track call ambiguity solver and select first track
- std::unique_ptr<const TrackCollection> resolvedTracks(m_trackAmbibuityResolver->process(&tracks));
- const Trk::Track* selectedTrack = resolvedTracks->front();
+ TrackCollection* resolvedTracks=m_trackAmbibuityResolver->process(&tracks);
+ Trk::Track* selectedTrack = resolvedTracks->front();
// get candidate
auto pos = trackCandidateLookup.find(selectedTrack);
@@ -925,14 +932,14 @@ namespace MuonCombined {
ATH_MSG_DEBUG(" candidate: beta " << beta << " associated layers with segments " << candidate->allLayers.size() );
// find best matching track
- std::pair<std::unique_ptr<const Muon::MuonCandidate>,std::unique_ptr<const Trk::Track> > result =
+ std::pair<std::unique_ptr<const Muon::MuonCandidate>,Trk::Track*> result =
m_insideOutRecoTool->findBestCandidate( indetTrackParticle, candidate->allLayers);
if( result.first && result.second ){
ATH_MSG_DEBUG(" combined track found " << std::endl << m_printer->print(*result.second) << std::endl << m_printer->printStations(*result.second) );
// add segments and track pointer to the candidate
candidate->muonCandidate = std::unique_ptr<const Muon::MuonCandidate>(result.first.release());
- candidate->combinedTrack = std::unique_ptr<const Trk::Track>(result.second.release());
+ candidate->combinedTrack.reset(result.second);
// extract times form track
extractTimeMeasurementsFromTrack(*candidate);
@@ -947,7 +954,7 @@ namespace MuonCombined {
// remove all candidates that were not combined
candidates = combinedCandidates;
- // print results afer createCandidate
+ // print results afer combineCandidate
if( m_doSummary || msgLvl(MSG::DEBUG) ) {
msg(MSG::INFO) << " Summary::combineCandidates ";
if( candidates.empty() ) msg(MSG::INFO) << " No candidated found ";
@@ -1021,7 +1028,10 @@ namespace MuonCombined {
ATH_MSG_DEBUG(" New candidate: time measurements " << newCandidate->hits.size() << " status " << newCandidate->betaFitResult.status
<< " beta " << newCandidate->betaFitResult.beta << " chi2/ndof " << newCandidate->betaFitResult.chi2PerDOF() );
// if the fit was successfull add the candidate to the candidate vector
- if( newCandidate->betaFitResult.status != 0 ) candidates.push_back(newCandidate);
+ if( newCandidate->betaFitResult.status != 0 ){
+ newCandidate->combinedTrack=nullptr; //no track exists at this stage
+ candidates.push_back(newCandidate);
+ }
}
}
@@ -1530,6 +1540,7 @@ namespace MuonCombined {
void MuonStauRecoTool::addCandidatesToNtuple( const xAOD::TrackParticle& indetTrackParticle, const MuonStauRecoTool::CandidateVec& candidates, int stage ) {
if( m_recoValidationTool.empty() ) return;
+ ATH_MSG_DEBUG("add candidates to ntuple, stage "<<stage);
for( const auto& candidate : candidates ){
int ntimes = 0;
float beta = -1.;
@@ -1547,6 +1558,7 @@ namespace MuonCombined {
beta = candidate->betaSeed.beta;
chi2ndof = 0;
}
+ if(candidate->combinedTrack) ATH_MSG_DEBUG("candidate has combined track");
m_recoValidationTool->addMuonCandidate( indetTrackParticle, candidate->muonCandidate.get(), candidate->combinedTrack.get(),
ntimes, beta, chi2ndof, stage );
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.h b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.h
index fda8ddd9849..3a21a32599a 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.h
@@ -126,7 +126,7 @@ namespace MuonCombined {
// information filled by the final tracking: MuonCandidate and the track
std::unique_ptr<const Muon::MuonCandidate> muonCandidate;
- std::unique_ptr<const Trk::Track> combinedTrack;
+ std::unique_ptr<Trk::Track> combinedTrack;
MuGirlNS::StauHits stauHits;
Muon::TimePointBetaFit::FitResult finalBetaFitResult;
@@ -152,15 +152,15 @@ namespace MuonCombined {
virtual StatusCode finalize() override;
/**IMuonCombinedInDetExtensionTool interface: extend ID candidate */
- virtual void extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap ) override;
+ virtual void extend( const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks, TrackCollection* meTracks,
+ Trk::SegmentCollection* segments) override;
- virtual void extendWithPRDs(const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap,
- const Muon::MdtPrepDataContainer* mdtPRDs, const Muon::CscPrepDataContainer* cscPRDs, const Muon::RpcPrepDataContainer* rpcPRDs,
- const Muon::TgcPrepDataContainer* tgcPRDs, const Muon::sTgcPrepDataContainer* sTGCPRDs, const Muon::MMPrepDataContainer* mmPRDs) override;
+ virtual void extendWithPRDs(const InDetCandidateCollection& inDetCandidates, InDetCandidateToTagMap* tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData,
+ TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments ) override;
private:
/** handle a single candidate */
- void handleCandidate( const InDetCandidate& inDetCandidate, InDetCandidateToTagMap* tagMap );
+ void handleCandidate( const InDetCandidate& inDetCandidate, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks, Trk::SegmentCollection* segments );
/** associate Hough maxima to intersection */
void associateHoughMaxima( LayerData& layerData );
@@ -208,7 +208,7 @@ namespace MuonCombined {
bool resolveAmbiguities( CandidateVec& candidates );
/** create final tag object and add it to the inDetCandidate */
- void addTag( const InDetCandidate& inDetCandidate, Candidate& candidate, InDetCandidateToTagMap* tagMap ) const;
+ void addTag( const InDetCandidate& inDetCandidate, Candidate& candidate, InDetCandidateToTagMap* tagMap, TrackCollection* combTracks, Trk::SegmentCollection* segments ) const;
/** extract time measurements from the track associated with the candidate */
void extractTimeMeasurementsFromTrack( Candidate& candidate );
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.cxx b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.cxx
index 1a1f0038f0e..8fa8b8e5355 100644
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.cxx
+++ b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.cxx
@@ -467,6 +467,7 @@ HLT::ErrorCode TrigMuSuperEF::hltEndEvent()
m_CacheMapTMEFonly.clear();
m_hashlist.clear();
clearCacheVector( m_tracksCache );
+ clearCacheVector( m_segsCache );
return HLT::OK;
}
@@ -641,6 +642,9 @@ HLT::ErrorCode TrigMuSuperEF::runCombinerOnly(const HLT::TriggerElement* inputTE
return hltStatus;
}
+ m_extrTrkTrackColl=new TrackCollection();
+ addElement( m_tracksCache, m_extrTrkTrackColl);
+
// build muon candidates from the xAOD muons
MuonCandidateCollection *muonCandidates = new MuonCandidateCollection();
xAOD::TrackParticleContainer* combTrackParticleCont = new xAOD::TrackParticleContainer();
@@ -648,7 +652,6 @@ HLT::ErrorCode TrigMuSuperEF::runCombinerOnly(const HLT::TriggerElement* inputTE
combTrackParticleCont->setStore( &combTrackParticleAuxCont );
// can remove the extrapolated track containers once the MuonCandidate no longer takes ownership of the track
- TrackCollection* extrapolatedTracks = new TrackCollection();
xAOD::TrackParticleContainer* saTrackParticleCont = new xAOD::TrackParticleContainer();
xAOD::TrackParticleAuxContainer saTrackParticleAuxCont;
saTrackParticleCont->setStore( &saTrackParticleAuxCont );
@@ -657,9 +660,7 @@ HLT::ErrorCode TrigMuSuperEF::runCombinerOnly(const HLT::TriggerElement* inputTE
const ElementLink<xAOD::TrackParticleContainer>& saTrackLink = muon->extrapolatedMuonSpectrometerTrackParticleLink();
if(saTrackLink.isValid() && muon->muonSpectrometerTrackParticleLink()) {
const ElementLink<xAOD::TrackParticleContainer> msTrackLink = muon->muonSpectrometerTrackParticleLink();
- // for now have to deep copy the extrapolated track (MuonCandidate takes ownership)
- // Upgraded MuonCandidate in future should allow MuonCandidate( msTrackLink, saTrackLink ) without the copy
- if(msTrackLink.isValid()) muonCandidates->push_back( new MuonCombined::MuonCandidate( msTrackLink, new Trk::Track(*((*saTrackLink)->track())) ) );
+ if(msTrackLink.isValid()) muonCandidates->push_back( new MuonCombined::MuonCandidate( msTrackLink, (*saTrackLink)->trackLink()));
else ATH_MSG_WARNING("xAOD::Muon has msTrackLink, but it is not valid");
}//valid Element Links
}//loop on muons
@@ -674,26 +675,28 @@ HLT::ErrorCode TrigMuSuperEF::runCombinerOnly(const HLT::TriggerElement* inputTE
itmap = m_CacheMap.find(m_hashlist);
if (itmap!=m_CacheMap.end()) {
InternalCache *cache = itmap->second;
- retrieveTrackContainersFromCache(cache, combTrackParticleCont, saTrackParticleCont, extrapolatedTracks);
+ retrieveTrackContainersFromCache(cache, combTrackParticleCont, saTrackParticleCont);
}
else{//if cache not in map or we don't have all the containers
//build the muons
+ m_combTrkTrackColl = new TrackCollection();
+ addElement( m_tracksCache, m_combTrkTrackColl);
hltStatus = buildCombinedTracks( muonCandidates, inDetCandidates, m_TMEF_monVars.CB,m_TMEF_CBTimers);
ATH_MSG_DEBUG( "Call buildMuons, n(inDetCandidates) = " << inDetCandidates.size());
- hltStatus = buildMuons( muonCandidates, &inDetCandidates, combTrackParticleCont, extrapolatedTracks, saTrackParticleCont);
+ hltStatus = buildMuons( muonCandidates, &inDetCandidates, combTrackParticleCont, saTrackParticleCont);
if(hltStatus!=HLT::OK) {
if(muonCandidates) for(auto cand : *muonCandidates) delete cand;
ATH_MSG_ERROR("Problem building muons");
return hltStatus;
}
//Set all the containers in the cache
- if(muonCandidates && combTrackParticleCont && extrapolatedTracks && saTrackParticleCont && m_combTrkTrackColl){
+ if(muonCandidates && combTrackParticleCont && saTrackParticleCont && m_combTrkTrackColl && m_extrTrkTrackColl){
InternalCache *cacheStore = new InternalCache();
cacheStore->SetMuonCandidates(muonCandidates);
cacheStore->SetCombinedTracks(combTrackParticleCont);
- cacheStore->SetExtrapolatedTracks(extrapolatedTracks);
cacheStore->SetSATracks(saTrackParticleCont);
cacheStore->SetCombinedTrackColl(m_combTrkTrackColl);
+ cacheStore->SetExtrapolatedTracks(m_extrTrkTrackColl);
cacheStore->SetMuonContainer(m_muonContainer);
//put the cache in the map
m_CacheMap[m_hashlist] = cacheStore;
@@ -702,9 +705,11 @@ HLT::ErrorCode TrigMuSuperEF::runCombinerOnly(const HLT::TriggerElement* inputTE
}
else{//if not in do cache
//build muons
+ m_combTrkTrackColl = new TrackCollection();
+ addElement( m_tracksCache, m_combTrkTrackColl);
hltStatus = buildCombinedTracks( muonCandidates, inDetCandidates, m_TMEF_monVars.CB,m_TMEF_CBTimers);
ATH_MSG_DEBUG( "Call buildMuons, n(inDetCandidates) = " << inDetCandidates.size());
- hltStatus = buildMuons( muonCandidates, &inDetCandidates, combTrackParticleCont, extrapolatedTracks, saTrackParticleCont);
+ hltStatus = buildMuons( muonCandidates, &inDetCandidates, combTrackParticleCont, saTrackParticleCont);
if(hltStatus!=HLT::OK) {
if(muonCandidates) for(auto cand : *muonCandidates) delete cand;
ATH_MSG_ERROR("Problem building muons");
@@ -715,13 +720,13 @@ HLT::ErrorCode TrigMuSuperEF::runCombinerOnly(const HLT::TriggerElement* inputTE
if(muonCandidates) for(auto cand : *muonCandidates) delete cand;
// attach output
- if(attachOutput( TEout, combTrackParticleCont, extrapolatedTracks, saTrackParticleCont, std::move(muonContainerOwn))!=HLT::OK) {
+ if(attachOutput( TEout, combTrackParticleCont, saTrackParticleCont, std::move(muonContainerOwn))!=HLT::OK) {
ATH_MSG_WARNING("Problem attaching output");
return HLT::MISSING_FEATURE;
}
return hltStatus;
-}// runCombinedReconstruction
+}// runCombinerOnly
HLT::ErrorCode TrigMuSuperEF::runCaloTagOnly(const HLT::TriggerElement* inputTE, HLT::TriggerElement* TEout, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn) {
ATH_MSG_DEBUG("Running CaloTag only mode");
@@ -816,7 +821,7 @@ HLT::ErrorCode TrigMuSuperEF::runCaloTagOnly(const HLT::TriggerElement* inputTE,
ATH_MSG_DEBUG("No muons found");
}
// attach output
- if(attachOutput( TEout, m_ctTrackParticleContainer, 0, 0, std::move(muonContainerOwn))!=HLT::OK) {
+ if(attachOutput( TEout, m_ctTrackParticleContainer, 0, std::move(muonContainerOwn))!=HLT::OK) {
ATH_MSG_WARNING("Problem attaching output");
return HLT::MISSING_FEATURE;
}
@@ -829,7 +834,7 @@ HLT::ErrorCode TrigMuSuperEF::runMSReconstruction(const IRoiDescriptor* muonRoI,
ATH_MSG_DEBUG("Call getExtrapolatedTracks");
// Use standalone track tool to find muon candidates
- HLT::ErrorCode hltStatus = m_TrigMuonEF_saTrackTool->getExtrapolatedTracks(muonRoI, muonCandidates, m_TMEF_monVars, m_TMEF_SATimers);
+ HLT::ErrorCode hltStatus = m_TrigMuonEF_saTrackTool->getExtrapolatedTracks(muonRoI, muonCandidates, *m_extrTrkTrackColl, m_TMEF_monVars, m_TMEF_SATimers);
// only bail out in case of real problem. So still attach features if no muon found: important for caching!
if ( hltStatus != HLT::OK && hltStatus != HLT::MISSING_FEATURE ) return hltStatus;
@@ -881,15 +886,14 @@ HLT::ErrorCode TrigMuSuperEF::runMSReconstruction(const IRoiDescriptor* muonRoI,
xAOD::TrackParticleAuxContainer saTrackParticleAuxCont;
saTrackParticleCont->setStore( &saTrackParticleAuxCont );
// and the track container
- TrackCollection* extrapolatedTracks = new TrackCollection();
// call muon builder, so muons are available to the hypos
- hltStatus = buildMuons( &muonCandidates, 0, 0, extrapolatedTracks, saTrackParticleCont );
+ hltStatus = buildMuons( &muonCandidates, 0, 0, saTrackParticleCont );
if(hltStatus!=HLT::OK) {
ATH_MSG_ERROR("Error building muons");
return hltStatus;
}
- hltStatus = attachOutput( TEout, 0, extrapolatedTracks, saTrackParticleCont, std::move(muonContainerOwn) );
+ hltStatus = attachOutput( TEout, 0, saTrackParticleCont, std::move(muonContainerOwn) );
if(hltStatus!=HLT::OK) {
ATH_MSG_ERROR("Problem attaching output");
return hltStatus;
@@ -974,9 +978,12 @@ HLT::ErrorCode TrigMuSuperEF::runStandardChain(const HLT::TriggerElement* inputT
// pre-define objects that are needed in muon building
InDetCandidateCollection inDetCandidates(0);
MuonCandidateCollection* muonCandidates=nullptr;
-
- if(m_standaloneOnly)
+
+ if(m_standaloneOnly){
+ m_extrTrkTrackColl=new TrackCollection();
+ addElement( m_tracksCache, m_extrTrkTrackColl);
return runStandAlone(muonRoI, TEout, muonCandidates, muonContainerOwn);
+ }
// some kind of combined reco
// get xAOD ID tracks
@@ -1016,17 +1023,21 @@ HLT::ErrorCode TrigMuSuperEF::runStandardChain(const HLT::TriggerElement* inputT
xAOD::TrackParticleAuxContainer saTrackParticleAuxCont;
saTrackParticleCont->setStore( &saTrackParticleAuxCont );
combTrackParticleCont->setStore( &combTrackParticleAuxCont );
- TrackCollection* extrapolatedTracks = new TrackCollection();
if(m_doCache){
- auto isSuccess = retrieveFromCache(itmap, muonCandidates, combTrackParticleCont, saTrackParticleCont, extrapolatedTracks);
+ auto isSuccess = retrieveFromCache(itmap, muonCandidates, combTrackParticleCont, saTrackParticleCont);
//todo: check if this can be returned directly
if(!isSuccess)
- hltStatus = rebuildCache(muonRoI, TEout, muonCandidates, &inDetCandidates, combTrackParticleCont, saTrackParticleCont, extrapolatedTracks, muonContainerOwn, elv_xaodidtrks);
+ hltStatus = rebuildCache(muonRoI, TEout, muonCandidates, &inDetCandidates, combTrackParticleCont, saTrackParticleCont, muonContainerOwn, elv_xaodidtrks);
}
else{//not in do cache
muonCandidates= new MuonCandidateCollection();
+ m_combTrkTrackColl=new TrackCollection();
+ addElement( m_tracksCache, m_combTrkTrackColl);
+ m_extrTrkTrackColl=new TrackCollection();
+ addElement( m_tracksCache, m_extrTrkTrackColl);
+
if(m_doOutsideIn && (!m_insideOutFirst || !m_doInsideOut) ) { // run TrigMuonEF
auto hltStatus = runOutsideInOnly(muonRoI, TEout, muonCandidates, &inDetCandidates, muonContainerOwn, elv_xaodidtrks);
if(hltStatus != HLT::OK && hltStatus != HLT::MISSING_FEATURE)
@@ -1034,6 +1045,8 @@ HLT::ErrorCode TrigMuSuperEF::runStandardChain(const HLT::TriggerElement* inputT
if(m_doInsideOut) {
if(m_forceBoth || hltStatus==HLT::MISSING_FEATURE) {
+ m_muGirlTrkSegColl=new Trk::SegmentCollection();
+ addElement(m_segsCache,m_muGirlTrkSegColl);
runMuGirl(elv_xaodidtrks, &inDetCandidates);
}
}
@@ -1045,7 +1058,11 @@ HLT::ErrorCode TrigMuSuperEF::runStandardChain(const HLT::TriggerElement* inputT
hltStatus = m_TrigMuonEF_saTrackTool->getSegments(muonRoI, m_TMEF_monVars, m_TMEF_SATimers);
MuonCombined::InDetCandidateToTagMap* mugirlTagMap=new MuonCombined::InDetCandidateToTagMap();
m_tagMaps.push_back(mugirlTagMap);
- m_muGirlTool->extend(inDetCandidates,mugirlTagMap);
+
+ m_muGirlTrkSegColl=new Trk::SegmentCollection();
+ addElement(m_segsCache,m_muGirlTrkSegColl);
+
+ m_muGirlTool->extend(inDetCandidates,mugirlTagMap,m_combTrkTrackColl,m_extrTrkTrackColl,m_muGirlTrkSegColl);
++m_counter_TrigMuGirl.pass;//@todo fix this counter
if(m_doOutsideIn) {
@@ -1065,7 +1082,7 @@ HLT::ErrorCode TrigMuSuperEF::runStandardChain(const HLT::TriggerElement* inputT
}//doOutsideIn
}// MuGirl first
ATH_MSG_DEBUG( "Call buildMuons, n(inDetCandidates) = " << inDetCandidates.size());
- hltStatus = buildMuons( muonCandidates, &inDetCandidates, combTrackParticleCont, extrapolatedTracks, saTrackParticleCont);
+ hltStatus = buildMuons( muonCandidates, &inDetCandidates, combTrackParticleCont, saTrackParticleCont);
if(hltStatus!=HLT::OK) {
if(muonCandidates) delete muonCandidates;
ATH_MSG_ERROR("Problem building muons");
@@ -1077,7 +1094,7 @@ HLT::ErrorCode TrigMuSuperEF::runStandardChain(const HLT::TriggerElement* inputT
ATH_MSG_DEBUG("saTrackParticleCont size after buildMuons = " << saTrackParticleCont->size());
// attach output
- if(attachOutput( TEout, combTrackParticleCont, extrapolatedTracks, saTrackParticleCont, std::move(muonContainerOwn) )!=HLT::OK) {
+ if(attachOutput( TEout, combTrackParticleCont, saTrackParticleCont, std::move(muonContainerOwn) )!=HLT::OK) {
ATH_MSG_WARNING("Problem attaching output");
return HLT::MISSING_FEATURE;
}
@@ -1112,6 +1129,7 @@ HLT::ErrorCode TrigMuSuperEF::runMSCBReconstruction(const IRoiDescriptor* muonRo
hltStatus = buildCombinedTracks(&muonCandidates,
inDetCandidates,
m_TMEF_monVars.CB,m_TMEF_CBTimers);
+
return hltStatus;
}
@@ -1132,20 +1150,20 @@ HLT::ErrorCode TrigMuSuperEF::runMSSegmentTaggedReconstruction(HLT::TriggerEleme
else{
auto hltStatus = buildSegmentTaggedTracks(inDetCandidates);
InternalCache *cacheStore = new InternalCache();
- hltStatus = buildMuons( &muonCandidates, &inDetCandidates, nullptr, nullptr, nullptr );
+ hltStatus = buildMuons( &muonCandidates, &inDetCandidates, nullptr, nullptr);
cacheStore->SetSegmentTaggedMuonCandidates(&muonCandidates);
}
}
else{
hltStatus = buildSegmentTaggedTracks(inDetCandidates);
- hltStatus = buildMuons( &muonCandidates, &inDetCandidates, nullptr, nullptr, nullptr );
+ hltStatus = buildMuons( &muonCandidates, &inDetCandidates, nullptr, nullptr);
}
if(hltStatus!=HLT::OK) {
ATH_MSG_ERROR("Error building muons");
return hltStatus;
}
- hltStatus = attachOutput( TEout, nullptr, nullptr, nullptr, std::move(muonContainerOwn) );
+ hltStatus = attachOutput( TEout, nullptr, nullptr, std::move(muonContainerOwn) );
if(hltStatus!=HLT::OK) {
ATH_MSG_ERROR("Problem attaching output");
return hltStatus;
@@ -1211,7 +1229,7 @@ HLT::ErrorCode TrigMuSuperEF::buildCombinedTracks(const MuonCandidateCollection*
// call the combiner
ATH_MSG_DEBUG("Call m_muonCombinedTool->combine, n(muon cand)=" << muonCandidates->size() << " n(ID cand)=" << inDetCandidates.size());
- if(muonCandidates) m_muonCombinedTool->combine( *muonCandidates, inDetCandidates, combinedTagMaps ) ;
+ if(muonCandidates) m_muonCombinedTool->combine( *muonCandidates, inDetCandidates, combinedTagMaps, m_combTrkTrackColl, m_extrTrkTrackColl) ;
if(trackFinderTime) trackFinderTime->stop();
if(dataOutputTime) dataOutputTime->start();
@@ -1226,16 +1244,18 @@ HLT::ErrorCode TrigMuSuperEF::buildCombinedTracks(const MuonCandidateCollection*
*/
HLT::ErrorCode TrigMuSuperEF::attachOutput(HLT::TriggerElement* TEout,
xAOD::TrackParticleContainer* combinedTrackParticles,
- const TrackCollection* extrapolatedTracks,
xAOD::TrackParticleContainer* extrapolatedTrackParticles, std::unique_ptr<xAOD::MuonContainer> muonContainerOwn) {
// attach TrackCollection for extrapolated tracks
- if(extrapolatedTracks) {
- HLT::ErrorCode hltStatus = attachFeature(TEout, extrapolatedTracks, "forCB");
+ if(m_extrTrkTrackColl) {
+ std::string label="MuonEFExtrTrkTracks";
+ if(m_standaloneOnly) label="MuonEFSATrkTracks";
+ HLT::ErrorCode hltStatus = attachFeature(TEout, m_extrTrkTrackColl, label);
if( hltStatus!=HLT::OK ) {
ATH_MSG_WARNING("attaching muon standalone tracks to TEout: unsuccessful");
return hltStatus;
} else {
- ATH_MSG_DEBUG("attached muon standalone tracks. Size: " << extrapolatedTracks->size());
+ ATH_MSG_DEBUG("attached muon standalone tracks. Size: " << m_extrTrkTrackColl->size());
+ removeElement( m_tracksCache, m_extrTrkTrackColl ); // make sure we don't try to delete it later
}
}//valid extrapolated tracks
@@ -1325,26 +1345,16 @@ HLT::ErrorCode TrigMuSuperEF::attachOutput(HLT::TriggerElement* TEout,
HLT::ErrorCode TrigMuSuperEF::buildMuons(const MuonCandidateCollection* muonCandidates,
InDetCandidateCollection* inDetCandidates,
xAOD::TrackParticleContainer* combinedTrackParticles,
- TrackCollection* extrapolatedTracks,
xAOD::TrackParticleContainer* extrapolatedTrackParticles) {
- if(combinedTrackParticles) {
- // Track Collection for combined tracks
- m_combTrkTrackColl = new TrackCollection();
- // store the new combined TrackCollection for deletion at end of event if no-one takes ownership
- addElement( m_tracksCache, m_combTrkTrackColl);
- }
-
// call muon creator tool to fill all xAOD objects
// note, this also does duplicate removal
ATH_MSG_DEBUG("Call m_muonCreatorTool->create");
MuonCombined::IMuonCreatorTool::OutputData output(*m_muonContainer);
output.combinedTrackParticleContainer = combinedTrackParticles;
- output.combinedTrackCollection = m_combTrkTrackColl;
output.extrapolatedTrackParticleContainer = extrapolatedTrackParticles;
- output.extrapolatedTrackCollection = extrapolatedTracks;
std::vector<const MuonCombined::InDetCandidateToTagMap*> tagMaps;
for(auto tmap : m_tagMaps){
@@ -1357,7 +1367,7 @@ HLT::ErrorCode TrigMuSuperEF::buildMuons(const MuonCandidateCollection* muonCand
tagMaps.clear();
- ATH_MSG_DEBUG("N(input SA) = " << muonCandidates->size() << " N(SA from muon creator tool) = " << extrapolatedTracks->size());
+ ATH_MSG_DEBUG("N(input SA) = " << muonCandidates->size() << " N(SA from muon creator tool) = " << m_extrTrkTrackColl->size());
if(combinedTrackParticles) ATH_MSG_DEBUG("n(xAOD combinedTrackParticles)=" << combinedTrackParticles->size());
if(extrapolatedTrackParticles) ATH_MSG_DEBUG("n(xAOD extrapolatedTrackParticles)=" << extrapolatedTrackParticles->size());
@@ -1887,7 +1897,7 @@ bool TrigMuSuperEF::buildL2InDetCandidates(const ElementLinkVector<xAOD::TrackPa
}
-bool TrigMuSuperEF::retrieveFromCache(map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap, MuonCandidateCollection* muonCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont, TrackCollection* extrapolatedTracks ){
+bool TrigMuSuperEF::retrieveFromCache(map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap, MuonCandidateCollection* muonCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont){
if(!m_doInsideOut)
itmap = m_CacheMapTMEFonly.find(m_hashlist);
else itmap = m_CacheMap.find(m_hashlist);
@@ -1899,20 +1909,30 @@ bool TrigMuSuperEF::retrieveFromCache(map<std::vector<std::vector<IdentifierHash
//get objects from cache
muonCandidates=cache->MuonCandidates();
ATH_MSG_VERBOSE("got muon candidates with size: "<<muonCandidates->size());
- retrieveTrackContainersFromCache(cache, combTrackParticleCont, saTrackParticleCont, extrapolatedTracks);
+ retrieveTrackContainersFromCache(cache, combTrackParticleCont, saTrackParticleCont);
return true;
}
-HLT::ErrorCode TrigMuSuperEF::rebuildCache(const IRoiDescriptor* muonRoI, HLT::TriggerElement* TEout, MuonCandidateCollection* muonCandidates, InDetCandidateCollection* inDetCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont, TrackCollection* extrapolatedTracks, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn, const ElementLinkVector<xAOD::TrackParticleContainer>& elv_xaodidtrks){
+HLT::ErrorCode TrigMuSuperEF::rebuildCache(const IRoiDescriptor* muonRoI, HLT::TriggerElement* TEout, MuonCandidateCollection* muonCandidates, InDetCandidateCollection* inDetCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn, const ElementLinkVector<xAOD::TrackParticleContainer>& elv_xaodidtrks){
auto hltStatus = HLT::OK;
muonCandidates = new MuonCandidateCollection();
+
+ m_combTrkTrackColl=new TrackCollection();
+ addElement( m_tracksCache, m_combTrkTrackColl);
+
+ m_extrTrkTrackColl=new TrackCollection();
+ addElement( m_tracksCache, m_extrTrkTrackColl);
+
if(m_doOutsideIn && (!m_insideOutFirst || !m_doInsideOut) ) { // run TrigMuonEF
auto hltStatus = runOutsideInOnly(muonRoI, TEout, muonCandidates, inDetCandidates, muonContainerOwn, elv_xaodidtrks);
if(hltStatus != HLT::OK && hltStatus != HLT::MISSING_FEATURE)
return hltStatus;
if(m_doInsideOut) {
- if(m_forceBoth || hltStatus==HLT::MISSING_FEATURE)
+ if(m_forceBoth || hltStatus==HLT::MISSING_FEATURE){
+ m_muGirlTrkSegColl=new Trk::SegmentCollection();
+ addElement(m_segsCache,m_muGirlTrkSegColl);
runMuGirl(elv_xaodidtrks, inDetCandidates);
+ }
}
}//TrigMuonEF first
@@ -1922,7 +1942,11 @@ HLT::ErrorCode TrigMuSuperEF::rebuildCache(const IRoiDescriptor* muonRoI, HLT::T
hltStatus = m_TrigMuonEF_saTrackTool->getSegments(muonRoI, m_TMEF_monVars, m_TMEF_SATimers);
MuonCombined::InDetCandidateToTagMap* mugirlTagMap=new MuonCombined::InDetCandidateToTagMap();
m_tagMaps.push_back(mugirlTagMap);
- m_muGirlTool->extend(*inDetCandidates,mugirlTagMap);
+
+ m_muGirlTrkSegColl=new Trk::SegmentCollection();
+ addElement(m_segsCache,m_muGirlTrkSegColl);
+
+ m_muGirlTool->extend(*inDetCandidates,mugirlTagMap,m_combTrkTrackColl,m_extrTrkTrackColl,m_muGirlTrkSegColl);
++m_counter_TrigMuGirl.pass;//@todo fix this counter
if(m_doOutsideIn) {
@@ -1942,7 +1966,7 @@ HLT::ErrorCode TrigMuSuperEF::rebuildCache(const IRoiDescriptor* muonRoI, HLT::T
}//doOutsideIn
}// MuGirl first
ATH_MSG_DEBUG( "Call buildMuons, n(inDetCandidates) = " << inDetCandidates->size());
- hltStatus = buildMuons( muonCandidates, inDetCandidates, combTrackParticleCont, extrapolatedTracks, saTrackParticleCont);
+ hltStatus = buildMuons( muonCandidates, inDetCandidates, combTrackParticleCont, saTrackParticleCont);
if(hltStatus!=HLT::OK) {
if(muonCandidates)
delete muonCandidates;
@@ -1953,11 +1977,11 @@ HLT::ErrorCode TrigMuSuperEF::rebuildCache(const IRoiDescriptor* muonRoI, HLT::T
delete muonCandidates;
//set cache objects
- if(muonCandidates && combTrackParticleCont && extrapolatedTracks && saTrackParticleCont && m_combTrkTrackColl){
+ if(muonCandidates && combTrackParticleCont && saTrackParticleCont && m_combTrkTrackColl && m_combTrkTrackColl && m_muGirlTrkSegColl){
InternalCache *cacheStore = new InternalCache();
cacheStore->SetMuonCandidates(muonCandidates);
cacheStore->SetCombinedTracks(combTrackParticleCont);
- cacheStore->SetExtrapolatedTracks(extrapolatedTracks);
+ cacheStore->SetExtrapolatedTracks(m_extrTrkTrackColl);
cacheStore->SetSATracks(saTrackParticleCont);
cacheStore->SetCombinedTrackColl(m_combTrkTrackColl);
cacheStore->SetMuonContainer(m_muonContainer);
@@ -1974,7 +1998,7 @@ void TrigMuSuperEF::runMuGirl(const ElementLinkVector<xAOD::TrackParticleContain
++m_counter_TrigMuGirl.total;
MuonCombined::InDetCandidateToTagMap* mugirlTagMap=new MuonCombined::InDetCandidateToTagMap();
m_tagMaps.push_back(mugirlTagMap);
- m_muGirlTool->extend(*inDetCandidates,mugirlTagMap);
+ m_muGirlTool->extend(*inDetCandidates,mugirlTagMap, m_combTrkTrackColl, m_extrTrkTrackColl, m_muGirlTrkSegColl);
++m_counter_TrigMuGirl.pass;//@todo fix this counter
}
@@ -1998,7 +2022,7 @@ HLT::ErrorCode TrigMuSuperEF::runOutsideInOnly(const IRoiDescriptor* muonRoI, HL
return hltStatus;
}
-void TrigMuSuperEF::retrieveTrackContainersFromCache(InternalCache* cache, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont, TrackCollection* extrapolatedTracks ){
+void TrigMuSuperEF::retrieveTrackContainersFromCache(InternalCache* cache, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont){
ATH_MSG_VERBOSE("Repeated ROI");
xAOD::TrackParticleContainer::iterator trk_itr = cache->CombinedTracks().first->begin();
@@ -2022,9 +2046,11 @@ void TrigMuSuperEF::retrieveTrackContainersFromCache(InternalCache* cache, xAOD:
}
//Get extrapolated tracks from cache
- extrapolatedTracks->reserve(cache->ExtrapolatedTracks()->size());
+ m_extrTrkTrackColl = new TrackCollection();
+ m_extrTrkTrackColl->reserve(cache->ExtrapolatedTracks()->size());
+ addElement( m_tracksCache, m_extrTrkTrackColl);
for(auto trk : *(cache->ExtrapolatedTracks()))
- extrapolatedTracks->push_back(new Trk::Track(*trk));
+ m_extrTrkTrackColl->push_back(new Trk::Track(*trk));
//Get combined track collection from cache
m_combTrkTrackColl = new TrackCollection();
@@ -2032,6 +2058,7 @@ void TrigMuSuperEF::retrieveTrackContainersFromCache(InternalCache* cache, xAOD:
addElement( m_tracksCache, m_combTrkTrackColl);
for(auto trk : *(cache->CombinedTrackColl()))
m_combTrkTrackColl->push_back(new Trk::Track(*trk));
+
//Get muon container from cache
xAOD::MuonContainer::iterator mu_itr = cache->MuonContainer().first->begin();
xAOD::MuonContainer::iterator mu_end = cache->MuonContainer().first->end();
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.h b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.h
index 81828729348..5e6e5fabc8b 100644
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.h
+++ b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.h
@@ -31,6 +31,7 @@
#include "MuonCombinedEvent/MuonCandidateCollection.h"
#include "MuonCombinedEvent/InDetCandidateCollection.h"
#include "MuonCombinedEvent/InDetCandidateToTagMap.h"
+#include "TrkSegment/SegmentCollection.h"
#include "InternalCache.h"
@@ -128,13 +129,11 @@ class TrigMuSuperEF: public virtual HLT::FexAlgo {
HLT::ErrorCode buildMuons(const MuonCandidateCollection* muonCandidates,
InDetCandidateCollection* inDetCandidates,
xAOD::TrackParticleContainer* combinedTrackParticles,
- TrackCollection* extrapolatedTracks,
xAOD::TrackParticleContainer* extrapolatedTrackParticles);
// attach all the different output collections to the TE
HLT::ErrorCode attachOutput(HLT::TriggerElement* TEout,
xAOD::TrackParticleContainer* combinedTrackParticles,
- const TrackCollection* extrapolatedTracks,
xAOD::TrackParticleContainer* extrapolatedTrackParticles, std::unique_ptr<xAOD::MuonContainer> muonContainerOwn);
HLT::ErrorCode attachMuonSegmentCombinationCollection(HLT::TriggerElement* TEout);
@@ -153,11 +152,11 @@ class TrigMuSuperEF: public virtual HLT::FexAlgo {
bool buildL2InDetCandidates(const ElementLinkVector<xAOD::TrackParticleContainer>&, InDetCandidateCollection*, const xAOD::L2CombinedMuonContainer*);
void runMuGirl(const ElementLinkVector<xAOD::TrackParticleContainer>&, InDetCandidateCollection*);
- bool retrieveFromCache(std::map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap, MuonCandidateCollection* muonCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont, TrackCollection* extrapolatedTracks );
+ bool retrieveFromCache(std::map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap, MuonCandidateCollection* muonCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont);
- void retrieveTrackContainersFromCache(InternalCache* cache, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont, TrackCollection* extrapolatedTracks );
+ void retrieveTrackContainersFromCache(InternalCache* cache, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont);
- HLT::ErrorCode rebuildCache(const IRoiDescriptor*, HLT::TriggerElement*, MuonCandidateCollection* muonCandidates, InDetCandidateCollection* inDetCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont, TrackCollection* extrapolatedTracks, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn, const ElementLinkVector<xAOD::TrackParticleContainer>& elv_idtrks );
+ HLT::ErrorCode rebuildCache(const IRoiDescriptor*, HLT::TriggerElement*, MuonCandidateCollection* muonCandidates, InDetCandidateCollection* inDetCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn, const ElementLinkVector<xAOD::TrackParticleContainer>& elv_idtrks );
HLT::ErrorCode runOutsideInOnly(const IRoiDescriptor*, HLT::TriggerElement*, MuonCandidateCollection* muonCandidates, InDetCandidateCollection* inDetCandidates, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn, const ElementLinkVector<xAOD::TrackParticleContainer>& elv_idtrks);
void printCounterStats( const PassCounters& counter, const std::string& source, int precision = 3 ) const;
@@ -198,9 +197,18 @@ class TrigMuSuperEF: public virtual HLT::FexAlgo {
// Output combined TrackCollection
TrackCollection* m_combTrkTrackColl;
+ //Output extrapolated TrackCollection
+ TrackCollection* m_extrTrkTrackColl;
+
/// holder for containers that we create and may need to be deleted at end of event
std::vector< TrackCollection* > m_tracksCache;
+ //collection for segments created by MuGirl and MuonStau
+ Trk::SegmentCollection* m_muGirlTrkSegColl;
+
+ // holder for segment containers that may need to be deleted
+ std::vector<Trk::SegmentCollection*> m_segsCache;
+
//Trigger pass/fail counts
PassCounters m_counter_TrigMuonEF;
PassCounters m_counter_TrigMuGirl;
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.cxx b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.cxx
index d4972ac474c..b72032796d2 100644
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.cxx
+++ b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.cxx
@@ -631,6 +631,7 @@ TrigMuonEFStandaloneTrackTool::getSpectrometerTracks(const IRoiDescriptor* muonR
//________________________________________________________________________
HLT::ErrorCode TrigMuonEFStandaloneTrackTool::getExtrapolatedTracks(const IRoiDescriptor* muonRoI,
MuonCandidateCollection& candidateCollection,
+ TrackCollection& extrapolatedTracks,
SegmentCache*& cache,
TrigMuonEFMonVars& monVars,
std::vector<TrigTimer*>& timers)
@@ -659,7 +660,7 @@ HLT::ErrorCode TrigMuonEFStandaloneTrackTool::getExtrapolatedTracks(const IRoiDe
//
// extrapolation
//
- hltStatus = extrapolate(m_spectrometerTrackParticles, candidateCollection, cache, monVars.SA, timers, 6);
+ hltStatus = extrapolate(m_spectrometerTrackParticles, candidateCollection, extrapolatedTracks, cache, monVars.SA, timers, 6);
if (hltStatus!=HLT::OK && hltStatus !=HLT::MISSING_FEATURE) {
ATH_MSG_DEBUG( "Failed to extrapolate spectrometer tracks to IP" );
return hltStatus;
@@ -1897,6 +1898,7 @@ TrigMuonEFStandaloneTrackTool::buildTracks(const MuonSegmentCombinationCollectio
HLT::ErrorCode
TrigMuonEFStandaloneTrackTool::extrapolate(const xAOD::TrackParticleContainer* spectrometerTrackParticles,
MuonCandidateCollection& candidateCollection,
+ TrackCollection& extrapolatedTracks,
SegmentCache* cache,
TrigMuonEFSAMonVars& monVars,
std::vector<TrigTimer*>& timers, unsigned int firstTimerIndex )
@@ -1931,7 +1933,7 @@ TrigMuonEFStandaloneTrackTool::extrapolate(const xAOD::TrackParticleContainer* s
else{
///// Call extrapolator tool
ATH_MSG_DEBUG("Call MuonCandidateTool");
- m_muonCandidateTool->create( *spectrometerTrackParticles, candidateCollection );
+ m_muonCandidateTool->create( *spectrometerTrackParticles, candidateCollection, extrapolatedTracks );
needToCacheExtrapTrks=true;
monVars.wasCached = 0;
}//end of else
@@ -1943,13 +1945,8 @@ TrigMuonEFStandaloneTrackTool::extrapolate(const xAOD::TrackParticleContainer* s
ATH_MSG_DEBUG("REGTEST MuonEF Found " << candidateCollection.size() << " tracks.");
unsigned int nTrack=0;
- for(auto cand : candidateCollection) {
+ for(auto trk : extrapolatedTracks) {
- const Trk::Track* trk = cand->extrapolatedTrack();
- if(!trk) {
- ATH_MSG_DEBUG("REGTEST MuonEF - MuonCandidate with no extrapolated Track");
- continue;
- }
ATH_MSG_DEBUG("REGTEST MuonEF - extrapolated track has Author " << trk->info().dumpInfo());
++nTrack;
@@ -1988,9 +1985,8 @@ TrigMuonEFStandaloneTrackTool::extrapolate(const xAOD::TrackParticleContainer* s
// update track summary
const Trk::TrackSummary* summary = NULL;
- Trk::Track& nonConstTrack = const_cast<Trk::Track&>(*trk);
- m_trackSummaryTool->updateTrack(nonConstTrack);
- summary = (nonConstTrack.trackSummary());
+ m_trackSummaryTool->updateTrack(*trk);
+ summary = (trk->trackSummary());
if(summary==0) {
ATH_MSG_DEBUG("trackSummary not found for this track, cannot get number of subdetector hits.");
}
@@ -2430,12 +2426,13 @@ TrigMuonEFStandaloneTrackTool::getSpectrometerTracks(const IRoiDescriptor* muonR
HLT::ErrorCode
TrigMuonEFStandaloneTrackTool::getExtrapolatedTracks(const IRoiDescriptor* muonRoI,
MuonCandidateCollection& candidateCollection,
+ TrackCollection& extrapolatedTracks,
TrigMuonEFMonVars& monVars,
std::vector<TrigTimer*>& timers)
{
SegmentCache* cache = 0;
ATH_MSG_DEBUG("In getExtrapolatedTracks without cache");
- return getExtrapolatedTracks( muonRoI, candidateCollection, cache, monVars, timers );
+ return getExtrapolatedTracks( muonRoI, candidateCollection, extrapolatedTracks, cache, monVars, timers );
}
//________________________________________________________________________
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.h b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.h
index 6407a3b7ead..96c558e5f36 100644
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.h
+++ b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.h
@@ -121,6 +121,7 @@ class TrigMuonEFStandaloneTrackTool : public AthAlgTool,
/** Run segment finding, spectrometer track building and extrapolation */
virtual HLT::ErrorCode getExtrapolatedTracks(const IRoiDescriptor* muonRoI,
MuonCandidateCollection& candidateCollection,
+ TrackCollection& extrapolatedTracks,
TrigMuonEFMonVars& monvars,
std::vector<TrigTimer*>& timers);
@@ -223,6 +224,7 @@ class TrigMuonEFStandaloneTrackTool : public AthAlgTool,
/** Run segment finding, spectrometer track building and extrapolation */
HLT::ErrorCode getExtrapolatedTracks(const IRoiDescriptor* muonRoI,
MuonCandidateCollection& candidateCollection,
+ TrackCollection& extrapolatedTracks,
SegmentCache*& cache,
TrigMuonEFMonVars& monvars,
std::vector<TrigTimer*>& timers);
@@ -244,6 +246,7 @@ class TrigMuonEFStandaloneTrackTool : public AthAlgTool,
/** Extrapolate input track to IP */
HLT::ErrorCode extrapolate(const xAOD::TrackParticleContainer* spectrometerTrackParticles,
MuonCandidateCollection& candidateCollection,
+ TrackCollection&extrapolatedTracks,
SegmentCache* cache,
TrigMuonEFSAMonVars& monvars,
std::vector<TrigTimer*>& timers, unsigned int firstTimerIndex );
diff --git a/Trigger/TrigTools/TrigMuonToolInterfaces/TrigMuonToolInterfaces/ITrigMuonStandaloneTrackTool.h b/Trigger/TrigTools/TrigMuonToolInterfaces/TrigMuonToolInterfaces/ITrigMuonStandaloneTrackTool.h
index 580a8a1e08e..47cfbcb22c4 100644
--- a/Trigger/TrigTools/TrigMuonToolInterfaces/TrigMuonToolInterfaces/ITrigMuonStandaloneTrackTool.h
+++ b/Trigger/TrigTools/TrigMuonToolInterfaces/TrigMuonToolInterfaces/ITrigMuonStandaloneTrackTool.h
@@ -63,6 +63,7 @@ class ITrigMuonStandaloneTrackTool : virtual public IAlgTool {
/** Run segment finding, spectrometer track building and extrapolation */
virtual HLT::ErrorCode getExtrapolatedTracks(const IRoiDescriptor* muonRoI,
MuonCandidateCollection& candidateCollection,
+ TrackCollection& extrapolatedTracks,
TrigMuonEFMonVars& monvars,
std::vector<TrigTimer*>& timers) = 0;
--
GitLab