diff --git a/Trigger/TrigT1/TrigT1MuonRecRoiTool/CMakeLists.txt b/Trigger/TrigT1/TrigT1MuonRecRoiTool/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..169d388e76c6f98d6d1221ccb4c2438fa4d2e3ff
--- /dev/null
+++ b/Trigger/TrigT1/TrigT1MuonRecRoiTool/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+
+# Declare the package name:
+atlas_subdir( TrigT1MuonRecRoiTool )
+
+# Component(s) in the package:
+atlas_add_library( TrigT1MuonRecRoiToolLib
+ src/*.cxx
+ PUBLIC_HEADERS TrigT1MuonRecRoiTool
+ LINK_LIBRARIES AthenaKernel GaudiKernel MuonIdHelpersLib MuonReadoutGeometry TGCcablingInterfaceLib RPCcablingInterfaceLib RPC_CondCablingLib )
+
+atlas_add_component( TrigT1MuonRecRoiTool
+ src/components/*.cxx
+ LINK_LIBRARIES TrigT1MuonRecRoiToolLib )
+
diff --git a/Trigger/TrigT1/TrigT1MuonRecRoiTool/TrigT1MuonRecRoiTool/ITrigT1MuonRecRoiTool.h b/Trigger/TrigT1/TrigT1MuonRecRoiTool/TrigT1MuonRecRoiTool/ITrigT1MuonRecRoiTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..b706f35fe18ee8a9dc4fbba055e4da74ded97595
--- /dev/null
+++ b/Trigger/TrigT1/TrigT1MuonRecRoiTool/TrigT1MuonRecRoiTool/ITrigT1MuonRecRoiTool.h
@@ -0,0 +1,94 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ITRIGT1MUONRECROITOOL_H
+#define ITRIGT1MUONRECROITOOL_H
+
+#include "GaudiKernel/IAlgTool.h"
+#include "TrigT1MuonRecRoiTool/TrigT1MuonRecRoiData.h"
+
+namespace LVL1 {
+
+ class ITrigT1MuonRecRoiTool: public virtual IAlgTool {
+ public:
+
+ ITrigT1MuonRecRoiTool();
+
+ virtual ~ITrigT1MuonRecRoiTool() {}
+
+ DeclareInterfaceID( ITrigT1MuonRecRoiTool, 1, 0);
+
+ /// pure virtual function to return eta and phi coord of RoI
+ virtual TrigT1MuonRecRoiData roiData(const unsigned int& roiWord ) const = 0;
+
+ /// pure virtual function returns roi size
+ virtual void RoIsize(const unsigned int& roiWord,
+ double& etaMin, double& etaMax,
+ double& phiMin, double& phiMax) const = 0;
+
+ /// pure virtual function for dumping roi mapping
+ virtual bool dumpRoiMap(const std::string& filename) const = 0;
+
+ unsigned int getBitMaskValue( const unsigned int * uintValue,
+ const unsigned int mask ) const;
+
+ enum RoiWordFormat{
+ Run2, Run3
+ };
+ void updateBitMask( const RoiWordFormat );
+
+ enum MuonTriggerSystem{
+ Barrel, Endcap, Forward, Undef
+ };
+ MuonTriggerSystem getSystem( const unsigned int& roiWord ) const;
+
+ unsigned int IsRun3Mask() const {return m_IsRun3Mask;}
+ unsigned int IsVetoedMask() const {return m_IsVetoedMask;}
+ unsigned int ChargeMask() const {return m_ChargeMask;}
+ unsigned int IsFirstCandMask() const {return m_IsFirstCandMask;}
+ unsigned int SectorAddressMask() const {return m_SectorAddressMask;}
+ unsigned int BarrelSectorIDMask() const {return m_BarrelSectorIDMask;}
+ unsigned int EndcapSectorIDMask() const {return m_EndcapSectorIDMask;}
+ unsigned int ForwardSectorIDMask() const {return m_ForwardSectorIDMask;}
+ unsigned int SysIDMask() const {return m_SysIDMask;}
+ unsigned int SubSysIDMask() const {return m_SubSysIDMask;}
+ unsigned int ThresholdMask() const {return m_ThresholdMask;}
+ unsigned int BarrelRoIMask() const {return m_BarrelRoIMask;}
+ unsigned int EndcapRoIMask() const {return m_EndcapRoIMask;}
+ unsigned int ForwardRoIMask() const {return m_ForwardRoIMask;}
+ unsigned int EndcapRMask() const {return m_EndcapRMask;}
+ unsigned int EndcapPhiMask() const {return m_EndcapPhiMask;}
+ unsigned int ForwardRMask() const {return m_ForwardRMask;}
+ unsigned int ForwardPhiMask() const {return m_ForwardPhiMask;}
+ unsigned int OverflowPerRoIMask() const {return m_OverflowPerRoIMask;}
+ unsigned int OverflowPerSectorMask() const {return m_OverflowPerSectorMask;}
+
+ private:
+
+ unsigned int m_IsRun3Mask{0};
+ unsigned int m_IsVetoedMask{0};
+ unsigned int m_ChargeMask{0};
+ unsigned int m_IsFirstCandMask{0};
+ unsigned int m_SectorAddressMask{0};
+ unsigned int m_BarrelSectorIDMask{0};
+ unsigned int m_EndcapSectorIDMask{0};
+ unsigned int m_ForwardSectorIDMask{0};
+ unsigned int m_SysIDMask{0};
+ unsigned int m_SubSysIDMask{0};
+ unsigned int m_ThresholdMask{0};
+ unsigned int m_BarrelRoIMask{0};
+ unsigned int m_EndcapRoIMask{0};
+ unsigned int m_ForwardRoIMask{0};
+ unsigned int m_EndcapRMask{0};
+ unsigned int m_EndcapPhiMask{0};
+ unsigned int m_ForwardRMask{0};
+ unsigned int m_ForwardPhiMask{0};
+ unsigned int m_OverflowPerRoIMask{0};
+ unsigned int m_OverflowPerSectorMask{0};
+
+ }; // end of ITrigT1MuonRecRoiTool
+
+} // namespace LVL1
+
+#endif
diff --git a/Trigger/TrigT1/TrigT1MuonRecRoiTool/TrigT1MuonRecRoiTool/TrigT1MuonRecRoiData.h b/Trigger/TrigT1/TrigT1MuonRecRoiTool/TrigT1MuonRecRoiTool/TrigT1MuonRecRoiData.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b49649bb9068f6bd87d55aa8cd8d53a57a73a8f
--- /dev/null
+++ b/Trigger/TrigT1/TrigT1MuonRecRoiTool/TrigT1MuonRecRoiTool/TrigT1MuonRecRoiData.h
@@ -0,0 +1,56 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRIGT1MUONRECROIDATA_H
+#define TRIGT1MUONRECROIDATA_H
+
+namespace LVL1 {
+
+ class TrigT1MuonRecRoiData{
+ public:
+ TrigT1MuonRecRoiData();
+ TrigT1MuonRecRoiData(const double _eta, const double _phi);
+ TrigT1MuonRecRoiData(const double _eta, const double _phi,
+ const double _etaMin, const double _etaMax,
+ const double _phiMin, const double _phiMax );
+ ~TrigT1MuonRecRoiData(){}
+
+ unsigned short side(void) const {return m_side;}
+ unsigned short sector(void) const {return m_sector;}
+ unsigned short roi(void) const {return m_roi;}
+ double eta(void) const {return m_eta;}
+ double phi(void) const {return m_phi;}
+ double etaMin(void) const {return m_etaMin;}
+ double etaMax(void) const {return m_etaMax;}
+ double phiMin(void) const {return m_phiMin;}
+ double phiMax(void) const {return m_phiMax;}
+
+ void set_side(unsigned short _side);
+ void set_sector(unsigned short _sector);
+ void set_roi(unsigned short _roi);
+ void set_eta(double _eta);
+ void set_phi(double _phi);
+ void set_etaMin(double _etaMin);
+ void set_etaMax(double _etaMax);
+ void set_phiMin(double _phiMin);
+ void set_phiMax(double _phiMax);
+ void update(void);
+
+ private:
+
+ unsigned short m_side{0};
+ unsigned short m_sector{0};
+ unsigned short m_roi{0};
+ double m_eta{0};
+ double m_phi{0};
+ double m_etaMin{0};
+ double m_etaMax{0};
+ double m_phiMin{0};
+ double m_phiMax{0};
+
+ }; // end of TrigT1MuonRecRoiData
+
+} // namespace LVL1
+
+#endif
diff --git a/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/ITrigT1MuonRecRoiTool.cxx b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/ITrigT1MuonRecRoiTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..a5e4762ec7ed14baecab5829e017cb7e6402e5c5
--- /dev/null
+++ b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/ITrigT1MuonRecRoiTool.cxx
@@ -0,0 +1,83 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrigT1MuonRecRoiTool/ITrigT1MuonRecRoiTool.h"
+
+namespace LVL1{
+
+ unsigned int ITrigT1MuonRecRoiTool::getBitMaskValue( const unsigned int * uintValue,
+ const unsigned int mask ) const {
+ unsigned int maskcopy = mask;
+ unsigned int result = *uintValue & mask;
+ if ( mask != 0 ) {
+ while ( ( maskcopy & 0x00000001 ) == 0 ) {
+ maskcopy = maskcopy >> 1;
+ result = result >> 1;
+ }
+ }
+ return result;
+ }
+
+ ITrigT1MuonRecRoiTool::MuonTriggerSystem ITrigT1MuonRecRoiTool::getSystem( const unsigned int& roiWord ) const
+ {
+ unsigned int result = getBitMaskValue(&roiWord,SysIDMask());
+ if( result == 0x0 ) return Barrel;
+ else if( result == 0x1 ) return Forward;
+ else if( result>>1 ) return Endcap;
+ else return Undef;
+ }
+
+ ITrigT1MuonRecRoiTool::ITrigT1MuonRecRoiTool()
+ {
+ updateBitMask( Run2 );
+ }
+ void ITrigT1MuonRecRoiTool::updateBitMask( const ITrigT1MuonRecRoiTool::RoiWordFormat format ){
+ if( format == Run2 ){
+ m_IsRun3Mask = 0x80000000;
+ m_IsVetoedMask = 0x10000000;
+ m_ChargeMask = 0x08000000;
+ m_IsFirstCandMask = 0x00400000;
+ m_SectorAddressMask = 0x003fc000;
+ m_BarrelSectorIDMask = 0x000f8000;
+ m_EndcapSectorIDMask = 0x001f8000;
+ m_ForwardSectorIDMask = 0x000f8000;
+ m_SysIDMask = 0x00300000;
+ m_SubSysIDMask = 0x00004000;
+ m_ThresholdMask = 0x00003800;
+ m_BarrelRoIMask = 0x0000007c;
+ m_EndcapRoIMask = 0x000003fc;
+ m_ForwardRoIMask = 0x000000fc;
+ m_EndcapRMask = 0x000003f0;
+ m_EndcapPhiMask = 0x0000000c;
+ m_ForwardRMask = 0x000000f0;
+ m_ForwardPhiMask = 0x0000000c;
+ m_OverflowPerRoIMask = 0x00000002;
+ m_OverflowPerSectorMask = 0x00000001;
+ }else if( format == Run3 ){
+ m_IsRun3Mask = 0x80000000;
+ m_IsVetoedMask = 0x00010000;
+ m_ChargeMask = 0x00001000;
+ m_IsFirstCandMask = 0x00000000; // undef
+ m_SectorAddressMask = 0x1fe00000;
+ m_BarrelSectorIDMask = 0x07c00000;
+ m_EndcapSectorIDMask = 0x0fc00000;
+ m_ForwardSectorIDMask = 0x07c00000;
+ m_SysIDMask = 0x18000000;
+ m_SubSysIDMask = 0x00200000;
+ m_ThresholdMask = 0x00000f00;
+ m_BarrelRoIMask = 0x0000001f;
+ m_EndcapRoIMask = 0x000000ff;
+ m_ForwardRoIMask = 0x0000003f;
+ m_EndcapRMask = 0x000000fc;
+ m_EndcapPhiMask = 0x00000003;
+ m_ForwardRMask = 0x0000003c;
+ m_ForwardPhiMask = 0x00000003;
+ m_OverflowPerRoIMask = 0x00001000;
+ m_OverflowPerSectorMask = 0x00020000;
+ }else{
+ // no update
+ }
+ }
+
+}
diff --git a/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1MuonRecRoiData.cxx b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1MuonRecRoiData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..9e701535b27c9df0d657e5b1ccdd06f3eae1a310
--- /dev/null
+++ b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1MuonRecRoiData.cxx
@@ -0,0 +1,56 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrigT1MuonRecRoiTool/TrigT1MuonRecRoiData.h"
+#include <math.h> /* M_PI */
+
+namespace LVL1{
+
+ TrigT1MuonRecRoiData::TrigT1MuonRecRoiData(const double eta, const double phi):
+ m_eta(eta),
+ m_phi(phi)
+ {
+ }
+ TrigT1MuonRecRoiData::TrigT1MuonRecRoiData()
+ {
+ }
+ TrigT1MuonRecRoiData::TrigT1MuonRecRoiData(const double eta, const double phi,
+ const double etaMin, const double etaMax,
+ const double phiMin, const double phiMax ):
+ m_eta(eta),
+ m_phi(phi),
+ m_etaMin(etaMin),
+ m_etaMax(etaMax),
+ m_phiMin(phiMin),
+ m_phiMax(phiMax)
+ {
+ }
+ void TrigT1MuonRecRoiData::set_side(unsigned short side){m_side = side;}
+ void TrigT1MuonRecRoiData::set_sector(unsigned short sector){m_sector=sector;}
+ void TrigT1MuonRecRoiData::set_roi(unsigned short roi){m_roi=roi;}
+ void TrigT1MuonRecRoiData::set_eta(double eta){m_eta=eta;}
+ void TrigT1MuonRecRoiData::set_phi(double phi){m_phi=phi;}
+ void TrigT1MuonRecRoiData::set_etaMin(double etaMin){m_etaMin=etaMin;}
+ void TrigT1MuonRecRoiData::set_etaMax(double etaMax){m_etaMax=etaMax;}
+ void TrigT1MuonRecRoiData::set_phiMin(double phiMin){m_phiMin=phiMin;}
+ void TrigT1MuonRecRoiData::set_phiMax(double phiMax){m_phiMax=phiMax;}
+ void TrigT1MuonRecRoiData::update(){
+ if (m_etaMin>m_etaMax) {
+ double tmp = m_etaMax;
+ m_etaMax = m_etaMin;
+ m_etaMin = tmp;
+ }
+ if(m_phi < -M_PI) {
+ m_phi += 2*M_PI;
+ }else if (m_phi > M_PI) {
+ m_phi -= 2*M_PI;
+ }
+ if (m_phiMin>m_phiMax&&m_phiMin-m_phiMax<M_PI) {
+ double tmp = m_phiMax;
+ m_phiMax = m_phiMin;
+ m_phiMin = tmp;
+ }
+ }
+
+}
diff --git a/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1RPCRecRoiTool.cxx b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1RPCRecRoiTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..febebaff5765606f459d0b1305875f3a20e2e091
--- /dev/null
+++ b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1RPCRecRoiTool.cxx
@@ -0,0 +1,271 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrigT1RPCRecRoiTool.h"
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
+#include "MuonReadoutGeometry/MuonDetectorManager.h"
+#include "MuonReadoutGeometry/RpcReadoutElement.h"
+#include "RPC_CondCabling/RpcCablingCondData.h"
+#include "RPCcablingInterface/IRPCcablingServerSvc.h"
+#include <fstream>
+
+namespace LVL1 {
+ TrigT1RPCRecRoiTool::TrigT1RPCRecRoiTool( const std::string& type, const std::string& name, const IInterface* parent) : base_class(type,name,parent)
+ {
+ }
+
+ TrigT1RPCRecRoiTool::~TrigT1RPCRecRoiTool() {
+ }
+
+ StatusCode TrigT1RPCRecRoiTool::initialize() {
+ ATH_CHECK(m_DetectorManagerKey.initialize());
+ ATH_CHECK( detStore()->retrieve(m_muonMgr) );
+ ATH_CHECK( m_idHelperSvc.retrieve() );
+ ServiceHandle<IRPCcablingServerSvc> rpcCabGet ("RPCcablingServerSvc", name());
+ ATH_CHECK( rpcCabGet.retrieve() );
+ ATH_CHECK( rpcCabGet->giveCabling(m_cabling) );
+ if(m_useRun3Config){
+ ATH_MSG_INFO("update to Run 3 bit mask");
+ updateBitMask( Run3 );
+ }
+ return StatusCode::SUCCESS;
+ }
+
+ TrigT1MuonRecRoiData TrigT1RPCRecRoiTool::roiData( const unsigned int & roiWord )const
+ {
+ TrigT1MuonRecRoiData data;
+
+ // subsystem ID and sector ID
+ data.set_side( getBitMaskValue(&roiWord,SubSysIDMask()) );
+ data.set_sector( getBitMaskValue(&roiWord,BarrelSectorIDMask()) );
+ // RoI
+ data.set_roi( getBitMaskValue(&roiWord,BarrelRoIMask()) );
+
+ // Get the strips delimiting the RoIs from rPCcablingSvc
+ Identifier EtaLowBorder_id;
+ Identifier EtaHighBorder_id;
+ Identifier PhiLowBorder_id;
+ Identifier PhiHighBorder_id;
+
+ Amg::Vector3D EtaLowBorder_pos(0.,0.,0.);
+ Amg::Vector3D EtaHighBorder_pos(0.,0.,0.);
+ Amg::Vector3D PhiLowBorder_pos(0.,0.,0.);
+ Amg::Vector3D PhiHighBorder_pos(0.,0.,0.);
+
+ if(m_cabling->give_RoI_borders_id(data.side(), data.sector(), data.roi(),
+ EtaLowBorder_id, EtaHighBorder_id,
+ PhiLowBorder_id, PhiHighBorder_id))
+ {
+
+ const MuonGM::MuonDetectorManager* muonMgr = m_muonMgr;
+ if(m_useConditionData){
+ SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
+ muonMgr = DetectorManagerHandle.cptr();
+ if(muonMgr==nullptr){
+ ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object. Use the one from DetectorStore");
+ muonMgr = m_muonMgr;
+ }
+ }
+
+ const MuonGM::RpcReadoutElement* EtaLowBorder_descriptor =
+ muonMgr->getRpcReadoutElement(EtaLowBorder_id);
+ EtaLowBorder_pos = EtaLowBorder_descriptor->stripPos(EtaLowBorder_id);
+
+ const MuonGM::RpcReadoutElement* EtaHighBorder_descriptor =
+ muonMgr->getRpcReadoutElement(EtaHighBorder_id);
+ EtaHighBorder_pos = EtaHighBorder_descriptor->stripPos(EtaHighBorder_id);
+
+ const MuonGM::RpcReadoutElement* PhiLowBorder_descriptor =
+ muonMgr->getRpcReadoutElement(PhiLowBorder_id);
+ PhiLowBorder_pos = PhiLowBorder_descriptor->stripPos(PhiLowBorder_id);
+
+ const MuonGM::RpcReadoutElement* PhiHighBorder_descriptor =
+ muonMgr->getRpcReadoutElement(PhiHighBorder_id);
+ PhiHighBorder_pos = PhiHighBorder_descriptor->stripPos(PhiHighBorder_id);
+
+ data.set_etaMin( EtaLowBorder_pos.eta() );
+ data.set_etaMax( EtaHighBorder_pos.eta() );
+ data.set_eta( (data.etaMin()+data.etaMax())/2. );
+
+ data.set_phiMin( PhiLowBorder_pos.phi() );
+ data.set_phiMax( PhiHighBorder_pos.phi() );
+ data.set_phi( (data.phiMin()+data.phiMax())/2. );
+
+ data.update();
+
+ }
+ return data;
+ }
+ void TrigT1RPCRecRoiTool::RoIsize(const unsigned int & roiWord,
+ double & etaMin_LowHigh, double & etaMax_LowHigh,
+ double & phiMin_LowHigh, double & phiMax_LowHigh) const
+ {
+ double etaMin_Low=0;
+ double etaMin_High=0;
+ double etaMax_Low=0;
+ double etaMax_High=0;
+
+ SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey};
+ std::unique_ptr<const RpcCablingCondData> readCdo(*readHandle);
+
+ auto data = roiData(roiWord);
+ phiMin_LowHigh=data.phiMin();
+ phiMax_LowHigh=data.phiMax();
+
+ bool low = etaDimLow(data,etaMin_Low,etaMax_Low, std::move(readCdo));
+ bool high = etaDimHigh(data,etaMin_High,etaMax_High, std::move(readCdo));
+
+ if (low&&high) {
+ etaMin_LowHigh=std::min(etaMin_Low,etaMin_High);
+ etaMax_LowHigh=std::max(etaMax_Low,etaMax_High);
+ } else if (low) {
+ etaMin_LowHigh =std::min(etaMin_Low,data.etaMin());
+ etaMax_LowHigh =std::max(etaMax_Low,data.etaMax());
+ } else if (high) {
+ etaMin_LowHigh =std::min(etaMin_High,data.etaMin());
+ etaMax_LowHigh =std::max(etaMax_High,data.etaMax());
+ } else {
+ etaMin_LowHigh = data.etaMin();
+ etaMax_LowHigh = data.etaMax();
+ }
+ return;
+ }
+
+ bool TrigT1RPCRecRoiTool::dumpRoiMap(const std::string& filename) const
+ {
+ const unsigned int maxSubsystem = 2;
+ const unsigned int maxLogicSector = 32;
+ const unsigned int maxRoI = 32;
+
+ SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey};
+ std::unique_ptr<const RpcCablingCondData> readCdo(*readHandle);
+
+ std::ofstream roi_map;
+ roi_map.open(filename.c_str(), std::ios::out );
+ if(!roi_map){
+ ATH_MSG_WARNING( "Unable to open ROI_Mapping file!" );
+ } else {
+ roi_map <<"# side sector roi etaMin etaMax phiMin phiMax etaMinLow etaMaxLow etaMinHigh etaMaxHigh "<< std::endl;
+ roi_map <<"# ------------------------------------------------------------------------------------------------------------------------------ "<< std::endl;
+ for(unsigned int side=0;side < maxSubsystem; side++){
+ for(unsigned int sector=0;sector < maxLogicSector; sector++){
+ for (unsigned int roi=0; roi<maxRoI; roi++){
+ unsigned long int roIWord = (m_useRun3Config) ? (roi+(side<<21)+(sector<<22)) : ((roi<<2)+(side<<14)+(sector<<15));
+ auto data = roiData(roIWord);
+ double etaMinLow(0),etaMaxLow(0),etaMinHigh(0),etaMaxHigh(0);
+ etaDimLow (data,etaMinLow, etaMaxLow, std::move(readCdo));
+ etaDimHigh(data,etaMinHigh,etaMaxHigh, std::move(readCdo));
+ roi_map << std::setw(8) << side << " "
+ << std::setw(8) << sector << " "
+ << std::setw(8) << roi << " "
+ << std::setw(12) << data.etaMin() << " "
+ << std::setw(12) << data.etaMax() << " "
+ << std::setw(12) << data.phiMin() << " "
+ << std::setw(12) << data.phiMax() << " "
+ << std::setw(8) << etaMinLow << " "
+ << std::setw(8) << etaMaxLow << " "
+ << std::setw(8) << etaMinHigh << " "
+ << std::setw(8) << etaMaxHigh << std::endl;
+ }
+ }
+ }
+ roi_map.close();
+ }
+ return true;
+ }
+
+
+ bool TrigT1RPCRecRoiTool::etaDimLow (const TrigT1MuonRecRoiData& data,
+ double& etaMin, double& etaMax,
+ std::unique_ptr<const RpcCablingCondData> readCdo) const
+ {
+ // Get the strips delimiting the RoIs from rPCcablingSvc
+ Identifier EtaLowBorder_id;
+ Identifier EtaHighBorder_id;
+ Identifier PhiLowBorder_id;
+ Identifier PhiHighBorder_id;
+ Amg::Vector3D EtaLowBorder_pos(0.,0.,0.);
+ Amg::Vector3D EtaHighBorder_pos(0.,0.,0.);
+
+ if(!readCdo->give_LowPt_borders_id(data.side(), data.sector(), data.roi(),
+ EtaLowBorder_id, EtaHighBorder_id,
+ PhiLowBorder_id, PhiHighBorder_id,
+ &m_idHelperSvc->rpcIdHelper())) return false;
+
+
+ const MuonGM::MuonDetectorManager* muonMgr = m_muonMgr;
+ if(m_useConditionData){
+ SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
+ muonMgr = DetectorManagerHandle.cptr();
+ if(muonMgr==nullptr){
+ ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object. Use the one from DetectorStore");
+ muonMgr = m_muonMgr;
+ }
+ }
+
+ const MuonGM::RpcReadoutElement* EtaLowBorder_descriptor =
+ muonMgr->getRpcReadoutElement(EtaLowBorder_id);
+ EtaLowBorder_pos = EtaLowBorder_descriptor->stripPos(EtaLowBorder_id);
+
+ const MuonGM::RpcReadoutElement* EtaHighBorder_descriptor =
+ muonMgr->getRpcReadoutElement(EtaHighBorder_id);
+ EtaHighBorder_pos = EtaHighBorder_descriptor->stripPos(EtaHighBorder_id);
+
+ etaMin=EtaLowBorder_pos.eta();
+ etaMax=EtaHighBorder_pos.eta();
+ if (etaMin>etaMax){
+ double tmp=etaMin;
+ etaMin=etaMax;
+ etaMax=tmp;
+ }
+ return true;
+ }
+
+ bool TrigT1RPCRecRoiTool::etaDimHigh (const TrigT1MuonRecRoiData& data,
+ double& etaMin, double& etaMax,
+ std::unique_ptr<const RpcCablingCondData> readCdo) const
+ {
+ // Get the strips delimiting the RoIs from rPCcablingSvc
+ Identifier EtaLowBorder_id;
+ Identifier EtaHighBorder_id;
+ Identifier PhiLowBorder_id;
+ Identifier PhiHighBorder_id;
+ Amg::Vector3D EtaLowBorder_pos(0.,0.,0.);
+ Amg::Vector3D EtaHighBorder_pos(0.,0.,0.);
+
+ if(!readCdo->give_HighPt_borders_id(data.side(), data.sector(), data.roi(),
+ EtaLowBorder_id, EtaHighBorder_id,
+ PhiLowBorder_id, PhiHighBorder_id,
+ &m_idHelperSvc->rpcIdHelper())) return false;
+
+ const MuonGM::MuonDetectorManager* muonMgr = m_muonMgr;
+ if(m_useConditionData){
+ SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
+ muonMgr = DetectorManagerHandle.cptr();
+ if(muonMgr==nullptr){
+ ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object. Use the one from DetectorStore");
+ muonMgr = m_muonMgr;
+ }
+ }
+
+ const MuonGM::RpcReadoutElement* EtaLowBorder_descriptor =
+ muonMgr->getRpcReadoutElement(EtaLowBorder_id);
+ EtaLowBorder_pos = EtaLowBorder_descriptor->stripPos(EtaLowBorder_id);
+
+ const MuonGM::RpcReadoutElement* EtaHighBorder_descriptor =
+ muonMgr->getRpcReadoutElement(EtaHighBorder_id);
+ EtaHighBorder_pos = EtaHighBorder_descriptor->stripPos(EtaHighBorder_id);
+
+ etaMin=EtaLowBorder_pos.eta();
+ etaMax=EtaHighBorder_pos.eta();
+ if (etaMin>etaMax){
+ double tmp=etaMin;
+ etaMin=etaMax;
+ etaMax=tmp;
+ }
+ return true;
+ }
+
+
+}
diff --git a/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1RPCRecRoiTool.h b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1RPCRecRoiTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..0becbc352a4b7866be4fe7f2a16f7c58eadbb3a9
--- /dev/null
+++ b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1RPCRecRoiTool.h
@@ -0,0 +1,60 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRIGT1RPCRECROITOOL_H
+#define TRIGT1RPCRECROITOOL_H
+
+#include "TrigT1MuonRecRoiTool/ITrigT1MuonRecRoiTool.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+
+namespace Muon{
+ class IMuonIdHelperSvc;
+}
+namespace MuonGM{
+ class MuonDetectorManager;
+}
+class RpcCablingCondData;
+class IRPCcablingSvc;
+
+namespace LVL1 {
+
+ class TrigT1RPCRecRoiTool: public extends<AthAlgTool, ITrigT1MuonRecRoiTool> {
+ public:
+ TrigT1RPCRecRoiTool(const std::string& type,
+ const std::string& name,
+ const IInterface* parent);
+ virtual ~TrigT1RPCRecRoiTool();
+ virtual StatusCode initialize() override;
+
+ virtual TrigT1MuonRecRoiData roiData (const unsigned int& roiWord) const override;
+
+ virtual void RoIsize(const unsigned int& roiWord,
+ double& etaMin, double& etaMax,
+ double& phiMin, double& phiMax) const override;
+
+ virtual bool dumpRoiMap(const std::string& filename) const override;
+
+ // RoI edges for Low-pt and High-pt confirm planes
+ bool etaDimLow (const TrigT1MuonRecRoiData& data,
+ double& etaMin, double& etaMax,
+ std::unique_ptr<const RpcCablingCondData> readCdo) const;
+ bool etaDimHigh(const TrigT1MuonRecRoiData& data,
+ double& etaMin, double& etaMax,
+ std::unique_ptr<const RpcCablingCondData> readCdo) const;
+
+ private:
+ BooleanProperty m_useRun3Config{this,"UseRun3Config",false,"use Run 3 config"};
+ BooleanProperty m_useConditionData{this,"UseConditionData",true,"use condition data"};
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
+ SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> m_DetectorManagerKey {this, "DetectorManagerKey","MuonDetectorManager","Key of input MuonDetectorManager condition data"};
+ SG::ReadCondHandleKey<RpcCablingCondData> m_readKey{this, "ReadKey", "RpcCablingCondData", "Key of RpcCablingCondData"};
+ const MuonGM::MuonDetectorManager* m_muonMgr{nullptr};
+ const IRPCcablingSvc* m_cabling{nullptr};
+
+ }; // end of TrigT1RPCRecRoiTool
+
+} // namespace LVL1
+
+
+#endif
diff --git a/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1TGCRecRoiTool.cxx b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1TGCRecRoiTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..6964ae3f507e95b4aa13a357fa1b1bfa8802372a
--- /dev/null
+++ b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1TGCRecRoiTool.cxx
@@ -0,0 +1,533 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrigT1TGCRecRoiTool.h"
+#include "TGCcablingInterface/TGCCablingBase.h"
+#include "TGCcablingInterface/ITGCcablingServerSvc.h"
+#include "TGCcablingInterface/ITGCcablingSvc.h"
+#include "TGCcablingInterface/TGCIdBase.h"
+#include "MuonReadoutGeometry/MuonDetectorManager.h"
+#include "MuonReadoutGeometry/TgcReadoutElement.h"
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
+#include <fstream>
+
+namespace LVL1 {
+
+ TrigT1TGCRecRoiTool::TrigT1TGCRecRoiTool( const std::string& type, const std::string& name, const IInterface* parent) : base_class(type,name,parent)
+ {
+ }
+
+ TrigT1TGCRecRoiTool::~TrigT1TGCRecRoiTool() {
+ }
+
+ StatusCode TrigT1TGCRecRoiTool::initialize() {
+ ATH_CHECK(m_DetectorManagerKey.initialize());
+ ATH_CHECK( detStore()->retrieve(m_muonMgr) );
+ ATH_CHECK( m_idHelperSvc.retrieve() );
+ ServiceHandle<ITGCcablingServerSvc> tgcCabGet ("TGCcablingServerSvc", name());
+ ATH_CHECK( tgcCabGet.retrieve() );
+ ATH_CHECK( tgcCabGet->giveCabling(m_cabling) );
+ m_isAtlas = tgcCabGet->isAtlas();
+ if(m_useRun3Config){
+ ATH_MSG_INFO("update to Run 3 bit mask");
+ updateBitMask( Run3 );
+ }
+ return StatusCode::SUCCESS;
+ }
+
+ TrigT1MuonRecRoiData TrigT1TGCRecRoiTool::roiData( const unsigned int & roiWord)const
+ {
+ TrigT1MuonRecRoiData data;
+ // get SLB parameters
+ TGCIdBase tgcIdBase;
+ unsigned int sectorID, roiNumber,r,phi;
+ int wireSLBId, block;
+
+ if (! getSLBparameters(roiWord,tgcIdBase,sectorID,roiNumber,r,phi,wireSLBId,block)){
+ ATH_MSG_ERROR( "TGCRecRoiSvc::reconstruct : BAD roiWord. "
+ << "Can not get SLBparameters "
+ << " roi word = " << std::hex << roiWord );
+ return data;
+ }
+ if (tgcIdBase.getSideType() == TGCIdBase::NoSideType) {
+ ATH_MSG_ERROR( "TGCRecRoiSvc::reconstruct : "
+ << "This roiWord is not of TGC" );
+ return data;
+ }
+
+
+ // get ASDout
+ int offset = 4;
+ std::unique_ptr<TGCIdBase> w_asdout =
+ getWireASDOut(tgcIdBase,sectorID,wireSLBId,block,phi,offset);
+ if (w_asdout == nullptr) {
+ ATH_MSG_WARNING( "TGCRecRoiSvc::reconstruct : "
+ << "Cannot get ASD out for Wire " );
+ return data;
+ }
+
+ std::unique_ptr<TGCIdBase> s_asdout =
+ getStripASDOut(tgcIdBase,sectorID,wireSLBId,block,phi,offset);
+ if (s_asdout == nullptr) {
+ ATH_MSG_WARNING( "TGCRecRoiSvc::reconstruct : "
+ << "Cannot get ASD out for Strip " );
+ return data;
+ }
+
+ // wire(eta)
+ Identifier wireId;
+ double w_eta,w_phi;
+ getWireInfo(w_eta,w_phi,wireId,std::move(w_asdout));
+
+ // strip(phi)
+ Identifier stripId;
+ double s_eta,s_phi;
+ getStripInfo(s_eta,s_phi,stripId,std::move(s_asdout));
+
+ ATH_MSG_DEBUG( "(eta,phi)=" <<" (" << w_eta <<","<< s_phi <<")" );
+ ATH_MSG_DEBUG( "channelId_eta=" << wireId << " channelId_phi=" << stripId );
+
+ data.set_eta(w_eta);
+ data.set_phi(s_phi);
+
+ double etaMin, etaMax, phiMin, phiMax;
+ RoIsize(roiWord,etaMin,etaMax,phiMin,phiMax);
+ data.set_etaMin(etaMin);
+ data.set_etaMax(etaMax);
+ data.set_phiMin(phiMin);
+ data.set_phiMax(phiMax);
+
+ return data;
+ }
+
+ bool TrigT1TGCRecRoiTool::getSLBparameters(const unsigned int & roiWord,
+ TGCIdBase & tgcIdBase,
+ unsigned int & sectorID,
+ unsigned int & roiNumber,
+ unsigned int & r,
+ unsigned int & phi,
+ int & wireSLBId,
+ int & block ) const
+ {
+ // init
+ tgcIdBase.setSideType( TGCIdBase::NoSideType );
+ tgcIdBase.setRegionType( TGCIdBase::NoRegionType );
+ sectorID = roiNumber = r = phi = 9999;
+ wireSLBId = block = 0;
+
+ // sysID, subSysID
+ unsigned int sysID = getBitMaskValue(&roiWord,SysIDMask());
+ unsigned int subSysID = getBitMaskValue(&roiWord,SubSysIDMask());
+
+ // trigger sector ID in the roiWord
+ unsigned int t_sectorID;
+
+ //
+ bool isOK = true;
+
+ if (sysID==1) { // Forward
+ tgcIdBase.setRegionType( TGCIdBase::Forward );
+ // trigger sector ID
+ t_sectorID = getBitMaskValue(&roiWord,ForwardSectorIDMask());
+ // roi number
+ roiNumber = getBitMaskValue(&roiWord,ForwardRoIMask());
+
+ // convert trigger sector ID to sector ID
+ if (m_patchForRoIWord) {
+ isOK = (t_sectorID<32) && (roiNumber<64);
+ } else {
+ isOK = (t_sectorID<24) && (roiNumber<64);
+ }
+
+ tgcIdBase.setSideType( (subSysID==1) ? TGCIdBase::Aside : TGCIdBase::Cside );
+ r = getBitMaskValue(&roiWord,ForwardRMask());
+ phi = getBitMaskValue(&roiWord,ForwardPhiMask());
+ wireSLBId = r/4;
+ block = r%4;
+ // convert trigger sector ID to sector ID
+ if (m_patchForRoIWord) {
+ int sec = (t_sectorID + 2 )%32;
+ int oct = sec/4;
+ sectorID = 3*oct + sec%3;
+ } else {
+ sectorID = (t_sectorID )%24;
+ }
+
+ } else if (sysID>1) {
+ // Endcap
+ tgcIdBase.setRegionType( TGCIdBase::Endcap );
+ // trigger sector ID
+ t_sectorID = getBitMaskValue(&roiWord,EndcapSectorIDMask());
+ // roi number
+ roiNumber = getBitMaskValue(&roiWord,EndcapRoIMask());
+
+ isOK = (t_sectorID<48) && (roiNumber<148);
+
+ tgcIdBase.setSideType( (subSysID==1) ? TGCIdBase::Aside : TGCIdBase::Cside );
+ r = getBitMaskValue(&roiWord,EndcapRMask());
+ phi = getBitMaskValue(&roiWord,EndcapPhiMask());
+ wireSLBId = (r+3)/4;
+ block = (r+3)%4;
+ // convert trigger sector ID to sector ID
+ if (m_patchForRoIWord) {
+ sectorID = (t_sectorID + 2 )%48;
+ } else {
+ sectorID = (t_sectorID )%48;
+ }
+
+ } else {
+ ATH_MSG_INFO( "Bad roiWord "
+ << " roi word = " << std::hex << roiWord
+ << " sysID = " << std::dec << sysID );
+ return false;
+ }
+
+ if (!isOK) {
+ ATH_MSG_INFO( "Bad roiWord "
+ << " roi word = " << std::hex << roiWord
+ << " sysID = " << std::dec << sysID
+ << " trigger sectorID = " << std::dec << t_sectorID
+ << " sectorID = " << std::dec << sectorID
+ << " roiNumber = " << std::dec << roiNumber );
+ return false;
+ } else {
+ ATH_MSG_DEBUG( " roi word = " << std::hex << roiWord
+ << " sysID = " << std::dec << sysID
+ << " trigger sectorID = " << std::dec << t_sectorID
+ << " sectorID = " << std::dec << sectorID
+ << " roiNumber = " << std::dec << roiNumber );
+ }
+ return true;
+
+ }
+
+ std::unique_ptr<TGCIdBase> TrigT1TGCRecRoiTool::getWireASDOut(TGCIdBase tgcIdBase,
+ unsigned int sectorID,
+ int wireSLBId,
+ int block,
+ int /* phi */,
+ int offset) const
+ {
+ // wire
+ TGCIdBase w_slbin(TGCIdBase::Channel);
+ w_slbin.setChannelIdType(TGCIdBase::SLBIn);
+ w_slbin.setSideType(tgcIdBase.getSideType());
+ w_slbin.setModuleType(TGCIdBase::WD);
+ w_slbin.setRegionType(tgcIdBase.getRegionType());
+ w_slbin.setSector(sectorID);
+ w_slbin.setId(wireSLBId);
+ w_slbin.setChannel(41+offset+8*block);
+
+ TGCCablingBase* tgcCabling = m_cabling->getTGCCabling();
+ std::unique_ptr<TGCIdBase> w_asdout( tgcCabling->getASDOutChannel (&w_slbin) );
+ return w_asdout;
+ }
+
+ std::unique_ptr<TGCIdBase> TrigT1TGCRecRoiTool::getStripASDOut(TGCIdBase tgcIdBase,
+ unsigned int sectorID,
+ int wireSLBId,
+ int block,
+ int phi,
+ int wireOffset,
+ int stripOffset) const
+ {
+
+ // If stripOffset is not given, wireOffset is used as stripOffset
+ if(stripOffset==DummyOffset) stripOffset = wireOffset;
+
+ // wire
+ TGCIdBase w_slbin(TGCIdBase::Channel);
+ w_slbin.setChannelIdType(TGCIdBase::SLBIn);
+ w_slbin.setSideType(tgcIdBase.getSideType());
+ w_slbin.setModuleType(TGCIdBase::WD);
+ w_slbin.setRegionType(tgcIdBase.getRegionType());
+ w_slbin.setSector(sectorID);
+ w_slbin.setId(wireSLBId);
+ w_slbin.setChannel(41+wireOffset+8*block);
+
+ TGCCablingBase* tgcCabling = m_cabling->getTGCCabling();
+ std::unique_ptr<TGCIdBase> w_asdout( tgcCabling->getASDOutChannel(&w_slbin) );
+
+ // strip
+ int stripSLBId = w_asdout->getChamber();
+
+ TGCIdBase s_slbin(TGCIdBase::Channel);
+ s_slbin.setChannelIdType(TGCIdBase::SLBIn);
+ s_slbin.setSideType(tgcIdBase.getSideType());
+ s_slbin.setModuleType(TGCIdBase::SD);
+ s_slbin.setRegionType(tgcIdBase.getRegionType());
+ s_slbin.setSector(sectorID);
+ s_slbin.setId(stripSLBId);
+ s_slbin.setChannel(41+stripOffset+8*phi);
+
+ std::unique_ptr<TGCIdBase> s_asdout( tgcCabling->getASDOutChannel (&s_slbin) );
+ return s_asdout;
+ }
+
+ void TrigT1TGCRecRoiTool::getWireInfo(double& w_eta, double& w_phi,
+ Identifier & wireId,
+ std::unique_ptr<TGCIdBase> w_asdout,
+ EdgeType edge) const {
+
+ // init
+ wireId=Identifier(0);
+ auto w_pos=Amg::Vector3D(0,0,0);
+ //
+ int subsystemNumber = (w_asdout->isAside())? 1 : -1;
+ int wireOrStrip = (w_asdout->isStrip())? 1 : 0;
+ bool status = m_cabling->getOfflineIDfromOnlineID (wireId,
+ subsystemNumber,
+ w_asdout->getOctant(),
+ w_asdout->getSectorModule(),
+ w_asdout->getLayer(),
+ w_asdout->getChamber(),
+ wireOrStrip,
+ w_asdout->getChannel());
+ if (status==false) return;
+
+ const MuonGM::MuonDetectorManager* muonMgr = m_muonMgr;
+ if(m_useConditionData){
+ SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
+ muonMgr = DetectorManagerHandle.cptr();
+ if(muonMgr==nullptr){
+ ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object. Use the one from DetectorStore");
+ muonMgr = m_muonMgr;
+ }
+ }
+
+ const MuonGM::TgcReadoutElement* tgcwire
+ = muonMgr->getTgcReadoutElement(m_idHelperSvc->tgcIdHelper().parentID(wireId));
+ w_pos = tgcwire -> channelPos(wireId);
+
+ // If edge correction is needed,
+ // the half length in the r direction is added (subtracted) for the upper (lower) edge.
+ if(edge==UpperREdge || edge==LowerREdge) {
+ int gasGap = m_idHelperSvc->tgcIdHelper().gasGap(wireId);
+ int channel = m_idHelperSvc->tgcIdHelper().channel(wireId);
+ double halfLength = tgcwire->gangLength(gasGap, channel)/2.;
+ double r = w_pos.perp();
+ double phi = w_pos.phi();
+ r += halfLength*(edge==UpperREdge ? +1. : -1.);
+ w_pos[Trk::locX] = r*cos(phi);
+ w_pos[Trk::locY] = r*sin(phi);
+ }
+ w_eta = w_pos.eta();
+ w_phi = w_pos.phi();
+ }
+
+ void TrigT1TGCRecRoiTool::getStripInfo(double& s_eta,double& s_phi,
+ Identifier & stripId,
+ std::unique_ptr<TGCIdBase> s_asdout,
+ EdgeType edge) const {
+
+
+ // init
+ auto s_pos = Amg::Vector3D(0,0,0);
+ stripId=Identifier(0);
+ //
+ int subsystemNumber = (s_asdout->isAside())? 1 : -1;
+ int wireOrStrip = (s_asdout->isStrip())? 1 : 0;
+ bool status = m_cabling->getOfflineIDfromOnlineID (stripId,
+ subsystemNumber,
+ s_asdout->getOctant(),
+ s_asdout->getSectorModule(),
+ s_asdout->getLayer(),
+ s_asdout->getChamber(),
+ wireOrStrip,
+ s_asdout->getChannel());
+ if (status==false) return;
+
+ const MuonGM::MuonDetectorManager* muonMgr = m_muonMgr;
+ if(m_useConditionData){
+ SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
+ muonMgr = DetectorManagerHandle.cptr();
+ if(muonMgr==nullptr){
+ ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object. Use the one from DetectorStore");
+ muonMgr = m_muonMgr;
+ }
+ }
+
+ const MuonGM::TgcReadoutElement* tgcstrip
+ = muonMgr->getTgcReadoutElement(m_idHelperSvc->tgcIdHelper().parentID(stripId));
+ s_pos = tgcstrip -> channelPos(stripId);
+
+ // If edge correction is needed,
+ // the half width in the phi direction is added (subtracted) for the upper (lower) edge.
+ if(edge==UpperPhiEdge || edge==LowerPhiEdge) {
+ int gasGap = m_idHelperSvc->tgcIdHelper().gasGap(stripId);
+ int channel = m_idHelperSvc->tgcIdHelper().channel(stripId);
+ double shortWidth = tgcstrip->stripShortWidth(gasGap, channel);
+ double longWidth = tgcstrip->stripLongWidth(gasGap, channel);
+ double halfWidth = (shortWidth + longWidth)/4.;
+ double r = s_pos.perp();
+ double phi = s_pos.phi();
+ double dPhi = atan2(halfWidth, r);
+ phi += dPhi*(edge==UpperPhiEdge ? +1. : -1.);
+ s_pos[Trk::locX] = r*cos(phi);
+ s_pos[Trk::locY] = r*sin(phi);
+ }
+ s_eta = s_pos.eta();
+ s_phi = s_pos.phi();
+ }
+
+
+
+ void TrigT1TGCRecRoiTool::RoIsize(const unsigned int & roiWord,
+ double & etaMin, double & etaMax,
+ double & phiMin, double & phiMax) const
+ {
+ // init
+ etaMin=etaMax=phiMin=phiMax=0;
+ //
+ TGCIdBase tgcIdBase;
+ unsigned int sectorID, roiNumber,r,phi;
+ int wireSLBId, block;
+ double w_eta,w_phi,s_eta,s_phi;
+ Identifier wireId, stripId;
+ // get wire/strip positions of both edges
+ for(int i=0; i<2; i++) {
+ // get edge, the range is from 1 to 8. One subsector consists of 8 (or less) wire channels and 8 strip channels
+ int offset=1+i*7;
+ if (! getSLBparameters(roiWord,tgcIdBase,sectorID,roiNumber,r,phi,wireSLBId,block)) {
+ ATH_MSG_ERROR( "TGCRecRoiSvc::RoIsize : "
+ << "BAD roiWord " );
+ return;
+ }
+
+ if (tgcIdBase.getSideType() == TGCIdBase::NoSideType) {
+ ATH_MSG_ERROR( "TGCRecRoiSvc::RoIsize : "
+ << "This roiWord is not of TGC" );
+ return;
+ }
+
+ int wireOffset = offset;
+ if(tgcIdBase.getRegionType()==TGCIdBase::Endcap) {
+ if(roiNumber<4) { // Outermost ROI (|eta|~1.04)
+ if(wireOffset==1) wireOffset = 3; // The largest R channel
+ } else if(roiNumber>=144) { // Innermost ROI (|eta|~1.91)
+ if(wireOffset==8) wireOffset = 4; // The smallest R channel
+ }
+ } else if(tgcIdBase.getRegionType()==TGCIdBase::Forward) {
+ if(roiNumber<4) { // Outermost ROI (|eta|~1.93)
+ if(wireOffset==1) wireOffset = 4; // The largest R channel
+ } else if(roiNumber>=60) { // Innermost ROI (|eta|~2.40)
+ if(wireOffset==8) wireOffset = 5; // The smallest R channel
+ }
+ }
+
+ std::unique_ptr<TGCIdBase> w_asdout =
+ getWireASDOut(tgcIdBase,sectorID,wireSLBId,block,phi,wireOffset);
+
+ std::unique_ptr<TGCIdBase> s_asdout =
+ getStripASDOut(tgcIdBase,sectorID,wireSLBId,block,phi,wireOffset,offset);
+
+ if (w_asdout!=nullptr) {
+ getWireInfo(w_eta,w_phi,wireId,std::move(w_asdout), (i==0 ? UpperREdge : LowerREdge));
+ if (i==0) etaMin=w_eta;
+ else etaMax=w_eta;
+ }
+
+ if (s_asdout!=nullptr) {
+ EdgeType stripEdge = NonEdge;
+ // Logic to know the relation between phi and strip channel directions
+ if(!m_isAtlas) { // 8-fold
+ stripEdge = ((i==0) ^ (sectorID%2==0)) ? LowerPhiEdge : UpperPhiEdge;
+ } else { // 12-fold
+ stripEdge = ((i==0) ^ ((s_asdout->isAside()) ^ (!(s_asdout->isBackward())))) ? LowerPhiEdge : UpperPhiEdge;
+ }
+
+ getStripInfo(s_eta,s_phi,stripId,std::move(s_asdout),stripEdge);
+ if (i==0) phiMin=s_phi;
+ else phiMax=s_phi;
+ }
+ }
+
+ if (etaMin>etaMax){
+ // SWAP(etaMin, etaMax);
+ double temp=etaMin; etaMin=etaMax; etaMax=temp;
+ }
+ if (phiMin>phiMax){
+ // SWAP(phiMin, phiMax);
+ double temp=phiMin; phiMin=phiMax; phiMax=temp;
+ }
+
+ if(phiMin<-3. && phiMax>3.) {
+ phiMin += 2.*M_PI;
+ // SWAP(phiMin, phiMax);
+ double temp=phiMin; phiMin=phiMax; phiMax=temp;
+ }
+ }
+
+ bool TrigT1TGCRecRoiTool::dumpRoiMap(const std::string& filename) const
+ {
+ const unsigned int maxSubsystem = 2;
+ const unsigned int maxTriggerSectorEndcap = 48;
+ const unsigned int maxTriggerSectorForward = 24;
+
+ const unsigned int maxEndcapR = 37;
+ const unsigned int maxForwardR = 16;
+
+ const unsigned int maxEndcapPhi = 4;
+ const unsigned int maxForwardPhi = 4;
+
+ std::ofstream roi_map;
+ roi_map.open(filename.c_str(), std::ios::out );
+ if(!roi_map){
+ ATH_MSG_WARNING( "Unable to open ROI_Mapping file!" );
+ } else {
+ roi_map <<"Endcap"<< std::endl;
+ roi_map <<"# side sector roi etaMin etaMax phiMin phiMax"<< std::endl;
+ roi_map <<"# ------------------------------------------------------------------------"<< std::endl;
+ for(unsigned int side=0;side < maxSubsystem; side++){
+ for(unsigned int sector=0;sector < maxTriggerSectorEndcap; sector++){
+ for (unsigned int r=0; r<maxEndcapR; r++){
+ for (unsigned int phi=0; phi<maxEndcapPhi; phi++){
+ int roi = (r<<2) + phi;
+ int sectorAddress = sector<<1;
+ sectorAddress |= 0x80;
+ sectorAddress |= (side==0)?(0x1):(0x0);
+ unsigned long int roiWord = (m_useRun3Config) ? (roi+(sectorAddress<<21)) : ((roi<<2)+(sectorAddress<<14));
+ auto data = roiData(roiWord);
+ roi_map << std::setw(8) << side << " "
+ << std::setw(8) << sector << " "
+ << std::setw(8) << roi << " "
+ << std::setw(12) << data.etaMin() << " "
+ << std::setw(12) << data.etaMax() << " "
+ << std::setw(12) << data.phiMin() << " "
+ << std::setw(12) << data.phiMax() << std::endl;
+ }
+ }
+ }
+ }
+ roi_map <<"Forward"<< std::endl;
+ roi_map <<"# side sector roi etaMin etaMax phiMin phiMax"<< std::endl;
+ roi_map <<"# ------------------------------------------------------------------------"<< std::endl;
+ for(unsigned int side=0;side < maxSubsystem; side++){
+ for(unsigned int sector=0;sector < maxTriggerSectorForward; sector++){
+ for (unsigned int r=0; r<maxForwardR; r++){
+ for (unsigned int phi=0; phi<maxForwardPhi; phi++){
+ int roi = (r<<2) + phi;
+ int sectorAddress = sector<<1;
+ sectorAddress |= 0x80;
+ sectorAddress |= (side==0)?(0x1):(0x0);
+ unsigned long int roiWord = (m_useRun3Config) ? (roi+(sectorAddress<<21)) : ((roi<<2)+(sectorAddress<<14));
+ auto data = roiData(roiWord);
+ roi_map << std::setw(8) << side << " "
+ << std::setw(8) << sector << " "
+ << std::setw(8) << roi << " "
+ << std::setw(12) << data.etaMin() << " "
+ << std::setw(12) << data.etaMax() << " "
+ << std::setw(12) << data.phiMin() << " "
+ << std::setw(12) << data.phiMax() << std::endl;
+ }
+ }
+ }
+ }
+ roi_map.close();
+ }
+ return true;
+ }
+
+
+}
diff --git a/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1TGCRecRoiTool.h b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1TGCRecRoiTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..7a30990d09c5d74d2f4c5935505bea23a77545a6
--- /dev/null
+++ b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/TrigT1TGCRecRoiTool.h
@@ -0,0 +1,96 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRIGT1TGCRECROITOOL_H
+#define TRIGT1TGCRECROITOOL_H
+
+#include "TrigT1MuonRecRoiTool/ITrigT1MuonRecRoiTool.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+
+class TGCIdBase;
+class Identifier;
+class ITGCcablingSvc;
+namespace Muon{
+ class IMuonIdHelperSvc;
+}
+namespace MuonGM{
+ class MuonDetectorManager;
+}
+
+namespace LVL1 {
+
+ class TrigT1TGCRecRoiTool: public extends<AthAlgTool, ITrigT1MuonRecRoiTool> {
+ public:
+ TrigT1TGCRecRoiTool(const std::string& type,
+ const std::string& name,
+ const IInterface* parent);
+ virtual ~TrigT1TGCRecRoiTool();
+ virtual StatusCode initialize() override;
+
+ virtual TrigT1MuonRecRoiData roiData(const unsigned int& roiWord ) const override;
+
+ virtual void RoIsize(const unsigned int& roiWord,
+ double& etaMin, double& etaMax,
+ double& phiMin, double& phiMax) const override;
+
+ virtual bool dumpRoiMap(const std::string& filename) const override;
+
+ private:
+
+ enum EdgeType {NonEdge=-1,
+ LowerREdge,
+ UpperREdge,
+ LowerPhiEdge,
+ UpperPhiEdge};
+ enum DummyOffset {DummyOffset=-9999};
+
+ bool getSLBparameters(const unsigned int & roIWord,
+ TGCIdBase & tgcIdBase,
+ unsigned int & sectorID,
+ unsigned int & roiNumber,
+ unsigned int & r,
+ unsigned int & phi,
+ int & wireSLBId,
+ int & block ) const;
+
+ std::unique_ptr<TGCIdBase> getWireASDOut(TGCIdBase tgcIdBase,
+ unsigned int sectorID,
+ int wireSLBId,
+ int block,
+ int phi ,
+ int offset) const;
+
+ std::unique_ptr<TGCIdBase> getStripASDOut(TGCIdBase tgcIdBase,
+ unsigned int sectorID,
+ int wireSLBId,
+ int block,
+ int phi,
+ int wireOffset,
+ int stripOffset=DummyOffset) const;
+
+ void getWireInfo(double& eta, double& phi,
+ Identifier & wireId,
+ std::unique_ptr<TGCIdBase> w_asdout,
+ EdgeType edge=NonEdge) const;
+
+ void getStripInfo(double& eta, double& phi,
+ Identifier & stripId,
+ std::unique_ptr<TGCIdBase> s_asdout,
+ EdgeType edge=NonEdge) const;
+
+
+ BooleanProperty m_useRun3Config{this,"UseRun3Config",false,"use Run 3 config"};
+ BooleanProperty m_patchForRoIWord{this,"PatchForRoIWord",false,"apply a patch to RoI word"};
+ BooleanProperty m_useConditionData{this,"UseConditionData",true,"use condition data"};
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
+ SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> m_DetectorManagerKey {this, "DetectorManagerKey","MuonDetectorManager","Key of input MuonDetectorManager condition data"};
+ const MuonGM::MuonDetectorManager* m_muonMgr{nullptr};
+ const ITGCcablingSvc* m_cabling{nullptr};
+ bool m_isAtlas{true};
+
+ }; // end of TrigT1TGCRecRoiTool
+} // namespace LVL1
+
+
+#endif
diff --git a/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/components/TrigT1MuonRecRoiTool_entries.cxx b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/components/TrigT1MuonRecRoiTool_entries.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..be7e2ce2085bb87466939c30bf535dc6600dafa4
--- /dev/null
+++ b/Trigger/TrigT1/TrigT1MuonRecRoiTool/src/components/TrigT1MuonRecRoiTool_entries.cxx
@@ -0,0 +1,10 @@
+#include "../TrigT1TGCRecRoiTool.h"
+#include "../TrigT1RPCRecRoiTool.h"
+#include "RPC_CondCabling/RpcCablingCondData.h"
+#include "MuonReadoutGeometry/MuonDetectorManager.h"
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
+
+DECLARE_COMPONENT( LVL1::TrigT1TGCRecRoiTool )
+DECLARE_COMPONENT( LVL1::TrigT1RPCRecRoiTool )
+
+