This is the algorithm that convert TGCRdo To TGCPrepdata as a tool. More...

#include <TgcRdoToPrepDataToolMT.h>

Inheritance diagram for Muon::TgcRdoToPrepDataToolMT:

Classes
struct	CablingInfo
struct	State

Public Member Functions
virtual	~TgcRdoToPrepDataToolMT ()=default
	Destructor.
virtual StatusCode	initialize () override
	Standard AthAlgTool initialize method.
virtual StatusCode	finalize () override
	Standard AthAlgTool finalize method.
virtual StatusCode	decode (const EventContext &ctx, const std::vector< IdentifierHash > &idVect) const override
	Decode RDO to PRD A vector of IdentifierHash are passed in, and the data corresponding to this list (i.e.
virtual StatusCode	provideEmptyContainer (const EventContext &ctx) const override

Private Types
enum	SUB_DETCTOR_ID { ASIDE = 103 , CSIDE = 104 }
	Sub detector IDs are 103 and 104 for TGC A side and C side, respectively. More...
enum	BIT_POS { BIT_POS_ASD_SIZE = 16 , BIT_POS_NUM_ASD = 2 , BIT_POS_INPUT_SIZE = BIT_POS_ASD_SIZE*BIT_POS_NUM_ASD , BIT_POS_OFFSET_LARGE_R = BIT_POS_ASD_SIZE , BIT_POS_OFFSET_LARGE_PHIFOR_A_FWD_C_BWD = BIT_POS_OFFSET_LARGE_R , BIT_POS_A_INPUT_ORIGIN = 73 , BIT_POS_B_INPUT_ORIGIN = 109 , BIT_POS_C_INPUT_ORIGIN = 149 , BIT_POS_D_INPUT_ORIGIN = 193 , BIT_POS_B_INPUT_LARGE_R_CH15 = BIT_POS_B_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 15 , BIT_POS_A_INPUT_LARGE_R_CH08 = BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 8 , BIT_POS_B_INPUT_LARGE_R_CH07 = BIT_POS_B_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 7 , BIT_POS_A_INPUT_LARGE_R_CH00 = BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R , BIT_POS_B_INPUT_SMALL_R_CH15 = BIT_POS_B_INPUT_ORIGIN - 15 , BIT_POS_A_INPUT_SMALL_R_CH08 = BIT_POS_A_INPUT_ORIGIN - 8 , BIT_POS_B_INPUT_SMALL_R_CH07 = BIT_POS_B_INPUT_ORIGIN - 7 , BIT_POS_A_INPUT_SMALL_R_CH00 = BIT_POS_A_INPUT_ORIGIN , BIT_POS_B_INPUT_SMALL_R_CH05 = BIT_POS_B_INPUT_ORIGIN - 5 , BIT_POS_A_INPUT_SMALL_R_CH03 = BIT_POS_A_INPUT_ORIGIN - 3 , BIT_POS_B_INPUT_LARGE_R_CH12 = BIT_POS_B_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 12 , BIT_POS_A_INPUT_SMALL_R_CH04 = BIT_POS_A_INPUT_ORIGIN - 4 , BIT_POS_A_INPUT_LARGE_R_CH12 = BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 12 , BIT_POS_A_INPUT_LARGE_R_CH04 = BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 4 , BIT_POS_A_INPUT_SMALL_R_CH12 = BIT_POS_A_INPUT_ORIGIN - 12 , BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH15 = BIT_POS_B_INPUT_LARGE_R_CH15 , BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH08 = BIT_POS_A_INPUT_LARGE_R_CH08 , BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH07 = BIT_POS_B_INPUT_LARGE_R_CH07 , BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH00 = BIT_POS_A_INPUT_LARGE_R_CH00 , BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH15 = BIT_POS_B_INPUT_SMALL_R_CH15 , BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH08 = BIT_POS_A_INPUT_SMALL_R_CH08 , BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH07 = BIT_POS_B_INPUT_SMALL_R_CH07 , BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH00 = BIT_POS_A_INPUT_SMALL_R_CH00 , BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH12 = BIT_POS_A_INPUT_LARGE_R_CH12 , BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH04 = BIT_POS_A_INPUT_LARGE_R_CH04 , BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH12 = BIT_POS_A_INPUT_SMALL_R_CH12 , BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH04 = BIT_POS_A_INPUT_SMALL_R_CH04 }
	SLB bit position /code Large R <--> Small R Large phi <--> Small phi for A side forward chambers and C side backward chambers Small phi <--> Large phi for A side backward chambers and C side forward chambers A-input : 40 - 75, 42 - 73 are valid. More...
enum	MAP_SIZE { WT_MAP_SIZE = 3BIT_POS_INPUT_SIZE , ST_MAP_SIZE = 2BIT_POS_INPUT_SIZE , SD_MAP_SIZE = 2BIT_POS_INPUT_SIZE , WD_MAP_SIZE = 2BIT_POS_INPUT_SIZE }
	Bit map sizes. More...

Private Member Functions
template<class ContType, class CollType>
StatusCode	transferData (ContType &container, std::vector< std::unique_ptr< CollType > > &&coll) const
StatusCode	setupState (const EventContext &ctx, State &state) const
void	selectDecoder (State &state, const TgcRawData &rd, const TgcRdo *rdoColl) const
	Select decoder based on RDO type (Hit or Coincidence (Tracklet, HiPt and SL))
StatusCode	decodeHits (State &state, const TgcRawData &rd) const
	Decode RDO's of Hit.
StatusCode	decodeTracklet (State &state, const TgcRawData &rd) const
	Decode RDO's of Tracklet.
StatusCode	decodeTrackletEIFI (State &state, const TgcRawData &rd) const
	Decode RDO's of Tracklet EIFI.
StatusCode	decodeHiPt (State &state, const TgcRawData &rd) const
	Decode RDO's of HiPt.
StatusCode	decodeInner (State &state, const TgcRawData &rd) const
	Decode RDO's of Inner.
StatusCode	decodeSL (State &state, const TgcRawData &rd, const TgcRdo *rdoColl) const
	Decode RDO's of SectorLogic.
bool	isOfflineIdOKForTgcReadoutElement (const MuonGM::TgcReadoutElement *descriptor, const Identifier channelId) const
	Check offline ID is OK for TgcReadoutElement.
bool	getTrackletInfo (const TgcRawData &rd, int &tmp_slbId, int &tmp_subMatrix, int &tmp_position) const
	Retrieve slbId, subMatrix and position from Tracklet RDO.
bool	isIncludedInChamberBoundary (const TgcRawData &rd) const
	Check SL RDO is at the chamber boundary.
void	getBitPosInWire (const TgcRawData &rd, const int DeltaBeforeConvert, std::array< int, 4 > &bitpos_i, std::array< int, 4 > &slbchannel_i, std::array< int, 4 > &slbId_in, std::array< int, 4 > &sbLoc_in, int &sswId_i, const std::array< int, 2 > &bitpos_o, std::array< int, 2 > &slbchannel_o, const int slbId_o) const
	Get bitPos etc of TGC1 wire for HiPt.
void	getBitPosInStrip (const TgcRawData &rd, const int DeltaBeforeConvert, std::array< int, 4 > &bitpos_i, std::array< int, 4 > &slbchannel_i, int &sbLoc_i, int &sswId_i, const std::array< int, 2 > &bitpos_o, std::array< int, 2 > &slbchannel_o) const
	Get bitPos etc of TGC1 strip for HiPt.
void	getBitPosWire (const TgcRawData &rd, const int hitId_w, const int sub_w, int &subMatrix_w, std::array< int, 3 > &bitpos_w) const
	Get bitPos etc of wire for SL.
bool	getSLWireGeometry (const std::array< Identifier, 3 > &channelId_wire, double &width_wire, double &r_wire, double &z_wire) const
	Get wire geometry (width, r, z) for SL.
bool	getSLStripGeometry (const std::array< Identifier, 3 > &channelId_strip, const bool isBackWard, const bool isAside, double &width_strip, double &theta_strip) const
	Get strip geometry (width, theta) for SL.
bool	getPosAndIdWireOut (const std::array< const MuonGM::TgcReadoutElement *, 2 > &descriptor_o, const std::array< Identifier, 2 > &channelIdOut, const std::array< int, 2 > &gasGap_o, const std::array< int, 2 > &channel_o, double &width_o, double &hit_position_o, Amg::Vector2D &tmp_hitPos_o, Identifier &channelIdOut_tmp) const
	Get position and offline ID of TGC3 wire for HiPt.
bool	getPosAndIdStripOut (const std::array< const MuonGM::TgcReadoutElement *, 2 > &descriptor_o, const std::array< Identifier, 2 > &channelIdOut, const std::array< int, 2 > &gasGap_o, const std::array< int, 2 > &channel_o, double &width_o, double &hit_position_o, Amg::Vector2D &tmp_hitPos_o, Identifier &channelIdOut_tmp, const bool isBackward, const bool isAside) const
	Get position and offline ID of TGC3 strip for HiPt.
bool	getPosAndIdWireIn (const std::array< const MuonGM::TgcReadoutElement *, 4 > &descriptor_i, const std::array< Identifier, 4 > &channelIdIn, const std::array< int, 4 > &gasGap_i, const std::array< int, 4 > &channel_i, double &width_i, double &hit_position_i, Amg::Vector2D &tmp_hitPos_i, Identifier &channelIdIn_tmp) const
	Get position and offline ID of TGC1 wire for HiPt.
bool	getPosAndIdStripIn (const std::array< const MuonGM::TgcReadoutElement *, 4 > &descriptor_i, const std::array< Identifier, 4 > &channelIdIn, const std::array< int, 4 > &gasGap_i, const std::array< int, 4 > &channel_i, double &width_i, double &hit_position_i, Amg::Vector2D &tmp_hitPos_i, Identifier &channelIdIn_tmp, const bool isBackward, const bool isAside) const
	Get position and offline ID of TGC1 strip for HiPt.
bool	getHiPtIds (const TgcRawData &rd, int &sswId_o, int &sbLoc_o, int &slbId_o) const
	Get ReadoutID of HiPt from RDOHighPtID.
bool	getSLIds (const bool isStrip, const TgcRawData &rd, std::array< Identifier, 3 > &channelId, int &index, int &chip, int &hitId, int &sub, int &sswId, int &sbLoc, int &subMatrix, std::array< int, 3 > &bitpos, const bool isBoundary=false, const TgcRdo *rdoColl=0, const int index_w=-1, const int chip_w=-1, const int hitId_w=-1, const int sub_w=-1) const
	Get ReadoutID of SL from RDO.
bool	getSbLocOfEndcapStripBoundaryFromHiPt (const TgcRawData &rd, int &sbLoc, const TgcRdo *rdoColl, const int index_w, const int chip_w, const int hitId_w, const int sub_w) const
	Get strip sbLoc of Endcap chamber boundary from HiPt Strip.
bool	getSbLocOfEndcapStripBoundaryFromTracklet (const TgcRawData &rd, int &sbLoc, const TgcRdo *rdoColl, const int index_w, const int chip_w, const int hitId_w, const int sub_w) const
	Get strip sbLoc of Endcap chamber boundary from Tracklet Strip.
const CablingInfo *	getCabling () const
StatusCode	decode (const EventContext &ctx, const std::vector< uint32_t > &robIds) const override
	Avoid compiler warning.
void	convertToRun2 (const TgcRawData *rd, uint16_t &newrodId, uint16_t &newsector) const
void	convertToRun2 (const TgcRawData &rd, uint16_t &newrodId, uint16_t &newsector) const

Static Private Member Functions
static int	getbitpos (int channel, TgcRawData::SlbType slbType)
	Get bitpos from channel and SlbType.
static int	getchannel (int bitpos, TgcRawData::SlbType slbType)
	Get channel from bitpos and SlbType.
static bool	getRfromEtaZ (const double eta, const double z, double &r)
	Get r from eta and z.
static bool	getEtafromRZ (const double r, const double z, double &eta)
	Get eta from r and z.
static bool	isAlreadyConverted (const std::vector< const TgcRdo * > &decodedRdoCollVec, const std::vector< const TgcRdo * > &rdoCollVec, const TgcRdo *rdoColl)
	Check the rdo is already converted or not.
static bool	isRequested (const std::vector< IdentifierHash > &requestedIdHashVect, IdentifierHash tgcHashId)
	Check the IdHash is already requested or not.
static int	getRoiRow (const TgcRawData &rd)
	Get ROI row from RDO.
static void	getBitPosOutWire (const TgcRawData &rd, int &slbsubMatrix, std::array< int, 2 > &bitpos_o)
	Get bitPos etc of TGC3 wire for HiPt.
static void	getBitPosOutStrip (const TgcRawData &rd, int &slbsubMatrix, std::array< int, 2 > &bitpos_o)
	Get bitPos etc of TGC3 strip for HiPt.
static void	getBitPosStrip (const int hitId_s, const int sub_s, int &subMatrix_s, std::array< int, 3 > &bitpos_s)
	Get bitPos etc of strip for SL.
static int	getDeltaBeforeConvert (const TgcRawData &rd)
	Get delta (sagitta) before converion for HiPt.
static bool	isBackwardBW (const TgcRawData &rd)
	Check if a chamber in BigWheel is a backward chamber or a forward chamber.
static void	getEndcapStripCandidateTrackletIds (const int roi, int &trackletIdStripFirst, int &trackletIdStripSecond, int &trackletIdStripThird)
	Get trackletIds of three Tracklet Strip candidates in the Endcap boudary.
static const Amg::Vector2D *	getSLLocalPosition (const MuonGM::TgcReadoutElement *readout, const Identifier, const double eta, const double phi)
	Get SL local position.

Private Attributes
CxxUtils::CachedValue< CablingInfo >	m_cablingInfo
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
Gaudi::Property< std::string >	m_outputCollectionLocation {this, "OutputCollection", "TGC_Measurements"}
	TgcPrepRawData container key for current BC.
Gaudi::Property< std::string >	m_outputCoinCollectionLocation {this, "OutputCoinCollection", "TrigT1CoinDataCollection"}
	TgcCoinData container key for current BC.
Gaudi::Property< int >	m_tgcOffset {this, "TGCHashIdOffset", 26000}
	Identifier hash offset.
Gaudi::Property< bool >	m_decodeData {this, "DecodeData", true}
	Switch for the decoding of TGC RDO into TgcPrepData.
Gaudi::Property< bool >	m_fillCoinData {this, "FillCoinData", true}
	Switch for the coincince decoding.
Gaudi::Property< bool >	m_show_warning_level_invalid_A09_SSW6_hit {this, "show_warning_level_invalid_A09_SSW6_hit", false}
	Switch for error message disabling on one invalid channel in sector A09 seen in 2008 data, at least run 79772 - 91800.
Gaudi::Property< bool >	m_dropPrdsWithZeroWidth {this, "dropPrdsWithZeroWidth", true}
	Flag for dropping PRD's with zero widths.
std::atomic< long >	m_nHitRDOs {0}
	long to count the numbers of RDOs and PRDs
std::atomic< long >	m_nHitPRDs {0}
std::atomic< long >	m_nTrackletRDOs {0}
std::atomic< long >	m_nTrackletPRDs {0}
std::atomic< long >	m_nTrackletEIFIRDOs {0}
std::atomic< long >	m_nTrackletEIFIPRDs {0}
std::atomic< long >	m_nHiPtRDOs {0}
std::atomic< long >	m_nHiPtPRDs {0}
std::atomic< long >	m_nSLRDOs {0}
std::atomic< long >	m_nSLPRDs {0}
SG::ReadHandleKey< TgcRdoContainer >	m_rdoContainerKey {this, "RDOContainer", "TGCRDO" ,"TgcRdoContainer to retrieve"}
SG::WriteHandleKeyArray< Muon::TgcCoinDataContainer >	m_outputCoinKeys {this, "outputCoinKey", {}}
SG::WriteHandleKeyArray< Muon::TgcPrepDataContainer >	m_outputprepdataKeys {this, "prepDataKeys", {}}
SG::WriteHandleKey< xAOD::TgcStripContainer >	m_xAODKey {this, "xAODKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}
TgcPrdUpdateHandles	m_prdContainerCacheKeys {this, "UpdateKeysPrd", {}}
	Keys for the PRD cache containers, 4 needed for different BC.
TgcCoinUpdateHandles	m_coinContainerCacheKeys {this, "UpdateKeysCoin", {}}
	Keys for the Coin cache containers, 3 needed for different BC.
Gaudi::Property< std::string >	m_prdContainerCacheKeyStr {this, "PrdCacheString", "", "Prefix for names of PRD cache collections"}
Gaudi::Property< std::string >	m_coinContainerCacheKeyStr {this, "CoinCacheString", "", "Prefix for names of Coin cache collections"}

Static Private Attributes
static constexpr int	NBC_HIT = 3
	The number of recorded Bunch Crossings (BCs) FOR HITS is 3 (Previous, Current, and Next BCs)
static constexpr int	NBC_TRIG = 4
static const double	s_cutDropPrdsWithZeroWidth = 0.1
	Cut value for zero widths.

Detailed Description

This is the algorithm that convert TGCRdo To TGCPrepdata as a tool.

Author: Susumu Oda Susum.nosp@m.u.Od.nosp@m.a@cer.nosp@m.n.ch; Edward Moyse

This class was developed by Takashi Kubota.

Definition at line 53 of file TgcRdoToPrepDataToolMT.h.

Member Enumeration Documentation

◆ BIT_POS

enum Muon::TgcRdoToPrepDataToolMT::BIT_POS

private

SLB bit position /code Large R <--> Small R Large phi <--> Small phi for A side forward chambers and C side backward chambers Small phi <--> Large phi for A side backward chambers and C side forward chambers A-input : 40 - 75, 42 - 73 are valid.

B-input : 76 - 111, 78 - 109 are valid. C-input : 112 - 155, 118 - 149 are valid. D-input : 156 - 199, 162 - 193 are valid.

Channel in this code : Large R 15 14 13 12 11 ... 0 15 ... 3 2 1 0 Small R (it is better to be reverted to avoid confusion) ASD channel order : 15 ... ... 0 (there are shifts dependent on position) PS board channel : 0 1 2 3 4 ... 15 16 ... 28 29 30 31 A-Input : 40 41 42 43 44 45 46 ... 57 58 ... 70 71 72 73 74 75 B-Input : 76 77 78 79 80 81 82 ... 93 94 ... 106 107 108 109 110 111 C-Input : 112 113 114 115 116 117 118 119 120 121 122 ... 133 134 ... 146 147 148 149 150 151 152 153 154 155 D-Input : 156 157 158 159 160 161 162 163 164 165 166 ... 177 178 ... 190 191 192 193 194 195 196 197 198 199 /endcode

Enumerator
BIT_POS_ASD_SIZE
BIT_POS_NUM_ASD
BIT_POS_INPUT_SIZE
BIT_POS_OFFSET_LARGE_R
BIT_POS_OFFSET_LARGE_PHIFOR_A_FWD_C_BWD
BIT_POS_A_INPUT_ORIGIN
BIT_POS_B_INPUT_ORIGIN
BIT_POS_C_INPUT_ORIGIN
BIT_POS_D_INPUT_ORIGIN
BIT_POS_B_INPUT_LARGE_R_CH15
BIT_POS_A_INPUT_LARGE_R_CH08
BIT_POS_B_INPUT_LARGE_R_CH07
BIT_POS_A_INPUT_LARGE_R_CH00
BIT_POS_B_INPUT_SMALL_R_CH15
BIT_POS_A_INPUT_SMALL_R_CH08
BIT_POS_B_INPUT_SMALL_R_CH07
BIT_POS_A_INPUT_SMALL_R_CH00
BIT_POS_B_INPUT_SMALL_R_CH05
BIT_POS_A_INPUT_SMALL_R_CH03
BIT_POS_B_INPUT_LARGE_R_CH12
BIT_POS_A_INPUT_SMALL_R_CH04
BIT_POS_A_INPUT_LARGE_R_CH12
BIT_POS_A_INPUT_LARGE_R_CH04
BIT_POS_A_INPUT_SMALL_R_CH12
BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH15
BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH08
BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH07
BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH00
BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH15
BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH08
BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH07
BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH00
BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH12
BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH04
BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH12
BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH04

Definition at line 143 of file TgcRdoToPrepDataToolMT.h.

                   {
    BIT_POS_ASD_SIZE = 16,
    BIT_POS_NUM_ASD = 2,
    BIT_POS_INPUT_SIZE = BIT_POS_ASD_SIZE*BIT_POS_NUM_ASD,
    BIT_POS_OFFSET_LARGE_R = BIT_POS_ASD_SIZE,
    BIT_POS_OFFSET_LARGE_PHIFOR_A_FWD_C_BWD = BIT_POS_OFFSET_LARGE_R,
    BIT_POS_A_INPUT_ORIGIN =  73,
    BIT_POS_B_INPUT_ORIGIN = 109,
    BIT_POS_C_INPUT_ORIGIN = 149,
    BIT_POS_D_INPUT_ORIGIN = 193,
    
    /* CHannel starts from 00 at the small R side (the same as ASD). */
    BIT_POS_B_INPUT_LARGE_R_CH15 = BIT_POS_B_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 15, //  78
    BIT_POS_A_INPUT_LARGE_R_CH08 = BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R -  8, //  49
    BIT_POS_B_INPUT_LARGE_R_CH07 = BIT_POS_B_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R -  7, //  86
    BIT_POS_A_INPUT_LARGE_R_CH00 = BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R,      //  57
    BIT_POS_B_INPUT_SMALL_R_CH15 = BIT_POS_B_INPUT_ORIGIN                          - 15, //  94
    BIT_POS_A_INPUT_SMALL_R_CH08 = BIT_POS_A_INPUT_ORIGIN                          -  8, //  65
    BIT_POS_B_INPUT_SMALL_R_CH07 = BIT_POS_B_INPUT_ORIGIN                          -  7, // 102
    BIT_POS_A_INPUT_SMALL_R_CH00 = BIT_POS_A_INPUT_ORIGIN,                               //  73
 
    BIT_POS_B_INPUT_SMALL_R_CH05 = BIT_POS_B_INPUT_ORIGIN                          -  5, // 104
    BIT_POS_A_INPUT_SMALL_R_CH03 = BIT_POS_A_INPUT_ORIGIN                          -  3, //  70
    BIT_POS_B_INPUT_LARGE_R_CH12 = BIT_POS_B_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 12, //  81
 
    BIT_POS_A_INPUT_SMALL_R_CH04 = BIT_POS_A_INPUT_ORIGIN                          -  4, //  69
    BIT_POS_A_INPUT_LARGE_R_CH12 = BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R - 12, //  45
    BIT_POS_A_INPUT_LARGE_R_CH04 = BIT_POS_A_INPUT_ORIGIN - BIT_POS_OFFSET_LARGE_R -  4, //  53
    BIT_POS_A_INPUT_SMALL_R_CH12 = BIT_POS_A_INPUT_ORIGIN                          - 12, //  61
 
    /* CHannel starts from 00 
       at the small phi side for A side forward chambers and C side backward chambers and 
       at the large phi side for A side backward chambers and C side forward chambers (the same as ASD). */
    BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH15 = BIT_POS_B_INPUT_LARGE_R_CH15,   //  78
    BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH08 = BIT_POS_A_INPUT_LARGE_R_CH08,   //  49
    BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH07 = BIT_POS_B_INPUT_LARGE_R_CH07,   //  86
    BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH00 = BIT_POS_A_INPUT_LARGE_R_CH00,   //  57
    BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH15 = BIT_POS_B_INPUT_SMALL_R_CH15,   //  94
    BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH08 = BIT_POS_A_INPUT_SMALL_R_CH08,   //  65
    BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH07 = BIT_POS_B_INPUT_SMALL_R_CH07,   // 102
    BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH00 = BIT_POS_A_INPUT_SMALL_R_CH00,   //  73
 
    BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH12 = BIT_POS_A_INPUT_LARGE_R_CH12,   //  45
    BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH04 = BIT_POS_A_INPUT_LARGE_R_CH04,   //  53
    BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH12 = BIT_POS_A_INPUT_SMALL_R_CH12,   //  61
    BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH04 = BIT_POS_A_INPUT_SMALL_R_CH04    //  69
      };

◆ MAP_SIZE

enum Muon::TgcRdoToPrepDataToolMT::MAP_SIZE

private

Bit map sizes.

Enumerator
WT_MAP_SIZE
ST_MAP_SIZE
SD_MAP_SIZE
WD_MAP_SIZE

Definition at line 192 of file TgcRdoToPrepDataToolMT.h.

                    {
        WT_MAP_SIZE = 3*BIT_POS_INPUT_SIZE,
        ST_MAP_SIZE = 2*BIT_POS_INPUT_SIZE,
        SD_MAP_SIZE = 2*BIT_POS_INPUT_SIZE,
        WD_MAP_SIZE = 2*BIT_POS_INPUT_SIZE
      };

◆ SUB_DETCTOR_ID

enum Muon::TgcRdoToPrepDataToolMT::SUB_DETCTOR_ID

private

Sub detector IDs are 103 and 104 for TGC A side and C side, respectively.

Enumerator
ASIDE
CSIDE

Definition at line 114 of file TgcRdoToPrepDataToolMT.h.

                          {
        ASIDE = 103,
        CSIDE = 104
      };

Constructor & Destructor Documentation

◆ ~TgcRdoToPrepDataToolMT()

virtual Muon::TgcRdoToPrepDataToolMT::~TgcRdoToPrepDataToolMT ( )

virtualdefault

Destructor.

Member Function Documentation

◆ convertToRun2() [1/2]

void Muon::TgcRdoToPrepDataToolMT::convertToRun2	(	const TgcRawData &	rd,
		uint16_t &	newrodId,
		uint16_t &	newsector ) const

inlineprivate

Definition at line 446 of file TgcRdoToPrepDataToolMT.h.

                                                                                              {
    convertToRun2(&rd,newrodId,newsector);
      }

◆ convertToRun2() [2/2]

void Muon::TgcRdoToPrepDataToolMT::convertToRun2	(	const TgcRawData *	rd,
		uint16_t &	newrodId,
		uint16_t &	newsector ) const

inlineprivate

Definition at line 433 of file TgcRdoToPrepDataToolMT.h.

                                                                                              {
        newrodId = rd->rodId();
        newsector = rd->sector();
        if (rd->rodId()>12){ // Run3 rodID is 17..19 while Run2 rodId is 1..12
          if(rd->isForward()){
            newrodId = rd->sector() / 2 + 1 + (rd->rodId()-17) * 4;
            newsector = (rd->sector() + (rd->rodId()-17)*8) % 2;
          }else{
            newrodId = rd->sector() / 4 + 1 + (rd->rodId()-17) * 4;
            newsector = (rd->sector() + (rd->rodId()-17)*16) % 4;
          }
        }
      }

◆ decode() [1/2]

StatusCode Muon::TgcRdoToPrepDataToolMT::decode	(	const EventContext &	ctx,
		const std::vector< IdentifierHash > &	idVect ) const

overridevirtual

Decode RDO to PRD
A vector of IdentifierHash are passed in, and the data corresponding to this list (i.e.

in a Region of Interest) are converted.

Parameters

requestedIdHashVect Vector of hashes to convert i.e. the hashes of ROD collections in a 'Region of Interest'

Returns: selectedIdHashVect This is the subset of requestedIdVect which were actually found to contain data
(i.e. if you want you can use this vector of hashes to optimise the retrieval of data in subsequent steps.)

In the R4 layout both phi & eta measurements are expressed on the same surface. However, the

Definition at line 206 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                                            {
  // Object to hold the containers for this decode call
  State state{};
  ATH_CHECK(setupState(ctx, state));
 
  SG::WriteHandle<xAOD::TgcStripContainer> xAODHandle{};
  if (!m_xAODKey.empty()) {
    xAODHandle =  SG::WriteHandle<xAOD::TgcStripContainer>{m_xAODKey, ctx};
    ATH_CHECK(xAODHandle.record(std::make_unique<xAOD::TgcStripContainer>(), 
                                std::make_unique<xAOD::TgcStripAuxContainer>()));
  }
 
  int sizeVectorRequested = requestedIdHashVect.size();
  ATH_MSG_DEBUG("decode for " << sizeVectorRequested << " offline collections called");
 
  const CablingInfo* cinfo = getCabling();
  if (!cinfo) {
    return StatusCode::FAILURE;
  }
  const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
 
  std::set<const TgcRdo*> decodedRdoCollVec{}, rdoCollVec{};
  std::vector<bool> decodedOnlineId (cinfo->m_MAX_N_ROD, false);
 
  // if TGC decoding is switched off stop here
  if(!m_decodeData) {
    ATH_MSG_DEBUG("Stored empty container. Decoding TGC RDO into TGC PrepRawData is switched off");
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG("Decoding TGC RDO into TGC PrepRawData");
 
  // retrieve the collection of RDO
  ATH_MSG_DEBUG("Retrieving TGC RDO container from the store");
  SG::ReadHandle<TgcRdoContainer> rdoContainer{m_rdoContainerKey, ctx};
  ATH_CHECK(rdoContainer.isValid());
  if(rdoContainer->empty()) {
    // empty csm container - no tgc rdo in this event
    ATH_MSG_DEBUG("Empty rdo container - no tgc rdo in this event");
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG("Not empty rdo container in this event, the container size is " << rdoContainer->size());
  
  // select RDOs to be decoded when seeded mode is used
  if(sizeVectorRequested!=0) {
    unsigned int nRdo = 0;
    for (IdentifierHash offlineCollHash : requestedIdHashVect) {
      uint16_t onlineId = cinfo->m_hashToOnlineId.at(static_cast<unsigned int>(offlineCollHash));
 
      if(decodedOnlineId.at(onlineId)) {
          ATH_MSG_DEBUG("The ROB with onlineId " << onlineId << " which contains hash "
                      << static_cast<unsigned int>(offlineCollHash)
                      << " is already decoded and skipped");
          continue;
      }
 
      decodedOnlineId.at(onlineId) = true; // The ROB with this onlineId will be decoded only once
   
      for(const TgcRdo* rdoColl : *rdoContainer) {
        if(rdoColl->identify()==onlineId) {
            if(!decodedRdoCollVec.count(rdoColl)) {
              rdoCollVec.insert(rdoColl);
              nRdo++;
            }
            break;
        }
      }
    }
    ATH_MSG_DEBUG("Number of RDOs to be converted is " << nRdo);
  } // End of selection of RDOs to be decoded
 
  // Decode Hits
  if(sizeVectorRequested!=0) {
    ATH_MSG_DEBUG("Start loop over rdos - seeded mode");
    // for each RDO collection we collect up all the PRD collections and then write them once filled
    // need a vector because we have the collections for the different bunch crosssings
    for (const TgcRdo* rdo : rdoCollVec) {
      for (const TgcRawData* rd : *rdo) {
        //Since OnlineIds are not unique, need some additional filtering on offline hashId
        //to avoid decoding RDO outside of an RoI
        Identifier offlineId{};
        if(!cinfo->m_tgcCabling->getElementIDfromReadoutID(offlineId, rd->subDetectorId(), 
                                                           rd->rodId(), rd->sswId(), rd->slbId(), 
                                                           rd->bitpos())){
            continue;
        }
        const IdentifierHash tgcHashId = m_idHelperSvc->moduleHash(offlineId);
        if (std::find(requestedIdHashVect.begin(), requestedIdHashVect.end(), tgcHashId) == requestedIdHashVect.end()){
            continue;
        }
        selectDecoder(state,*rd, rdo);
      }
      decodedRdoCollVec.insert(rdo);
    }   
  } else {
    ATH_MSG_DEBUG("Start loop over rdos - unseeded mode");
    for(const TgcRdo* rdoColl : *rdoContainer) {
      if (rdoColl->empty() || decodedRdoCollVec.count(rdoColl) || rdoCollVec.count(rdoColl)) {
          continue;
      }
      ATH_MSG_DEBUG(" Number of RawData in this rdo " << rdoColl->size());
      for (const TgcRawData* rd : *rdoColl) {
          selectDecoder(state,*rd, rdoColl);
      }
      decodedRdoCollVec.insert(rdoColl);
    }
  }
  // first collect up all the HashIDs in any of the containers
  std::set<IdentifierHash> hashesInAnyBC;
  for(unsigned int ibc = 0; ibc < NBC_HIT; ++ibc) {
 
      uint16_t bcBitMap = 0;
      if(ibc == 0) bcBitMap = TgcPrepData::BCBIT_PREVIOUS;
      else if (ibc == 1) bcBitMap = TgcPrepData::BCBIT_CURRENT;
      else if (ibc == 2) bcBitMap = TgcPrepData::BCBIT_NEXT;
      
      for (std::unique_ptr<TgcPrepDataCollection>& bcColl : state.tgcPrepDataCollections[ibc]) {
        if (!bcColl) continue;
        std::unique_ptr<TgcPrepDataCollection>& allBcColl = state.tgcPrepDataCollections[NBC_HIT][bcColl->identifyHash()];
        if (!allBcColl) {
           allBcColl = std::make_unique<TgcPrepDataCollection>(bcColl->identifyHash());
           allBcColl->setIdentifier(bcColl->identify());
        }
        hashesInAnyBC.insert(bcColl->identifyHash());
        for (const TgcPrepData* prdToUpdate : *bcColl) {
          auto search_itr = std::find_if(allBcColl->begin(), allBcColl->end(),
                                         [prdToUpdate](const TgcPrepData* prd){
                                            return prd->identify() == prdToUpdate->identify();
                                         });
          if (search_itr == allBcColl->end())  {
            auto allBcPrd = std::make_unique<TgcPrepData>(*prdToUpdate);
            allBcPrd->setHashAndIndex(allBcColl->identifyHash(), allBcColl->size());
            allBcPrd->setBcBitMap(bcBitMap);
            allBcColl->push_back(std::move(allBcPrd));
          } else {
            TgcPrepData* allBcPrd = (*search_itr);
            const uint16_t bcBitMap_current = allBcPrd->getBcBitMap();
            ATH_MSG_VERBOSE(m_idHelperSvc->toString(allBcPrd->identify())<<" Old bitmap " << bcBitMap_current 
                          << " adding " << bcBitMap << " to get " << (bcBitMap_current | bcBitMap));
            allBcPrd->setBcBitMap((bcBitMap_current | bcBitMap));
          }
        }
     }
  }
 
  if (!m_xAODKey.empty()) {
    for (std::unique_ptr<TgcPrepDataCollection>& allBcColl : state.tgcPrepDataCollections[NBC_HIT]) {
        if (!allBcColl) continue;
        for (const TgcPrepData* allBcPrd : *allBcColl) {
          xAOD::TgcStrip* tgcStrip = xAODHandle->push_back(std::make_unique<xAOD::TgcStrip>());
          tgcStrip->setMeasuresPhi(idHelper.isStrip(allBcPrd->identify()));
          tgcStrip->setGasGap(idHelper.gasGap(allBcPrd->identify()));
          tgcStrip->setChannelNumber(idHelper.channel(allBcPrd->identify()));
          tgcStrip->setBcBitMap(allBcPrd->getBcBitMap());
          tgcStrip->setIdentifier(allBcPrd->identify().get_compact());
          //  rotation from eta -> phi is clockwise  --> minus sign in prd creation
          const double locPos = (tgcStrip->measuresPhi() ? -1. : 1.) * allBcPrd->localPosition().x();
          tgcStrip->setMeasurement(m_idHelperSvc->moduleHash(allBcPrd->identify()),
                                  xAOD::MeasVector<1>(locPos),
                                  xAOD::MeasMatrix<1>(allBcPrd->localCovariance()(0,0)));
        }
    }
}
 
  for (unsigned int k = 0 ; k < state.tgcPrepDataContainer.size(); ++k){
    ATH_CHECK(transferData(*state.tgcPrepDataContainer[k], std::move(state.tgcPrepDataCollections[k])));
  }
  for (unsigned int k = 0 ; k < state.tgcCoinDataContainer.size(); ++k) {
    ATH_CHECK(transferData(*state.tgcCoinDataContainer[k], std::move(state.tgcCoinDataCollections[k])));
  }
  ATH_MSG_DEBUG("Found " << hashesInAnyBC.size() << " hashes that must be added to AllBC container");
  
  return StatusCode::SUCCESS;
}

◆ decode() [2/2]

StatusCode Muon::TgcRdoToPrepDataToolMT::decode	(	const EventContext &	ctx,
		const std::vector< uint32_t > &	robIds ) const

overrideprivate

Avoid compiler warning.

Definition at line 118 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                                      {
   ATH_MSG_FATAL("ROB based decoding is not supported....");
   return StatusCode::FAILURE;
}

◆ decodeHiPt()

StatusCode Muon::TgcRdoToPrepDataToolMT::decodeHiPt	(	State &	state,
		const TgcRawData &	rd ) const

private

Decode RDO's of HiPt.

Definition at line 893 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                           {
  m_nHiPtRDOs++; // Count the number of input HiPt RDOs. 
 
  const CablingInfo* cinfo = getCabling();
 
  // conversion for Run3
  uint16_t tmprodId{}, tmpsector{};
  convertToRun2(rd0,tmprodId,tmpsector);
  const TgcRawData rd(rd0.bcTag(), rd0.subDetectorId(), tmprodId,
                      rd0.l1Id(), rd0.bcId(), rd0.isStrip(),
                      rd0.isForward(), tmpsector, rd0.chip(),
                      rd0.index(), rd0.isHipt(), rd0.hitId(),
                      rd0.hsub(), rd0.delta(), rd0.inner());
 
  // Protection against invalid subDetectorId and isForward
  if((rd.subDetectorId()!=ASIDE && rd.subDetectorId()!=CSIDE)) {
    ATH_MSG_DEBUG("TgcRdoToPrepDataToolMT::decodeHiPt::Unknown subDetectorId!!");
    return StatusCode::SUCCESS;
  }
 
  // Protection against invalid hitId
  if(rd.hitId()==0) {
    ATH_MSG_DEBUG("Invalid hitId_rdo_hipt, hitId == 0!! skip to convert this RDO to PRD");
    return StatusCode::SUCCESS;
  }
  int slbsubMatrix = 0;
  bool isBackward = isBackwardBW(rd);  // Backward or Forward
  int deltaBeforeConvert = getDeltaBeforeConvert(rd);
  
  bool found = false;
  
  Identifier channelIdOut_tmp{};
  std::array<Identifier, 2> channelIdOut{};
  std::array<int, 2>  bitpos_o{}, slbchannel_o{};
  int sswId_o{0}, sbLoc_o{0}, slbId_o{0};
  
  Identifier channelIdIn_tmp{};
  std::array<Identifier, 4> channelIdIn{};
  std::array<int, 4> bitpos_i{}, slbchannel_i{};
  int sswId_i{0}, sbLoc_i{0};
  
  std::array<int, 4> slbId_in {}, sbLoc_in{}; // only used for wire
 
  std::array<int, 4> gasGap_i{}, channel_i{}; 
  double width_i{0.},hit_position_i{0};
  Amg::Vector2D tmp_hitPos_i{Amg::Vector2D::Zero()};
 
  std::array<int, 2> gasGap_o{}, channel_o{};
  double width_o{0.}, hit_position_o{0.};
  Amg::Vector2D tmp_hitPos_o{Amg::Vector2D::Zero()};
 
  const MuonGM::TgcReadoutElement* descriptor_ii = nullptr;
  const MuonGM::TgcReadoutElement* descriptor_oo = nullptr;
 
  //*** TGC3 start ***//
  // RDOHighPtID --> (Sim)HighPtID --> OfflineID --> ReadoutID --> getSLBID
  found = getHiPtIds(rd, sswId_o, sbLoc_o, slbId_o);
  if(!found) {
    return StatusCode::SUCCESS;
  }
 
  // get the OfflineID of cernter of ROI of TGC3
  if(!rd.isStrip()) { // wire
    getBitPosOutWire(rd, slbsubMatrix, bitpos_o);
  } else { // strip
    getBitPosOutStrip(rd, slbsubMatrix, bitpos_o);
  }
  for(int i=0; i<2; i++) {
    found = cinfo->m_tgcCabling->getOfflineIDfromReadoutID(channelIdOut[i], rd.subDetectorId(), rd.rodId(), 
                                                           sswId_o, sbLoc_o, bitpos_o[i]);
    if(!found) {
      ATH_MSG_DEBUG("Failed to get OfflineID from ReadoutID for Pivot " << (rd.isStrip() ? "Strip" : "Wire") << ".");
      return StatusCode::SUCCESS;
    }
  }
   
  //}
  //*** TGC3 end ***//
 
  //*** TGC1 start ***//
  // get the OfflineID of cernter of ROI of TGC1
  if(!rd.isStrip()) { // wire
    getBitPosInWire(rd, deltaBeforeConvert, bitpos_i, slbchannel_i, slbId_in, sbLoc_in, sswId_i, bitpos_o, 
                    slbchannel_o, slbId_o);
  } else { // strip
    getBitPosInStrip(rd, deltaBeforeConvert, bitpos_i, slbchannel_i, sbLoc_i, sswId_i, bitpos_o, slbchannel_o);
  }
  for(int i=0; i<4; i++) {
    found = cinfo->m_tgcCabling->getOfflineIDfromReadoutID(channelIdIn[i], rd.subDetectorId(), rd.rodId(), sswId_i,
                                                           rd.isStrip() ? sbLoc_i : sbLoc_in[i], 
                                                           bitpos_i[i]);
    if(!found) {
      ATH_MSG_DEBUG("Failed to get OfflineID from ReadoutID for Pivot "
                    << (rd.isStrip() ? "Strip" : "Wire") << ".");
      return StatusCode::SUCCESS;
    }
  }
  //}
  //*** TGC1 end ***//
  
  ATH_MSG_DEBUG("TGC RDO->Coindata for HIPT: " << m_idHelperSvc->toString(channelIdOut[1])); 
 
  const IdentifierHash tgcHashId = m_idHelperSvc->moduleHash(channelIdOut[1]);
 
  int locId = (rd.bcTag()==TgcDigit::BC_CURRENT || rd.bcTag()==TgcDigit::BC_UNDEFINED)  ? 1 : rd.bcTag()-1;
 
  std::unique_ptr<Muon::TgcCoinDataCollection>& coincollection = state.tgcCoinDataCollections[locId][tgcHashId];
  if (!coincollection) {
      coincollection = std::make_unique<Muon::TgcCoinDataCollection>(tgcHashId);
      coincollection->setIdentifier(m_idHelperSvc->chamberId(channelIdOut[1]));
  }
 
  //*** TGC3 start ***// 
  // Get geometry of pivot plane 
  std::array<const MuonGM::TgcReadoutElement*, 2> descriptor_o{state.muDetMgr->getTgcReadoutElement(channelIdOut[0]), 
                                                               state.muDetMgr->getTgcReadoutElement(channelIdOut[1])};
  for(int i=0; i<2; i++) {
    if(!isOfflineIdOKForTgcReadoutElement(descriptor_o[i], channelIdOut[i])) {
      return StatusCode::SUCCESS;
    }
  }
 
  const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
  for(int i=0; i<2; i++) { 
    gasGap_o[i] = idHelper.gasGap(channelIdOut[i]);
    channel_o[i] = idHelper.channel(channelIdOut[i]);
  }
 
  if(!rd.isStrip()) { // wire
    found = getPosAndIdWireOut(descriptor_o, channelIdOut,
                               gasGap_o, channel_o,
                               width_o, hit_position_o, tmp_hitPos_o,
                               channelIdOut_tmp);
  } else { //strip
    found = getPosAndIdStripOut(descriptor_o, channelIdOut,
                                gasGap_o, channel_o,
                                width_o, hit_position_o, tmp_hitPos_o,
                                channelIdOut_tmp,
                                isBackward, rd.subDetectorId()==ASIDE);
  }
  if(!found) {
    return StatusCode::SUCCESS;
  }
  if(width_o<s_cutDropPrdsWithZeroWidth && m_dropPrdsWithZeroWidth) { // Invalid PRD's whose widths are zero are dropped.
    return StatusCode::SUCCESS;
  }
 
  descriptor_oo = state.muDetMgr->getTgcReadoutElement(channelIdOut_tmp);
  if(!isOfflineIdOKForTgcReadoutElement(descriptor_oo, channelIdOut_tmp)) {
    return StatusCode::SUCCESS;
  }
  //}
  //*** TGC3 end ***// 
  
  //*** TGC1 start ***// 
  // Get geometry of non-pivot plane 
  std::array<const MuonGM::TgcReadoutElement*, 4> descriptor_i{state.muDetMgr->getTgcReadoutElement(channelIdIn[0]), 
                                                               state.muDetMgr->getTgcReadoutElement(channelIdIn[1]), 
                                                               state.muDetMgr->getTgcReadoutElement(channelIdIn[2]), 
                                                               state.muDetMgr->getTgcReadoutElement(channelIdIn[3])};
  for(int i=0; i<4; i++) {
    if(!isOfflineIdOKForTgcReadoutElement(descriptor_i[i], channelIdIn[i])) {
      return StatusCode::SUCCESS;
    }
  }
  for(int i=0; i<4; i++) { 
    gasGap_i[i] = idHelper.gasGap(channelIdIn[i]); 
    channel_i[i] = idHelper.channel(channelIdIn[i]); 
  }
    
  if(!rd.isStrip()) { // WIRE
    found = getPosAndIdWireIn(descriptor_i, channelIdIn,
                              gasGap_i, channel_i,
                              width_i, hit_position_i, tmp_hitPos_i,
                              channelIdIn_tmp);
  } else { // STRIP
    found = getPosAndIdStripIn(descriptor_i, channelIdIn,
                               gasGap_i, channel_i,
                               width_i, hit_position_i, tmp_hitPos_i,
                               channelIdIn_tmp,
                               isBackward, (rd.subDetectorId()==ASIDE));
  }
  if(!found) {
    return StatusCode::SUCCESS;
  }
  if(width_i<s_cutDropPrdsWithZeroWidth && m_dropPrdsWithZeroWidth) { // Invalid PRD's whose widths are zero are dropped.
    return StatusCode::SUCCESS;
  }
 
  descriptor_ii = state.muDetMgr->getTgcReadoutElement(channelIdIn_tmp);
  if(!isOfflineIdOKForTgcReadoutElement(descriptor_ii, channelIdIn_tmp)) {
    return StatusCode::SUCCESS;
  }
  //}
  //*** TGC1 end ***// 
 
  int trackletId = 2*sbLoc_o + slbsubMatrix;
  int delta = static_cast<int>(rd.delta());
  int hsub = static_cast<int>(rd.hsub());
  int inner = static_cast<int>(rd.inner());
 
  // check duplicate digits
  for (const TgcCoinData* tgcCoinData : *coincollection) {
    if((TgcCoinData::TYPE_HIPT==tgcCoinData->type()) && // Coincidence type
       (channelIdOut_tmp==tgcCoinData->identify()) && // channelIdOut, identify returns channelIdOut for HiPt
       (channelIdIn_tmp==tgcCoinData->channelIdIn()) && // channelIdIn
       (trackletId==tgcCoinData->trackletId()) && // trackletId 
       (delta==tgcCoinData->delta()) && // delta
       (hsub==tgcCoinData->sub()) && // hsub
       (inner==tgcCoinData->inner())) { 
      if(38<=trackletId && trackletId<=41) {
        // This drop is most probably due to the fix of the HiPt Endcap Strip Board bug. 
        m_nHiPtRDOs--; // Reduce the number of input RDOs. 
      }
      ATH_MSG_DEBUG("Duplicated TgcCoinData (HiPt) = "<< m_idHelperSvc->toString(channelIdOut_tmp));
      return StatusCode::SUCCESS;
    }
  }
  
  auto hitPos_o = std::make_unique<Amg::Vector2D>(tmp_hitPos_o);
  auto hitPos_i = std::make_unique<Amg::Vector2D>(tmp_hitPos_i);
 
  TgcCoinData* newCoinData = new TgcCoinData(channelIdIn_tmp,
                                             channelIdOut_tmp,
                                             tgcHashId, // determined from channelIdOut[1]
                                             descriptor_ii, // determined from channelIdIn_tmp
                                             descriptor_oo, // determined from channelIdOut_tmp
                                             TgcCoinData::TYPE_HIPT, // Coincidence type
                                             rd.subDetectorId()==ASIDE, // isAside
                                             idHelper.stationPhi(channelIdOut_tmp), // phi
                                             0, // isInner
                                             rd.isForward(), // isForward
                                             rd.isStrip(), // isStrip
                                             trackletId, // trackletId
                                             hitPos_i.release(),
                                             hitPos_o.release(),
                                             width_i,
                                             width_o,
                                             delta, // delta
                                             hsub,  // hsub
                                             inner);
  // add the digit to the collection
  newCoinData->setHashAndIndex(coincollection->identifyHash(), coincollection->size());  
  coincollection->push_back(newCoinData);
 
  ATH_MSG_DEBUG("coincollection->push_back done (for HIPT)");
 
  m_nHiPtPRDs++; // Count the number of output HiPt PRDs. 
  
  return StatusCode::SUCCESS;
}

◆ decodeHits()

StatusCode Muon::TgcRdoToPrepDataToolMT::decodeHits	(	State &	state,
		const TgcRawData &	rd ) const

private

Decode RDO's of Hit.

Definition at line 427 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                           {
  // The channel hit by hardware-ROD supports only three-bunch readout. Data of TgcDigit::BC_NEXTNEXT should be skipped in this function.
  if (rd.bcTag() == TgcDigit::BC_NEXTNEXT) return StatusCode::SUCCESS;
 
  m_nHitRDOs++; // Count the number of input Hit RDOs.
  bool isConverted{false}, isDuplicated{false}, isInvalid{false}; 
  
  ATH_MSG_DEBUG("decodeHits() :"<<__LINE__<< " sub=" << rd.subDetectorId()
                                << " rod=" << rd.rodId() << " ssw=" << rd.sswId()
                                << " slb=" << rd.slbId() << " bitpos=" << rd.bitpos());
 
  const CablingInfo* cinfo = getCabling();
 
  const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
  
  // select current Hits, =0 for backward compatibility
  // BC_CURRENT=2, BC_UNDEFINED=0
  int locId = (rd.bcTag()==TgcDigit::BC_CURRENT || rd.bcTag()==TgcDigit::BC_UNDEFINED) ? 1 : rd.bcTag()-1;
 
  // repeat two times for ORed channel
  for(int iOr=0; iOr<2; iOr++) {
    bool orFlag = false;
    // check if this channel has ORed partner only when 2nd time
    if(iOr != 0) {
      bool o_found = cinfo->m_tgcCabling->isOredChannel(rd.subDetectorId(), rd.rodId(), rd.sswId(),
                                                        rd.slbId(), rd.bitpos());
      // set OR flag
      if(o_found) orFlag = true;
      else continue;
    }
    
    // get element ID
    Identifier elementId{};
    bool e_found = cinfo->m_tgcCabling->getElementIDfromReadoutID(elementId,
                                                                  rd.subDetectorId(), rd.rodId(),
                                                                  rd.sswId(),  rd.slbId(),
                                                                  rd.bitpos(), orFlag);
    if(!e_found) {
      if(!orFlag) {
        bool show_warning_level = true;
 
        /* One invalid channel in sector A09: 
           sub=103 rod=9 ssw=6 slb=20 bitpos=151 +offset=0 orFlag=0
           was always seen in 2008 data, at least run 79772 - 91800.
           bug #48828 */
        /* One invalid channel in sector A11: 
           sub=103 rod=11 ssw=2 slb=8 bitpos=41 orFlag=0 
           was seen 5 times in 1,059,867 events of run 159179. */ 
        /* EIFI of MC ByteStream without correction issue : bug 57051 */ 
        if( (rd.subDetectorId()==103 && rd.rodId()==9 && rd.sswId()==6 && rd.slbId()==20 && rd.bitpos()==151) || 
            (rd.subDetectorId()==103 && rd.rodId()==11 && rd.sswId()==2 &&rd.slbId()==8 && rd.bitpos()==41) ||
            (rd.rodId()%3==2 && rd.sswId()==8)) {
          show_warning_level = m_show_warning_level_invalid_A09_SSW6_hit;
          isInvalid = true; 
        } 
        if (msgLvl(show_warning_level ? MSG::WARNING : MSG::DEBUG)){
          msg(show_warning_level ? MSG::WARNING : MSG::DEBUG) << "ElementID not found for "
              << " sub=" << rd.subDetectorId() << " rod=" << rd.rodId() << " ssw=" << rd.sswId()
              << " slb=" << rd.slbId() << " bitpos=" << rd.bitpos() << " orFlag=" << orFlag << endmsg;
        }
      }
      continue;
    }
    const IdentifierHash tgcHashId = m_idHelperSvc->moduleHash(elementId);
 
    Identifier channelId{};    
    bool c_found = cinfo->m_tgcCabling->getOfflineIDfromReadoutID(channelId,
                                                                  rd.subDetectorId(), rd.rodId(),
                                                                  rd.sswId(), rd.slbId(),
                                                                  rd.bitpos(), orFlag);
    if(!c_found) {
      if(!orFlag) {
        ATH_MSG_WARNING("OfflineID not found for "
                        << " sub=" << rd.subDetectorId()<< " rod=" << rd.rodId()
                        << " ssw=" << rd.sswId()<< " slb=" << rd.slbId()
                        << " bitpos=" << rd.bitpos()<< " orFlag=" << orFlag);
      }
      continue;
    }
    
 
    std::unique_ptr<TgcPrepDataCollection>& collection = state.tgcPrepDataCollections[locId][tgcHashId];
    if (!collection) {
      collection = std::make_unique<TgcPrepDataCollection>(tgcHashId);
      collection->setIdentifier(elementId);
    }
    const bool duplicate = std::find_if(collection->begin(), collection->end(),
                                        [&channelId](const TgcPrepData* prd){
                                          return prd->identify() == channelId;
                                        }) != collection->end();
    if(duplicate) {
      isDuplicated = true; // A converted PRD of this RDO is duplicated. 
      continue;
    }
    
    const MuonGM::TgcReadoutElement* descriptor = state.muDetMgr->getTgcReadoutElement(channelId);
    if(!isOfflineIdOKForTgcReadoutElement(descriptor, channelId)) {
      ATH_MSG_WARNING("decodeHits: MuonGM::TgcReadoutElement is invalid.");
      continue;
    }
    ATH_MSG_DEBUG("TGC RDO->PrepRawdata: " << m_idHelperSvc->toString(channelId));
    
    std::vector<Identifier> identifierList{channelId};
 
    Amg::Vector3D position = descriptor->channelPos(channelId);
    Amg::Vector2D hitPos{Amg::Vector2D::Zero()};
    bool onSurface = descriptor->surface(channelId).globalToLocal(position,position,hitPos);
    // the globalToLocal should not fail, if it does produce a WARNING
    if(!onSurface) {
      ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::decodeHits Amg::Vector2D* hitPos is null."); 
      continue; 
    }
    
 
    int gasGap  = idHelper.gasGap(channelId);
    int channel = idHelper.channel(channelId);
    const double width = !idHelper.isStrip(channelId) ? descriptor->gangRadialLength(gasGap, channel)
                                                      : descriptor->stripWidth(gasGap, channel);
   
    if(width<s_cutDropPrdsWithZeroWidth && m_dropPrdsWithZeroWidth) { // Invalid PRD's whose widths are zero are dropped. 
      ATH_MSG_WARNING("decodeHits: width= " << width << " is smaller than s_cutDropPrdsWithZeroWidth= " 
                     << s_cutDropPrdsWithZeroWidth<<" "<<m_idHelperSvc->toString(channelId));
      continue; 
    }
    double errPos = width/std::sqrt(12.);
    
    Amg::MatrixX mat(1,1);
    mat.setIdentity();
    mat *= errPos*errPos;
    
    // add the digit to the collection
    // new TgcPrepRawData
    TgcPrepData* newPrepData = new TgcPrepData(channelId, // Readout ID -> Offline ID
                                               tgcHashId, // Readout ID -> Element ID -> Hash 
                                               hitPos, // determined from channelId
                                               identifierList, // holds channelId only
                                               mat, // determined from channelId
                                               descriptor); // determined from channelId
    newPrepData->setHashAndIndex(collection->identifyHash(), collection->size());
    collection->push_back(newPrepData);
    isConverted = true; // This RDO is converted to at least one PRD.  
  }
 
  if(isConverted) m_nHitPRDs++; // Count the number of output Hit PRDs.
  else if(isDuplicated || isInvalid) m_nHitRDOs--; // Reduce the number of input RDOs. 
 
  return StatusCode::SUCCESS;
}

◆ decodeInner()

StatusCode Muon::TgcRdoToPrepDataToolMT::decodeInner	(	State &	state,
		const TgcRawData &	rd ) const

private

Decode RDO's of Inner.

Definition at line 1145 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                          {
  m_nHiPtRDOs++; // Count the number of input HiPt RDOs. 
 
  const CablingInfo* cinfo = getCabling();
  if (!cinfo) {
    return StatusCode::FAILURE;
  }
 
  int subDetectorId = rd.subDetectorId();
  // Protection against invalid subDetectorId and isForward
  if(subDetectorId!=ASIDE && subDetectorId!=CSIDE) {
    ATH_MSG_DEBUG("TgcRdoToPrepDataToolMT::decodeHiPt::Unknown subDetectorId!!");
    return StatusCode::SUCCESS;
  }
 
  bool isInner = ((rd.sector() & 4) != 0 ); // Inner flag for EIFI and Tilecal
 
 
  Identifier channelIdIn{};
  Identifier channelIdOut{};
  int sswId_o = 9;
  int sbLoc_o = rd.sector() & 3;
  int inner   = rd.inner();
  bool isStrip = rd.isStrip();
 
  int phi = 0; bool isAside = false; bool isEndcap = false;
  if(rd.rodId() < 13){ // Run2
    cinfo->m_tgcCabling->getSLIDfromReadoutID(phi, isAside, isEndcap, subDetectorId,
                                              rd.rodId(), sswId_o, sbLoc_o);
  }else{ // Run3
    sbLoc_o = rd.sector();
    cinfo->m_tgcCabling->getSLIDfromSReadoutID(phi, isAside, subDetectorId, rd.rodId(), sbLoc_o, rd.isForward());
    isEndcap = !rd.isForward();
    if(rd.type()==TgcRawData::TYPE_INNER_NSW){
      isInner = true; isStrip = false;
      inner = (rd.nsweta()    << Muon::TgcCoinData::INNER_NSW_R_BITSHIFT)
            + (rd.nswphi()    << Muon::TgcCoinData::INNER_NSW_PHI_BITSHIFT)
            + (rd.nswdtheta() << Muon::TgcCoinData::INNER_NSW_DTHETA_BITSHIFT)
            + (rd.nswphires() << Muon::TgcCoinData::INNER_NSW_PHIRES_BITSHIFT)
            + (rd.nswlowres() << Muon::TgcCoinData::INNER_NSW_LOWRES_BITSHIFT)
            + (rd.nswid()     << Muon::TgcCoinData::INNER_NSW_ID_BITSHIFT)
            + (((rd.nswcand()>>TgcRawData::NSW_BCID_BITSHIFT)&TgcRawData::NSW_BCID_BIT)   << Muon::TgcCoinData::INNER_NSW_BCID_BITSHIFT)
            + (((rd.nswcand()>>TgcRawData::NSW_INPUT_BITSHIFT)&TgcRawData::NSW_INPUT_BIT) << Muon::TgcCoinData::INNER_NSW_INPUT_BITSHIFT);
    } else if(rd.type()==TgcRawData::TYPE_INNER_BIS){
      isInner = true; isStrip = true;
      inner = (rd.rpceta()  << Muon::TgcCoinData::INNER_RPC_ETA_BITSHIFT)
            + (rd.rpcphi()  << Muon::TgcCoinData::INNER_RPC_PHI_BITSHIFT)
            + (rd.rpcdeta() << Muon::TgcCoinData::INNER_RPC_DETA_BITSHIFT)
            + (rd.rpcdphi() << Muon::TgcCoinData::INNER_RPC_DPHI_BITSHIFT)
            + (((rd.rpcflag()>>TgcRawData::RPC_FLAG_BITSHIFT)&TgcRawData::RPC_FLAG_BIT) << Muon::TgcCoinData::INNER_RPC_FLAG_BITSHIFT)
            + (((rd.rpcflag()>>TgcRawData::RPC_BCID_BITSHIFT)&TgcRawData::RPC_BCID_BIT) << Muon::TgcCoinData::INNER_RPC_BCID_BITSHIFT);
    }else if(rd.type()==TgcRawData::TYPE_INNER_EIFI){
      isInner = false; isStrip = false;
      inner = (rd.ei()  << Muon::TgcCoinData::INNER_EIFI_EI_BITSHIFT)
            + (rd.fi()  << Muon::TgcCoinData::INNER_EIFI_FI_BITSHIFT)
            + (rd.cid() << Muon::TgcCoinData::INNER_EIFI_CID_BITSHIFT);
    }else if(rd.type()==TgcRawData::TYPE_INNER_TMDB){
      isInner = false; isStrip = true;
      inner = (rd.tmdbmod()  << Muon::TgcCoinData::INNER_TILE_MODULE_BITSHIFT)
            + (rd.tmdbbcid() << Muon::TgcCoinData::INNER_TILE_BCID_BITSHIFT);
    }
  }
 
  int locId = (rd.bcTag()==TgcDigit::BC_CURRENT || rd.bcTag()==TgcDigit::BC_UNDEFINED) ? 1 : rd.bcTag()-1;
  
  auto hitPos_o = std::make_unique< Amg::Vector2D >(Amg::Vector2D::Zero());
  auto hitPos_i = std::make_unique< Amg::Vector2D >(Amg::Vector2D::Zero());
 
  const MuonGM::TgcReadoutElement* descriptor_ii = nullptr;
  const MuonGM::TgcReadoutElement* descriptor_oo = nullptr;
 
  std::string stationName = "T3E";
  int stationEta = isAside ? 1 : -1;
  int stationPhi = phi;
  bool isValid{false};
  Identifier elementId = m_idHelperSvc->tgcIdHelper().elementID(stationName, stationEta, stationPhi, isValid);
  const IdentifierHash tgcHashId = m_idHelperSvc->moduleHash(elementId);
 
  std::unique_ptr<Muon::TgcCoinDataCollection>& coincollection = state.tgcCoinDataCollections[locId][tgcHashId];
  if (!coincollection) {
      coincollection = std::make_unique<Muon::TgcCoinDataCollection>(tgcHashId);
      coincollection->setIdentifier(elementId);
  }
  
  ATH_MSG_DEBUG("Inner Data Word, phi: " << phi << " isAside: " << isAside << " isEndcap: " << isEndcap
                << " subDetectorId: " << subDetectorId << " isStrip: " << rd.isStrip()
                << " rodId: " << rd.rodId() << " slbId: " << sbLoc_o << " inner:"<< rd.inner());
 
  TgcCoinData* newCoinData = new TgcCoinData(channelIdIn,  // empty
                                             channelIdOut, // empty
                                             tgcHashId, // determined from channelIdOut[1]
                                             descriptor_ii, // determined from channelIdIn_tmp
                                             descriptor_oo, // determined from channelIdOut_tmp
                                             (rd.rodId()<13)?(TgcCoinData::TYPE_HIPT):(TgcCoinData::TYPE_UNKNOWN), // Coincidence type: rd.rodId()<13 for Run2, rd.rodId()>12 for Run3
                                             isAside, // isAside
                                             phi, // phi
                                                                 isInner, // Selection for NSW/BIS/EIFI/TMDB
                                             !isEndcap, // isForward
                                             isStrip, // Selection for NSW/BIS/EIFI/TMDB
                                             0, // trackletId
                                             hitPos_i.release(),
                                             hitPos_o.release(),
                                             0., // width_i,
                                             0., // width_o,
                                             0, // delta,
                                             0, // hsub,
                                             inner);
  // add the digit to the collection
  newCoinData->setHashAndIndex(coincollection->identifyHash(), coincollection->size());  
  coincollection->push_back(newCoinData);
 
  ATH_MSG_DEBUG("coincollection->push_back done (for Inner)");
 
  m_nHiPtPRDs++; // Count the number of output HiPt PRDs.
 
  return StatusCode::SUCCESS;
}

◆ decodeSL()

StatusCode Muon::TgcRdoToPrepDataToolMT::decodeSL	(	State &	state,
		const TgcRawData &	rd,
		const TgcRdo *	rdoColl ) const

private

Decode RDO's of SectorLogic.

Definition at line 1263 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                                                {
  m_nSLRDOs++; // Count the number of input SL RDOs. 
 
  // conversion for Run3
  uint16_t tmprodId, tmpsector;
  convertToRun2(rd0,tmprodId,tmpsector);
  const TgcRawData rd(rd0.bcTag(), rd0.subDetectorId(), tmprodId, rd0.l1Id(),rd0.bcId(),
                      rd0.isForward(), tmpsector, rd0.innerflag(), rd0.coinflag(),
                      rd0.isMuplus(), rd0.threshold(), rd0.roi());
 
  // Protection against invalid subDetectorId
  if(rd.subDetectorId()!=ASIDE && rd.subDetectorId()!=CSIDE) {
    ATH_MSG_DEBUG("TgcRdoToPrepDataToolMT::decodeSL::Unknown subDetectorId!!");
    return StatusCode::SUCCESS;
  }
  
  bool found = false;
 
  std::array<Identifier, 3> channelId_wire{};
  int index_w{0}, chip_w{0}, hitId_w{0}, sub_w{0}, sswId_w{0}, sbLoc_w{0}, subMatrix_w{0};
  std::array<int, 3> bitpos_w{};
 
  //***  get OfflineID, center of ROI of R (wire) ***//
  found = getSLIds(false, rd, channelId_wire, index_w, chip_w, hitId_w, sub_w, sswId_w, sbLoc_w, 
                   subMatrix_w, bitpos_w);
  if(!found) {
    return StatusCode::SUCCESS;
  }
 
  std::array<Identifier, 3> channelId_strip{};
  int index_s{0}, chip_s{0}, hitId_s{0}, sub_s{0}, sswId_s{0}, sbLoc_s{0}, subMatrix_s{0};
  std::array<int, 3> bitpos_s{};
 
  //***  get OfflineID, center of ROI of phi (strip) ***//
  found = getSLIds(true, rd, channelId_strip, index_s, chip_s, hitId_s, sub_s, sswId_s, sbLoc_s, subMatrix_s, 
                   bitpos_s, isIncludedInChamberBoundary(rd), rdoColl, index_w, chip_w, hitId_w, sub_w);
  if(!found) {
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG("TGC RDO->TgcCoindata(SL): " << m_idHelperSvc->toString(channelId_wire[1])); 
  
  const IdentifierHash tgcHashId= m_idHelperSvc->moduleHash(channelId_wire[1]);
 
 
  int locId = (rd.bcTag()==TgcDigit::BC_CURRENT || rd.bcTag()==TgcDigit::BC_UNDEFINED) ? 1 : rd.bcTag()-1;
 
  std::unique_ptr<Muon::TgcCoinDataCollection>& coincollection = state.tgcCoinDataCollections[locId][tgcHashId];
  if (!coincollection) {
      coincollection = std::make_unique<Muon::TgcCoinDataCollection>(tgcHashId);
      coincollection->setIdentifier(m_idHelperSvc->chamberId(channelId_wire[1]));
  }
  
  
  int trackletId = 2*sbLoc_w + subMatrix_w;
  int trackletIdStrip = 2*sbLoc_s + subMatrix_s;
  int roi = static_cast<int>(rd.roi());
  int pt = static_cast<int>(rd.threshold());
  if(rd0.rodId()>12){ // Run3:  pT 4 bit, CoinFlag 3 bit, InnerFlag 4 bit
    pt += (static_cast<int>( rd.coinflag() ) << 4 );
    pt += (static_cast<int>( rd.innerflag() ) << 7 );
  }
  bool veto = rd.isVeto();
  bool isPositiveDeltaR = rd.isMuplus(); // Current SL sets isMuplus flag based on sign of deltaR. 
                                              // Postive deltaR gives isMuplus=true.
  // check duplicate digits
  for (const TgcCoinData* tgcCoinData : *coincollection) {
    if(TgcCoinData::TYPE_SL==tgcCoinData->type() && channelId_wire[2]==tgcCoinData->identify() &&
       trackletId==tgcCoinData->trackletId() && trackletIdStrip==tgcCoinData->trackletIdStrip() &&       
       roi==tgcCoinData->roi() && pt==tgcCoinData->pt() &&  veto==tgcCoinData->veto() && 
       isPositiveDeltaR==tgcCoinData->isPositiveDeltaR()) {
      ATH_MSG_DEBUG("Duplicated TgcCoinData (SL) = "
            << m_idHelperSvc->toString(channelId_wire[2]));
      return StatusCode::SUCCESS;
    }
  }
 
  //*** R (wire) start ***//
  double width_w{0.}, tmp_r{0.}, tmp_wire_z{0.};
  found = getSLWireGeometry(channelId_wire, width_w, tmp_r, tmp_wire_z);
  if(!found) {
    return StatusCode::SUCCESS;
  }
  if(width_w<s_cutDropPrdsWithZeroWidth && m_dropPrdsWithZeroWidth) { // Invalid PRD's whose widths are zero are dropped.
    return StatusCode::SUCCESS;
  }
 
  double tmp_eta = 0.; 
  bool isGoodEta = getEtafromRZ(tmp_r, tmp_wire_z, tmp_eta); 
  if(!isGoodEta) { 
    ATH_MSG_WARNING("Conversion from r and z to eta by Muon::TgcRdoToPrepDataToolMT::getEtafromRZ failed."); 
    return StatusCode::SUCCESS; 
  } 
  if(tmp_wire_z<0.) tmp_eta *= -1.; 
  //*** R (wire) end ***//
 
  //*** Phi (strip) start ***//
  double width_s{0.}, tmp_phi{0.};
  found = getSLStripGeometry(channelId_strip, isBackwardBW(rd), (rd.subDetectorId()==ASIDE), width_s, tmp_phi);
  if(!found) {
    return StatusCode::SUCCESS;
  }
  if(width_s<s_cutDropPrdsWithZeroWidth && m_dropPrdsWithZeroWidth) { // Invalid PRD's whose widths are zero are dropped.
    return StatusCode::SUCCESS;
  }
  //*** Phi (strip) end ***//
  const MuonGM::TgcReadoutElement* descriptor_w2 = state.muDetMgr->getTgcReadoutElement(channelId_wire[2]);
  if(!isOfflineIdOKForTgcReadoutElement(descriptor_w2, channelId_wire[2])) {
    return StatusCode::SUCCESS;
  }
  
  Amg::Vector3D tmp_gp(tmp_r*std::cos(tmp_phi), tmp_r*std::sin(tmp_phi), tmp_wire_z);
  Amg::Vector2D tmp_hitPos{Amg::Vector2D::Zero()};
  bool onSurface = descriptor_w2->surface(channelId_wire[2]).globalToLocal(tmp_gp,tmp_gp,tmp_hitPos);
    // If TGC A-lines with rotations are used, the z-coordinate of a chamber depends on position. 
    // In this case, the global to local conversion fails. 
    // Obtain the local position in a different way. 
  const Amg::Vector2D* hitPos = !onSurface ? new Amg::Vector2D(tmp_hitPos) : 
                                             getSLLocalPosition(descriptor_w2, channelId_wire[2], tmp_eta, tmp_phi);
 
 
  Amg::MatrixX mat(2,2);
  mat.setIdentity();
  mat(0,0) = width_w;
  mat(1,1) = width_s;
  const Amg::MatrixX* errMat = new Amg::MatrixX(std::move(mat));
 
 
  // new TgcCoinData          
  TgcCoinData* newCoinData = new TgcCoinData(channelId_wire[2],
                                             tgcHashId, // determined from channelId_wire[1]
                                             descriptor_w2, // determined from channelId_wire[2]
                                             TgcCoinData::TYPE_SL, // Coincidence type
                                             rd.subDetectorId()==ASIDE, // isAside
                                             m_idHelperSvc->tgcIdHelper().stationPhi(channelId_wire[2]), // phi
                                             rd.isForward(), // isForward
                                             trackletId, // trackletId 
                                             trackletIdStrip, // trackletIdStrip
                                             hitPos,
                                             errMat,
                                             roi, // roi from RDO
                                             pt, // threshold from RDO
                                             veto, // veto flag from RDO
                                             isPositiveDeltaR); // isMuplus from RDO
 
  // add the digit to the collection
  newCoinData->setHashAndIndex(coincollection->identifyHash(), coincollection->size());  
  coincollection->push_back(newCoinData);
  ATH_MSG_DEBUG("coincollection->push_back done (for SL)");
 
  m_nSLPRDs++; // Count the number of output SL PRDs.
  return StatusCode::SUCCESS;
}

◆ decodeTracklet()

StatusCode Muon::TgcRdoToPrepDataToolMT::decodeTracklet	(	State &	state,
		const TgcRawData &	rd ) const

private

Decode RDO's of Tracklet.

Definition at line 576 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                              {
  ++m_nTrackletRDOs; // Count the number of input Tracklet RDOs. 
 
  const CablingInfo* cinfo = getCabling();
 
  bool found = false;
  
  //*** Get OfflineId of pivot plane (TGC3) start ***//
  Identifier channelIdOut{};
  found = cinfo->m_tgcCabling->getOfflineIDfromLowPtCoincidenceID(channelIdOut, 
                                                                  rd.subDetectorId(), rd.rodId(),
                                                                  rd.sswId(), rd.slbId(), rd.subMatrix(), 
                                                                  rd.position(), false);
  if(!found) {
    ATH_MSG_DEBUG("decodeTracklet: can't get the OfflineIdOut");
    return StatusCode::SUCCESS;
  }
  //*** Get OfflineId of pivot plane (TGC3) end ***//
  
  //*** Get OfflineId of non-pivot plane (TGC2) start ***//
  int tmp_slbId{0}, tmp_subMatrix{0}, tmp_position{0};
  found = getTrackletInfo(rd, tmp_slbId, tmp_subMatrix, tmp_position);
  if(!found) {
    return StatusCode::SUCCESS;
  }
  Identifier channelIdIn{};
  found = cinfo->m_tgcCabling->getOfflineIDfromLowPtCoincidenceID(channelIdIn, 
                                                                  rd.subDetectorId(), rd.rodId(),
                                                                  rd.sswId(), tmp_slbId, 
                                                                  tmp_subMatrix, tmp_position, true);          
  if(!found) {
    ATH_MSG_DEBUG("decodeTracklet: can't get the OfflineIdIn");
    return StatusCode::SUCCESS;
  }
  //*** Get OfflineId of non-pivot plane (TGC2) end ***//
  
  const IdentifierHash tgcHashId = m_idHelperSvc->moduleHash(channelIdOut);
  
 
  int locId = (rd.bcTag()==TgcDigit::BC_CURRENT || rd.bcTag()==TgcDigit::BC_UNDEFINED)? 1 : rd.bcTag()-1;
 
  std::unique_ptr<Muon::TgcCoinDataCollection>& coincollection = state.tgcCoinDataCollections[locId][tgcHashId];
  if (!coincollection) {
      coincollection = std::make_unique<Muon::TgcCoinDataCollection>(tgcHashId);
      coincollection->setIdentifier(m_idHelperSvc->chamberId(channelIdOut));
  }
 
  int subMatrix = static_cast<int>(rd.subMatrix());
  int trackletId = static_cast<int>(2*rd.slbId()+subMatrix); 
  int delta = static_cast<int>(rd.delta());
 
  // Check duplicate digits
  for (const TgcCoinData* tgcCoinData : *coincollection) {
    if(TgcCoinData::TYPE_TRACKLET==tgcCoinData->type() && // coincidence type
       channelIdOut==tgcCoinData->identify() && // channelIdOut, identify returns channelIdOut for Tracklet
       channelIdIn==tgcCoinData->channelIdIn() &&  // channelIdIn
       trackletId==tgcCoinData->trackletId() && // trackletId
       delta==tgcCoinData->delta() && // delta
       subMatrix==tgcCoinData->sub()) { // subMatrix 
      
      ATH_MSG_DEBUG("Duplicated TgcCoinData (Tracklet) = "<< m_idHelperSvc->toString(channelIdIn));
      return StatusCode::SUCCESS;
    }
  }
 
  ATH_MSG_DEBUG("TGC RDO->Coindata for LowPT: " << m_idHelperSvc->toString(channelIdOut)); 
 
  //*** Get geometry of pivot plane (TGC3) start ***//
  const MuonGM::TgcReadoutElement* descriptor_o = state.muDetMgr->getTgcReadoutElement(channelIdOut);
  if(!isOfflineIdOKForTgcReadoutElement(descriptor_o, channelIdOut)) {
    return StatusCode::SUCCESS;
  }
  
  const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
  int gasGap_o = idHelper.gasGap(channelIdOut);
  int channel_o = idHelper.channel(channelIdOut);
  double width_o = !idHelper.isStrip(channelIdOut) ? descriptor_o->gangRadialLength(gasGap_o, channel_o)
                                                   : descriptor_o->stripWidth(gasGap_o, channel_o);
 
  if(width_o<s_cutDropPrdsWithZeroWidth && m_dropPrdsWithZeroWidth) { // Invalid PRD's whose widths are zero are dropped.
    return StatusCode::SUCCESS;
  }
  
  Amg::Vector3D position_o = descriptor_o->channelPos(channelIdOut);
  Amg::Vector2D hitPos_o{Amg::Vector2D::Zero()};
  bool onSurface_o = descriptor_o->surface(channelIdOut).globalToLocal(position_o,position_o,hitPos_o);
  // the globalToLocal should not fail, if it does produce a WARNING
  if(!onSurface_o) {
    ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::decodeTracklet Amg::Vector2D* hitPos_o is null.");
    return StatusCode::SUCCESS;
  }  
  //*** Get geometry of pivot plane (TGC3) end ***//
  
  //*** Get geometry of non-pivot plane (TGC2) start ***//
  const MuonGM::TgcReadoutElement* descriptor_i = state.muDetMgr->getTgcReadoutElement(channelIdIn);
  if(!isOfflineIdOKForTgcReadoutElement(descriptor_i, channelIdIn)) {
    return StatusCode::SUCCESS;
  }
  
  int gasGap_i = idHelper.gasGap(channelIdIn);
  int channel_i = idHelper.channel(channelIdIn);
  double width_i = !idHelper.isStrip(channelIdIn) ? descriptor_i->gangRadialLength(gasGap_i, channel_i)
                                                  : descriptor_i->stripWidth(gasGap_i, channel_i);
  
  if(width_i<s_cutDropPrdsWithZeroWidth && m_dropPrdsWithZeroWidth) { // Invalid PRD's whose widths are zero are dropped.
    return StatusCode::SUCCESS;
  }
 
  Amg::Vector3D position_i = descriptor_i->channelPos(channelIdIn);
  Amg::Vector2D hitPos_i{Amg::Vector2D::Zero()};
  bool onSurface_i = descriptor_i->surface(channelIdIn).globalToLocal(position_i,position_i,hitPos_i);
  // the globalToLocal should not fail, if it does produce a WARNING
  if(!onSurface_i) {
    ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::decodeTracklet Amg::Vector2D* hitPos_i is null."); 
    return StatusCode::SUCCESS;
  }  
  //*** Get geometry of non-pivot plane (TGC2) end ***//
  const Amg::Vector2D* hitPosition_o = new Amg::Vector2D(hitPos_o);
  const Amg::Vector2D* hitPosition_i = new Amg::Vector2D(hitPos_i);
  // Add the digit to the collection
  TgcCoinData* newCoinData = new TgcCoinData(channelIdIn,
                                             channelIdOut,
                                             tgcHashId, // determined from channelIdOut
                                             descriptor_i, // determined from channelIdIn
                                             descriptor_o, // determined from channelIdOut
                                             TgcCoinData::TYPE_TRACKLET, 
                                             rd.subDetectorId()==ASIDE, // isAside
                                             idHelper.stationPhi(channelIdOut), // phi
                                             0, // isInner
                                             rd.sswId()==7||rd.sswId()==2, // isForward
                                             idHelper.isStrip(channelIdOut), // isStrip
                                             trackletId, // trackletId
                                             hitPosition_i, // determined from channelIdIn
                                             hitPosition_o, // determined from channelIdOut
                                             width_i, // determined from channelIdIn 
                                             width_o, // determined from channelIdOut
                                             delta, // delta
                                             subMatrix,
                                             0); // subMatrix
  newCoinData->setHashAndIndex(coincollection->identifyHash(), coincollection->size());  
  coincollection->push_back(newCoinData);
  
  ATH_MSG_DEBUG("coincollection->push_back done (for LowPT)");
 
  m_nTrackletPRDs++; // Count the number of output Tracklet PRDs. 
  
  return StatusCode::SUCCESS;
}

◆ decodeTrackletEIFI()

StatusCode Muon::TgcRdoToPrepDataToolMT::decodeTrackletEIFI	(	State &	state,
		const TgcRawData &	rd ) const

private

Decode RDO's of Tracklet EIFI.

Definition at line 725 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                                  {
  // Count the number of input TrackletEIFI RDOs. 
  m_nTrackletEIFIRDOs++; 
 
  const CablingInfo* cinfo = getCabling();
 
  const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
 
 
  // Determine chamber type 
  bool isStrip = rd.slbType()==TgcRawData::SLB_TYPE_INNER_STRIP;
  bool isAside = rd.subDetectorId()==ASIDE; 
  // https://twiki.cern.ch/twiki/pub/Main/TgcDocument/EIFI_PSB_SSW_ConnectionTable_v20080808.pdf
  bool isForward = (rd.slbId()%2==0);
  // Assuming RXID in the above file is equal to slbId 
  // rodId:     2                 5                 8                11
  // slbId FI:  0  2  4  6  8 10  0  2  4  6  8 10  0  2  4  6  8 10  0  2  4  6  8 10 
  //       EI:  1  3  5  7  9 11  1  3  5 XX  9 11  1  3  5  7  9 XX  1  3  5 XX  9 11  
  // slot:     24  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
  // stationPhi
  //       FI: 24  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
  //       EI: 21  1  2  3  4  5  6  7  8 XX  9 10 11 12 13 14 15 XX 16 17 18 XX 19 20  
  int slot = ((rd.slbId()/2) + (rd.rodId()-2)*2 + 23)%24 + 1; 
 
  bool isBackward = false; 
  if(!isForward) { // EI
    // Special case of EI11
    if(slot==15) {
      isBackward = !isAside;
    } else if(slot==16) {
      isBackward =  isAside;
    } else {
      //  A-side phi0 F: phi1 F: phi2 B
      //  C-side phi0 B: phi1 B: phi2 F
      if(isAside) isBackward = (slot%3==2);
      else        isBackward = (slot%3!=2);
    }
  } else { // FI
    isBackward = isAside;
  }
 
  // Determine bitpos based on wire/strip and subMatrix 
  // Input is chosen so that gasGap is 1 and channel is 4,12,20,28.  
  // One subMatrix covers 8 channels (=BIT_POS_ASD_SIZE/2)
  uint16_t bitpos = 0;
  if(!isStrip) { // Wire
    // For wires, D-Input is gasGap=1 
 
    int tmpsubMatrix = static_cast<int>(rd.subMatrix());
    if(!isForward) { // If an edge channel of EI fires, subMatrix of the tracklet can be greater than one of the hit channel.  
      if(tmpsubMatrix==3) {
        if(slot== 1 || slot== 3 || slot== 4 || slot== 5 || slot== 6 || slot== 7 || slot== 8 || 
           slot==10 || slot==11 || slot==13 || slot==18 || slot==19 || slot==20) {
          // These slots have only 24 wire channels (=3 submatrixes)  
          tmpsubMatrix = 2;
        }
      } else if(tmpsubMatrix==2) {
        if(slot== 2 || slot==12 || slot==14 || slot==15 || slot==16 || slot==22 || slot==23 || slot==24) {
          // These slots have only 16 wire channels (=2 submatrixes)  
          tmpsubMatrix = 1;
        }
      }
    }
 
    bitpos = BIT_POS_D_INPUT_ORIGIN - BIT_POS_INPUT_SIZE + 1 + BIT_POS_ASD_SIZE/4*(tmpsubMatrix*2+1); 
  } else { // Strip
    if(isBackward) {
      // For Backward chambers, B-Input is gasGap 1
      bitpos = BIT_POS_B_INPUT_ORIGIN - BIT_POS_INPUT_SIZE + (isAside ? 1 : 0) + BIT_POS_ASD_SIZE/4*(rd.subMatrix()*2+1); 
    } else {
      // For Forward  chambers, A-Input is gasGap 1
      bitpos = BIT_POS_A_INPUT_ORIGIN - BIT_POS_INPUT_SIZE + (isAside ? 0 : 1) + BIT_POS_ASD_SIZE/4*(rd.subMatrix()*2+1); 
    }
  }
 
  // Retrieve OfflineID from ReadoutID
  Identifier channelIdIn;
  bool o_found = cinfo->m_tgcCabling->getOfflineIDfromReadoutID(channelIdIn,
                                                                rd.subDetectorId(), rd.rodId(),
                                                                rd.sswId(),rd.slbId(), bitpos,
                                                                false/*orflag*/);
  if(!o_found) {
    ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::decodeTrackletEIFI OfflineID not found for "
                  << " subDetectorId=" << rd.subDetectorId() << " rodId=" << rd.rodId()
                  << " sswId=" << rd.sswId()<< " slbId=" << rd.slbId() << " slbType=" << rd.slbType() 
                  << " subMatrix=" << rd.subMatrix() << " bitpos=" << bitpos << " isStrip=" << isStrip
                  << " isAside=" << isAside<< " isForward=" << isForward<< " slot=" << slot
                  << " isBackward=" << isBackward);
    return StatusCode::SUCCESS;
  }
 
 
  // Retrieve Hash from ElementID
  const IdentifierHash tgcHashId = m_idHelperSvc->moduleHash(channelIdIn);
  // Index is determined based on bcTag. 
  int locId = (rd.bcTag()==TgcDigit::BC_CURRENT || rd.bcTag()==TgcDigit::BC_UNDEFINED) ? 1 : rd.bcTag()-1;
 
  std::unique_ptr<Muon::TgcCoinDataCollection>& coincollection = state.tgcCoinDataCollections[locId][tgcHashId];
  if (!coincollection) {
      coincollection = std::make_unique<Muon::TgcCoinDataCollection>(tgcHashId);
      coincollection->setIdentifier(m_idHelperSvc->chamberId(channelIdIn));
  }
 
  // Check duplicate digits
  for (const TgcCoinData* tgcCoinData : *coincollection) {
    if(TgcCoinData::TYPE_TRACKLET_EIFI==tgcCoinData->type() && // coincidence type
       channelIdIn==tgcCoinData->channelIdIn() && // channelIdIn
       static_cast<int>(rd.subMatrix())==tgcCoinData->sub()) { // sub
      ATH_MSG_DEBUG("Duplicated TgcCoinData (TrackletEIFI) = "<< m_idHelperSvc->toString(channelIdIn));
      return StatusCode::SUCCESS;
    }
  }
  // Get MuonGM::TgcReadoutElement from channelIdIn
  const MuonGM::TgcReadoutElement* descriptor = state.muDetMgr->getTgcReadoutElement(channelIdIn);
  if(!isOfflineIdOKForTgcReadoutElement(descriptor, channelIdIn)) {
    ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::decodeTrackletEIFI descriptor doesn't contain " 
            << m_idHelperSvc->toString(channelIdIn));
    return StatusCode::SUCCESS;
  }
 
  // Get Amg::Vector2D from channelIdIn //here I am
  Amg::Vector3D position = descriptor->channelPos(channelIdIn);
  Amg::Vector2D hitPos{Amg::Vector2D::Zero()};
  bool onSurface = descriptor->surface(channelIdIn).globalToLocal(position,position,hitPos);
  // the globalToLocal should not fail, if it does produce a WARNING
  if(!onSurface) {
    ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::decodeTrackletEIFI Amg::Vector2D* hitPos is null.");
    return StatusCode::SUCCESS;
  }
 
  // Get width from channelIdIn, one subMatrix covers 8 channels per gasGap 
  int gasGap = idHelper.gasGap(channelIdIn); // 1
  int channel = idHelper.channel(channelIdIn); // 4, 12, 20, 28
  double width {0};
  if(isStrip) { // Strip
    double localZ = (descriptor->transform(channelIdIn).inverse()*descriptor->channelPos(channelIdIn)).z();
    double stripMaxX  = descriptor->stripHighEdgeLocX(gasGap, channel+4, localZ);
    double stripMinX  = descriptor->stripLowEdgeLocX(gasGap, channel-3, localZ);
    width = std::abs(stripMaxX - stripMinX);
  } else { // Wire
    int positiveOffset = +4;
    if(isForward && (slot%3==2) && channel==28) positiveOffset = +2; // T10S has only 30 channels.  
    double gangMaxZ = descriptor->gangLongWidth(gasGap, channel+positiveOffset);
    double gangMinZ = descriptor->gangShortWidth(gasGap, channel-3);
    width = std::abs(gangMaxZ - gangMinZ);
  }
 
  const Amg::Vector2D* hitPosition = new Amg::Vector2D(hitPos);
  // Add the digit to the collection
  TgcCoinData* newCoinData = new TgcCoinData(channelIdIn, 
                                             tgcHashId, // determined from channelIdIn
                                             descriptor, // determined from channelIdIn
                                             TgcCoinData::TYPE_TRACKLET_EIFI,
                                             isAside, 
                                             m_idHelperSvc->tgcIdHelper().stationPhi(channelIdIn), 
                                             isForward, 
                                             isStrip, 
                                             hitPosition, // determined from channelIdIn
                                             width, // determined from channelIdIn
                                             static_cast<int>(rd.subMatrix())); // subMatrix
  newCoinData->setHashAndIndex(coincollection->identifyHash(), coincollection->size());  
  coincollection->push_back(newCoinData);
 
  // Count the number of output Tracklet EIFI PRDs.
  m_nTrackletEIFIPRDs++; 
  return StatusCode::SUCCESS;
}

◆ finalize()

StatusCode Muon::TgcRdoToPrepDataToolMT::finalize ( )

overridevirtual

Standard AthAlgTool finalize method.

Definition at line 105 of file TgcRdoToPrepDataToolMT.cxx.

{
  ATH_MSG_INFO("finalize(): input RDOs->output PRDs ["  << 
           "Hit: "          << m_nHitRDOs          << "->" << m_nHitPRDs          << ", " << 
           "Tracklet: "     << m_nTrackletRDOs     << "->" << m_nTrackletPRDs     << ", " << 
           "TrackletEIFI: " << m_nTrackletEIFIRDOs << "->" << m_nTrackletEIFIPRDs << ", " << 
           "HiPt: "         << m_nHiPtRDOs         << "->" << m_nHiPtPRDs         << ", " << 
           "SL: "           << m_nSLRDOs           << "->" << m_nSLPRDs           << "]"); 
 
  return AthAlgTool::finalize();
}

◆ getbitpos()

int Muon::TgcRdoToPrepDataToolMT::getbitpos	(	int	channel,
		TgcRawData::SlbType	slbType )

staticprivate

Get bitpos from channel and SlbType.

Definition at line 1417 of file TgcRdoToPrepDataToolMT.cxx.

{
  int bitpos = -BIT_POS_INPUT_SIZE +1;
  if(slbType==TgcRawData::SLB_TYPE_TRIPLET_WIRE) {
    if(channel<0 || channel>=WT_MAP_SIZE) return -1; // Invalid channel
 
    if(     channel%3==0) bitpos += BIT_POS_C_INPUT_ORIGIN; // C-Input
    else if(channel%3==1) bitpos += BIT_POS_B_INPUT_ORIGIN; // B-Input
    else                  bitpos += BIT_POS_A_INPUT_ORIGIN; // A-Input
    return bitpos + channel/3;
  } else if(slbType==TgcRawData::SLB_TYPE_TRIPLET_STRIP || 
        slbType==TgcRawData::SLB_TYPE_DOUBLET_STRIP) {
    if(channel<0 || channel>=ST_MAP_SIZE) return -1; // Invalid channel, SD_MAP_SIZE is equal to ST_MAP_SIZE. 
 
    if(channel%2==0) bitpos += BIT_POS_B_INPUT_ORIGIN; // B-Input
    else             bitpos += BIT_POS_A_INPUT_ORIGIN; // A-Input
    return bitpos + channel/2;
  } else if(slbType==TgcRawData::SLB_TYPE_DOUBLET_WIRE) {
    if(channel<0 || channel>=WD_MAP_SIZE) return -1; // Invalid channel
 
    if(channel%2==0) bitpos += BIT_POS_B_INPUT_ORIGIN; // B-Input
    else             bitpos += BIT_POS_A_INPUT_ORIGIN; // A-Input
    return bitpos + channel/2;
  } else {
    return -1;
  }
}

◆ getBitPosInStrip()

void Muon::TgcRdoToPrepDataToolMT::getBitPosInStrip	(	const TgcRawData &	rd,
		const int	DeltaBeforeConvert,
		std::array< int, 4 > &	bitpos_i,
		std::array< int, 4 > &	slbchannel_i,
		int &	sbLoc_i,
		int &	sswId_i,
		const std::array< int, 2 > &	bitpos_o,
		std::array< int, 2 > &	slbchannel_o ) const

private

Get bitPos etc of TGC1 strip for HiPt.

Definition at line 1768 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                         {
  // This method is used by decodeHiPt 
  //*** get bitpos for TGC1 Station ***//
  // ST
  int rdochIn_max = ST_MAP_SIZE-1;
  int rdochIn_min = 0;
 
  if((rd.sector()%2)==0) { 
    if(rd.chip()==0) {
      sbLoc_i = 16; // EST0 (phi0 and phi2) or FST0 (phi0)
    } else if(rd.chip()==1) {
      sbLoc_i = 17; // EST1 (phi0 and phi2)
    }
  } else {
    if(rd.chip()==0) {
      sbLoc_i = 24; // EST0 (phi1 and phi3) or FST0 (phi2)
    } else if(rd.chip()==1) {
      sbLoc_i = 25; // EST1 (phi1 and phi3)
    }
  }
 
  for(int i=0; i<2; i++) {
    slbchannel_o[i] = getchannel(bitpos_o[i], TgcRawData::SLB_TYPE_DOUBLET_STRIP);
    slbchannel_i[i] = slbchannel_o[i] + deltaBeforeConvert;
    if(slbchannel_i[i]>rdochIn_max) {
      slbchannel_i[i] = rdochIn_max;
    } else if(slbchannel_i[i]<rdochIn_min) {
      slbchannel_i[i] = rdochIn_min;
    }
 
    if(i==0) {
      slbchannel_i[i+2] = slbchannel_i[i] + 1;
    } else {
      slbchannel_i[i+2] = slbchannel_i[i] - 1;
    }
 
    if(slbchannel_i[i+2] > rdochIn_max) {
      slbchannel_i[i+2] = rdochIn_max;
    } else if(slbchannel_i[i+2] < rdochIn_min) {
      slbchannel_i[i+2] = rdochIn_min;
    }
 
    bitpos_i[i]   = getbitpos(slbchannel_i[i],   TgcRawData::SLB_TYPE_TRIPLET_STRIP);
    bitpos_i[i+2] = getbitpos(slbchannel_i[i+2], TgcRawData::SLB_TYPE_TRIPLET_STRIP);
  }
 
  if(!rd.isForward()) { // EST
    sswId_i = static_cast<int>(rd.sector()/2);
  } else { // FST
    sswId_i = 2;
  }
}

◆ getBitPosInWire()

void Muon::TgcRdoToPrepDataToolMT::getBitPosInWire	(	const TgcRawData &	rd,
		const int	DeltaBeforeConvert,
		std::array< int, 4 > &	bitpos_i,
		std::array< int, 4 > &	slbchannel_i,
		std::array< int, 4 > &	slbId_in,
		std::array< int, 4 > &	sbLoc_in,
		int &	sswId_i,
		const std::array< int, 2 > &	bitpos_o,
		std::array< int, 2 > &	slbchannel_o,
		const int	slbId_o ) const

private

Get bitPos etc of TGC1 wire for HiPt.

Definition at line 1655 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                                           {
  // This method is used by decodeHiPt 
  const int NUM_SLBID_SBLOC_OFFSET_WT = 8; // (see https://twiki.cern.ch/twiki/pub/Main/TgcDocument/sbloc-070701.xls)
 
  /*** get bitpos for TGC1 Station ***/
 
  int rdochIn_max = 0;
  int rdochIn_min = 0;
  int offset_dt = 0;
  if(!rd.isForward()) { // EWT
    rdochIn_max = 665;
    rdochIn_min = 78;
    offset_dt = 32;
  } else { // FWT
    rdochIn_max = 312;
    rdochIn_min = 0;
    offset_dt = 0;
  }
 
  int tmp_rdochannel_i = 0;
  int tmp_rdochannel_i2 = 0;
  for(int i=0; i<2; i++) {
    slbchannel_o[i] = getchannel(bitpos_o[i], TgcRawData::SLB_TYPE_DOUBLET_WIRE);
    tmp_rdochannel_i = WD_MAP_SIZE*slbId_o + slbchannel_o[i] + deltaBeforeConvert + offset_dt; 
    if(tmp_rdochannel_i>rdochIn_max) {
      tmp_rdochannel_i = rdochIn_max;
    } else if(tmp_rdochannel_i<rdochIn_min) {
      tmp_rdochannel_i = rdochIn_min;
    }
 
    //                               Large R <-----------------> Small R
    // tmp_rdochannel_i           :  0  1  2  3  4  5  6  7  8  9 10 ...
    //------------------------------------------------------------------- 
    // tmp_rdochannel_i/3         :  0  0  0  1  1  1  2  2  2  3  3 ...
    // (tmp_rdochannel_i/3)*3     :  0  0  0  3  3  3  6  6  6  9  9 ...
    // tmp_rdochannel_i2 (i==0)   :  2  2  2  5  5  5  8  8  8 11 11 ...
    //-------------------------------------------------------------------
    // tmp_rdochannel_i+1         :  1  2  3  4  5  6  7  8  9 10 11 ...
    // (tmp_rdochannel_i+1)/3     :  0  0  1  1  1  2  2  2  3  3  3 ...
    // ((tmp_rdochannel_i+1)/3)*3 :  0  0  3  3  3  6  6  6  9  9  9 ...
    // tmp_rdochannel_i2 (i==1)   : -1 -1  2  2  2  5  5  5  8  8  8 ... 
    
    if(i==0) { // get the lower R channel on L3 nearest from bitpos_o[0]
      tmp_rdochannel_i2 = (tmp_rdochannel_i/3)*3 + 2; 
    } else { // get the higher R channel on L3 nearest from bitpos_o[1] 
      tmp_rdochannel_i2 = ((tmp_rdochannel_i + 1)/3)*3 - 1; 
    }
    
    if(tmp_rdochannel_i2>rdochIn_max) {
      tmp_rdochannel_i2 = rdochIn_max;
    } else if(tmp_rdochannel_i2<rdochIn_min) {
      tmp_rdochannel_i2 = rdochIn_min + 2; // 2 is added for L3 
    }
 
    slbId_in[i]   = tmp_rdochannel_i /WT_MAP_SIZE;
    slbId_in[i+2] = tmp_rdochannel_i2/WT_MAP_SIZE;
 
    sbLoc_in[i]   = slbId_in[i];
    sbLoc_in[i+2] = slbId_in[i+2];
    if(rd.sector()%2==1) { 
      // phi1 and phi3 have offset (see https://twiki.cern.ch/twiki/pub/Main/TgcDocument/sbloc-070701.xls) 
      // Endcap sector=1, 3 are phi1 and phi3, and Forward sector=1 is phi2.
      sbLoc_in[i]   += NUM_SLBID_SBLOC_OFFSET_WT;
      sbLoc_in[i+2] += NUM_SLBID_SBLOC_OFFSET_WT;
    }
 
    slbchannel_i[i]   = tmp_rdochannel_i %WT_MAP_SIZE;
    slbchannel_i[i+2] = tmp_rdochannel_i2%WT_MAP_SIZE;
 
    bitpos_i[i]   = getbitpos(slbchannel_i[i],   TgcRawData::SLB_TYPE_TRIPLET_WIRE);
    bitpos_i[i+2] = getbitpos(slbchannel_i[i+2], TgcRawData::SLB_TYPE_TRIPLET_WIRE);
  }
 
  if(!rd.isForward()) { // EWT
    sswId_i = static_cast<int>(rd.sector()/2);
  } else { // FWT
    sswId_i = 2;
  }
}

◆ getBitPosOutStrip()

void Muon::TgcRdoToPrepDataToolMT::getBitPosOutStrip	(	const TgcRawData &	rd,
		int &	slbsubMatrix,
		std::array< int, 2 > &	bitpos_o )

staticprivate

Get bitPos etc of TGC3 strip for HiPt.

Definition at line 1743 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                 {
  // This method is used by decodeHiPt
  if((rd.hitId()%2)==1) { // 1,3,5::hitId:1-6 for EC, 2-3 for Fw
    slbsubMatrix = 0;
    if((rd.hsub())==0) {
      bitpos_o[0] = BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH15; //  78 
      bitpos_o[1] = BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH08; //  49
    } else if((rd.hsub())==1) {
      bitpos_o[0] = BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH07; //  86
      bitpos_o[1] = BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH00; //  57
    }
  } else { // 2,4,6
    slbsubMatrix = 1;
    if((rd.hsub())==0) {
      bitpos_o[0] = BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH15; //  94
      bitpos_o[1] = BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH08; //  65
    } else if((rd.hsub())==1) {
      bitpos_o[0] = BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH07; // 102
      bitpos_o[1] = BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH00; //  73
    }
  }
}

◆ getBitPosOutWire()

void Muon::TgcRdoToPrepDataToolMT::getBitPosOutWire	(	const TgcRawData &	rd,
		int &	slbsubMatrix,
		std::array< int, 2 > &	bitpos_o )

staticprivate

Get bitPos etc of TGC3 wire for HiPt.

Definition at line 1604 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                {
  // This method is used by decodeHiPt 
  if((rd.hitId()%2)==1) { // 1,3,5
    slbsubMatrix = 0;
    if((rd.hsub())==0) {
      bitpos_o[0] = BIT_POS_B_INPUT_LARGE_R_CH15; //  78
      bitpos_o[1] = BIT_POS_A_INPUT_LARGE_R_CH08; //  49
    } else if((rd.hsub())==1) {
      bitpos_o[0] = BIT_POS_B_INPUT_LARGE_R_CH07; //  86
      bitpos_o[1] = BIT_POS_A_INPUT_LARGE_R_CH00; //  57
    }
  } else { // 2,4,6
    slbsubMatrix = 1;
    if((rd.hsub())==0) {
      bitpos_o[0] = BIT_POS_B_INPUT_SMALL_R_CH15; //  94
      bitpos_o[1] = BIT_POS_A_INPUT_SMALL_R_CH08; //  65
    } else if((rd.hsub())==1) {
      bitpos_o[0] = BIT_POS_B_INPUT_SMALL_R_CH07; // 102
      bitpos_o[1] = BIT_POS_A_INPUT_SMALL_R_CH00; //  73
    }
  }
 
  // In case of WIRE, there are no bit assign.(EWD0 EWD4 FWD0 FWD1)-----------------------------
  // EWD0 sbLoc = 0     bitpos = 102 : does not exist and has 6 channels only (the largest  R, RoiRow== 0).
  // EWD4 sbLoc = 9     bitpos =  73 : does not exist and has 4 channels only (the smallest R, RoiRow==36). 
  // FWD0 sbLoc = 0, 8  bitpos =  78 : does not exist and has 5 channels only (the largest  R, RoiRow== 0). 
  // FWD1 sbLoc = 3, 11 bitpos =  73 : does not exist and has 5 channels only (the smallest R, RoiTow==15).
  // fixed it by following description.
  if(!rd.isForward()) { // Endcap
    if((rd.chip()==0) && (rd.hitId()==1) && (rd.hsub()==1)) { 
      // chip 0 should have these values and means EWD0's position.
      slbsubMatrix = 1;
      bitpos_o[0] = BIT_POS_B_INPUT_SMALL_R_CH05; // 104
      bitpos_o[1] = BIT_POS_A_INPUT_SMALL_R_CH00; //  73
    } else if((rd.chip()==3) && (rd.hitId()==6) && (rd.hsub()==1)) { // EWD4's position
      bitpos_o[0] = BIT_POS_B_INPUT_SMALL_R_CH07; // 102
      bitpos_o[1] = BIT_POS_A_INPUT_SMALL_R_CH04; //  69 
    }
  } else { // Forward
    if((rd.chip()==0) && (rd.hitId()==1) && (rd.hsub()==0)) { // FWD0
      bitpos_o[0] = BIT_POS_B_INPUT_LARGE_R_CH12; //  81
      bitpos_o[1] = BIT_POS_A_INPUT_LARGE_R_CH08; //  49
    } else if((rd.chip()==1) && (rd.hitId()==2) && (rd.hsub()==1)) { //FWD1
      bitpos_o[0] = BIT_POS_B_INPUT_SMALL_R_CH07; // 102
      bitpos_o[1] = BIT_POS_A_INPUT_SMALL_R_CH03; //  70
    }
  }// end of Forward
  // end of fixed----------------------------------------------------------------------------------
}

◆ getBitPosStrip()

void Muon::TgcRdoToPrepDataToolMT::getBitPosStrip	(	const int	hitId_s,
		const int	sub_s,
		int &	subMatrix_s,
		std::array< int, 3 > &	bitpos_s )

staticprivate

Get bitPos etc of strip for SL.

Definition at line 1892 of file TgcRdoToPrepDataToolMT.cxx.

{
  // This method is used by getSLIds 
  // 0 : Index for the largest phi (for A-side forward and C-side backward) channel 
  // 1 : Index for the smallest phi (for A-side forward and C-side backward) channel 
  // 2 : Index for the "center" channel
 
  if((hitId_s%2)==0) { // 0, 2, 4
    subMatrix_s = 0;
    if(sub_s==0) {
      bitpos_s[0] = BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH15; //  78 
      bitpos_s[1] = BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH12; //  45
      bitpos_s[2] = BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH08; //  49
    } else if(sub_s==1) {
      bitpos_s[0] = BIT_POS_B_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH07; //  86
      bitpos_s[1] = BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH04; //  53
      bitpos_s[2] = BIT_POS_A_INPUT_LARGE_PHI_FOR_A_FWD_C_BWD_CH00; //  57
    }
  } else if((hitId_s%2)==1) { // 1, 3, 5
    subMatrix_s = 1;
    if(sub_s==0) {
      bitpos_s[0] = BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH15; //  94
      bitpos_s[1] = BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH12; //  61
      bitpos_s[2] = BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH08; //  65
    } else if(sub_s==1) {
      bitpos_s[0] = BIT_POS_B_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH07; // 102 
      bitpos_s[1] = BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH04; //  69 
      bitpos_s[2] = BIT_POS_A_INPUT_SMALL_PHI_FOR_A_FWD_C_BWD_CH00; //  73
    }
  }
}

◆ getBitPosWire()

void Muon::TgcRdoToPrepDataToolMT::getBitPosWire	(	const TgcRawData &	rd,
		const int	hitId_w,
		const int	sub_w,
		int &	subMatrix_w,
		std::array< int, 3 > &	bitpos_w ) const

private

Get bitPos etc of wire for SL.

Definition at line 1828 of file TgcRdoToPrepDataToolMT.cxx.

{
  // This method is used by getSLIds 
  // This method assumes sub_w is 0 or 1.
  // Protection for other possibility is needed.
 
  // 0 : Index for the largest R channel 
  // 1 : Index for the smallest R channel 
  // 2 : Index for the "center" channel
 
  int RoiRow = getRoiRow(rd);
  bool isForward = rd.isForward();
 
  if(RoiRow==0 && !isForward) { // EWD0,SLB0 exception (It has 6 channels only, the largest R)
    subMatrix_w = 1;
    bitpos_w[0] = BIT_POS_B_INPUT_SMALL_R_CH05; // 104 
    bitpos_w[1] = BIT_POS_A_INPUT_SMALL_R_CH04; //  69
    bitpos_w[2] = BIT_POS_A_INPUT_SMALL_R_CH00; //  73
  } else if(RoiRow==36 && !isForward) { // EWD4,SLB1 exception (It has 4 channels only, the smallest R)
    subMatrix_w = 1;
    bitpos_w[0] = BIT_POS_B_INPUT_SMALL_R_CH07; // 102
    bitpos_w[1] = BIT_POS_A_INPUT_SMALL_R_CH04; //  69
    bitpos_w[2] = BIT_POS_A_INPUT_SMALL_R_CH04; //  69
  } else if(RoiRow==0 && isForward) { // FWD0,SLB0 exception (It has 5 channels only, the largest R)
    subMatrix_w = 0;
    bitpos_w[0] = BIT_POS_B_INPUT_LARGE_R_CH12; //  81
    bitpos_w[1] = BIT_POS_A_INPUT_LARGE_R_CH12; //  45
    bitpos_w[2] = BIT_POS_A_INPUT_LARGE_R_CH08; //  49
  } else if(RoiRow==15 && isForward) { // FWD1,SLB1 exception (It has 5 channels only, the smallest R)
    subMatrix_w = 1;
    bitpos_w[0] = BIT_POS_B_INPUT_SMALL_R_CH07; // 102
    bitpos_w[1] = BIT_POS_A_INPUT_SMALL_R_CH04; //  69
    bitpos_w[2] = BIT_POS_A_INPUT_SMALL_R_CH03; //  70
  } else {
    if((hitId_w%2)==0) { // 0, 2, 4
      subMatrix_w = 0;
      if(sub_w==0) {
        bitpos_w[0] = BIT_POS_B_INPUT_LARGE_R_CH15; //  78 
    bitpos_w[1] = BIT_POS_A_INPUT_LARGE_R_CH12; //  45 
    bitpos_w[2] = BIT_POS_A_INPUT_LARGE_R_CH08; //  49
      } else if(sub_w==1) {
        bitpos_w[0] = BIT_POS_B_INPUT_LARGE_R_CH07; //  86
    bitpos_w[1] = BIT_POS_A_INPUT_LARGE_R_CH04; //  53
    bitpos_w[2] = BIT_POS_A_INPUT_LARGE_R_CH00; //  57
      }
    } else { // 1, 3, 5
      subMatrix_w = 1;
      if(sub_w==0) {
        bitpos_w[0] = BIT_POS_B_INPUT_SMALL_R_CH15; //  94 
    bitpos_w[1] = BIT_POS_A_INPUT_SMALL_R_CH12; //  61 
    bitpos_w[2] = BIT_POS_A_INPUT_SMALL_R_CH08; //  65
      } else if(sub_w==1) {
        bitpos_w[0] = BIT_POS_B_INPUT_SMALL_R_CH07; // 102 
    bitpos_w[1] = BIT_POS_A_INPUT_SMALL_R_CH04; //  69
    bitpos_w[2] = BIT_POS_A_INPUT_SMALL_R_CH00; //  73
      }
    }
  }
}

◆ getCabling()

const Muon::TgcRdoToPrepDataToolMT::CablingInfo * Muon::TgcRdoToPrepDataToolMT::getCabling ( ) const

private

Definition at line 2908 of file TgcRdoToPrepDataToolMT.cxx.

{
  if (m_cablingInfo.isValid()) {
    return m_cablingInfo.ptr();
  }
 
  // get TGC Cabling Svc
  CablingInfo cinfo;
  if (cinfo.m_tgcCabling.retrieve().isFailure()) {
    ATH_MSG_ERROR( "Could not get MuonTGC_CablingSvc!" );
    return nullptr;
  }
 
  ATH_MSG_DEBUG(cinfo.m_tgcCabling->name() << " is OK");  
 
  // check the relation between hash and onlineId (onlineId depends on cabling)  
  unsigned int hashId_max = m_idHelperSvc->tgcIdHelper().module_hash_max();  
  cinfo.m_hashToOnlineId.reserve(hashId_max);  
  IdContext tgcContext = m_idHelperSvc->tgcIdHelper().module_context(); // TGC context   
  Identifier elementId;  
  int subDetectorId = 0; // 103(=0x67) for A side, 104(=0x68) for C side  
  int rodId = 0; // 1 to 12 (12-fold cabling)
  TgcRdo tgcRdo; // For onlineId conversion  
  for(unsigned int hashId=0; hashId<hashId_max; hashId++) {  
    IdentifierHash hash(hashId);  
    m_idHelperSvc->tgcIdHelper().get_id(hash, elementId, &tgcContext);  
    cinfo.m_tgcCabling->getReadoutIDfromElementID(elementId, subDetectorId, rodId);  
    // onlineId: 0 to 11 on A side and 12 to 23 on C side (12-fold cabling)  
    uint16_t onlineId = TgcRdo::calculateOnlineId(subDetectorId, rodId);   
    cinfo.m_hashToOnlineId.push_back(onlineId);  
  } 
 
  // initialize with false  
  cinfo.m_MAX_N_ROD = 2*12;
 
  m_cablingInfo.set (std::move (cinfo));
  return m_cablingInfo.ptr();
}

◆ getchannel()

int Muon::TgcRdoToPrepDataToolMT::getchannel	(	int	bitpos,
		TgcRawData::SlbType	slbType )

staticprivate

Get channel from bitpos and SlbType.

Definition at line 1445 of file TgcRdoToPrepDataToolMT.cxx.

{
  int input = -1;
  if(     (bitpos<=BIT_POS_A_INPUT_ORIGIN) && (bitpos>BIT_POS_A_INPUT_ORIGIN-BIT_POS_INPUT_SIZE)) input = 2; // A-Input
  else if((bitpos<=BIT_POS_B_INPUT_ORIGIN) && (bitpos>BIT_POS_B_INPUT_ORIGIN-BIT_POS_INPUT_SIZE)) input = 1; // B-Input
  else if((bitpos<=BIT_POS_C_INPUT_ORIGIN) && (bitpos>BIT_POS_C_INPUT_ORIGIN-BIT_POS_INPUT_SIZE)) input = 0; // C-Input
  // D-Input is not implemented yet. 
  else return -1; // Invalid bitpos
  if(input==0 && slbType!=TgcRawData::SLB_TYPE_TRIPLET_WIRE) return -1; // Only Wire Triplet has C-input.
  
  int channel = 1-BIT_POS_INPUT_SIZE;
  if(slbType==TgcRawData::SLB_TYPE_TRIPLET_WIRE) {
    if(     input==2) channel += BIT_POS_A_INPUT_ORIGIN; // A-input
    else if(input==1) channel += BIT_POS_B_INPUT_ORIGIN; // B-input
    else              channel += BIT_POS_C_INPUT_ORIGIN; // C-input
    channel = 3*(bitpos - channel) + input;
    return channel; // C(0)->B(1)->A(2)->C(3)->B(4)->A(5)-> ... ->C(96-3)->B(96-2)->A(96-1)
  } else if(slbType==TgcRawData::SLB_TYPE_TRIPLET_STRIP ||
        slbType==TgcRawData::SLB_TYPE_DOUBLET_WIRE  ||
        slbType==TgcRawData::SLB_TYPE_DOUBLET_STRIP) {
    if(input==2) channel += BIT_POS_A_INPUT_ORIGIN; // A-input
    else         channel += BIT_POS_B_INPUT_ORIGIN; // B-input
    channel = 2*(bitpos - channel) + input-1;
    return channel; // B(0)->A(1)->B(2)->A(3)-> ... ->B(64-2)->A(64-1)
  } else {
    return -1;
  }
}

◆ getDeltaBeforeConvert()

int Muon::TgcRdoToPrepDataToolMT::getDeltaBeforeConvert ( const TgcRawData & rd )

staticprivate

Get delta (sagitta) before converion for HiPt.

Definition at line 1927 of file TgcRdoToPrepDataToolMT.cxx.

{
  int deltaBeforeConvert = 0;
 
  if(rd.isStrip()) {// strip
    switch(rd.delta()) {
    case  5: deltaBeforeConvert =   6; break;
    case  6: deltaBeforeConvert =   8; break;
    case  7: deltaBeforeConvert =  10; break;
    case -4: deltaBeforeConvert =  -5; break;
    case -5: deltaBeforeConvert =  -7; break;
    case -6: deltaBeforeConvert =  -9; break;
    case -7: deltaBeforeConvert = -12; break;
    default: deltaBeforeConvert = rd.delta(); break;
    }
  } else {// wire
    switch (rd.delta()) {
    case  11: deltaBeforeConvert =  12; break;
    case  12: deltaBeforeConvert =  14; break;
    case  13: deltaBeforeConvert =  16; break;
    case  14: deltaBeforeConvert =  18; break;
    case  15: deltaBeforeConvert =  20; break;
    case -12: deltaBeforeConvert = -13; break;
    case -13: deltaBeforeConvert = -15; break;
    case -14: deltaBeforeConvert = -17; break;
    case -15: deltaBeforeConvert = -19; break;
    default:  deltaBeforeConvert = rd.delta(); break;
    }
  }
 
  return deltaBeforeConvert;
}

◆ getEndcapStripCandidateTrackletIds()

void Muon::TgcRdoToPrepDataToolMT::getEndcapStripCandidateTrackletIds	(	const int	roi,
		int &	trackletIdStripFirst,
		int &	trackletIdStripSecond,
		int &	trackletIdStripThird )

staticprivate

Get trackletIds of three Tracklet Strip candidates in the Endcap boudary.

Definition at line 2843 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                                 {
  constexpr int T9SscMax =  2; // SSC 0 to SSC 2
  constexpr int T8SscMax =  4; // SSC 3 to SSC 4
  constexpr int T7SscMax =  6; // SSC 5 to SSC 6
  constexpr int T6SscMax = 12; // SSC 7 to SSC12
  constexpr int T5SscMax = 18; // SSC13 to SSC18
 
  constexpr int T9Offset = 32 + 0; 
  constexpr int T8Offset = 32 + 2; 
  constexpr int T7Offset = 32 + 4; 
  constexpr int T6Offset = 32 + 6; 
  constexpr int T5Offset = 32 + 8; 
  
  // ROI     :  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 ...
  // SSC     :  0  0  0  0  1  1  1  1  1  1  1  1  2  2  2  2  2  2 ...
  // Half SSC:  0  0  1  1  0  0  1  1  0  0  1  1  0  0  1  1  0  0 ... 
  int ssc = (roi+4)/8; 
  int halfSsc = (roi%4)/2; 
  
  if(       ssc< T9SscMax) { // SSC 0 to SSC 1 
    trackletIdStripFirst  = T9Offset + halfSsc; // T9
    trackletIdStripSecond = -1;
    trackletIdStripThird  = -1;
  } else if(ssc==T9SscMax) { // SSC 2 (boundary)
    trackletIdStripFirst  = T8Offset + halfSsc; // T8
    trackletIdStripSecond = T9Offset + halfSsc; // T9
    trackletIdStripThird  = -1;
  } else if(ssc< T8SscMax) { // SSC 3
    trackletIdStripFirst  = T8Offset + halfSsc; // T8
    trackletIdStripSecond = -1;
    trackletIdStripThird  = -1;
  } else if(ssc==T8SscMax) { // SSC 4 (boundary)
    trackletIdStripFirst  = T7Offset + halfSsc; // T7
    trackletIdStripSecond = T8Offset + halfSsc; // T8
    trackletIdStripThird  = -1;
  } else if(ssc< T7SscMax) { // SSC 5
    trackletIdStripFirst  = T7Offset + halfSsc; // T7
    trackletIdStripSecond = -1;
    trackletIdStripThird  = -1;
  } else if(ssc==T7SscMax) { // SSC 6 (boundary)
    trackletIdStripFirst  = T6Offset + halfSsc; // T6
    trackletIdStripSecond = T7Offset + halfSsc; // T7
    trackletIdStripThird  = T5Offset + halfSsc; // T5, HiPt Endcap Strip board bug
  } else if(ssc< T6SscMax) { // SSC 7 to SSC11 
    trackletIdStripFirst  = T6Offset + halfSsc; // T6
    trackletIdStripSecond = T5Offset + halfSsc; // T5, HiPt Endcap Strip board bug 
    trackletIdStripThird  = -1;
  } else if(ssc==T6SscMax) { // SSC12 (boundary)
    trackletIdStripFirst  = T6Offset + halfSsc; // T6
    trackletIdStripSecond = T5Offset + halfSsc; // T5
    trackletIdStripThird  = -1;
  } else if(ssc<=T5SscMax) { // SSC13 to SSC18 
    trackletIdStripFirst  = T5Offset + halfSsc; // T5
    trackletIdStripSecond = T6Offset + halfSsc; // T6, HiPt Endcap Strip board bug 
    trackletIdStripThird  = -1;
  } else {
    trackletIdStripFirst  = -1;
    trackletIdStripSecond = -1;
    trackletIdStripThird  = -1;
  }
}

◆ getEtafromRZ()

bool Muon::TgcRdoToPrepDataToolMT::getEtafromRZ	(	const double	r,
		const double	z,
		double &	eta )

staticprivate

Get eta from r and z.

Definition at line 1484 of file TgcRdoToPrepDataToolMT.cxx.

{
  double r_tmp = std::abs(r);
  double z_tmp = std::abs(z);
 
  if((r_tmp<std::numeric_limits<double>::epsilon()) && (z_tmp<std::numeric_limits<double>::epsilon())) return false; 
 
  eta = std::abs(atan2(r_tmp,z_tmp)); // theta
  eta = tan(eta/2.); // tan(theta/2)
  eta = -log(eta); // rapidity=-log(tan(theta/2))
  return true;
}

◆ getHiPtIds()

bool Muon::TgcRdoToPrepDataToolMT::getHiPtIds	(	const TgcRawData &	rd,
		int &	sswId_o,
		int &	sbLoc_o,
		int &	slbId_o ) const

private

Get ReadoutID of HiPt from RDOHighPtID.

Definition at line 2436 of file TgcRdoToPrepDataToolMT.cxx.

{
  const CablingInfo* cinfo = getCabling();
  if (!cinfo) {
    return false;
  }
 
  int index = static_cast<int>(rd.index());
  int chip = static_cast<int>(rd.chip());
  int hitId = static_cast<int>(rd.hitId());
  
  // getSimHighPtIDfromRDOHighPtID changes index, chip and hitId.
  bool found = cinfo->m_tgcCabling->getSimHighPtIDfromRDOHighPtID(rd.isForward(), rd.isStrip(), index, chip, hitId);
  if(!found) {
    ATH_MSG_DEBUG("Failed to get SimHighPtID from RDOHighPtID for Pivot "
          << (rd.isStrip() ? "Strip" : "Wire"));
    return false;
  }
  
  // conversion for Run3
  uint16_t tmprodId, tmpsector;
  convertToRun2(rd,tmprodId,tmpsector);
 
  Identifier dummyId;
  if (rd.rodId()>12){ // Run3
    found = cinfo->m_tgcCabling->getOfflineIDfromHighPtID(dummyId,
                                                 rd.subDetectorId(), tmprodId, tmpsector,
                                                 rd.isStrip(), rd.isForward(), index,
                                                 chip, hitId, rd.hsub());
  }else{
    found = cinfo->m_tgcCabling->getOfflineIDfromHighPtID(dummyId,
                                                 rd.subDetectorId(), rd.rodId(), rd.sector(),
                                                 rd.isStrip(), rd.isForward(), index,
                                                 chip, hitId, rd.hsub());
  }
 
  if(!found) {
    ATH_MSG_DEBUG("Failed to get offlineID from HighPtID for Pivot "
          << (rd.isStrip() ? "Strip" : "Wire"));
    return false;
  }
  
  std::array<int, 3> dummy_i{};
  found = cinfo->m_tgcCabling->getReadoutIDfromOfflineID(dummyId, dummy_i[0], dummy_i[1], sswId_o, sbLoc_o, dummy_i[2]);
  if(!found) {
    ATH_MSG_DEBUG("Failed to get ReadoutID from OfflineID for Pivot "
          << (rd.isStrip() ? "Strip" : "Wire"));
    return false;
  }
  
  std::array<int, 2> i_o{};
  std::array<bool, 2> b_o{false, false};
  if (rd.rodId()>12){ // Run3
    found = cinfo->m_tgcCabling->getSLBIDfromReadoutID(i_o[0], b_o[0], b_o[1], i_o[1], slbId_o, 
                                              rd.subDetectorId(), tmprodId, sswId_o, sbLoc_o);
  }else{
    found = cinfo->m_tgcCabling->getSLBIDfromReadoutID(i_o[0], b_o[0], b_o[1], i_o[1], slbId_o, 
                                              rd.subDetectorId(), rd.rodId(), sswId_o, sbLoc_o);
  }
  if(!found) {
    ATH_MSG_DEBUG("Failed to get SLBID from ReadoutID for Pivot "
          << (rd.isStrip() ? "Strip" : "Wire"));
    return false;
  }
 
  return true;
}

◆ getPosAndIdStripIn()

bool Muon::TgcRdoToPrepDataToolMT::getPosAndIdStripIn	(	const std::array< const MuonGM::TgcReadoutElement *, 4 > &	descriptor_i,
		const std::array< Identifier, 4 > &	channelIdIn,
		const std::array< int, 4 > &	gasGap_i,
		const std::array< int, 4 > &	channel_i,
		double &	width_i,
		double &	hit_position_i,
		Amg::Vector2D &	tmp_hitPos_i,
		Identifier &	channelIdIn_tmp,
		const bool	isBackward,
		const bool	isAside ) const

private

Get position and offline ID of TGC1 strip for HiPt.

Definition at line 2347 of file TgcRdoToPrepDataToolMT.cxx.

{
  // This method is used by decodeHiPt
  int flag_isL3 = -1;
  // which bitpos is Layer3?
  for(int i=0; i<4; i++) {
    if(gasGap_i[i]==3) {
      flag_isL3 = i;
      break;
    }
  }
  if(flag_isL3<0 || flag_isL3>=4) {
    ATH_MSG_DEBUG("getPosAndIdStripIn: Any bitpos is not at Layer3!");
    return false;
  }
  
  channelIdIn_tmp = channelIdIn[flag_isL3];
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
  const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
  const MuonGM::TgcReadoutElement* descriptor_is = muDetMgr->getTgcReadoutElement(channelIdIn_tmp);
  if(!isOfflineIdOKForTgcReadoutElement(descriptor_is, channelIdIn_tmp)) {
    return true;
  }
  
  std::array<double, 3> tmp_r_i{}, tmp_phi_i{}, tmp_eta_i{};
  std::array<Amg::Vector3D, 3> position_is{make_array<Amg::Vector3D, 3>(Amg::Vector3D::Zero())};
  for(int i=0; i<3; i++) {
    if(i<2) {
      position_is[i] = descriptor_i[i]->channelPos(channelIdIn[i]);
    } else {
      position_is[i] = descriptor_is->channelPos(channelIdIn_tmp);
    }
    tmp_r_i[i] = position_is[i].perp();
    tmp_phi_i[i] = position_is[i].phi(); 
    tmp_eta_i[i] = position_is[i].eta();
  }
  
  std::array<int, 2> index{};
  bool flag_reverse = false;
  if(!isBackward) { // Forward chamber
    if(isAside) { // Aside/Forward Chamber
      index[0] = 1; index[1] = 0; flag_reverse = true;
    } else { // Cside/Forward Chamber
      index[0] = 0; index[1] = 1; flag_reverse = false;
    }
  } else { // Backward chamber
    if(isAside) { // Aside/Backward Chamber
      index[0] = 0; index[1] = 1; flag_reverse = true;
    } else { // Cside/Backward Chamber
      index[0] = 1; index[1] = 0; flag_reverse = false;
    }
  }
  
  std::array<Amg::Vector3D,2 > localpos_i{make_array<Amg::Vector3D, 2>(Amg::Vector3D::Zero())};
  for(int i=0; i<2; i++) {
    localpos_i[i] = descriptor_i[i]->transform(channelIdIn[i]).inverse()*descriptor_i[i]->channelPos(channelIdIn[i]);
  }
  double stripMaxX = descriptor_i[index[0]]->stripHighEdgeLocX(gasGap_i[index[0]], channel_i[index[0]], 
                               localpos_i[index[0]].z());
  double stripMinX = descriptor_i[index[1]]->stripLowEdgeLocX(gasGap_i[index[1]], channel_i[index[1]], 
                               localpos_i[index[1]].z());
  width_i = stripMaxX - stripMinX;
  // X-coordinate
  hit_position_i = stripMinX +  width_i/2.;
  if(flag_reverse) hit_position_i *= -1.;
  tmp_hitPos_i[Trk::locX] = hit_position_i;
  // Y-coordinate
  Amg::Vector3D position_in = Amg::Vector3D(descriptor_i[1]->channelPos(channelIdIn[1]));
  // dummy global pos
  Amg::Vector2D loc_hitPos_i;
  bool onSurface_i = descriptor_i[1]->surface(channelIdIn[1]).globalToLocal(position_in,position_in,loc_hitPos_i); 
  if(!onSurface_i) { 
    ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::getPosAndIdStripIn Amg::Vector2D* loc_hitPos_i is null."); 
    return false; 
  } 
  tmp_hitPos_i[Trk::locY] = loc_hitPos_i[Trk::loc2];
  
  return true;
}

◆ getPosAndIdStripOut()

bool Muon::TgcRdoToPrepDataToolMT::getPosAndIdStripOut	(	const std::array< const MuonGM::TgcReadoutElement *, 2 > &	descriptor_o,
		const std::array< Identifier, 2 > &	channelIdOut,
		const std::array< int, 2 > &	gasGap_o,
		const std::array< int, 2 > &	channel_o,
		double &	width_o,
		double &	hit_position_o,
		Amg::Vector2D &	tmp_hitPos_o,
		Identifier &	channelIdOut_tmp,
		const bool	isBackward,
		const bool	isAside ) const

private

Get position and offline ID of TGC3 strip for HiPt.

Definition at line 2182 of file TgcRdoToPrepDataToolMT.cxx.

{
  // This method is used by decodeHiPt
  // Currently, this method always returns true.
  std::array<Amg::Vector3D, 2> localpos_o{make_array<Amg::Vector3D, 2>(Amg::Vector3D::Zero())};
  for(int i=0; i<2; i++) {
    localpos_o[i] = descriptor_o[i]->transform(channelIdOut[i]).inverse()*descriptor_o[i]->channelPos(channelIdOut[i]);
  }
  
  std::array<int, 3> index{};
  bool flag_reverse = false;
  if(!isBackward) { // Forward chamber
    index[2] = 0;
    if(isAside) { // Aside/Forward Chamber
      index[0] = 1; index[1] = 0; flag_reverse = true;
    } else { // Cside/Forward Chamber
      index[0] = 0; index[1] = 1; flag_reverse = false;
    }
  } else { // Backward chamber   
    index[2] = 1;
    if(isAside) { // Aside/Backward Chamber
      index[0] = 0; index[1] = 1; flag_reverse = true;
    } else { // Cside/Backward Chamber
      index[0] = 1; index[1] = 0; flag_reverse = false;
    }
  }
  
  double stripMax = descriptor_o[index[0]]->stripHighEdgeLocX(gasGap_o[index[0]], channel_o[index[0]], 
                              localpos_o[index[0]].z());
  double stripMin = descriptor_o[index[1]]->stripLowEdgeLocX(gasGap_o[index[1]], channel_o[index[1]], 
                              localpos_o[index[1]].z());
  width_o = stripMax - stripMin;
  // X-coordinate
  hit_position_o = stripMin + width_o/2.;
  if(flag_reverse) hit_position_o *= -1.;
  tmp_hitPos_o[Trk::locX] = hit_position_o;
  // Y-coordinate
  Amg::Vector3D position_out = Amg::Vector3D(descriptor_o[1]->channelPos(channelIdOut[1]));
  // dummy global pos
  Amg::Vector2D loc_hitPos_o{Amg::Vector2D::Zero()};
  bool onSurface_o = descriptor_o[1]->surface(channelIdOut[1]).globalToLocal(position_out,position_out,loc_hitPos_o); 
  if(!onSurface_o) { 
    ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::getPosAndIdStripOut Amg::Vector2D* loc_hitPos_o is null."); 
    return false; 
  } 
  tmp_hitPos_o[Trk::locY] = loc_hitPos_o[Trk::loc2];
  
  channelIdOut_tmp = channelIdOut[index[2]];
  
  return true;
}

◆ getPosAndIdWireIn()

bool Muon::TgcRdoToPrepDataToolMT::getPosAndIdWireIn	(	const std::array< const MuonGM::TgcReadoutElement *, 4 > &	descriptor_i,
		const std::array< Identifier, 4 > &	channelIdIn,
		const std::array< int, 4 > &	gasGap_i,
		const std::array< int, 4 > &	channel_i,
		double &	width_i,
		double &	hit_position_i,
		Amg::Vector2D &	tmp_hitPos_i,
		Identifier &	channelIdIn_tmp ) const

private

Get position and offline ID of TGC1 wire for HiPt.

Definition at line 2242 of file TgcRdoToPrepDataToolMT.cxx.

{
  // This method is used by decodeHiPt
  int flag_boundary_i = 0;
  if(descriptor_i[1]->chamberType()==descriptor_i[3]->chamberType()) { 
    // in case lower edge is not chamber boundary
    if(gasGap_i[1]==gasGap_i[3]) { // in case that edge channel is on L3; use [1]
      flag_boundary_i = 1;
    } else { // in case that edge channel is not on L3; use [3]
      flag_boundary_i = 3;
    }
  } else if(descriptor_i[0]->chamberType()==descriptor_i[2]->chamberType()) { 
    // in case higher edge is not chamber boundary
    if(gasGap_i[0]==gasGap_i[2]) { // in case that edge channel is on L3; use [0]
      flag_boundary_i = 0;
    } else { // in case that edge channel is not on L3; use [2]
      flag_boundary_i = 2;
    }
  } else {
    ATH_MSG_DEBUG("TgcRdoToPrepDataToolMT::getPosAndIdWireIn::ROI has 3 readout elements!!");
    return false;
  }
  
  channelIdIn_tmp = channelIdIn[flag_boundary_i];
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
  const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
  const MuonGM::TgcReadoutElement* descriptor_iw = muDetMgr->getTgcReadoutElement(channelIdIn_tmp);
  if(!isOfflineIdOKForTgcReadoutElement(descriptor_iw, channelIdIn_tmp)) {
    return false;
  }
  
  std::array<double, 3> tmp_r_i{}, tmp_phi_i{}, tmp_eta_i{};
  
  std::array<Amg::Vector3D, 3> position_i {descriptor_i[0]->channelPos(channelIdIn[0]), 
                                           descriptor_i[1]->channelPos(channelIdIn[1]), 
                                           descriptor_iw->channelPos(channelIdIn_tmp)};
 
  for(int i=0; i<3; i++) {
    tmp_r_i[i] =position_i[i].perp();
    tmp_phi_i[i] = position_i[i].phi();
    tmp_eta_i[i] = position_i[i].eta();
    
    if(i<2) {
      // add half widths of edge channels
      double half_width = descriptor_i[i]->gangRadialLength(gasGap_i[i], channel_i[i])/2.;
      if(half_width<s_cutDropPrdsWithZeroWidth/2. && m_dropPrdsWithZeroWidth) { // Invalid PRD's whose widths are zero are dropped.
    return false;
      }
      if(i==0) tmp_r_i[0] += half_width;
      else     tmp_r_i[1] -= half_width;
      
      bool flag_geteta_i = getEtafromRZ(tmp_r_i[i], position_i[i].z(), tmp_eta_i[i]);
      bool flag_getr_i = getRfromEtaZ(tmp_eta_i[i], position_i[2].z(), tmp_r_i[i]); 
      
      if(!flag_geteta_i || !flag_getr_i) {
    ATH_MSG_DEBUG("TgcRdoToPrepDataToolMT::getPosAndIdWireIn::failed to getRIn" << i << " on L3!!");
    return false;
      }
    }
  }
  
  width_i = tmp_r_i[0] - tmp_r_i[1];
  if(width_i<0.) {
    ATH_MSG_DEBUG("TgcRdoToPrepDataToolMT::getPosAndIdWireIn::minus value width_i = " << width_i);
    return false;
  }
  
  int gasGap_tmp = m_idHelperSvc->tgcIdHelper().gasGap(channelIdIn_tmp);
  int channel_tmp = m_idHelperSvc->tgcIdHelper().channel(channelIdIn_tmp);
  double half_width = descriptor_iw->gangRadialLength(gasGap_tmp, channel_tmp)/2.;
  if(half_width<s_cutDropPrdsWithZeroWidth/2. && m_dropPrdsWithZeroWidth) { // Invalid PRD's whose widths are zero are dropped.
    return false;
  }
  if((flag_boundary_i%2)==1) { // in case lower edge is not chamber boundary
    tmp_r_i[2] -= half_width;
    hit_position_i = descriptor_iw->gangShortWidth(gasGap_tmp, channel_tmp)
      - (tmp_r_i[2] - tmp_r_i[1]) + width_i/2.;
  } else { // in case higher edge is not chamber boundary
    tmp_r_i[2] += half_width;
    hit_position_i = descriptor_iw->gangLongWidth(gasGap_tmp, channel_tmp)
      + (tmp_r_i[0] - tmp_r_i[2]) - width_i/2.;
  }
  
  // X-coordinate
  tmp_hitPos_i[Trk::locX] = hit_position_i;
  Amg::Vector3D position_in = descriptor_i[1]->channelPos(channelIdIn[1]);
  // dummy global pos
  Amg::Vector2D loc_hitPos_i{Amg::Vector2D::Zero()};
  bool onSurface_i = descriptor_i[1]->surface(channelIdIn[1]).globalToLocal(position_in,position_in,loc_hitPos_i); 
  if(!onSurface_i) { 
    ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::getPosAndIdWireIn Amg::Vector2D* loc_hitPos_i is null."); 
    return false; 
  } 
  // Y-coordinate
  tmp_hitPos_i[Trk::locY] = loc_hitPos_i[Trk::loc2];
  
  return true;
}

◆ getPosAndIdWireOut()

bool Muon::TgcRdoToPrepDataToolMT::getPosAndIdWireOut	(	const std::array< const MuonGM::TgcReadoutElement *, 2 > &	descriptor_o,
		const std::array< Identifier, 2 > &	channelIdOut,
		const std::array< int, 2 > &	gasGap_o,
		const std::array< int, 2 > &	channel_o,
		double &	width_o,
		double &	hit_position_o,
		Amg::Vector2D &	tmp_hitPos_o,
		Identifier &	channelIdOut_tmp ) const

private

Get position and offline ID of TGC3 wire for HiPt.

Definition at line 2128 of file TgcRdoToPrepDataToolMT.cxx.

{
  // This method is used by decodeHiPt
  std::array<Amg::Vector3D, 2> position_o{make_array<Amg::Vector3D, 2>(Amg::Vector3D::Zero())};
  std::array<double, 2> tmp_phi_o{}, tmp_eta_o{}, tmp_r_o {};
  
  for(int i=0; i<2; i++) {
    position_o[i] = descriptor_o[i]->channelPos(channelIdOut[i]);
    tmp_r_o[i] = position_o[i].perp();
    tmp_phi_o[i] = position_o[i].phi();
    tmp_eta_o[i] = position_o[i].phi();
    // add half widths of edge channels
    double half_width = descriptor_o[i]->gangRadialLength(gasGap_o[i], channel_o[i])/2.;
    if(half_width<s_cutDropPrdsWithZeroWidth/2. && m_dropPrdsWithZeroWidth) { // Invalid PRD's whose widths are zero are dropped.
      return false;
    }
    if(i==0) tmp_r_o[0] += half_width;
    else     tmp_r_o[1] -= half_width;
  }
  
  bool flag_geteta_o = getEtafromRZ(tmp_r_o[0], position_o[0].z(), tmp_eta_o[0]);
  bool flag_getr_o = getRfromEtaZ(tmp_eta_o[0], position_o[1].z(), tmp_r_o[0]);
  if(!flag_geteta_o || !flag_getr_o) {
    ATH_MSG_DEBUG("TgcRdoToPrepDataToolMT::getPosAndIdWireOut::failed to getR on L7!!");
    return false;
  }
  
  width_o = tmp_r_o[0] - tmp_r_o[1];
  // X-coordinate
  hit_position_o = descriptor_o[1]->gangShortWidth(gasGap_o[1], channel_o[1]) + width_o/2;
  tmp_hitPos_o[Trk::locX] = (hit_position_o); 
  // Y-coordinate
  Amg::Vector3D position_out = Amg::Vector3D(descriptor_o[1]->channelPos(channelIdOut[1]));
  // dummy global pos
  Amg::Vector2D loc_hitPos_o;
  bool onSurface_o = descriptor_o[1]->surface(channelIdOut[1]).globalToLocal(position_out,position_out,loc_hitPos_o); 
  if(!onSurface_o) { 
    ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::getPosAndIdWireOut Amg::Vector2D* loc_hitPos_o is null."); 
    return false; 
  } 
  tmp_hitPos_o[Trk::locY] = loc_hitPos_o[Trk::loc2];
  
  channelIdOut_tmp = channelIdOut[1];
  
  return true;
}

◆ getRfromEtaZ()

bool Muon::TgcRdoToPrepDataToolMT::getRfromEtaZ	(	const double	eta,
		const double	z,
		double &	r )

staticprivate

Get r from eta and z.

Definition at line 1474 of file TgcRdoToPrepDataToolMT.cxx.

{
  r = exp(-eta); // tan(theta/2)
  r = atan(r); // theta/2
  r = tan(2.*r); // tan(theta)
  r *= std::abs(z); // r=|z|*tan(theta)
 
  return r >= 0.;
}

◆ getRoiRow()

int Muon::TgcRdoToPrepDataToolMT::getRoiRow ( const TgcRawData & rd )

staticprivate

Get ROI row from RDO.

Definition at line 1583 of file TgcRdoToPrepDataToolMT.cxx.

{
  int RoiRow = static_cast<int>(rd.roi()/4);
  return RoiRow;
}

◆ getSbLocOfEndcapStripBoundaryFromHiPt()

bool Muon::TgcRdoToPrepDataToolMT::getSbLocOfEndcapStripBoundaryFromHiPt	(	const TgcRawData &	rd,
		int &	sbLoc,
		const TgcRdo *	rdoColl,
		const int	index_w,
		const int	chip_w,
		const int	hitId_w,
		const int	sub_w ) const

private

Get strip sbLoc of Endcap chamber boundary from HiPt Strip.

Definition at line 2622 of file TgcRdoToPrepDataToolMT.cxx.

{ 
  const CablingInfo* cinfo = getCabling();
  if (!cinfo) {
    return false;
  }
 
  bool exist_hipt_s = false;
  
  // Get trackletIds of three candidates 
  int trackletIdStripFirst{-1}, trackletIdStripSecond{-1}, trackletIdStripThird{-1};
  getEndcapStripCandidateTrackletIds(static_cast<int>(rd.roi()), trackletIdStripFirst, 
                     trackletIdStripSecond, trackletIdStripThird); 
 
  // Loop over all HiPt Strip to find an associated one
  for (const TgcRawData* rdH0 : *rdoColl) {
 
    // conversion for Run3
    uint16_t tmprodId, tmpsector;
    convertToRun2(rdH0,tmprodId,tmpsector);
    const TgcRawData rdH(rdH0->bcTag(), rdH0->subDetectorId(), tmprodId,
                         rdH0->l1Id(), rdH0->bcId(), rdH0->isStrip(),
                         rdH0->isForward(), tmpsector, rdH0->chip(),
                         rdH0->index(),rdH0->isHipt(), rdH0->hitId(),
                         rdH0->hsub(), rdH0->delta(), rdH0->inner());
 
    if((rdH.type()==TgcRawData::TYPE_HIPT) && // HiPt
       (rdH.isHipt()) && // HiPt flag is required
       (rdH.isStrip()) && // Strip
       (!rdH.isForward()) && // Endcap
       (rdH.bcTag()==rd.bcTag()) && // The same timing
       (rdH.subDetectorId()==rd.subDetectorId()) && // The same side
       (rdH.rodId()==rd.rodId()) && // The same ROD
       (rdH.sector()==rd.sector()) // The same sector (1/48 phi)
       ) {
 
      // Get sbLoc
      int sswId_o{0}, sbLoc_o{0}, slbId_o{0};
      bool found = getHiPtIds(rdH, sswId_o, sbLoc_o, slbId_o);
      if(!found){
        continue;
      }
 
      // Get subMatrix
      int slbsubMatrix = 0;
      std::array<int, 2> bitpos_o{};
      getBitPosOutStrip(rdH, slbsubMatrix, bitpos_o);
 
      // Get trackletId 
      int trackletIdStrip = 2*sbLoc_o + slbsubMatrix;
 
      // Compare trackletIds 
      if(trackletIdStrip!=trackletIdStripFirst &&  trackletIdStrip!=trackletIdStripSecond && 
         trackletIdStrip!=trackletIdStripThird) continue; 
 
      // The third candidate is used only if any corresponding HiPt Strip is found so far.  
      if(exist_hipt_s && trackletIdStrip==trackletIdStripThird) continue;
 
      // getRDOHighPtIDfromSimHighPtID overwrites index, chip and hitId. 
      int index_w_tmp = index_w;
      int chip_w_tmp = chip_w;
      int hitId_w_tmp = hitId_w;
      // Get RDO HighPt ID from SimHighPtID for wire 
      found = cinfo->m_tgcCabling->getRDOHighPtIDfromSimHighPtID(false, // false for endcap
                                                                 false, // wire
                                                                 index_w_tmp,
                                                                 chip_w_tmp,
                                                                 hitId_w_tmp);
      if(!found) {
        ATH_MSG_DEBUG("Failed to get RDOHighPtID from SimHighPtID for Wire");
        continue;
      }
 
      // RDO High Pt ID of Strip 
      int chip_s = static_cast<int>(rdH.chip());
      int hitId_s = static_cast<int>(rdH.hitId());
      int hsub_s = static_cast<int>(rdH.hsub());
 
      int roi = 0;
      found = cinfo->m_tgcCabling->getROINumberfromHighPtID(roi,
                                                            false, // false for Endcap
                                                            index_w_tmp, // hpb_wire (not used)
                                                            chip_w_tmp, // chip_wire
                                                            hitId_w_tmp, // hitId_wire
                                                            sub_w, // sub_wire
                                                            chip_s, // chip_strip (not used)
                                                            hitId_s, // hitId_strip 
                                                            hsub_s); // sub_strip
      if(!found) {
        ATH_MSG_DEBUG("Failed to get ROINumber from HighPtID for Strip");
        continue;
      }
      
      if(roi==rd.roi()) { 
        sbLoc = sbLoc_o;
        exist_hipt_s = true;
        if(trackletIdStrip==trackletIdStripFirst) break; // If the first candidate is found, exit from this for loop
      }
    }
  }
 
  return exist_hipt_s;
}

◆ getSbLocOfEndcapStripBoundaryFromTracklet()

bool Muon::TgcRdoToPrepDataToolMT::getSbLocOfEndcapStripBoundaryFromTracklet	(	const TgcRawData &	rd,
		int &	sbLoc,
		const TgcRdo *	rdoColl,
		const int	index_w,
		const int	chip_w,
		const int	hitId_w,
		const int	sub_w ) const

private

Get strip sbLoc of Endcap chamber boundary from Tracklet Strip.

Definition at line 2728 of file TgcRdoToPrepDataToolMT.cxx.

{
  const CablingInfo* cinfo = getCabling();
 
  bool exist_tracklet_s = false;
  
  // Get trackletIds of three candidates 
  int trackletIdStripFirst{-1}, trackletIdStripSecond{-1}, trackletIdStripThird{-1};
  getEndcapStripCandidateTrackletIds(static_cast<int>(rd.roi()), trackletIdStripFirst, 
                     trackletIdStripSecond, trackletIdStripThird); 
  
  // Loop over all Tracklet Strip to find an associated one
  for (const TgcRawData* rdS0 : *rdoColl) {
 
    // conversion for Run3
    uint16_t tmprodId{0}, tmpsector{0};
    convertToRun2(rdS0,tmprodId,tmpsector);
    const TgcRawData rdS(rdS0->bcTag(), rdS0->subDetectorId(), tmprodId,
                         rdS0->sswId(), rdS0->slbId(), rdS0->l1Id(),
                         rdS0->bcId(), rdS0->slbType(), rdS0->delta(),
                         rdS0->segment(), rdS0->subMatrix(), rdS0->position());
    
    bool isForward_s = (rdS.sswId()==7); // Doublet, Forward
    if(isForward_s) continue; // Chamber boundaries exist in endcap only
 
    if((rdS.type()==TgcRawData::TYPE_TRACKLET) &&
       (rdS.slbType()==TgcRawData::SLB_TYPE_DOUBLET_STRIP) &&
       (rdS.bcTag()==rd.bcTag()) &&
       (rdS.subDetectorId()==rd.subDetectorId()) &&
       (rdS.rodId()==rd.rodId()) &&
       (rdS.sswId()-3==rd.sector()) // SSW3: M3-EC phi0, SSW4: M3-EC phi1, SSW5: M3-EC phi2, SSW6: M3-EC phi3
       ) {
 
      // Compare trackletIds 
      int trackletIdStrip = static_cast<int>(2*rdS.slbId()+rdS.subMatrix()); // trackletId of Tracklet Strip
      if(trackletIdStrip!=trackletIdStripFirst && 
     trackletIdStrip!=trackletIdStripSecond && 
     trackletIdStrip!=trackletIdStripThird) continue; 
 
      // The third candidate is used only if any corresponding Tracklet Strip is found so far.
      if(exist_tracklet_s && trackletIdStrip==trackletIdStripThird) continue;
      
      Identifier offlineId;
      bool found = cinfo->m_tgcCabling->getOfflineIDfromLowPtCoincidenceID(offlineId, rdS.subDetectorId(), rdS.rodId(),
                                                                  rdS.sswId(), rdS.slbId(), rdS.subMatrix(),
                                                                  rdS.position(), false);
      if(!found) {
        ATH_MSG_DEBUG("Failed to get OfflineID from LowPtCoincidenceID for Strip");
        continue;
      }
      
      std::array<int, 7> i{};
      std::array<bool, 2> b{};
      found = cinfo->m_tgcCabling->getHighPtIDfromOfflineID(offlineId,i[0],i[1],i[2],b[0],b[1],i[3],i[4],i[5],i[6]);
      // i[0] subDetectorID, i[1] rodID, i[2] sectorInReadout, b[0] isStrip, 
      // b[1] isForward, i[3] hpb, i[4] chip, i[5] hitID, i[6] pos
      
      if(!found) {
        ATH_MSG_DEBUG("Failed to get HighPtID from OfflineID for Strip");
        continue;
      }
 
      // getRDOHighPtIDfromSimHighPtID overwrites index, chip and hitId. 
      int index_w_tmp = index_w;
      int chip_w_tmp = chip_w;
      int hitId_w_tmp = hitId_w;
      found = cinfo->m_tgcCabling->getRDOHighPtIDfromSimHighPtID(rd.isForward(), // false for endcap
                                                                 false, // wire
                                                                 index_w_tmp, // hpb-index
                                                                 chip_w_tmp, // chip-chip
                                                                 hitId_w_tmp); // hitID-hitId
      if(!found) {
        ATH_MSG_DEBUG("Failed to get RDOHighPtID from SimHighPtID for Wire");
        continue;
      }
      
      found = cinfo->m_tgcCabling->getRDOHighPtIDfromSimHighPtID(rd.isForward(), // false for endcap
                                                                 true, // strip
                                                                 i[3], // hpb-index
                                                                 i[4], // chip-chip
                                                                 i[5]); // hitID-hitId
      if(!found) {
        ATH_MSG_DEBUG("Failed to get RDOHighPtID from SimHighPtID for Strip");
        continue;
      }
      
      int roi = 0;
      found = cinfo->m_tgcCabling->getROINumberfromHighPtID(roi, 
                                                            rd.isForward(), // false for endcap
                                                            index_w_tmp, // hpb_wire (not used)
                                                            chip_w_tmp, // chip_wire
                                                            hitId_w_tmp, // hitId_wire
                                                            sub_w, // sub_wire
                                                            i[4], // chip_strip (not used)
                                                            i[5], // hitId_strip
                                                            i[6]); // sub_strip
      if(!found) {
        ATH_MSG_DEBUG("Failed to get ROINumber from HighPtID for Strip");
        continue;
      }
      
      if(roi==rd.roi()) { 
        sbLoc = rdS.slbId();
        exist_tracklet_s = true;
        if(trackletIdStrip==trackletIdStripFirst) break; // If the first candidate is found, exit from this for loop 
      }
    }
  }
 
  return exist_tracklet_s;
}

◆ getSLIds()

bool Muon::TgcRdoToPrepDataToolMT::getSLIds	(	const bool	isStrip,
		const TgcRawData &	rd,
		std::array< Identifier, 3 > &	channelId,
		int &	index,
		int &	chip,
		int &	hitId,
		int &	sub,
		int &	sswId,
		int &	sbLoc,
		int &	subMatrix,
		std::array< int, 3 > &	bitpos,
		const bool	isBoundary = false,
		const TgcRdo *	rdoColl = 0,
		const int	index_w = -1,
		const int	chip_w = -1,
		const int	hitId_w = -1,
		const int	sub_w = -1 ) const

private

Get ReadoutID of SL from RDO.

Definition at line 2503 of file TgcRdoToPrepDataToolMT.cxx.

{
  const CablingInfo* cinfo = getCabling();
  if (!cinfo) {
    return false;
  }
 
  bool found = cinfo->m_tgcCabling->getHighPtIDfromROINumber(rd.roi(),
                                                    rd.isForward(),
                                                    isStrip, // get HitID of HPT Board
                                                    index,
                                                    chip,
                                                    hitId,
                                                    sub);
  if(!found) {
    ATH_MSG_DEBUG("Failed to get HighPtID from ROINumber for "
          << (!isStrip ? "Wire" : "Strip"));
    return false;
  }
  
  found = cinfo->m_tgcCabling->getSimHighPtIDfromRDOHighPtID(rd.isForward(),
                                                    isStrip,
                                                    index,
                                                    chip,
                                                    hitId);
  if(!found) {
    ATH_MSG_DEBUG("Failed to get SimHighPtID from RDOHighPtID for "
          << (!isStrip ? "Wire" : "Strip"));
    return false;
  }
  
  Identifier offlineId;
  found = cinfo->m_tgcCabling->getOfflineIDfromHighPtID(offlineId,
                           rd.subDetectorId(),
                           rd.rodId(),
                           rd.sector(),
                           isStrip,
                           rd.isForward(),
                           index,
                           chip,
                           hitId,
                           sub);
  if(!found) {
    ATH_MSG_DEBUG("Failed to get OfflineID from HighPtID for "
          << (!isStrip ? "Wire" : "Strip"));
    return false;
  }
    
  if(!isStrip || !isBoundary) { // Wire or strip whose ROI not including chamber boundary
    channelId[1] = offlineId;
    std::array<int, 3> dummy_i{};
    found = cinfo->m_tgcCabling->getReadoutIDfromOfflineID(channelId[1], 
                                                  dummy_i[0],
                                                  dummy_i[1],
                                                  sswId,
                                                  sbLoc,
                                                  dummy_i[2]);
    if(!found) {
      ATH_MSG_DEBUG("Failed to get ReadoutID from OfflineID for "
            << (!isStrip ? "Wire" : "Strip"));
      return false;
    }
  } else { // --> solving the chamber boundary of strip 
    sswId = rd.sector()+3; // SSW3: M3-EC phi0, SSW4: M3-EC phi1, SSW5: M3-EC phi2, SSW6: M3-EC phi3 
 
    // Loop over all HiPt Strip to find an associated one to obtain sbLoc
    bool exist_hipt_s = getSbLocOfEndcapStripBoundaryFromHiPt(rd, sbLoc, rdoColl, index_w, chip_w, hitId_w, sub_w);
    if(!exist_hipt_s) { 
      // Loop over all Tracklet Strip to find an associated one to obtain sbLoc 
      bool exist_tracklet_s = getSbLocOfEndcapStripBoundaryFromTracklet(rd, sbLoc, rdoColl, index_w, chip_w, hitId_w, sub_w);
      if(!exist_tracklet_s) { 
    ATH_MSG_DEBUG("Failed to find correspond Tracklet_strip for SL!!");
    return false;
      }
    }
  }
 
  if(!isStrip) { // wire
    getBitPosWire(rd, hitId, sub, subMatrix, bitpos);
  } else { // strip
    getBitPosStrip(hitId, sub, subMatrix, bitpos);
  } 
  
  for(int i=0; i<3; i++) { 
    if(i==1 && (!isStrip || !isBoundary)) continue; 
    
    found = cinfo->m_tgcCabling->getOfflineIDfromReadoutID(channelId[i],
                                                  rd.subDetectorId(),
                                                  rd.rodId(),
                                                  sswId,
                                                  sbLoc,
                                                  bitpos[i]);
    if(!found) {
      ATH_MSG_DEBUG("Failed to get OfflineID from ReadoutID for " 
            << (!isStrip ? "Wire" : "Strip"));
      if(!isStrip || i==1) {
    ATH_MSG_DEBUG("subDetectorId = " << rd.subDetectorId()
              << ", rodId = " << rd.rodId()
              << ", sswId = " << sswId
              << ", slbId = " << sbLoc
              << ", bitpos_" << (!isStrip ? "w" : "s") 
              << "[" << i << "] = " << bitpos[i]);
      }
      return false;
    }
  }
 
  return true;
}

◆ getSLLocalPosition()

const Amg::Vector2D * Muon::TgcRdoToPrepDataToolMT::getSLLocalPosition	(	const MuonGM::TgcReadoutElement *	readout,
		const Identifier	identify,
		const double	eta,
		const double	phi )

staticprivate

Get SL local position.

Definition at line 2947 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                        { 
  if(!readout) return nullptr;  
  
  // Obtain the local coordinate by the secant method
  constexpr double length = 100.; // 100 mm
  constexpr unsigned int nRep = 10; // 10 repetitions
  constexpr double dRAccuracy = 1.0E-20; // recuqired dR accuracy
  constexpr double maxLocR = 10000.; // 10 m
  
  double locX = 0.;  
  double locY = 0.;  
  for(unsigned int iRep=0; iRep<nRep; iRep++) { 
    Amg::Vector2D loc_hitPos_c(locX, locY); // center or current position 
    Amg::Vector3D tmp_glob_hitPos_c{Amg::Vector3D::Zero()};
    readout->surface(identify).localToGlobal(loc_hitPos_c,tmp_glob_hitPos_c,tmp_glob_hitPos_c);
    const Amg::Vector3D &glob_hitPos_c  = tmp_glob_hitPos_c;
 
    double glob_eta_c = glob_hitPos_c.eta();
    double glob_phi_c = glob_hitPos_c.phi();
 
    Amg::Vector2D vector{eta - glob_eta_c,  deltaPhi(phi, glob_phi_c)};
      
    double dR =  std::hypot(vector[0], vector[1]);
    if(dR<dRAccuracy) {
    break;
    }
      
    Amg::Vector2D loc_hitPos_w(locX+length, locY       ); // slightly shifted position in the wire direction 
    Amg::Vector2D loc_hitPos_s(locX,        locY+length); // slightly shifted position in the strip direction 
    Amg::Vector3D tmp_glob_hitPos_w{Amg::Vector3D::Zero()}; 
    readout->surface(identify).localToGlobal(loc_hitPos_w,tmp_glob_hitPos_w,tmp_glob_hitPos_w);
    const Amg::Vector3D &glob_hitPos_w = tmp_glob_hitPos_w;
    Amg::Vector3D tmp_glob_hitPos_s{Amg::Vector3D::Zero()}; 
    readout->surface(identify).localToGlobal(loc_hitPos_s,tmp_glob_hitPos_s,tmp_glob_hitPos_s);
    const Amg::Vector3D &glob_hitPos_s = tmp_glob_hitPos_s;
      
    AmgSymMatrix(2) matrix{AmgSymMatrix(2)::Identity()};
    matrix(0,0) = glob_hitPos_w.eta() - glob_eta_c;
    matrix(1,0) = deltaPhi(glob_hitPos_w.phi(), glob_phi_c);   
    matrix(0,1) = glob_hitPos_s.eta() - glob_eta_c;
    matrix(1,1) = deltaPhi(glob_hitPos_s.phi(), glob_phi_c);
   
    bool invertible = matrix.determinant();
    if(invertible) {
      Amg::MatrixX invertedMatrix = matrix.inverse();
      Amg::Vector2D solution = invertedMatrix * vector;
      locX += length * solution(0,0);
      locY += length * solution(1,0);
      
      double locR = sqrt(locX*locX + locY*locY);
      if(locR>maxLocR) {
        locX *= maxLocR/locR;
        locY *= maxLocR/locR;
      }
    }
  }
  
  return new Amg::Vector2D(locX, locY); 
} 

◆ getSLStripGeometry()

bool Muon::TgcRdoToPrepDataToolMT::getSLStripGeometry	(	const std::array< Identifier, 3 > &	channelId_strip,
		const bool	isBackWard,
		const bool	isAside,
		double &	width_strip,
		double &	theta_strip ) const

private

Get strip geometry (width, theta) for SL.

Definition at line 2053 of file TgcRdoToPrepDataToolMT.cxx.

{
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
  const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
  std::array<const MuonGM::TgcReadoutElement*, 3> descriptor_s{muDetMgr->getTgcReadoutElement(channelId_strip[0]), 
                                                               muDetMgr->getTgcReadoutElement(channelId_strip[1]), 
                                                               muDetMgr->getTgcReadoutElement(channelId_strip[2])};
  for(int i=0; i<3; i++) {
    if(!isOfflineIdOKForTgcReadoutElement(descriptor_s[i], channelId_strip[i])) {
      return false;
    }
  }
  
  Amg::Vector3D position_s = Amg::Vector3D(descriptor_s[1]->channelPos(channelId_strip[1]));
  Amg::Vector2D loc_hitPos_s;
  bool onSurface_s = descriptor_s[1]->surface(channelId_strip[1]).globalToLocal(position_s,position_s,loc_hitPos_s);
  if(!onSurface_s) { 
    ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::getSLStripGeometry Amg::Vector2D* loc_hitPos_s is null."); 
    return false; 
  } 
  Amg::Vector2D tmp_hitPos_s{Amg::Vector2D::Zero()};
  
  std::array<int, 3> gasGap_s, channel_s{};
  for(int i=0; i<3; i++) {
    gasGap_s[i] = m_idHelperSvc->tgcIdHelper().gasGap(channelId_strip[i]);
    channel_s[i] = m_idHelperSvc->tgcIdHelper().channel(channelId_strip[i]);
  }
 
  std::array<Amg::Vector3D, 3> localPos{Amg::Vector3D::Zero()};
  for(int i=0; i<3; i+=2) { // i=0 and 2
    localPos[i] = descriptor_s[i]->transform(channelId_strip[i]).inverse()
      *descriptor_s[i]->channelPos(channelId_strip[i]);
  }
  
  bool flag_reverse = false;
  std::array<int, 2> index_strip{};
 
  if(!isBackward) { // Forward chamber
    if(isAside) { // Aside/Forward Chamber
      index_strip[0] = 2; index_strip[1] = 0; flag_reverse = true;
    } else { // Cside/Forward Chamber
      index_strip[0] = 0; index_strip[1] = 2; flag_reverse = false;
    }
  } else { // Backward chamber   
    if(isAside) { // Aside/Backward Chamber
      index_strip[0] = 0; index_strip[1] = 2; flag_reverse = true;
    } else { // Cside/Backward Chamber
      index_strip[0] = 2; index_strip[1] = 0; flag_reverse = false;
    }
  }
  
  double stripMaxX = descriptor_s[index_strip[0]]->stripHighEdgeLocX(gasGap_s[index_strip[0]], channel_s[index_strip[0]], 
                                 localPos[index_strip[0]].z());
  double stripMinX = descriptor_s[index_strip[1]]->stripLowEdgeLocX(gasGap_s[index_strip[1]], channel_s[index_strip[1]], 
                                 localPos[index_strip[1]].z());
  width_strip = stripMaxX - stripMinX;
  double strip = stripMinX +  width_strip/2.;
  if(flag_reverse) strip *= -1.;
  
  tmp_hitPos_s[Trk::locX] = strip;
  tmp_hitPos_s[Trk::locY] = loc_hitPos_s[Trk::loc2];
  
  int index_strip_gp = 0;
  if(!isBackward) index_strip_gp = 0;
  else index_strip_gp = 2;
  Amg::Vector3D tmp_strip_gp; 
  descriptor_s[index_strip_gp]->surface(channelId_strip[index_strip_gp]).localToGlobal(tmp_hitPos_s,tmp_strip_gp,tmp_strip_gp);
  theta_strip = atan2(tmp_strip_gp.y(), tmp_strip_gp.x()); 
 
  
  return true;
}

◆ getSLWireGeometry()

bool Muon::TgcRdoToPrepDataToolMT::getSLWireGeometry	(	const std::array< Identifier, 3 > &	channelId_wire,
		double &	width_wire,
		double &	r_wire,
		double &	z_wire ) const

private

Get wire geometry (width, r, z) for SL.

Definition at line 1984 of file TgcRdoToPrepDataToolMT.cxx.

{
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
  const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
  std::array<const MuonGM::TgcReadoutElement*, 3> descriptor_w{muDetMgr->getTgcReadoutElement(channelId_wire[0]), 
                                                               muDetMgr->getTgcReadoutElement(channelId_wire[1]), 
                                                               muDetMgr->getTgcReadoutElement(channelId_wire[2])};
  for(int i=0; i<3; i++) {
    if(!isOfflineIdOKForTgcReadoutElement(descriptor_w[i], channelId_wire[i])) {
      return false;
    }
  }
 
  Amg::Vector3D position_w = descriptor_w[2]->channelPos(channelId_wire[2]);
  Amg::Vector2D loc_hitPos_w{Amg::Vector2D::Zero()};
  bool onSurface_w = descriptor_w[2]->surface(channelId_wire[2]).globalToLocal(position_w,position_w,loc_hitPos_w);
  if(!onSurface_w) { 
    ATH_MSG_WARNING("Muon::TgcRdoToPrepDataToolMT::getSLWireGeometry Amg::Vector2D* loc_hitPos_w is null."); 
    return false; 
  } 
  Amg::Vector2D tmp_hitPos_w{Amg::Vector2D::Zero()};
 
  std::array<int, 3> gasGap_w{}, channel_w{};
  for(int i=0; i<3; i++) {
    gasGap_w[i] = m_idHelperSvc->tgcIdHelper().gasGap(channelId_wire[i]);
    channel_w[i] = m_idHelperSvc->tgcIdHelper().channel(channelId_wire[i]);
  }
  
  std::array<double,3> tmp_r_w{}, tmp_phi_w{}, tmp_eta_w{};
  
  std::array<Amg::Vector3D,3> tmp_position_w{make_array<Amg::Vector3D, 3>(Amg::Vector3D::Zero())};
  for(int i=0; i<3; i+=2) { // i=0 and 2
    tmp_position_w[i] = descriptor_w[i]->channelPos(channelId_wire[i]);
    tmp_r_w[i] = tmp_position_w[i].perp();
    tmp_phi_w[i] = tmp_position_w[i].phi();
    tmp_eta_w[i] = tmp_position_w[i].eta();
  
    double half_width = descriptor_w[i]->gangRadialLength(gasGap_w[i], channel_w[i])/2.;
    if(half_width<s_cutDropPrdsWithZeroWidth/2. && m_dropPrdsWithZeroWidth) { // Invalid PRD's whose widths are zero are dropped.
      return false;
    }
    // add half widths of edge channels
    if(i==0) {
      tmp_r_w[0] += half_width;
    } else if(i==2) {
      tmp_r_w[2] -= half_width;
    }
  }
  
  bool flag_geteta_w = getEtafromRZ(tmp_r_w[0], tmp_position_w[0].z(), tmp_eta_w[0]);
  bool flag_getr_w = getRfromEtaZ(tmp_eta_w[0], tmp_position_w[2].z(), tmp_r_w[0]);
  if(!flag_geteta_w || !flag_getr_w) {
    ATH_MSG_DEBUG("TgcRdoToPrepDataToolMT::getSLWireGeometry::failed to getR on L7!!");
    return false;
  }  
  width_wire = tmp_r_w[0] - tmp_r_w[2];
  double gang = descriptor_w[2]->gangShortWidth(gasGap_w[2],channel_w[2]) + width_wire/2.;
  tmp_hitPos_w[Trk::locX] = gang;
  tmp_hitPos_w[Trk::locY] = ((loc_hitPos_w)[Trk::loc2]);
 
  Amg::Vector3D tmp_wire_gp;
  descriptor_w[2]->surface(channelId_wire[2]).localToGlobal(tmp_hitPos_w,tmp_wire_gp,tmp_wire_gp);
  z_wire = tmp_wire_gp.z();
  r_wire = tmp_r_w[2] + width_wire/2.;
 
  return true;
}

◆ getTrackletInfo()

bool Muon::TgcRdoToPrepDataToolMT::getTrackletInfo	(	const TgcRawData &	rd,
		int &	tmp_slbId,
		int &	tmp_subMatrix,
		int &	tmp_position ) const

private

Retrieve slbId, subMatrix and position from Tracklet RDO.

Definition at line 1507 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                                {
  tmp_subMatrix = rd.subMatrix();
  if(tmp_subMatrix!=0 && tmp_subMatrix!=1) {
    ATH_MSG_DEBUG("getTrackletInfo: subMatrix " << tmp_subMatrix << " is invalid.");
    return false;
  }
  
  int tmp_sswId = rd.sswId();
  tmp_slbId = rd.slbId();
  tmp_position = rd.position();
  
  int tmp_position_delta = tmp_position + rd.delta();
  int tmp_slbType = rd.slbType();
 
  if(tmp_position_delta>=BIT_POS_INPUT_SIZE) {
    tmp_position = tmp_position_delta-BIT_POS_INPUT_SIZE;
    if(tmp_subMatrix==1) {
      if(tmp_slbType==TgcRawData::SLB_TYPE_DOUBLET_STRIP) {
    tmp_position = BIT_POS_INPUT_SIZE-1;
    ATH_MSG_DEBUG("Expected TGC2 Strip position (" << tmp_position_delta <<  
              ") does not exist and is changed to the edge position " << tmp_position);
      } else if((tmp_slbType==TgcRawData::SLB_TYPE_DOUBLET_WIRE) && (tmp_sswId==7) && ((tmp_slbId==3) || (tmp_slbId==11))) { 
    // upper edge SLB of FWD:sbLoc3,11
    ATH_MSG_DEBUG("sbLoc " << tmp_slbId+1 << " doesn't exist for FWD!! (upper edge SLB of FWD:sbLoc3,11)");
        return false;
      } else if((tmp_slbType==TgcRawData::SLB_TYPE_DOUBLET_WIRE) && (tmp_sswId!=7) && (tmp_slbId==9)) { 
    // upper edge SLB of EWD:sbLoc9
    ATH_MSG_DEBUG("sbLoc " << tmp_slbId+1 << " doesn't exist for EWD!! (upper edge SLB of EWD:sbLoc9)");
        return false;
      } else { 
    // Valid sbLoc,delta,blockpos
        tmp_subMatrix = 0;
        tmp_slbId++;
      }
    } else {
      tmp_subMatrix = 1;
    }
  } else if(tmp_position_delta<0) {
    tmp_position = tmp_position_delta+BIT_POS_INPUT_SIZE;
    if(tmp_subMatrix==0) { 
      if(tmp_slbType==TgcRawData::SLB_TYPE_DOUBLET_STRIP) {
    tmp_position = 0;
    ATH_MSG_DEBUG("Expected TGC2 Strip position (" << tmp_position_delta <<  
              ") does not exist and is changed to the edge position " << tmp_position);
      } else if((tmp_slbType==TgcRawData::SLB_TYPE_DOUBLET_WIRE) && (tmp_sswId==7) && ((tmp_slbId==0) || (tmp_slbId==8))) { 
    // bottom edge SLB of FWD:sbLoc0,8
    if(tmp_position_delta==-1) { // This case is valid. 
      tmp_position = 0; 
    } else { 
      ATH_MSG_DEBUG("sbLoc " << tmp_slbId-1 << " doesn't exist for FWD!! (bottom edge SLB of FWD:sbLoc0,8)");
      return false;
    }
      } else if((tmp_slbType==TgcRawData::SLB_TYPE_DOUBLET_WIRE) &&(tmp_sswId!=7) && (tmp_slbId==0)) { 
    // bottom edge SLB of EWD:sbLoc0
    if(tmp_position_delta==-1) { // This case is valid. 
      tmp_position = 0; 
    } else { 
      ATH_MSG_DEBUG("sbLoc " << tmp_slbId-1 << " doesn't exist for EWD!! (bottom edge SLB of EWD:sbLoc0)");
      return false;
    }
      } else { 
    // Valid sbLoc,delta,
        tmp_subMatrix = 1;
        tmp_slbId--;
      }
    } else {
      tmp_subMatrix = 0;
    }
  } else {
    tmp_position = tmp_position_delta;
  }
 
  return true;
}

◆ initialize()

StatusCode Muon::TgcRdoToPrepDataToolMT::initialize ( )

overridevirtual

Standard AthAlgTool initialize method.

Definition at line 25 of file TgcRdoToPrepDataToolMT.cxx.

{
  ATH_CHECK(m_idHelperSvc.retrieve());
 
  m_outputprepdataKeys.resize(NBC_HIT+1);
  for (int ibc=0; ibc < NBC_HIT+1; ibc++) {
    int bcTag = ibc+1;
    std::ostringstream location;
    location << m_outputCollectionLocation.value()
             << (bcTag==TgcDigit::BC_PREVIOUS ? "PriorBC" : "")
             << (bcTag==TgcDigit::BC_CURRENT ? "" : "")
         << (bcTag==TgcDigit::BC_NEXT ? "NextBC" : "")
             << (bcTag==(NBC_HIT+1) ? "AllBCs" : "");    
    m_outputprepdataKeys.at(ibc) = location.str();
  }
 
  m_outputCoinKeys.resize(NBC_TRIG);
  for (int ibc=0; ibc < NBC_TRIG; ibc++) {
    int bcTag = ibc+1;
    std::ostringstream location;
    location << m_outputCoinCollectionLocation.value()
             << (bcTag==TgcDigit::BC_PREVIOUS ? "PriorBC" : "")
             << (bcTag==TgcDigit::BC_NEXT ? "NextBC" : "")
             << (bcTag==TgcDigit::BC_NEXTNEXT ? "NextNextBC" : "");
    m_outputCoinKeys.at(ibc) = location.str();
  }
 
  ATH_CHECK(m_outputCoinKeys.initialize());
  ATH_CHECK(m_outputprepdataKeys.initialize());
  ATH_CHECK(m_muDetMgrKey.initialize());
 
  // check if initializing of DataHandle objects success
  ATH_CHECK( m_rdoContainerKey.initialize() );
 
  //try to configure the cabling service
  if (!getCabling()) {
    // ??? Is this delayed initialization still needed?
    ATH_MSG_INFO("MuonTGC_CablingSvc not yet retrieved; postpone TGCcabling initialization at first event.");
  }
 
  // Build names for the keys same as done for output containers
  if (not m_prdContainerCacheKeyStr.empty()) {
    m_prdContainerCacheKeys.resize(NBC_HIT+1);
    for (int ibc=0; ibc < NBC_HIT+1; ibc++) {
      int bcTag = ibc+1;
      std::ostringstream location;
      location << m_prdContainerCacheKeyStr.value()
               << (bcTag==TgcDigit::BC_PREVIOUS ? "PriorBC" : "")
               << (bcTag==TgcDigit::BC_CURRENT ? "" : "")
               << (bcTag==TgcDigit::BC_NEXT ? "NextBC" : "")
               << (bcTag==(NBC_HIT+1) ? "AllBCs" : "");    
      m_prdContainerCacheKeys.at(ibc) = location.str();
      ATH_MSG_DEBUG(location.str());      
    }
  }
 
  if (not m_coinContainerCacheKeyStr.empty()){
    m_coinContainerCacheKeys.resize(NBC_TRIG);
    for (int ibc=0; ibc < NBC_TRIG; ibc++) {
      int bcTag = ibc+1;
      std::ostringstream location;
      location << m_coinContainerCacheKeyStr.value()
               << (bcTag==TgcDigit::BC_PREVIOUS ? "PriorBC" : "")
               << (bcTag==TgcDigit::BC_NEXT ? "NextBC" : "")
               << (bcTag==TgcDigit::BC_NEXTNEXT ? "NextNextBC" : "");
      m_coinContainerCacheKeys.at(ibc) = location.str();
      ATH_MSG_DEBUG(location.str());
    }
  }
 
  // Only initialise if we passed in the cache name
  ATH_CHECK( m_prdContainerCacheKeys.initialize( not m_prdContainerCacheKeyStr.empty() ) );
  ATH_CHECK( m_coinContainerCacheKeys.initialize( not m_coinContainerCacheKeyStr.empty() ) );
  
  ATH_CHECK(m_xAODKey.initialize(!m_xAODKey.empty()));
  return StatusCode::SUCCESS;
}

◆ isAlreadyConverted()

bool Muon::TgcRdoToPrepDataToolMT::isAlreadyConverted	(	const std::vector< const TgcRdo * > &	decodedRdoCollVec,
		const std::vector< const TgcRdo * > &	rdoCollVec,
		const TgcRdo *	rdoColl )

staticprivate

Check the rdo is already converted or not.

◆ isBackwardBW()

bool Muon::TgcRdoToPrepDataToolMT::isBackwardBW ( const TgcRawData & rd )

staticprivate

Check if a chamber in BigWheel is a backward chamber or a forward chamber.

Definition at line 1960 of file TgcRdoToPrepDataToolMT.cxx.

{
  bool isBackward = false;
 
  if(!rd.isForward()) { // Endcap
    if(((rd.subDetectorId()==ASIDE) && (rd.sector()%2==1)) ||
       ((rd.subDetectorId()==CSIDE) && (rd.sector()%2==0))) {
      // Aside,phi_odd::Backward
      // Cside,phi_even::Backward
      isBackward = true;
    } else {
      // Aside,phi_even::Forward
      // Cside,phi_odd::Forward
      isBackward = false;
    }
  } else { // Forward
    // Aide::Backward
    // Cside::Forward
    isBackward = (rd.subDetectorId()==ASIDE);
  }
 
  return isBackward;
}

◆ isIncludedInChamberBoundary()

bool Muon::TgcRdoToPrepDataToolMT::isIncludedInChamberBoundary ( const TgcRawData & rd ) const

private

Check SL RDO is at the chamber boundary.

Definition at line 1589 of file TgcRdoToPrepDataToolMT.cxx.

{
  int RoiRow = getRoiRow(rd);
 
  if(!rd.isForward() && 
     (RoiRow== 3 || RoiRow== 4 || // SSC 2 : ROI 12-19
      RoiRow== 7 || RoiRow== 8 || // SSC 4 : ROI 28-35
      RoiRow==11 || RoiRow==12 || // SSC 6 : ROI 44-51
      RoiRow==23 || RoiRow==24    // SSC12 : ROI 92-99
      )) {
    return true;
  }
  return false;
}

◆ isOfflineIdOKForTgcReadoutElement()

bool Muon::TgcRdoToPrepDataToolMT::isOfflineIdOKForTgcReadoutElement	(	const MuonGM::TgcReadoutElement *	descriptor,
		const Identifier	channelId ) const

private

Check offline ID is OK for TgcReadoutElement.

Definition at line 1498 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                                       {
  if(!descriptor || !descriptor->containsId(channelId)) {
    ATH_MSG_DEBUG("Illegal OfflineID for TgcReadoutElement" << m_idHelperSvc->toString(channelId));
    return false;
  }
  return true;
}

◆ isRequested()

bool Muon::TgcRdoToPrepDataToolMT::isRequested	(	const std::vector< IdentifierHash > &	requestedIdHashVect,
		IdentifierHash	tgcHashId )

staticprivate

Check the IdHash is already requested or not.

◆ provideEmptyContainer()

StatusCode Muon::TgcRdoToPrepDataToolMT::provideEmptyContainer ( const EventContext & ctx ) const

overridevirtual

Definition at line 136 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                          {
  if (!m_xAODKey.empty()){
    SG::WriteHandle handle{m_xAODKey, ctx};
    ATH_CHECK(handle.record(std::make_unique<xAOD::TgcStripContainer>(), 
                            std::make_unique<xAOD::TgcStripAuxContainer>()));
  }
   State state{};
   return setupState(ctx, state);
}

◆ selectDecoder()

void Muon::TgcRdoToPrepDataToolMT::selectDecoder	(	State &	state,
		const TgcRawData &	rd,
		const TgcRdo *	rdoColl ) const

private

Select decoder based on RDO type (Hit or Coincidence (Tracklet, HiPt and SL))

Definition at line 385 of file TgcRdoToPrepDataToolMT.cxx.

                                                                              {
 
  const CablingInfo* cinfo = getCabling();
  if (!cinfo) {
    return;
  }
 
  if(!rd.isCoincidence()) {
    if(!decodeHits(state, rd).isSuccess()) {
      ATH_MSG_WARNING("Cannot decode TGC Hits");
    }
  } else if(rd.isCoincidence() && m_fillCoinData) {  // coincidence start
    StatusCode status = StatusCode::SUCCESS;
    if (rd.type()==TgcRawData::TYPE_TRACKLET) {
      if(rd.slbType()==TgcRawData::SLB_TYPE_DOUBLET_WIRE || 
         rd.slbType()==TgcRawData::SLB_TYPE_DOUBLET_STRIP) {
        status = decodeTracklet(state, rd);
      } else if(rd.slbType()==TgcRawData::SLB_TYPE_INNER_WIRE ||
                rd.slbType()==TgcRawData::SLB_TYPE_INNER_STRIP) {
        status = decodeTrackletEIFI(state, rd);
      }
    } // rd.rodId()<13 for Run2, rd.rodId()>12 for Run3
      else if( rd.type()==TgcRawData::TYPE_HIPT && 
               ( (rd.isHipt() && rd.rodId()<13) || rd.rodId()>12) ) { 
      status = decodeHiPt(state, rd);
    } else if( (rd.rodId()<13 && rd.type()==TgcRawData::TYPE_HIPT && (rd.sector() & 4)!=0) || // Run2
               (rd.rodId()>12 && ( rd.type()==TgcRawData::TYPE_INNER_NSW  || // Run3
                                   rd.type()==TgcRawData::TYPE_INNER_BIS  || // Run3
                                   rd.type()==TgcRawData::TYPE_INNER_EIFI || // Run3
                                   rd.type()==TgcRawData::TYPE_INNER_TMDB )) ){ // Run3
      status = decodeInner(state, rd);
    } else if(rd.type()==TgcRawData::TYPE_SL) {
      status = decodeSL(state, rd, rdoColl);
    }
    if(!status.isSuccess()) {
      ATH_MSG_WARNING("Cannot decode TGC Coincidences");
    }
  }
}

◆ setupState()

StatusCode Muon::TgcRdoToPrepDataToolMT::setupState	(	const EventContext &	ctx,
		State &	state ) const

private

clean up containers for Hits

clean up containers for Coincidence

Definition at line 146 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                            {
  const unsigned hashMax = m_idHelperSvc->tgcIdHelper().module_hash_max();
 
  for(unsigned int ibc=0; ibc < NBC_HIT+1; ibc++) {   //  +1 for AllBCs
    // initialize with false
    SG::WriteHandle<TgcPrepDataContainer>  handle(m_outputprepdataKeys[ibc], ctx);
 
    const bool externalCachePRD = m_prdContainerCacheKeys.size()>ibc &&
                                  !m_prdContainerCacheKeys[ibc].key().empty();
    if (!externalCachePRD) {
      // record the container in storeGate
      ATH_CHECK(handle.record(std::make_unique<TgcPrepDataContainer>(hashMax)));      
      ATH_MSG_DEBUG("TGC PrepData Container recorded in StoreGate with key " << m_outputprepdataKeys[ibc].key());
      
      // cache the pointer, storegate retains ownership
      state.tgcPrepDataContainer[ibc] = handle.ptr();
    } else {
      // use the cache to get the container
      SG::UpdateHandle<TgcPrepDataCollection_Cache> update(m_prdContainerCacheKeys[ibc], ctx);
      ATH_CHECK(update.isValid());
 
      ATH_CHECK(handle.record(std::make_unique<Muon::TgcPrepDataContainer>(update.ptr())));
     
      state.tgcPrepDataContainer[ibc] = handle.ptr();
      ATH_MSG_DEBUG("Created container using cache for " << m_prdContainerCacheKeys[ibc].key());
     }
     state.tgcPrepDataCollections[ibc].resize(hashMax);
   }
  for (unsigned int ibc=0; ibc < NBC_TRIG; ibc++) {
    // prepare write handle for this BC
    SG::WriteHandle<TgcCoinDataContainer>  handle(m_outputCoinKeys[ibc], ctx);
 
    const bool externalCacheCoin = m_coinContainerCacheKeys.size()>ibc && 
                                   !m_coinContainerCacheKeys[ibc].key().empty();
    if(!externalCacheCoin) {
      // No cache (offline case), just record container into store gate
      ATH_CHECK(handle.record(std::make_unique<TgcCoinDataContainer>(hashMax)));
    } else {
      // Using the cache (trigger case)
      SG::UpdateHandle<TgcCoinDataCollection_Cache> update(m_coinContainerCacheKeys[ibc], ctx);
      ATH_CHECK(update.isValid());
      ATH_CHECK(handle.record(std::make_unique<TgcCoinDataContainer>(update.ptr())));    
      ATH_MSG_DEBUG("Created container using cache for " << m_coinContainerCacheKeys[ibc].key());
 
    }//external cache
 
    // cache the pointer for duration of function, storegate retains ownership
    state.tgcCoinDataContainer[ibc] = handle.ptr();
    state.tgcCoinDataCollections[ibc].resize(hashMax);
 
  }  // loop on BC_TRIG
 
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> detMgr{m_muDetMgrKey, ctx};
  ATH_CHECK(detMgr.isValid());
  state.muDetMgr = detMgr.cptr();
  return StatusCode::SUCCESS;
}

◆ transferData()

template<class ContType, class CollType>

StatusCode Muon::TgcRdoToPrepDataToolMT::transferData	(	ContType &	container,
		std::vector< std::unique_ptr< CollType > > &&	coll ) const

private

Definition at line 123 of file TgcRdoToPrepDataToolMT.cxx.

                                                                                                         {
  for (std::unique_ptr<CollType>& toMove : coll) {
    if (!toMove) continue;
    const IdentifierHash hash = toMove->identifyHash();
    auto lock = container.getWriteHandle(hash);
    if(!lock.alreadyPresent()) {
      ATH_CHECK(lock.addOrDelete(std::move(toMove)));
    }
  }  
  return StatusCode::SUCCESS;
}

Member Data Documentation

◆ m_cablingInfo

CxxUtils::CachedValue<CablingInfo> Muon::TgcRdoToPrepDataToolMT::m_cablingInfo

private

Definition at line 111 of file TgcRdoToPrepDataToolMT.h.

◆ m_coinContainerCacheKeys

TgcCoinUpdateHandles Muon::TgcRdoToPrepDataToolMT::m_coinContainerCacheKeys {this, "UpdateKeysCoin", {}}

private

Keys for the Coin cache containers, 3 needed for different BC.

Definition at line 423 of file TgcRdoToPrepDataToolMT.h.

423{this, "UpdateKeysCoin", {}};

◆ m_coinContainerCacheKeyStr

Gaudi::Property<std::string> Muon::TgcRdoToPrepDataToolMT::m_coinContainerCacheKeyStr {this, "CoinCacheString", "", "Prefix for names of Coin cache collections"}

private

Definition at line 428 of file TgcRdoToPrepDataToolMT.h.

428{this, "CoinCacheString", "", "Prefix for names of Coin cache collections"};

◆ m_decodeData

Gaudi::Property<bool> Muon::TgcRdoToPrepDataToolMT::m_decodeData {this, "DecodeData", true}

private

Switch for the decoding of TGC RDO into TgcPrepData.

Definition at line 382 of file TgcRdoToPrepDataToolMT.h.

382{this, "DecodeData", true};

◆ m_dropPrdsWithZeroWidth

Gaudi::Property<bool> Muon::TgcRdoToPrepDataToolMT::m_dropPrdsWithZeroWidth {this, "dropPrdsWithZeroWidth", true}

private

Flag for dropping PRD's with zero widths.

Definition at line 394 of file TgcRdoToPrepDataToolMT.h.

394{this, "dropPrdsWithZeroWidth", true};

◆ m_fillCoinData

Gaudi::Property<bool> Muon::TgcRdoToPrepDataToolMT::m_fillCoinData {this, "FillCoinData", true}

private

Switch for the coincince decoding.

Definition at line 384 of file TgcRdoToPrepDataToolMT.h.

384{this, "FillCoinData", true};

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::TgcRdoToPrepDataToolMT::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 370 of file TgcRdoToPrepDataToolMT.h.

370{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

◆ m_muDetMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::TgcRdoToPrepDataToolMT::m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}

private

Definition at line 368 of file TgcRdoToPrepDataToolMT.h.

368{this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"};

◆ m_nHiPtPRDs

std::atomic<long> Muon::TgcRdoToPrepDataToolMT::m_nHiPtPRDs {0}

mutableprivate

Definition at line 406 of file TgcRdoToPrepDataToolMT.h.

406{0};

◆ m_nHiPtRDOs

std::atomic<long> Muon::TgcRdoToPrepDataToolMT::m_nHiPtRDOs {0}

mutableprivate

Definition at line 405 of file TgcRdoToPrepDataToolMT.h.

405{0};

◆ m_nHitPRDs

std::atomic<long> Muon::TgcRdoToPrepDataToolMT::m_nHitPRDs {0}

mutableprivate

Definition at line 400 of file TgcRdoToPrepDataToolMT.h.

400{0};

◆ m_nHitRDOs

std::atomic<long> Muon::TgcRdoToPrepDataToolMT::m_nHitRDOs {0}

mutableprivate

long to count the numbers of RDOs and PRDs

Definition at line 399 of file TgcRdoToPrepDataToolMT.h.

399{0};

◆ m_nSLPRDs

std::atomic<long> Muon::TgcRdoToPrepDataToolMT::m_nSLPRDs {0}

mutableprivate

Definition at line 408 of file TgcRdoToPrepDataToolMT.h.

408{0};

◆ m_nSLRDOs

std::atomic<long> Muon::TgcRdoToPrepDataToolMT::m_nSLRDOs {0}

mutableprivate

Definition at line 407 of file TgcRdoToPrepDataToolMT.h.

407{0};

◆ m_nTrackletEIFIPRDs

std::atomic<long> Muon::TgcRdoToPrepDataToolMT::m_nTrackletEIFIPRDs {0}

mutableprivate

Definition at line 404 of file TgcRdoToPrepDataToolMT.h.

404{0};

◆ m_nTrackletEIFIRDOs

std::atomic<long> Muon::TgcRdoToPrepDataToolMT::m_nTrackletEIFIRDOs {0}

mutableprivate

Definition at line 403 of file TgcRdoToPrepDataToolMT.h.

403{0};

◆ m_nTrackletPRDs

std::atomic<long> Muon::TgcRdoToPrepDataToolMT::m_nTrackletPRDs {0}

mutableprivate

Definition at line 402 of file TgcRdoToPrepDataToolMT.h.

402{0};

◆ m_nTrackletRDOs

std::atomic<long> Muon::TgcRdoToPrepDataToolMT::m_nTrackletRDOs {0}

mutableprivate

Definition at line 401 of file TgcRdoToPrepDataToolMT.h.

401{0};

◆ m_outputCoinCollectionLocation

Gaudi::Property<std::string> Muon::TgcRdoToPrepDataToolMT::m_outputCoinCollectionLocation {this, "OutputCoinCollection", "TrigT1CoinDataCollection"}

private

TgcCoinData container key for current BC.

Definition at line 376 of file TgcRdoToPrepDataToolMT.h.

376{this, "OutputCoinCollection", "TrigT1CoinDataCollection"};

◆ m_outputCoinKeys

SG::WriteHandleKeyArray<Muon::TgcCoinDataContainer> Muon::TgcRdoToPrepDataToolMT::m_outputCoinKeys {this, "outputCoinKey", {}}

private

Definition at line 413 of file TgcRdoToPrepDataToolMT.h.

413{this, "outputCoinKey", {}};

◆ m_outputCollectionLocation

Gaudi::Property<std::string> Muon::TgcRdoToPrepDataToolMT::m_outputCollectionLocation {this, "OutputCollection", "TGC_Measurements"}

private

TgcPrepRawData container key for current BC.

Definition at line 373 of file TgcRdoToPrepDataToolMT.h.

373{this, "OutputCollection", "TGC_Measurements"};

◆ m_outputprepdataKeys

SG::WriteHandleKeyArray<Muon::TgcPrepDataContainer> Muon::TgcRdoToPrepDataToolMT::m_outputprepdataKeys {this, "prepDataKeys", {}}

private

Definition at line 415 of file TgcRdoToPrepDataToolMT.h.

415{this, "prepDataKeys", {}};

◆ m_prdContainerCacheKeys

TgcPrdUpdateHandles Muon::TgcRdoToPrepDataToolMT::m_prdContainerCacheKeys {this, "UpdateKeysPrd", {}}

private

Keys for the PRD cache containers, 4 needed for different BC.

Definition at line 421 of file TgcRdoToPrepDataToolMT.h.

421{this, "UpdateKeysPrd", {}};

◆ m_prdContainerCacheKeyStr

Gaudi::Property<std::string> Muon::TgcRdoToPrepDataToolMT::m_prdContainerCacheKeyStr {this, "PrdCacheString", "", "Prefix for names of PRD cache collections"}

private

Definition at line 426 of file TgcRdoToPrepDataToolMT.h.

426{this, "PrdCacheString", "", "Prefix for names of PRD cache collections"};

◆ m_rdoContainerKey

SG::ReadHandleKey<TgcRdoContainer> Muon::TgcRdoToPrepDataToolMT::m_rdoContainerKey {this, "RDOContainer", "TGCRDO" ,"TgcRdoContainer to retrieve"}

private

Definition at line 410 of file TgcRdoToPrepDataToolMT.h.

410{this, "RDOContainer", "TGCRDO" ,"TgcRdoContainer to retrieve"};

◆ m_show_warning_level_invalid_A09_SSW6_hit

Gaudi::Property<bool> Muon::TgcRdoToPrepDataToolMT::m_show_warning_level_invalid_A09_SSW6_hit {this, "show_warning_level_invalid_A09_SSW6_hit", false}

private

Switch for error message disabling on one invalid channel in sector A09 seen in 2008 data, at least run 79772 - 91800.

bug #48828: TgcRdoToTgcDigit WARNING ElementID not found for sub=103 rod=9 ssw=6 slb=20 bitpos=151 +offset=0 orFlag=0

Definition at line 391 of file TgcRdoToPrepDataToolMT.h.

391{this, "show_warning_level_invalid_A09_SSW6_hit", false};

◆ m_tgcOffset

Gaudi::Property<int> Muon::TgcRdoToPrepDataToolMT::m_tgcOffset {this, "TGCHashIdOffset", 26000}

private

Identifier hash offset.

Definition at line 379 of file TgcRdoToPrepDataToolMT.h.

379{this, "TGCHashIdOffset", 26000};

◆ m_xAODKey

SG::WriteHandleKey<xAOD::TgcStripContainer> Muon::TgcRdoToPrepDataToolMT::m_xAODKey {this, "xAODKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}

private

Definition at line 417 of file TgcRdoToPrepDataToolMT.h.

417{this, "xAODKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"};

◆ NBC_HIT

int Muon::TgcRdoToPrepDataToolMT::NBC_HIT = 3

staticconstexprprivate

The number of recorded Bunch Crossings (BCs) FOR HITS is 3 (Previous, Current, and Next BCs)

Definition at line 78 of file TgcRdoToPrepDataToolMT.h.

◆ NBC_TRIG

int Muon::TgcRdoToPrepDataToolMT::NBC_TRIG = 4

staticconstexprprivate

Definition at line 81 of file TgcRdoToPrepDataToolMT.h.

◆ s_cutDropPrdsWithZeroWidth

const double Muon::TgcRdoToPrepDataToolMT::s_cutDropPrdsWithZeroWidth = 0.1

staticprivate

Cut value for zero widths.

Definition at line 396 of file TgcRdoToPrepDataToolMT.h.

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ BIT_POS

◆ MAP_SIZE

◆ SUB_DETCTOR_ID

Constructor & Destructor Documentation

◆ ~TgcRdoToPrepDataToolMT()

Member Function Documentation

◆ convertToRun2() [1/2]

◆ convertToRun2() [2/2]

◆ decode() [1/2]

◆ decode() [2/2]

◆ decodeHiPt()

◆ decodeHits()

◆ decodeInner()

◆ decodeSL()

◆ decodeTracklet()

◆ decodeTrackletEIFI()

◆ finalize()

◆ getbitpos()

◆ getBitPosInStrip()

◆ getBitPosInWire()

◆ getBitPosOutStrip()

◆ getBitPosOutWire()

◆ getBitPosStrip()

◆ getBitPosWire()

◆ getCabling()

◆ getchannel()

◆ getDeltaBeforeConvert()

◆ getEndcapStripCandidateTrackletIds()

◆ getEtafromRZ()

◆ getHiPtIds()

◆ getPosAndIdStripIn()

◆ getPosAndIdStripOut()

◆ getPosAndIdWireIn()

◆ getPosAndIdWireOut()

◆ getRfromEtaZ()

◆ getRoiRow()

◆ getSbLocOfEndcapStripBoundaryFromHiPt()

◆ getSbLocOfEndcapStripBoundaryFromTracklet()

◆ getSLIds()

◆ getSLLocalPosition()

◆ getSLStripGeometry()

◆ getSLWireGeometry()

◆ getTrackletInfo()

◆ initialize()

◆ isAlreadyConverted()

◆ isBackwardBW()

◆ isIncludedInChamberBoundary()

◆ isOfflineIdOKForTgcReadoutElement()

◆ isRequested()

◆ provideEmptyContainer()

◆ selectDecoder()

◆ setupState()

◆ transferData()

Member Data Documentation

◆ m_cablingInfo

◆ m_coinContainerCacheKeys

◆ m_coinContainerCacheKeyStr

◆ m_decodeData

◆ m_dropPrdsWithZeroWidth

◆ m_fillCoinData

◆ m_idHelperSvc

◆ m_muDetMgrKey

◆ m_nHiPtPRDs

◆ m_nHiPtRDOs

◆ m_nHitPRDs

◆ m_nHitRDOs

◆ m_nSLPRDs

◆ m_nSLRDOs

◆ m_nTrackletEIFIPRDs

◆ m_nTrackletEIFIRDOs

◆ m_nTrackletPRDs