RPCAMCRawToDigi.cc

Go to the documentation of this file.

#include "EventFilter/RPCRawToDigi/plugins/RPCAMCRawToDigi.h"

#include <memory>

#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"

#include "DataFormats/FEDRawData/interface/FEDHeader.h"
#include "DataFormats/FEDRawData/interface/FEDTrailer.h"
#include "EventFilter/RPCRawToDigi/interface/RPCAMCLinkEvents.h"
#include "EventFilter/RPCRawToDigi/interface/RPCAMCRecord.h"
#include "EventFilter/RPCRawToDigi/plugins/RPCAMCUnpacker.h"
#include "EventFilter/RPCRawToDigi/plugins/RPCAMCUnpackerFactory.h"

RPCAMCRawToDigi::RPCAMCRawToDigi(edm::ParameterSet const & config)
    : 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()
{}

void RPCAMCRawToDigi::fillDescriptions(edm::ConfigurationDescriptions & descs)
{
    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);
}

void RPCAMCRawToDigi::beginRun(edm::Run const & run, edm::EventSetup const & setup)
{
    rpc_unpacker_->beginRun(run, setup);
}

void RPCAMCRawToDigi::produce(edm::Event & event, edm::EventSetup const & setup)
{
    // 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));
    }
}

bool RPCAMCRawToDigi::processCDFHeaders(int fed
                                        , std::uint64_t const * & word, std::uint64_t const * & word_end
                                        , std::uint16_t & crc
                                        , RPCAMCLinkCounters & counters) const
{
    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
{
    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;
}

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
{
    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;
}

#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(RPCAMCRawToDigi);