diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonRecoValidationTool.h b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonRecoValidationTool.h
index 1afbad978f6f172317cb51ace18855d9e6ccd669..33fface4a890bdd0de50923e2d542a365fd3e38c 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 6ec4245861a46c56461b44c66b6285ee439b9d30..b9ba6ed927d23c8f3933fa68af6f7c9d3870a989 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 bf65ff876729321a3528bb8618839b66468c5da8..2fd46a55f61f732e75a6674cbb5a0a7ab0934fcb 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 ad783a294987e0462f65e7ce4cee3b2f1deb067e..0051f79b2c852714ec89c0a7c2fc40ac1b9c7f8c 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 379665da764c0098821f7c17c2e72bb052a0886f..3a5469f1cbee5bbe10c0e5c2ff83da34a32e2059 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 b0ff4fc42942d15c6781696ba48bb0ef0389a524..c980ebe33e36b243fb360a10bd22fdc09f196b59 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 be605a4efa70d58aa1454ca8468ce8d9d65d6986..9e5ed941f9a804ed38cdc8802b272d388505098a 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 ba0cd2ec2d41245905ad76b1af6caa4eb5d45ac2..1511542592829f60c5101a50ab5e4f640fd93025 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 badea7d2eb6b6d9a412756cc4b6a5a47760e5f2e..2815d4a3cbf421569e4942fb63be005211488031 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 4af8c52449b869b91f7d73b16ecb51e8958e853b..aa2e6a6068771d73f0d9d532555148715a278e09 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 213cc00ab4e7d999b6fdaff61cba1e98ab0bb568..99e513cd5b085fd292cb8f4c7d171c9aa257d28d 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 a3854bbc5ab4bfdb8231c75db4192011ed2db91e..8782d9c11babd1406636c5761e81a94ce59e07d7 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 2ef3ad4f3c5bc72037380c2e6ed1a8c233b99738..c9e5a802efbdc982808b23f78783c361fcc5ce7d 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 ea07afe1334e7c2d396e80bf356f807ee9056112..2a89ba830b054cabc01bc97aa384886b6db0ff49 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 2832188d7c6c0f847f02a268b70b236cfd96b79f..cb3e62278604829c14c3b24fc8bd7a5041e82e08 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 1e7e2323a3be5cd4d41a5792219bce3748725b38..e568d04b98c967719017124a31d4f73bec441dc7 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 1cdd08a8612cc124560d914f414c9933a3ce7b6c..774277391ff2b24cf9ba9a20d97ff400194d66d2 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 28bdb47b5c41deb48432fe3900f85a8a9a92a82a..77c7a2e3ed67413d78c0c1120ddd68fb23cb69a0 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 0d8e32d90bf2ed139b06e92052714eb5a1898620..487ac24e1142c64de84aef391707a89a143a8630 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 7031f81c703f180bb5b87072d4daaedfde39902e..ac21f9bcd54c2ce01a481e0b1095d1c94b6ed1ab 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 969db192e9967a1620ed5c74054a67ad52c39dfd..c4f7e6d96770eca37b14fc98ed49137e65824373 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 27505db94f9bae6de754c56f5c0a54f731a76134..f397951c4cf1ec9ccd74b0593dd36f624363b6c0 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 c2c31db8950d5704122bdb87e860a1358e34292c..ad0a2d28b22cc2a4b844bea3ec564fbf3f0bd808 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 6d86c51842a99408a7d045aa98e717ce3ba26e2f..b0c05ec4e0eb46414274d59d23715f6532cd1cd3 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 06947b750911fb441aa660cb8f397f63b286baf6..65b24990ca82541f731870bd9cc45c0bae45bfd2 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 feea6d941e5d9d85b460fd80d71baff575f65d7d..0bc7e2be2bdec16eb68d8e740ec7eb9aee4e471c 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 be60144bdd48ab8b3b2d05655db9e812a4df4c61..77f05cd1bb83d03a838afcecad7506a848b6a106 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 ad24457cba0c3fcb4db1a9cd6fd95963b144cf94..951fd91cdd9173d2023c48c44a7183b9ee843df9 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 61b258b01fe057529d2d86fddbdd8d0037bd7d20..31c056b92983a96724e58a84223a0ff295a4a8dc 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 404f2eb932707aedb79bfb07d8f30f840b2a69d3..485b6ea0b7c03f81589131d2b12d98b8cf2e5eeb 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 e1cfb796dad557daad46b888c6e824e965aa0359..170a0444e19a6d7a43b5989c627a8c431fd2a128 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 00264aedb2110cfbdaa5ab4b223c528e5787e79c..633a3b3f947c13cf3207b748385b9744bfbc1220 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 28b1cb6ab34bceb46b179677d0dbc49fb92b5c0b..9a057412dc86e8bff03e5030e5c18c77bc82b5f7 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 14d5b6273d379f098e2eec7b4f843d1712dd0981..4c34834439154dc6438e2678d09291ec337cb130 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 bf45a000ac9261c213ee7424297af0fb9e8778c7..08f4f94329300dd9650ad87656f5199af4f29b6e 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 0e46a287a750611da2c2801c4b31ff6c7c18e52a..dbf046b8dac167846a3e49e0f7219c3f17145de2 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 544037b1df5b88e98f2409236bc640d253f5ec07..65a2169ef0ca1c253adbca4578d46dd6b14b6fb8 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 6a11b0a0b70cf6c63b982e7ed5cc285ed04cf057..a25bd32d96e53b3bcce76d819cc759091f1effaa 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 0fcb0d40dd5130cf1782457f23d5da58235fccda..ad81b30778083950681553047244dec07cde53e7 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 adee09114dd6cc2ccfbf1f1d8b4f796c6ade4e63..bb9107f4585287cc2e3b0db480dc711889d8af56 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 8cf4920ee27ea5b22ac9304e8013c0581c26a606..0fb2e5210d5dbe9bbae86cc34d6574ef319036cb 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 b9a86aeb70099524d01c9e383ff7d7a7ce199b76..e5befec9507cb9a32dfa6a49f71d76c026ad851c 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 2a9e05409343ee142b799563e99cad8cd864af4f..2d6122674b43394281fc5a05f7f5a4f134f88b63 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 f631a008c03f3990283a8f0b3308db12d985b3f5..9af202aff012b7e50ca435d9a4536cc3aea43e57 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 d8ce9dfba4d7bd9b71ebf4f161faeeded3cb54f4..3ce00b8a6b79e3128789b0a9d15bf05a2e84b1d3 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 8bacf45aaab8cb64654cbef44e09cbe8bea0614e..8e8cce48b171c07e3843121a21a7328a9457d2f9 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 35d37fcf667cd3c050b54b7103dd7674ea0a9721..538dbf66fb82166867e1b3516b1f6aabf1e72095 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 5a28f350d2d64d844d10e6abe9cc5b08e2789ab8..9027023c02c08fe9f699a95469f24781b9c5c214 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 c942b80487a0fca2b3b5c12e18e46610b43ee7e3..c1fb1c04bc0d87680498be2c8ce43d17db907e9f 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 4bf2a44d809b0fa846a3de4562072319f0dc8b0b..bdb76be9f9b607de8327eca2f60004422c2e6cf3 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 8c1a5c4a377bd6af62c4b3e8aeb0d3c95701cbf3..23b1fcd5313acd58e87c125205f058de65e3a3a9 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 a47a561ec356002058df3f0283165c22d4324d3e..e992339e8caa231d66f974a43258983eda05209f 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 0e66309b35e890394282277a5611def081fa6d88..494d5381affcfe840b481d9a80e572df2a129b73 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 eab4f692d486a7514f9a4d0fc7d84f5c9f6272d2..d3e55eee99a2086a365ee855aa9a46364661c53e 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 72e459d38c96fb683cf21c443fdb7f8613a9a3e3..ec7322c6c084ff417453912193ee4b4c690a9454 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 a34733c607be63eca05beaef660802f9819597d4..2e5b49038dccf4fd35a38166f8fa8c574ddb5c19 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 a95c33f19cc94c03fd8428dcc185396e39a28ba2..40b47c36d218b3e7019f0bffef1a7106d097b293 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 fda8ddd9849720276bd572397be14e3b4a264da5..3a21a32599abea1b5b11f52e18c165e7a387177c 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 1a1f0038f0edd5430cd135d5826694bd73589582..8fa8b8e5355e6c7396cfa3a2633f26ebc6fad93f 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 818287293482e7c4137ab6a5e1632794c60962d2..5e6e5fabc8b7a5a7b00a30106d30879354171298 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 d4972ac474cbf3d430628ed3537aadff662115ef..b72032796d202d8deb64f2475c5037238eb499e6 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 6407a3b7eadec4038e08e799e2a70f4a9560690d..96c558e5f365cfbc80b0622c0f1350c632209a90 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 580a8a1e08e1bc35ab6f7a90a9a2ca4b319b3d8e..47cfbcb22c409607fcd26255a30fc4898f34d5ef 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;