RpcByteStreamDecoder Class Reference

#include <RpcByteStreamDecoder.h>

Collaboration diagram for RpcByteStreamDecoder:

Public Member Functions
	RpcByteStreamDecoder (const RPCbytestream *p_bytestream, const RpcCablingCondData *readCdo, const RpcIdHelper *rpcId, MsgStream *log=nullptr)
	~RpcByteStreamDecoder ()
StatusCode	decodeByteStream ()
std::vector< RpcPad * > *	getPads ()
void	print ()

Private Member Functions
RpcPad *	decodePad (PADreadout &pad)
RpcCoinMatrix *	decodeMatrix (MatrixReadOut *matrix, Identifier &id)
RpcByteStreamDecoder &	operator= (const RpcByteStreamDecoder &right)
	RpcByteStreamDecoder (const RpcByteStreamDecoder &)

Private Attributes
const RPCbytestream *	m_bytestream
const RpcCablingCondData *	m_cabling
const RpcIdHelper *	m_rpcIdHelper
std::vector< RpcPad * > *	m_rpcpads
MsgStream *	m_log
bool	m_debug
bool	m_verbose

Detailed Description

Definition at line 24 of file RpcByteStreamDecoder.h.

Constructor & Destructor Documentation

RpcByteStreamDecoder() [1/2]

RpcByteStreamDecoder::RpcByteStreamDecoder	(	const RPCbytestream *	p_bytestream,
		const RpcCablingCondData *	readCdo,
		const RpcIdHelper *	rpcId,
		MsgStream *	log = nullptr )

Definition at line 11 of file RpcByteStreamDecoder.cxx.

                                                           :
    m_bytestream(p_bytestream), m_cabling(readCdo), m_rpcIdHelper(rpcId) {
    m_rpcpads = new std::vector<RpcPad*>;
    m_log = log;
    if (m_log) {
        m_debug = m_log->level() <= MSG::DEBUG;
        m_verbose = m_log->level() <= MSG::VERBOSE;
    } else {
        m_debug = false;
        m_verbose = false;
    }
}

~RpcByteStreamDecoder()

RpcByteStreamDecoder::~RpcByteStreamDecoder

(

)

Definition at line 25 of file RpcByteStreamDecoder.cxx.

                                            {
    if (m_rpcpads != nullptr) {
        delete m_rpcpads;
        m_rpcpads = nullptr;
    }
}

RpcByteStreamDecoder() [2/2]

RpcByteStreamDecoder::RpcByteStreamDecoder ( const RpcByteStreamDecoder & )

private

Member Function Documentation

decodeByteStream()

StatusCode RpcByteStreamDecoder::decodeByteStream

(

)

Definition at line 32 of file RpcByteStreamDecoder.cxx.

                                                  {
    if (m_debug && m_log) *m_log << MSG::DEBUG << "Start decoding" << endmsg;
 
    PAD_Readout padReadout = m_bytestream->pad_readout();
 
    // Iterate on the readout PADS and decode them
    for (PAD_Readout::iterator it = padReadout.begin(); it != padReadout.end(); ++it) {
        PADreadout pad = (*it).second;
        RpcPad* newpad = decodePad(pad);
 
        // Push back the decoded pad in the vector
        m_rpcpads->push_back(newpad);
    }
 
    if (m_debug && m_log) *m_log << MSG::DEBUG << "Number of decoded Pads : " << m_rpcpads->size() << endmsg;
 
    return StatusCode::SUCCESS;
}

decodeMatrix()

RpcCoinMatrix * RpcByteStreamDecoder::decodeMatrix ( MatrixReadOut * matrix, Identifier & id )

private

