RPCAMCRawToDigi Class Reference

#include <RPCAMCRawToDigi.h>

Inheritance diagram for RPCAMCRawToDigi:

Public Member Functions
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) override
void	produce (edm::Event &event, edm::EventSetup const &setup) override
	RPCAMCRawToDigi (edm::ParameterSet const &config)
	~RPCAMCRawToDigi ()
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final

Static Public Member Functions
static void	compute_crc16_64bit (std::uint16_t &crc, std::uint64_t const &word)
static void	fillDescriptions (edm::ConfigurationDescriptions &descs)

Protected Member Functions
bool	processBlocks (int fed, std::uint64_t const *&word, std::uint64_t const *word_end, std::uint16_t &crc, RPCAMCLinkCounters &counters, std::map< RPCAMCLink, rpcamc13::AMCPayload > &amc_payload) const
bool	processCDFHeaders (int fed, std::uint64_t const *&word, std::uint64_t const *&word_end, std::uint16_t &crc, RPCAMCLinkCounters &counters) const
bool	processCDFTrailers (int fed, unsigned int nwords, std::uint64_t const *&word, std::uint64_t const *&word_end, std::uint16_t &crc, RPCAMCLinkCounters &counters) const

Protected Attributes
bool	calculate_crc_
bool	fill_counters_
edm::EDGetTokenT< FEDRawDataCollection >	raw_token_
std::unique_ptr< RPCAMCUnpacker >	rpc_unpacker_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 21 of file RPCAMCRawToDigi.h.

Constructor & Destructor Documentation

RPCAMCRawToDigi::RPCAMCRawToDigi

(

edm::ParameterSet const &

config

)

Definition at line 20 of file RPCAMCRawToDigi.cc.

References fill_counters_, edm::ParameterSet::getParameter(), and raw_token_.

    : calculate_crc_(config.getParameter<bool>("calculateCRC"))
    , fill_counters_(config.getParameter<bool>("fillCounters"))
    , rpc_unpacker_(RPCAMCUnpackerFactory::get()->create(config.getParameter<std::string>("RPCAMCUnpacker")
                                                         , *this
                                                         , config.getParameter<edm::ParameterSet>("RPCAMCUnpackerSettings")))
{
    if (fill_counters_) {
        produces<RPCAMCLinkCounters>();
    }

    raw_token_ = consumes<FEDRawDataCollection>(config.getParameter<edm::InputTag>("inputTag"));
}

RPCAMCRawToDigi::~RPCAMCRawToDigi

(

)

Definition at line 34 of file RPCAMCRawToDigi.cc.

{}

Member Function Documentation

void RPCAMCRawToDigi::beginRun ( edm::Run const &  run, edm::EventSetup const &  setup  )

override

Definition at line 48 of file RPCAMCRawToDigi.cc.

References rpc_unpacker_.

{
    rpc_unpacker_->beginRun(run, setup);
}

void RPCAMCRawToDigi::compute_crc16_64bit ( std::uint16_t &  crc, std::uint64_t const &  word  )

inlinestatic

Definition at line 58 of file RPCAMCRawToDigi.h.

References evf::compute_crc_8bit().

Referenced by processBlocks(), processCDFHeaders(), and produce().

{ // overcome constness problem evf::compute_crc_64bit
    unsigned char const * uchars(reinterpret_cast<unsigned char const *>(&word));
    for (unsigned char const * uchar = uchars + 7
             ; uchar >= uchars ; --uchar) {
        crc = evf::compute_crc_8bit(crc, *uchar);
    }
}

void RPCAMCRawToDigi::fillDescriptions ( edm::ConfigurationDescriptions &  descs )

static

Definition at line 37 of file RPCAMCRawToDigi.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), RPCAMCUnpacker::fillDescription(), and AlCaHLTBitMon_QueryRunRegistry::string.

{
    edm::ParameterSetDescription desc;
    desc.add<edm::InputTag>("inputTag", edm::InputTag("rawDataCollector", ""));
    desc.add<bool>("calculateCRC", true);
    desc.add<bool>("fillCounters", true);
    desc.add<std::string>("RPCAMCUnpacker", "RPCAMCUnpacker");
    RPCAMCUnpacker::fillDescription(desc);
    descs.add("RPCAMCRawToDigi", desc);
}

