#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::vector< uint32_t > &tob, const int type, SG::WriteHandle< xAOD::gFexGlobalRoIContainer > &container, 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_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::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_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 39 of file gFexByteStreamTool.h.

Constructor & Destructor Documentation

◆ gFexByteStreamTool()

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

Definition at line 24 of file gFexByteStreamTool.cxx.

27 : 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 165 of file gFexByteStreamTool.cxx.

                                                                                                               {
        
    //WriteHandle for gFEX EDMs
    
    //---Rho Container
    SG::WriteHandle<xAOD::gFexJetRoIContainer> gRhoContainer(m_gFexRhoWriteKey, ctx);
    ATH_CHECK(gRhoContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetRoIContainer with key " << gRhoContainer.key());
    
    //---Small Jets Container
    SG::WriteHandle<xAOD::gFexJetRoIContainer> gSJContainer(m_gFexBlockWriteKey, ctx);
    ATH_CHECK(gSJContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetRoIContainer with key " << gSJContainer.key());
 
    //---Large Jets Container
    SG::WriteHandle<xAOD::gFexJetRoIContainer> gLJContainer(m_gFexJetWriteKey, ctx);
    ATH_CHECK(gLJContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetRoIContainer with key " << gLJContainer.key());
 
    //---Scalar MET and SumET JwoJ Container
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarEJwojContainer(m_gScalarEJwojWriteKey, ctx);
    ATH_CHECK(gScalarEJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gScalarEJwojContainer.key());
 
    //---gEspresso Container
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gEspressoContainer(m_gEspressoWriteKey, ctx);
    ATH_CHECK(gEspressoContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gEspressoContainer.key());
 
    //---MET Components JwoJ Container
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsJwojContainer(m_gMETComponentsJwojWriteKey, ctx);
    ATH_CHECK(gMETComponentsJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMETComponentsJwojContainer.key());
 
    //---MHT Components JwoJ Container
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMHTComponentsJwojContainer(m_gMHTComponentsJwojWriteKey, ctx);
    ATH_CHECK(gMHTComponentsJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMHTComponentsJwojContainer.key());
 
    //---MST Components JwoJ Container
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMSTComponentsJwojContainer(m_gMSTComponentsJwojWriteKey, ctx);
    ATH_CHECK(gMSTComponentsJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMSTComponentsJwojContainer.key());
 
    //---MET Components NoiseCut Container
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsNoiseCutContainer(m_gMETComponentsNoiseCutWriteKey, ctx);
    ATH_CHECK(gMETComponentsNoiseCutContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMETComponentsNoiseCutContainer.key());
 
    //---MET Components Rms Container
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsRmsContainer(m_gMETComponentsRmsWriteKey, ctx);
    ATH_CHECK(gMETComponentsRmsContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMETComponentsRmsContainer.key());
 
    //---Scalar MET and SumET NoiseCut Container
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarENoiseCutContainer(m_gScalarENoiseCutWriteKey, ctx);
    ATH_CHECK(gScalarENoiseCutContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gScalarENoiseCutContainer.key());
 
    //---Scalar MET and SumET Rms Container
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarERmsContainer(m_gScalarERmsWriteKey, ctx);
    ATH_CHECK(gScalarERmsContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gScalarERmsContainer.key());
 
 
    // Iterate over ROBFragments to decode
    for (const ROBF* rob : vrobf) {
        // Iterate over ROD words and decode
        
        
        ATH_MSG_DEBUG("Starting to decode " << rob->rod_ndata() << " ROD words from ROB 0x" << std::hex << rob->rob_source_id());
        
        //There is no data to decode.. not even the ROD trailers
        if(rob->rod_ndata() <= 0){
            continue;
        }
        
        const auto dataArray = std::span{rob->rod_data(), rob->rod_ndata()};
 
        
        // Starting to loop over the gFEX words
 
        unsigned int n_words = rob->rod_ndata();
 
        //saving Jet TOBs into the EDM container
        for(unsigned int iWord=0; iWord<n_words; iWord++) {
            ATH_MSG_DEBUG("Raw word  0x" << std::hex << dataArray[iWord]  << "    " << std::bitset<32> (dataArray[iWord]));
        }
        
        // Vectors to temporarily store global tob before their are summed together
        int global_counter = 0;
        std::vector<uint32_t> JWOJ_MHT(3, 0);
        std::vector<uint32_t> JWOJ_MST(3, 0);
        std::vector<uint32_t> JWOJ_MET(3, 0);
        std::vector<uint32_t> JWOJ_SCALAR(3, 0);
        std::vector<uint32_t> GESPRESSO(3, 0);
        std::vector<uint32_t> NC_MET(3, 0);
        std::vector<uint32_t> NC_SCALAR(3, 0);
        std::vector<uint32_t> RMS_MET(3, 0);
        std::vector<uint32_t> RMS_SCALAR(3, 0);
 
        size_t index = 0;
        while ( index < n_words ) {
            const uint32_t headerWord = dataArray[index];//Identify the header words. The first is a header word.
            const uint32_t blockType  = (headerWord >> gPos::BLOCK_TYPE_BIT)  &    gPos::BLOCK_TYPE_MASK;
            const uint32_t headerSize = (headerWord >> gPos::HEADER_SIZE_BIT) &    gPos::HEADER_SIZE_MASK;
            const uint32_t errorFlags = (headerWord >> gPos::ERROR_FLAG_BIT)  &    gPos::ERROR_FLAG_MASK;
            const uint32_t dataSize   =  headerWord        &  gPos::DATA_SIZE_MASK;
      
            ATH_MSG_DEBUG( "index        "<< index );
            ATH_MSG_DEBUG( "word         "<< std::bitset<32> (dataArray[index]) );
            ATH_MSG_DEBUG( "headerWord   "<< std::bitset<32> (headerWord) );
            ATH_MSG_DEBUG( "blockType    "<< std::bitset<4> (blockType) );
            ATH_MSG_DEBUG( "headerSize   "<< std::bitset<2> (headerSize) );
            ATH_MSG_DEBUG( "errorFlags   "<< std::bitset<1> (errorFlags) );
            ATH_MSG_DEBUG( "dataSize     "<< std::bitset<12> (dataSize) );
            
            const uint32_t blockSize  = headerSize + dataSize;
            if ( (index + blockSize) > n_words ) {
                
                std::stringstream sdetail;
                sdetail  << "Remaining block size " << (n_words - index) << " is too small for subblock of type " << blockType << " with headerSize " << headerSize << " and dataSize " << dataSize ;
                std::stringstream slocation;
                slocation  << "0x"<< std::hex << rob->rob_source_id() << std::dec << " type:"<<blockType;
                std::stringstream stitle;
                stitle  << "Small subblock size " ;
                printError(slocation.str(),stitle.str(),MSG::DEBUG,sdetail.str());  
                
            }
 
            index += headerSize;
      
            const uint32_t numSlices = dataSize / gPos::WORDS_PER_SLICE;
            ATH_MSG_DEBUG( "numSlices   "  <<  numSlices );
 
            if ( numSlices * gPos::WORDS_PER_SLICE != dataSize ) {
 
                std::stringstream sdetail;
                sdetail  << "L1CaloBsDecoderRun3::decodeGfexTobs: subblock type " << blockType << " with dataSize " << dataSize << " is not a multiple of " << gPos::WORDS_PER_SLICE << " words" ;
                std::stringstream slocation;
                slocation  << "0x"<< std::hex << rob->rob_source_id()<< std::dec << " type:"<<blockType;
                std::stringstream stitle;
                stitle  << "Wrong dataSize" ;
                printError(slocation.str(),stitle.str(),MSG::DEBUG,sdetail.str());   
                     
                //skip decode of this fragment
                index+=dataSize;
                continue;
                
            }
 
            // The subblock type is 0xA,B,C for jet TOBs from FPGA A,B,C
            // and 0x1,2,3 for global (MET) TOBs.
            bool isMet = (blockType >= 0x1 && blockType <= 0x3);
            bool isJet = (blockType >= 0xA && blockType <= 0xC);
 
            
            for (uint32_t sliceNumber = 0; sliceNumber < numSlices; sliceNumber++) {
                if (sliceNumber == 0){
                    if ( !isJet && !isMet ) {
                        
                        std::stringstream sdetail;
                        sdetail  << "gFexByteStreamTool::decodeGfexTobSlice: Invalid block type " << blockType ;
                        std::stringstream slocation;
                        slocation  << "0x"<< std::hex << rob->rob_source_id();
                        std::stringstream stitle;
                        stitle  << "Invalid block type" ;
                        printError(slocation.str(),stitle.str(),MSG::DEBUG,sdetail.str());                         
                        
                    }
 
                    for(unsigned int iWord=0; iWord<gPos::WORDS_PER_SLICE; iWord++) {
 
                        if (isJet) {
                            //Skipping the unused words
                            if (std::find(gPos::JET_UNUSED_POSITION.begin(),gPos::JET_UNUSED_POSITION.end(),iWord)!=gPos::JET_UNUSED_POSITION.end()){
                                continue;
                            }
                            //Skipping the trailer words
                            if (std::find(gPos::TRAILER_POSITION.begin(),gPos::TRAILER_POSITION.end(),iWord)!=gPos::TRAILER_POSITION.end()){
                                continue;
                            }
                            //Saving gRho TOBs into the EDM container
                            if (iWord == gPos::GRHO_POSITION){
                                std::unique_ptr<xAOD::gFexJetRoI> myEDM (new xAOD::gFexJetRoI());
                                gRhoContainer->push_back(std::move(myEDM));
                                gRhoContainer->back()->initialize(dataArray[index+iWord], m_gJ_scale);
                            }
                            //Saving gBlock TOBs into the EDM container
                            if (std::find(gPos::GBLOCK_POSITION.begin(),gPos::GBLOCK_POSITION.end(),iWord)!=gPos::GBLOCK_POSITION.end()){
                                std::unique_ptr<xAOD::gFexJetRoI> myEDM (new xAOD::gFexJetRoI());
                                gSJContainer->push_back(std::move(myEDM));
                                gSJContainer->back()->initialize(dataArray[index+iWord], m_gJ_scale);
                            }
                            //Saving gJet TOBs into the EDM container
                            if (std::find(gPos::GJET_POSITION.begin(),gPos::GJET_POSITION.end(),iWord)!=gPos::GJET_POSITION.end()){
                                std::unique_ptr<xAOD::gFexJetRoI> myEDM (new xAOD::gFexJetRoI());
                                gLJContainer->push_back(std::move(myEDM));
                                gLJContainer->back()->initialize(dataArray[index+iWord], m_gLJ_scale);
                            }
 
                        }
 
                        if (isMet){
                            //Skipping the unused words
                            if (std::find(gPos::GLOBAL_UNUSED_POSITION.begin(),gPos::GLOBAL_UNUSED_POSITION.end(),iWord)!=gPos::GLOBAL_UNUSED_POSITION.end()){
                                continue;
                            }
                            //Skipping the trailer words
                            if (std::find(gPos::TRAILER_POSITION.begin(),gPos::TRAILER_POSITION.end(),iWord)!=gPos::TRAILER_POSITION.end()){
                                continue;
                            }
                            //Saving jwoj MHT TOBs into the EDM container
                            if (iWord == gPos::JWOJ_MHT_POSITION){
                                global_counter ++;
                                if (blockType == 0x1) {JWOJ_MHT[0] = dataArray[index+iWord];}
                                if (blockType == 0x2) {JWOJ_MHT[1] = dataArray[index+iWord];}
                                if (blockType == 0x3) {JWOJ_MHT[2] = dataArray[index+iWord];}
                            }
                            //Saving jwoj MST TOBs into the EDM container
                            if (iWord == gPos::JWOJ_MST_POSITION){
                                if (blockType == 0x1) {JWOJ_MST[0] = dataArray[index+iWord];}
                                if (blockType == 0x2) {JWOJ_MST[1] = dataArray[index+iWord];}
                                if (blockType == 0x3) {JWOJ_MST[2] = dataArray[index+iWord];}
                            }
                            //Saving jwoj MET TOBs into the EDM container
                            if (iWord == gPos::JWOJ_MET_POSITION){
                                if (blockType == 0x1) {JWOJ_MET[0] = dataArray[index+iWord];}
                                if (blockType == 0x2) {JWOJ_MET[1] = dataArray[index+iWord];}
                                if (blockType == 0x3) {JWOJ_MET[2] = dataArray[index+iWord];}
                            }
                            //Saving jwoj Scalar TOBs into the EDM container
                            if (iWord == gPos::JWOJ_SCALAR_POSITION){
                                if (blockType == 0x1) {JWOJ_SCALAR[0] = dataArray[index+iWord];}
                                if (blockType == 0x2) {JWOJ_SCALAR[1] = dataArray[index+iWord];}
                                if (blockType == 0x3) {JWOJ_SCALAR[2] = dataArray[index+iWord];}
                            }
                            //Saving gEspresso TOBs into the EDM container
                            if (iWord == gPos::GESPRESSO_POSITION){
                                if (blockType == 0x1) {GESPRESSO[0] = dataArray[index+iWord];}
                                if (blockType == 0x2) {GESPRESSO[1] = dataArray[index+iWord];}
                                if (blockType == 0x3) {GESPRESSO[2] = dataArray[index+iWord];}
                            }
                            //Saving Noise Cut MET TOBs into the EDM container
                            if (iWord == gPos::NC_MET_POSITION){
                                if (blockType == 0x1) {NC_MET[0] = dataArray[index+iWord];}
                                if (blockType == 0x2) {NC_MET[1] = dataArray[index+iWord];}
                                if (blockType == 0x3) {NC_MET[2] = dataArray[index+iWord];}
                            }
                            //Saving Noise Cut Scalar TOBs into the EDM container
                            if (iWord == gPos::NC_SCALAR_POSITION){
                                if (blockType == 0x1) {NC_SCALAR[0] = dataArray[index+iWord];}
                                if (blockType == 0x2) {NC_SCALAR[1] = dataArray[index+iWord];}
                                if (blockType == 0x3) {NC_SCALAR[2] = dataArray[index+iWord];}
                            }
                            //Saving Rho+RMS MET TOBs into the EDM container
                            if (iWord == gPos::RMS_MET_POSITION){
                                if (blockType == 0x1) {RMS_MET[0] = dataArray[index+iWord];}
                                if (blockType == 0x2) {RMS_MET[1] = dataArray[index+iWord];}
                                if (blockType == 0x3) {RMS_MET[2] = dataArray[index+iWord];}
                            }
                            //Saving Rho+RMS Scalar TOBs into the EDM container
                            if (iWord == gPos::RMS_SCALAR_POSITION){
                                if (blockType == 0x1) {RMS_SCALAR[0] = dataArray[index+iWord];}
                                if (blockType == 0x2) {RMS_SCALAR[1] = dataArray[index+iWord];}
                                if (blockType == 0x3) {RMS_SCALAR[2] = dataArray[index+iWord];}
                            }
 
                        }
 
                    }
 
                }
                index += gPos::WORDS_PER_SLICE;
            }
 
            ATH_MSG_DEBUG("global_counter is " << global_counter);
            if (global_counter == 3) {
 
                fillGlobal(JWOJ_MHT, 3, gMHTComponentsJwojContainer);
                fillGlobal(JWOJ_MST, 4, gMSTComponentsJwojContainer);
                int16_t scalar = fillGlobal(JWOJ_MET, 2, gMETComponentsJwojContainer);
                fillGlobal(JWOJ_SCALAR, 1, gScalarEJwojContainer, scalar);
 
                fillGlobal(GESPRESSO, 1, gEspressoContainer, 0);
                                
                scalar = fillGlobal(NC_MET, 2, gMETComponentsNoiseCutContainer);
                fillGlobal(NC_SCALAR, 1, gScalarENoiseCutContainer, scalar);
 
                scalar = fillGlobal(RMS_MET, 2, gMETComponentsRmsContainer);
                fillGlobal(RMS_SCALAR, 1, gScalarERmsContainer, scalar);
 
                global_counter = 0;
            }
            
        }
    }
    return StatusCode::SUCCESS;
} 

◆ convertToBS()

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

overridevirtual

xAOD->BS conversion

Definition at line 545 of file gFexByteStreamTool.cxx.

                                                                                      {
 
    return StatusCode::SUCCESS;
    
}

◆ decodeGfexTobSlice()

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

private

◆ fillGlobal()

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

private

Definition at line 469 of file gFexByteStreamTool.cxx.

                                                              {
    
    ATH_MSG_DEBUG("fillGlobal with type " << type);
    
    // 32 bit integers to avoid interim overflows when summing 16b (signed) 
    // quantities from each pFPGA. Proper clamping and bit masking follows afterwards
    int32_t sum_x = 0;
    int32_t sum_y = 0;
 
    // Extract the x and y components and sum them for the three FPGAs
    for (size_t fpga = 0; fpga < 3; fpga++) {
        int16_t x = tob[fpga] >> gPos::GLOBAL_X_BIT & gPos::GLOBAL_X_MASK;
        int16_t y = tob[fpga] >> gPos::GLOBAL_Y_BIT & gPos::GLOBAL_Y_MASK;
        if (x & 0x00080000) { x  = 0xFFFF0000 | x;  }
        if (y & 0x00080000) { y  = 0xFFFF0000 | y;  }
        sum_x += x;
        if (container.key() == "L1_gScalarEJwoj" && y < 0) y = 0;
        sum_y += y;
    }
 
    // Special case for gEspresso: in the readout the gEspresso quantity is stored in x. We need to move it to y to armonize this with the other scalar quantities
    // 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).
    if  (container.key() == "L1_gEspresso" ) {
        sum_y = sum_x; 
    }
 
    if (type == 1) {//we are considering the scalar case (sum_x = MET and sum_y = SumEt) 
        ATH_MSG_DEBUG("  scalar tob, saving " << scalar << " in X component");
        sum_x = scalar; //Total MET
        if( sum_y > 0x000FFF) sum_y = 0x000FFF; //Overflow control for SumEt
        if( sum_y < 0) sum_y = 0;
 
    } else {
        if (sum_x < -0x000800) sum_x = -0x000800; //-2048
        if (sum_x > 0x0007FF) sum_x  = 0x0007FF; //2047
 
        if (sum_y < -0x000800) sum_y = -0x000800; //-2048
        if (sum_y > 0x0007FF) sum_y  = 0x0007FF; //2047
    }
 
    ATH_MSG_DEBUG("  fillGlobal type " << type << std::dec << " sum_x " << sum_x << " sum_y " << sum_y);
 
    uint32_t METword = 0;
 
    METword = (sum_y &  0x00000FFF) << 0; //set the Quantity2 to the corresponding slot (LSB)
    METword = METword | (sum_x  &  0x00000FFF) << 12;//Quantity 1 (in bit number 12)
    if (sum_y != 0) METword = METword | 0x00000001 << 24;//Status bit for Quantity 2 (0 if quantity is null)
    if (sum_x != 0) METword = METword | 0x00000001 << 25;//Status bit for Quantity 1 (0 if quantity is null)
    METword = METword | (type  &  0x0000001F) << 26;//TOB ID (5 bits starting at 26)
 
    // Save to the EDM
    std::unique_ptr<xAOD::gFexGlobalRoI> myEDM (new xAOD::gFexGlobalRoI());
    container->push_back(std::move(myEDM));
    container->back()->setWord(METword);
    container->back()->setQuantityOne(sum_x);
    container->back()->setQuantityTwo(sum_y);
    container->back()->setScaleOne(m_gXE_scale);
    container->back()->setScaleTwo(m_gTE_scale);
    container->back()->setStatusOne(1);
    container->back()->setStatusTwo(1);
    container->back()->setSaturated(0);
    container->back()->setGlobalType(type);
    
 
    int MET2 = sum_x * sum_x + sum_y * sum_y;
    int16_t MET = std::sqrt(MET2);
    if (MET > 0x000FFF) MET = 0x000FFF;
 
    return MET;
 
}

◆ initialize()

StatusCode gFexByteStreamTool::initialize ( )

overridevirtual

Definition at line 29 of file gFexByteStreamTool.cxx.

                                          {
    // Conversion mode for gRho TOBs
    ATH_MSG_DEBUG(" ROB IDs: " << MSG::hex << m_robIds.value() << MSG::dec);
 
    ConversionMode gRhomode = getConversionMode(m_gFexRhoReadKey, m_gFexRhoWriteKey, msg());
    ATH_CHECK(gRhomode!=ConversionMode::Undefined);
    ATH_CHECK(m_gFexRhoWriteKey.initialize(gRhomode==ConversionMode::Decoding));
    ATH_CHECK(m_gFexRhoReadKey.initialize(gRhomode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gRhomode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gRho ");
 
    // Conversion mode for gSJ TOBs
    ConversionMode gSJmode = getConversionMode(m_gFexBlockReadKey, m_gFexBlockWriteKey, msg());
    ATH_CHECK(gSJmode!=ConversionMode::Undefined);
    ATH_CHECK(m_gFexBlockWriteKey.initialize(gSJmode==ConversionMode::Decoding));
    ATH_CHECK(m_gFexBlockReadKey.initialize(gSJmode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gSJmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gSJ ");
 
    // Conversion mode for gLJ TOBs
    ConversionMode gLJmode = getConversionMode(m_gFexJetReadKey, m_gFexJetWriteKey, msg());
    ATH_CHECK(gLJmode!=ConversionMode::Undefined);
    ATH_CHECK(m_gFexJetWriteKey.initialize(gLJmode==ConversionMode::Decoding));
    ATH_CHECK(m_gFexJetReadKey.initialize(gLJmode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gLJmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gLJ ");
 
    // Conversion mode for gScalarEJwoj TOBs
    ConversionMode gScalarEJwojmode = getConversionMode(m_gScalarEJwojReadKey, m_gScalarEJwojWriteKey, msg());
    ATH_CHECK(gScalarEJwojmode!=ConversionMode::Undefined);
    ATH_CHECK(m_gScalarEJwojWriteKey.initialize(gScalarEJwojmode==ConversionMode::Decoding));
    ATH_CHECK(m_gScalarEJwojReadKey.initialize(gScalarEJwojmode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gScalarEJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gScalarEJwoj ");
 
    // Conversion mode for gEspresso TOBs
    ConversionMode gEspressomode = getConversionMode(m_gEspressoReadKey, m_gEspressoWriteKey, msg());
    ATH_CHECK(gEspressomode!=ConversionMode::Undefined);
    ATH_CHECK(m_gEspressoWriteKey.initialize(gEspressomode==ConversionMode::Decoding));
    ATH_CHECK(m_gEspressoReadKey.initialize(gEspressomode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gEspressomode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gEspresso ");
 
    // Conversion mode for gMETComponentsJwoj TOBs
    ConversionMode gMETComponentsJwojmode = getConversionMode(m_gMETComponentsJwojReadKey, m_gMETComponentsJwojWriteKey, msg());
    ATH_CHECK(gMETComponentsJwojmode!=ConversionMode::Undefined);
    ATH_CHECK(m_gMETComponentsJwojWriteKey.initialize(gMETComponentsJwojmode==ConversionMode::Decoding));
    ATH_CHECK(m_gMETComponentsJwojReadKey.initialize(gMETComponentsJwojmode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gMETComponentsJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMETComponentsJwoj ");
 
    // Conversion mode for gMHTComponentsJwoj TOBs
    ConversionMode gMHTComponentsJwojmode = getConversionMode(m_gMHTComponentsJwojReadKey, m_gMHTComponentsJwojWriteKey, msg());
    ATH_CHECK(gMHTComponentsJwojmode!=ConversionMode::Undefined);
    ATH_CHECK(m_gMHTComponentsJwojWriteKey.initialize(gMHTComponentsJwojmode==ConversionMode::Decoding));
    ATH_CHECK(m_gMHTComponentsJwojReadKey.initialize(gMHTComponentsJwojmode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gMHTComponentsJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMHTComponentsJwoj ");
 
   // Conversion mode for gMSTComponentsJwoj TOBs
    ConversionMode gMSTComponentsJwojmode = getConversionMode(m_gMSTComponentsJwojReadKey, m_gMSTComponentsJwojWriteKey, msg());
    ATH_CHECK(gMSTComponentsJwojmode!=ConversionMode::Undefined);
    ATH_CHECK(m_gMSTComponentsJwojWriteKey.initialize(gMSTComponentsJwojmode==ConversionMode::Decoding));
    ATH_CHECK(m_gMSTComponentsJwojReadKey.initialize(gMSTComponentsJwojmode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gMSTComponentsJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMSTComponentsJwoj ");
 
    // Conversion mode for gMETComponentsNoiseCut TOBs
    ConversionMode gMETComponentsNoiseCutmode = getConversionMode(m_gMETComponentsNoiseCutReadKey, m_gMETComponentsNoiseCutWriteKey, msg());
    ATH_CHECK(gMETComponentsNoiseCutmode!=ConversionMode::Undefined);
    ATH_CHECK(m_gMETComponentsNoiseCutWriteKey.initialize(gMETComponentsNoiseCutmode==ConversionMode::Decoding));
    ATH_CHECK(m_gMETComponentsNoiseCutReadKey.initialize(gMETComponentsNoiseCutmode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gMETComponentsNoiseCutmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMETComponentsNoiseCut ");
 
    // Conversion mode for gMETRms TOBs
    ConversionMode gMETComponentsRmsmode = getConversionMode(m_gMETComponentsRmsReadKey, m_gMETComponentsRmsWriteKey, msg());
    ATH_CHECK(gMETComponentsRmsmode!=ConversionMode::Undefined);
    ATH_CHECK(m_gMETComponentsRmsWriteKey.initialize(gMETComponentsRmsmode==ConversionMode::Decoding));
    ATH_CHECK(m_gMETComponentsRmsReadKey.initialize(gMETComponentsRmsmode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gMETComponentsRmsmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMETComponentsRms ");
 
    // Conversion mode for gScalarENoiseCut TOBs
    ConversionMode gScalarENoiseCutmode = getConversionMode(m_gScalarENoiseCutReadKey, m_gScalarENoiseCutWriteKey, msg());
    ATH_CHECK(gScalarENoiseCutmode!=ConversionMode::Undefined);
    ATH_CHECK(m_gScalarENoiseCutWriteKey.initialize(gScalarENoiseCutmode==ConversionMode::Decoding));
    ATH_CHECK(m_gScalarENoiseCutReadKey.initialize(gScalarENoiseCutmode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gScalarENoiseCutmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gScalarENoiseCut ");
 
    // Conversion mode for gScalarERms TOBs
    ConversionMode gScalarERmsmode = getConversionMode(m_gScalarERmsReadKey, m_gScalarERmsWriteKey, msg());
    ATH_CHECK(gScalarERmsmode!=ConversionMode::Undefined);
    ATH_CHECK(m_gScalarERmsWriteKey.initialize(gScalarERmsmode==ConversionMode::Decoding));
    ATH_CHECK(m_gScalarERmsReadKey.initialize(gScalarERmsmode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gScalarERmsmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gScalarERms ");
 
    //checking all Conversion modes.. avoid misconfigurations
    const std::array<ConversionMode,2> modes{gSJmode,gLJmode};
    if (std::any_of(modes.begin(),modes.end(),[&gRhomode](ConversionMode m) { return m!=gRhomode;  } )) {
        ATH_MSG_ERROR("Inconsistent conversion modes");
        return StatusCode::FAILURE;
    }
    
    ATH_CHECK(m_l1MenuKey.initialize());
    
    if (!m_monTool.empty()) {
        ATH_CHECK(m_monTool.retrieve());
        ATH_MSG_INFO("Logging errors to " << m_monTool.name() << " monitoring tool");
        m_UseMonitoring = true;
    }
    
    
    return StatusCode::SUCCESS;
}

◆ printError()

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

private

Definition at line 552 of file gFexByteStreamTool.cxx.

                                                                                                                                   {
    
    if(m_UseMonitoring){
        Monitored::Group(m_monTool,
                     Monitored::Scalar("gfexDecoderErrorLocation",location.empty() ? std::string("UNKNOWN") : location),
                     Monitored::Scalar("gfexDecoderErrorTitle"   ,title.empty()    ? std::string("UNKNOWN") : title)
                     );
    }
    else {
        msg() << type << detail << endmsg;
    }
}

◆ robIds()

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

inlineoverridevirtual

Declare ROB IDs for conversion.

Definition at line 56 of file gFexByteStreamTool.h.

                                                                   {
            return m_robIds.value();
        }

◆ start()

StatusCode gFexByteStreamTool::start ( )

overridevirtual

Definition at line 135 of file gFexByteStreamTool.cxx.

                                     {
    // Retrieve the L1 menu configuration
    SG::ReadHandle<TrigConf::L1Menu> l1Menu (m_l1MenuKey);
    ATH_CHECK(l1Menu.isValid());
 
    try {
        const auto & l1Menu_gJ = l1Menu->thrExtraInfo().gJ();
        const auto & l1Menu_gLJ = l1Menu->thrExtraInfo().gLJ();
        const auto & l1Menu_gXE = l1Menu->thrExtraInfo().gXE();
        const auto & l1Menu_gTE = l1Menu->thrExtraInfo().gTE();
 
        ATH_CHECK(l1Menu_gJ.isValid());
        ATH_CHECK(l1Menu_gLJ.isValid());
        ATH_CHECK(l1Menu_gXE.isValid());
        ATH_CHECK(l1Menu_gTE.isValid());
 
        m_gJ_scale = l1Menu_gJ.resolutionMeV(); 
        m_gLJ_scale = l1Menu_gLJ.resolutionMeV(); 
        m_gXE_scale = l1Menu_gXE.resolutionMeV(); 
        m_gTE_scale = l1Menu_gTE.resolutionMeV();
    } catch (const std::exception& e) {
        ATH_MSG_ERROR("Exception reading L1Menu: " << e.what());
        return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
 
}

Member Data Documentation

◆ m_DEBUG

uint8_t gFexByteStreamTool::m_DEBUG =0

staticconstexprprivate

Definition at line 113 of file gFexByteStreamTool.h.

◆ m_ERROR

uint8_t gFexByteStreamTool::m_ERROR =2

staticconstexprprivate

Definition at line 115 of file gFexByteStreamTool.h.

◆ m_FATAL

uint8_t gFexByteStreamTool::m_FATAL =3

staticconstexprprivate

Definition at line 116 of file gFexByteStreamTool.h.

◆ m_gEspressoReadKey

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

private

Definition at line 95 of file gFexByteStreamTool.h.

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

◆ m_gEspressoWriteKey

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

private

Definition at line 80 of file gFexByteStreamTool.h.

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

◆ m_gFexBlockReadKey

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

private

Definition at line 92 of file gFexByteStreamTool.h.

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

◆ m_gFexBlockWriteKey

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

private

Definition at line 77 of file gFexByteStreamTool.h.

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

◆ m_gFexJetReadKey

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

private

Definition at line 93 of file gFexByteStreamTool.h.

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

◆ m_gFexJetWriteKey

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

private

Definition at line 78 of file gFexByteStreamTool.h.

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

◆ m_gFexRhoReadKey

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

private

Definition at line 91 of file gFexByteStreamTool.h.

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

◆ m_gFexRhoWriteKey

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

private

Definition at line 76 of file gFexByteStreamTool.h.

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

◆ m_gJ_scale

int gFexByteStreamTool::m_gJ_scale = 0

private

Definition at line 70 of file gFexByteStreamTool.h.

◆ m_gLJ_scale

int gFexByteStreamTool::m_gLJ_scale = 0

private

Definition at line 71 of file gFexByteStreamTool.h.

◆ 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 96 of file gFexByteStreamTool.h.

96{this,"gMETComponentsJwojOutputContainerReadKey","L1_gMETComponentsJwoj","Read gFEX EDM total MET components (JwoJ) 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 81 of file gFexByteStreamTool.h.

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

◆ 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 99 of file gFexByteStreamTool.h.

99{this,"gMETComponentsNoiseCutOutputContainerReadKey","L1_gMETComponentsNoiseCut","Read gFEX EDM total MET components (NoiseCut) 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 84 of file gFexByteStreamTool.h.

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

◆ 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 100 of file gFexByteStreamTool.h.

100{this,"gMETComponentsRmsOutputContainerReadKey","L1_gMETComponentsRms","Read gFEX EDM total MET components (RMS) 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 85 of file gFexByteStreamTool.h.

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

◆ 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 97 of file gFexByteStreamTool.h.

97{this,"gMHTComponentsJwojOutputContainerReadKey","L1_gMHTComponentsJwoj","Read gFEX EDM hard MET components (JwoJ) 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 82 of file gFexByteStreamTool.h.

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

◆ 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 98 of file gFexByteStreamTool.h.

98{this,"gMSTComponentsJwojOutputContainerReadKey","L1_gMSTComponentsJwoj","Read gFEX EDM soft MET components (JwoJ) 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 83 of file gFexByteStreamTool.h.

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

◆ 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 94 of file gFexByteStreamTool.h.

94{this,"gScalarEJwojOutputContainerReadKey","L1_gScalarEJwoj","Read gFEX EDM Scalar MET and SumET (JwoJ) 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 79 of file gFexByteStreamTool.h.

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

◆ 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 101 of file gFexByteStreamTool.h.

101{this,"gScalarENoiseCutOutputContainerReadKey","L1_gScalarENoiseCut","Read gFEX EDM Scalar MET and SumET (NoiseCut) 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 86 of file gFexByteStreamTool.h.

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

◆ 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 102 of file gFexByteStreamTool.h.

102{this,"gScalarERmsOutputContainerReadKey","L1_gScalarERms","Read gFEX EDM Scalar MET and SumET (RMS) 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 87 of file gFexByteStreamTool.h.

87{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 73 of file gFexByteStreamTool.h.

◆ m_gXE_scale

int gFexByteStreamTool::m_gXE_scale = 0

private

Definition at line 72 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 105 of file gFexByteStreamTool.h.

105{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 62 of file gFexByteStreamTool.h.

62{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 67 of file gFexByteStreamTool.h.

67{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 68 of file gFexByteStreamTool.h.

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

◆ m_UseMonitoring

bool gFexByteStreamTool::m_UseMonitoring = false

private

Definition at line 63 of file gFexByteStreamTool.h.

◆ m_WARNING

uint8_t gFexByteStreamTool::m_WARNING =1

staticconstexprprivate

Definition at line 114 of file gFexByteStreamTool.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ gFexByteStreamTool()

◆ ~gFexByteStreamTool()

Member Function Documentation

◆ convertFromBS()

◆ convertToBS()

◆ decodeGfexTobSlice()

◆ fillGlobal()

◆ initialize()

◆ printError()

◆ robIds()

◆ start()

Member Data Documentation

◆ m_DEBUG

◆ m_ERROR

◆ m_FATAL

◆ m_gEspressoReadKey

◆ m_gEspressoWriteKey

◆ m_gFexBlockReadKey

◆ m_gFexBlockWriteKey

◆ m_gFexJetReadKey

◆ m_gFexJetWriteKey

◆ m_gFexRhoReadKey

◆ m_gFexRhoWriteKey

◆ m_gJ_scale

◆ m_gLJ_scale

◆ m_gMETComponentsJwojReadKey

◆ m_gMETComponentsJwojWriteKey

◆ m_gMETComponentsNoiseCutReadKey

◆ m_gMETComponentsNoiseCutWriteKey

◆ m_gMETComponentsRmsReadKey

◆ m_gMETComponentsRmsWriteKey

◆ m_gMHTComponentsJwojReadKey

◆ m_gMHTComponentsJwojWriteKey

◆ m_gMSTComponentsJwojReadKey

◆ m_gMSTComponentsJwojWriteKey

◆ m_gScalarEJwojReadKey

◆ m_gScalarEJwojWriteKey

◆ m_gScalarENoiseCutReadKey

◆ m_gScalarENoiseCutWriteKey

◆ m_gScalarERmsReadKey

◆ m_gScalarERmsWriteKey

◆ m_gTE_scale

◆ m_gXE_scale

◆ m_l1MenuKey

◆ m_monTool

◆ m_robIds

◆ m_saveExtendedTOBs

◆ m_UseMonitoring

◆ m_WARNING