Definition at line 129 of file RpcByteStreamDecoder.cxx.

                                                                                       {
    if (m_debug && m_log) *m_log << MSG::DEBUG << "Decoding a new RpcCoinMatrix" << endmsg;
 
    // Matrix Header and SubHeader
    MatrixReadOutStructure matrix_header = matrix->getHeader();
    MatrixReadOutStructure matrix_subheader = matrix->getSubHeader();
    MatrixReadOutStructure matrix_footer = matrix->getFooter();
    // Check the data structure
    // cppcheck-suppress assertWithSideEffect
    assert(matrix_header.isHeader());
    // cppcheck-suppress assertWithSideEffect
    assert(matrix_subheader.isSubHeader());
    // cppcheck-suppress assertWithSideEffect
    assert(matrix_footer.isFooter());
 
    // Create the coincidence matrix
    RpcCoinMatrix* coinMatrix =
        new RpcCoinMatrix(id, matrix_header.cmid(), matrix_footer.crc(), matrix_header.fel1id(), matrix_subheader.febcid());
 
    // Iterate on fired channels and decode them
    MatrixReadOutStructure cm_hit;
    for (int j = 0; j < matrix->numberOfBodyWords(); ++j) {
        cm_hit = matrix->getCMAHit(j);
        // cppcheck-suppress assertWithSideEffect
        assert(cm_hit.isBody());
        RpcFiredChannel* firedChannel = nullptr;
 
        if (cm_hit.ijk() < rpcRawHitWordLength) {
            firedChannel = new RpcFiredChannel(cm_hit.bcid(), cm_hit.time(), cm_hit.ijk(), cm_hit.channel());
        } else if (cm_hit.ijk() == rpcRawHitWordLength) {
            firedChannel = new RpcFiredChannel(cm_hit.bcid(), cm_hit.time(), cm_hit.ijk(), cm_hit.threshold(), cm_hit.overlap());
        }
 
        coinMatrix->push_back(firedChannel);
    }
 
    if (m_debug && m_log) *m_log << MSG::DEBUG << "Number of Fired Channels in Matrix : " << coinMatrix->size() << endmsg;
    return coinMatrix;
}

decodePad()

RpcPad * RpcByteStreamDecoder::decodePad ( PADreadout & pad )

private

Definition at line 52 of file RpcByteStreamDecoder.cxx.

                                                       {
    if (m_debug && m_log) *m_log << MSG::DEBUG << "Decoding a new RpcPad" << endmsg;
 
    // Identifier elements
    int name = 0;
    int eta = 0;
    int phi = 0;
    int doublet_r = 0;
    int doublet_z = 0;
    int doublet_phi = 0;
    int gas_gap = 0;
    int measures_phi = 0;
    int strip = 0;
 
    PadReadOut* readout = pad.give_pad_readout();
 
    // Retrieve PAD sector and PAD ID
    int sector = pad.sector();
    int pad_id = pad.PAD();
    // Compute side and logic sector
    int side = (sector < 32) ? 0 : 1;
    int logic_sector = sector % 32;
    // Compute the key to retrieve the offline id from the map (as from LVL1 sim.)
    int key = side * 10000 + logic_sector * 100 + pad_id;
 
    if (m_debug && m_log) *m_log << MSG::DEBUG << "Pad: Side " << side << " Sector logic" << logic_sector << " Id " << pad_id << endmsg;
 
    // Retrieve the identifier elements from the map
    const RpcCablingCondData::RDOmap& pad_map = m_cabling->give_RDOs();
    RDOindex index = (*pad_map.find(key)).second;
 
    index.offline_indexes(name, eta, phi, doublet_r, doublet_z, doublet_phi, gas_gap, measures_phi, strip);
 
    // Build the pad offline identifier
    bool valid{false};
    Identifier id = m_rpcIdHelper->padID(name, eta, phi, doublet_r, doublet_z, doublet_phi, valid);
 
    if (m_log && !valid) {
        *m_log << MSG::ERROR << "Invalid pad offline indices " << endmsg;
        *m_log << MSG::ERROR << "Name : " << name << endmsg;
        *m_log << MSG::ERROR << "Eta " << eta << "   Phi " << phi << endmsg;
        *m_log << MSG::ERROR << "Doublet r " << doublet_r << "  Doublet_z " << doublet_z << "  Doublet_phi " << doublet_phi << endmsg;
        *m_log << MSG::ERROR << "Gas gap " << gas_gap << "   Measures_phi " << measures_phi << "  Strip " << strip << endmsg;
    }
 
    // Retrieve Pad status and error code from Pad header and footer
    PadReadOutStructure pad_header = readout->getHeader();
    PadReadOutStructure pad_footer = readout->getFooter();
    // Check the data format
    // cppcheck-suppress assertWithSideEffect
    assert(pad_header.isHeader());
    // cppcheck-suppress assertWithSideEffect
    assert(pad_footer.isFooter());
 
    unsigned int hashId = index.hash();
    unsigned int onlineId = pad_id;
    // unsigned int status    = pad_header.status();
    unsigned int status = 0;
    unsigned int errorCode = pad_footer.errorCode();
 
    // Construct the new Pad
    RpcPad* rpc_pad = new RpcPad(id, hashId, onlineId, status, errorCode, sector);
 
    // Iterate on the matrices and decode them
    for (int i = 0; i < readout->numberOfCMROFragments(); ++i) {
        MatrixReadOut* matrix = pad.matrices_readout(i);
        RpcCoinMatrix* coinMatrix = decodeMatrix(matrix, id);
        // Add the matrix to the pad
        rpc_pad->push_back(coinMatrix);
    }
 
    if (m_debug && m_log) *m_log << MSG::DEBUG << "Number of matrices in Pad : " << rpc_pad->size() << endmsg;
 
    return rpc_pad;
}