bool RPCAMCRawToDigi::processBlocks ( int  fed, std::uint64_t const *&  word, std::uint64_t const *  word_end, std::uint16_t &  crc, RPCAMCLinkCounters &  counters, std::map< RPCAMCLink, rpcamc13::AMCPayload > &  amc_payload  ) const

protected

Definition at line 208 of file RPCAMCRawToDigi.cc.

References RPCAMCLinkCounters::add(), amc, RPCAMCLinkEvents::amc_amc13_block_incomplete_, RPCAMCLinkEvents::amc_amc13_crc_mismatch_, RPCAMCLinkEvents::amc_amc13_evc_bc_invalid_, RPCAMCLinkEvents::amc_amc13_length_incorrect_, RPCAMCLinkEvents::amc_amc13_size_inconsistent_, RPCAMCLinkEvents::amc_event_, RPCAMCLinkEvents::amc_number_mismatch_, RPCAMCLinkEvents::amc_payload_incomplete_, RPCAMCLinkEvents::amc_size_mismatch_, calculate_crc_, compute_crc16_64bit(), DEFINE_FWK_MODULE, RPCAMCLinkEvents::fed_amc13_amc_number_invalid_, RPCAMCLinkEvents::fed_amc13_block_incomplete_, fill_counters_, rpcamc13::AMCPayload::getAMCHeader(), rpcamc::Header::getAMCNumber(), rpcamc13::AMCHeader::getAMCNumber(), rpcamc13::AMCPayload::getData(), rpcamc::Header::getDataLength(), rpcamc13::Header::getNAMC(), rpcamc13::AMCHeader::getSize(), rpcamc13::AMCHeader::getSizeInBlock(), rpcamc::Header::hasDataLength(), rpcamc13::AMCHeader::hasTotalSize(), RecoTauValidation_cfi::header, rpcamc13::AMCPayload::insert(), rpcamc13::AMCHeader::isCRCOk(), rpcamc13::AMCHeader::isFirstBlock(), rpcamc13::AMCHeader::isLastBlock(), rpcamc13::AMCHeader::isLengthCorrect(), rpcamc13::AMCHeader::isValid(), RPCAMCLink::max_amcnumber_, jets_cff::payload, rpcamc13::AMCPayload::setAMCHeader(), rpcamc13::AMCHeader::setCRCOk(), rpcamc13::AMCHeader::setLengthCorrect(), rpcamc13::AMCPayload::setValid(), and RPCAMCLink::wildcard_.

Referenced by produce().

