Muon::TgcRdoToPrepDataToolMT Class Reference

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

#include <TgcRdoToPrepDataToolMT.h>

Inheritance diagram for Muon::TgcRdoToPrepDataToolMT:

Classes
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_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_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_A_INPUT_SMALL_R_CH04 = BIT_POS_A_INPUT_ORIGIN - 4 , BIT_POS_A_INPUT_LARGE_R_CH12 , BIT_POS_A_INPUT_LARGE_R_CH04 , 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_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 }
	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 = 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 }
	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 State &state, const TgcRawData &rd, int &sswId_o, int &sbLoc_o, int &slbId_o) const
	Get ReadoutID of HiPt from RDOHighPtID.
bool	getSLIds (const State &state, 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 State &state, 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 State &state, 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.
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 Amg::Vector2D	getSLLocalPosition (const MuonGM::TgcReadoutElement *readout, const Identifier, const double eta, const double phi)
	Get SL local position.

Private Attributes
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muDetMgrKey
SG::ReadCondHandleKey< Muon::TgcCablingMap >	m_cablingKey
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
Gaudi::Property< std::string >	m_outputCollectionLocation
	TgcPrepRawData container key for current BC.
Gaudi::Property< std::string >	m_outputCoinCollectionLocation
	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
	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
	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
SG::WriteHandleKeyArray< Muon::TgcCoinDataContainer >	m_outputCoinKeys
SG::WriteHandleKeyArray< Muon::TgcPrepDataContainer >	m_outputprepdataKeys
SG::WriteHandleKey< xAOD::TgcStripContainer >	m_xAODKey
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
Gaudi::Property< std::string >	m_coinContainerCacheKeyStr

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
	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 57 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

• https://twiki.cern.ch/twiki/bin/view/Main/TgcDocument
• https://twiki.cern.ch/twiki/pub/Main/TgcDocument/celladdress2_asic_rev2.pdf
• https://twiki.cern.ch/twiki/pub/Main/TgcDocument/psboard_table_v070119.xls
• https://twiki.cern.ch/twiki/pub/Main/TgcDocument/psboard_table_v070119.pdf

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 155 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 224 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 128 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 497 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 482 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.)

here the RDO container is retrieved and filled -whatever input type we start with- => check the size

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

Definition at line 220 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 TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
 
    std::set<const TgcRdo*> decodedRdoCollVec{}, rdoCollVec{};
    std::array<char, 24> decodedOnlineId{};
  
    // 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");
    const TgcRdoContainer* rdoContainer{};
    ATH_CHECK(SG::get(rdoContainer, m_rdoContainerKey, ctx));
    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;
        const IdContext tgcContext = m_idHelperSvc->tgcIdHelper().module_context();  // TGC context
   
        for (const IdentifierHash& offlineCollHash : requestedIdHashVect) {
            Identifier elementId;
            int subDetectorId = 0;  // 103(=0x67) for A side, 104(=0x68) for C side
            int rodId = 0;          // 1 to 12 (12-fold cabling)
            m_idHelperSvc->tgcIdHelper().get_id(offlineCollHash, elementId, &tgcContext);
            state.cabling->getReadoutIDfromElementID(elementId, subDetectorId, rodId);
            // onlineId: 0 to 11 on A side and 12 to 23 on C side (12-fold cabling)
            const uint16_t onlineId = TgcRdo::calculateOnlineId(subDetectorId, rodId);
 
            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 (!state.cabling->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 116 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 1039 of file TgcRdoToPrepDataToolMT.cxx.

                                               {
    m_nHiPtRDOs++;  // Count the number of input HiPt 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.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(state, 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 = state.cabling->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 = state.cabling->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 484 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 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 = state.cabling->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 = state.cabling->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 = state.cabling->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 1310 of file TgcRdoToPrepDataToolMT.cxx.

                                              {
    m_nHiPtRDOs++;  // Count the number of input HiPt RDOs.
 
 
    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
        state.cabling->getSLIDfromReadoutID(phi, isAside, isEndcap,
                                                  subDetectorId, rd.rodId(),
                                                  sswId_o, sbLoc_o);
    } else {  // Run3
        sbLoc_o = rd.sector();
        state.cabling->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 1459 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(state, 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(state, 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 = new Amg::Vector2D(!onSurface ? 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 666 of file TgcRdoToPrepDataToolMT.cxx.

                                              {
    ++m_nTrackletRDOs;  // Count the number of input Tracklet RDOs.
 
    bool found = false;
 
    //*** Get OfflineId of pivot plane (TGC3) start ***//
    Identifier channelIdOut{};
    found = state.cabling->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 = state.cabling->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 836 of file TgcRdoToPrepDataToolMT.cxx.

                                              {
    // Count the number of input TrackletEIFI RDOs.
    m_nTrackletEIFIRDOs++;
 
    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 = state.cabling->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 103 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 1643 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 2074 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 1949 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 2042 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 1893 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 2199 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 2134 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
            }
        }
    }
}

getchannel()

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

staticprivate

Get channel from bitpos and SlbType.

Definition at line 1687 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 2244 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 3328 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 1745 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 State & state, const TgcRawData & rd, int & sswId_o, int & sbLoc_o, int & slbId_o ) const

private

Get ReadoutID of HiPt from RDOHighPtID.

Definition at line 2907 of file TgcRdoToPrepDataToolMT.cxx.

                                                                  {
    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 = state.cabling->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 = state.cabling->getOfflineIDfromHighPtID(
            dummyId, rd.subDetectorId(), tmprodId, tmpsector, rd.isStrip(),
            rd.isForward(), index, chip, hitId, rd.hsub());
    } else {
        found = state.cabling->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 = state.cabling->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 = state.cabling->getSLBIDfromReadoutID(
            i_o[0], b_o[0], b_o[1], i_o[1], slbId_o, rd.subDetectorId(),
            tmprodId, sswId_o, sbLoc_o);
    } else {
        found = state.cabling->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 2800 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 2590 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 2665 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 2520 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 1735 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 1873 of file TgcRdoToPrepDataToolMT.cxx.

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

getSbLocOfEndcapStripBoundaryFromHiPt()

bool Muon::TgcRdoToPrepDataToolMT::getSbLocOfEndcapStripBoundaryFromHiPt ( const State & state, 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 3072 of file TgcRdoToPrepDataToolMT.cxx.

                                                                {
  
    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(state, 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 = state.cabling->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 = state.cabling->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 State & state, 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 3186 of file TgcRdoToPrepDataToolMT.cxx.

                                                                {
 
    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 =
                state.cabling->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 = state.cabling->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 = state.cabling->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 = state.cabling->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 = state.cabling->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 State & state, 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 2972 of file TgcRdoToPrepDataToolMT.cxx.

{
    bool found = state.cabling->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 = state.cabling->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 = state.cabling->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 = state.cabling->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(state,
            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(state,
                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 = state.cabling->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()

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 3397 of file TgcRdoToPrepDataToolMT.cxx.

                                        {
    if (!readout) {
        return Amg::Vector2D::Zero();
    }
 
    // 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 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 2422 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 2335 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 1772 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 26 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());
    ATH_CHECK(m_cablingKey.initialize());
 
    // check if initializing of DataHandle objects success
    ATH_CHECK(m_rdoContainerKey.initialize());
 
 
    // 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 2312 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 1878 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 1761 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 137 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 445 of file TgcRdoToPrepDataToolMT.cxx.

                                                                              {
 
    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 149 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 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 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 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 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
 
    ATH_CHECK(SG::get(state.muDetMgr, m_muDetMgrKey, ctx));
    ATH_CHECK(SG::get(state.cabling, m_cablingKey, ctx));
    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 122 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_cablingKey

SG::ReadCondHandleKey<Muon::TgcCablingMap> Muon::TgcRdoToPrepDataToolMT::m_cablingKey

private

Initial value:

{
        this, "CablingKey", "MuonTgc_CablingMap"}

Definition at line 397 of file TgcRdoToPrepDataToolMT.h.

                                                       {
        this, "CablingKey", "MuonTgc_CablingMap"};

m_coinContainerCacheKeys

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

private

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

Definition at line 465 of file TgcRdoToPrepDataToolMT.h.

{this, "UpdateKeysCoin", {}};

m_coinContainerCacheKeyStr

Gaudi::Property<std::string> Muon::TgcRdoToPrepDataToolMT::m_coinContainerCacheKeyStr

private

Initial value:

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

Definition at line 474 of file TgcRdoToPrepDataToolMT.h.

                                                       {
        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 415 of file TgcRdoToPrepDataToolMT.h.

{this, "DecodeData", true};

m_dropPrdsWithZeroWidth

Gaudi::Property<bool> Muon::TgcRdoToPrepDataToolMT::m_dropPrdsWithZeroWidth

private

Initial value:

{this, "dropPrdsWithZeroWidth",
                                                  true}

Flag for dropping PRD's with zero widths.

Definition at line 428 of file TgcRdoToPrepDataToolMT.h.

                                               {this, "dropPrdsWithZeroWidth",
                                                  true};

m_fillCoinData

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

private

Switch for the coincince decoding.

Definition at line 417 of file TgcRdoToPrepDataToolMT.h.

{this, "FillCoinData", true};

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::TgcRdoToPrepDataToolMT::m_idHelperSvc

private

Initial value:

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

Definition at line 400 of file TgcRdoToPrepDataToolMT.h.

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

m_muDetMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::TgcRdoToPrepDataToolMT::m_muDetMgrKey

private

Initial value:

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

Definition at line 393 of file TgcRdoToPrepDataToolMT.h.

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

m_nHiPtPRDs

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

mutableprivate

Definition at line 441 of file TgcRdoToPrepDataToolMT.h.

{0};

m_nHiPtRDOs

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

mutableprivate

Definition at line 440 of file TgcRdoToPrepDataToolMT.h.

{0};

m_nHitPRDs

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

mutableprivate

Definition at line 435 of file TgcRdoToPrepDataToolMT.h.

{0};

m_nHitRDOs

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

mutableprivate

long to count the numbers of RDOs and PRDs

Definition at line 434 of file TgcRdoToPrepDataToolMT.h.

{0};

m_nSLPRDs

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

mutableprivate

Definition at line 443 of file TgcRdoToPrepDataToolMT.h.

{0};

m_nSLRDOs

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

mutableprivate

Definition at line 442 of file TgcRdoToPrepDataToolMT.h.

{0};

m_nTrackletEIFIPRDs

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

mutableprivate

Definition at line 439 of file TgcRdoToPrepDataToolMT.h.

{0};

m_nTrackletEIFIRDOs

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

mutableprivate

Definition at line 438 of file TgcRdoToPrepDataToolMT.h.

{0};

m_nTrackletPRDs

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

mutableprivate

Definition at line 437 of file TgcRdoToPrepDataToolMT.h.

{0};

m_nTrackletRDOs

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

mutableprivate

Definition at line 436 of file TgcRdoToPrepDataToolMT.h.

{0};

m_outputCoinCollectionLocation

Gaudi::Property<std::string> Muon::TgcRdoToPrepDataToolMT::m_outputCoinCollectionLocation

private

Initial value:

{
        this, "OutputCoinCollection", "TrigT1CoinDataCollection"}

TgcCoinData container key for current BC.

Definition at line 408 of file TgcRdoToPrepDataToolMT.h.

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

m_outputCoinKeys

SG::WriteHandleKeyArray<Muon::TgcCoinDataContainer> Muon::TgcRdoToPrepDataToolMT::m_outputCoinKeys

private

Initial value:

{
        this, "outputCoinKey", {}}

Definition at line 450 of file TgcRdoToPrepDataToolMT.h.

                                                                    {
        this, "outputCoinKey", {}};

m_outputCollectionLocation

Gaudi::Property<std::string> Muon::TgcRdoToPrepDataToolMT::m_outputCollectionLocation

private

Initial value:

{
        this, "OutputCollection", "TGC_Measurements"}

TgcPrepRawData container key for current BC.

Definition at line 404 of file TgcRdoToPrepDataToolMT.h.

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

m_outputprepdataKeys

SG::WriteHandleKeyArray<Muon::TgcPrepDataContainer> Muon::TgcRdoToPrepDataToolMT::m_outputprepdataKeys

private

Initial value:

{
        this, "prepDataKeys", {}}

Definition at line 454 of file TgcRdoToPrepDataToolMT.h.

                                                                        {
        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 463 of file TgcRdoToPrepDataToolMT.h.

{this, "UpdateKeysPrd", {}};

m_prdContainerCacheKeyStr

Gaudi::Property<std::string> Muon::TgcRdoToPrepDataToolMT::m_prdContainerCacheKeyStr

private

Initial value:

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

Definition at line 469 of file TgcRdoToPrepDataToolMT.h.

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

m_rdoContainerKey

SG::ReadHandleKey<TgcRdoContainer> Muon::TgcRdoToPrepDataToolMT::m_rdoContainerKey

private

Initial value:

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

Definition at line 445 of file TgcRdoToPrepDataToolMT.h.

                                                      {
        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

private

Initial value:

{
        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.

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 424 of file TgcRdoToPrepDataToolMT.h.

                                                                 {
        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 412 of file TgcRdoToPrepDataToolMT.h.

{this, "TGCHashIdOffset", 26000};

m_xAODKey

SG::WriteHandleKey<xAOD::TgcStripContainer> Muon::TgcRdoToPrepDataToolMT::m_xAODKey

private

Initial value:

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

Definition at line 457 of file TgcRdoToPrepDataToolMT.h.

                                                     {
        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 90 of file TgcRdoToPrepDataToolMT.h.

NBC_TRIG

int Muon::TgcRdoToPrepDataToolMT::NBC_TRIG = 4

staticconstexprprivate

Definition at line 95 of file TgcRdoToPrepDataToolMT.h.

s_cutDropPrdsWithZeroWidth

const double Muon::TgcRdoToPrepDataToolMT::s_cutDropPrdsWithZeroWidth

staticprivate

Initial value:

=
    0.1

Cut value for zero widths.

Definition at line 431 of file TgcRdoToPrepDataToolMT.h.

---

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

• TgcRdoToPrepDataToolMT.h
• TgcRdoToPrepDataToolMT.cxx