getPads()

std::vector< RpcPad * > * RpcByteStreamDecoder::getPads ( )

inline

Definition at line 35 of file RpcByteStreamDecoder.h.

{ return m_rpcpads; };

operator=()

RpcByteStreamDecoder & RpcByteStreamDecoder::operator= ( const RpcByteStreamDecoder & right )

private

print()

void RpcByteStreamDecoder::print

(

)

Definition at line 170 of file RpcByteStreamDecoder.cxx.

                                 {
    std::cout << "Printing out RPC RDO's : " << std::endl;
    std::cout << "Number of Pads in event : " << m_rpcpads->size() << std::endl;
    std::vector<RpcPad*>::const_iterator pad_it;
    int ipad = 1;
    // Iterate on pads
    for (pad_it = m_rpcpads->begin(); pad_it != m_rpcpads->end(); ++pad_it, ++ipad) {
        std::cout << "Pad number " << ipad << " Identifier : " << std::endl;
        (*pad_it)->identify().show();
        std::cout << std::endl;
        std::cout << "Number of Matrices in Pad : " << (*pad_it)->size() << std::endl;
        // Iterate on the pad's coincidence matrices
        RpcPad::const_iterator mat_it;
        int imat = 1;
        for (mat_it = (*pad_it)->begin(); mat_it != (*pad_it)->end(); ++mat_it, ++imat) {
            std::cout << "Matrix number " << imat << std::endl;
            std::cout << "Number of fired channels: " << (*mat_it)->size() << std::endl;
            RpcCoinMatrix::const_iterator chan_it;
            int ichan = 1;
            // Printout the fired channels
            for (chan_it = (*mat_it)->begin(); chan_it != (*mat_it)->end(); ++chan_it, ++ichan) {
                std::cout << "Fired Channel " << ichan << " :: bcid " << (*chan_it)->bcid() << "   ijk " << (*chan_it)->ijk()
                          << "   channel " << (*chan_it)->channel() << std::endl;
            }
        }
    }
}

Member Data Documentation

m_bytestream

const RPCbytestream* RpcByteStreamDecoder::m_bytestream

private

Definition at line 46 of file RpcByteStreamDecoder.h.

m_cabling

const RpcCablingCondData* RpcByteStreamDecoder::m_cabling

private

Definition at line 47 of file RpcByteStreamDecoder.h.

m_debug

bool RpcByteStreamDecoder::m_debug

private

Definition at line 52 of file RpcByteStreamDecoder.h.

m_log

MsgStream* RpcByteStreamDecoder::m_log

private

Definition at line 51 of file RpcByteStreamDecoder.h.

m_rpcIdHelper

const RpcIdHelper* RpcByteStreamDecoder::m_rpcIdHelper

private

Definition at line 48 of file RpcByteStreamDecoder.h.

m_rpcpads

std::vector<RpcPad*>* RpcByteStreamDecoder::m_rpcpads

private

Definition at line 49 of file RpcByteStreamDecoder.h.

m_verbose

bool RpcByteStreamDecoder::m_verbose

private

Definition at line 53 of file RpcByteStreamDecoder.h.

---

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

• RpcByteStreamDecoder.h
• RpcByteStreamDecoder.cxx