Skip to content
Snippets Groups Projects
Commit cce0e94a authored by Leonardo Monaco's avatar Leonardo Monaco Committed by Vakhtang Tsulaia
Browse files

Change MdtDataPreparator to run dead channels removal only when phase1 geometry is setup 

Change MdtDataPreparator to run dead channels removal only when phase1 geometry is setup
parent 669eb3f1
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Trigger/TrigAlgorithms/TrigL2MuonSA/python/MdtDataPreparator_test.py
+ 1
− 1
View file @ cce0e94a
......@@ -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
......
Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig.py
+ 2
− 1
View file @ cce0e94a
......@@ -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
......
Trigger/TrigAlgorithms/TrigL2MuonSA/src/MdtDataPreparator.cxx
+ 117
− 142
View file @ cce0e94a
/*
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;
}
// --------------------------------------------------------------------------------
......
Trigger/TrigAlgorithms/TrigL2MuonSA/src/MdtDataPreparator.h
+ 25
− 31
View file @ cce0e94a
/*
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
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment