ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
gFexByteStreamTool Class Reference

#include <gFexByteStreamTool.h>

Inheritance diagram for gFexByteStreamTool:
Collaboration diagram for gFexByteStreamTool:

Public Member Functions

 gFexByteStreamTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual ~gFexByteStreamTool () override=default
virtual StatusCode initialize () override
virtual StatusCode start () override
virtual StatusCode convertFromBS (const std::vector< const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment * > &vrobf, const EventContext &eventContext) const override
 BS->xAOD conversion.
virtual StatusCode convertToBS (std::vector< OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment * > &vrobf, const EventContext &eventContext) override
 xAOD->BS conversion
virtual const std::vector< uint32_t > & robIds () const override
 Declare ROB IDs for conversion.

Private Member Functions

void decodeGfexTobSlice (const uint32_t dataArray[], uint32_t blockType) const
void printError (const std::string &location, const std::string &title, MSG::Level type, const std::string &detail) const
int16_t fillGlobal (const std::array< uint32_t, 3 > &tob, const int type, SG::WriteHandle< xAOD::gFexGlobalRoIContainer > &container, uint32_t sliceNumber, int16_t scalar=-1) const

Private Attributes

ToolHandle< GenericMonitoringTool > m_monTool {this,"MonTool","","Monitoring tool"}
bool m_UseMonitoring = false
Gaudi::Property< std::vector< uint32_t > > m_robIds {this, "ROBIDs", {}, "List of ROB IDs required for conversion to/from xAOD RoI"}
Gaudi::Property< bool > m_saveExtendedTOBs {this, "SaveExtendedTOBs", false, "Decode and write xTOBs instead of TOBs"}
int m_gJ_scale = 0
int m_gLJ_scale = 0
int m_gXE_scale = 0
int m_gTE_scale = 0
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexRhoWriteKey {this,"gFexRhoOutputContainerWriteKey","L1_gFexRhoRoI","Write gFEX EDM gFexRho container"}
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexBlockWriteKey {this,"gFexSRJetOutputContainerWriteKey","L1_gFexSRJetRoI","Write gFEX EDM gFexBlock container"}
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexJetWriteKey {this,"gFexLRJetOutputContainerWriteKey","L1_gFexLRJetRoI","Write gFEX EDM gFexJet container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarEJwojWriteKey {this,"gScalarEJwojOutputContainerWriteKey","L1_gScalarEJwoj","Write gFEX EDM Scalar MET and SumET (JwoJ) container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gEspressoWriteKey {this,"gEspressoOutputContainerWriteKey","L1_gEspresso","Write gFEX EDM gEspresso container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gRistrettoWriteKey {this,"gRistrettoOutputContainerWriteKey","L1_gRistretto","Write gFEX EDM gRistretto container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsJwojWriteKey {this,"gMETComponentsJwojOutputContainerWriteKey","L1_gMETComponentsJwoj","Write gFEX EDM total MET components (JwoJ) container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMHTComponentsJwojWriteKey {this,"gMHTComponentsJwojOutputContainerWriteKey","L1_gMHTComponentsJwoj","Write gFEX EDM hard MET components (JwoJ) container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMSTComponentsJwojWriteKey {this,"gMSTComponentsJwojOutputContainerWriteKey","L1_gMSTComponentsJwoj","Write gFEX EDM soft MET components (JwoJ) container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsNoiseCutWriteKey {this,"gMETComponentsNoiseCutOutputContainerWriteKey","L1_gMETComponentsNoiseCut","Write gFEX EDM total MET components (NoiseCut) container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsRmsWriteKey {this,"gMETComponentsRmsOutputContainerWriteKey","L1_gMETComponentsRms","Write gFEX EDM total MET components (RMS) container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarENoiseCutWriteKey {this,"gScalarENoiseCutOutputContainerWriteKey","L1_gScalarENoiseCut","Write gFEX EDM Scalar MET and SumET (NoiseCut) container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarERmsWriteKey {this,"gScalarERmsOutputContainerWriteKey","L1_gScalarERms","Write gFEX EDM Scalar MET and SumET (RMS) container"}
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexRhoSliceWriteKey {this,"gFexRhoSliceContainerWriteKey","","Write gFEX EDM gFexRho out-of-time container"}
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexBlockSliceWriteKey {this,"gFexSRJetSliceContainerWriteKey","","Write gFEX EDM gFexBlock out-of-time container"}
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexJetSliceWriteKey {this,"gFexLRJetSliceContainerWriteKey","","Write gFEX EDM gFexJet out-of-time container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarEJwojSliceWriteKey {this,"gScalarEJwojSliceContainerWriteKey","","Write gFEX EDM Scalar (JwoJ) out-of-time container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsJwojSliceWriteKey {this,"gMETComponentsJwojSliceContainerWriteKey","","Write gFEX EDM MET (JwoJ) out-of-time container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMHTComponentsJwojSliceWriteKey {this,"gMHTComponentsJwojSliceContainerWriteKey","","Write gFEX EDM MHT (JwoJ) out-of-time container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMSTComponentsJwojSliceWriteKey {this,"gMSTComponentsJwojSliceContainerWriteKey","","Write gFEX EDM MST (JwoJ) out-of-time container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gEspressoSliceWriteKey {this,"gEspressoSliceContainerWriteKey","","Write gFEX EDM gEspresso out-of-time container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gRistrettoSliceWriteKey {this,"gRistrettoSliceContainerWriteKey","","Write gFEX EDM gRistretto out-of-time container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsNoiseCutSliceWriteKey {this,"gMETComponentsNoiseCutSliceContainerWriteKey","","Write gFEX EDM MET (NoiseCut) out-of-time container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarENoiseCutSliceWriteKey {this,"gScalarENoiseCutSliceContainerWriteKey","","Write gFEX EDM Scalar (NoiseCut) out-of-time container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsRmsSliceWriteKey {this,"gMETComponentsRmsSliceContainerWriteKey","","Write gFEX EDM MET (Rms) out-of-time container"}
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarERmsSliceWriteKey {this,"gScalarERmsSliceContainerWriteKey","","Write gFEX EDM Scalar (Rms) out-of-time container"}
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_gFexRhoOOTDecorKey {this,"gFexRhoOOTDecorKey",m_gFexRhoSliceWriteKey,"sliceNumber","Slice number decoration for gFexRho out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_gFexBlockOOTDecorKey {this,"gFexBlockOOTDecorKey",m_gFexBlockSliceWriteKey,"sliceNumber","Slice number decoration for gFexBlock out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_gFexJetOOTDecorKey {this,"gFexJetOOTDecorKey",m_gFexJetSliceWriteKey,"sliceNumber","Slice number decoration for gFexJet out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarEJwojOOTDecorKey {this,"gScalarEJwojOOTDecorKey",m_gScalarEJwojSliceWriteKey,"sliceNumber","Slice number decoration for gScalarEJwoj out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsJwojOOTDecorKey {this,"gMETComponentsJwojOOTDecorKey",m_gMETComponentsJwojSliceWriteKey,"sliceNumber","Slice number decoration for gMETComponentsJwoj out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gMHTComponentsJwojOOTDecorKey {this,"gMHTComponentsJwojOOTDecorKey",m_gMHTComponentsJwojSliceWriteKey,"sliceNumber","Slice number decoration for gMHTComponentsJwoj out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gMSTComponentsJwojOOTDecorKey {this,"gMSTComponentsJwojOOTDecorKey",m_gMSTComponentsJwojSliceWriteKey,"sliceNumber","Slice number decoration for gMSTComponentsJwoj out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gEspressoOOTDecorKey {this,"gEspressoOOTDecorKey",m_gEspressoSliceWriteKey,"sliceNumber","Slice number decoration for gEspresso out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gRistrettoOOTDecorKey {this,"gRistrettoOOTDecorKey",m_gRistrettoSliceWriteKey,"sliceNumber","Slice number decoration for gRistretto out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsNoiseCutOOTDecorKey {this,"gMETComponentsNoiseCutOOTDecorKey",m_gMETComponentsNoiseCutSliceWriteKey,"sliceNumber","Slice number decoration for gMETComponentsNoiseCut out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarENoiseCutOOTDecorKey {this,"gScalarENoiseCutOOTDecorKey",m_gScalarENoiseCutSliceWriteKey,"sliceNumber","Slice number decoration for gScalarENoiseCut out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsRmsOOTDecorKey {this,"gMETComponentsRmsOOTDecorKey",m_gMETComponentsRmsSliceWriteKey,"sliceNumber","Slice number decoration for gMETComponentsRms out-of-time"}
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarERmsOOTDecorKey {this,"gScalarERmsOOTDecorKey",m_gScalarERmsSliceWriteKey,"sliceNumber","Slice number decoration for gScalarERms out-of-time"}
SG::ReadHandleKey< xAOD::gFexJetRoIContainer > m_gFexRhoReadKey {this,"gFexRhoOutputContainerReadKey","L1_gFexRhoRoI","Read gFEX EDM gFexRho container"}
SG::ReadHandleKey< xAOD::gFexJetRoIContainer > m_gFexBlockReadKey {this,"gFexSRJetOutputContainerReadKey","L1_gFexSRJetRoI","Read gFEX EDM gFexBlock container"}
SG::ReadHandleKey< xAOD::gFexJetRoIContainer > m_gFexJetReadKey {this,"gFexLRJetOutputContainerReadKey","L1_gFexLRJetRoI","Read gFEX EDM gFexJet container"}
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarEJwojReadKey {this,"gScalarEJwojOutputContainerReadKey","L1_gScalarEJwoj","Read gFEX EDM Scalar MET and SumET (JwoJ) container"}
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gEspressoReadKey {this,"gEspressoOutputContainerReadKey","L1_gEspresso","Read gFEX EDM gEspresso container"}
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gRistrettoReadKey {this,"gRistrettoOutputContainerReadKey","L1_gRistretto","Read gFEX EDM gRistretto container"}
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsJwojReadKey {this,"gMETComponentsJwojOutputContainerReadKey","L1_gMETComponentsJwoj","Read gFEX EDM total MET components (JwoJ) container"}
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gMHTComponentsJwojReadKey {this,"gMHTComponentsJwojOutputContainerReadKey","L1_gMHTComponentsJwoj","Read gFEX EDM hard MET components (JwoJ) container"}
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gMSTComponentsJwojReadKey {this,"gMSTComponentsJwojOutputContainerReadKey","L1_gMSTComponentsJwoj","Read gFEX EDM soft MET components (JwoJ) container"}
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsNoiseCutReadKey {this,"gMETComponentsNoiseCutOutputContainerReadKey","L1_gMETComponentsNoiseCut","Read gFEX EDM total MET components (NoiseCut) container"}
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsRmsReadKey {this,"gMETComponentsRmsOutputContainerReadKey","L1_gMETComponentsRms","Read gFEX EDM total MET components (RMS) container"}
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarENoiseCutReadKey {this,"gScalarENoiseCutOutputContainerReadKey","L1_gScalarENoiseCut","Read gFEX EDM Scalar MET and SumET (NoiseCut) container"}
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarERmsReadKey {this,"gScalarERmsOutputContainerReadKey","L1_gScalarERms","Read gFEX EDM Scalar MET and SumET (RMS) container"}
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey {this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu","Name of the L1Menu object to read configuration from"}

Static Private Attributes

static constexpr uint8_t m_DEBUG =0
static constexpr uint8_t m_WARNING =1
static constexpr uint8_t m_ERROR =2
static constexpr uint8_t m_FATAL =3

Detailed Description

Definition at line 43 of file gFexByteStreamTool.h.

Constructor & Destructor Documentation

◆ gFexByteStreamTool()

gFexByteStreamTool::gFexByteStreamTool ( const std::string & type,
const std::string & name,
const IInterface * parent )

Definition at line 25 of file gFexByteStreamTool.cxx.

28 : base_class(type, name, parent) {}

◆ ~gFexByteStreamTool()

virtual gFexByteStreamTool::~gFexByteStreamTool ( )
overridevirtualdefault

Member Function Documentation

◆ convertFromBS()

StatusCode gFexByteStreamTool::convertFromBS ( const std::vector< const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment * > & vrobf,
const EventContext & eventContext ) const
overridevirtual

BS->xAOD conversion.

Definition at line 231 of file gFexByteStreamTool.cxx.

231 {
232
233 //WriteHandle for gFEX EDMs
234
235 // Check if standard L1A containers should be decoded (TOBs=True mode)
236 // or are disabled (TOBs=False mode, standard containers come from HLT result)
237 const bool decodeStdTOBs = !m_gFexRhoWriteKey.key().empty();
238
239 //---Standard L1A TOB containers (only created and recorded when decodeStdTOBs is true)
240 SG::WriteHandle<xAOD::gFexJetRoIContainer> gRhoContainer;
241 SG::WriteHandle<xAOD::gFexJetRoIContainer> gSJContainer;
242 SG::WriteHandle<xAOD::gFexJetRoIContainer> gLJContainer;
243 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarEJwojContainer;
244 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsJwojContainer;
245 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMHTComponentsJwojContainer;
246 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMSTComponentsJwojContainer;
247 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsNoiseCutContainer;
248 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsRmsContainer;
249 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarENoiseCutContainer;
250 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarERmsContainer;
251
252 if (decodeStdTOBs) {
253 gRhoContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexRhoWriteKey, ctx);
254 gSJContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexBlockWriteKey, ctx);
255 gLJContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexJetWriteKey, ctx);
256 gScalarEJwojContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarEJwojWriteKey, ctx);
257 gMETComponentsJwojContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsJwojWriteKey, ctx);
258 gMHTComponentsJwojContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMHTComponentsJwojWriteKey, ctx);
259 gMSTComponentsJwojContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMSTComponentsJwojWriteKey, ctx);
260 gMETComponentsNoiseCutContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsNoiseCutWriteKey, ctx);
261 gMETComponentsRmsContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsRmsWriteKey, ctx);
262 gScalarENoiseCutContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarENoiseCutWriteKey, ctx);
263 gScalarERmsContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarERmsWriteKey, ctx);
264
265 ATH_CHECK(gRhoContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
266 ATH_MSG_DEBUG("Recorded gFexJetRoIContainer with key " << gRhoContainer.key());
267 ATH_CHECK(gSJContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
268 ATH_MSG_DEBUG("Recorded gFexJetRoIContainer with key " << gSJContainer.key());
269 ATH_CHECK(gLJContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
270 ATH_MSG_DEBUG("Recorded gFexJetRoIContainer with key " << gLJContainer.key());
271 ATH_CHECK(gScalarEJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
272 ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gScalarEJwojContainer.key());
273 ATH_CHECK(gMETComponentsJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
274 ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMETComponentsJwojContainer.key());
275 ATH_CHECK(gMHTComponentsJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
276 ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMHTComponentsJwojContainer.key());
277 ATH_CHECK(gMSTComponentsJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
278 ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMSTComponentsJwojContainer.key());
279 ATH_CHECK(gMETComponentsNoiseCutContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
280 ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMETComponentsNoiseCutContainer.key());
281 ATH_CHECK(gMETComponentsRmsContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
282 ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMETComponentsRmsContainer.key());
283 ATH_CHECK(gScalarENoiseCutContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
284 ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gScalarENoiseCutContainer.key());
285 ATH_CHECK(gScalarERmsContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
286 ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gScalarERmsContainer.key());
287 }
288
289 //---gEspresso Container (always decoded - not in HLT result)
290 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gEspressoContainer(m_gEspressoWriteKey, ctx);
291 ATH_CHECK(gEspressoContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
292 ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gEspressoContainer.key());
293
294 //---gRistretto Container (always decoded - not in HLT result)
295 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gRistrettoContainer(m_gRistrettoWriteKey, ctx);
296 ATH_CHECK(gRistrettoContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
297 ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gRistrettoContainer.key());
298
299 // Determine if multi-slice mode is enabled (slice 0 = L1A, slices 1,2 = out-of-time)
300 const bool multiSlice = !m_gFexJetSliceWriteKey.empty();
301
302 // Create out-of-time containers for jet TOBs if multi-slice enabled
303 SG::WriteHandle<xAOD::gFexJetRoIContainer> gRhoSliceContainer;
304 SG::WriteHandle<xAOD::gFexJetRoIContainer> gSJSliceContainer;
305 SG::WriteHandle<xAOD::gFexJetRoIContainer> gLJSliceContainer;
306 // Create out-of-time containers for global TOBs if multi-slice enabled
307 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarEJwojSliceContainer;
308 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsJwojSliceContainer;
309 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMHTComponentsJwojSliceContainer;
310 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMSTComponentsJwojSliceContainer;
311 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gEspressoSliceContainer;
312 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gRistrettoSliceContainer;
313 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsNoiseCutSliceContainer;
314 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarENoiseCutSliceContainer;
315 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsRmsSliceContainer;
316 SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarERmsSliceContainer;
317
318 if (multiSlice) {
319 gRhoSliceContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexRhoSliceWriteKey, ctx);
320 ATH_CHECK(gRhoSliceContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
321 ATH_MSG_DEBUG("Recorded gFexJetRoIContainer (out-of-time) with key " << gRhoSliceContainer.key());
322
323 gSJSliceContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexBlockSliceWriteKey, ctx);
324 ATH_CHECK(gSJSliceContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
325 ATH_MSG_DEBUG("Recorded gFexJetRoIContainer (out-of-time) with key " << gSJSliceContainer.key());
326
327 gLJSliceContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexJetSliceWriteKey, ctx);
328 ATH_CHECK(gLJSliceContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
329 ATH_MSG_DEBUG("Recorded gFexJetRoIContainer (out-of-time) with key " << gLJSliceContainer.key());
330
331 gScalarEJwojSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarEJwojSliceWriteKey, ctx);
332 ATH_CHECK(gScalarEJwojSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
333 ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gScalarEJwojSliceContainer.key());
334
335 gMETComponentsJwojSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsJwojSliceWriteKey, ctx);
336 ATH_CHECK(gMETComponentsJwojSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
337 ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gMETComponentsJwojSliceContainer.key());
338
339 gMHTComponentsJwojSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMHTComponentsJwojSliceWriteKey, ctx);
340 ATH_CHECK(gMHTComponentsJwojSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
341 ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gMHTComponentsJwojSliceContainer.key());
342
343 gMSTComponentsJwojSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMSTComponentsJwojSliceWriteKey, ctx);
344 ATH_CHECK(gMSTComponentsJwojSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
345 ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gMSTComponentsJwojSliceContainer.key());
346
347 gEspressoSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gEspressoSliceWriteKey, ctx);
348 ATH_CHECK(gEspressoSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
349 ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gEspressoSliceContainer.key());
350
351 gRistrettoSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gRistrettoSliceWriteKey, ctx);
352 ATH_CHECK(gRistrettoSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
353 ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gRistrettoSliceContainer.key());
354
355 gMETComponentsNoiseCutSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsNoiseCutSliceWriteKey, ctx);
356 ATH_CHECK(gMETComponentsNoiseCutSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
357 ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gMETComponentsNoiseCutSliceContainer.key());
358
359 gScalarENoiseCutSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarENoiseCutSliceWriteKey, ctx);
360 ATH_CHECK(gScalarENoiseCutSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
361 ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gScalarENoiseCutSliceContainer.key());
362
363 gMETComponentsRmsSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsRmsSliceWriteKey, ctx);
364 ATH_CHECK(gMETComponentsRmsSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
365 ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gMETComponentsRmsSliceContainer.key());
366
367 gScalarERmsSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarERmsSliceWriteKey, ctx);
368 ATH_CHECK(gScalarERmsSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
369 ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gScalarERmsSliceContainer.key());
370 }
371
372
373 // Iterate over ROBFragments to decode
374 for (const ROBF* rob : vrobf) {
375 // Iterate over ROD words and decode
376
377
378 ATH_MSG_DEBUG("Starting to decode " << rob->rod_ndata() << " ROD words from ROB 0x" << std::hex << rob->rob_source_id());
379
380 //There is no data to decode.. not even the ROD trailers
381 if(rob->rod_ndata() <= 0){
382 continue;
383 }
384
385 const auto dataArray = std::span{rob->rod_data(), rob->rod_ndata()};
386
387
388 // Starting to loop over the gFEX words
389
390 unsigned int n_words = rob->rod_ndata();
391
392 //saving Jet TOBs into the EDM container
393 for(unsigned int iWord=0; iWord<n_words; iWord++) {
394 ATH_MSG_DEBUG("Raw word 0x" << std::hex << dataArray[iWord] << " " << std::bitset<32> (dataArray[iWord]));
395 }
396
397 // Vectors to temporarily store global tob before they are summed together
398 // For multi-slice support, we use vectors of arrays: [sliceNumber][fpga]
399 // Vectors are dynamically resized based on the actual number of slices in the data
400 // Inner arrays are fixed size 3 (one element per FPGA)
401 std::vector<int> global_counter;
402 std::vector<std::array<uint32_t, 3>> JWOJ_MHT;
403 std::vector<std::array<uint32_t, 3>> JWOJ_MST;
404 std::vector<std::array<uint32_t, 3>> JWOJ_MET;
405 std::vector<std::array<uint32_t, 3>> JWOJ_SCALAR;
406 std::vector<std::array<uint32_t, 3>> GESPRESSO;
407 std::vector<std::array<uint32_t, 3>> GRISTRETTO;
408 std::vector<std::array<uint32_t, 3>> NC_MET;
409 std::vector<std::array<uint32_t, 3>> NC_SCALAR;
410 std::vector<std::array<uint32_t, 3>> RMS_MET;
411 std::vector<std::array<uint32_t, 3>> RMS_SCALAR;
412 // Track slice numbers for global TOBs (to be assigned when fillGlobal is called)
413 std::vector<uint32_t> globalSliceNumbers;
414
415 // Helper lambda to ensure vectors are large enough for a given slice
416 auto ensureSliceCapacity = [&](size_t sliceNum) {
417 if (sliceNum >= global_counter.size()) {
418 size_t newSize = sliceNum + 1;
419 global_counter.resize(newSize, 0);
420 JWOJ_MHT.resize(newSize, {0, 0, 0});
421 JWOJ_MST.resize(newSize, {0, 0, 0});
422 JWOJ_MET.resize(newSize, {0, 0, 0});
423 JWOJ_SCALAR.resize(newSize, {0, 0, 0});
424 GESPRESSO.resize(newSize, {0, 0, 0});
425 GRISTRETTO.resize(newSize, {0, 0, 0});
426 NC_MET.resize(newSize, {0, 0, 0});
427 NC_SCALAR.resize(newSize, {0, 0, 0});
428 RMS_MET.resize(newSize, {0, 0, 0});
429 RMS_SCALAR.resize(newSize, {0, 0, 0});
430 }
431 };
432
433 size_t index = 0;
434 while ( index < n_words ) {
435 const uint32_t headerWord = dataArray[index];//Identify the header words. The first is a header word.
436 const uint32_t blockType = (headerWord >> gPos::BLOCK_TYPE_BIT) & gPos::BLOCK_TYPE_MASK;
437 const uint32_t headerSize = (headerWord >> gPos::HEADER_SIZE_BIT) & gPos::HEADER_SIZE_MASK;
438 const uint32_t errorFlags = (headerWord >> gPos::ERROR_FLAG_BIT) & gPos::ERROR_FLAG_MASK;
439 const uint32_t dataSize = headerWord & gPos::DATA_SIZE_MASK;
440
441 ATH_MSG_DEBUG( "index "<< index );
442 ATH_MSG_DEBUG( "word "<< std::bitset<32> (dataArray[index]) );
443 ATH_MSG_DEBUG( "headerWord "<< std::bitset<32> (headerWord) );
444 ATH_MSG_DEBUG( "blockType "<< std::bitset<4> (blockType) );
445 ATH_MSG_DEBUG( "headerSize "<< std::bitset<2> (headerSize) );
446 ATH_MSG_DEBUG( "errorFlags "<< std::bitset<1> (errorFlags) );
447 ATH_MSG_DEBUG( "dataSize "<< std::bitset<12> (dataSize) );
448
449 const uint32_t blockSize = headerSize + dataSize;
450 if ( (index + blockSize) > n_words ) {
451
452 std::stringstream sdetail;
453 sdetail << "Remaining block size " << (n_words - index) << " is too small for subblock of type " << blockType << " with headerSize " << headerSize << " and dataSize " << dataSize ;
454 std::stringstream slocation;
455 slocation << "0x"<< std::hex << rob->rob_source_id() << std::dec << " type:"<<blockType;
456 std::stringstream stitle;
457 stitle << "Small subblock size " ;
458 printError(slocation.str(),stitle.str(),MSG::DEBUG,sdetail.str());
459
460 }
461
462 index += headerSize;
463
464 const uint32_t numSlices = dataSize / gPos::WORDS_PER_SLICE;
465 ATH_MSG_DEBUG( "numSlices " << numSlices );
466
467 if ( numSlices * gPos::WORDS_PER_SLICE != dataSize ) {
468
469 std::stringstream sdetail;
470 sdetail << "L1CaloBsDecoderRun3::decodeGfexTobs: subblock type " << blockType << " with dataSize " << dataSize << " is not a multiple of " << gPos::WORDS_PER_SLICE << " words" ;
471 std::stringstream slocation;
472 slocation << "0x"<< std::hex << rob->rob_source_id()<< std::dec << " type:"<<blockType;
473 std::stringstream stitle;
474 stitle << "Wrong dataSize" ;
475 printError(slocation.str(),stitle.str(),MSG::DEBUG,sdetail.str());
476
477 //skip decode of this fragment
478 index+=dataSize;
479 continue;
480
481 }
482
483 // The subblock type is 0xA,B,C for jet TOBs from FPGA A,B,C
484 // and 0x1,2,3 for global (MET) TOBs.
485 bool isMet = (blockType >= 0x1 && blockType <= 0x3);
486 bool isJet = (blockType >= 0xA && blockType <= 0xC);
487
488 for (uint32_t sliceNumber = 0; sliceNumber < numSlices; sliceNumber++) {
489
490 // Skip out-of-time slices (slice != 0) if multi-slice mode is disabled
491 if (sliceNumber != 0 && !multiSlice) {
492 index += gPos::WORDS_PER_SLICE;
493 continue;
494 }
495
496 if ( !isJet && !isMet ) {
497 std::stringstream sdetail;
498 sdetail << "gFexByteStreamTool::decodeGfexTobSlice: Invalid block type " << blockType ;
499 std::stringstream slocation;
500 slocation << "0x"<< std::hex << rob->rob_source_id();
501 std::stringstream stitle;
502 stitle << "Invalid block type" ;
503 printError(slocation.str(),stitle.str(),MSG::DEBUG,sdetail.str());
504 }
505
506 // Select target containers based on slice (slice 0 = L1A -> main containers, others -> out-of-time containers)
507 auto& targetRhoContainer = (sliceNumber == 0) ? gRhoContainer : gRhoSliceContainer;
508 auto& targetSJContainer = (sliceNumber == 0) ? gSJContainer : gSJSliceContainer;
509 auto& targetLJContainer = (sliceNumber == 0) ? gLJContainer : gLJSliceContainer;
510
511 for(unsigned int iWord=0; iWord<gPos::WORDS_PER_SLICE; iWord++) {
512
513 // Skip jet TOB fill at slice 0 when standard containers are disabled
514 if (isJet && (sliceNumber != 0 || decodeStdTOBs)) {
515 //Skipping the unused words
516 if (std::find(gPos::JET_UNUSED_POSITION.begin(),gPos::JET_UNUSED_POSITION.end(),iWord)!=gPos::JET_UNUSED_POSITION.end()){
517 continue;
518 }
519 //Skipping the trailer words
520 if (std::find(gPos::TRAILER_POSITION.begin(),gPos::TRAILER_POSITION.end(),iWord)!=gPos::TRAILER_POSITION.end()){
521 continue;
522 }
523 // Decorator for slice number - only needed for out-of-time containers
524 // (L1A containers by definition only contain slice 0)
525 static const SG::AuxElement::Decorator<uint32_t> sliceNumberDec("sliceNumber");
526
527 //Saving gRho TOBs into the EDM container
528 if (iWord == gPos::GRHO_POSITION){
529 std::unique_ptr<xAOD::gFexJetRoI> myEDM (new xAOD::gFexJetRoI());
530 targetRhoContainer->push_back(std::move(myEDM));
531 targetRhoContainer->back()->initialize(dataArray[index+iWord], m_gJ_scale);
532 if (sliceNumber != 0) sliceNumberDec(*targetRhoContainer->back()) = sliceNumber;
533 }
534 //Saving gBlock TOBs into the EDM container
535 if (std::find(gPos::GBLOCK_POSITION.begin(),gPos::GBLOCK_POSITION.end(),iWord)!=gPos::GBLOCK_POSITION.end()){
536 std::unique_ptr<xAOD::gFexJetRoI> myEDM (new xAOD::gFexJetRoI());
537 targetSJContainer->push_back(std::move(myEDM));
538 targetSJContainer->back()->initialize(dataArray[index+iWord], m_gJ_scale);
539 if (sliceNumber != 0) sliceNumberDec(*targetSJContainer->back()) = sliceNumber;
540 }
541 //Saving gJet TOBs into the EDM container
542 if (std::find(gPos::GJET_POSITION.begin(),gPos::GJET_POSITION.end(),iWord)!=gPos::GJET_POSITION.end()){
543 std::unique_ptr<xAOD::gFexJetRoI> myEDM (new xAOD::gFexJetRoI());
544 targetLJContainer->push_back(std::move(myEDM));
545 targetLJContainer->back()->initialize(dataArray[index+iWord], m_gLJ_scale);
546 if (sliceNumber != 0) sliceNumberDec(*targetLJContainer->back()) = sliceNumber;
547 }
548
549 }
550
551 // Global TOBs - decode for all slices, store per-slice data
552 // They require data from all 3 FPGAs to be combined later
553 if (isMet){
554 // Ensure we have storage for this slice
555 ensureSliceCapacity(sliceNumber);
556
557 //Skipping the unused words
558 if (std::find(gPos::GLOBAL_UNUSED_POSITION.begin(),gPos::GLOBAL_UNUSED_POSITION.end(),iWord)!=gPos::GLOBAL_UNUSED_POSITION.end()){
559 continue;
560 }
561 //Skipping the trailer words
562 if (std::find(gPos::TRAILER_POSITION.begin(),gPos::TRAILER_POSITION.end(),iWord)!=gPos::TRAILER_POSITION.end()){
563 continue;
564 }
565 //Saving jwoj MHT TOBs into the EDM container
566 if (iWord == gPos::JWOJ_MHT_POSITION){
567 global_counter[sliceNumber]++;
568 if (blockType == 0x1) {JWOJ_MHT[sliceNumber][0] = dataArray[index+iWord];}
569 if (blockType == 0x2) {JWOJ_MHT[sliceNumber][1] = dataArray[index+iWord];}
570 if (blockType == 0x3) {JWOJ_MHT[sliceNumber][2] = dataArray[index+iWord];}
571 }
572 //Saving jwoj MST TOBs into the EDM container
573 if (iWord == gPos::JWOJ_MST_POSITION){
574 if (blockType == 0x1) {JWOJ_MST[sliceNumber][0] = dataArray[index+iWord];}
575 if (blockType == 0x2) {JWOJ_MST[sliceNumber][1] = dataArray[index+iWord];}
576 if (blockType == 0x3) {JWOJ_MST[sliceNumber][2] = dataArray[index+iWord];}
577 }
578 //Saving jwoj MET TOBs into the EDM container
579 if (iWord == gPos::JWOJ_MET_POSITION){
580 if (blockType == 0x1) {JWOJ_MET[sliceNumber][0] = dataArray[index+iWord];}
581 if (blockType == 0x2) {JWOJ_MET[sliceNumber][1] = dataArray[index+iWord];}
582 if (blockType == 0x3) {JWOJ_MET[sliceNumber][2] = dataArray[index+iWord];}
583 }
584 //Saving jwoj Scalar TOBs into the EDM container
585 if (iWord == gPos::JWOJ_SCALAR_POSITION){
586 if (blockType == 0x1) {JWOJ_SCALAR[sliceNumber][0] = dataArray[index+iWord];}
587 if (blockType == 0x2) {JWOJ_SCALAR[sliceNumber][1] = dataArray[index+iWord];}
588 if (blockType == 0x3) {JWOJ_SCALAR[sliceNumber][2] = dataArray[index+iWord];}
589 }
590 //Saving gEspresso TOBs into the EDM container
591 if (iWord == gPos::GESPRESSO_POSITION){
592 if (blockType == 0x1) {GESPRESSO[sliceNumber][0] = dataArray[index+iWord];}
593 if (blockType == 0x2) {GESPRESSO[sliceNumber][1] = dataArray[index+iWord];}
594 if (blockType == 0x3) {GESPRESSO[sliceNumber][2] = dataArray[index+iWord];}
595 }
596 //Saving gRistretto TOBs into the EDM container
597 if (iWord == gPos::GRISTRETTO_POSITION){
598 if (blockType == 0x1) {GRISTRETTO[sliceNumber][0] = dataArray[index+iWord];}
599 if (blockType == 0x2) {GRISTRETTO[sliceNumber][1] = dataArray[index+iWord];}
600 if (blockType == 0x3) {GRISTRETTO[sliceNumber][2] = dataArray[index+iWord];}
601 }
602 //Saving Noise Cut MET TOBs into the EDM container
603 if (iWord == gPos::NC_MET_POSITION){
604 if (blockType == 0x1) {NC_MET[sliceNumber][0] = dataArray[index+iWord];}
605 if (blockType == 0x2) {NC_MET[sliceNumber][1] = dataArray[index+iWord];}
606 if (blockType == 0x3) {NC_MET[sliceNumber][2] = dataArray[index+iWord];}
607 }
608 //Saving Noise Cut Scalar TOBs into the EDM container
609 if (iWord == gPos::NC_SCALAR_POSITION){
610 if (blockType == 0x1) {NC_SCALAR[sliceNumber][0] = dataArray[index+iWord];}
611 if (blockType == 0x2) {NC_SCALAR[sliceNumber][1] = dataArray[index+iWord];}
612 if (blockType == 0x3) {NC_SCALAR[sliceNumber][2] = dataArray[index+iWord];}
613 }
614 //Saving Rho+RMS MET TOBs into the EDM container
615 if (iWord == gPos::RMS_MET_POSITION){
616 if (blockType == 0x1) {RMS_MET[sliceNumber][0] = dataArray[index+iWord];}
617 if (blockType == 0x2) {RMS_MET[sliceNumber][1] = dataArray[index+iWord];}
618 if (blockType == 0x3) {RMS_MET[sliceNumber][2] = dataArray[index+iWord];}
619 }
620 //Saving Rho+RMS Scalar TOBs into the EDM container
621 if (iWord == gPos::RMS_SCALAR_POSITION){
622 if (blockType == 0x1) {RMS_SCALAR[sliceNumber][0] = dataArray[index+iWord];}
623 if (blockType == 0x2) {RMS_SCALAR[sliceNumber][1] = dataArray[index+iWord];}
624 if (blockType == 0x3) {RMS_SCALAR[sliceNumber][2] = dataArray[index+iWord];}
625 }
626
627 }
628
629 }
630
631 index += gPos::WORDS_PER_SLICE;
632 }
633
634 // Fill global TOBs for each slice that has complete data from all 3 FPGAs
635 for (size_t slice = 0; slice < global_counter.size(); slice++) {
636 ATH_MSG_DEBUG("global_counter[" << slice << "] is " << global_counter[slice]);
637 if (global_counter[slice] == 3) {
638 // Skip out-of-time slices if multi-slice mode is disabled
639 if (slice != 0 && !multiSlice) {
640 global_counter[slice] = 0;
641 continue;
642 }
643
644 // Select target containers based on slice (slice 0 = L1A, others = out-of-time)
645 if (slice == 0 && !decodeStdTOBs) {
646 // Only fill gEspresso and gRistretto when standard TOBs are disabled
647 fillGlobal(GESPRESSO[slice], 1, gEspressoContainer, slice, 0);
648 fillGlobal(GRISTRETTO[slice], 1, gRistrettoContainer, slice, 0);
649 } else {
650 auto& targetMHTContainer = (slice == 0) ? gMHTComponentsJwojContainer : gMHTComponentsJwojSliceContainer;
651 auto& targetMSTContainer = (slice == 0) ? gMSTComponentsJwojContainer : gMSTComponentsJwojSliceContainer;
652 auto& targetMETContainer = (slice == 0) ? gMETComponentsJwojContainer : gMETComponentsJwojSliceContainer;
653 auto& targetScalarContainer = (slice == 0) ? gScalarEJwojContainer : gScalarEJwojSliceContainer;
654 auto& targetEspressoContainer = (slice == 0) ? gEspressoContainer : gEspressoSliceContainer;
655 auto& targetRistrettoContainer = (slice == 0) ? gRistrettoContainer : gRistrettoSliceContainer;
656 auto& targetNCMETContainer = (slice == 0) ? gMETComponentsNoiseCutContainer : gMETComponentsNoiseCutSliceContainer;
657 auto& targetNCScalarContainer = (slice == 0) ? gScalarENoiseCutContainer : gScalarENoiseCutSliceContainer;
658 auto& targetRMSMETContainer = (slice == 0) ? gMETComponentsRmsContainer : gMETComponentsRmsSliceContainer;
659 auto& targetRMSScalarContainer = (slice == 0) ? gScalarERmsContainer : gScalarERmsSliceContainer;
660
661 fillGlobal(JWOJ_MHT[slice], 3, targetMHTContainer, slice);
662 fillGlobal(JWOJ_MST[slice], 4, targetMSTContainer, slice);
663 int16_t scalar = fillGlobal(JWOJ_MET[slice], 2, targetMETContainer, slice);
664 fillGlobal(JWOJ_SCALAR[slice], 1, targetScalarContainer, slice, scalar);
665
666 fillGlobal(GESPRESSO[slice], 1, targetEspressoContainer, slice, 0);
667
668 fillGlobal(GRISTRETTO[slice], 1, targetRistrettoContainer, slice, 0);
669
670 scalar = fillGlobal(NC_MET[slice], 2, targetNCMETContainer, slice);
671 fillGlobal(NC_SCALAR[slice], 1, targetNCScalarContainer, slice, scalar);
672
673 scalar = fillGlobal(RMS_MET[slice], 2, targetRMSMETContainer, slice);
674 fillGlobal(RMS_SCALAR[slice], 1, targetRMSScalarContainer, slice, scalar);
675 } // end else (standard TOBs enabled or out-of-time slice)
676
677 global_counter[slice] = 0;
678 }
679 }
680
681 }
682 }
683 return StatusCode::SUCCESS;
684}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
ROBF
OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment ROBF
Definition ByteStreamMergeOutputSvc.cxx:16
printError
void printError()
Definition CalibrateIBL.cxx:1359
SG::VarHandleBase::key
virtual const std::string & key() const override final
Return the StoreGate ID for the referenced object.
Definition AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx:64
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
gFexByteStreamTool::m_gMETComponentsRmsWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsRmsWriteKey
Definition gFexByteStreamTool.h:90
gFexByteStreamTool::m_gMETComponentsNoiseCutWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsNoiseCutWriteKey
Definition gFexByteStreamTool.h:89
gFexByteStreamTool::m_gRistrettoSliceWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gRistrettoSliceWriteKey
Definition gFexByteStreamTool.h:104
gFexByteStreamTool::m_gScalarENoiseCutSliceWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarENoiseCutSliceWriteKey
Definition gFexByteStreamTool.h:106
gFexByteStreamTool::m_gScalarERmsSliceWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarERmsSliceWriteKey
Definition gFexByteStreamTool.h:108
gFexByteStreamTool::m_gFexRhoSliceWriteKey
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexRhoSliceWriteKey
Definition gFexByteStreamTool.h:95
gFexByteStreamTool::m_gEspressoSliceWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gEspressoSliceWriteKey
Definition gFexByteStreamTool.h:103
gFexByteStreamTool::m_gMSTComponentsJwojSliceWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMSTComponentsJwojSliceWriteKey
Definition gFexByteStreamTool.h:102
gFexByteStreamTool::m_gMSTComponentsJwojWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMSTComponentsJwojWriteKey
Definition gFexByteStreamTool.h:88
gFexByteStreamTool::m_gScalarEJwojSliceWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarEJwojSliceWriteKey
Definition gFexByteStreamTool.h:99
gFexByteStreamTool::m_gRistrettoWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gRistrettoWriteKey
Definition gFexByteStreamTool.h:85
gFexByteStreamTool::m_gMHTComponentsJwojWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMHTComponentsJwojWriteKey
Definition gFexByteStreamTool.h:87
gFexByteStreamTool::m_gMHTComponentsJwojSliceWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMHTComponentsJwojSliceWriteKey
Definition gFexByteStreamTool.h:101
gFexByteStreamTool::m_gMETComponentsNoiseCutSliceWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsNoiseCutSliceWriteKey
Definition gFexByteStreamTool.h:105
gFexByteStreamTool::m_gScalarENoiseCutWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarENoiseCutWriteKey
Definition gFexByteStreamTool.h:91
gFexByteStreamTool::fillGlobal
int16_t fillGlobal(const std::array< uint32_t, 3 > &tob, const int type, SG::WriteHandle< xAOD::gFexGlobalRoIContainer > &container, uint32_t sliceNumber, int16_t scalar=-1) const
Definition gFexByteStreamTool.cxx:690
gFexByteStreamTool::m_gMETComponentsJwojWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsJwojWriteKey
Definition gFexByteStreamTool.h:86
gFexByteStreamTool::m_gScalarEJwojWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarEJwojWriteKey
Definition gFexByteStreamTool.h:83
gFexByteStreamTool::m_gEspressoWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gEspressoWriteKey
Definition gFexByteStreamTool.h:84
gFexByteStreamTool::m_gFexJetWriteKey
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexJetWriteKey
Definition gFexByteStreamTool.h:82
gFexByteStreamTool::m_gFexBlockWriteKey
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexBlockWriteKey
Definition gFexByteStreamTool.h:81
gFexByteStreamTool::m_gScalarERmsWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarERmsWriteKey
Definition gFexByteStreamTool.h:92
gFexByteStreamTool::m_gFexRhoWriteKey
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexRhoWriteKey
Definition gFexByteStreamTool.h:80
gFexByteStreamTool::m_gFexJetSliceWriteKey
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexJetSliceWriteKey
Definition gFexByteStreamTool.h:97
gFexByteStreamTool::m_gMETComponentsJwojSliceWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsJwojSliceWriteKey
Definition gFexByteStreamTool.h:100
gFexByteStreamTool::m_gMETComponentsRmsSliceWriteKey
SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsRmsSliceWriteKey
Definition gFexByteStreamTool.h:107
gFexByteStreamTool::m_gFexBlockSliceWriteKey
SG::WriteHandleKey< xAOD::gFexJetRoIContainer > m_gFexBlockSliceWriteKey
Definition gFexByteStreamTool.h:96
DeMoScan.index
str index
Definition DeMoScan.py:362
L1Topo::blockType
L1Topo::BlockTypes blockType(const uint32_t word, uint32_t offset=28, uint32_t size=0x0f)
Function to return the block type of a data word from L1Topo.
Definition BlockTypes.cxx:9
LVL1::gFEXPos::WORDS_PER_SLICE
constexpr unsigned int WORDS_PER_SLICE
Definition gFexPos.h:22
LVL1::gFEXPos::GBLOCK_POSITION
constexpr std::array< unsigned int, 4 > GBLOCK_POSITION
Definition gFexPos.h:31
LVL1::gFEXPos::BLOCK_TYPE_BIT
constexpr unsigned int BLOCK_TYPE_BIT
Definition gFexPos.h:14
LVL1::gFEXPos::GJET_POSITION
constexpr std::array< unsigned int, 2 > GJET_POSITION
Definition gFexPos.h:32
LVL1::gFEXPos::DATA_SIZE_MASK
constexpr unsigned int DATA_SIZE_MASK
Definition gFexPos.h:20
LVL1::gFEXPos::JWOJ_MHT_POSITION
constexpr unsigned int JWOJ_MHT_POSITION
Definition gFexPos.h:35
LVL1::gFEXPos::GESPRESSO_POSITION
constexpr unsigned int GESPRESSO_POSITION
Definition gFexPos.h:41
LVL1::gFEXPos::RMS_MET_POSITION
constexpr unsigned int RMS_MET_POSITION
Definition gFexPos.h:46
LVL1::gFEXPos::NC_SCALAR_POSITION
constexpr unsigned int NC_SCALAR_POSITION
Definition gFexPos.h:44
LVL1::gFEXPos::GLOBAL_UNUSED_POSITION
constexpr std::array< unsigned int, 2 > GLOBAL_UNUSED_POSITION
Definition gFexPos.h:29
LVL1::gFEXPos::BLOCK_TYPE_MASK
constexpr unsigned int BLOCK_TYPE_MASK
Definition gFexPos.h:15
LVL1::gFEXPos::ERROR_FLAG_BIT
constexpr unsigned int ERROR_FLAG_BIT
Definition gFexPos.h:18
LVL1::gFEXPos::TRAILER_POSITION
constexpr std::array< unsigned int, 2 > TRAILER_POSITION
Definition gFexPos.h:27
LVL1::gFEXPos::HEADER_SIZE_MASK
constexpr unsigned int HEADER_SIZE_MASK
Definition gFexPos.h:17
LVL1::gFEXPos::NC_MET_POSITION
constexpr unsigned int NC_MET_POSITION
Definition gFexPos.h:43
LVL1::gFEXPos::HEADER_SIZE_BIT
constexpr unsigned int HEADER_SIZE_BIT
Definition gFexPos.h:16
LVL1::gFEXPos::ERROR_FLAG_MASK
constexpr unsigned int ERROR_FLAG_MASK
Definition gFexPos.h:19
LVL1::gFEXPos::JET_UNUSED_POSITION
constexpr std::array< unsigned int, 5 > JET_UNUSED_POSITION
Definition gFexPos.h:28
LVL1::gFEXPos::GRHO_POSITION
constexpr unsigned int GRHO_POSITION
Definition gFexPos.h:33
LVL1::gFEXPos::JWOJ_SCALAR_POSITION
constexpr unsigned int JWOJ_SCALAR_POSITION
Definition gFexPos.h:38
LVL1::gFEXPos::GRISTRETTO_POSITION
constexpr unsigned int GRISTRETTO_POSITION
Definition gFexPos.h:40
LVL1::gFEXPos::JWOJ_MST_POSITION
constexpr unsigned int JWOJ_MST_POSITION
Definition gFexPos.h:36
LVL1::gFEXPos::RMS_SCALAR_POSITION
constexpr unsigned int RMS_SCALAR_POSITION
Definition gFexPos.h:47
LVL1::gFEXPos::JWOJ_MET_POSITION
constexpr unsigned int JWOJ_MET_POSITION
Definition gFexPos.h:37
Muon::nsw::STGTPPad::n_words
constexpr std::size_t n_words
Definition NSWSTGTPDecodeBitmaps.h:62
PayloadHelpers::dataSize
constexpr size_t dataSize(TDA::PayloadIterator start)
Size in bytes of the buffer that is needed to decode next fragment data content.
Definition TriggerEDMDeserialiserAlg.cxx:179
xAOD::gFexJetRoI
gFexJetRoI_v1 gFexJetRoI
Define the latest version of the gFexJetRoI class.
Definition gFexJetRoI.h:16
xAOD::int16_t
setScaleOne setStatusOne setSaturated int16_t
Definition gFexGlobalRoI_v1.cxx:55
xAOD::uint32_t
setEventNumber uint32_t
Definition EventInfo_v1.cxx:127

◆ convertToBS()

StatusCode gFexByteStreamTool::convertToBS ( std::vector< OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment * > & vrobf,
const EventContext & eventContext )
overridevirtual

xAOD->BS conversion

Definition at line 772 of file gFexByteStreamTool.cxx.

772 {
773
774 return StatusCode::SUCCESS;
775
776}

◆ decodeGfexTobSlice()

void gFexByteStreamTool::decodeGfexTobSlice ( const uint32_t dataArray[],
uint32_t blockType ) const
private

◆ fillGlobal()

int16_t gFexByteStreamTool::fillGlobal ( const std::array< uint32_t, 3 > & tob,
const int type,
SG::WriteHandle< xAOD::gFexGlobalRoIContainer > & container,
uint32_t sliceNumber,
int16_t scalar = -1 ) const
private

Definition at line 690 of file gFexByteStreamTool.cxx.

692 {
693
694 ATH_MSG_DEBUG("fillGlobal with type " << type << " slice " << sliceNumber);
695
696 // 32 bit integers to avoid interim overflows when summing 16b (signed)
697 // quantities from each pFPGA. Proper clamping and bit masking follows afterwards
698 int32_t sum_x = 0;
699 int32_t sum_y = 0;
700
701 // Extract the x and y components and sum them for the three FPGAs
702 for (size_t fpga = 0; fpga < 3; fpga++) {
703 int16_t x = tob[fpga] >> gPos::GLOBAL_X_BIT & gPos::GLOBAL_X_MASK;
704 int16_t y = tob[fpga] >> gPos::GLOBAL_Y_BIT & gPos::GLOBAL_Y_MASK;
705 if (x & 0x00080000) { x = 0xFFFF0000 | x; }
706 if (y & 0x00080000) { y = 0xFFFF0000 | y; }
707 sum_x += x;
708 if (container.key() == "L1_gScalarEJwoj" && y < 0) y = 0;
709 sum_y += y;
710 }
711
712 // Special case for gEspresso/gRistretto: in the readout these quantities are stored in x. We need to move them to y to armonize this with the other scalar quantities
713 // This is true for the readout only. On the realtime path gEspresso is sent to Topo on y (see https://docs.google.com/spreadsheets/d/15YVVtGofhXMtV7jXRFzWO0FVUtUAjS-X-aQjh3FKE_w/edit?gid=1546010783#gid=1546010783).
714 if (container.key() == "L1_gEspresso" || container.key() == "L1_gRistretto" ) {
715 sum_y = sum_x;
716 }
717
718 if (type == 1) {//we are considering the scalar case (sum_x = MET and sum_y = SumEt)
719 ATH_MSG_DEBUG(" scalar tob, saving " << scalar << " in X component");
720 sum_x = scalar; //Total MET
721 if( sum_y > 0x000FFF) sum_y = 0x000FFF; //Overflow control for SumEt
722 if( sum_y < 0) sum_y = 0;
723
724 } else {
725 if (sum_x < -0x000800) sum_x = -0x000800; //-2048
726 if (sum_x > 0x0007FF) sum_x = 0x0007FF; //2047
727
728 if (sum_y < -0x000800) sum_y = -0x000800; //-2048
729 if (sum_y > 0x0007FF) sum_y = 0x0007FF; //2047
730 }
731
732 ATH_MSG_DEBUG(" fillGlobal type " << type << std::dec << " sum_x " << sum_x << " sum_y " << sum_y);
733
734 uint32_t METword = 0;
735
736 METword = (sum_y & 0x00000FFF) << 0; //set the Quantity2 to the corresponding slot (LSB)
737 METword = METword | (sum_x & 0x00000FFF) << 12;//Quantity 1 (in bit number 12)
738 if (sum_y != 0) METword = METword | 0x00000001 << 24;//Status bit for Quantity 2 (0 if quantity is null)
739 if (sum_x != 0) METword = METword | 0x00000001 << 25;//Status bit for Quantity 1 (0 if quantity is null)
740 METword = METword | (type & 0x0000001F) << 26;//TOB ID (5 bits starting at 26)
741
742 // Save to the EDM
743 std::unique_ptr<xAOD::gFexGlobalRoI> myEDM (new xAOD::gFexGlobalRoI());
744 container->push_back(std::move(myEDM));
745 container->back()->setWord(METword);
746 container->back()->setQuantityOne(sum_x);
747 container->back()->setQuantityTwo(sum_y);
748 container->back()->setScaleOne(m_gXE_scale);
749 container->back()->setScaleTwo(m_gTE_scale);
750 container->back()->setStatusOne(1);
751 container->back()->setStatusTwo(1);
752 container->back()->setSaturated(0);
753 container->back()->setGlobalType(type);
754
755 // Add slice number decoration only for out-of-time TOBs
756 // (L1A containers by definition only contain slice 0)
757 if (sliceNumber != 0) {
758 static const SG::AuxElement::Decorator<uint32_t> sliceNumberDec("sliceNumber");
759 sliceNumberDec(*container->back()) = sliceNumber;
760 }
761
762 int MET2 = sum_x * sum_x + sum_y * sum_y;
763 int16_t MET = std::sqrt(MET2);
764 if (MET > 0x000FFF) MET = 0x000FFF;
765
766 return MET;
767
768}
y
#define y
x
#define x
LVL1::gFEXPos::GLOBAL_Y_MASK
constexpr unsigned int GLOBAL_Y_MASK
Definition gFexPos.h:50
LVL1::gFEXPos::GLOBAL_X_MASK
constexpr unsigned int GLOBAL_X_MASK
Definition gFexPos.h:49
LVL1::gFEXPos::GLOBAL_Y_BIT
constexpr unsigned int GLOBAL_Y_BIT
Definition gFexPos.h:52
LVL1::gFEXPos::GLOBAL_X_BIT
constexpr unsigned int GLOBAL_X_BIT
Definition gFexPos.h:51
SG::container
const SG::AuxVectorData * container() const
Return the container holding this element.
xAOD::gFexGlobalRoI
gFexGlobalRoI_v1 gFexGlobalRoI
Define the latest version of the eFexEMRoI class.
Definition gFexGlobalRoI.h:16