{
    while (word < word_end) {
        rpcamc13::Header header(*word);
        if (calculate_crc_) {
            compute_crc16_64bit(crc, *word);
        }
        ++word;

        unsigned int n_amc(header.getNAMC());
        if (word + n_amc + 1 >= word_end) { // AMC Headers and AMC13 Trailer
            if (fill_counters_) {
                counters.add(RPCAMCLinkEvents::fed_amc13_block_incomplete_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
            }
            edm::LogWarning("RPCAMCRawToDigi") << "AMC13 Block can not be complete for FED " << fed;
            word = word_end;
            return false;
        }

        std::uint64_t const * payload_word(word + n_amc);
        std::uint64_t const * payload_word_end(payload_word);
        for (unsigned int amc = 0 ; amc < n_amc ; ++amc) {
            rpcamc13::AMCHeader amc13_amc_header(*word);
            if (calculate_crc_) {
                compute_crc16_64bit(crc, *word);
            }
            ++word;

            unsigned int size_in_block(amc13_amc_header.getSizeInBlock());
            if (size_in_block == 0) {
                continue;
            }
            payload_word = payload_word_end;
            payload_word_end += size_in_block;

            unsigned int amc_number(amc13_amc_header.getAMCNumber());
            if (amc_number > (unsigned int)RPCAMCLink::max_amcnumber_) {
                if (fill_counters_) {
                    counters.add(RPCAMCLinkEvents::fed_amc13_amc_number_invalid_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
                }
                edm::LogWarning("RPCAMCRawToDigi") << "Invalid AMC Number " << amc_number << " for FED " << fed;
                continue;
            }

            if (payload_word_end > word_end) {
                if (fill_counters_) {
                    counters.add(RPCAMCLinkEvents::amc_amc13_block_incomplete_, RPCAMCLink(fed, amc_number));
                }
                edm::LogWarning("RPCAMCRawToDigi") << "AMC Block can not be complete for FED " << fed
                                                   << " at AMC " << amc_number;
                return false;
            }

            rpcamc13::AMCPayload & payload(amc_payload[RPCAMCLink(fed, amc_number)]);

            if (amc13_amc_header.isFirstBlock()) {
                payload.setAMCHeader(amc13_amc_header);
                if (fill_counters_) {
                    counters.add(RPCAMCLinkEvents::amc_event_, RPCAMCLink(fed, amc_number));
                }

                if (!amc13_amc_header.isValid()) {
                    if (fill_counters_) {
                        counters.add(RPCAMCLinkEvents::amc_amc13_evc_bc_invalid_, RPCAMCLink(fed, amc_number));
                    }
                    edm::LogWarning("RPCAMCRawToDigi") << "AMC13 AMC Header is reporting an invalid "
                                                       << "Event Counter or Bunch Counter for FED " << fed
                                                       << ", AMC " << amc_number;
                    payload.setValid(false);
                }

                rpcamc::Header amc_amc_header(payload_word);
                if (amc_number!= amc_amc_header.getAMCNumber()) {
                    if (fill_counters_) {
                        counters.add(RPCAMCLinkEvents::amc_number_mismatch_, RPCAMCLink(fed, amc_number));
                    }
                    edm::LogWarning("RPCAMCRawToDigi") << "AMC Number inconsistent in AMC13 AMC Header vs AMC Header: " << amc_number
                                                       << " vs " << amc_amc_header.getAMCNumber();
                    payload.setValid(false);
                }

                if (amc_amc_header.hasDataLength()
                    && amc13_amc_header.hasTotalSize()
                    && amc13_amc_header.getSize() != amc_amc_header.getDataLength()) {
                    if (fill_counters_) {
                        counters.add(RPCAMCLinkEvents::amc_size_mismatch_, RPCAMCLink(fed, amc_number));
                    }
                    edm::LogWarning("RPCAMCRawToDigi") << "AMC size inconsistent in AMC13 AMC Header vs AMC Header: " << amc13_amc_header.getSize()
                                                       << " vs " << amc_amc_header.getDataLength();
                    payload.setValid(false);
                }
            }

            if (amc13_amc_header.isLastBlock()) {
                if (!amc13_amc_header.isFirstBlock()) {
                    edm::LogWarning("RPCAMCRawToDigi") << "Multiple blocks";
                }
                payload.getAMCHeader().setCRCOk(amc13_amc_header.isCRCOk());
                payload.getAMCHeader().setLengthCorrect(amc13_amc_header.isLengthCorrect());

                if (!amc13_amc_header.isCRCOk()) {
                    if (fill_counters_) {
                        counters.add(RPCAMCLinkEvents::amc_amc13_crc_mismatch_, RPCAMCLink(fed, amc_number));
                    }
                    edm::LogWarning("RPCAMCRawToDigi") << "AMC13 AMC Header is reporting a mismatched  "
                                                       << "Event Counter or Bunch Counter for FED " << fed
                                                       << ", AMC " << amc_number;
                    payload.setValid(false);
                }

                if (!amc13_amc_header.isLengthCorrect()) {
                    if (fill_counters_) {
                        counters.add(RPCAMCLinkEvents::amc_amc13_length_incorrect_, RPCAMCLink(fed, amc_number));
                    }
                    edm::LogWarning("RPCAMCRawToDigi") << "AMC13 AMC Header is reporting an incorrect length "
                                                       << "for FED " << fed << ", AMC " << amc_number;
                    payload.setValid(false);
                }

                if (amc13_amc_header.hasTotalSize()
                    && amc13_amc_header.getSize() != (payload.getData().size() + size_in_block)) {
                    if (fill_counters_) {
                        counters.add(RPCAMCLinkEvents::amc_amc13_size_inconsistent_, RPCAMCLink(fed, amc_number));
                    }
                    edm::LogWarning("RPCAMCRawToDigi") << "Size in AMC13 AMC Header doesn't match payload size "
                                                       << "for FED " << fed << ", AMC " << amc_number;
                    payload.setValid(false);
                }

                if (!payload.getData().empty() && (payload.getData().size() + size_in_block) < 3) {
                    if (fill_counters_) {
                        counters.add(RPCAMCLinkEvents::amc_payload_incomplete_, RPCAMCLink(fed, amc_number));
                    }
                    edm::LogWarning("RPCAMCRawToDigi") << "Size in AMC13 AMC Header doesn't match payload size "
                                                       << "for FED " << fed << ", AMC " << amc_number;
                    payload.setValid(false);
                }
            }

            if (size_in_block > 0) {
                payload.insert(payload_word, size_in_block);
            }
        }

        if (calculate_crc_) {
            for ( ; word < payload_word_end ; ++word) {
                compute_crc16_64bit(crc, *word);
            }
        } else {
            word = payload_word_end;
        }

        if (calculate_crc_) {
            compute_crc16_64bit(crc, *word);
        }
        ++word;
    }
    return true;
}

bool RPCAMCRawToDigi::processCDFHeaders ( int  fed, std::uint64_t const *&  word, std::uint64_t const *&  word_end, std::uint16_t &  crc, RPCAMCLinkCounters &  counters  ) const

protected

Definition at line 132 of file RPCAMCRawToDigi.cc.

References RPCAMCLinkCounters::add(), calculate_crc_, FEDHeader::check(), compute_crc16_64bit(), TauDecayModes::dec, RPCAMCLinkEvents::fed_header_check_fail_, RPCAMCLinkEvents::fed_header_id_mismatch_, fill_counters_, RecoTauValidation_cfi::header, LogDebug, FEDHeader::sourceID(), and RPCAMCLink::wildcard_.

Referenced by produce().

{
    bool more_headers(true);
    for ( ; word < word_end && more_headers ; ++word) {
        if (calculate_crc_) {
            compute_crc16_64bit(crc, *word);
        }

        LogDebug("RPCAMCRawToDigi") << "CDF Header " << std::hex << *word << std::dec;
        FEDHeader header(reinterpret_cast<unsigned char const *>(word));
        if (!header.check()) {
            if (fill_counters_) {
                counters.add(RPCAMCLinkEvents::fed_header_check_fail_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
            }
            edm::LogWarning("RPCAMCRawToDigi") << "FED Header check failed for FED id " << fed;
            ++word;
            return false;
        }
        if (header.sourceID() != fed) {
            if (fill_counters_) {
                counters.add(RPCAMCLinkEvents::fed_header_id_mismatch_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
            }
            edm::LogWarning("RPCAMCRawToDigi") << "FED Header Source ID " << header.sourceID()
                                               << " does not match requested FED id " << fed;
            ++word;
            return false;
        }

        // moreHeaders() not used
        // more_headers = header.moreHeaders();
        more_headers = false;
    }

    return !more_headers;
}

bool RPCAMCRawToDigi::processCDFTrailers ( int  fed, unsigned int  nwords, std::uint64_t const *&  word, std::uint64_t const *&  word_end, std::uint16_t &  crc, RPCAMCLinkCounters &  counters  ) const

protected

Definition at line 171 of file RPCAMCRawToDigi.cc.

References RPCAMCLinkCounters::add(), FEDTrailer::check(), TauDecayModes::dec, RPCAMCLinkEvents::fed_trailer_check_fail_, RPCAMCLinkEvents::fed_trailer_length_mismatch_, fill_counters_, FEDTrailer::fragmentLength(), LogDebug, and RPCAMCLink::wildcard_.

Referenced by produce().

{
    bool more_trailers(true);
    for (--word_end ; word_end > word && more_trailers ; --word_end) {
        FEDTrailer trailer(reinterpret_cast<unsigned char const *>(word_end));
        LogDebug("RPCAMCRawToDigi") << "CDF Trailer " << std::hex << *word_end << std::dec
                                    << ", length " << trailer.fragmentLength();
        if (!trailer.check()) {
            if (fill_counters_) {
                counters.add(RPCAMCLinkEvents::fed_trailer_check_fail_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
            }
            edm::LogWarning("RPCAMCRawToDigi") << "FED Trailer check failed for FED id " << fed;
            return false;
        }
        if (trailer.fragmentLength() != nwords) {
            if (fill_counters_) {
                counters.add(RPCAMCLinkEvents::fed_trailer_length_mismatch_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
            }
            edm::LogWarning("RPCAMCRawToDigi") << "FED Trailer length " << trailer.fragmentLength()
                                               << " does not match actual data size " << nwords
                                               << " for FED id " << fed;
            return false;
        }

        // moreTrailers() not used
        // more_trailers = trailer.moreTrailers();
        more_trailers = false;
    }

    ++word_end;

    return !more_trailers;
}

void RPCAMCRawToDigi::produce ( edm::Event &  event, edm::EventSetup const &  setup  )

override

Definition at line 53 of file RPCAMCRawToDigi.cc.

References calculate_crc_, compute_crc16_64bit(), FEDTrailer::crc(), FEDRawData::data(), RPCAMCLinkEvents::fed_event_, RPCAMCLinkEvents::fed_trailer_crc_mismatch_, FEDRawDataCollection::FEDData(), fill_counters_, LogDebug, eostools::move(), processBlocks(), processCDFHeaders(), processCDFTrailers(), raw_token_, rpc_unpacker_, FEDRawData::size(), and RPCAMCLink::wildcard_.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

{
    // Get RAW Data
    edm::Handle<FEDRawDataCollection> raw_data_collection;
    event.getByToken(raw_token_, raw_data_collection);

    std::unique_ptr<RPCAMCLinkCounters> counters(new RPCAMCLinkCounters());

    std::map<RPCAMCLink, rpcamc13::AMCPayload> amc_payload;

    // Loop over the FEDs
    for (int fed : rpc_unpacker_->getFeds()) {

        if (fill_counters_) {
            counters->add(RPCAMCLinkEvents::fed_event_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
        }

        std::uint16_t crc(0xffff);

        FEDRawData const & raw_data = raw_data_collection->FEDData(fed);
        unsigned int nwords(raw_data.size() / sizeof(std::uint64_t));
        if (!nwords) {
            continue;
        }

        std::uint64_t const * word(reinterpret_cast<std::uint64_t const *>(raw_data.data()));
        std::uint64_t const * word_end = word + nwords;

        LogDebug("RPCAMCRawToDigi") << "Handling FED " << fed << " with length " << nwords;

        // Handle the CDF Headers
        if (!processCDFHeaders(fed
                               , word, word_end
                               , crc, *counters)) {
            continue;
        }

        // Handle the CDF Trailers
        if (!processCDFTrailers(fed, nwords
                                , word, word_end
                                , crc, *counters)) {
            continue;
        }

        // Loop over the Blocks
        if (!processBlocks(fed
                           , word, word_end
                           , crc, *counters, amc_payload)) {
            continue;
        }

        // Complete CRC check with trailer
        if (calculate_crc_) {
            word = word_end;
            word_end = reinterpret_cast<std::uint64_t const *>(raw_data.data()) + nwords - 1;
            for ( ; word < word_end ; ++word) {
                compute_crc16_64bit(crc, *word);
            }
            compute_crc16_64bit(crc, (*word & 0xffffffff0000ffff)); // trailer excluding crc
            FEDTrailer trailer(reinterpret_cast<unsigned char const *>(word_end));
            if ((unsigned int)(trailer.crc()) != crc) {
                if (fill_counters_) {
                    counters->add(RPCAMCLinkEvents::fed_trailer_crc_mismatch_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
                }
                edm::LogWarning("RPCAMCRawToDigi") << "FED Trailer CRC doesn't match for FED id " << fed;
                continue;
            }
        }

    }

    rpc_unpacker_->produce(event, setup
                           , amc_payload);

    if (fill_counters_) {
        event.put(std::move(counters));
    }
}

Member Data Documentation

bool RPCAMCRawToDigi::calculate_crc_

protected

Definition at line 53 of file RPCAMCRawToDigi.h.

Referenced by processBlocks(), processCDFHeaders(), and produce().

bool RPCAMCRawToDigi::fill_counters_

protected

Definition at line 53 of file RPCAMCRawToDigi.h.

Referenced by processBlocks(), processCDFHeaders(), processCDFTrailers(), produce(), and RPCAMCRawToDigi().

edm::EDGetTokenT<FEDRawDataCollection> RPCAMCRawToDigi::raw_token_

protected

Definition at line 51 of file RPCAMCRawToDigi.h.

Referenced by produce(), and RPCAMCRawToDigi().

std::unique_ptr<RPCAMCUnpacker> RPCAMCRawToDigi::rpc_unpacker_

protected

Definition at line 55 of file RPCAMCRawToDigi.h.

Referenced by beginRun(), and produce().