diff --git a/Trigger/TrigAlgorithms/TrigL2MuonSA/python/MdtDataPreparator_test.py b/Trigger/TrigAlgorithms/TrigL2MuonSA/python/MdtDataPreparator_test.py
index 09a61fa54547388154740d53efb56ff51ac6944f..65ea70c60f4f212032a571dee99b0cc96522a4b9 100644
--- a/Trigger/TrigAlgorithms/TrigL2MuonSA/python/MdtDataPreparator_test.py
+++ b/Trigger/TrigAlgorithms/TrigL2MuonSA/python/MdtDataPreparator_test.py
@@ -44,7 +44,7 @@ def testCfg (configFlags):
result.merge (AtlasFieldCacheCondAlgCfg(configFlags, UseDCS = False))
TrigL2MuonSA__MdtDataPreparator=CompFactory.TrigL2MuonSA.MdtDataPreparator
- result.addPublicTool (TrigL2MuonSA__MdtDataPreparator ('TrigL2MuonSA::MdtDataPreparator', OutputLevel = 1)) # noqa: ATL900
+ result.addPublicTool (TrigL2MuonSA__MdtDataPreparator ('TrigL2MuonSA::MdtDataPreparator', OutputLevel = 1, isPhase2=configFlags.Muon.usePhaseIIGeoSetup)) # noqa: ATL900
result.addEventAlgo (TestAlg ('TestAlg'))
return result
diff --git a/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig.py b/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig.py
index 52350e973e9980f1f891a1a088bf9c7eafd957ef..4d80602d4fca3cbe73d245b0909e00d23cd6344c 100644
--- a/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig.py
+++ b/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig.py
@@ -47,7 +47,8 @@ def MdtDataPreparatorCfg( flags ):
# Set Mdt data preparator for MuFast data preparator
from RegionSelector.RegSelToolConfig import regSelTool_MDT_Cfg
MdtDataPreparator = CompFactory.getComp("TrigL2MuonSA::MdtDataPreparator")(
- RegSel_MDT = acc.popToolsAndMerge( regSelTool_MDT_Cfg( flags ) )
+ RegSel_MDT = acc.popToolsAndMerge( regSelTool_MDT_Cfg( flags ) ),
+ isPhase2 = flags.Muon.usePhaseIIGeoSetup
)
return acc, MdtDataPreparator
diff --git a/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MdtDataPreparator.cxx b/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MdtDataPreparator.cxx
index b7efb3010c375c03a916cd327e0300fd1f9dc8fa..cc5634aa9202f0aa719c3c3cad0066dd855db00d 100644
--- a/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MdtDataPreparator.cxx
+++ b/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MdtDataPreparator.cxx
@@ -1,9 +1,11 @@
/*
- Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#include "MdtDataPreparator.h"
+#include "AthenaBaseComps/AthMsgStreamMacros.h"
+#include "Identifier/Identifier.h"
#include "Identifier/IdentifierHash.h"
#include "MuonReadoutGeometry/MuonDetectorManager.h"
#include "MuonReadoutGeometry/MdtReadoutElement.h"
@@ -18,6 +20,7 @@
#include "GeoModelUtilities/GeoGetIds.h"
#include "MuonIdHelpers/MdtIdHelper.h"
+#include <unordered_set>
namespace {
// the tube number of a tube in a tubeLayer in encoded in the GeoSerialIdentifier (modulo maxNTubesPerLayer)
constexpr unsigned int maxNTubesPerLayer = MdtIdHelper::maxNTubesPerLayer;
@@ -26,20 +29,6 @@ namespace {
// --------------------------------------------------------------------------------
// --------------------------------------------------------------------------------
-TrigL2MuonSA::MdtDataPreparator::MdtDataPreparator(const std::string& type,
- const std::string& name,
- const IInterface* parent):
- AthAlgTool(type,name,parent),
- m_regionSelector("RegSelTool/RegSelTool_MDT",this),
- m_BMGpresent(false),
- m_BMGid(-1)
-{
- declareProperty("RegSel_MDT", m_regionSelector);
-}
-
-// --------------------------------------------------------------------------------
-// --------------------------------------------------------------------------------
-
StatusCode TrigL2MuonSA::MdtDataPreparator::initialize()
{
@@ -49,40 +38,41 @@ StatusCode TrigL2MuonSA::MdtDataPreparator::initialize()
ATH_CHECK( m_mdtRegionDefiner.retrieve() );
ATH_MSG_DEBUG("Retrieved service " << m_mdtRegionDefiner);
- ATH_CHECK(m_muDetMgrKey.initialize());
-
- const MuonGM::MuonDetectorManager* muonDetMgr=nullptr;
- ATH_CHECK( detStore()->retrieve(muonDetMgr) );
- ATH_MSG_DEBUG("Retrieved GeoModel from DetectorStore.");
ATH_CHECK( m_idHelperSvc.retrieve() );
+ ATH_CHECK(m_mdtPrepContainerKey.initialize());
- m_BMGpresent = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG") != -1;
- if(m_BMGpresent){
- ATH_MSG_INFO("Processing configuration for layouts with BMG chambers.");
- m_BMGid = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG");
- for(int phi=6; phi<8; phi++) { // phi sectors - BMGs are ony in (6 aka 12) and (7 aka 14)
- for(int eta=1; eta<4; eta++) { // eta sectors - BMGs are in eta 1 to 3
- for(int side=-1; side<2; side+=2) { // side - both sides have BMGs
- if( !muonDetMgr->getMuonStation("BMG", side*eta, phi) ) continue;
- for(int roe=1; roe<=( muonDetMgr->getMuonStation("BMG", side*eta, phi) )->nMuonReadoutElements(); roe++) { // iterate on readout elemets
- const MuonGM::MdtReadoutElement* mdtRE =
- dynamic_cast<const MuonGM::MdtReadoutElement*> ( ( muonDetMgr->getMuonStation("BMG", side*eta, phi) )->getMuonReadoutElement(roe) ); // has to be an MDT
- if(mdtRE) initDeadChannels(mdtRE);
- }
- }
+ if(!m_isPhase2){
+
+ const MuonGM::MuonDetectorManager* muonDetMgr=nullptr;
+ ATH_CHECK( detStore()->retrieve(muonDetMgr) );
+ ATH_MSG_DEBUG("Retrieved GeoModel from DetectorStore.");
+
+ if(m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG") != -1){ //if we have BMGs
+
+ ATH_MSG_INFO("Processing configuration for layouts with BMG chambers.");
+ m_BMGid = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG");
+ for(int phi=6; phi<8; phi++) { // phi sectors - BMGs are ony in (6 aka 12) and (7 aka 14)
+ for(int eta=1; eta<4; eta++) { // eta sectors - BMGs are in eta 1 to 3
+ for(int side=-1; side<2; side+=2) { // side - both sides have BMGs
+ if( !muonDetMgr->getMuonStation("BMG", side*eta, phi) ) continue;
+ for(int roe=1; roe<=( muonDetMgr->getMuonStation("BMG", side*eta, phi) )->nMuonReadoutElements(); roe++) { // iterate on readout elemets
+ const MuonGM::MdtReadoutElement* mdtRE =
+ dynamic_cast<const MuonGM::MdtReadoutElement*> ( ( muonDetMgr->getMuonStation("BMG", side*eta, phi) )->getMuonReadoutElement(roe) ); // has to be an MDT
+ if(mdtRE) initDeadChannels(mdtRE);
+ }
+ }
+ }
}
}
}
-
- ATH_CHECK(m_mdtPrepContainerKey.initialize());
-
return StatusCode::SUCCESS;
}
// --------------------------------------------------------------------------------
// --------------------------------------------------------------------------------
-StatusCode TrigL2MuonSA::MdtDataPreparator::prepareData(const TrigRoiDescriptor* p_roids,
+StatusCode TrigL2MuonSA::MdtDataPreparator::prepareData(
+ const TrigRoiDescriptor* p_roids,
const TrigL2MuonSA::RpcFitResult& rpcFitResult,
TrigL2MuonSA::MuonRoad& muonRoad,
TrigL2MuonSA::MdtRegion& mdtRegion,
@@ -99,7 +89,8 @@ StatusCode TrigL2MuonSA::MdtDataPreparator::prepareData(const TrigRoiDescriptor*
// --------------------------------------------------------------------------------
// --------------------------------------------------------------------------------
-StatusCode TrigL2MuonSA::MdtDataPreparator::prepareData(const TrigRoiDescriptor* p_roids,
+StatusCode TrigL2MuonSA::MdtDataPreparator::prepareData(
+ const TrigRoiDescriptor* p_roids,
const TrigL2MuonSA::TgcFitResult& tgcFitResult,
TrigL2MuonSA::MuonRoad& muonRoad,
TrigL2MuonSA::MdtRegion& mdtRegion,
@@ -117,39 +108,40 @@ StatusCode TrigL2MuonSA::MdtDataPreparator::prepareData(const TrigRoiDescriptor*
// --------------------------------------------------------------------------------
// --------------------------------------------------------------------------------
-StatusCode TrigL2MuonSA::MdtDataPreparator::getMdtHits(const TrigRoiDescriptor* p_roids,
- TrigL2MuonSA::MuonRoad& muonRoad,
- TrigL2MuonSA::MdtHits& mdtHits_normal) const
+StatusCode TrigL2MuonSA::MdtDataPreparator::getMdtHits(
+ const TrigRoiDescriptor* p_roids,
+ TrigL2MuonSA::MuonRoad& muonRoad,
+ TrigL2MuonSA::MdtHits& mdtHits_normal) const
{
- SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
- const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
// preload ROBs
std::vector<uint32_t> v_robIds;
std::vector<IdentifierHash> mdtHashList;
+ const EventContext& ctx = Gaudi::Hive::currentContext();
+
if (m_use_RoIBasedDataAccess) {
ATH_MSG_DEBUG("Use RoI based data access");
const IRoiDescriptor* iroi = (IRoiDescriptor*) p_roids;
- m_regionSelector->lookup( Gaudi::Hive::currentContext() )->HashIDList(*iroi, mdtHashList);
+ m_regionSelector->lookup( ctx )->HashIDList(*iroi, mdtHashList);
ATH_MSG_DEBUG("mdtHashList.size()=" << mdtHashList.size());
- m_regionSelector->lookup( Gaudi::Hive::currentContext() )->ROBIDList(*iroi, v_robIds);
+ m_regionSelector->lookup( ctx )->ROBIDList(*iroi, v_robIds);
} else {
ATH_MSG_DEBUG("Use full data access");
TrigRoiDescriptor fullscan_roi( true );
- m_regionSelector->lookup( Gaudi::Hive::currentContext() )->HashIDList(fullscan_roi, mdtHashList);
+ m_regionSelector->lookup( ctx )->HashIDList(fullscan_roi, mdtHashList);
ATH_MSG_DEBUG("mdtHashList.size()=" << mdtHashList.size());
- m_regionSelector->lookup( Gaudi::Hive::currentContext() )->ROBIDList(fullscan_roi, v_robIds);
+ m_regionSelector->lookup( ctx )->ROBIDList(fullscan_roi, v_robIds);
}
- ATH_CHECK( collectMdtHitsFromPrepData(mdtHashList, mdtHits_normal, muonRoad, muDetMgr) );
+ ATH_CHECK( collectMdtHitsFromPrepData(ctx, mdtHashList, mdtHits_normal, muonRoad) );
return StatusCode::SUCCESS;
}
@@ -157,10 +149,10 @@ StatusCode TrigL2MuonSA::MdtDataPreparator::getMdtHits(const TrigRoiDescriptor*
// --------------------------------------------------------------------------------
// --------------------------------------------------------------------------------
-StatusCode TrigL2MuonSA::MdtDataPreparator::collectMdtHitsFromPrepData(const std::vector<IdentifierHash>& v_idHash,
- TrigL2MuonSA::MdtHits& mdtHits,
- const TrigL2MuonSA::MuonRoad& muonRoad,
- const MuonGM::MuonDetectorManager* muDetMgr) const
+StatusCode TrigL2MuonSA::MdtDataPreparator::collectMdtHitsFromPrepData(const EventContext& ctx,
+ const std::vector<IdentifierHash>& v_idHash,
+ TrigL2MuonSA::MdtHits& mdtHits,
+ const TrigL2MuonSA::MuonRoad& muonRoad) const
{
// Get MDT container
@@ -168,18 +160,13 @@ StatusCode TrigL2MuonSA::MdtDataPreparator::collectMdtHitsFromPrepData(const std
ATH_MSG_DEBUG("Hash list is empty");
return StatusCode::SUCCESS;
}
-
- const Muon::MdtPrepDataContainer* mdtPrds;
- auto mdtPrepContainerHandle = SG::makeHandle(m_mdtPrepContainerKey);
- mdtPrds = mdtPrepContainerHandle.cptr();
- if (!mdtPrepContainerHandle.isValid()) {
- ATH_MSG_ERROR(" Cannot retrieve MDT PRD Container " << m_mdtPrepContainerKey.key());
- return StatusCode::FAILURE;
- }
+ SG::ReadHandle mdtPrds{m_mdtPrepContainerKey, ctx};
+ ATH_CHECK(mdtPrds.isPresent());
// Get MDT collections
///// Vectors of prep data collections
- std::vector<const Muon::MdtPrepDataCollection*> mdtCols;
+ std::vector<const Muon::MdtPrepDataCollection*> mdtCols{};
+ mdtCols.reserve(v_idHash.size());
for(const IdentifierHash& id : v_idHash) {
@@ -198,7 +185,7 @@ StatusCode TrigL2MuonSA::MdtDataPreparator::collectMdtHitsFromPrepData(const std
mdtCols.push_back(MDTcoll);
ATH_MSG_DEBUG("Selected Mdt Collection: "
- << m_idHelperSvc->mdtIdHelper().show_to_string(MDTcoll->identify())
+ << m_idHelperSvc->toStringChamber(MDTcoll->identify())
<< " with size " << MDTcoll->size()
<< "in Hash ID" << (int)id);
}
@@ -209,17 +196,13 @@ StatusCode TrigL2MuonSA::MdtDataPreparator::collectMdtHitsFromPrepData(const std
for( const Muon::MdtPrepData* mdt : *mdtCol ) {
const MuonGM::MdtReadoutElement* mdtReadout = mdt->detectorElement();
- if (!mdtReadout) continue;
const MuonGM::MuonStation* muonStation = mdtReadout->parentMuonStation();
int StationPhi = mdtReadout->getStationPhi();
int StationEta = mdtReadout->getStationEta();
int MultiLayer = mdtReadout->getMultilayer();
- double cXmid;
- double cYmid;
- double cAmid = 0;
- double cPhip;
+ double cXmid{0.}, cYmid{0.}, cAmid{0.}, cPhip{0.};
Identifier id = mdt->identify();
int adc = mdt->adc();
@@ -237,66 +220,62 @@ StatusCode TrigL2MuonSA::MdtDataPreparator::collectMdtHitsFromPrepData(const std
int chamber = 0;
if (chamberType[0]=='E') {
- /// Endcap
- if (st=='I') chamber = xAOD::L2MuonParameters::Chamber::EndcapInner;
- if (st=='M') chamber = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
- if (st=='O') chamber = xAOD::L2MuonParameters::Chamber::EndcapOuter;
- if (st=='E') chamber = xAOD::L2MuonParameters::Chamber::EndcapExtra;
- } else {
- /// Barrel
- if (st=='I') chamber = xAOD::L2MuonParameters::Chamber::BarrelInner;
- if (st=='M') chamber = xAOD::L2MuonParameters::Chamber::BarrelMiddle;
- if (st=='O') chamber = xAOD::L2MuonParameters::Chamber::BarrelOuter;
- if (st=='E' && chamberType[2]=='E') chamber = xAOD::L2MuonParameters::Chamber::BEE;
- if (st=='M' && chamberType[2]=='E') chamber = xAOD::L2MuonParameters::Chamber::BME;
- if (st=='M' && chamberType[2]=='G') chamber = xAOD::L2MuonParameters::Chamber::Backup;
+ /// Endcap
+ if (st=='I') chamber = xAOD::L2MuonParameters::Chamber::EndcapInner;
+ if (st=='M') chamber = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
+ if (st=='O') chamber = xAOD::L2MuonParameters::Chamber::EndcapOuter;
+ if (st=='E') chamber = xAOD::L2MuonParameters::Chamber::EndcapExtra;
+ }
+ else {
+ /// Barrel
+ if (st=='I') chamber = xAOD::L2MuonParameters::Chamber::BarrelInner;
+ if (st=='M') chamber = xAOD::L2MuonParameters::Chamber::BarrelMiddle;
+ if (st=='O') chamber = xAOD::L2MuonParameters::Chamber::BarrelOuter;
+ if (st=='E' && chamberType[2]=='E') chamber = xAOD::L2MuonParameters::Chamber::BEE;
+ if (st=='M' && chamberType[2]=='E') chamber = xAOD::L2MuonParameters::Chamber::BME;
+ if (st=='M' && chamberType[2]=='G') chamber = xAOD::L2MuonParameters::Chamber::Backup;
}
double R = -99999., Z = -99999.;
- if(m_BMGpresent && m_idHelperSvc->mdtIdHelper().stationName(id) == m_BMGid ) {
- std::map<Identifier, std::vector<Identifier> >::const_iterator myIt = m_DeadChannels.find( muDetMgr->getMdtReadoutElement(id)->identify() );
- if( myIt != m_DeadChannels.end() ){
- if( std::find( (myIt->second).begin(), (myIt->second).end(), id) != (myIt->second).end() ) {
- ATH_MSG_DEBUG("Skipping tube with identifier " << m_idHelperSvc->mdtIdHelper().show_to_string(id) );
- continue;
- }
- }
+ if(m_idHelperSvc->mdtIdHelper().stationName(id) == m_BMGid && m_DeadChannels.count(id)) {
+ ATH_MSG_DEBUG("Skipping tube with identifier " << m_idHelperSvc->toString(id) );
+ continue;
}
R = mdtReadout->center(TubeLayer, Tube).perp();
Z = mdtReadout->center(TubeLayer, Tube).z();
Amg::Transform3D trans = muonStation->getNominalAmdbLRSToGlobal();
if(muonStation->endcap()==0){
- cXmid = (trans.translation()).z();
- double halfRadialThicknessOfMultilayer = muonStation->RsizeMdtStation()/2.;
- cYmid = ((trans.translation()).perp()+halfRadialThicknessOfMultilayer);
+ cXmid = (trans.translation()).z();
+ double halfRadialThicknessOfMultilayer = muonStation->RsizeMdtStation()/2.;
+ cYmid = ((trans.translation()).perp()+halfRadialThicknessOfMultilayer);
}
else{
- cXmid = (trans.translation()).perp();
- double halfZThicknessOfMultilayer = muonStation->ZsizeMdtStation()/2.;
- cYmid = (trans.translation()).z();
- if(cYmid>0) cYmid += halfZThicknessOfMultilayer;
- else cYmid -= halfZThicknessOfMultilayer;
+ cXmid = (trans.translation()).perp();
+ double halfZThicknessOfMultilayer = muonStation->ZsizeMdtStation()/2.;
+ cYmid = (trans.translation()).z();
+ if(cYmid>0) cYmid += halfZThicknessOfMultilayer;
+ else cYmid -= halfZThicknessOfMultilayer;
}
cPhip = (trans.translation()).phi();
double dphi = 0;
double cphi = muonRoad.phi[chamber][0];
if( cPhip*cphi>0 ) {
- dphi = std::abs(cPhip - cphi);
- } else {
- if(std::abs(cphi) > M_PI/2.) {
- double phi1 = (cPhip>0.)? cPhip-M_PI : cPhip+M_PI;
- double phi2 = (cphi >0.)? cphi -M_PI : cphi +M_PI;
- dphi = std::abs(phi1) + std::abs(phi2);
- }
- else {
- dphi = std::abs(cPhip) + std::abs(cphi);
- }
+ dphi = std::abs(cPhip - cphi);
+ }
+ else {
+ if(std::abs(cphi) > M_PI/2.) {
+ double phi1 = (cPhip>0.)? cPhip-M_PI : cPhip+M_PI;
+ double phi2 = (cphi >0.)? cphi -M_PI : cphi +M_PI;
+ dphi = std::abs(phi1) + std::abs(phi2);
+ }
+ else {
+ dphi = std::abs(cPhip) + std::abs(cphi);
+ }
}
- if(muonStation->endcap()==1)
- R = R *std::hypot(1, std::tan(dphi));
+ if(muonStation->endcap()==1) R = R *std::hypot(1, std::tan(dphi));
Amg::Vector3D OrigOfMdtInAmdbFrame = muonStation->getBlineFixedPointInAmdbLRS() ;
double Rmin =(trans*OrigOfMdtInAmdbFrame).perp();
@@ -314,33 +293,33 @@ StatusCode TrigL2MuonSA::MdtDataPreparator::collectMdtHitsFromPrepData(const std
// (residual check at pattern finder)
if(Layer!=0 && Tube !=0) {
- // create the new digit
- TrigL2MuonSA::MdtHitData tmp;
- tmp.name = m_idHelperSvc->mdtIdHelper().stationName(id);
- tmp.StationEta = StationEta;
- tmp.StationPhi = StationPhi;
- tmp.Multilayer = MultiLayer;
- tmp.Layer = Layer - 1;
- tmp.TubeLayer = TubeLayer;
- tmp.Tube = Tube;
- tmp.cYmid = cYmid;
- tmp.cXmid = cXmid;
- tmp.cAmid = cAmid;
- tmp.cPhip = cPhip;
- tmp.cInCo = cInCo;
- tmp.cPhi0 = cPhi0;
- for(unsigned int i=0; i<4; i++) { tmp.cType[i] = chamberType[i]; }
- tmp.Z = Z;
- tmp.R = R;
- tmp.DriftTime = drift;
- tmp.Adc = adc;
- tmp.LeadingCoarseTime = (drift>>5) & 0xfff;
- tmp.LeadingFineTime = drift & 0x1f;
- tmp.Chamber = chamber;
- tmp.readEle = mdtReadout;
- tmp.Id = id;
-
- mdtHits.push_back(std::move(tmp));
+ // create the new digit
+ TrigL2MuonSA::MdtHitData tmp;
+ tmp.name = m_idHelperSvc->mdtIdHelper().stationName(id);
+ tmp.StationEta = StationEta;
+ tmp.StationPhi = StationPhi;
+ tmp.Multilayer = MultiLayer;
+ tmp.Layer = Layer - 1;
+ tmp.TubeLayer = TubeLayer;
+ tmp.Tube = Tube;
+ tmp.cYmid = cYmid;
+ tmp.cXmid = cXmid;
+ tmp.cAmid = cAmid;
+ tmp.cPhip = cPhip;
+ tmp.cInCo = cInCo;
+ tmp.cPhi0 = cPhi0;
+ for(unsigned int i=0; i<4; i++) { tmp.cType[i] = chamberType[i]; }
+ tmp.Z = Z;
+ tmp.R = R;
+ tmp.DriftTime = drift;
+ tmp.Adc = adc;
+ tmp.LeadingCoarseTime = (drift>>5) & 0xfff;
+ tmp.LeadingFineTime = drift & 0x1f;
+ tmp.Chamber = chamber;
+ tmp.readEle = mdtReadout;
+ tmp.Id = id;
+
+ mdtHits.push_back(std::move(tmp));
}
} // end of MdtPrepDataCollection loop
} // end of MdtPrepDataCollection vector loop
@@ -357,7 +336,7 @@ void TrigL2MuonSA::MdtDataPreparator::initDeadChannels(const MuonGM::MdtReadoutE
if(nGrandchildren <= 0) return;
std::vector<int> tubes;
- geoGetIds ([&] (int id) { tubes.push_back (id); }, &*cv);
+ geoGetIds ([&] (int id) { tubes.push_back (id); }, cv);
std::sort (tubes.begin(), tubes.end());
Identifier detElId = mydetEl->identify();
@@ -366,7 +345,6 @@ void TrigL2MuonSA::MdtDataPreparator::initDeadChannels(const MuonGM::MdtReadoutE
int eta = m_idHelperSvc->mdtIdHelper().stationEta(detElId);
int phi = m_idHelperSvc->mdtIdHelper().stationPhi(detElId);
int ml = m_idHelperSvc->mdtIdHelper().multilayer(detElId);
- std::vector<Identifier> deadTubes;
std::vector<int>::iterator it = tubes.begin();
for(int layer = 1; layer <= mydetEl->getNLayers(); layer++){
@@ -382,7 +360,7 @@ void TrigL2MuonSA::MdtDataPreparator::initDeadChannels(const MuonGM::MdtReadoutE
}
else {
Identifier deadTubeId = m_idHelperSvc->mdtIdHelper().channelID( name, eta, phi, ml, layer, tube );
- deadTubes.push_back( deadTubeId );
+ m_DeadChannels.insert(deadTubeId);
ATH_MSG_VERBOSE("adding dead tube (" << tube << "), layer(" << layer
<< "), phi(" << phi << "), eta(" << eta << "), name(" << name
<< "), multilayerId(" << ml << ") and identifier " << deadTubeId <<" .");
@@ -390,9 +368,6 @@ void TrigL2MuonSA::MdtDataPreparator::initDeadChannels(const MuonGM::MdtReadoutE
}
}
}
- std::sort(deadTubes.begin(), deadTubes.end());
- m_DeadChannels[detElId] = deadTubes;
- return;
}
// --------------------------------------------------------------------------------
diff --git a/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MdtDataPreparator.h b/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MdtDataPreparator.h
index 4ec9fff68e709f23891957871e4154bbb423186b..2ce6b110c8fcc00d6029e1527bc75cf3fe3aaf29 100644
--- a/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MdtDataPreparator.h
+++ b/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MdtDataPreparator.h
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef TRIGL2MUONSA_MDTDATAPREPARATOR_H
@@ -7,25 +7,22 @@
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
-#include "GaudiKernel/ToolHandle.h"
#include "MuonCnvToolInterfaces/IMuonRdoToPrepDataTool.h"
-#include "MuonCnvToolInterfaces/IMuonRawDataProviderTool.h"
#include "IRegionSelector/IRegSelTool.h"
#include "Identifier/IdentifierHash.h"
#include "TrigSteeringEvent/TrigRoiDescriptor.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonCablingData/MuonMDT_CablingMap.h"
-#include "StoreGate/ReadCondHandleKey.h"
#include "MuonPrepRawData/MuonPrepDataContainer.h"
#include "MuonReadoutGeometry/MuonDetectorManager.h"
-#include "TgcData.h"
#include "MdtData.h"
#include "MdtRegionDefiner.h"
#include "RpcFitResult.h"
#include "TgcFitResult.h"
+#include <unordered_set>
namespace MuonGM{
class MdtReadoutElement;
@@ -45,39 +42,38 @@ namespace TrigL2MuonSA {
public:
- MdtDataPreparator(const std::string& type,
- const std::string& name,
- const IInterface* parent);
+ using AthAlgTool::AthAlgTool;
virtual StatusCode initialize() override;
public:
- StatusCode prepareData(const TrigRoiDescriptor* p_roids,
- const TrigL2MuonSA::RpcFitResult& rpcFitResult,
- TrigL2MuonSA::MuonRoad& muonRoad,
- TrigL2MuonSA::MdtRegion& mdtRegion,
- TrigL2MuonSA::MdtHits& mdtHits_normal) const;
+ StatusCode prepareData(const TrigRoiDescriptor* p_roids,
+ const TrigL2MuonSA::RpcFitResult& rpcFitResult,
+ TrigL2MuonSA::MuonRoad& muonRoad,
+ TrigL2MuonSA::MdtRegion& mdtRegion,
+ TrigL2MuonSA::MdtHits& mdtHits_normal) const;
- StatusCode prepareData(const TrigRoiDescriptor* p_roids,
- const TrigL2MuonSA::TgcFitResult& tgcFitResult,
- TrigL2MuonSA::MuonRoad& muonRoad,
- TrigL2MuonSA::MdtRegion& mdtRegion,
- TrigL2MuonSA::MdtHits& mdtHits_normal) const;
+ StatusCode prepareData(const TrigRoiDescriptor* p_roids,
+ const TrigL2MuonSA::TgcFitResult& tgcFitResult,
+ TrigL2MuonSA::MuonRoad& muonRoad,
+ TrigL2MuonSA::MdtRegion& mdtRegion,
+ TrigL2MuonSA::MdtHits& mdtHits_normal) const;
void setRpcGeometry(bool use_rpc) {m_mdtRegionDefiner->setRpcGeometry(use_rpc);};
void setRoIBasedDataAccess(bool use_RoIBasedDataAccess){m_use_RoIBasedDataAccess = use_RoIBasedDataAccess;};
private:
- StatusCode getMdtHits(const TrigRoiDescriptor* p_roids,
+ StatusCode getMdtHits(
+ const TrigRoiDescriptor* p_roids,
TrigL2MuonSA::MuonRoad& muonRoad,
TrigL2MuonSA::MdtHits& mdtHits_normal) const;
- StatusCode collectMdtHitsFromPrepData(const std::vector<IdentifierHash>& v_idHash,
+ StatusCode collectMdtHitsFromPrepData(const EventContext& ctx,
+ const std::vector<IdentifierHash>& v_idHash,
TrigL2MuonSA::MdtHits& mdtHits,
- const TrigL2MuonSA::MuonRoad& muonRoad,
- const MuonGM::MuonDetectorManager* muDetMgr) const;
+ const TrigL2MuonSA::MuonRoad& muonRoad) const;
void initDeadChannels(const MuonGM::MdtReadoutElement* mydetEl);
@@ -85,10 +81,9 @@ namespace TrigL2MuonSA {
// Geometry Services
ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
- IdentifierHash m_hash_id;
// Region Selector
- ToolHandle<IRegSelTool> m_regionSelector;
+ ToolHandle<IRegSelTool> m_regionSelector{this, "RegSel_MDT", "RegSelTool/RegSelTool_MDT"};
// MdtRegionDefiner
ToolHandle<MdtRegionDefiner> m_mdtRegionDefiner {
@@ -97,13 +92,12 @@ namespace TrigL2MuonSA {
// handles to data access
SG::ReadHandleKey<Muon::MdtPrepDataContainer> m_mdtPrepContainerKey{
this, "MDTPrepDataContainer","MDT_DriftCircles", "Name of the MDTContainer to read in"};
- SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"};
-
- bool m_use_RoIBasedDataAccess = false;
- bool m_BMGpresent;
- int m_BMGid;
- std::map<Identifier, std::vector<Identifier> > m_DeadChannels;
-
+
+ Gaudi::Property<bool> m_isPhase2{this, "isPhase2", false, "if the phase 2 geometry is setup"};
+ Gaudi::Property<bool> m_use_RoIBasedDataAccess{this, "use_RoIBasedDataAccess", false};
+
+ int m_BMGid{0};
+ std::unordered_set<Identifier> m_DeadChannels{};
};
} // namespace TrigL2MuonSA