◆ initialize()

StatusCode gFexByteStreamTool::initialize ( )
overridevirtual

Definition at line 30 of file gFexByteStreamTool.cxx.

30 {
31 // Conversion mode for gRho TOBs
32 ATH_MSG_DEBUG(" ROB IDs: " << MSG::hex << m_robIds.value() << MSG::dec);
33
34 // When both read and write keys are empty for standard containers, they are disabled.
35 // This happens in TOBs=False mode: standard L1A containers come from the HLT result
36 // and only gEspresso/gRistretto/OutOfTime containers are decoded from the L1 ROB.
37 const bool stdTOBsEnabled = !m_gFexRhoReadKey.key().empty() || !m_gFexRhoWriteKey.key().empty();
38
39 ConversionMode gRhomode = ConversionMode::Undefined;
40 ConversionMode gSJmode = ConversionMode::Undefined;
41 ConversionMode gLJmode = ConversionMode::Undefined;
42
43 if (stdTOBsEnabled) {
44 gRhomode = getConversionMode(m_gFexRhoReadKey, m_gFexRhoWriteKey, msg());
45 ATH_CHECK(gRhomode!=ConversionMode::Undefined);
46 ATH_CHECK(m_gFexRhoWriteKey.initialize(gRhomode==ConversionMode::Decoding));
47 ATH_CHECK(m_gFexRhoReadKey.initialize(gRhomode==ConversionMode::Encoding));
48 ATH_MSG_DEBUG((gRhomode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gRho ");
49
50 gSJmode = getConversionMode(m_gFexBlockReadKey, m_gFexBlockWriteKey, msg());
51 ATH_CHECK(gSJmode!=ConversionMode::Undefined);
52 ATH_CHECK(m_gFexBlockWriteKey.initialize(gSJmode==ConversionMode::Decoding));
53 ATH_CHECK(m_gFexBlockReadKey.initialize(gSJmode==ConversionMode::Encoding));
54 ATH_MSG_DEBUG((gSJmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gSJ ");
55
56 gLJmode = getConversionMode(m_gFexJetReadKey, m_gFexJetWriteKey, msg());
57 ATH_CHECK(gLJmode!=ConversionMode::Undefined);
58 ATH_CHECK(m_gFexJetWriteKey.initialize(gLJmode==ConversionMode::Decoding));
59 ATH_CHECK(m_gFexJetReadKey.initialize(gLJmode==ConversionMode::Encoding));
60 ATH_MSG_DEBUG((gLJmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gLJ ");
61
62 ConversionMode gScalarEJwojmode = getConversionMode(m_gScalarEJwojReadKey, m_gScalarEJwojWriteKey, msg());
63 ATH_CHECK(gScalarEJwojmode!=ConversionMode::Undefined);
64 ATH_CHECK(m_gScalarEJwojWriteKey.initialize(gScalarEJwojmode==ConversionMode::Decoding));
65 ATH_CHECK(m_gScalarEJwojReadKey.initialize(gScalarEJwojmode==ConversionMode::Encoding));
66 ATH_MSG_DEBUG((gScalarEJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gScalarEJwoj ");
67
68 ConversionMode gMETComponentsJwojmode = getConversionMode(m_gMETComponentsJwojReadKey, m_gMETComponentsJwojWriteKey, msg());
69 ATH_CHECK(gMETComponentsJwojmode!=ConversionMode::Undefined);
70 ATH_CHECK(m_gMETComponentsJwojWriteKey.initialize(gMETComponentsJwojmode==ConversionMode::Decoding));
71 ATH_CHECK(m_gMETComponentsJwojReadKey.initialize(gMETComponentsJwojmode==ConversionMode::Encoding));
72 ATH_MSG_DEBUG((gMETComponentsJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMETComponentsJwoj ");
73
74 ConversionMode gMHTComponentsJwojmode = getConversionMode(m_gMHTComponentsJwojReadKey, m_gMHTComponentsJwojWriteKey, msg());
75 ATH_CHECK(gMHTComponentsJwojmode!=ConversionMode::Undefined);
76 ATH_CHECK(m_gMHTComponentsJwojWriteKey.initialize(gMHTComponentsJwojmode==ConversionMode::Decoding));
77 ATH_CHECK(m_gMHTComponentsJwojReadKey.initialize(gMHTComponentsJwojmode==ConversionMode::Encoding));
78 ATH_MSG_DEBUG((gMHTComponentsJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMHTComponentsJwoj ");
79
80 ConversionMode gMSTComponentsJwojmode = getConversionMode(m_gMSTComponentsJwojReadKey, m_gMSTComponentsJwojWriteKey, msg());
81 ATH_CHECK(gMSTComponentsJwojmode!=ConversionMode::Undefined);
82 ATH_CHECK(m_gMSTComponentsJwojWriteKey.initialize(gMSTComponentsJwojmode==ConversionMode::Decoding));
83 ATH_CHECK(m_gMSTComponentsJwojReadKey.initialize(gMSTComponentsJwojmode==ConversionMode::Encoding));
84 ATH_MSG_DEBUG((gMSTComponentsJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMSTComponentsJwoj ");
85
86 ConversionMode gMETComponentsNoiseCutmode = getConversionMode(m_gMETComponentsNoiseCutReadKey, m_gMETComponentsNoiseCutWriteKey, msg());
87 ATH_CHECK(gMETComponentsNoiseCutmode!=ConversionMode::Undefined);
88 ATH_CHECK(m_gMETComponentsNoiseCutWriteKey.initialize(gMETComponentsNoiseCutmode==ConversionMode::Decoding));
89 ATH_CHECK(m_gMETComponentsNoiseCutReadKey.initialize(gMETComponentsNoiseCutmode==ConversionMode::Encoding));
90 ATH_MSG_DEBUG((gMETComponentsNoiseCutmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMETComponentsNoiseCut ");
91
92 ConversionMode gMETComponentsRmsmode = getConversionMode(m_gMETComponentsRmsReadKey, m_gMETComponentsRmsWriteKey, msg());
93 ATH_CHECK(gMETComponentsRmsmode!=ConversionMode::Undefined);
94 ATH_CHECK(m_gMETComponentsRmsWriteKey.initialize(gMETComponentsRmsmode==ConversionMode::Decoding));
95 ATH_CHECK(m_gMETComponentsRmsReadKey.initialize(gMETComponentsRmsmode==ConversionMode::Encoding));
96 ATH_MSG_DEBUG((gMETComponentsRmsmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMETComponentsRms ");
97
98 ConversionMode gScalarENoiseCutmode = getConversionMode(m_gScalarENoiseCutReadKey, m_gScalarENoiseCutWriteKey, msg());
99 ATH_CHECK(gScalarENoiseCutmode!=ConversionMode::Undefined);
100 ATH_CHECK(m_gScalarENoiseCutWriteKey.initialize(gScalarENoiseCutmode==ConversionMode::Decoding));
101 ATH_CHECK(m_gScalarENoiseCutReadKey.initialize(gScalarENoiseCutmode==ConversionMode::Encoding));
102 ATH_MSG_DEBUG((gScalarENoiseCutmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gScalarENoiseCut ");
103
104 ConversionMode gScalarERmsmode = getConversionMode(m_gScalarERmsReadKey, m_gScalarERmsWriteKey, msg());
105 ATH_CHECK(gScalarERmsmode!=ConversionMode::Undefined);
106 ATH_CHECK(m_gScalarERmsWriteKey.initialize(gScalarERmsmode==ConversionMode::Decoding));
107 ATH_CHECK(m_gScalarERmsReadKey.initialize(gScalarERmsmode==ConversionMode::Encoding));
108 ATH_MSG_DEBUG((gScalarERmsmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gScalarERms ");
109
110 //checking all Conversion modes.. avoid misconfigurations
111 const std::array<ConversionMode,2> modes{gSJmode,gLJmode};
112 if (std::any_of(modes.begin(),modes.end(),[&gRhomode](ConversionMode m) { return m!=gRhomode; } )) {
113 ATH_MSG_ERROR("Inconsistent conversion modes");
114 return StatusCode::FAILURE;
115 }
116 } else {
117 // Standard L1A containers disabled (decoded from HLT result instead)
118 ATH_MSG_INFO("Standard L1A gFex TOB containers disabled (decoded from HLT result)");
119 ATH_CHECK(m_gFexRhoWriteKey.initialize(false));
120 ATH_CHECK(m_gFexRhoReadKey.initialize(false));
121 ATH_CHECK(m_gFexBlockWriteKey.initialize(false));
122 ATH_CHECK(m_gFexBlockReadKey.initialize(false));
123 ATH_CHECK(m_gFexJetWriteKey.initialize(false));
124 ATH_CHECK(m_gFexJetReadKey.initialize(false));
125 ATH_CHECK(m_gScalarEJwojWriteKey.initialize(false));
126 ATH_CHECK(m_gScalarEJwojReadKey.initialize(false));
127 ATH_CHECK(m_gMETComponentsJwojWriteKey.initialize(false));
128 ATH_CHECK(m_gMETComponentsJwojReadKey.initialize(false));
129 ATH_CHECK(m_gMHTComponentsJwojWriteKey.initialize(false));
130 ATH_CHECK(m_gMHTComponentsJwojReadKey.initialize(false));
131 ATH_CHECK(m_gMSTComponentsJwojWriteKey.initialize(false));
132 ATH_CHECK(m_gMSTComponentsJwojReadKey.initialize(false));
133 ATH_CHECK(m_gMETComponentsNoiseCutWriteKey.initialize(false));
134 ATH_CHECK(m_gMETComponentsNoiseCutReadKey.initialize(false));
135 ATH_CHECK(m_gMETComponentsRmsWriteKey.initialize(false));
136 ATH_CHECK(m_gMETComponentsRmsReadKey.initialize(false));
137 ATH_CHECK(m_gScalarENoiseCutWriteKey.initialize(false));
138 ATH_CHECK(m_gScalarENoiseCutReadKey.initialize(false));
139 ATH_CHECK(m_gScalarERmsWriteKey.initialize(false));
140 ATH_CHECK(m_gScalarERmsReadKey.initialize(false));
141 }
142
143 // gEspresso and gRistretto are always enabled (not provided by HLT result)
144 ConversionMode gEspressomode = getConversionMode(m_gEspressoReadKey, m_gEspressoWriteKey, msg());
145 ATH_CHECK(gEspressomode!=ConversionMode::Undefined);
146 ATH_CHECK(m_gEspressoWriteKey.initialize(gEspressomode==ConversionMode::Decoding));
147 ATH_CHECK(m_gEspressoReadKey.initialize(gEspressomode==ConversionMode::Encoding));
148 ATH_MSG_DEBUG((gEspressomode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gEspresso ");
149
150 ConversionMode gRistrettomode = getConversionMode(m_gRistrettoReadKey, m_gRistrettoWriteKey, msg());
151 ATH_CHECK(gRistrettomode!=ConversionMode::Undefined);
152 ATH_CHECK(m_gRistrettoWriteKey.initialize(gRistrettomode==ConversionMode::Decoding));
153 ATH_CHECK(m_gRistrettoReadKey.initialize(gRistrettomode==ConversionMode::Encoding));
154 ATH_MSG_DEBUG((gRistrettomode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gRistretto ");
155
156 // Initialize multi-slice write handle keys (only if configured with non-empty key)
157 ATH_CHECK(m_gFexRhoSliceWriteKey.initialize(!m_gFexRhoSliceWriteKey.empty()));
158 ATH_CHECK(m_gFexBlockSliceWriteKey.initialize(!m_gFexBlockSliceWriteKey.empty()));
159 ATH_CHECK(m_gFexJetSliceWriteKey.initialize(!m_gFexJetSliceWriteKey.empty()));
160 ATH_CHECK(m_gScalarEJwojSliceWriteKey.initialize(!m_gScalarEJwojSliceWriteKey.empty()));
161 ATH_CHECK(m_gMETComponentsJwojSliceWriteKey.initialize(!m_gMETComponentsJwojSliceWriteKey.empty()));
162 ATH_CHECK(m_gMHTComponentsJwojSliceWriteKey.initialize(!m_gMHTComponentsJwojSliceWriteKey.empty()));
163 ATH_CHECK(m_gMSTComponentsJwojSliceWriteKey.initialize(!m_gMSTComponentsJwojSliceWriteKey.empty()));
164 ATH_CHECK(m_gEspressoSliceWriteKey.initialize(!m_gEspressoSliceWriteKey.empty()));
165 ATH_CHECK(m_gRistrettoSliceWriteKey.initialize(!m_gRistrettoSliceWriteKey.empty()));
166 ATH_CHECK(m_gMETComponentsNoiseCutSliceWriteKey.initialize(!m_gMETComponentsNoiseCutSliceWriteKey.empty()));
167 ATH_CHECK(m_gScalarENoiseCutSliceWriteKey.initialize(!m_gScalarENoiseCutSliceWriteKey.empty()));
168 ATH_CHECK(m_gMETComponentsRmsSliceWriteKey.initialize(!m_gMETComponentsRmsSliceWriteKey.empty()));
169 ATH_CHECK(m_gScalarERmsSliceWriteKey.initialize(!m_gScalarERmsSliceWriteKey.empty()));
170
171 // Initialize slice number decoration keys for out-of-time containers.
172 // Multi-slice mode is activated based on m_gFexJetSliceWriteKey being non-empty,
173 // so all decoration keys are initialized based on that same condition.
174 // When multi-slice mode is enabled, all OOT container keys must be configured together.
175 ATH_CHECK(m_gFexRhoOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
176 ATH_CHECK(m_gFexBlockOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
177 ATH_CHECK(m_gFexJetOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
178 ATH_CHECK(m_gScalarEJwojOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
179 ATH_CHECK(m_gMETComponentsJwojOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
180 ATH_CHECK(m_gMHTComponentsJwojOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
181 ATH_CHECK(m_gMSTComponentsJwojOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
182 ATH_CHECK(m_gEspressoOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
183 ATH_CHECK(m_gRistrettoOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
184 ATH_CHECK(m_gMETComponentsNoiseCutOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
185 ATH_CHECK(m_gScalarENoiseCutOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
186 ATH_CHECK(m_gMETComponentsRmsOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
187 ATH_CHECK(m_gScalarERmsOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
188
189 ATH_CHECK(m_l1MenuKey.initialize());
190
191 if (!m_monTool.empty()) {
192 ATH_CHECK(m_monTool.retrieve());
193 ATH_MSG_INFO("Logging errors to " << m_monTool.name() << " monitoring tool");
194 m_UseMonitoring = true;
195 }
196
197
198 return StatusCode::SUCCESS;
199}
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
gFexByteStreamTool::m_gFexRhoReadKey
SG::ReadHandleKey< xAOD::gFexJetRoIContainer > m_gFexRhoReadKey
Definition gFexByteStreamTool.h:130
gFexByteStreamTool::m_gMHTComponentsJwojReadKey
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gMHTComponentsJwojReadKey
Definition gFexByteStreamTool.h:137
gFexByteStreamTool::m_gMSTComponentsJwojOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gMSTComponentsJwojOOTDecorKey
Definition gFexByteStreamTool.h:121
gFexByteStreamTool::m_gScalarEJwojReadKey
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarEJwojReadKey
Definition gFexByteStreamTool.h:133
gFexByteStreamTool::m_gFexRhoOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_gFexRhoOOTDecorKey
Definition gFexByteStreamTool.h:114
gFexByteStreamTool::m_gRistrettoOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gRistrettoOOTDecorKey
Definition gFexByteStreamTool.h:123
gFexByteStreamTool::m_l1MenuKey
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey
Definition gFexByteStreamTool.h:145
gFexByteStreamTool::m_gMETComponentsJwojReadKey
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsJwojReadKey
Definition gFexByteStreamTool.h:136
gFexByteStreamTool::m_gMETComponentsNoiseCutReadKey
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsNoiseCutReadKey
Definition gFexByteStreamTool.h:139
gFexByteStreamTool::m_gFexJetOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_gFexJetOOTDecorKey
Definition gFexByteStreamTool.h:116
gFexByteStreamTool::m_gScalarERmsReadKey
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarERmsReadKey
Definition gFexByteStreamTool.h:142
gFexByteStreamTool::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition gFexByteStreamTool.h:66
gFexByteStreamTool::m_gFexJetReadKey
SG::ReadHandleKey< xAOD::gFexJetRoIContainer > m_gFexJetReadKey
Definition gFexByteStreamTool.h:132
gFexByteStreamTool::m_gScalarENoiseCutOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarENoiseCutOOTDecorKey
Definition gFexByteStreamTool.h:125
gFexByteStreamTool::m_gEspressoReadKey
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gEspressoReadKey
Definition gFexByteStreamTool.h:134
gFexByteStreamTool::m_gMHTComponentsJwojOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gMHTComponentsJwojOOTDecorKey
Definition gFexByteStreamTool.h:120
gFexByteStreamTool::m_gScalarERmsOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarERmsOOTDecorKey
Definition gFexByteStreamTool.h:127
gFexByteStreamTool::m_gMETComponentsRmsReadKey
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsRmsReadKey
Definition gFexByteStreamTool.h:140
gFexByteStreamTool::m_gFexBlockReadKey
SG::ReadHandleKey< xAOD::gFexJetRoIContainer > m_gFexBlockReadKey
Definition gFexByteStreamTool.h:131
gFexByteStreamTool::m_gMSTComponentsJwojReadKey
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gMSTComponentsJwojReadKey
Definition gFexByteStreamTool.h:138
gFexByteStreamTool::m_gFexBlockOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_gFexBlockOOTDecorKey
Definition gFexByteStreamTool.h:115
gFexByteStreamTool::m_gMETComponentsRmsOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsRmsOOTDecorKey
Definition gFexByteStreamTool.h:126
gFexByteStreamTool::m_gEspressoOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gEspressoOOTDecorKey
Definition gFexByteStreamTool.h:122
gFexByteStreamTool::m_robIds
Gaudi::Property< std::vector< uint32_t > > m_robIds
Definition gFexByteStreamTool.h:71
gFexByteStreamTool::m_gScalarEJwojOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarEJwojOOTDecorKey
Definition gFexByteStreamTool.h:118
gFexByteStreamTool::m_gScalarENoiseCutReadKey
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gScalarENoiseCutReadKey
Definition gFexByteStreamTool.h:141
gFexByteStreamTool::m_gMETComponentsNoiseCutOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsNoiseCutOOTDecorKey
Definition gFexByteStreamTool.h:124
gFexByteStreamTool::m_gRistrettoReadKey
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_gRistrettoReadKey
Definition gFexByteStreamTool.h:135
gFexByteStreamTool::m_gMETComponentsJwojOOTDecorKey
SG::WriteDecorHandleKey< xAOD::gFexGlobalRoIContainer > m_gMETComponentsJwojOOTDecorKey
Definition gFexByteStreamTool.h:119
CaloClusterMLCalib::modes
float modes(const std::vector< float > &mus, const std::vector< float > &log_sigma2s, const std::vector< float > &alphas)
Definition CaloClusterMLGaussianMixture.h:55
msg
MsgStream & msg
Definition testRead.cxx:32

◆ printError()

void gFexByteStreamTool::printError ( const std::string & location,
const std::string & title,
MSG::Level type,
const std::string & detail ) const
private

Definition at line 779 of file gFexByteStreamTool.cxx.

779 {
780
781 if(m_UseMonitoring){
782 Monitored::Group(m_monTool,
783 Monitored::Scalar("gfexDecoderErrorLocation",location.empty() ? std::string("UNKNOWN") : location),
784 Monitored::Scalar("gfexDecoderErrorTitle" ,title.empty() ? std::string("UNKNOWN") : title)
785 );
786 }
787 else {
788 msg() << type << detail << endmsg;
789 }
790}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63

◆ robIds()

virtual const std::vector< uint32_t > & gFexByteStreamTool::robIds ( ) const
inlineoverridevirtual

Declare ROB IDs for conversion.

Definition at line 60 of file gFexByteStreamTool.h.

60 {
61 return m_robIds.value();
62 }

◆ start()

StatusCode gFexByteStreamTool::start ( )
overridevirtual

Definition at line 201 of file gFexByteStreamTool.cxx.

201 {
202 // Retrieve the L1 menu configuration
203 SG::ReadHandle<TrigConf::L1Menu> l1Menu (m_l1MenuKey);
204 ATH_CHECK(l1Menu.isValid());
205
206 try {
207 const auto & l1Menu_gJ = l1Menu->thrExtraInfo().gJ();
208 const auto & l1Menu_gLJ = l1Menu->thrExtraInfo().gLJ();
209 const auto & l1Menu_gXE = l1Menu->thrExtraInfo().gXE();
210 const auto & l1Menu_gTE = l1Menu->thrExtraInfo().gTE();
211
212 ATH_CHECK(l1Menu_gJ.isValid());
213 ATH_CHECK(l1Menu_gLJ.isValid());
214 ATH_CHECK(l1Menu_gXE.isValid());
215 ATH_CHECK(l1Menu_gTE.isValid());
216
217 m_gJ_scale = l1Menu_gJ.resolutionMeV();
218 m_gLJ_scale = l1Menu_gLJ.resolutionMeV();
219 m_gXE_scale = l1Menu_gXE.resolutionMeV();
220 m_gTE_scale = l1Menu_gTE.resolutionMeV();
221 } catch (const std::exception& e) {
222 ATH_MSG_ERROR("Exception reading L1Menu: " << e.what());
223 return StatusCode::FAILURE;
224 }
225
226 return StatusCode::SUCCESS;
227
228}

Member Data Documentation

◆ m_DEBUG

uint8_t gFexByteStreamTool::m_DEBUG =0
staticconstexprprivate

Definition at line 153 of file gFexByteStreamTool.h.

◆ m_ERROR

uint8_t gFexByteStreamTool::m_ERROR =2
staticconstexprprivate

Definition at line 155 of file gFexByteStreamTool.h.

◆ m_FATAL

uint8_t gFexByteStreamTool::m_FATAL =3
staticconstexprprivate

Definition at line 156 of file gFexByteStreamTool.h.

◆ m_gEspressoOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexGlobalRoIContainer> gFexByteStreamTool::m_gEspressoOOTDecorKey {this,"gEspressoOOTDecorKey",m_gEspressoSliceWriteKey,"sliceNumber","Slice number decoration for gEspresso out-of-time"}
private

Definition at line 122 of file gFexByteStreamTool.h.

122{this,"gEspressoOOTDecorKey",m_gEspressoSliceWriteKey,"sliceNumber","Slice number decoration for gEspresso out-of-time"};

◆ m_gEspressoReadKey

SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gEspressoReadKey {this,"gEspressoOutputContainerReadKey","L1_gEspresso","Read gFEX EDM gEspresso container"}
private

Definition at line 134 of file gFexByteStreamTool.h.

134{this,"gEspressoOutputContainerReadKey","L1_gEspresso","Read gFEX EDM gEspresso container"};

◆ m_gEspressoSliceWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gEspressoSliceWriteKey {this,"gEspressoSliceContainerWriteKey","","Write gFEX EDM gEspresso out-of-time container"}
private

Definition at line 103 of file gFexByteStreamTool.h.

103{this,"gEspressoSliceContainerWriteKey","","Write gFEX EDM gEspresso out-of-time container"};

◆ m_gEspressoWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gEspressoWriteKey {this,"gEspressoOutputContainerWriteKey","L1_gEspresso","Write gFEX EDM gEspresso container"}
private

Definition at line 84 of file gFexByteStreamTool.h.

84{this,"gEspressoOutputContainerWriteKey","L1_gEspresso","Write gFEX EDM gEspresso container"};

◆ m_gFexBlockOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> gFexByteStreamTool::m_gFexBlockOOTDecorKey {this,"gFexBlockOOTDecorKey",m_gFexBlockSliceWriteKey,"sliceNumber","Slice number decoration for gFexBlock out-of-time"}
private

Definition at line 115 of file gFexByteStreamTool.h.

115{this,"gFexBlockOOTDecorKey",m_gFexBlockSliceWriteKey,"sliceNumber","Slice number decoration for gFexBlock out-of-time"};

◆ m_gFexBlockReadKey

SG::ReadHandleKey< xAOD::gFexJetRoIContainer > gFexByteStreamTool::m_gFexBlockReadKey {this,"gFexSRJetOutputContainerReadKey","L1_gFexSRJetRoI","Read gFEX EDM gFexBlock container"}
private

Definition at line 131 of file gFexByteStreamTool.h.

131{this,"gFexSRJetOutputContainerReadKey","L1_gFexSRJetRoI","Read gFEX EDM gFexBlock container"};

◆ m_gFexBlockSliceWriteKey

SG::WriteHandleKey< xAOD::gFexJetRoIContainer > gFexByteStreamTool::m_gFexBlockSliceWriteKey {this,"gFexSRJetSliceContainerWriteKey","","Write gFEX EDM gFexBlock out-of-time container"}
private

Definition at line 96 of file gFexByteStreamTool.h.

96{this,"gFexSRJetSliceContainerWriteKey","","Write gFEX EDM gFexBlock out-of-time container"};

◆ m_gFexBlockWriteKey

SG::WriteHandleKey< xAOD::gFexJetRoIContainer > gFexByteStreamTool::m_gFexBlockWriteKey {this,"gFexSRJetOutputContainerWriteKey","L1_gFexSRJetRoI","Write gFEX EDM gFexBlock container"}
private

Definition at line 81 of file gFexByteStreamTool.h.

81{this,"gFexSRJetOutputContainerWriteKey","L1_gFexSRJetRoI","Write gFEX EDM gFexBlock container"};

◆ m_gFexJetOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> gFexByteStreamTool::m_gFexJetOOTDecorKey {this,"gFexJetOOTDecorKey",m_gFexJetSliceWriteKey,"sliceNumber","Slice number decoration for gFexJet out-of-time"}
private

Definition at line 116 of file gFexByteStreamTool.h.

116{this,"gFexJetOOTDecorKey",m_gFexJetSliceWriteKey,"sliceNumber","Slice number decoration for gFexJet out-of-time"};

◆ m_gFexJetReadKey

SG::ReadHandleKey< xAOD::gFexJetRoIContainer > gFexByteStreamTool::m_gFexJetReadKey {this,"gFexLRJetOutputContainerReadKey","L1_gFexLRJetRoI","Read gFEX EDM gFexJet container"}
private

Definition at line 132 of file gFexByteStreamTool.h.

132{this,"gFexLRJetOutputContainerReadKey","L1_gFexLRJetRoI","Read gFEX EDM gFexJet container"};

◆ m_gFexJetSliceWriteKey

SG::WriteHandleKey< xAOD::gFexJetRoIContainer > gFexByteStreamTool::m_gFexJetSliceWriteKey {this,"gFexLRJetSliceContainerWriteKey","","Write gFEX EDM gFexJet out-of-time container"}
private

Definition at line 97 of file gFexByteStreamTool.h.

97{this,"gFexLRJetSliceContainerWriteKey","","Write gFEX EDM gFexJet out-of-time container"};

◆ m_gFexJetWriteKey

SG::WriteHandleKey< xAOD::gFexJetRoIContainer > gFexByteStreamTool::m_gFexJetWriteKey {this,"gFexLRJetOutputContainerWriteKey","L1_gFexLRJetRoI","Write gFEX EDM gFexJet container"}
private

Definition at line 82 of file gFexByteStreamTool.h.

82{this,"gFexLRJetOutputContainerWriteKey","L1_gFexLRJetRoI","Write gFEX EDM gFexJet container"};

◆ m_gFexRhoOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexJetRoIContainer> gFexByteStreamTool::m_gFexRhoOOTDecorKey {this,"gFexRhoOOTDecorKey",m_gFexRhoSliceWriteKey,"sliceNumber","Slice number decoration for gFexRho out-of-time"}
private

Definition at line 114 of file gFexByteStreamTool.h.

114{this,"gFexRhoOOTDecorKey",m_gFexRhoSliceWriteKey,"sliceNumber","Slice number decoration for gFexRho out-of-time"};

◆ m_gFexRhoReadKey

SG::ReadHandleKey< xAOD::gFexJetRoIContainer > gFexByteStreamTool::m_gFexRhoReadKey {this,"gFexRhoOutputContainerReadKey","L1_gFexRhoRoI","Read gFEX EDM gFexRho container"}
private

Definition at line 130 of file gFexByteStreamTool.h.

130{this,"gFexRhoOutputContainerReadKey","L1_gFexRhoRoI","Read gFEX EDM gFexRho container"};

◆ m_gFexRhoSliceWriteKey

SG::WriteHandleKey< xAOD::gFexJetRoIContainer > gFexByteStreamTool::m_gFexRhoSliceWriteKey {this,"gFexRhoSliceContainerWriteKey","","Write gFEX EDM gFexRho out-of-time container"}
private

Definition at line 95 of file gFexByteStreamTool.h.

95{this,"gFexRhoSliceContainerWriteKey","","Write gFEX EDM gFexRho out-of-time container"};

◆ m_gFexRhoWriteKey

SG::WriteHandleKey< xAOD::gFexJetRoIContainer > gFexByteStreamTool::m_gFexRhoWriteKey {this,"gFexRhoOutputContainerWriteKey","L1_gFexRhoRoI","Write gFEX EDM gFexRho container"}
private

Definition at line 80 of file gFexByteStreamTool.h.

80{this,"gFexRhoOutputContainerWriteKey","L1_gFexRhoRoI","Write gFEX EDM gFexRho container"};

◆ m_gJ_scale

int gFexByteStreamTool::m_gJ_scale = 0
private

Definition at line 74 of file gFexByteStreamTool.h.

◆ m_gLJ_scale

int gFexByteStreamTool::m_gLJ_scale = 0
private

Definition at line 75 of file gFexByteStreamTool.h.

◆ m_gMETComponentsJwojOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexGlobalRoIContainer> gFexByteStreamTool::m_gMETComponentsJwojOOTDecorKey {this,"gMETComponentsJwojOOTDecorKey",m_gMETComponentsJwojSliceWriteKey,"sliceNumber","Slice number decoration for gMETComponentsJwoj out-of-time"}
private

Definition at line 119 of file gFexByteStreamTool.h.

119{this,"gMETComponentsJwojOOTDecorKey",m_gMETComponentsJwojSliceWriteKey,"sliceNumber","Slice number decoration for gMETComponentsJwoj out-of-time"};

◆ m_gMETComponentsJwojReadKey

SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMETComponentsJwojReadKey {this,"gMETComponentsJwojOutputContainerReadKey","L1_gMETComponentsJwoj","Read gFEX EDM total MET components (JwoJ) container"}
private

Definition at line 136 of file gFexByteStreamTool.h.

136{this,"gMETComponentsJwojOutputContainerReadKey","L1_gMETComponentsJwoj","Read gFEX EDM total MET components (JwoJ) container"};

◆ m_gMETComponentsJwojSliceWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMETComponentsJwojSliceWriteKey {this,"gMETComponentsJwojSliceContainerWriteKey","","Write gFEX EDM MET (JwoJ) out-of-time container"}
private

Definition at line 100 of file gFexByteStreamTool.h.

100{this,"gMETComponentsJwojSliceContainerWriteKey","","Write gFEX EDM MET (JwoJ) out-of-time container"};

◆ m_gMETComponentsJwojWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMETComponentsJwojWriteKey {this,"gMETComponentsJwojOutputContainerWriteKey","L1_gMETComponentsJwoj","Write gFEX EDM total MET components (JwoJ) container"}
private

Definition at line 86 of file gFexByteStreamTool.h.

86{this,"gMETComponentsJwojOutputContainerWriteKey","L1_gMETComponentsJwoj","Write gFEX EDM total MET components (JwoJ) container"};

◆ m_gMETComponentsNoiseCutOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexGlobalRoIContainer> gFexByteStreamTool::m_gMETComponentsNoiseCutOOTDecorKey {this,"gMETComponentsNoiseCutOOTDecorKey",m_gMETComponentsNoiseCutSliceWriteKey,"sliceNumber","Slice number decoration for gMETComponentsNoiseCut out-of-time"}
private

Definition at line 124 of file gFexByteStreamTool.h.

124{this,"gMETComponentsNoiseCutOOTDecorKey",m_gMETComponentsNoiseCutSliceWriteKey,"sliceNumber","Slice number decoration for gMETComponentsNoiseCut out-of-time"};

◆ m_gMETComponentsNoiseCutReadKey

SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMETComponentsNoiseCutReadKey {this,"gMETComponentsNoiseCutOutputContainerReadKey","L1_gMETComponentsNoiseCut","Read gFEX EDM total MET components (NoiseCut) container"}
private

Definition at line 139 of file gFexByteStreamTool.h.

139{this,"gMETComponentsNoiseCutOutputContainerReadKey","L1_gMETComponentsNoiseCut","Read gFEX EDM total MET components (NoiseCut) container"};

◆ m_gMETComponentsNoiseCutSliceWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMETComponentsNoiseCutSliceWriteKey {this,"gMETComponentsNoiseCutSliceContainerWriteKey","","Write gFEX EDM MET (NoiseCut) out-of-time container"}
private

Definition at line 105 of file gFexByteStreamTool.h.

105{this,"gMETComponentsNoiseCutSliceContainerWriteKey","","Write gFEX EDM MET (NoiseCut) out-of-time container"};

◆ m_gMETComponentsNoiseCutWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMETComponentsNoiseCutWriteKey {this,"gMETComponentsNoiseCutOutputContainerWriteKey","L1_gMETComponentsNoiseCut","Write gFEX EDM total MET components (NoiseCut) container"}
private

Definition at line 89 of file gFexByteStreamTool.h.

89{this,"gMETComponentsNoiseCutOutputContainerWriteKey","L1_gMETComponentsNoiseCut","Write gFEX EDM total MET components (NoiseCut) container"};

◆ m_gMETComponentsRmsOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexGlobalRoIContainer> gFexByteStreamTool::m_gMETComponentsRmsOOTDecorKey {this,"gMETComponentsRmsOOTDecorKey",m_gMETComponentsRmsSliceWriteKey,"sliceNumber","Slice number decoration for gMETComponentsRms out-of-time"}
private

Definition at line 126 of file gFexByteStreamTool.h.

126{this,"gMETComponentsRmsOOTDecorKey",m_gMETComponentsRmsSliceWriteKey,"sliceNumber","Slice number decoration for gMETComponentsRms out-of-time"};

◆ m_gMETComponentsRmsReadKey

SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMETComponentsRmsReadKey {this,"gMETComponentsRmsOutputContainerReadKey","L1_gMETComponentsRms","Read gFEX EDM total MET components (RMS) container"}
private

Definition at line 140 of file gFexByteStreamTool.h.

140{this,"gMETComponentsRmsOutputContainerReadKey","L1_gMETComponentsRms","Read gFEX EDM total MET components (RMS) container"};

◆ m_gMETComponentsRmsSliceWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMETComponentsRmsSliceWriteKey {this,"gMETComponentsRmsSliceContainerWriteKey","","Write gFEX EDM MET (Rms) out-of-time container"}
private

Definition at line 107 of file gFexByteStreamTool.h.

107{this,"gMETComponentsRmsSliceContainerWriteKey","","Write gFEX EDM MET (Rms) out-of-time container"};

◆ m_gMETComponentsRmsWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMETComponentsRmsWriteKey {this,"gMETComponentsRmsOutputContainerWriteKey","L1_gMETComponentsRms","Write gFEX EDM total MET components (RMS) container"}
private

Definition at line 90 of file gFexByteStreamTool.h.

90{this,"gMETComponentsRmsOutputContainerWriteKey","L1_gMETComponentsRms","Write gFEX EDM total MET components (RMS) container"};

◆ m_gMHTComponentsJwojOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexGlobalRoIContainer> gFexByteStreamTool::m_gMHTComponentsJwojOOTDecorKey {this,"gMHTComponentsJwojOOTDecorKey",m_gMHTComponentsJwojSliceWriteKey,"sliceNumber","Slice number decoration for gMHTComponentsJwoj out-of-time"}
private

Definition at line 120 of file gFexByteStreamTool.h.

120{this,"gMHTComponentsJwojOOTDecorKey",m_gMHTComponentsJwojSliceWriteKey,"sliceNumber","Slice number decoration for gMHTComponentsJwoj out-of-time"};

◆ m_gMHTComponentsJwojReadKey

SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMHTComponentsJwojReadKey {this,"gMHTComponentsJwojOutputContainerReadKey","L1_gMHTComponentsJwoj","Read gFEX EDM hard MET components (JwoJ) container"}
private

Definition at line 137 of file gFexByteStreamTool.h.

137{this,"gMHTComponentsJwojOutputContainerReadKey","L1_gMHTComponentsJwoj","Read gFEX EDM hard MET components (JwoJ) container"};

◆ m_gMHTComponentsJwojSliceWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMHTComponentsJwojSliceWriteKey {this,"gMHTComponentsJwojSliceContainerWriteKey","","Write gFEX EDM MHT (JwoJ) out-of-time container"}
private

Definition at line 101 of file gFexByteStreamTool.h.

101{this,"gMHTComponentsJwojSliceContainerWriteKey","","Write gFEX EDM MHT (JwoJ) out-of-time container"};

◆ m_gMHTComponentsJwojWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMHTComponentsJwojWriteKey {this,"gMHTComponentsJwojOutputContainerWriteKey","L1_gMHTComponentsJwoj","Write gFEX EDM hard MET components (JwoJ) container"}
private

Definition at line 87 of file gFexByteStreamTool.h.

87{this,"gMHTComponentsJwojOutputContainerWriteKey","L1_gMHTComponentsJwoj","Write gFEX EDM hard MET components (JwoJ) container"};

◆ m_gMSTComponentsJwojOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexGlobalRoIContainer> gFexByteStreamTool::m_gMSTComponentsJwojOOTDecorKey {this,"gMSTComponentsJwojOOTDecorKey",m_gMSTComponentsJwojSliceWriteKey,"sliceNumber","Slice number decoration for gMSTComponentsJwoj out-of-time"}
private

Definition at line 121 of file gFexByteStreamTool.h.

121{this,"gMSTComponentsJwojOOTDecorKey",m_gMSTComponentsJwojSliceWriteKey,"sliceNumber","Slice number decoration for gMSTComponentsJwoj out-of-time"};

◆ m_gMSTComponentsJwojReadKey

SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMSTComponentsJwojReadKey {this,"gMSTComponentsJwojOutputContainerReadKey","L1_gMSTComponentsJwoj","Read gFEX EDM soft MET components (JwoJ) container"}
private

Definition at line 138 of file gFexByteStreamTool.h.

138{this,"gMSTComponentsJwojOutputContainerReadKey","L1_gMSTComponentsJwoj","Read gFEX EDM soft MET components (JwoJ) container"};

◆ m_gMSTComponentsJwojSliceWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMSTComponentsJwojSliceWriteKey {this,"gMSTComponentsJwojSliceContainerWriteKey","","Write gFEX EDM MST (JwoJ) out-of-time container"}
private

Definition at line 102 of file gFexByteStreamTool.h.

102{this,"gMSTComponentsJwojSliceContainerWriteKey","","Write gFEX EDM MST (JwoJ) out-of-time container"};

◆ m_gMSTComponentsJwojWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gMSTComponentsJwojWriteKey {this,"gMSTComponentsJwojOutputContainerWriteKey","L1_gMSTComponentsJwoj","Write gFEX EDM soft MET components (JwoJ) container"}
private

Definition at line 88 of file gFexByteStreamTool.h.

88{this,"gMSTComponentsJwojOutputContainerWriteKey","L1_gMSTComponentsJwoj","Write gFEX EDM soft MET components (JwoJ) container"};

◆ m_gRistrettoOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexGlobalRoIContainer> gFexByteStreamTool::m_gRistrettoOOTDecorKey {this,"gRistrettoOOTDecorKey",m_gRistrettoSliceWriteKey,"sliceNumber","Slice number decoration for gRistretto out-of-time"}
private

Definition at line 123 of file gFexByteStreamTool.h.

123{this,"gRistrettoOOTDecorKey",m_gRistrettoSliceWriteKey,"sliceNumber","Slice number decoration for gRistretto out-of-time"};

◆ m_gRistrettoReadKey

SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gRistrettoReadKey {this,"gRistrettoOutputContainerReadKey","L1_gRistretto","Read gFEX EDM gRistretto container"}
private

Definition at line 135 of file gFexByteStreamTool.h.

135{this,"gRistrettoOutputContainerReadKey","L1_gRistretto","Read gFEX EDM gRistretto container"};

◆ m_gRistrettoSliceWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gRistrettoSliceWriteKey {this,"gRistrettoSliceContainerWriteKey","","Write gFEX EDM gRistretto out-of-time container"}
private

Definition at line 104 of file gFexByteStreamTool.h.

104{this,"gRistrettoSliceContainerWriteKey","","Write gFEX EDM gRistretto out-of-time container"};

◆ m_gRistrettoWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gRistrettoWriteKey {this,"gRistrettoOutputContainerWriteKey","L1_gRistretto","Write gFEX EDM gRistretto container"}
private

Definition at line 85 of file gFexByteStreamTool.h.

85{this,"gRistrettoOutputContainerWriteKey","L1_gRistretto","Write gFEX EDM gRistretto container"};

◆ m_gScalarEJwojOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexGlobalRoIContainer> gFexByteStreamTool::m_gScalarEJwojOOTDecorKey {this,"gScalarEJwojOOTDecorKey",m_gScalarEJwojSliceWriteKey,"sliceNumber","Slice number decoration for gScalarEJwoj out-of-time"}
private

Definition at line 118 of file gFexByteStreamTool.h.

118{this,"gScalarEJwojOOTDecorKey",m_gScalarEJwojSliceWriteKey,"sliceNumber","Slice number decoration for gScalarEJwoj out-of-time"};

◆ m_gScalarEJwojReadKey

SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gScalarEJwojReadKey {this,"gScalarEJwojOutputContainerReadKey","L1_gScalarEJwoj","Read gFEX EDM Scalar MET and SumET (JwoJ) container"}
private

Definition at line 133 of file gFexByteStreamTool.h.

133{this,"gScalarEJwojOutputContainerReadKey","L1_gScalarEJwoj","Read gFEX EDM Scalar MET and SumET (JwoJ) container"};

◆ m_gScalarEJwojSliceWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gScalarEJwojSliceWriteKey {this,"gScalarEJwojSliceContainerWriteKey","","Write gFEX EDM Scalar (JwoJ) out-of-time container"}
private

Definition at line 99 of file gFexByteStreamTool.h.

99{this,"gScalarEJwojSliceContainerWriteKey","","Write gFEX EDM Scalar (JwoJ) out-of-time container"};

◆ m_gScalarEJwojWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gScalarEJwojWriteKey {this,"gScalarEJwojOutputContainerWriteKey","L1_gScalarEJwoj","Write gFEX EDM Scalar MET and SumET (JwoJ) container"}
private

Definition at line 83 of file gFexByteStreamTool.h.

83{this,"gScalarEJwojOutputContainerWriteKey","L1_gScalarEJwoj","Write gFEX EDM Scalar MET and SumET (JwoJ) container"};

◆ m_gScalarENoiseCutOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexGlobalRoIContainer> gFexByteStreamTool::m_gScalarENoiseCutOOTDecorKey {this,"gScalarENoiseCutOOTDecorKey",m_gScalarENoiseCutSliceWriteKey,"sliceNumber","Slice number decoration for gScalarENoiseCut out-of-time"}
private

Definition at line 125 of file gFexByteStreamTool.h.

125{this,"gScalarENoiseCutOOTDecorKey",m_gScalarENoiseCutSliceWriteKey,"sliceNumber","Slice number decoration for gScalarENoiseCut out-of-time"};

◆ m_gScalarENoiseCutReadKey

SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gScalarENoiseCutReadKey {this,"gScalarENoiseCutOutputContainerReadKey","L1_gScalarENoiseCut","Read gFEX EDM Scalar MET and SumET (NoiseCut) container"}
private

Definition at line 141 of file gFexByteStreamTool.h.

141{this,"gScalarENoiseCutOutputContainerReadKey","L1_gScalarENoiseCut","Read gFEX EDM Scalar MET and SumET (NoiseCut) container"};

◆ m_gScalarENoiseCutSliceWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gScalarENoiseCutSliceWriteKey {this,"gScalarENoiseCutSliceContainerWriteKey","","Write gFEX EDM Scalar (NoiseCut) out-of-time container"}
private

Definition at line 106 of file gFexByteStreamTool.h.

106{this,"gScalarENoiseCutSliceContainerWriteKey","","Write gFEX EDM Scalar (NoiseCut) out-of-time container"};

◆ m_gScalarENoiseCutWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gScalarENoiseCutWriteKey {this,"gScalarENoiseCutOutputContainerWriteKey","L1_gScalarENoiseCut","Write gFEX EDM Scalar MET and SumET (NoiseCut) container"}
private

Definition at line 91 of file gFexByteStreamTool.h.

91{this,"gScalarENoiseCutOutputContainerWriteKey","L1_gScalarENoiseCut","Write gFEX EDM Scalar MET and SumET (NoiseCut) container"};

◆ m_gScalarERmsOOTDecorKey

SG::WriteDecorHandleKey<xAOD::gFexGlobalRoIContainer> gFexByteStreamTool::m_gScalarERmsOOTDecorKey {this,"gScalarERmsOOTDecorKey",m_gScalarERmsSliceWriteKey,"sliceNumber","Slice number decoration for gScalarERms out-of-time"}
private

Definition at line 127 of file gFexByteStreamTool.h.

127{this,"gScalarERmsOOTDecorKey",m_gScalarERmsSliceWriteKey,"sliceNumber","Slice number decoration for gScalarERms out-of-time"};

◆ m_gScalarERmsReadKey

SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gScalarERmsReadKey {this,"gScalarERmsOutputContainerReadKey","L1_gScalarERms","Read gFEX EDM Scalar MET and SumET (RMS) container"}
private

Definition at line 142 of file gFexByteStreamTool.h.

142{this,"gScalarERmsOutputContainerReadKey","L1_gScalarERms","Read gFEX EDM Scalar MET and SumET (RMS) container"};

◆ m_gScalarERmsSliceWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gScalarERmsSliceWriteKey {this,"gScalarERmsSliceContainerWriteKey","","Write gFEX EDM Scalar (Rms) out-of-time container"}
private

Definition at line 108 of file gFexByteStreamTool.h.

108{this,"gScalarERmsSliceContainerWriteKey","","Write gFEX EDM Scalar (Rms) out-of-time container"};

◆ m_gScalarERmsWriteKey

SG::WriteHandleKey< xAOD::gFexGlobalRoIContainer > gFexByteStreamTool::m_gScalarERmsWriteKey {this,"gScalarERmsOutputContainerWriteKey","L1_gScalarERms","Write gFEX EDM Scalar MET and SumET (RMS) container"}
private

Definition at line 92 of file gFexByteStreamTool.h.

92{this,"gScalarERmsOutputContainerWriteKey","L1_gScalarERms","Write gFEX EDM Scalar MET and SumET (RMS) container"};

◆ m_gTE_scale

int gFexByteStreamTool::m_gTE_scale = 0
private

Definition at line 77 of file gFexByteStreamTool.h.

◆ m_gXE_scale

int gFexByteStreamTool::m_gXE_scale = 0
private

Definition at line 76 of file gFexByteStreamTool.h.

◆ m_l1MenuKey

SG::ReadHandleKey<TrigConf::L1Menu> gFexByteStreamTool::m_l1MenuKey {this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu","Name of the L1Menu object to read configuration from"}
private

Definition at line 145 of file gFexByteStreamTool.h.

145{this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu","Name of the L1Menu object to read configuration from"};

◆ m_monTool

ToolHandle<GenericMonitoringTool> gFexByteStreamTool::m_monTool {this,"MonTool","","Monitoring tool"}
private

Definition at line 66 of file gFexByteStreamTool.h.

66{this,"MonTool","","Monitoring tool"};

◆ m_robIds

Gaudi::Property<std::vector<uint32_t> > gFexByteStreamTool::m_robIds {this, "ROBIDs", {}, "List of ROB IDs required for conversion to/from xAOD RoI"}
private

Definition at line 71 of file gFexByteStreamTool.h.

71{this, "ROBIDs", {}, "List of ROB IDs required for conversion to/from xAOD RoI"};

◆ m_saveExtendedTOBs

Gaudi::Property<bool> gFexByteStreamTool::m_saveExtendedTOBs {this, "SaveExtendedTOBs", false, "Decode and write xTOBs instead of TOBs"}
private

Definition at line 72 of file gFexByteStreamTool.h.

72{this, "SaveExtendedTOBs", false, "Decode and write xTOBs instead of TOBs"};

◆ m_UseMonitoring

bool gFexByteStreamTool::m_UseMonitoring = false
private

Definition at line 67 of file gFexByteStreamTool.h.

◆ m_WARNING

uint8_t gFexByteStreamTool::m_WARNING =1
staticconstexprprivate

Definition at line 154 of file gFexByteStreamTool.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.16.1