diff --git a/MuonSpectrometer/MuonAlignment/MuonAlignExample/share/MuonAlignment.py b/MuonSpectrometer/MuonAlignment/MuonAlignExample/share/MuonAlignment.py
index f0bc736841f4e5db0a4fe5700db9b57aac0537b8..feb9fb19de0ba274f9c650eb3fc5213bfb4d07be 100644
--- a/MuonSpectrometer/MuonAlignment/MuonAlignExample/share/MuonAlignment.py
+++ b/MuonSpectrometer/MuonAlignment/MuonAlignExample/share/MuonAlignment.py
@@ -39,10 +39,12 @@ if 'errorScaleDb' in dir() and errorScaleDb!='':
MdtDriftCircleOnTrackCreator.OutputLevel = align.OutputLevel()
MdtDriftCircleOnTrackCreator.ErrorScalingTool=muonErrorScalingTool
- CscClusterOnTrackCreator = MuonRecTools.getPublicTool("CscClusterOnTrackCreator")
- CscClusterOnTrackCreator.DoErrorScaling = True
- CscClusterOnTrackCreator.OutputLevel = align.OutputLevel()
- CscClusterOnTrackCreator.ErrorScalingTool=muonErrorScalingTool
+ from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
+ if MuonGeometryFlags.hasCSC():
+ CscClusterOnTrackCreator = MuonRecTools.getPublicTool("CscClusterOnTrackCreator")
+ CscClusterOnTrackCreator.DoErrorScaling = True
+ CscClusterOnTrackCreator.OutputLevel = align.OutputLevel()
+ CscClusterOnTrackCreator.ErrorScalingTool=muonErrorScalingTool
MuonClusterOnTrackCreator = MuonRecTools.getPublicTool("MuonClusterOnTrackCreator")
MuonClusterOnTrackCreator.DoErrorScaling = True
diff --git a/MuonSpectrometer/MuonAlignment/MuonAlignExample/share/muonErrorScaling.py b/MuonSpectrometer/MuonAlignment/MuonAlignExample/share/muonErrorScaling.py
index f54e1283031b84a3ed51ad09a6a1723a8710894c..22ec5a120649cff9d1afb5867574a9f1425d8019 100644
--- a/MuonSpectrometer/MuonAlignment/MuonAlignExample/share/muonErrorScaling.py
+++ b/MuonSpectrometer/MuonAlignment/MuonAlignExample/share/muonErrorScaling.py
@@ -20,13 +20,15 @@ MdtDriftCircleOnTrackCreator.DoErrorScaling = True
MdtDriftCircleOnTrackCreator.ScaleErrorsManually=False
MdtDriftCircleOnTrackCreator.OutputLevel = outputLevel
MdtDriftCircleOnTrackCreator.ErrorScalingTool=muonErrorScalingTool
-
-CscClusterOnTrackCreator = MuonRecTools.getPrivateTool("CscClusterOnTrackCreator")
-CscClusterOnTrackCreator.DoRpcErrorScaling = True
-CscClusterOnTrackCreator.DoTgcErrorScaling = True
-CscClusterOnTrackCreator.DoCscErrorScaling = True
-CscClusterOnTrackCreator.OutputLevel = outputLevel
-CscClusterOnTrackCreator.ErrorScalingTool=muonErrorScalingTool
+
+from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
+if MuonGeometryFlags.hasCSC():
+ CscClusterOnTrackCreator = MuonRecTools.getPrivateTool("CscClusterOnTrackCreator")
+ CscClusterOnTrackCreator.DoRpcErrorScaling = True
+ CscClusterOnTrackCreator.DoTgcErrorScaling = True
+ CscClusterOnTrackCreator.DoCscErrorScaling = True
+ CscClusterOnTrackCreator.OutputLevel = outputLevel
+ CscClusterOnTrackCreator.ErrorScalingTool=muonErrorScalingTool
MuonClusterOnTrackCreator = MuonRecTools.getPublicTool("MuonClusterOnTrackCreator")
MuonClusterOnTrackCreator.DoRpcErrorScaling = True
diff --git a/MuonSpectrometer/MuonCalib/MuonCalibAlgs/MuonCalibAlgs/MuonCalibAlg.h b/MuonSpectrometer/MuonCalib/MuonCalibAlgs/MuonCalibAlgs/MuonCalibAlg.h
index 74b55b4254d764c44d257fa6f379c931476dcf15..ef5f364e3380d051080d92626aea884bae214adc 100644
--- a/MuonSpectrometer/MuonCalib/MuonCalibAlgs/MuonCalibAlgs/MuonCalibAlg.h
+++ b/MuonSpectrometer/MuonCalib/MuonCalibAlgs/MuonCalibAlgs/MuonCalibAlg.h
@@ -2,18 +2,16 @@
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-
#ifndef MUONCALIB_MUONCALIBALG_H
#define MUONCALIB_MUONCALIBALG_H
#include "AthenaBaseComps/AthAlgorithm.h"
#include "GaudiKernel/ToolHandle.h"
+#include "GaudiKernel/ServiceHandle.h"
#include "MuonCalibEventBase/MuonCalibEvent.h"
#include "MuonPrdSelector/MuonIdCutTool.h"
-#include "MuonIdHelpers/MuonIdHelperTool.h"
-
-class MdtIdHelper;
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
class ICscStripFitter;
@@ -116,13 +114,10 @@ namespace MuonCalib {
// time samples and extract strip charge
ToolHandle<ICscStripFitter> m_stripFitter;
-
// Tool to cut on identifiers
ToolHandle<IMuonIdCutTool> m_muonIdCutTool;
- /* Tool for Identifier Helpers */
- ToolHandle<Muon::MuonIdHelperTool> m_muonIdHelperTool{this, "idHelper",
- "Muon::MuonIdHelperTool/MuonIdHelperTool", "Handle to the MuonIdHelperTool"};
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
std::vector <const MuonCalibEvent*> m_events; //!< vector holding pointers to events, for deletion at finalize
diff --git a/MuonSpectrometer/MuonCalib/MuonCalibAlgs/src/MuonCalibAlg.cxx b/MuonSpectrometer/MuonCalib/MuonCalibAlgs/src/MuonCalibAlg.cxx
index 103a59a357647b52fc3e1fcb250a928cd90b5fe0..e39d5f532f7bf7ca9ae266820b9f11f4306490ae 100644
--- a/MuonSpectrometer/MuonCalib/MuonCalibAlgs/src/MuonCalibAlg.cxx
+++ b/MuonSpectrometer/MuonCalib/MuonCalibAlgs/src/MuonCalibAlg.cxx
@@ -122,7 +122,7 @@ namespace MuonCalib {
declareProperty("doMDTs", m_doMDTs = true );
declareProperty("doCSCs", m_doCSCs = true );
- //declareProperty("CSCStripFitter", m_stripFitter);
+ declareProperty("CSCStripFitter", m_stripFitter);
declareProperty("doRPCs", m_doRPCs = true );
declareProperty("doTGCs", m_doTGCs = true );
@@ -138,8 +138,6 @@ namespace MuonCalib {
}
MuonCalibAlg::~MuonCalibAlg() {
- // close root file
-// if( m_createRootFile ) RootFileManager::getInstance()->closeFile();
}
StatusCode MuonCalibAlg::initialize()
@@ -162,32 +160,22 @@ namespace MuonCalib {
log << MSG::INFO << "================================" << endmsg;
- StatusCode sc = m_stripFitter.retrieve();
- if ( sc.isFailure() ) {
- log << MSG::FATAL << "MuonCalibAlg: Unable to retrieve strip fitter" << endmsg;
- return sc;
- } else {
- log << MSG::INFO << "CSCStripFitter : " << "Using Fitter with name \"" << m_stripFitter->name() << "\"" << endmsg;
- }
+ ATH_CHECK(m_idHelperSvc.retrieve());
+ if (!m_stripFitter.empty()) {
+ if (!m_idHelperSvc->hasCSC()) ATH_MSG_WARNING("The current layout does not have any CSC chamber but you gave a CSCStripFitter, ignoring it, but double-check configuration");
+ else ATH_CHECK( m_stripFitter.retrieve() );
+ }
+ if (m_doCSCs && !m_idHelperSvc->hasCSC()) {
+ ATH_MSG_WARNING("The current layout does not have any CSC chamber but you have set doCSCs to true, setting it to false, but double-check configuration");
+ m_doCSCs = false;
+ }
m_eventNumber = 0;
- sc = m_idToFixedIdTool.retrieve();
- if (sc.isFailure()) {
- log << MSG::FATAL << "Could not find tool " << m_idToFixedIdTool << endmsg;
- return sc;
- } else {
- log << MSG::INFO << "Retrieved tool " << m_idToFixedIdTool << endmsg;
- }
+ ATH_CHECK( m_idToFixedIdTool.retrieve() );
- sc = m_muonIdCutTool.retrieve();
- if (sc.isFailure()) {
- log << MSG::FATAL << "Could not find tool " << m_muonIdCutTool << endmsg;
- return sc;
- } else {
- log << MSG::INFO << "Retrieved tool " << m_muonIdCutTool << endmsg;
- }
+ ATH_CHECK( m_muonIdCutTool.retrieve() );
// retrieve TileTBID helper
// (The MBTS was added to the Test Beam (TB) list.)
@@ -198,16 +186,11 @@ namespace MuonCalib {
// retrieve MuonDetectorManager
std::string managerName="Muon";
- sc=detStore()->retrieve(m_detMgr);
- if (sc.isFailure()) {
+ if (detStore()->retrieve(m_detMgr).isFailure()) {
log << MSG::INFO << "Could not find the MuonGeoModel Manager: "
<< managerName << " ! " << endmsg;
}
-
- // initialize MuonIdHelperTool
- ATH_CHECK( m_muonIdHelperTool.retrieve() );
-
log << MSG::INFO << "Initialization ended " << endmsg;
return StatusCode::SUCCESS;
}
@@ -817,7 +800,7 @@ namespace MuonCalib {
const MuonGM::CscReadoutElement* detEl = m_detMgr->getCscReadoutElement(id);
if( !detEl ){
log << MSG::WARNING << "Found CSC Identifier which seems to have no readout element "
- << m_muonIdHelperTool->mdtIdHelper().print_to_string(id) << endmsg;
+ << m_idHelperSvc->mdtIdHelper().print_to_string(id) << endmsg;
continue;
}
MuonFixedId mfi = m_idToFixedIdTool->idToFixedId(id);
@@ -1261,8 +1244,8 @@ namespace MuonCalib {
// time of first sample is not very useful. we need fitted time
// invoke fitter first and then set the time
//rawCscHit->setT( (*csc_it)->timeOfFirstSample() );
- int measuresPhi = m_muonIdHelperTool->cscIdHelper().measuresPhi((*csc_it)->identify());
- int chamberLayer = m_muonIdHelperTool->cscIdHelper().chamberLayer((*csc_it)->identify());
+ int measuresPhi = m_idHelperSvc->cscIdHelper().measuresPhi((*csc_it)->identify());
+ int chamberLayer = m_idHelperSvc->cscIdHelper().chamberLayer((*csc_it)->identify());
float stripWidth = (*csc_it)->detectorElement()->cathodeReadoutPitch( chamberLayer, measuresPhi );
rawCscHit->setWidth( stripWidth );
// invoke the strip fitter to fit the time samples (which is a vector of 4 elements)
@@ -1323,9 +1306,9 @@ namespace MuonCalib {
for( ; tgc_it!=tgc_it_end; ++ tgc_it){
MuonCalibRawTgcHit* rawTgcHit = new MuonCalibRawTgcHit();
MuonFixedId fID = m_idToFixedIdTool->idToFixedId( (*tgc_it)->identify() ) ;
- bool measuresPhi = (bool) m_muonIdHelperTool->tgcIdHelper().isStrip((*tgc_it)->identify());
- int gasGap = m_muonIdHelperTool->tgcIdHelper().gasGap((*tgc_it)->identify());
- int channel = m_muonIdHelperTool->tgcIdHelper().channel((*tgc_it)->identify());
+ bool measuresPhi = (bool) m_idHelperSvc->tgcIdHelper().isStrip((*tgc_it)->identify());
+ int gasGap = m_idHelperSvc->tgcIdHelper().gasGap((*tgc_it)->identify());
+ int channel = m_idHelperSvc->tgcIdHelper().channel((*tgc_it)->identify());
const MuonGM::TgcReadoutElement* detEl = (*tgc_it)->detectorElement();
double width = -999.;
@@ -1346,9 +1329,9 @@ namespace MuonCalib {
rawTgcHit->setId( fID );
rawTgcHit->setGlobalPosition( (*tgc_it)->globalPosition() );
- rawTgcHit->setStation( m_muonIdHelperTool->tgcIdHelper().stationName((*tgc_it)->identify()) );
- rawTgcHit->setEta( m_muonIdHelperTool->tgcIdHelper().stationEta((*tgc_it)->identify()) );
- rawTgcHit->setPhi( m_muonIdHelperTool->tgcIdHelper().stationPhi((*tgc_it)->identify()) );
+ rawTgcHit->setStation( m_idHelperSvc->tgcIdHelper().stationName((*tgc_it)->identify()) );
+ rawTgcHit->setEta( m_idHelperSvc->tgcIdHelper().stationEta((*tgc_it)->identify()) );
+ rawTgcHit->setPhi( m_idHelperSvc->tgcIdHelper().stationPhi((*tgc_it)->identify()) );
rawTgcHit->setGasGap( gasGap );
rawTgcHit->setIsStrip( static_cast<int>(measuresPhi) );
rawTgcHit->setChannel( channel );
@@ -1429,7 +1412,7 @@ namespace MuonCalib {
rawTgcCoin->setGlobalPositionIn((*tgcCoin_it)->globalposIn());
rawTgcCoin->setGlobalPositionOut((*tgcCoin_it)->globalposOut());
rawTgcCoin->setType(0);
- rawTgcCoin->setEta(m_muonIdHelperTool->tgcIdHelper().stationEta((*tgcCoin_it)->identify()));
+ rawTgcCoin->setEta(m_idHelperSvc->tgcIdHelper().stationEta((*tgcCoin_it)->identify()));
rawTgcCoin->setPhi((*tgcCoin_it)->phi());
rawTgcCoin->setSector(sector);
rawTgcCoin->setIsForward(static_cast<int>((*tgcCoin_it)->isForward()));
@@ -1450,7 +1433,7 @@ namespace MuonCalib {
rawTgcCoin->setGlobalPositionIn((*tgcCoin_it)->globalposIn());
rawTgcCoin->setGlobalPositionOut((*tgcCoin_it)->globalposOut());
rawTgcCoin->setType(1);
- rawTgcCoin->setEta(m_muonIdHelperTool->tgcIdHelper().stationEta((*tgcCoin_it)->identify()));
+ rawTgcCoin->setEta(m_idHelperSvc->tgcIdHelper().stationEta((*tgcCoin_it)->identify()));
rawTgcCoin->setPhi((*tgcCoin_it)->phi());
rawTgcCoin->setSector(sector);
rawTgcCoin->setIsForward(static_cast<int>((*tgcCoin_it)->isForward()));
@@ -1472,7 +1455,7 @@ namespace MuonCalib {
rawTgcCoin->setGlobalPositionIn(tmp);
rawTgcCoin->setGlobalPositionOut((*tgcCoin_it)->globalposOut());
rawTgcCoin->setType(2);
- rawTgcCoin->setEta(m_muonIdHelperTool->tgcIdHelper().stationEta((*tgcCoin_it)->identify()));
+ rawTgcCoin->setEta(m_idHelperSvc->tgcIdHelper().stationEta((*tgcCoin_it)->identify()));
rawTgcCoin->setPhi((*tgcCoin_it)->phi());
rawTgcCoin->setSector(sector);
rawTgcCoin->setIsForward(static_cast<int>((*tgcCoin_it)->isForward()));
@@ -1684,8 +1667,8 @@ namespace MuonCalib {
rawRpcHit->setT( prd.time() );
// get detector element
const MuonGM::RpcReadoutElement* detEl = prd.detectorElement();
- rawRpcHit->setWidth( detEl->StripWidth( m_muonIdHelperTool->rpcIdHelper().measuresPhi(prd.identify()) ) );
- rawRpcHit->setLength( detEl->StripLength(m_muonIdHelperTool->rpcIdHelper().measuresPhi(prd.identify())));
+ rawRpcHit->setWidth( detEl->StripWidth( m_idHelperSvc->rpcIdHelper().measuresPhi(prd.identify()) ) );
+ rawRpcHit->setLength( detEl->StripLength(m_idHelperSvc->rpcIdHelper().measuresPhi(prd.identify())));
return rawRpcHit;
}
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/CscClusterOnTrackCreator.cxx b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/CscClusterOnTrackCreator.cxx
index 5021d3cfbeabdb394dd7f134752aa3f8b71c343e..ae2974c2b95f83bfbd046b2214379beb9e1ae7b8 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/CscClusterOnTrackCreator.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/CscClusterOnTrackCreator.cxx
@@ -1,18 +1,10 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-
-
-///////////////////////////////////////////////////////////////////
-// Implementation file for class CscClusterOnTrackCreator
-///////////////////////////////////////////////////////////////////
-// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
// AlgTool used for MuonClusterOnTrack object production
///////////////////////////////////////////////////////////////////
-// Version 1.0 20/07/2004
-///////////////////////////////////////////////////////////////////
#include "CscClusterOnTrackCreator.h"
#include "TrkEventPrimitives/LocalParameters.h"
@@ -35,9 +27,6 @@
#include "TrkRIO_OnTrack/check_cast.h"
-using std::vector;
-using std::setw;
-using std::atan2;
using Muon::CscStripPrepDataContainer;
using Muon::CscStripPrepDataCollection;
using Muon::CscStripPrepData;
@@ -90,9 +79,12 @@ namespace Muon {
return StatusCode::FAILURE;
}
- ATH_CHECK( m_muonIdHelperTool.retrieve() );
+ ATH_CHECK( m_idHelperSvc.retrieve() );
- // -- check this, maybe the helpers are not necessary after all.
+ if (!m_idHelperSvc->hasCSC()) {
+ ATH_MSG_ERROR("The given detector layout does not contain any CSC chamber, there must be something wrong in the configuration, since the CscClusterOnTrackCreator cannot be needed.");
+ return StatusCode::FAILURE;
+ }
// get error scaling tool
//
@@ -189,28 +181,28 @@ namespace Muon {
Amg::MatrixX loce = RIO.localCovariance();
if ( m_doCsc
- && m_muonIdHelperTool->cscIdHelper().is_csc(RIO.identify())
+ && m_idHelperSvc->cscIdHelper().is_csc(RIO.identify())
&& !m_cscErrorScalingKey.key().empty()) {
SG::ReadCondHandle<RIO_OnTrackErrorScaling> error_scaling( m_cscErrorScalingKey );
loce = check_cast<MuonEtaPhiRIO_OnTrackErrorScaling>(*error_scaling)->getScaledCovariance( loce, Trk::distPhi);
ATH_MSG_VERBOSE ( "CSC: new cov(0,0) is " << loce(0,0) );
}
if ( m_doRpc
- && m_muonIdHelperTool->rpcIdHelper().is_rpc(RIO.identify())
+ && m_idHelperSvc->rpcIdHelper().is_rpc(RIO.identify())
&& !m_rpcErrorScalingKey.key().empty()) {
SG::ReadCondHandle<RIO_OnTrackErrorScaling> error_scaling( m_rpcErrorScalingKey );
loce = check_cast<MuonEtaPhiRIO_OnTrackErrorScaling>(*error_scaling)->getScaledCovariance( loce, Trk::distPhi);
ATH_MSG_VERBOSE ( "RPC: new cov(0,0) is " << loce(0,0) );
}
if ( m_doTgc
- && m_muonIdHelperTool->tgcIdHelper().is_tgc(RIO.identify())
+ && m_idHelperSvc->tgcIdHelper().is_tgc(RIO.identify())
&& !m_tgcErrorScalingKey.key().empty() ) {
SG::ReadCondHandle<RIO_OnTrackErrorScaling> error_scaling( m_tgcErrorScalingKey );
loce = check_cast<MuonEtaPhiRIO_OnTrackErrorScaling>(*error_scaling)->getScaledCovariance( loce, Trk::distPhi);
ATH_MSG_VERBOSE ( "TGC: new cov(1,1) is " << loce(0,0) );
}
- if( m_doRpc && m_muonIdHelperTool->rpcIdHelper().is_rpc(RIO.identify()) ){
+ if( m_doRpc && m_idHelperSvc->rpcIdHelper().is_rpc(RIO.identify()) ){
// cast to RpcPrepData
const RpcPrepData* MClus = dynamic_cast<const RpcPrepData*> (&RIO);
if (!MClus) {
@@ -219,7 +211,7 @@ namespace Muon {
}
MClT = new RpcClusterOnTrack(MClus,locpar,loce,positionAlongStrip);
- }else if( m_doTgc && m_muonIdHelperTool->tgcIdHelper().is_tgc(RIO.identify()) ){
+ }else if( m_doTgc && m_idHelperSvc->tgcIdHelper().is_tgc(RIO.identify()) ){
// cast to TgcPrepData
const TgcPrepData* MClus = dynamic_cast<const TgcPrepData*> (&RIO);
@@ -229,11 +221,11 @@ namespace Muon {
}
// calculation of 2D error matrix for TGC phi strips
- if ( m_muonIdHelperTool->tgcIdHelper().isStrip(RIO.identify())){
+ if ( m_idHelperSvc->tgcIdHelper().isStrip(RIO.identify())){
- int stationeta=m_muonIdHelperTool->tgcIdHelper().stationEta(RIO.identify());
- int stripNo = m_muonIdHelperTool->tgcIdHelper().channel(RIO.identify());
- int gasGap = m_muonIdHelperTool->tgcIdHelper().gasGap(RIO.identify());
+ int stationeta=m_idHelperSvc->tgcIdHelper().stationEta(RIO.identify());
+ int stripNo = m_idHelperSvc->tgcIdHelper().channel(RIO.identify());
+ int gasGap = m_idHelperSvc->tgcIdHelper().gasGap(RIO.identify());
const MuonGM::TgcReadoutElement *ele= MClus->detectorElement();
@@ -248,22 +240,22 @@ namespace Muon {
}
Amg::MatrixX mat = Amg::MatrixX(2,2);
- double phistereo=atan2(localX2-localX1,stripLength);
- double Sn = sin(phistereo);
+ double phistereo=std::atan2(localX2-localX1,stripLength);
+ double Sn = std::sin(phistereo);
double Sn2 = Sn*Sn;
double Cs2 = 1.-Sn2;
double V0 = stripWidth*stripWidth/12;
double V1 = stripLength*stripLength/12;
mat(0,0) = (Cs2*V0+Sn2*V1);
- mat.fillSymmetric(1,0,(Sn*sqrt(Cs2)*(V0-V1)));
+ mat.fillSymmetric(1,0,(Sn*std::sqrt(Cs2)*(V0-V1)));
mat(1,1) = (Sn2*V0+Cs2*V1);
loce=mat;
}
MClT = new TgcClusterOnTrack(MClus,locpar,loce,positionAlongStrip);
- } else if ( m_doCsc && m_muonIdHelperTool->cscIdHelper().is_csc(RIO.identify()) ){
+ } else if ( m_doCsc && m_idHelperSvc->cscIdHelper().is_csc(RIO.identify()) ){
// cast to CscPrepData
const CscPrepData* MClus = dynamic_cast<const CscPrepData*> (&RIO);
@@ -286,7 +278,7 @@ namespace Muon {
createRIO_OnTrack(const Trk::PrepRawData& RIO, const Amg::Vector3D& GP,
const Amg::Vector3D& GD) const {
- if ( ! ( m_doCsc && m_muonIdHelperTool->cscIdHelper().is_csc(RIO.identify()) ) ) {
+ if ( ! ( m_doCsc && m_idHelperSvc->cscIdHelper().is_csc(RIO.identify()) ) ) {
ATH_MSG_WARNING ( "CscClusterOnTrackCreator::createRIO_OnTrack is called by the other muon tech" );
return 0;
}
@@ -310,7 +302,7 @@ namespace Muon {
// in RIO_OnTrack the local param and cov should have the same dimension
Trk::LocalParameters locpar = Trk::LocalParameters (RIO.localPosition ());
if (RIO.localCovariance().cols() > 1 ||
- (m_muonIdHelperTool->tgcIdHelper().is_tgc(RIO.identify()) && m_muonIdHelperTool->tgcIdHelper().isStrip(RIO.identify()))) {
+ (m_idHelperSvc->tgcIdHelper().is_tgc(RIO.identify()) && m_idHelperSvc->tgcIdHelper().isStrip(RIO.identify()))) {
ATH_MSG_VERBOSE ( "Making 2-dim local parameters" );
} else {
Trk::DefinedParameter radiusPar(RIO.localPosition().x(),Trk::locX);
@@ -334,7 +326,7 @@ namespace Muon {
Amg::MatrixX loce = RIO.localCovariance();
if ( m_doCsc
- && m_muonIdHelperTool->cscIdHelper().is_csc(RIO.identify())
+ && m_idHelperSvc->cscIdHelper().is_csc(RIO.identify())
&& !m_cscErrorScalingKey.key().empty()) {
SG::ReadCondHandle<RIO_OnTrackErrorScaling> error_scaling( m_cscErrorScalingKey );
loce = check_cast<MuonEtaPhiRIO_OnTrackErrorScaling>(*error_scaling)->getScaledCovariance( loce, Trk::distPhi);
@@ -384,7 +376,7 @@ namespace Muon {
// + m_errorScaler*m_errorScaler*res0.dposition*res0.dposition);
// v1 scaling up total uncertainty and add up misalignment term....like sqrt( sigma_nominal^2 * alpha^2 + beta^2)
double nominal_error = res.dposition;
- double errorCorrected = sqrt( nominal_error*nominal_error*m_errorScaler*m_errorScaler + m_errorScalerBeta*m_errorScalerBeta);
+ double errorCorrected = std::sqrt( nominal_error*nominal_error*m_errorScaler*m_errorScaler + m_errorScalerBeta*m_errorScalerBeta);
if( errorCorrected < m_minimumError ) errorCorrected = m_minimumError;
Amg::MatrixX newloce( Amg::MatrixX(1,1) );
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/CscClusterOnTrackCreator.h b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/CscClusterOnTrackCreator.h
index 49d7c787efd0368e587d68e52f7476e252efa6fe..2b447caf07e05750180115eafd2748efa2254502 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/CscClusterOnTrackCreator.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/CscClusterOnTrackCreator.h
@@ -1,16 +1,10 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-///////////////////////////////////////////////////////////////////
-// Header file for class CscClusterOnTrackCreator
-///////////////////////////////////////////////////////////////////
-// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
// Interface for CscClusterOnTrack production
///////////////////////////////////////////////////////////////////
-// Version 1.0 20/07/2004
-///////////////////////////////////////////////////////////////////
#ifndef CscClusterOnTrackCreator_H
#define CscClusterOnTrackCreator_H
@@ -18,6 +12,7 @@
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
+#include "GaudiKernel/ServiceHandle.h"
#include "MuonRecToolInterfaces/ICscClusterOnTrackCreator.h"
#include "MuonRIO_OnTrack/MuonClusterOnTrack.h"
@@ -28,7 +23,7 @@
#include "MuonPrepRawData/CscStripPrepDataContainer.h"
-#include "MuonIdHelpers/MuonIdHelperTool.h"
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
namespace Muon {
@@ -101,8 +96,8 @@ namespace Muon {
private:
const MuonGM::MuonDetectorManager* m_muonMgr; // Muon GeoModel
- ToolHandle<Muon::MuonIdHelperTool> m_muonIdHelperTool{this, "idHelper",
- "Muon::MuonIdHelperTool/MuonIdHelperTool", "Handle to the MuonIdHelperTool"};
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
+
ToolHandle<ICscStripFitter> m_stripFitter;
ToolHandle<ICscClusterFitter> m_clusterFitter;
ToolHandle<ICscClusterUtilTool> m_clusterUtilTool;
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/MuonClusterOnTrackCreator.cxx b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/MuonClusterOnTrackCreator.cxx
index 589ddebdc46d310f4163b94d37ff7e3fd341a29c..685917e4873b4d844a0003d98b28ec8703530a1a 100755
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/MuonClusterOnTrackCreator.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/MuonClusterOnTrackCreator.cxx
@@ -1,23 +1,14 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-///////////////////////////////////////////////////////////////////
-// Implementation file for class MuonClusterOnTrackCreator
-///////////////////////////////////////////////////////////////////
-// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
// AlgTool used for MuonClusterOnTrack object production
///////////////////////////////////////////////////////////////////
-// Version 1.0 20/07/2004
-///////////////////////////////////////////////////////////////////
#include "MuonClusterOnTrackCreator.h"
#include "TrkEventPrimitives/LocalParameters.h"
#include "TrkSurfaces/Surface.h"
-#include "MuonIdHelpers/CscIdHelper.h"
-#include "MuonIdHelpers/RpcIdHelper.h"
-#include "MuonIdHelpers/TgcIdHelper.h"
#include "MuonPrepRawData/RpcPrepData.h"
#include "MuonPrepRawData/TgcPrepData.h"
@@ -32,8 +23,6 @@
#include "MuonRIO_OnTrack/MMClusterOnTrack.h"
#include <sstream>
-using std::atan2;
-
#define SIG_VEL 4.80000 // ns/m
#define C_VEL 3.33564 // ns/m
@@ -41,17 +30,12 @@ namespace Muon {
MuonClusterOnTrackCreator::MuonClusterOnTrackCreator
(const std::string& ty,const std::string& na,const IInterface* pa)
- : AthAlgTool(ty,na,pa),
- m_idHelper("Muon::MuonIdHelperTool/MuonIdHelperTool")
+ : AthAlgTool(ty,na,pa)
{
// algtool interface - necessary!
declareInterface<IMuonClusterOnTrackCreator>(this);
declareInterface<IRIO_OnTrackCreator>(this);
- // --- some job options here.
- declareProperty("doCSC", m_doCsc = true);
- declareProperty("doRPC", m_doRpc = true);
- declareProperty("doTGC", m_doTgc = true);
declareProperty("DoFixedErrorTgcEta", m_doFixedErrorTgcEta = false );
declareProperty("DoFixedErrorRpcEta", m_doFixedErrorRpcEta = false );
declareProperty("DoFixedErrorCscEta", m_doFixedErrorCscEta = false );
@@ -78,12 +62,7 @@ namespace Muon {
return StatusCode::FAILURE;
}
- // Get DetectorStore service
- //
- if ( m_idHelper.retrieve().isFailure() ) {
- ATH_MSG_ERROR ( " Cannot retrieve " << m_idHelper );
- return StatusCode::FAILURE;
- }
+ ATH_CHECK(m_idHelperSvc.retrieve());
return StatusCode::SUCCESS;
}
@@ -115,7 +94,7 @@ namespace Muon {
if (RIO.localCovariance().cols()!=RIO.localCovariance().rows()){
ATH_MSG_WARNING ( "Rows and colums not equal!");
- if (m_idHelper->isRpc(RIO.identify())){
+ if (m_idHelperSvc->isRpc(RIO.identify())){
std::stringstream ss;
ss << "RPC hit with (r,c)="<<RIO.localCovariance().rows()<<","<<RIO.localCovariance().cols();
ATH_MSG_WARNING(ss.str().c_str() );
@@ -123,12 +102,12 @@ namespace Muon {
}
if (RIO.localCovariance().cols() > 1 ||
- (m_idHelper->isTgc(RIO.identify()) && m_idHelper->measuresPhi(RIO.identify()))) {
- ATH_MSG_VERBOSE ( "Making 2-dim local parameters: " << m_idHelper->toString(RIO.identify()) );
+ (m_idHelperSvc->isTgc(RIO.identify()) && m_idHelperSvc->measuresPhi(RIO.identify()))) {
+ ATH_MSG_VERBOSE ( "Making 2-dim local parameters: " << m_idHelperSvc->toString(RIO.identify()) );
} else {
Trk::DefinedParameter radiusPar(RIO.localPosition().x(),Trk::locX);
locpar = Trk::LocalParameters(radiusPar);
- ATH_MSG_VERBOSE ( "Making 1-dim local parameters: " << m_idHelper->toString(RIO.identify()) );
+ ATH_MSG_VERBOSE ( "Making 1-dim local parameters: " << m_idHelperSvc->toString(RIO.identify()) );
}
@@ -149,7 +128,7 @@ namespace Muon {
Amg::MatrixX loce = RIO.localCovariance();
ATH_MSG_DEBUG ( "All: new err matrix is " << loce );
- if( m_idHelper->isRpc(RIO.identify()) ){
+ if( m_idHelperSvc->isRpc(RIO.identify()) ){
// cast to RpcPrepData
const RpcPrepData* MClus = dynamic_cast<const RpcPrepData*> (&RIO);
@@ -158,7 +137,7 @@ namespace Muon {
return 0;
}
- bool measphi = m_idHelper->measuresPhi(RIO.identify());
+ bool measphi = m_idHelperSvc->measuresPhi(RIO.identify());
double fixedError = 1.;
bool scale = false;
@@ -203,7 +182,7 @@ namespace Muon {
ATH_MSG_DEBUG (" correct_time_along_strip " << correct_time_along_strip<<" av_correct_time_along_strip " << av_correct_time_along_strip<<" real_TOF_onRPCgap " << real_TOF_onRPCgap<<" nominal_TOF_onRPCgap " << nominal_TOF_onRPCgap<<" MClus->time() " << MClus->time()<<" correct_time_tot " <<correct_time_tot );
- }else if( m_idHelper->isTgc(RIO.identify()) ){
+ }else if( m_idHelperSvc->isTgc(RIO.identify()) ){
// cast to TgcPrepData
const TgcPrepData* MClus = dynamic_cast<const TgcPrepData*> (&RIO);
@@ -213,11 +192,11 @@ namespace Muon {
}
// calculation of 2D error matrix for TGC phi strips
- if ( m_idHelper->measuresPhi(RIO.identify()) ){
+ if ( m_idHelperSvc->measuresPhi(RIO.identify()) ){
- int stationeta=m_idHelper->stationEta(RIO.identify());
- int stripNo = m_idHelper->tgcIdHelper().channel(RIO.identify());
- int gasGap = m_idHelper->tgcIdHelper().gasGap(RIO.identify());
+ int stationeta=m_idHelperSvc->stationEta(RIO.identify());
+ int stripNo = m_idHelperSvc->tgcIdHelper().channel(RIO.identify());
+ int gasGap = m_idHelperSvc->tgcIdHelper().gasGap(RIO.identify());
const MuonGM::TgcReadoutElement *ele= MClus->detectorElement();
@@ -232,8 +211,8 @@ namespace Muon {
}
Amg::MatrixX mat(2,2);
- double phistereo=atan2(localX2-localX1,stripLength);
- double Sn = sin(phistereo);
+ double phistereo=std::atan2(localX2-localX1,stripLength);
+ double Sn = std::sin(phistereo);
double Sn2 = Sn*Sn;
double Cs2 = 1.-Sn2;
@@ -241,7 +220,7 @@ namespace Muon {
if( m_doFixedErrorTgcPhi ) V0 = m_fixedErrorTgcPhi*m_fixedErrorTgcPhi;
double V1 = stripLength*stripLength/12;
mat(0,0) = (Cs2*V0+Sn2*V1);
- mat.fillSymmetric(1,0,(Sn*sqrt(Cs2)*(V0-V1)));
+ mat.fillSymmetric(1,0,(Sn*std::sqrt(Cs2)*(V0-V1)));
mat(1,1) = (Sn2*V0+Cs2*V1);
loce=mat;
}else{
@@ -254,16 +233,15 @@ namespace Muon {
MClT = new TgcClusterOnTrack(MClus,locpar,loce,positionAlongStrip);
- }else if( m_idHelper->isCsc(RIO.identify()) ){
+ }else if( m_idHelperSvc->isCsc(RIO.identify()) ){
- // cast to CscPrepData
const CscPrepData* MClus = dynamic_cast<const CscPrepData*> (&RIO);
if (!MClus) {
ATH_MSG_WARNING ( "RIO not of type CscPrepData, cannot create ROT" );
return 0;
}
- bool measphi = m_idHelper->measuresPhi(RIO.identify());
+ bool measphi = m_idHelperSvc->measuresPhi(RIO.identify());
double fixedError = 1.;
bool scale = false;
// check whether to scale eta/phi hit
@@ -282,7 +260,7 @@ namespace Muon {
// current not changing CscClusterStatus but passing status of RIO
MClT = new CscClusterOnTrack(MClus,locpar,loce,positionAlongStrip,MClus->status(),MClus->timeStatus());
- }else if( m_idHelper->isMM(RIO.identify()) ){
+ }else if( m_idHelperSvc->isMM(RIO.identify()) ){
// cast to MMPrepData
const MMPrepData* MClus = dynamic_cast<const MMPrepData*> (&RIO);
if (!MClus) {
@@ -331,9 +309,8 @@ namespace Muon {
MClT = new MMClusterOnTrack(MClus,locpar,loce,positionAlongStrip);
- }else if( m_idHelper->issTgc(RIO.identify()) ){
+ }else if( m_idHelperSvc->issTgc(RIO.identify()) ){
- // cast to CscPrepData
const sTgcPrepData* MClus = dynamic_cast<const sTgcPrepData*> (&RIO);
if (!MClus) {
ATH_MSG_WARNING ( "RIO not of type MMPrepData, cannot create ROT" );
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/MuonClusterOnTrackCreator.h b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/MuonClusterOnTrackCreator.h
index 403b8f421b1b679271523cba3f9bab36b82f8c8c..086d25e1f8d49e84ff9ef3fd6f30b4a599ab07ec 100755
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/MuonClusterOnTrackCreator.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonClusterOnTrackCreator/src/MuonClusterOnTrackCreator.h
@@ -1,35 +1,25 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-///////////////////////////////////////////////////////////////////
-// Header file for class MuonClusterOnTrackCreator
-///////////////////////////////////////////////////////////////////
-// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
// Interface for MuonClusterOnTrack production
// (for CSC and RPC technologies)
///////////////////////////////////////////////////////////////////
-// Version 1.0 20/07/2004
-///////////////////////////////////////////////////////////////////
#ifndef MuonClusterOnTrackCreator_H
#define MuonClusterOnTrackCreator_H
#include "AthenaBaseComps/AthAlgTool.h"
-#include "GaudiKernel/ToolHandle.h"
+#include "GaudiKernel/ServiceHandle.h"
#include "MuonRecToolInterfaces/IMuonClusterOnTrackCreator.h"
#include "MuonRIO_OnTrack/MuonClusterOnTrack.h"
-#include "MuonIdHelpers/MuonIdHelperTool.h"
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonReadoutGeometry/MuonDetectorManager.h"
#include "TrkPrepRawData/PrepRawDataCLASS_DEF.h"
#include "TrkParameters/TrackParameters.h"
-class CscIdHelper;
-class RpcIdHelper;
-class TgcIdHelper;
-
/** @class MuonClusterOnTrackCreator
This tool creates MuonClusterOnTrack objects using a given
global postion prediction.
@@ -81,15 +71,7 @@ namespace Muon {
private:
- // /////////////////////////////////////////////////////////////////
- // Private data:
- // /////////////////////////////////////////////////////////////////
-
- ToolHandle<Muon::MuonIdHelperTool> m_idHelper;
-
- bool m_doCsc;
- bool m_doRpc;
- bool m_doTgc;
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
bool m_doFixedErrorTgcEta;
bool m_doFixedErrorRpcEta;
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.cxx
index 735f5a25cd54e5aa9d896d0ba42ae0dfa8f4d8a3..888406e81299a870f51355aaf83a9fb4663763a4 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.cxx
@@ -9,7 +9,6 @@
#include "MuonTrackMakerUtils/MuonTSOSHelper.h"
#include "GaudiKernel/MsgStream.h"
-#include "MuonIdHelpers/MuonIdHelperTool.h"
#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
#include "MuonRecHelperTools/MuonEDMPrinterTool.h"
#include "MuonIdHelpers/MuonStationIndex.h"
@@ -44,15 +43,6 @@
#include "TrkEventPrimitives/ResidualPull.h"
#include "TrkParameters/TrackParameters.h"
-#include "MuonIdHelpers/MdtIdHelper.h"
-#include "MuonIdHelpers/RpcIdHelper.h"
-#include "MuonIdHelpers/CscIdHelper.h"
-#include "MuonIdHelpers/TgcIdHelper.h"
-// New Small Wheel
-#include "MuonIdHelpers/sTgcIdHelper.h"
-#include "MuonIdHelpers/MmIdHelper.h"
-
-
#include "EventPrimitives/EventPrimitivesHelpers.h"
#include "GeoPrimitives/GeoPrimitivesToStringConverter.h"
@@ -70,21 +60,17 @@ namespace Muon {
m_cscRotCreator("Muon::CscClusterOnTrackCreator/CscClusterOnTrackCreator", this),
m_clusRotCreator("Muon::MuonClusterOnTrackCreator/MuonClusterOnTrackCreator"),
m_pullCalculator("Trk::ResidualPullCalculator/ResidualPullCalculator"),
- m_idHelperTool("Muon::MuonIdHelperTool/MuonIdHelperTool"),
m_printer("Muon::MuonEDMPrinterTool/MuonEDMPrinterTool")
{
declareInterface<IMuonHoleRecoveryTool>(this);
declareInterface<MuonChamberHoleRecoveryTool>(this);
-
-
declareProperty("MuonStationIntersectSvc", m_intersectSvc);
declareProperty("Extrapolator", m_extrapolator);
declareProperty("MdtRotCreator", m_mdtRotCreator);
declareProperty("CscRotCreator", m_cscRotCreator);
- declareProperty("ClusterRotCreator", m_clusRotCreator);
+ declareProperty("ClusterRotCreator", m_clusRotCreator);
declareProperty("PullCalculator", m_pullCalculator);
- declareProperty("IdHelper", m_idHelperTool);
declareProperty("EDMPrinter", m_printer);
declareProperty("AddMeasurements", m_addMeasurements = true);
@@ -103,19 +89,20 @@ namespace Muon {
ATH_CHECK( detStore()->retrieve( m_detMgr ) );
ATH_CHECK( m_edmHelperSvc.retrieve() );
+ ATH_CHECK( m_idHelperSvc.retrieve() );
ATH_CHECK( m_printer.retrieve() );
ATH_CHECK( m_extrapolator.retrieve() );
ATH_CHECK( m_mdtRotCreator.retrieve() );
if ( !m_cscRotCreator.empty() ) {
- ATH_CHECK( m_cscRotCreator.retrieve() );
+ if (!m_idHelperSvc->hasCSC()) ATH_MSG_WARNING("The current layout does not have any CSC chamber but you gave a CscRotCreator, ignoring it, but double-check configuration");
+ else ATH_CHECK( m_cscRotCreator.retrieve() );
} else {
ATH_MSG_INFO("CSC rot creation disabled" );
}
ATH_CHECK( m_clusRotCreator.retrieve() );
ATH_CHECK( m_pullCalculator.retrieve() );
- ATH_CHECK( m_idHelperTool.retrieve() );
ATH_CHECK( m_intersectSvc.retrieve() );
ATH_CHECK(m_key_mdt.initialize());
@@ -205,25 +192,25 @@ namespace Muon {
Identifier id = m_edmHelperSvc->getIdentifier(*meas);
// Not a ROT, else it would have had an identifier. Keep the TSOS.
- if ( !id.is_valid() || !m_idHelperTool->mdtIdHelper().is_muon(id) ) {
+ if ( !id.is_valid() || !m_idHelperSvc->mdtIdHelper().is_muon(id) ) {
if ( msgLvl(MSG::VERBOSE)) {
if (!id.is_valid() ) ATH_MSG_VERBOSE(" new TSOS without valid identifier, copying " );
- else if ( !m_idHelperTool->mdtIdHelper().is_muon(id) ) ATH_MSG_VERBOSE(" new TSOS with none muon identifier, copying " );
+ else if ( !m_idHelperSvc->mdtIdHelper().is_muon(id) ) ATH_MSG_VERBOSE(" new TSOS with none muon identifier, copying " );
}
newStates.push_back( std::make_pair(false, *tsit) );
continue;
}
- if ( m_idHelperTool->isMdt(id) ) {
+ if ( m_idHelperSvc->isMdt(id) ) {
// get station index
- Identifier chId = m_idHelperTool->chamberId(id);
- MuonStationIndex::StIndex stIndex = m_idHelperTool->stationIndex(chId);
+ Identifier chId = m_idHelperSvc->chamberId(id);
+ MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(chId);
stations.insert(stIndex);
// MDT case: Run hole search in chamber.
tsit = insertMdtsWithHoleSearch( tsit, tsit_end, newStates, chamberLayersOnTrack );
continue;
- } else if ( m_idHelperTool->isTrigger(id) || m_idHelperTool->isCsc(id) || m_idHelperTool->isMM(id) || m_idHelperTool->issTgc(id) ) {
+ } else if ( m_idHelperSvc->isTrigger(id) || m_idHelperSvc->isCsc(id) || m_idHelperSvc->isMM(id) || m_idHelperSvc->issTgc(id) ) {
// Non-MDT case: Look for missing layers in chamber, add them to track
tsit = insertClustersWithHoleSearch( tsit, tsit_end, newStates );
continue;
@@ -302,16 +289,16 @@ namespace Muon {
}
// get chamber Id
- Identifier detElId = m_idHelperTool->detElId(id);
+ Identifier detElId = m_idHelperSvc->detElId(id);
if ( !detectorElId ) detectorElId = new Identifier( detElId );
// check whether we are still in the same chamber, stop loop if not
if ( detElId != *detectorElId ) break;
// sanity check, this SHOULD be a RPC, TGC, MM, STGC or CSC measurement
- if ( !( m_idHelperTool->isTrigger(id) || m_idHelperTool->isCsc(id) || m_idHelperTool->isMM(id) || m_idHelperTool->issTgc(id) ) ) {
+ if ( !( m_idHelperSvc->isTrigger(id) || m_idHelperSvc->isCsc(id) || m_idHelperSvc->isMM(id) || m_idHelperSvc->issTgc(id) ) ) {
newStates.push_back( std::make_pair(false, *tsit) );
- ATH_MSG_WARNING(" Identifier should be TGC/RPC/CSC/MM/STGC: " << m_idHelperTool->toString(id) );
+ ATH_MSG_WARNING(" Identifier should be TGC/RPC/CSC/MM/STGC: " << m_idHelperSvc->toString(id) );
continue;
}
@@ -320,20 +307,20 @@ namespace Muon {
const CompetingMuonClustersOnTrack* comp = dynamic_cast<const CompetingMuonClustersOnTrack*>(meas);
if ( comp ) {
- std::vector<const MuonClusterOnTrack*>::const_iterator clit = comp->containedROTs().begin();
- std::vector<const MuonClusterOnTrack*>::const_iterator clit_end = comp->containedROTs().end();
- for ( ; clit != clit_end; ++clit ) {
+ std::vector<const MuonClusterOnTrack*>::const_iterator cl_it = comp->containedROTs().begin();
+ std::vector<const MuonClusterOnTrack*>::const_iterator cl_it_end = comp->containedROTs().end();
+ for ( ; cl_it != cl_it_end; ++cl_it ) {
// get layer Identifier and insert it into set
- Identifier layId = m_idHelperTool->layerId( (*clit)->identify() );
+ Identifier layId = m_idHelperSvc->layerId( (*cl_it)->identify() );
layIds.insert(layId);
}
} else {
// get layer Identifier and insert it into set
- Identifier layId = m_idHelperTool->layerId(id);
+ Identifier layId = m_idHelperSvc->layerId(id);
layIds.insert(layId);
}
if ( msgLvl(MSG::VERBOSE) ) {
- msg(MSG::VERBOSE) << " new hit " << m_idHelperTool->toString(id);
+ msg(MSG::VERBOSE) << " new hit " << m_idHelperSvc->toString(id);
if ( comp ) msg(MSG::VERBOSE) << " competing, layers: " << layIds.size();
msg(MSG::VERBOSE) << endmsg;
}
@@ -380,14 +367,14 @@ namespace Muon {
// this should be a MDT
const MdtDriftCircleOnTrack* mdtFirst = dynamic_cast<const MdtDriftCircleOnTrack*>(meas);
if ( !mdtFirst ) {
- ATH_MSG_WARNING("Bad hit: not a MDT " << m_idHelperTool->toString(m_edmHelperSvc->getIdentifier(*meas)) );
+ ATH_MSG_WARNING("Bad hit: not a MDT " << m_idHelperSvc->toString(m_edmHelperSvc->getIdentifier(*meas)) );
if ( tsit + 1 == tsit_end ) --tsit;
return tsit;
}
// get chamber identifier
- MuonStationIndex::ChIndex currentChIndex = m_idHelperTool->chamberIndex(mdtFirst->identify());
- Identifier chId = m_idHelperTool->chamberId(mdtFirst->identify());
+ MuonStationIndex::ChIndex currentChIndex = m_idHelperSvc->chamberIndex(mdtFirst->identify());
+ Identifier chId = m_idHelperSvc->chamberId(mdtFirst->identify());
// to correctly handle low pt tracks average the direction of the track in the chamber
const Trk::TrackParameters* parsLast = 0;
@@ -424,7 +411,7 @@ namespace Muon {
const Identifier& id = mdt->identify();
// check whether we are still in the same chamber layer
- if ( currentChIndex != m_idHelperTool->chamberIndex(id) ) break;
+ if ( currentChIndex != m_idHelperSvc->chamberIndex(id) ) break;
ids.insert(id); // insert identifier
newStates.push_back( std::make_pair(false, *tsit) );
@@ -451,7 +438,7 @@ namespace Muon {
// create holes
createHoleTSOSsForMdtChamber( chId, *pars, parsLast, ids, newStates );
- ATH_MSG_DEBUG(" Chamber " << m_idHelperTool->toStringChamber(chId)
+ ATH_MSG_DEBUG(" Chamber " << m_idHelperSvc->toStringChamber(chId)
<< " has hits " << ids.size() << " new states " << newStates.size() - ids.size() );
// sort all states in this chamber
@@ -469,14 +456,13 @@ namespace Muon {
std::set<Identifier>& layIds,
std::vector< std::pair<bool, const Trk::TrackStateOnSurface* > >& states ) const {
- ATH_MSG_VERBOSE(" performing holes search in chamber " << m_idHelperTool->toString(detElId) );
+ ATH_MSG_VERBOSE(" performing holes search in chamber " << m_idHelperSvc->toString(detElId) );
- if ( m_idHelperTool->isCsc(detElId) ) createHoleTSOSsForCscChamber(detElId, pars, layIds, states);
- else if ( m_idHelperTool->isTgc(detElId) ) createHoleTSOSsForTgcChamber(detElId, pars, layIds, states);
- else if ( m_idHelperTool->isRpc(detElId) ) createHoleTSOSsForRpcChamber(detElId, pars, layIds, states);
- else if ( m_idHelperTool->isMM(detElId) ) createHoleTSOSsForMmChamber(detElId, pars, layIds, states);
- else if ( m_idHelperTool->issTgc(detElId) ) createHoleTSOSsForStgcChamber(detElId, pars, layIds, states);
- // else if( m_idHelperTool->isMM(detElId) || m_idHelperTool->issTgc(detElId) ) ATH_MSG_DEBUG(" NSW hole recovery not implemented yet");
+ if ( m_idHelperSvc->isCsc(detElId) ) createHoleTSOSsForCscChamber(detElId, pars, layIds, states);
+ else if ( m_idHelperSvc->isTgc(detElId) ) createHoleTSOSsForTgcChamber(detElId, pars, layIds, states);
+ else if ( m_idHelperSvc->isRpc(detElId) ) createHoleTSOSsForRpcChamber(detElId, pars, layIds, states);
+ else if ( m_idHelperSvc->isMM(detElId) ) createHoleTSOSsForMmChamber(detElId, pars, layIds, states);
+ else if ( m_idHelperSvc->issTgc(detElId) ) createHoleTSOSsForStgcChamber(detElId, pars, layIds, states);
else ATH_MSG_WARNING(" unexpected Identifier, cannot perform holes search" );
}
@@ -487,13 +473,13 @@ namespace Muon {
// get detector element
const MuonGM::sTgcReadoutElement* detEl = m_detMgr->getsTgcReadoutElement(detElId);
if ( !detEl ) {
- ATH_MSG_WARNING(" No detector element found for " << m_idHelperTool->toStringChamber(detElId) );
+ ATH_MSG_WARNING(" No detector element found for " << m_idHelperSvc->toStringChamber(detElId) );
return;
}
// get list of layers with a hole
unsigned int nGasGaps = detEl->numberOfLayers(false);
- int multilayer = m_idHelperTool->stgcIdHelper().multilayer(detElId);
+ int multilayer = m_idHelperSvc->stgcIdHelper().multilayer(detElId);
LayerHoleVec holeVec = holesInClusterChamber( pars, detElId, layIds, nGasGaps );
if ( holeVec.empty() ) return;
@@ -502,12 +488,12 @@ namespace Muon {
LayerHoleVec::iterator it = holeVec.begin();
LayerHoleVec::iterator it_end = holeVec.end();
- Identifier layId = m_idHelperTool->stgcIdHelper().channelID(detElId, multilayer, it->first, 1, 1);
- bool measuresPhi1 = m_idHelperTool->measuresPhi(layId);
- layId = m_idHelperTool->stgcIdHelper().channelID(detElId, multilayer, it->first, 0, 1);
- bool measuresPhi0 = m_idHelperTool->measuresPhi(layId);
- layId = m_idHelperTool->stgcIdHelper().channelID(detElId, multilayer, it->first, 2, 1);
- bool measuresPhi2 = m_idHelperTool->measuresPhi(layId);
+ Identifier layId = m_idHelperSvc->stgcIdHelper().channelID(detElId, multilayer, it->first, 1, 1);
+ bool measuresPhi1 = m_idHelperSvc->measuresPhi(layId);
+ layId = m_idHelperSvc->stgcIdHelper().channelID(detElId, multilayer, it->first, 0, 1);
+ bool measuresPhi0 = m_idHelperSvc->measuresPhi(layId);
+ layId = m_idHelperSvc->stgcIdHelper().channelID(detElId, multilayer, it->first, 2, 1);
+ bool measuresPhi2 = m_idHelperSvc->measuresPhi(layId);
ATH_MSG_DEBUG(" createHoleTSOSsFor StgcChamber measuresPhi type 0" << (int) measuresPhi0 << " measuresPhi type 1 " << (int) measuresPhi1 << " measuresPhi type 2 " << (int) measuresPhi2 );
for ( ; it != it_end; ++it ) {
@@ -516,14 +502,14 @@ namespace Muon {
// Identifier id = m_idHelper->channelID(parentId, m_idHelper->multilayer(layid), m_idHelper->gasGap(layid),type,1,m_checkIds);
if (it->second == 0) {
// eta strip
- chHoles.insert( m_idHelperTool->stgcIdHelper().channelID(detElId, multilayer, it->first, 1, 1) );
+ chHoles.insert( m_idHelperSvc->stgcIdHelper().channelID(detElId, multilayer, it->first, 1, 1) );
} else {
- if (abs(m_idHelperTool->stationEta(detElId)) > 2) {
+ if (abs(m_idHelperSvc->stationEta(detElId)) > 2) {
// wires
- chHoles.insert( m_idHelperTool->stgcIdHelper().channelID(detElId, multilayer, it->first, 2, 1) );
+ chHoles.insert( m_idHelperSvc->stgcIdHelper().channelID(detElId, multilayer, it->first, 2, 1) );
} else {
// pads
- chHoles.insert( m_idHelperTool->stgcIdHelper().channelID(detElId, multilayer, it->first, 0, 1) );
+ chHoles.insert( m_idHelperSvc->stgcIdHelper().channelID(detElId, multilayer, it->first, 0, 1) );
}
}
}
@@ -543,7 +529,7 @@ namespace Muon {
sTgcPrepDataCollection::const_iterator hit = prdCol->begin();
sTgcPrepDataCollection::const_iterator hit_end = prdCol->end();
for ( ; hit != hit_end; ++hit ) {
- if ( detElId == m_idHelperTool->detElId( (*hit)->identify() ) ) prds.push_back(*hit);
+ if ( detElId == m_idHelperSvc->detElId( (*hit)->identify() ) ) prds.push_back(*hit);
}
createHoleTSOSsForClusterChamber( detElId, pars, layIds, chHoles, prds, states );
@@ -557,13 +543,13 @@ namespace Muon {
// get detector element
const MuonGM::MMReadoutElement* detEl = m_detMgr->getMMReadoutElement(detElId);
if ( !detEl ) {
- ATH_MSG_WARNING(" No detector element found for " << m_idHelperTool->toStringChamber(detElId) );
+ ATH_MSG_WARNING(" No detector element found for " << m_idHelperSvc->toStringChamber(detElId) );
return;
}
// get list of layers with a hole
unsigned int nGasGaps = detEl->numberOfLayers(false);
- int multilayer = m_idHelperTool->mmIdHelper().multilayer(detElId);
+ int multilayer = m_idHelperSvc->mmIdHelper().multilayer(detElId);
LayerHoleVec holeVec = holesInClusterChamber( pars, detElId, layIds, nGasGaps );
if ( holeVec.empty() ) return;
@@ -573,7 +559,7 @@ namespace Muon {
LayerHoleVec::iterator it_end = holeVec.end();
for ( ; it != it_end; ++it ) {
// eta strip
- if (it->second == 0) chHoles.insert( m_idHelperTool->mmIdHelper().channelID(detElId, multilayer, it->first, 1) );
+ if (it->second == 0) chHoles.insert( m_idHelperSvc->mmIdHelper().channelID(detElId, multilayer, it->first, 1) );
}
if ( chHoles.empty() ) return;
@@ -591,7 +577,7 @@ namespace Muon {
MMPrepDataCollection::const_iterator hit = prdCol->begin();
MMPrepDataCollection::const_iterator hit_end = prdCol->end();
for ( ; hit != hit_end; ++hit ) {
- if ( detElId == m_idHelperTool->detElId( (*hit)->identify() ) ) prds.push_back(*hit);
+ if ( detElId == m_idHelperSvc->detElId( (*hit)->identify() ) ) prds.push_back(*hit);
}
createHoleTSOSsForClusterChamber( detElId, pars, layIds, chHoles, prds, states );
@@ -612,15 +598,15 @@ namespace Muon {
LayerHoleVec::iterator it = holeVec.begin();
LayerHoleVec::iterator it_end = holeVec.end();
for ( ; it != it_end; ++it ) {
- Identifier parentId = m_idHelperTool->cscIdHelper().parentID(detElId);
- Identifier layId = m_idHelperTool->cscIdHelper().channelID(parentId, 2, it->first, it->second, 1);
- bool measuresPhi = m_idHelperTool->measuresPhi(layId);
+ Identifier parentId = m_idHelperSvc->cscIdHelper().parentID(detElId);
+ Identifier layId = m_idHelperSvc->cscIdHelper().channelID(parentId, 2, it->first, it->second, 1);
+ bool measuresPhi = m_idHelperSvc->measuresPhi(layId);
// sanity check this should always be true!!!
if ( measuresPhi != (bool)it->second ) {
ATH_MSG_WARNING(" Problem spotted creating CSC identifier, measures Phi not correctly set " );
continue;
}
- ATH_MSG_VERBOSE(" adding hole layer " << m_idHelperTool->toString(layId)
+ ATH_MSG_VERBOSE(" adding hole layer " << m_idHelperSvc->toString(layId)
<< " layer " << it->first << " measPhi " << it->second );
chHoles.insert( layId );
}
@@ -650,7 +636,7 @@ namespace Muon {
// get detector element
const MuonGM::TgcReadoutElement* detEl = m_detMgr->getTgcReadoutElement(detElId);
if ( !detEl ) {
- ATH_MSG_WARNING(" No detector element found for " << m_idHelperTool->toStringChamber(detElId) );
+ ATH_MSG_WARNING(" No detector element found for " << m_idHelperSvc->toStringChamber(detElId) );
return;
}
@@ -667,7 +653,7 @@ namespace Muon {
// the second gas gap of the three layer stations does not have a phi measurement
if ( nGasGaps == 3 && it->first == 2 && it->second ) continue;
- chHoles.insert( m_idHelperTool->tgcIdHelper().channelID(detElId, it->first, it->second, 1) );
+ chHoles.insert( m_idHelperSvc->tgcIdHelper().channelID(detElId, it->first, it->second, 1) );
}
if ( chHoles.empty() ) return;
@@ -685,7 +671,7 @@ namespace Muon {
TgcPrepDataCollection::const_iterator hit = prdCol->begin();
TgcPrepDataCollection::const_iterator hit_end = prdCol->end();
for ( ; hit != hit_end; ++hit ) {
- if ( detElId == m_idHelperTool->detElId( (*hit)->identify() ) ) prds.push_back(*hit);
+ if ( detElId == m_idHelperSvc->detElId( (*hit)->identify() ) ) prds.push_back(*hit);
}
//prds.insert(prds.begin(),prdCol->begin(),prdCol->end());
@@ -702,7 +688,7 @@ namespace Muon {
if ( holeVec.empty() ) return;
const MuonGM::RpcReadoutElement* detEl = m_detMgr->getRpcReadoutElement(detElId);
if ( !detEl ) {
- ATH_MSG_WARNING("Could not find ReadoutElement for " << m_idHelperTool->toString(detElId) );
+ ATH_MSG_WARNING("Could not find ReadoutElement for " << m_idHelperSvc->toString(detElId) );
return;
}
int dbZ = detEl->getDoubletZ();
@@ -716,10 +702,10 @@ namespace Muon {
LayerHoleVec::iterator it = holeVec.begin();
LayerHoleVec::iterator it_end = holeVec.end();
for ( ; it != it_end; ++it ) {
- Identifier clusId = m_idHelperTool->rpcIdHelper().channelID(detElId, dbZ, dbPhi, it->first, it->second, 1);
+ Identifier clusId = m_idHelperSvc->rpcIdHelper().channelID(detElId, dbZ, dbPhi, it->first, it->second, 1);
chHoles.insert( clusId );
- ATH_MSG_VERBOSE("Adding hole " << m_idHelperTool->toString(clusId) );
+ ATH_MSG_VERBOSE("Adding hole " << m_idHelperSvc->toString(clusId) );
}
@@ -736,7 +722,7 @@ namespace Muon {
RpcPrepDataCollection::const_iterator hit = prdCol->begin();
RpcPrepDataCollection::const_iterator hit_end = prdCol->end();
for ( ; hit != hit_end; ++hit ) {
- if ( detElId == m_idHelperTool->detElId( (*hit)->identify() ) ) prds.push_back(*hit);
+ if ( detElId == m_idHelperSvc->detElId( (*hit)->identify() ) ) prds.push_back(*hit);
}
//prds.insert(prds.begin(),prdCol->begin(),prdCol->end());
@@ -757,7 +743,7 @@ namespace Muon {
if ( msgLvl(MSG::DEBUG) ) {
- msg() << " chamber " << m_idHelperTool->toString(detElId)
+ msg() << " chamber " << m_idHelperSvc->toString(detElId)
<< " PRDs in chamber " << prds.size() << " holes " << chHoles.size();
if ( msgLvl(MSG::VERBOSE) ) {
if ( pars.covariance() ) msg() << MSG::VERBOSE << " extrapolation error " << Amg::error(*pars.covariance(), Trk::locX);
@@ -771,12 +757,12 @@ namespace Muon {
ClusterLayerMap clusterLayerMap;
const Trk::TrkDetElementBase* detEl = 0;
- if ( m_idHelperTool->isTgc(detElId) ) detEl = m_detMgr->getTgcReadoutElement(detElId);
- else if ( m_idHelperTool->isRpc(detElId) ) detEl = m_detMgr->getRpcReadoutElement(detElId);
- else if ( m_idHelperTool->isCsc(detElId) ) detEl = m_detMgr->getCscReadoutElement(detElId);
+ if ( m_idHelperSvc->isTgc(detElId) ) detEl = m_detMgr->getTgcReadoutElement(detElId);
+ else if ( m_idHelperSvc->isRpc(detElId) ) detEl = m_detMgr->getRpcReadoutElement(detElId);
+ else if ( m_idHelperSvc->isCsc(detElId) ) detEl = m_detMgr->getCscReadoutElement(detElId);
// New Small Wheel
- else if ( m_idHelperTool->issTgc(detElId) ) detEl = m_detMgr->getsTgcReadoutElement(detElId);
- else if ( m_idHelperTool->isMM(detElId) ) detEl = m_detMgr->getMMReadoutElement(detElId);
+ else if ( m_idHelperSvc->issTgc(detElId) ) detEl = m_detMgr->getsTgcReadoutElement(detElId);
+ else if ( m_idHelperSvc->isMM(detElId) ) detEl = m_detMgr->getMMReadoutElement(detElId);
unsigned int nNewHits = 0;
// loop over prds
@@ -788,7 +774,7 @@ namespace Muon {
const MuonCluster& clus = **it;
if ( !detEl ) detEl = clus.detectorElement();
const Identifier& id = clus.identify();
- Identifier layId = m_idHelperTool->layerId(id);
+ Identifier layId = m_idHelperSvc->layerId(id);
// do not add hits in layers that are already on track
if ( layIds.count(layId) ) {
@@ -809,13 +795,13 @@ namespace Muon {
//parsToBeDeleted.push_back(exPars);
}
if ( msgLvl(MSG::VERBOSE) ) {
- msg() << MSG::VERBOSE << " --- " << m_idHelperTool->toString(id) << " error " << Amg::error(clus.localCovariance(), Trk::locX);
+ msg() << MSG::VERBOSE << " --- " << m_idHelperSvc->toString(id) << " error " << Amg::error(clus.localCovariance(), Trk::locX);
if ( exPars->covariance() ) msg() << MSG::VERBOSE << " measured parameters, error " << Amg::error(*exPars->covariance(), Trk::locX);
msg() << endmsg;
}
const MuonClusterOnTrack* clusterOnTrack = 0;
- if ( m_idHelperTool->isTrigger(clus.identify()) || m_idHelperTool->isMM(clus.identify()) || m_idHelperTool->issTgc(clus.identify()) ) {
+ if ( m_idHelperSvc->isTrigger(clus.identify()) || m_idHelperSvc->isMM(clus.identify()) || m_idHelperSvc->issTgc(clus.identify()) ) {
clusterOnTrack = m_clusRotCreator->createRIO_OnTrack( clus, exPars->position(), exPars->momentum().unit() );
} else {
if ( m_cscRotCreator.empty() ) {
@@ -842,7 +828,7 @@ namespace Muon {
continue;
}
- double pullCut = m_idHelperTool->measuresPhi(id) ? m_associationPullCutPhi : m_associationPullCutEta;
+ double pullCut = m_idHelperSvc->measuresPhi(id) ? m_associationPullCutPhi : m_associationPullCutEta;
double pull = fabs(resPull->pull().front());
Amg::Vector2D locExPos(exPars->parameters()[Trk::locX], exPars->parameters()[Trk::locY]);
bool inbounds = surf.insideBounds(locExPos, 10., 10.);
@@ -850,7 +836,7 @@ namespace Muon {
if ( msgLvl(MSG::VERBOSE) ) {
std::string boundStr = inbounds ? " inside bounds " : " outside bounds ";
double residual = resPull->residual().front();
- ATH_MSG_VERBOSE(" found prd: " << m_idHelperTool->toString(id)
+ ATH_MSG_VERBOSE(" found prd: " << m_idHelperSvc->toString(id)
<< " res " << residual << " pull " << pull << boundStr);
}
delete resPull;
@@ -859,14 +845,14 @@ namespace Muon {
if ( pull < pullCut && inbounds ) {
// check whether there are other hits in the same layer with smaller residual, if not add
- ClusterLayerMap::iterator clit = clusterLayerMap.find(layId);
- if ( clit != clusterLayerMap.end() ) {
- if ( pull < clit->second.pull ) {
- clit->second.pull = pull;
- if ( &pars != clit->second.pars ) delete clit->second.pars;
- delete clit->second.clus;
- clit->second.pars = exPars;
- clit->second.clus = clusterOnTrack;
+ ClusterLayerMap::iterator cl_it = clusterLayerMap.find(layId);
+ if ( cl_it != clusterLayerMap.end() ) {
+ if ( pull < cl_it->second.pull ) {
+ cl_it->second.pull = pull;
+ if ( &pars != cl_it->second.pars ) delete cl_it->second.pars;
+ delete cl_it->second.clus;
+ cl_it->second.pars = exPars;
+ cl_it->second.clus = clusterOnTrack;
} else {
if ( &pars != exPars ) delete exPars;
delete clusterOnTrack;
@@ -885,16 +871,16 @@ namespace Muon {
}
// loop over cluster layer map and add the clusters to the state vector
- ClusterLayerMap::iterator clit = clusterLayerMap.begin();
- ClusterLayerMap::iterator clit_end = clusterLayerMap.end();
- for ( ; clit != clit_end; ++clit ) {
+ ClusterLayerMap::iterator cl_it = clusterLayerMap.begin();
+ ClusterLayerMap::iterator cl_it_end = clusterLayerMap.end();
+ for ( ; cl_it != cl_it_end; ++cl_it ) {
// bool addMeasurements = true;
- Trk::TrackStateOnSurface* tsos = MuonTSOSHelper::createMeasTSOS( clit->second.clus, clit->second.pars != &pars ? clit->second.pars : clit->second.pars->clone() ,
+ Trk::TrackStateOnSurface* tsos = MuonTSOSHelper::createMeasTSOS( cl_it->second.clus, cl_it->second.pars != &pars ? cl_it->second.pars : cl_it->second.pars->clone() ,
Trk::TrackStateOnSurface::Measurement );
// addMeasurements ? Trk::TrackStateOnSurface::Measurement : Trk::TrackStateOnSurface::Outlier );
states.push_back( std::make_pair(true, tsos) );
- ATH_MSG_VERBOSE(" added hit " << m_idHelperTool->toString(clit->second.clus->identify()));
+ ATH_MSG_VERBOSE(" added hit " << m_idHelperSvc->toString(cl_it->second.clus->identify()));
++nNewHits;
}
@@ -908,16 +894,16 @@ namespace Muon {
// if no detEl yet try retrieving if from the detMgr
if ( !detEl ) {
- if ( m_idHelperTool->isTgc(id) ) detEl = m_detMgr->getTgcReadoutElement(id);
- else if ( m_idHelperTool->isRpc(id) ) detEl = m_detMgr->getRpcReadoutElement(id);
- else if ( m_idHelperTool->isCsc(id) ) detEl = m_detMgr->getCscReadoutElement(id);
+ if ( m_idHelperSvc->isTgc(id) ) detEl = m_detMgr->getTgcReadoutElement(id);
+ else if ( m_idHelperSvc->isRpc(id) ) detEl = m_detMgr->getRpcReadoutElement(id);
+ else if ( m_idHelperSvc->isCsc(id) ) detEl = m_detMgr->getCscReadoutElement(id);
// New Small Wheel
- else if ( m_idHelperTool->issTgc(id) ) detEl = m_detMgr->getsTgcReadoutElement(id);
- else if ( m_idHelperTool->isMM(id) ) detEl = m_detMgr->getMMReadoutElement(id);
+ else if ( m_idHelperSvc->issTgc(id) ) detEl = m_detMgr->getsTgcReadoutElement(id);
+ else if ( m_idHelperSvc->isMM(id) ) detEl = m_detMgr->getMMReadoutElement(id);
if ( !detEl ) {
- ATH_MSG_DEBUG("No detector element found for " << m_idHelperTool->toString(id) );
+ ATH_MSG_DEBUG("No detector element found for " << m_idHelperSvc->toString(id) );
continue;
}
}
@@ -943,7 +929,7 @@ namespace Muon {
}
if ( msgLvl(MSG::VERBOSE) ) {
std::string boundStr = inBounds ? " inside bounds " : " outside bounds ";
- ATH_MSG_VERBOSE(" new hole " << m_idHelperTool->toString(id) << " position "
+ ATH_MSG_VERBOSE(" new hole " << m_idHelperSvc->toString(id) << " position "
<< exPars->parameters()[Trk::locR] << boundStr);
}
@@ -951,7 +937,7 @@ namespace Muon {
continue;
}
- if ( msgLvl(MSG::VERBOSE) ) if (m_idHelperTool->issTgc(id)) ATH_MSG_VERBOSE(" new hole sTgc measuresPhi " << (int) m_idHelperTool->measuresPhi(id));
+ if ( msgLvl(MSG::VERBOSE) ) if (m_idHelperSvc->issTgc(id)) ATH_MSG_VERBOSE(" new hole sTgc measuresPhi " << (int) m_idHelperSvc->measuresPhi(id));
Trk::TrackStateOnSurface* tsos = MuonTSOSHelper::createHoleTSOS(exPars->clone());
states.push_back( std::make_pair(true, tsos) );
++nholes;
@@ -959,7 +945,7 @@ namespace Muon {
//break; // only add one hole per det el
}
- ATH_MSG_DEBUG(" chamber " << m_idHelperTool->toStringChamber(detElId) << " added hits " << nNewHits << " found holes " << nholes );
+ ATH_MSG_DEBUG(" chamber " << m_idHelperSvc->toStringChamber(detElId) << " added hits " << nNewHits << " found holes " << nholes );
// clean up parameters
std::for_each( parsToBeDeleted.begin(), parsToBeDeleted.end(), MuonDeleteObject<const Trk::TrackParameters>() );
@@ -976,7 +962,7 @@ namespace Muon {
// check whether we need to average the parameters
if ( parsLast ) direction = (parsLast->position() - pars.position()).unit();
std::set<Identifier> chHoles = holesInMdtChamber( pars.position(), direction, chId, ids );
- ATH_MSG_VERBOSE(" chamber " << m_idHelperTool->toStringChamber(chId) << " has holes " << chHoles.size() );
+ ATH_MSG_VERBOSE(" chamber " << m_idHelperSvc->toStringChamber(chId) << " has holes " << chHoles.size() );
if ( chHoles.empty() ) return;
@@ -995,7 +981,7 @@ namespace Muon {
for ( ; hit != hit_end; ++hit ) {
// only handle chamers once
- Identifier chIdentifier = m_idHelperTool->chamberId(*hit);
+ Identifier chIdentifier = m_idHelperSvc->chamberId(*hit);
if ( chIds.count(chIdentifier) ) continue;
chIds.insert(chIdentifier);
@@ -1038,7 +1024,7 @@ namespace Muon {
MdtDriftCircleOnTrack* mdtROT = m_mdtRotCreator->createRIO_OnTrack(mdtPrd, exPars->position(), &(exPars->momentum()));
// sanity check
if ( !mdtROT ) {
- ATH_MSG_DEBUG(" failed to calibrate MdtPrepData " << m_idHelperTool->toString(id) );
+ ATH_MSG_DEBUG(" failed to calibrate MdtPrepData " << m_idHelperSvc->toString(id) );
continue;
}
@@ -1102,7 +1088,7 @@ namespace Muon {
inBounds = mdtROT->associatedSurface().insideBounds(locPos);
}
if ( msgLvl(MSG::VERBOSE) ) {
- std::string idString = m_idHelperTool->toString( id );
+ std::string idString = m_idHelperSvc->toString( id );
std::string boundCheck = inBounds ? "inBounds" : "outBounds";
msg(MSG::VERBOSE) << m_printer->print( *resPull ) << " " << idString << " " << boundCheck;
std::string hitType = " delta";
@@ -1139,7 +1125,7 @@ namespace Muon {
for ( ; hit != hit_end; ++hit ) {
if ( associatedHoles.count(*hit) ) continue;
// only create holes in the current chamber
- Identifier ch = m_idHelperTool->chamberId(*hit);
+ Identifier ch = m_idHelperSvc->chamberId(*hit);
if ( ch != chIdentifier ) continue;
const MuonGM::MdtReadoutElement* detEl = m_detMgr->getMdtReadoutElement(*hit);
@@ -1167,11 +1153,11 @@ namespace Muon {
}
}
if ( !inBounds ) {
- ATH_MSG_VERBOSE(" discarding hole " << m_idHelperTool->toString(*hit) << " dist wire "
+ ATH_MSG_VERBOSE(" discarding hole " << m_idHelperSvc->toString(*hit) << " dist wire "
<< exPars->parameters()[Trk::locR] << " outside bounds " );
continue;
}
- ATH_MSG_VERBOSE(" new hole " << m_idHelperTool->toString(*hit) << " dist wire "
+ ATH_MSG_VERBOSE(" new hole " << m_idHelperSvc->toString(*hit) << " dist wire "
<< exPars->parameters()[Trk::locR] );
Trk::TrackStateOnSurface* tsos = MuonTSOSHelper::createHoleTSOS(exPars->clone());
states.push_back( std::make_pair(true, tsos) );
@@ -1202,11 +1188,11 @@ namespace Muon {
std::set<Identifier>::const_iterator it = layIds.begin();
std::set<Identifier>::const_iterator it_end = layIds.end();
for ( ; it != it_end; ++it ) {
- int gasGap = m_idHelperTool->gasGap(*it);
- bool measuresPhi = m_idHelperTool->measuresPhi(*it);
+ int gasGap = m_idHelperSvc->gasGap(*it);
+ bool measuresPhi = m_idHelperSvc->measuresPhi(*it);
// sanity check
if ( gasGap < 0 && gasGap >= (int)nGasGaps ) {
- ATH_MSG_WARNING(" gas gap index out of range " << m_idHelperTool->toString(*it) );
+ ATH_MSG_WARNING(" gas gap index out of range " << m_idHelperSvc->toString(*it) );
continue;
}
@@ -1254,7 +1240,7 @@ namespace Muon {
continue;
}
if ( msgLvl(MSG::VERBOSE) ) {
- msg(MSG::VERBOSE) << " intersect " << m_idHelperTool->toString(tint.tubeId)
+ msg(MSG::VERBOSE) << " intersect " << m_idHelperSvc->toString(tint.tubeId)
<< " dist wire " << tint.rIntersect << " dist to tube end " << tint.xIntersect;
}
if ( fabs( tint.rIntersect ) > 14.4 || tint.xIntersect > -10. ) {
@@ -1285,11 +1271,11 @@ namespace Muon {
}
if(mdtPrdContainer->size()==0) return 0;
IdentifierHash hash_id;
- m_idHelperTool->mdtIdHelper().get_module_hash(chId,hash_id );
+ m_idHelperSvc->mdtIdHelper().get_module_hash(chId,hash_id );
MdtPrepDataContainer::const_iterator colIt = mdtPrdContainer->indexFind(hash_id);
if( colIt == mdtPrdContainer->end() ){
- ATH_MSG_DEBUG(" MdtPrepDataCollection for: " << m_idHelperTool->toStringChamber(chId)
+ ATH_MSG_DEBUG(" MdtPrepDataCollection for: " << m_idHelperSvc->toStringChamber(chId)
<< " not found in container " );
return 0;
}
@@ -1309,11 +1295,11 @@ namespace Muon {
}
if(cscPrdContainer->size()==0) return 0;
IdentifierHash hash_id;
- m_idHelperTool->cscIdHelper().get_geo_module_hash(detElId,hash_id );
+ m_idHelperSvc->cscIdHelper().get_geo_module_hash(detElId,hash_id );
CscPrepDataContainer::const_iterator colIt = cscPrdContainer->indexFind(hash_id);
if( colIt == cscPrdContainer->end() ){
- ATH_MSG_DEBUG(" CscPrepDataCollection for: " << m_idHelperTool->toStringChamber(detElId)
+ ATH_MSG_DEBUG(" CscPrepDataCollection for: " << m_idHelperSvc->toStringChamber(detElId)
<< " not found in container " );
return 0;
}
@@ -1333,11 +1319,11 @@ namespace Muon {
}
if(tgcPrdContainer->size()==0) return 0;
IdentifierHash hash_id;
- m_idHelperTool->tgcIdHelper().get_module_hash(detElId,hash_id );
+ m_idHelperSvc->tgcIdHelper().get_module_hash(detElId,hash_id );
TgcPrepDataContainer::const_iterator colIt = tgcPrdContainer->indexFind(hash_id);
if( colIt == tgcPrdContainer->end() ){
- ATH_MSG_DEBUG(" TgcPrepDataCollection for: " << m_idHelperTool->toStringChamber(detElId)
+ ATH_MSG_DEBUG(" TgcPrepDataCollection for: " << m_idHelperSvc->toStringChamber(detElId)
<< " not found in container " );
return 0;
}
@@ -1357,10 +1343,10 @@ namespace Muon {
}
if(rpcPrdContainer->size()==0) return 0;
IdentifierHash hash_id;
- m_idHelperTool->rpcIdHelper().get_module_hash(detElId,hash_id );
+ m_idHelperSvc->rpcIdHelper().get_module_hash(detElId,hash_id );
RpcPrepDataContainer::const_iterator colIt = rpcPrdContainer->indexFind(hash_id);
if( colIt == rpcPrdContainer->end() ){
- ATH_MSG_DEBUG(" RpcPrepDataCollection for: " << m_idHelperTool->toStringChamber(detElId) << " not found in container " );
+ ATH_MSG_DEBUG(" RpcPrepDataCollection for: " << m_idHelperSvc->toStringChamber(detElId) << " not found in container " );
return 0;
}
return *colIt;
@@ -1379,11 +1365,11 @@ namespace Muon {
}
if(stgcPrdContainer->size()==0) return 0;
IdentifierHash hash_id;
- m_idHelperTool->stgcIdHelper().get_module_hash(detElId, hash_id );
+ m_idHelperSvc->stgcIdHelper().get_module_hash(detElId, hash_id );
sTgcPrepDataContainer::const_iterator colIt = stgcPrdContainer->indexFind(hash_id);
if ( colIt == stgcPrdContainer->end() ) {
- ATH_MSG_DEBUG(" StgcPrepDataCollection for: " << m_idHelperTool->toStringChamber(detElId)
+ ATH_MSG_DEBUG(" StgcPrepDataCollection for: " << m_idHelperSvc->toStringChamber(detElId)
<< " not found in container " );
return 0;
}
@@ -1404,11 +1390,11 @@ namespace Muon {
if(mmPrdContainer->size()==0) return 0;
IdentifierHash hash_id;
- m_idHelperTool->mmIdHelper().get_module_hash(detElId, hash_id );
+ m_idHelperSvc->mmIdHelper().get_module_hash(detElId, hash_id );
MMPrepDataContainer::const_iterator colIt = mmPrdContainer->indexFind(hash_id);
if ( colIt == mmPrdContainer->end() ) {
- ATH_MSG_DEBUG(" MmPrepDataCollection for: " << m_idHelperTool->toStringChamber(detElId)
+ ATH_MSG_DEBUG(" MmPrepDataCollection for: " << m_idHelperSvc->toStringChamber(detElId)
<< " not found in container " );
return 0;
}
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.h
index 0147d526635ed0752f4a737e4be872595d860241..8d48723831cd88e492fa205183aeea1e0d3541a7 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.h
@@ -8,12 +8,11 @@
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
-#include "Identifier/Identifier.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkToolInterfaces/ITrackSelectorTool.h"
#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonRecToolInterfaces/IMuonHoleRecoveryTool.h"
-#include "MuonIdHelpers/MuonStationIndex.h"
#include "MuonCondData/MdtCondDbData.h"
#include "TrkTrack/Track.h"
@@ -30,13 +29,6 @@ class StoreGateSvc;
class MdtCondDbData;
class MuonStationIntersectSvc;
-class RpcIdHelper;
-class MdtIdHelper;
-class CscIdHelper;
-class TgcIdHelper;
-// New Small Wheel
-class sTgcIdHelper;
-class MmIdHelper;
namespace MuonGM {
class MuonDetectorManager;
@@ -45,7 +37,6 @@ namespace MuonGM {
namespace Muon {
class IMdtDriftCircleOnTrackCreator;
class IMuonClusterOnTrackCreator;
- class MuonIdHelperTool;
class MuonEDMPrinterTool;
}
@@ -190,7 +181,7 @@ namespace Muon {
ToolHandle<Muon::IMuonClusterOnTrackCreator> m_clusRotCreator; //!< IMuonClusterOnTrackCreator for trigger hits
ToolHandle<Trk::IResidualPullCalculator> m_pullCalculator; //!< residual pull calculator
- ToolHandle<Muon::MuonIdHelperTool> m_idHelperTool; //!< IdHelper tool
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
ServiceHandle<Muon::IMuonEDMHelperSvc> m_edmHelperSvc {this, "edmHelper",
"Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
"Handle to the service providing the IMuonEDMHelperSvc interface" }; //!< EDM Helper tool
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonRefitTool.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonRefitTool.cxx
index a30733bb9077d09bd24b1d01f4eb12cc6c1908dd..257b1d743f3d3a599863c047f16ac1f2518b3270 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonRefitTool.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonRefitTool.cxx
@@ -7,7 +7,6 @@
#include <iostream>
// FrameWork includes
-//#include "CLHEP/Units/SystemOfUnits.h"
#include "AthenaKernel/errorcheck.h"
//Collections
@@ -28,8 +27,6 @@
#include "MuonRecHelperTools/MuonEDMPrinterTool.h"
-#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
-#include "MuonIdHelpers/MuonIdHelperTool.h"
#include "MuonRecToolInterfaces/IMuonTrackExtrapolationTool.h"
#include "MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h"
#include "MuonRecToolInterfaces/IMuonClusterOnTrackCreator.h"
@@ -56,7 +53,6 @@ namespace Muon {
MuonRefitTool::MuonRefitTool( const std::string& ty,const std::string& na,const IInterface* pa) :
AthAlgTool(ty,na,pa),
m_printer("Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"),
- m_idHelper("Muon::MuonIdHelperTool/MuonIdHelperTool"),
m_alignErrorTool("MuonAlign::AlignmentErrorTool"),
m_trackFitter("Trk::GlobalChi2Fitter/MCTBFitterMaterialFromTrack"),
m_extrapolator("Trk::Extrapolator/AtlasExtrapolator"),
@@ -111,7 +107,6 @@ namespace Muon {
declareProperty("UsedFixedError",m_fixedError = 1. );
declareProperty("FlagT0FitRange",m_flagT0FitRange = 0.00005 );
declareProperty("Printer", m_printer );
- declareProperty("IdHelper", m_idHelper );
declareProperty("AlignmentErrorTool", m_alignErrorTool);
declareProperty("Extrapolator", m_extrapolator );
declareProperty("MuonExtrapolator", m_muonExtrapolator );
@@ -150,7 +145,7 @@ namespace Muon {
ATH_CHECK( m_printer.retrieve() );
ATH_CHECK( m_edmHelperSvc.retrieve() );
- ATH_CHECK( m_idHelper.retrieve() );
+ ATH_CHECK( m_idHelperSvc.retrieve() );
if( !m_alignErrorTool.empty() ) ATH_CHECK(m_alignErrorTool.retrieve());
ATH_CHECK( m_extrapolator.retrieve() );
ATH_CHECK( m_muonExtrapolator.retrieve() );
@@ -159,9 +154,12 @@ namespace Muon {
ATH_MSG_INFO("Retrieved " << m_trackFitter );
ATH_CHECK( m_mdtRotCreator.retrieve() );
- if( ! m_cscRotCreator.empty() ) ATH_CHECK( m_cscRotCreator.retrieve() );
- if( ! m_triggerRotCreator.empty() ) ATH_CHECK( m_triggerRotCreator.retrieve() );
- if( !m_compClusterCreator.empty() ) ATH_CHECK( m_compClusterCreator.retrieve() );
+ if(!m_cscRotCreator.empty()) {
+ if (!m_idHelperSvc->hasCSC()) ATH_MSG_WARNING("The current layout does not have any CSC chamber but you gave a CscRotCreator, ignoring it, but double-check configuration");
+ else ATH_CHECK( m_cscRotCreator.retrieve() );
+ }
+ if(!m_triggerRotCreator.empty()) ATH_CHECK( m_triggerRotCreator.retrieve() );
+ if(!m_compClusterCreator.empty()) ATH_CHECK( m_compClusterCreator.retrieve() );
if( !m_t0Fitter.empty() ){
ATH_CHECK( m_t0Fitter.retrieve() );
@@ -413,18 +411,18 @@ namespace Muon {
// bool to decide if deviation should be skipped (if it's for more than 1 station)
for(auto riowithdev : vec_riowithdev){
Identifier id_riowithdev = riowithdev->identify();
- if(m_idHelper->isEndcap(id_riowithdev)) {
+ if(m_idHelperSvc->isEndcap(id_riowithdev)) {
isEndcap = true;
} else {
isBarrel = true;
}
- if(m_idHelper->isSmallChamber(id_riowithdev)) {
+ if(m_idHelperSvc->isSmallChamber(id_riowithdev)) {
isSmallChamber = true;
} else {
isLargeChamber = true;
}
hitids.push_back(id_riowithdev);
- if( hitids.size()>1 && m_idHelper->chamberId(id_riowithdev) != m_idHelper->chamberId(hitids[0]) ) {
+ if( hitids.size()>1 && m_idHelperSvc->chamberId(id_riowithdev) != m_idHelperSvc->chamberId(hitids[0]) ) {
differentChambers = true;
jdifferent = hitids.size()-1;
}
@@ -444,18 +442,6 @@ namespace Muon {
} else {
ATH_MSG_ERROR("One of the alignment deviations has an invalid hash created from the hits.");
}
- /* std::vector<Identifier> hitidsRot;
- itRot->getListOfHits(vec_riowithdev);
- for(auto riowithdev : vec_riowithdev){
- Identifier id_riowithdev = riowithdev->identify();
- hitidsRot.push_back(id_riowithdev);
- if(id_riowithdev==hitids[0]) {
- angleError = sqrt(itRot->getCovariance(0,0));
- matchFound = true;
- break;
- }
- }
- if(matchFound) usedRotations.push_back(iRot); */
}
if(matchFound) break;
}
@@ -466,13 +452,13 @@ namespace Muon {
iok++;
alignerrmap.insert( std::pair < std::vector<Identifier>, std::pair < double, double > > ( hitids, std::pair < double, double > (translationError,angleError) ) );
- if(matchFound) ATH_MSG_DEBUG(" AlignmentMap entry " << iok << " filled with nr hitids " << hitids.size() << " " << m_idHelper->toString(hitids[0]) << " translationError " << translationError << " angleError " << angleError );
- if(!matchFound) ATH_MSG_DEBUG(" AlignmentMap entry No angleError" << iok << " filled with nr hitids " << hitids.size() << " " << m_idHelper->toString(hitids[0]) << " translationError " << translationError << " angleError " << angleError );
+ if(matchFound) ATH_MSG_DEBUG(" AlignmentMap entry " << iok << " filled with nr hitids " << hitids.size() << " " << m_idHelperSvc->toString(hitids[0]) << " translationError " << translationError << " angleError " << angleError );
+ if(!matchFound) ATH_MSG_DEBUG(" AlignmentMap entry No angleError" << iok << " filled with nr hitids " << hitids.size() << " " << m_idHelperSvc->toString(hitids[0]) << " translationError " << translationError << " angleError " << angleError );
if(isEndcap) ATH_MSG_DEBUG(" AlignmentMap Endcap Chamber ");
if(isBarrel) ATH_MSG_DEBUG(" AlignmentMap Barrel Chamber ");
if(isSmallChamber) ATH_MSG_DEBUG(" AlignmentMap Small Chamber ");
if(isLargeChamber) ATH_MSG_DEBUG(" AlignmentMap Large Chamber ");
- if(differentChambers) ATH_MSG_DEBUG(" AlignmentMap entry " << iok << " for different Chamber " << m_idHelper->toString(hitids[jdifferent]) );
+ if(differentChambers) ATH_MSG_DEBUG(" AlignmentMap entry " << iok << " for different Chamber " << m_idHelperSvc->toString(hitids[jdifferent]) );
}
}
@@ -499,12 +485,12 @@ namespace Muon {
// bool to decide if deviation should be skipped (if it's for more than 1 station)
for(auto riowithdev : vec_riowithdev){
Identifier id_riowithdev = riowithdev->identify();
- if(m_idHelper->isEndcap(id_riowithdev)) {
+ if(m_idHelperSvc->isEndcap(id_riowithdev)) {
isEndcap = true;
} else {
isBarrel = true;
}
- if(m_idHelper->isSmallChamber(id_riowithdev)) {
+ if(m_idHelperSvc->isSmallChamber(id_riowithdev)) {
isSmallChamber = true;
} else {
isLargeChamber = true;
@@ -517,7 +503,7 @@ namespace Muon {
iok++;
alignerrmap.insert( std::pair < std::vector<Identifier>, std::pair < double, double > > ( hitids, std::pair < double, double > (translationError,angleError) ) );
- ATH_MSG_DEBUG(" AlignmentMap entry No Translation Error " << iok << " filled with nr hitids " << hitids.size() << " " << m_idHelper->toString(hitids[0]) << " translationError " << translationError << " angleError " << angleError );
+ ATH_MSG_DEBUG(" AlignmentMap entry No Translation Error " << iok << " filled with nr hitids " << hitids.size() << " " << m_idHelperSvc->toString(hitids[0]) << " translationError " << translationError << " angleError " << angleError );
if(isEndcap) ATH_MSG_DEBUG(" AlignmentMap Endcap Chamber");
if(isBarrel) ATH_MSG_DEBUG(" AlignmentMap Barrel Chamber");
if(isSmallChamber) ATH_MSG_DEBUG(" AlignmentMap Small Chamber ");
@@ -560,10 +546,9 @@ namespace Muon {
if( !meas ) {
continue;
}
-// if( (*tsit)->type(Trk::TrackStateOnSurface::Outlier) ) continue;
Identifier id = m_edmHelperSvc->getIdentifier(*meas);
- if( m_idHelper->isMdt(id) ) stationIds.insert( m_idHelper->chamberIndex(id) );
+ if( m_idHelperSvc->isMdt(id) ) stationIds.insert( m_idHelperSvc->chamberIndex(id) );
// make Alignment Effect using the surface of the TSOS
@@ -682,20 +667,19 @@ namespace Muon {
}
Identifier id = m_edmHelperSvc->getIdentifier(*meas);
// Not a ROT, else it would have had an identifier. Keep the TSOS.
- if( !id.is_valid() || !m_idHelper->isMuon(id) ) continue;
- MuonStationIndex::StIndex stIndex = m_idHelper->stationIndex(id);
+ if( !id.is_valid() || !m_idHelperSvc->isMuon(id) ) continue;
+ MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(id);
// skip phi measurements
- if( (m_idHelper->isTrigger(id)&&m_idHelper->measuresPhi(id)) || (m_idHelper->isCsc(id)&&m_idHelper->measuresPhi(id) ) ) continue;
+ if( (m_idHelperSvc->isTrigger(id)&&m_idHelperSvc->measuresPhi(id)) || (m_idHelperSvc->isCsc(id)&&m_idHelperSvc->measuresPhi(id) ) ) continue;
if(m_addAll) {
// skip RPC and TGC eta (to avoid code crashes)
- if( m_idHelper->isTrigger(id)) continue;
-// if( m_idHelper->isTrigger(id) && (stIndex == MuonStationIndex::BM || stIndex == MuonStationIndex::BO) ) continue;
+ if( m_idHelperSvc->isTrigger(id)) continue;
if(indexFirst==-1) indexFirst = index;
indicesOfAffectedTSOS.push_back(*tsit);
indicesOfAffectedIds.push_back(id);
} else {
// skip trigger hits and CSC phi measurements and select precision hits
- if( m_idHelper->isTrigger(id)) continue;
+ if( m_idHelperSvc->isTrigger(id)) continue;
if( stIndex == MuonStationIndex::BM || stIndex == MuonStationIndex::EM) {
if(indexFirst==-1) indexFirst = index;
indicesOfAffectedTSOS.push_back(*tsit);
@@ -838,10 +822,10 @@ namespace Muon {
Identifier id = m_edmHelperSvc->getIdentifier(*meas);
// Not a ROT, else it would have had an identifier. Keep the TSOS.
- if( !id.is_valid() || !m_idHelper->isMuon(id) ) continue;
- if( m_idHelper->isTrigger(id) || (m_idHelper->isCsc(id)&&m_idHelper->measuresPhi(id) ) ) continue;
- MuonStationIndex::StIndex stIndex = m_idHelper->stationIndex(id);
- int sector = m_idHelper->sector(id);
+ if( !id.is_valid() || !m_idHelperSvc->isMuon(id) ) continue;
+ if( m_idHelperSvc->isTrigger(id) || (m_idHelperSvc->isCsc(id)&&m_idHelperSvc->measuresPhi(id) ) ) continue;
+ MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(id);
+ int sector = m_idHelperSvc->sector(id);
stationsPerSector[sector].insert(stIndex);
}
@@ -984,7 +968,7 @@ namespace Muon {
Identifier id = m_edmHelperSvc->getIdentifier(*meas);
// Not a ROT, else it would have had an identifier. Keep the TSOS.
- if( !id.is_valid() || !m_idHelper->isMuon(id) ){
+ if( !id.is_valid() || !m_idHelperSvc->isMuon(id) ){
newStates.push_back( std::make_pair(false,*tsit) );
continue;
}
@@ -993,9 +977,9 @@ namespace Muon {
newStates.push_back( std::make_pair(false,*tsit) );
}else{
- Identifier chId = m_idHelper->chamberId(id);
- MuonStationIndex::StIndex stIndex = m_idHelper->stationIndex(id);
- if( m_idHelper->isMdt(id) ) {
+ Identifier chId = m_idHelperSvc->chamberId(id);
+ MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(id);
+ if( m_idHelperSvc->isMdt(id) ) {
const MdtDriftCircleOnTrack* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(meas);
if( !mdt ){
@@ -1012,16 +996,16 @@ namespace Muon {
}
const Trk::RIO_OnTrack* rot = 0;
- int sector = m_idHelper->sector(id);
+ int sector = m_idHelperSvc->sector(id);
Trk::TrackStateOnSurface::TrackStateOnSurfaceType type = (*tsit)->type(Trk::TrackStateOnSurface::Outlier) ?
Trk::TrackStateOnSurface::Outlier : Trk::TrackStateOnSurface::Measurement;
- stIndex = m_idHelper->stationIndex(id);
+ stIndex = m_idHelperSvc->stationIndex(id);
// error update for three stations with barrel-endcap and shared sectors
if( !m_deweightTwoStationTracks || nmaxStations > 2 ){
- if( m_deweightEEL1C05 && stIndex == MuonStationIndex::EE && m_idHelper->chamberIndex(id) == MuonStationIndex::EEL &&
- m_idHelper->stationEta(id) < 0 && m_idHelper->stationPhi(id) == 3){
+ if( m_deweightEEL1C05 && stIndex == MuonStationIndex::EE && m_idHelperSvc->chamberIndex(id) == MuonStationIndex::EEL &&
+ m_idHelperSvc->stationEta(id) < 0 && m_idHelperSvc->stationPhi(id) == 3){
//for this chamber the errors are enormous (for a period of time)
rot = m_mdtRotCreator->updateError( *mdt, pars, &m_errorStrategyEEL1C05 );
@@ -1050,32 +1034,27 @@ namespace Muon {
//std::cout << " MUONREFIT deweightEE " << std::endl;
rot = m_mdtRotCreator->updateError( *mdt, pars, &m_errorStrategyEE );
- }else if( m_deweightBIS78 && stIndex == MuonStationIndex::BI && m_idHelper->chamberIndex(id) == MuonStationIndex::BIS &&
- abs(m_idHelper->stationEta(id)) > 6 ){
+ }else if( m_deweightBIS78 && stIndex == MuonStationIndex::BI && m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BIS &&
+ abs(m_idHelperSvc->stationEta(id)) > 6 ){
rot = m_mdtRotCreator->updateError( *mdt, pars, &m_errorStrategyBIS78 );
- }else if( m_deweightBME && stIndex == MuonStationIndex::BM && m_idHelper->stationPhi(id) == 7 &&
- (m_idHelper->mdtIdHelper()).stationName(id) == 53 ){
+ }else if( m_deweightBME && stIndex == MuonStationIndex::BM && m_idHelperSvc->stationPhi(id) == 7 &&
+ (m_idHelperSvc->mdtIdHelper()).stationName(id) == 53 ){
rot = m_mdtRotCreator->updateError( *mdt, pars, &m_errorStrategyBXE );
- }else if( m_deweightBOE && stIndex == MuonStationIndex::BO && m_idHelper->chamberIndex(id) == MuonStationIndex::BOL &&
- abs(m_idHelper->stationEta(id)) == 7 && m_idHelper->stationPhi(id) == 7){
+ }else if( m_deweightBOE && stIndex == MuonStationIndex::BO && m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BOL &&
+ abs(m_idHelperSvc->stationEta(id)) == 7 && m_idHelperSvc->stationPhi(id) == 7){
rot = m_mdtRotCreator->updateError( *mdt, pars, &m_errorStrategyBXE );
}else{
/** default strategy */
- //std::cout << " MUONREFIT updateError " << std::endl;
-// if( !m_alignErrorTool.empty() && !alignerrmap.empty() ) {
-// rot = m_mdtRotCreator->updateErrorExternal( *mdt, pars, &alignerrmap);
-// } else {
MuonDriftCircleErrorStrategy strat(m_errorStrategy);
if( hasT0Fit ) strat.setParameter(MuonDriftCircleErrorStrategy::T0Refit,true);
if( settings.broad ) strat.setParameter(MuonDriftCircleErrorStrategy::BroadError,true);
rot = m_mdtRotCreator->updateError( *mdt, pars, &strat );
-// }
}
}else{
rot = m_mdtRotCreator->updateError( *mdt, pars, &m_errorStrategyTwoStations );
@@ -1098,7 +1077,7 @@ namespace Muon {
if( msgLvl(MSG::DEBUG) ){
- msg() << m_idHelper->toString(newMdt->identify()) << " radius " << newMdt->driftRadius()
+ msg() << m_idHelperSvc->toString(newMdt->identify()) << " radius " << newMdt->driftRadius()
<< " new err " << Amg::error(newMdt->localCovariance(),Trk::locR)
<< " old err " << Amg::error(mdt->localCovariance(),Trk::locR);
if( hasT0Fit ) msg() << " HasT0";
@@ -1110,7 +1089,7 @@ namespace Muon {
Trk::TrackStateOnSurface* tsos = MuonTSOSHelper::createMeasTSOSWithUpdate( **tsit, newMdt, pars->clone(), type );
newStates.push_back( std::make_pair(true,tsos) );
- }else if( m_idHelper->isCsc(id) ) {
+ }else if( m_idHelperSvc->isCsc(id) ) {
if( settings.chambersToBeremoved.count(chId) || settings.precisionLayersToBeremoved.count(stIndex) ){
@@ -1122,11 +1101,11 @@ namespace Muon {
newStates.push_back( std::make_pair(false,*tsit) );
}
- }else if( m_idHelper->isTrigger(id) ){
+ }else if( m_idHelperSvc->isTrigger(id) ){
- if( m_idHelper->measuresPhi(id) ){
+ if( m_idHelperSvc->measuresPhi(id) ){
- MuonStationIndex::PhiIndex phiIndex = m_idHelper->phiIndex(id);
+ MuonStationIndex::PhiIndex phiIndex = m_idHelperSvc->phiIndex(id);
if( settings.chambersToBeremoved.count(chId) || settings.phiLayersToBeremoved.count(phiIndex) ){
@@ -1151,11 +1130,11 @@ namespace Muon {
}
}
- }else if( m_idHelper->isMM(id) || m_idHelper->issTgc(id) ){
+ }else if( m_idHelperSvc->isMM(id) || m_idHelperSvc->issTgc(id) ){
newStates.push_back( std::make_pair(false,*tsit) );
}else{
- ATH_MSG_WARNING(" unknown Identifier " << m_idHelper->mdtIdHelper().print_to_string(id) );
+ ATH_MSG_WARNING(" unknown Identifier " << m_idHelperSvc->mdtIdHelper().print_to_string(id) );
}
}
}
@@ -1233,8 +1212,8 @@ namespace Muon {
Identifier id = m_edmHelperSvc->getIdentifier(*meas);
// Not a ROT, else it would have had an identifier. Keep the TSOS.
- if( !id.is_valid() || !m_idHelper->isMuon(id) ) continue;
- if( m_idHelper->isTrigger(id) || (m_idHelper->isCsc(id)&&m_idHelper->measuresPhi(id) ) ) continue;
+ if( !id.is_valid() || !m_idHelperSvc->isMuon(id) ) continue;
+ if( m_idHelperSvc->isTrigger(id) || (m_idHelperSvc->isCsc(id)&&m_idHelperSvc->measuresPhi(id) ) ) continue;
}
if( !startPars ){
@@ -1308,7 +1287,7 @@ namespace Muon {
Identifier id = m_edmHelperSvc->getIdentifier(*meas);
// Not a ROT, else it would have had an identifier. Keep the TSOS.
- if( !id.is_valid() || !m_idHelper->isMuon(id) ){
+ if( !id.is_valid() || !m_idHelperSvc->isMuon(id) ){
newStates.push_back( std::make_pair(false,*tsit) );
continue;
}
@@ -1317,9 +1296,9 @@ namespace Muon {
newStates.push_back( std::make_pair(false,*tsit) );
}else{
- Identifier chId = m_idHelper->chamberId(id);
- MuonStationIndex::StIndex stIndex = m_idHelper->stationIndex(id);
- if( m_idHelper->isMdt(id) ) {
+ Identifier chId = m_idHelperSvc->chamberId(id);
+ MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(id);
+ if( m_idHelperSvc->isMdt(id) ) {
const MdtDriftCircleOnTrack* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(meas);
if( !mdt ){
@@ -1336,11 +1315,10 @@ namespace Muon {
}
const Trk::RIO_OnTrack* rot = 0;
-// int sector = m_idHelper->sector(id);
Trk::TrackStateOnSurface::TrackStateOnSurfaceType type = (*tsit)->type(Trk::TrackStateOnSurface::Outlier) ?
Trk::TrackStateOnSurface::Outlier : Trk::TrackStateOnSurface::Measurement;
- stIndex = m_idHelper->stationIndex(id);
+ stIndex = m_idHelperSvc->stationIndex(id);
// use the muonErrorStrategy
MuonDriftCircleErrorStrategy strat(m_muonErrorStrategy);
@@ -1353,19 +1331,13 @@ namespace Muon {
newMdt = mdt->clone();
type = Trk::TrackStateOnSurface::Outlier;
}
- if( settings.removeOtherSectors ) {
-// if( sector != selectedSector ){
-// ++removedSectorHits;
-// type = Trk::TrackStateOnSurface::Outlier;
-// }
- }
if( settings.chambersToBeremoved.count(chId) || settings.precisionLayersToBeremoved.count(stIndex) ){
type = Trk::TrackStateOnSurface::Outlier;
}
if( msgLvl(MSG::DEBUG) ){
- msg() << " updateMdtErrors " << m_idHelper->toString(newMdt->identify()) << " radius " << newMdt->driftRadius()
+ msg() << " updateMdtErrors " << m_idHelperSvc->toString(newMdt->identify()) << " radius " << newMdt->driftRadius()
<< " new err " << Amg::error(newMdt->localCovariance(),Trk::locR)
<< " old err " << Amg::error(mdt->localCovariance(),Trk::locR);
if( hasT0Fit ) msg() << " HasT0";
@@ -1377,7 +1349,7 @@ namespace Muon {
Trk::TrackStateOnSurface* tsos = MuonTSOSHelper::createMeasTSOSWithUpdate( **tsit, newMdt, pars->clone(), type );
newStates.push_back( std::make_pair(true,tsos) );
- }else if( m_idHelper->isCsc(id) ) {
+ }else if( m_idHelperSvc->isCsc(id) ) {
if( settings.chambersToBeremoved.count(chId) || settings.precisionLayersToBeremoved.count(stIndex) ){
@@ -1389,11 +1361,11 @@ namespace Muon {
newStates.push_back( std::make_pair(false,*tsit) );
}
- }else if( m_idHelper->isTrigger(id) ){
+ }else if( m_idHelperSvc->isTrigger(id) ){
- if( m_idHelper->measuresPhi(id) ){
+ if( m_idHelperSvc->measuresPhi(id) ){
- MuonStationIndex::PhiIndex phiIndex = m_idHelper->phiIndex(id);
+ MuonStationIndex::PhiIndex phiIndex = m_idHelperSvc->phiIndex(id);
if( settings.chambersToBeremoved.count(chId) || settings.phiLayersToBeremoved.count(phiIndex) ){
@@ -1418,11 +1390,11 @@ namespace Muon {
}
}
- }else if( m_idHelper->isMM(id) || m_idHelper->issTgc(id) ){
+ }else if( m_idHelperSvc->isMM(id) || m_idHelperSvc->issTgc(id) ){
newStates.push_back( std::make_pair(false,*tsit) );
}else{
- ATH_MSG_WARNING(" unknown Identifier " << m_idHelper->mdtIdHelper().print_to_string(id) );
+ ATH_MSG_WARNING(" unknown Identifier " << m_idHelperSvc->mdtIdHelper().print_to_string(id) );
}
}
}
@@ -1489,7 +1461,7 @@ namespace Muon {
continue;
}
- if( m_idHelper->isMdt(id) ) {
+ if( m_idHelperSvc->isMdt(id) ) {
const MdtDriftCircleOnTrack* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(meas);
if( !mdt ){
@@ -1497,7 +1469,7 @@ namespace Muon {
continue;
}
// get ch ID
- Identifier chId = m_idHelper->chamberId(id);
+ Identifier chId = m_idHelperSvc->chamberId(id);
// if we have a new chambers
if( chId != currentMdtChId ){
@@ -1505,7 +1477,7 @@ namespace Muon {
// check that there are pars (not the case for the first mdt), if so we collected all hits for this chamber so call cleaning
if( chamberPars ){
if( !removeMdtOutliers(*chamberPars,mdts,removedIdentifiers,settings) ){
- if( mdts.size() > 4 ) ATH_MSG_WARNING("Problem removing outliers in chamber " << m_idHelper->toStringChamber(currentMdtChId) << " hits " << mdts.size());
+ if( mdts.size() > 4 ) ATH_MSG_WARNING("Problem removing outliers in chamber " << m_idHelperSvc->toStringChamber(currentMdtChId) << " hits " << mdts.size());
if( settings.discardNotCleanedTracks ) return 0;
}
}
@@ -1522,7 +1494,7 @@ namespace Muon {
// clean the last chamber on the track
if( chamberPars ){
if( !removeMdtOutliers(*chamberPars,mdts,removedIdentifiers,settings) ){
- if( mdts.size() > 4 ) ATH_MSG_WARNING("Problem removing outliers in chamber " << m_idHelper->toStringChamber(currentMdtChId) << " hits " << mdts.size());
+ if( mdts.size() > 4 ) ATH_MSG_WARNING("Problem removing outliers in chamber " << m_idHelperSvc->toStringChamber(currentMdtChId) << " hits " << mdts.size());
if( settings.discardNotCleanedTracks ) return 0;
}
}
@@ -1601,7 +1573,6 @@ namespace Muon {
continue;
}
Identifier id = mdt->identify();
- //Identifier elId = m_idHelper->mdtIdHelper().elementID( id );
if( !detEl ){
detEl = mdt->prepRawData()->detectorElement();
@@ -1617,12 +1588,12 @@ namespace Muon {
double r = fabs(mdt->localParameters()[Trk::locR]);
double dr = Amg::error(mdt->localCovariance(),Trk::locR);
- ATH_MSG_VERBOSE("New MDT " << m_idHelper->toString(id) << " r " << mdt->localParameters()[Trk::locR]
+ ATH_MSG_VERBOSE("New MDT " << m_idHelperSvc->toString(id) << " r " << mdt->localParameters()[Trk::locR]
<< " dr " << dr << " (original) " << Amg::error(mdt->localCovariance(),Trk::locR) );
// create identifier
- TrkDriftCircleMath::MdtId mdtid( m_idHelper->mdtIdHelper().isBarrel(id),m_idHelper->mdtIdHelper().multilayer(id)-1,
- m_idHelper->mdtIdHelper().tubeLayer(id)-1, m_idHelper->mdtIdHelper().tube(id)-1 );
+ TrkDriftCircleMath::MdtId mdtid( m_idHelperSvc->mdtIdHelper().isBarrel(id),m_idHelperSvc->mdtIdHelper().multilayer(id)-1,
+ m_idHelperSvc->mdtIdHelper().tubeLayer(id)-1, m_idHelperSvc->mdtIdHelper().tube(id)-1 );
// create new DriftCircle
TrkDriftCircleMath::DriftCircle dc( lpos, r, 1., dr, TrkDriftCircleMath::DriftCircle::InTime, mdtid, index, mdt );
@@ -1781,7 +1752,7 @@ namespace Muon {
std::vector< std::pair<Identifier,bool> >::iterator iit_end = indexIdMap.end();
for( ;iit!=iit_end;++iit ){
if(iit->second){
- ATH_MSG_VERBOSE(" removing hit " << m_idHelper->toString( iit->first ) );
+ ATH_MSG_VERBOSE(" removing hit " << m_idHelperSvc->toString( iit->first ) );
removedIdentifiers.insert( iit->first );
}
}
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonRefitTool.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonRefitTool.h
index 9a1f297fb82650caa999082fbe7724d43cb7d381..d3de2d1869e7619b5e7ed63ee4f7f412a7536db9 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonRefitTool.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonRefitTool.h
@@ -19,13 +19,12 @@
#include "TrkDriftCircleMath/DCSLFitter.h"
#include "TrkDriftCircleMath/SegmentFinder.h"
-#include "Identifier/Identifier.h"
#include "TrkParameters/TrackParameters.h"
#include "MuonRIO_OnTrack/MuonDriftCircleErrorStrategy.h"
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
namespace Muon {
class MuonEDMPrinterTool;
- class MuonIdHelperTool;
class IMdtDriftCircleOnTrackCreator;
class IMuonClusterOnTrackCreator;
class IMuonCompetingClustersOnTrackCreator;
@@ -86,7 +85,7 @@ namespace Muon {
ServiceHandle<IMuonEDMHelperSvc> m_edmHelperSvc {this, "edmHelper",
"Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
"Handle to the service providing the IMuonEDMHelperSvc interface" }; //<! muon EDM helper
- ToolHandle<MuonIdHelperTool> m_idHelper; //<! muon id helper
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
ToolHandle<Trk::ITrkAlignmentDeviationTool> m_alignErrorTool; //<! alignment error tool
struct State {
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.cxx
index 111825c782676267ae459f863caa8424aa968b9a..43866f76465e40431f3869770732f8999704ede9 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.cxx
@@ -45,11 +45,13 @@ namespace Muon {
}
StatusCode MuPatCandidateTool::initialize(){
-
+ ATH_CHECK( m_idHelperSvc.retrieve() );
ATH_CHECK( m_mdtRotCreator.retrieve() );
- if ( ! m_cscRotCreator.empty() ) ATH_CHECK( m_cscRotCreator.retrieve() );
+ if (!m_cscRotCreator.empty()) {
+ if (!m_idHelperSvc->hasCSC()) ATH_MSG_WARNING("The current layout does not have any CSC chamber but you gave a CscRotCreator, ignoring it, but double-check configuration");
+ else ATH_CHECK( m_cscRotCreator.retrieve() );
+ }
ATH_CHECK( m_compClusterCreator.retrieve() );
- ATH_CHECK( m_idHelperTool.retrieve() );
ATH_CHECK( m_hitHandler.retrieve() );
ATH_CHECK( m_edmHelperSvc.retrieve() );
ATH_CHECK( m_printer.retrieve() );
@@ -65,31 +67,31 @@ namespace Muon {
MuPatSegment* MuPatCandidateTool::createSegInfo( const MuonSegment& segment ) const
{
Identifier chid = m_edmHelperSvc->chamberId(segment);
- if( m_idHelperTool->isTrigger(chid) ){
- ATH_MSG_WARNING("Trigger hit only segments not supported " << m_idHelperTool->toStringChamber(chid) );
+ if( m_idHelperSvc->isTrigger(chid) ){
+ ATH_MSG_WARNING("Trigger hit only segments not supported " << m_idHelperSvc->toStringChamber(chid) );
return 0;
}
MuPatSegment* info = new MuPatSegment();
info->segment = &segment;
info->chid = chid;
- info->chIndex = m_idHelperTool->chamberIndex(info->chid);
+ info->chIndex = m_idHelperSvc->chamberIndex(info->chid);
std::set<Identifier> chIds = m_edmHelperSvc->chamberIds(segment);
std::set<Identifier>::iterator chit = chIds.begin();
std::set<Identifier>::iterator chit_end = chIds.end();
for( ;chit!=chit_end;++chit ){
- MuonStationIndex::ChIndex chIdx = m_idHelperTool->chamberIndex(*chit);
+ MuonStationIndex::ChIndex chIdx = m_idHelperSvc->chamberIndex(*chit);
info->addChamber(chIdx);
// set default name
if ( !info->name.empty() ) info->name += "+";
// stationname_eta_phi
std::ostringstream oss;
oss << MuonStationIndex::chName(chIdx)
- << "_" << m_idHelperTool->stationEta(*chit) << "_" << m_idHelperTool->stationPhi(*chit);
+ << "_" << m_idHelperSvc->stationEta(*chit) << "_" << m_idHelperSvc->stationPhi(*chit);
info->name += oss.str();
}
- info->stIndex = m_idHelperTool->stationIndex(info->chid);
- info->isEndcap = m_idHelperTool->isEndcap(info->chid);
- info->isMdt = m_idHelperTool->isMdt(info->chid);
+ info->stIndex = m_idHelperSvc->stationIndex(info->chid);
+ info->isEndcap = m_idHelperSvc->isEndcap(info->chid);
+ info->isMdt = m_idHelperSvc->isMdt(info->chid);
info->usedInFit = 0;
info->quality = m_segmentSelector->quality( segment );
info->segQuality = dynamic_cast<const MuonSegmentQuality*>(segment.fitQuality());
@@ -260,18 +262,18 @@ namespace Muon {
}
// skip ID hits
- if( !m_idHelperTool->isMuon(id) ) continue;
+ if( !m_idHelperSvc->isMuon(id) ) continue;
- Identifier chId = m_idHelperTool->chamberId(id);
- MuonStationIndex::ChIndex chIndex = m_idHelperTool->chamberIndex(chId);
- MuonStationIndex::StIndex stIndex = m_idHelperTool->stationIndex(chId);
- if( !hasEndcap ) hasEndcap = m_idHelperTool->isEndcap(id);
+ Identifier chId = m_idHelperSvc->chamberId(id);
+ MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(chId);
+ MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(chId);
+ if( !hasEndcap ) hasEndcap = m_idHelperSvc->isEndcap(id);
bool measuresPhi = false;
- bool isMdt = m_idHelperTool->isMdt(id);
- bool isCsc = m_idHelperTool->isCsc(id);
- bool isNSW = m_idHelperTool->isMM(id) || m_idHelperTool->issTgc(id);
+ bool isMdt = m_idHelperSvc->isMdt(id);
+ bool isCsc = m_idHelperSvc->isCsc(id);
+ bool isNSW = m_idHelperSvc->isMM(id) || m_idHelperSvc->issTgc(id);
// only add precision hits
if( isMdt || isCsc || isNSW ) {
entry.addChamber(chIndex); // will also add stationIndex
@@ -287,7 +289,7 @@ namespace Muon {
}else{
const MdtDriftCircleOnTrack* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(meas);
if( !mdt ){
- ATH_MSG_WARNING(" found MdtDriftCircleOnTrack without MDT identifier " << m_idHelperTool->toString(id) );
+ ATH_MSG_WARNING(" found MdtDriftCircleOnTrack without MDT identifier " << m_idHelperSvc->toString(id) );
continue;
}
ATH_MSG_DEBUG(" recreating MdtDriftCircleOnTrack " );
@@ -298,7 +300,7 @@ namespace Muon {
}
- bool isSmall = m_idHelperTool->isSmallChamber(id);
+ bool isSmall = m_idHelperSvc->isSmallChamber(id);
if( isSmall ) hasSmall = true;
else hasLarge = true;
@@ -306,20 +308,20 @@ namespace Muon {
previssmall=isSmall;
prevstIndex=stIndex;
- unsigned int ml = m_idHelperTool->mdtIdHelper().multilayer(id);
+ unsigned int ml = m_idHelperSvc->mdtIdHelper().multilayer(id);
if( ml == 1 ) ++nmdtHitsMl1;
else ++nmdtHitsMl2;
}else{
- measuresPhi = m_idHelperTool->measuresPhi(id);
+ measuresPhi = m_idHelperSvc->measuresPhi(id);
- bool isRpc = m_idHelperTool->isRpc(id);
+ bool isRpc = m_idHelperSvc->isRpc(id);
if( isRpc ){
if( measuresPhi ) ++nrpcHitsPhi;
else ++nrpcHitsEta;
}
- bool isTgc = m_idHelperTool->isTgc(id);
+ bool isTgc = m_idHelperSvc->isTgc(id);
if( isTgc ){
if( measuresPhi ) ++ntgcHitsPhi;
else ++ntgcHitsEta;
@@ -330,7 +332,7 @@ namespace Muon {
if( recreateCSC ) {
const CscClusterOnTrack* csc = dynamic_cast<const CscClusterOnTrack*>(meas);
if( !csc ){
- ATH_MSG_WARNING(" found CscClusterOnTrack without CSC identifier " << m_idHelperTool->toString(id) );
+ ATH_MSG_WARNING(" found CscClusterOnTrack without CSC identifier " << m_idHelperSvc->toString(id) );
continue;
}
ATH_MSG_DEBUG(" recreating CscClusterOnTrack " );
@@ -398,7 +400,7 @@ namespace Muon {
}else{
Identifier id = m_edmHelperSvc->getIdentifier(meas);
ATH_MSG_WARNING(" Trigger Measurement is not a MuonClusterOnTrack or CompetingMuonClustersOnTrack!! "
- << m_idHelperTool->toString(id) );
+ << m_idHelperSvc->toString(id) );
}
}
}
@@ -420,7 +422,7 @@ namespace Muon {
const MuonClusterOnTrack* clus = *it;
Identifier id = clus->identify();
- Identifier detId = m_idHelperTool->detElId(id);
+ Identifier detId = m_idHelperSvc->detElId(id);
idClusters[detId].push_back(clus);
}
@@ -430,23 +432,23 @@ namespace Muon {
IdClusIt chit_end = idClusters.end();
for( ;chit!=chit_end;++chit ){
if( msgLvl(MSG::VERBOSE) ) {
- msg(MSG::VERBOSE) << " in " << m_idHelperTool->toStringDetEl(chit->first)
+ msg(MSG::VERBOSE) << " in " << m_idHelperSvc->toStringDetEl(chit->first)
<< " clusters: " << chit->second.size() << std::endl;
- std::vector<const MuonClusterOnTrack*>::iterator clit = chit->second.begin();
- std::vector<const MuonClusterOnTrack*>::iterator clit_end = chit->second.end();
- for( ;clit!=clit_end;++clit){
- msg(MSG::VERBOSE) << " " << m_idHelperTool->toString((*clit)->identify());
+ std::vector<const MuonClusterOnTrack*>::iterator cl_it = chit->second.begin();
+ std::vector<const MuonClusterOnTrack*>::iterator cl_it_end = chit->second.end();
+ for( ;cl_it!=cl_it_end;++cl_it){
+ msg(MSG::VERBOSE) << " " << m_idHelperSvc->toString((*cl_it)->identify());
// hack to get correct print-out
- if( clit+1 == clit_end ) msg(MSG::VERBOSE) << endmsg;
+ if( cl_it+1 == cl_it_end ) msg(MSG::VERBOSE) << endmsg;
else msg(MSG::VERBOSE) << std::endl;
}
}
if( chit->second.empty() ){
ATH_MSG_WARNING(" empty list, could not create CompetingMuonClustersOnTrack in chamber "
- << m_idHelperTool->toString(chit->first) );
+ << m_idHelperSvc->toString(chit->first) );
continue;
}
@@ -459,10 +461,10 @@ namespace Muon {
// create list of PRDs
std::list<const Trk::PrepRawData*> prds;
- std::vector<const MuonClusterOnTrack*>::iterator clit = chit->second.begin();
- std::vector<const MuonClusterOnTrack*>::iterator clit_end = chit->second.end();
- for( ;clit!=clit_end;++clit){
- const Trk::PrepRawData* prd = (*clit)->prepRawData();
+ std::vector<const MuonClusterOnTrack*>::iterator cl_it = chit->second.begin();
+ std::vector<const MuonClusterOnTrack*>::iterator cl_it_end = chit->second.end();
+ for( ;cl_it!=cl_it_end;++cl_it){
+ const Trk::PrepRawData* prd = (*cl_it)->prepRawData();
if (prd){
prds.push_back( prd );
} else {
@@ -472,7 +474,7 @@ namespace Muon {
const CompetingMuonClustersOnTrack* comprot = m_compClusterCreator->createBroadCluster(prds,0);
if( !comprot ){
- ATH_MSG_WARNING(" could not create CompetingMuonClustersOnTrack in chamber " << m_idHelperTool->toString(chit->first));
+ ATH_MSG_WARNING(" could not create CompetingMuonClustersOnTrack in chamber " << m_idHelperSvc->toString(chit->first));
continue;
}
hits.push_back(comprot);
@@ -506,15 +508,15 @@ namespace Muon {
// get chamber index
Identifier id = m_edmHelperSvc->getIdentifier(*meas);
- if( !id.is_valid() || !m_idHelperTool->isMuon(id) ) continue;
+ if( !id.is_valid() || !m_idHelperSvc->isMuon(id) ) continue;
// don't include trigger hits
- if( m_idHelperTool->isTrigger(id) ) continue;
+ if( m_idHelperSvc->isTrigger(id) ) continue;
- chambers.insert(m_idHelperTool->chamberIndex(id));
+ chambers.insert(m_idHelperSvc->chamberIndex(id));
if( msgLvl(MSG::VERBOSE) ) {
- msg(MSG::VERBOSE) << " in recal " << m_idHelperTool->toString(id) << endmsg;
+ msg(MSG::VERBOSE) << " in recal " << m_idHelperSvc->toString(id) << endmsg;
}
}
@@ -556,7 +558,7 @@ namespace Muon {
for( ; it!=it_end; ++it ){
if( !(*it)->info().id.is_valid() ) continue;
// only want MDT or CSC detEls
- if ( !m_idHelperTool->isMdt( (*it)->info().id ) && !m_idHelperTool->isCsc( (*it)->info().id ) ) continue;
+ if ( !m_idHelperSvc->isMdt( (*it)->info().id ) && !m_idHelperSvc->isCsc( (*it)->info().id ) ) continue;
const Trk::MeasurementBase& meas = (*it)->measurement();
const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*>(&meas);
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.h
index 310f8752112139faf1eccbe442438325cd147909..51d735f92f12adda5d26834f9a30acf82f672e39 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatCandidateTool.h
@@ -21,7 +21,7 @@
#include "MuPatHitTool.h" // Needed to enfornce build order for reflex dict
#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
-#include "MuonIdHelpers/MuonIdHelperTool.h"
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonRecHelperTools/MuonEDMPrinterTool.h"
#include "MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h"
#include "MuonRecToolInterfaces/IMuonClusterOnTrackCreator.h"
@@ -32,8 +32,6 @@
class MsgStream;
-class MdtIdHelper;
-
namespace Trk {
class Track;
class MeasurementBase;
@@ -180,8 +178,7 @@ namespace Muon {
{this, "CscRotCreator", "Muon::CscClusterOnTrackCreator/CscClusterOnTrackCreator"}; //<! tool to calibrate CSC hits
ToolHandle<IMuonCompetingClustersOnTrackCreator> m_compClusterCreator
{this, "CompetingClustersCreator", "Muon::TriggerChamberClusterOnTrackCreator/TriggerChamberClusterOnTrackCreator"}; //<! tool to create competing clusters on track
- ToolHandle<MuonIdHelperTool> m_idHelperTool
- {this, "IdHelper", "Muon::MuonIdHelperTool/MuonIdHelperTool"}; //<! tool to assist with Identifiers
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
ServiceHandle<IMuonEDMHelperSvc> m_edmHelperSvc
{this, "edmHelper",
"Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatHitTool.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatHitTool.cxx
index 41fb2101b29c50fb639b309b5ca8b0d57cc6b74f..78268fd1d159a96d9d6b7d843e8073dc38c786d7 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatHitTool.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatHitTool.cxx
@@ -7,7 +7,6 @@
#include "MuonTrackMakerUtils/MuonTrackMakerStlTools.h"
#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
-#include "MuonIdHelpers/MuonIdHelperTool.h"
#include "MuonRecHelperTools/MuonEDMPrinterTool.h"
#include "MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h"
#include "MuonRecToolInterfaces/IMuonClusterOnTrackCreator.h"
@@ -44,7 +43,6 @@ namespace Muon {
m_cscRotCreator("Muon::CscClusterOnTrackCreator/CscClusterOnTrackCreator",this),
m_compClusterCreator("Muon::TriggerChamberClusterOnTrackCreator/TriggerChamberClusterOnTrackCreator"),
m_pullCalculator("Trk::ResidualPullCalculator/ResidualPullCalculator"),
- m_idHelperTool("Muon::MuonIdHelperTool/MuonIdHelperTool"),
m_printer("Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"),
m_incidentSvc("IncidentSvc",n),
m_magFieldProperties(Trk::NoField)
@@ -57,11 +55,13 @@ namespace Muon {
MuPatHitTool::~MuPatHitTool() { }
StatusCode MuPatHitTool::initialize(){
-
+ ATH_CHECK( m_idHelperSvc.retrieve() );
ATH_CHECK( m_mdtRotCreator.retrieve() );
- if ( ! m_cscRotCreator.empty() ) ATH_CHECK( m_cscRotCreator.retrieve() );
+ if (!m_cscRotCreator.empty()) {
+ if (!m_idHelperSvc->hasCSC()) ATH_MSG_WARNING("The current layout does not have any CSC chamber but you gave a CscRotCreator, ignoring it, but double-check configuration");
+ else ATH_CHECK( m_cscRotCreator.retrieve() );
+ }
ATH_CHECK( m_compClusterCreator.retrieve() );
- ATH_CHECK( m_idHelperTool.retrieve() );
ATH_CHECK( m_edmHelperSvc.retrieve() );
ATH_CHECK( m_printer.retrieve() );
ATH_CHECK( m_pullCalculator.retrieve() );
@@ -143,14 +143,14 @@ namespace Muon {
const Identifier& id = hitInfo.id;
if( hitInfo.type == MuPatHit::UnknownType ) {
- ATH_MSG_WARNING(" unknown hit type " << m_idHelperTool->toString(id) );
+ ATH_MSG_WARNING(" unknown hit type " << m_idHelperSvc->toString(id) );
continue;
}
// create broad measurement
const Trk::MeasurementBase* broadMeas = createBroadMeasurement(**sit, hitInfo);
if( !broadMeas ){
- ATH_MSG_WARNING(" could not create broad measurement " << m_idHelperTool->toString(id) );
+ ATH_MSG_WARNING(" could not create broad measurement " << m_idHelperSvc->toString(id) );
continue;
}
@@ -179,7 +179,7 @@ namespace Muon {
// create hit and insert it into list
MuPatHit* hit = new MuPatHit(exPars,*sit,broadMeas,hitInfo);
m_hitsToBeDeleted.push_back(hit);
- ATH_MSG_VERBOSE(" inserting hit " << m_idHelperTool->toString(id) << " " << m_printer->print(*exPars) );
+ ATH_MSG_VERBOSE(" inserting hit " << m_idHelperSvc->toString(id) << " " << m_printer->print(*exPars) );
currentHitIt = insert(hitList,currentHitIt, hit);
@@ -220,17 +220,17 @@ namespace Muon {
const Identifier& id = hitInfo.id;
- if( !m_idHelperTool->isMuon(id) ) continue;
+ if( !m_idHelperSvc->isMuon(id) ) continue;
if( hitInfo.type == MuPatHit::UnknownType ) {
- ATH_MSG_WARNING(" unknown hit type " << m_idHelperTool->toString(id) );
+ ATH_MSG_WARNING(" unknown hit type " << m_idHelperSvc->toString(id) );
continue;
}
// create broad measurement
const Trk::MeasurementBase* broadMeas = createBroadMeasurement(*meas, hitInfo);
if( !broadMeas ){
- ATH_MSG_WARNING(" could not create broad measurement " << m_idHelperTool->toString(id) );
+ ATH_MSG_WARNING(" could not create broad measurement " << m_idHelperSvc->toString(id) );
continue;
}
@@ -273,13 +273,13 @@ namespace Muon {
MuPatHitCit it = hitList2.begin(), it_end = hitList2.end();
for( ;it!=it_end;++it ){
if( !(*it)->info().id.is_valid() ) continue;
- MuonStationIndex::StIndex stIndex = m_idHelperTool->stationIndex( (*it)->info().id );
+ MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex( (*it)->info().id );
// add hits in first list
idList.insert((*it)->info().id);
if( stationParsMap.find(stIndex) == stationParsMap.end() ) {
- ATH_MSG_VERBOSE(" reference hit " << *it << " " << m_idHelperTool->toString((*it)->info().id)
+ ATH_MSG_VERBOSE(" reference hit " << *it << " " << m_idHelperSvc->toString((*it)->info().id)
<< " " << m_printer->print((*it)->parameters()) );
stationParsMap[stIndex] = &(*it)->parameters();
@@ -301,7 +301,7 @@ namespace Muon {
if( idList.count((*it)->info().id) ) continue;
idList.insert((*it)->info().id);
- MuonStationIndex::StIndex stIndex = m_idHelperTool->stationIndex( (*it)->info().id );
+ MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex( (*it)->info().id );
// check whether there were also hits in this station in the second list
std::map<MuonStationIndex::StIndex,const Trk::TrackParameters*>::iterator stationPos = stationParsMap.find(stIndex);
@@ -395,13 +395,13 @@ namespace Muon {
MuPatHit::Type MuPatHitTool::getHitType( const Identifier& id ) const {
- if( m_idHelperTool->isMdt(id) ) return MuPatHit::MDT;
- else if( m_idHelperTool->isTgc(id) ) return MuPatHit::TGC;
- else if( m_idHelperTool->isCsc(id) ) return MuPatHit::CSC;
- else if( m_idHelperTool->isRpc(id) ) return MuPatHit::RPC;
- else if( m_idHelperTool->isMM(id) ) return MuPatHit::MM;
- else if( m_idHelperTool->issTgc(id) ) return MuPatHit::sTGC;
- else if( m_idHelperTool->isMuon(id) ) return MuPatHit::PREC;
+ if( m_idHelperSvc->isMdt(id) ) return MuPatHit::MDT;
+ else if( m_idHelperSvc->isTgc(id) ) return MuPatHit::TGC;
+ else if( m_idHelperSvc->isCsc(id) ) return MuPatHit::CSC;
+ else if( m_idHelperSvc->isRpc(id) ) return MuPatHit::RPC;
+ else if( m_idHelperSvc->isMM(id) ) return MuPatHit::MM;
+ else if( m_idHelperSvc->issTgc(id) ) return MuPatHit::sTGC;
+ else if( m_idHelperSvc->isMuon(id) ) return MuPatHit::PREC;
return MuPatHit::UnknownType;
}
@@ -412,10 +412,10 @@ namespace Muon {
hitInfo.measuresPhi = true; // assume that all PseudoMeasurements measure phi!!
hitInfo.type = MuPatHit::Pseudo;
hitInfo.status = MuPatHit::OnTrack;
- if( hitInfo.id.is_valid() && m_idHelperTool->isMuon(hitInfo.id) ) {
+ if( hitInfo.id.is_valid() && m_idHelperSvc->isMuon(hitInfo.id) ) {
hitInfo.type = getHitType(hitInfo.id);
- hitInfo.measuresPhi = m_idHelperTool->measuresPhi(hitInfo.id);
- if( hitInfo.type != MuPatHit::MDT && hitInfo.type != MuPatHit::MM ) hitInfo.id = m_idHelperTool->layerId(hitInfo.id);
+ hitInfo.measuresPhi = m_idHelperSvc->measuresPhi(hitInfo.id);
+ if( hitInfo.type != MuPatHit::MDT && hitInfo.type != MuPatHit::MM ) hitInfo.id = m_idHelperSvc->layerId(hitInfo.id);
}
}
@@ -427,7 +427,7 @@ namespace Muon {
const MdtDriftCircleOnTrack* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(&meas);
if( !mdt ){
ATH_MSG_WARNING(" found hit with a MDT Identifier that is not a MdtDriftCircleOnTrack "
- << m_idHelperTool->toString(hitInfo.id) );
+ << m_idHelperSvc->toString(hitInfo.id) );
return 0;
}
ATH_MSG_DEBUG(" creating broad MdtDriftCircleOnTrack " );
@@ -442,7 +442,7 @@ namespace Muon {
const CscClusterOnTrack* csc = dynamic_cast<const CscClusterOnTrack*>(&meas);
if( !csc ){
ATH_MSG_WARNING(" found hit with CSC identifier that is not a CscClusterOnTrack "
- << m_idHelperTool->toString(hitInfo.id) );
+ << m_idHelperSvc->toString(hitInfo.id) );
return 0;
}
ATH_MSG_DEBUG(" creating broad CscClusterOnTrack " );
@@ -458,7 +458,7 @@ namespace Muon {
// first check whether list is empty, if so insert
if( list.empty() ) {
- ATH_MSG_VERBOSE(" inserting first hit " << m_idHelperTool->toString(hit->info().id)
+ ATH_MSG_VERBOSE(" inserting first hit " << m_idHelperSvc->toString(hit->info().id)
<< " " << m_printer->print(hit->parameters()) );
list.push_back(hit);
return list.begin();
@@ -481,13 +481,13 @@ namespace Muon {
if( pos == list.end() ) {
// check whether hit duplicate of last hit in list
if( isLargerCal(list.back(),hit) != isLargerCal(hit,list.back()) || (hit->info().type == MuPatHit::MM && hit->info().id != list.back()->info().id) ){
- ATH_MSG_VERBOSE(" inserting hit at back " << m_idHelperTool->toString(hit->info().id)
+ ATH_MSG_VERBOSE(" inserting hit at back " << m_idHelperSvc->toString(hit->info().id)
<< " " << m_printer->print(hit->parameters()) );
list.push_back(hit);
pos = list.end();
}else{
// hit is a duplicate
- ATH_MSG_VERBOSE(" NOT inserting duplicate hit " << m_idHelperTool->toString(hit->info().id)
+ ATH_MSG_VERBOSE(" NOT inserting duplicate hit " << m_idHelperSvc->toString(hit->info().id)
<< " " << m_printer->print(hit->parameters()) );
}
return --pos;
@@ -504,13 +504,13 @@ namespace Muon {
if( pos == list.begin() && !isLarger ){
// check whether hit duplicate of last hit in list
if( isLargerCal(list.front(),hit) != isLargerCal(hit,list.front()) || (hit->info().type == MuPatHit::MM && hit->info().id != list.front()->info().id) ){
- ATH_MSG_VERBOSE(" inserting hit at front " << m_idHelperTool->toString(hit->info().id)
+ ATH_MSG_VERBOSE(" inserting hit at front " << m_idHelperSvc->toString(hit->info().id)
<< " " << m_printer->print(hit->parameters()) );
list.push_front(hit);
}else{
// hit is a duplicate
- ATH_MSG_VERBOSE(" NOT inserting duplicate hit " << m_idHelperTool->toString(hit->info().id)
+ ATH_MSG_VERBOSE(" NOT inserting duplicate hit " << m_idHelperSvc->toString(hit->info().id)
<< " " << m_printer->print(hit->parameters()) );
}
return list.begin();
@@ -523,13 +523,13 @@ namespace Muon {
if( pos == list.end() ) {
// check whether hit duplicate of last hit in list
if( isLargerCal(list.back(),hit) != isLargerCal(hit,list.back()) || (hit->info().type == MuPatHit::MM && hit->info().id != list.back()->info().id) ){
- ATH_MSG_VERBOSE(" inserting hit at back " << m_idHelperTool->toString(hit->info().id)
+ ATH_MSG_VERBOSE(" inserting hit at back " << m_idHelperSvc->toString(hit->info().id)
<< " " << m_printer->print(hit->parameters()) );
list.push_back(hit);
pos = list.end();
}else{
// hit is a duplicate
- ATH_MSG_VERBOSE(" NOT inserting duplicate hit " << m_idHelperTool->toString(hit->info().id)
+ ATH_MSG_VERBOSE(" NOT inserting duplicate hit " << m_idHelperSvc->toString(hit->info().id)
<< " " << m_printer->print(hit->parameters()) );
}
return --pos;
@@ -542,7 +542,7 @@ namespace Muon {
// check whether hit and entry at pos are a duplicate
if( isLarger == isLargerCal(*pos,hit) && (hit->info().type != MuPatHit::MM || hit->info().id == (*pos)->info().id) ){
// hit is a duplicate
- ATH_MSG_VERBOSE(" NOT inserting duplicate hit " << m_idHelperTool->toString(hit->info().id)
+ ATH_MSG_VERBOSE(" NOT inserting duplicate hit " << m_idHelperSvc->toString(hit->info().id)
<< " " << m_printer->print(hit->parameters()) );
return pos;
}
@@ -555,7 +555,7 @@ namespace Muon {
if( isLargerCal(hit,*pos) == isLargerCal(*pos,hit) && (hit->info().type != MuPatHit::MM || hit->info().id == (*pos)->info().id) ){
++pos; // move forward to insert position for pos
// hit is a duplicate
- ATH_MSG_VERBOSE(" NOT inserting duplicate hit " << m_idHelperTool->toString(hit->info().id)
+ ATH_MSG_VERBOSE(" NOT inserting duplicate hit " << m_idHelperSvc->toString(hit->info().id)
<< " " << m_printer->print(hit->parameters()) );
return pos;
}
@@ -564,7 +564,7 @@ namespace Muon {
}
// the hit will be inserted before pos
- ATH_MSG_VERBOSE(" inserting hit in middle " << m_idHelperTool->toString(hit->info().id)
+ ATH_MSG_VERBOSE(" inserting hit in middle " << m_idHelperSvc->toString(hit->info().id)
<< " " << m_printer->print(hit->parameters()) );
return list.insert(pos,hit);
}
@@ -582,7 +582,7 @@ namespace Muon {
Identifier id = m_edmHelperSvc->getIdentifier(**mit);
if( !id.is_valid() ) continue;
- if( !m_idHelperTool->isMdt(id) ) id = m_idHelperTool->layerId(id);
+ if( !m_idHelperSvc->isMdt(id) ) id = m_idHelperSvc->layerId(id);
ids.insert(id);
}
@@ -620,7 +620,7 @@ namespace Muon {
if( itNext != it_end ) ++itNext;
for( ; it!=it_end; ++it,++itNext ){
Identifier id = m_edmHelperSvc->getIdentifier( (*it)->measurement() );
- std::string idStr = id.is_valid() ? m_idHelperTool->toString( id ) : "pseudo-measurement";
+ std::string idStr = id.is_valid() ? m_idHelperSvc->toString( id ) : "pseudo-measurement";
idStrings.push_back(idStr);
if (idStr.length() > idWidth) idWidth = idStr.length();
const Trk::TrackParameters& pars = (*it)->parameters();
@@ -671,10 +671,10 @@ namespace Muon {
const Trk::PseudoMeasurementOnTrack* pseudo = dynamic_cast<const Trk::PseudoMeasurementOnTrack*>(&measurement);
if( pseudo ) idStr = "pseudo measurement";
else idStr = "no Identifier";
- }else if( !m_idHelperTool->mdtIdHelper().is_muon(id) ) {
+ }else if( !m_idHelperSvc->mdtIdHelper().is_muon(id) ) {
idStr = "Id hit";
}else{
- idStr = m_idHelperTool->toString( id );
+ idStr = m_idHelperSvc->toString( id );
}
return idStr;
@@ -725,7 +725,7 @@ namespace Muon {
rpcTimes.reserve(nhits);
std::vector<const MuonClusterOnTrack*>::const_iterator itR = rots.begin(), itR_end = rots.end();
for ( ; itR != itR_end; ++itR ) {
- Identifier layerId = m_idHelperTool->layerId((*itR)->identify());
+ Identifier layerId = m_idHelperSvc->layerId((*itR)->identify());
layers.insert(layerId);
const RpcClusterOnTrack* rpc = dynamic_cast<const RpcClusterOnTrack*>(*itR);
const RpcPrepData* rpcPRD = rpc ? rpc->prepRawData() : 0;
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatHitTool.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatHitTool.h
index b51c513e35f6a05b4615d625ce3b2c166d32a139..fe3a92a42d71a48bea897d643ffbe2d3a4a7aecd 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatHitTool.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackSteeringTools/src/MuPatHitTool.h
@@ -12,6 +12,7 @@
#include "GaudiKernel/IIncidentListener.h"
#include "TrkGeometry/MagneticFieldProperties.h"
#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include <vector>
@@ -30,12 +31,9 @@ namespace Muon {
class IMdtDriftCircleOnTrackCreator;
class IMuonClusterOnTrackCreator;
class IMuonCompetingClustersOnTrackCreator;
- class MuonIdHelperTool;
class MuonEDMPrinterTool;
-
class MuonSegment;
-
static const InterfaceID IID_MuPatHitTool("Muon::MuPatHitTool",1,0);
class MuPatHitTool : public AthAlgTool, virtual public IIncidentListener {
@@ -172,7 +170,7 @@ namespace Muon {
ToolHandle<IMuonClusterOnTrackCreator> m_cscRotCreator; //<! tool to calibrate CSC hits
ToolHandle<IMuonCompetingClustersOnTrackCreator> m_compClusterCreator; //<! tool to create competing clusters on track
ToolHandle<Trk::IResidualPullCalculator> m_pullCalculator; //<! tool to calculate residuals and pulls
- ToolHandle<MuonIdHelperTool> m_idHelperTool; //<! tool to assist with Identifiers
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
ServiceHandle<IMuonEDMHelperSvc> m_edmHelperSvc {this, "edmHelper",
"Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
"Handle to the service providing the IMuonEDMHelperSvc interface" }; //<! multipurpose helper tool