RPCTwinMuxRawToDigi Class Reference

#include <RPCTwinMuxRawToDigi.h>

Inheritance diagram for RPCTwinMuxRawToDigi:

Public Member Functions
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) override
void	produce (edm::Event &event, edm::EventSetup const &setup) override
	RPCTwinMuxRawToDigi (edm::ParameterSet const &config)
	~RPCTwinMuxRawToDigi ()
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDProducerBase ()
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const
	ProducerBase ()
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)
virtual	~ProducerBase () noexcept(false)
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	compute_crc_64bit (std::uint16_t &crc, std::uint64_t const &word)
static void	fillDescriptions (edm::ConfigurationDescriptions &descs)
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions
bool	processBlock (int fed, std::uint64_t const *&word, std::uint64_t const *word_end, std::uint16_t &crc, RPCAMCLinkCounters &counters, std::set< std::pair< RPCDetId, RPCDigi > > &digis) 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
void	processRPCRecord (int fed, unsigned int amc_number, unsigned int bx_counter, rpctwinmux::RPCRecord const &record, RPCAMCLinkCounters &counters, std::set< std::pair< RPCDetId, RPCDigi > > &digis, int bx_min, int bx_max, unsigned int link, unsigned int link_max) const
bool	processTwinMux (int fed, unsigned int amc_number, unsigned int size, std::uint64_t const *&word, std::uint64_t const *word_end, std::uint16_t &crc, RPCAMCLinkCounters &counters, std::set< std::pair< RPCDetId, RPCDigi > > &digis) const
void	putCounters (edm::Event &event, std::unique_ptr< RPCAMCLinkCounters > counters)
void	putRPCDigis (edm::Event &event, std::set< std::pair< RPCDetId, RPCDigi > > const &digis)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Protected Attributes
int	bx_max_
int	bx_min_
bool	calculate_crc_
edm::ESHandle< RPCLBLinkMap >	es_lb_link_map_
edm::ESHandle< RPCAMCLinkMap >	es_tm_link_map_
edm::ESWatcher< RPCTwinMuxLinkMapRcd >	es_tm_link_map_watcher_
std::vector< int >	feds_
bool	fill_counters_
edm::EDGetTokenT< FEDRawDataCollection >	raw_token_

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
Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Detailed Description

Definition at line 30 of file RPCTwinMuxRawToDigi.h.

Constructor & Destructor Documentation

RPCTwinMuxRawToDigi::RPCTwinMuxRawToDigi

(

edm::ParameterSet const &

config

)

Definition at line 23 of file RPCTwinMuxRawToDigi.cc.

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

    : calculate_crc_(config.getParameter<bool>("calculateCRC"))
    , fill_counters_(config.getParameter<bool>("fillCounters"))
    , bx_min_(config.getParameter<int>("bxMin"))
    , bx_max_(config.getParameter<int>("bxMax"))
{
    produces<RPCDigiCollection>();
    if (fill_counters_) {
        produces<RPCAMCLinkCounters>();
    }
    raw_token_ = consumes<FEDRawDataCollection>(config.getParameter<edm::InputTag>("inputTag"));
}

RPCTwinMuxRawToDigi::~RPCTwinMuxRawToDigi

(

)

Definition at line 36 of file RPCTwinMuxRawToDigi.cc.

{}

Member Function Documentation

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

overridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 59 of file RPCTwinMuxRawToDigi.cc.

References edm::ESWatcher< T >::check(), es_tm_link_map_, es_tm_link_map_watcher_, feds_, edm::EventSetup::get(), and RPCAMCLinkMap::getMap().

{
    if (es_tm_link_map_watcher_.check(setup)) {
        setup.get<RPCTwinMuxLinkMapRcd>().get(es_tm_link_map_);
        std::set<int> feds;
        for (auto const & tm_link : es_tm_link_map_->getMap()) {
            feds.insert(tm_link.first.getFED());
        }
        feds_.assign(feds.begin(), feds.end());
    }
}

void RPCTwinMuxRawToDigi::compute_crc_64bit ( std::uint16_t &  crc, std::uint64_t const &  word  )

static

Definition at line 39 of file RPCTwinMuxRawToDigi.cc.

References evf::compute_crc_8bit().

Referenced by processBlock(), processCDFHeaders(), processTwinMux(), 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 RPCTwinMuxRawToDigi::fillDescriptions ( edm::ConfigurationDescriptions &  descs )

static

Definition at line 48 of file RPCTwinMuxRawToDigi.cc.

References edm::ConfigurationDescriptions::add(), and edm::ParameterSetDescription::add().

{
    edm::ParameterSetDescription desc;
    desc.add<edm::InputTag>("inputTag", edm::InputTag("rawDataCollector", ""));
    desc.add<bool>("calculateCRC", true);
    desc.add<bool>("fillCounters", true);
    desc.add<int>("bxMin", -2);
    desc.add<int>("bxMax", 2);
    descs.add("RPCTwinMuxRawToDigi", desc);
}

bool RPCTwinMuxRawToDigi::processBlock ( int  fed, std::uint64_t const *&  word, std::uint64_t const *  word_end, std::uint16_t &  crc, RPCAMCLinkCounters &  counters, std::set< std::pair< RPCDetId, RPCDigi > > &  digis  ) const

protected

Definition at line 226 of file RPCTwinMuxRawToDigi.cc.

References RPCAMCLinkCounters::add(), amc, RPCAMCLinkCounters::amc_evc_bc_invalid_, calculate_crc_, compute_crc_64bit(), RPCAMCLinkCounters::fed_block_length_invalid_, fill_counters_, rpctwinmux::BlockAMCContent::getAMCNumber(), rpctwinmux::BlockHeader::getNAMC(), rpctwinmux::BlockAMCContent::getSize(), rpctwinmux::BlockAMCContent::isValid(), LogDebug, processTwinMux(), and RPCAMCLink::wildcard_.

Referenced by produce().

{
    // Block Header and Content
    rpctwinmux::BlockHeader block_header(*word);
    if (calculate_crc_) {
        compute_crc_64bit(crc, *word);
    }
    ++word;

    unsigned int n_amc(block_header.getNAMC());
    if (word + n_amc + 1 >= word_end) {
        if (fill_counters_) {
            counters.add(RPCAMCLinkCounters::fed_block_length_invalid_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
        }
        edm::LogWarning("RPCTwinMuxRawToDigi") << "Block can not be complete for FED " << fed;
        word = word_end;
        return false;
    }

    std::vector<std::pair<unsigned int, unsigned int> > amc_size_map;
    for (unsigned int amc = 0 ; amc < n_amc ; ++amc) {
        LogDebug("RPCTwinMuxRawToDigi") << "Block AMC " << amc;
        rpctwinmux::BlockAMCContent amc_content(*word);
        if (calculate_crc_) {
            compute_crc_64bit(crc, *word);
        }
        ++word;

        amc_size_map.push_back(std::make_pair(amc_content.getAMCNumber(), amc_content.getSize()));
        if (!amc_content.isValid()) {
            if (fill_counters_) {
                counters.add(RPCAMCLinkCounters::amc_evc_bc_invalid_, RPCAMCLink(fed, amc_content.getAMCNumber()));
            }
            edm::LogWarning("RPCTwinMuxRawToDigi") << "BlockAMCContent is reporting an invalid "
                                                   << "Event Counter or Bunch Counter for FED " << fed
                                                   << ", AMC " << amc_content.getAMCNumber();
        }
    }

    for (std::pair<unsigned int, unsigned int> const & amc_size : amc_size_map) {
        processTwinMux(fed, amc_size.first, amc_size.second
                       , word, word_end
                       , crc, counters
                       , digis);
    }

    if (word < word_end) {
        rpctwinmux::BlockTrailer block_trailer(*word);
        if (calculate_crc_) {
            compute_crc_64bit(crc, *word);
        }
        ++word;
        return true;
    } else {
        return false;
    }
}

bool RPCTwinMuxRawToDigi::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 149 of file RPCTwinMuxRawToDigi.cc.

References RPCAMCLinkCounters::add(), calculate_crc_, FEDHeader::check(), compute_crc_64bit(), TauDecayModes::dec, RPCAMCLinkCounters::fed_header_check_fail_, RPCAMCLinkCounters::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_crc_64bit(crc, *word);
        }

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

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

    return !more_headers;
}

bool RPCTwinMuxRawToDigi::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 187 of file RPCTwinMuxRawToDigi.cc.

References RPCAMCLinkCounters::add(), FEDTrailer::check(), TauDecayModes::dec, RPCAMCLinkCounters::fed_trailer_check_fail_, RPCAMCLinkCounters::fed_trailer_length_mismatch_, fill_counters_, createfilelist::int, FEDTrailer::lenght(), 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("RPCTwinMuxRawToDigi") << "CDF Trailer " << std::hex << *word_end << std::dec
                                        << ", length " << trailer.lenght();
        if (!trailer.check()) {
            if (fill_counters_) {
                counters.add(RPCAMCLinkCounters::fed_trailer_check_fail_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
            }
            edm::LogWarning("RPCTwinMuxRawToDigi") << "FED Trailer check failed for FED id " << fed;
            --word_end;
            break;
        }
        if (trailer.lenght() != (int)nwords) {
            if (fill_counters_) {
                counters.add(RPCAMCLinkCounters::fed_trailer_length_mismatch_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
            }
            edm::LogWarning("RPCTwinMuxRawToDigi") << "FED Trailer length " << trailer.lenght()
                                                   << " does not match actual data size " << nwords
                                                   << " for FED id " << fed;
            --word_end;
            break;
        }

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

    ++word_end;

    return !more_trailers;
}

void RPCTwinMuxRawToDigi::processRPCRecord ( int  fed, unsigned int  amc_number, unsigned int  bx_counter, rpctwinmux::RPCRecord const &  record, RPCAMCLinkCounters &  counters, std::set< std::pair< RPCDetId, RPCDigi > > &  digis, int  bx_min, int  bx_max, unsigned int  link, unsigned int  link_max  ) const

protected

Definition at line 399 of file RPCTwinMuxRawToDigi.cc.

References RPCAMCLinkCounters::add(), RPCAMCLinkCounters::amc_data_, RPCAMCLinkCounters::amc_link_invalid_, data, TauDecayModes::dec, es_lb_link_map_, es_tm_link_map_, fill_counters_, rpctwinmux::RPCRecord::getBXOffset(), RPCLBLinkMap::getMap(), RPCAMCLinkMap::getMap(), rpctwinmux::RPCRecord::getRecord(), RPCFebConnector::getRPCDetId(), rpctwinmux::RPCRecord::getRPCLinkRecord(), RPCFebConnector::getStrip(), RPCAMCLinkCounters::input_connector_invalid_, RPCAMCLinkCounters::input_connector_not_used_, RPCAMCLinkCounters::input_data_, RPCAMCLinkCounters::input_eod_, RPCAMCLinkCounters::input_lb_invalid_, RPCAMCLinkCounters::input_link_ack_fail_, RPCAMCLinkCounters::input_link_error_, createfilelist::int, LogDebug, RPCLBLink::max_connector_, RPCLBLink::max_linkboard_, RPCLBLink::setConnector(), RPCLBLink::setLinkBoard(), and digi_MixPreMix_cfi::strip.

Referenced by processTwinMux().

{
    LogDebug("RPCTwinMuxRawToDigi") << "RPCRecord " << std::hex << record.getRecord()[0]
                                    << ", " << record.getRecord()[1] << std::dec << std::endl;
    int bx_offset(record.getBXOffset());
    RPCAMCLink tm_link(fed, amc_number);
    for ( ; link <= link_max ; ++link) {
        tm_link.setAMCInput(link);
        rpctwinmux::RPCLinkRecord link_record(record.getRPCLinkRecord(link));

        if (link_record.isError()) {
            if (fill_counters_ && bx_offset == 0) {
                counters.add(RPCAMCLinkCounters::input_link_error_, tm_link);
            }
            LogDebug("RPCTwinMuxRawToDigi") << "Link in error for " << tm_link;
            continue;
        } else if (!link_record.isAcknowledge()) {
            if (fill_counters_ && bx_offset == 0) {
                counters.add(RPCAMCLinkCounters::input_link_ack_fail_, tm_link);
            }
            LogDebug("RPCTwinMuxRawToDigi") << "Link without acknowledge for " << tm_link;
            continue;
        }

        if (!link_record.getPartitionData()) {
            continue;
        }

        int bx(bx_offset - (int)(link_record.getDelay()));
        LogDebug("RPCTwinMuxRawToDigi") << "RPC BX " << bx << " for offset " << bx_offset;

        if (fill_counters_ && bx == 0 && link_record.isEOD()) { // EOD comes at the last delay
            counters.add(RPCAMCLinkCounters::input_eod_, tm_link);
        }

        RPCAMCLinkMap::map_type::const_iterator tm_link_it = es_tm_link_map_->getMap().find(tm_link);
        if (tm_link_it == es_tm_link_map_->getMap().end()) {
            if (fill_counters_ && bx_offset == 0) {
                counters.add(RPCAMCLinkCounters::amc_link_invalid_, RPCAMCLink(fed, amc_number));
            }
            LogDebug("RPCTwinMuxRawToDigi") << "Skipping unknown TwinMuxLink " << tm_link;
            continue;
        }

        RPCLBLink lb_link = tm_link_it->second;

        if (link_record.getLinkBoard() > (unsigned int)RPCLBLink::max_linkboard_) {
            if (fill_counters_ && bx_offset == 0) {
                counters.add(RPCAMCLinkCounters::input_lb_invalid_, tm_link);
            }
            LogDebug("RPCTwinMuxRawToDigi") << "Skipping invalid LinkBoard " << link_record.getLinkBoard()
                                            << " for record " << link << " (" << std::hex << link_record.getRecord()
                                            << " in " << record.getRecord()[0] << ':' << record.getRecord()[1] << std::dec
                                            << " from " << tm_link;
            continue;
        }

        if (link_record.getConnector() > (unsigned int)RPCLBLink::max_connector_) {
            if (fill_counters_ && bx_offset == 0) {
                counters.add(RPCAMCLinkCounters::input_connector_invalid_, tm_link);
            }
            LogDebug("RPCTwinMuxRawToDigi") << "Skipping invalid Connector " << link_record.getConnector()
                                            << " for record " << link << " (" << std::hex << link_record.getRecord()
                                            << " in " << record.getRecord()[0] << ':' << record.getRecord()[1] << std::dec
                                            << ") from " << tm_link;
            continue;
        }

        lb_link.setLinkBoard(link_record.getLinkBoard());
        lb_link.setConnector(link_record.getConnector());

        RPCLBLinkMap::map_type::const_iterator lb_link_it = es_lb_link_map_->getMap().find(lb_link);
        if (lb_link_it == es_lb_link_map_->getMap().end()) {
            if (fill_counters_ && bx_offset == 0) {
                counters.add(RPCAMCLinkCounters::input_connector_not_used_, tm_link);
            }
            LogDebug("RPCTwinMuxRawToDigi") << "Could not find " << lb_link
                                            << " for record " << link << " (" << std::hex << link_record.getRecord()
                                            << " in " << record.getRecord()[0] << ':' << record.getRecord()[1] << std::dec
                                            << ") from " << tm_link;
            continue;
        }

        if (bx < bx_min || bx > bx_max) {
            continue;
        }

        if (fill_counters_ && bx == 0) {
            counters.add(RPCAMCLinkCounters::amc_data_, RPCAMCLink(fed, amc_number));
            counters.add(RPCAMCLinkCounters::input_data_, tm_link);
        }

        RPCFebConnector const & feb_connector(lb_link_it->second);
        RPCDetId det_id(feb_connector.getRPCDetId());
        unsigned int channel_offset(link_record.getPartition() ? 9 : 1); // 1-16
        std::uint8_t data(link_record.getPartitionData());

        for (unsigned int channel = 0 ; channel < 8 ; ++channel) {
            if (data & (0x1 << channel)) {
                unsigned int strip(feb_connector.getStrip(channel + channel_offset));
                if (strip) {
                    digis.insert(std::pair<RPCDetId, RPCDigi>(det_id, RPCDigi(strip, bx)));
                    LogDebug("RPCTwinMuxRawToDigi") << "RPCDigi " << det_id.rawId()
                                                    << ", " << strip << ", " << bx;
                }
            }
        }

        // rpctwinmux::RPCBXRecord checks postponed: not implemented in firmware as planned and tbd if design or firmware should change

    }
}

bool RPCTwinMuxRawToDigi::processTwinMux ( int  fed, unsigned int  amc_number, unsigned int  size, std::uint64_t const *&  word, std::uint64_t const *  word_end, std::uint16_t &  crc, RPCAMCLinkCounters &  counters, std::set< std::pair< RPCDetId, RPCDigi > > &  digis  ) const

protected

Definition at line 288 of file RPCTwinMuxRawToDigi.cc.

References RPCAMCLinkCounters::add(), RPCAMCLinkCounters::amc_number_mismatch_, RPCAMCLinkCounters::amc_payload_length_invalid_, bx_max_, bx_min_, calculate_crc_, compute_crc_64bit(), TauDecayModes::dec, RPCAMCLinkCounters::fed_block_amc_number_invalid_, fill_counters_, rpctwinmux::TwinMuxHeader::getAMCNumber(), rpctwinmux::TwinMuxHeader::getBXCounter(), rpctwinmux::TwinMuxHeader::getRPCBXMax(), rpctwinmux::TwinMuxHeader::getRPCBXMin(), rpctwinmux::TwinMuxRecord::getType(), rpctwinmux::TwinMuxHeader::hasRPCBXWindow(), RecoTauValidation_cfi::header, LogDebug, hpstanc_transforms::max, RPCAMCLink::max_amcnumber_, min(), processRPCRecord(), rpctwinmux::RPCRecord::reset(), rpctwinmux::TwinMuxRecord::rpc_first_type_, rpctwinmux::TwinMuxRecord::rpc_second_type_, rpctwinmux::RPCRecord::set(), findQualityFiles::size, and RPCAMCLink::wildcard_.

Referenced by processBlock().

{
    LogDebug("RPCTwinMuxRawToDigi") << "TwinMux AMC#" << amc_number << ", size " << size;
    if (!size) {
        return true;
    }
    if (amc_number > (unsigned int)RPCAMCLink::max_amcnumber_) {
        if (fill_counters_) {
            counters.add(RPCAMCLinkCounters::fed_block_amc_number_invalid_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
        }
        edm::LogWarning("RPCTwinMuxRawToDigi") << "Invalid AMC Number " << amc_number
                                               << " for FED " << fed;
        if (calculate_crc_) {
            for ( ; size > 0 ; --size, ++word) {
                compute_crc_64bit(crc, *word);
            }
        } else {
            word += size;
        }
        return false;
    }
    if (word + size >= word_end || size < 3) {
        if (fill_counters_) {
            counters.add(RPCAMCLinkCounters::amc_payload_length_invalid_, RPCAMCLink(fed, amc_number));
        }
        edm::LogWarning("RPCTwinMuxRawToDigi") << "TwinMux Data can not be complete for FED " << fed << " AMC #" << amc_number;
        if (calculate_crc_) {
            for ( ; size > 0 ; --size, ++word) {
                compute_crc_64bit(crc, *word);
            }
        } else {
            word += size;
        }
        return false;
    }

    rpctwinmux::TwinMuxHeader header(word);
    unsigned int bx_counter(header.getBXCounter());
    if (calculate_crc_) {
        compute_crc_64bit(crc, *word); ++word;
        compute_crc_64bit(crc, *word); ++word;
    } else {
        word += 2;
    }
    size -= 2;

    if (amc_number != header.getAMCNumber()) {
        if (fill_counters_) {
            counters.add(RPCAMCLinkCounters::amc_number_mismatch_, RPCAMCLink(fed, amc_number));
        }
        edm::LogWarning("RPCTwinMuxRawToDigi") << "AMC Number inconsistent in TwinMuxHeader vs BlockAMCContent: " << header.getAMCNumber()
                                               << " vs " << amc_number;
        if (calculate_crc_) {
            for ( ; size > 0 ; --size, ++word) {
                compute_crc_64bit(crc, *word);
            }
        } else {
            word += size;
        }
        return false;
    }

    int bx_min(bx_min_), bx_max(bx_max_);
    if (header.hasRPCBXWindow()) {
        bx_min = std::max(bx_min, header.getRPCBXMin());
        bx_max = std::min(bx_max, header.getRPCBXMax());
        LogDebug("RPCTwinMuxRawToDigi") << "BX range set to " << bx_min << ", " << bx_max;
    }

    bool has_first_rpc_word(false);
    rpctwinmux::RPCRecord rpc_record;
    for ( ; size > 1 ; --size, ++word) {
        if (calculate_crc_) {
            compute_crc_64bit(crc, *word);
        }
        unsigned int type(rpctwinmux::TwinMuxRecord::getType(*word));
        LogDebug("RPCTwinMuxRawToDigi") << "TwinMux data type " << std::hex << type << std::dec;
        if (type == rpctwinmux::TwinMuxRecord::rpc_first_type_) {
            if (has_first_rpc_word) {
                processRPCRecord(fed, amc_number, bx_counter, rpc_record, counters, digis, bx_min, bx_max, 0, 1);
            }
            rpc_record.reset();
            rpc_record.set(0, *word);
            has_first_rpc_word = true;
        } else if (type == rpctwinmux::TwinMuxRecord::rpc_second_type_) {
            if (!has_first_rpc_word) {
                edm::LogWarning("RPCTwinMuxRawToDigi") << "Received second RPC word without first";
            } else {
                rpc_record.set(1, *word);
                processRPCRecord(fed, amc_number, bx_counter, rpc_record, counters, digis, bx_min, bx_max, 0, 4);
                has_first_rpc_word = false;
            }
        }
    }
    if (has_first_rpc_word) {
        processRPCRecord(fed, amc_number, bx_counter, rpc_record, counters, digis, bx_min, bx_max, 0, 1);
    }

    rpctwinmux::TwinMuxTrailer trailer(*word);
    LogDebug("RPCTwinMuxRawToDigi") << "TwinMux Trailer " << std::hex << *word << std::dec;
    if (calculate_crc_) {
        compute_crc_64bit(crc, *word);
    }
    ++word;
    return true;
}

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

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 71 of file RPCTwinMuxRawToDigi.cc.

References calculate_crc_, compute_crc_64bit(), FEDTrailer::crc(), FEDRawData::data(), es_lb_link_map_, es_tm_link_map_, RPCAMCLinkCounters::fed_event_, RPCAMCLinkCounters::fed_trailer_crc_mismatch_, FEDRawDataCollection::FEDData(), feds_, fill_counters_, edm::EventSetup::get(), LogDebug, eostools::move(), processBlock(), processCDFHeaders(), processCDFTrailers(), putCounters(), putRPCDigis(), raw_token_, FEDRawData::size(), and RPCAMCLink::wildcard_.

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

{
    // Get EventSetup Electronics Maps
    setup.get<RPCTwinMuxLinkMapRcd>().get(es_tm_link_map_);
    setup.get<RPCLBLinkMapRcd>().get(es_lb_link_map_);

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

    std::set<std::pair<RPCDetId, RPCDigi> > rpc_digis;
    std::unique_ptr<RPCAMCLinkCounters> counters(new RPCAMCLinkCounters());

    // Loop over the FEDs
    for (int fed : feds_) {

        if (fill_counters_) {
            counters->add(RPCAMCLinkCounters::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("RPCTwinMuxRawToDigi") << "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
        while (word < word_end) {
            processBlock(fed
                         , word, word_end
                         , crc, *counters, rpc_digis);
        }

        // 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_crc_64bit(crc, *word);
            }
            compute_crc_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(RPCAMCLinkCounters::fed_trailer_crc_mismatch_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
                }
                edm::LogWarning("RPCTwinMuxRawToDigi") << "FED Trailer CRC doesn't match for FED id " << fed;
            }
        }
    }

    putRPCDigis(event, rpc_digis);
    if (fill_counters_) {
        putCounters(event, std::move(counters));
    }
}

void RPCTwinMuxRawToDigi::putCounters ( edm::Event &  event, std::unique_ptr< RPCAMCLinkCounters >  counters  )

protected

Definition at line 543 of file RPCTwinMuxRawToDigi.cc.

References DEFINE_FWK_MODULE, and eostools::move().

Referenced by produce().

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

void RPCTwinMuxRawToDigi::putRPCDigis ( edm::Event &  event, std::set< std::pair< RPCDetId, RPCDigi > > const &  digis  )

protected

Definition at line 518 of file RPCTwinMuxRawToDigi.cc.

References LogDebug, and eostools::move().

Referenced by produce().

{
    std::unique_ptr<RPCDigiCollection> rpc_digi_collection(new RPCDigiCollection());
    RPCDetId rpc_det_id;
    std::vector<RPCDigi> local_digis;
    for (std::pair<RPCDetId, RPCDigi> const & rpc_digi : digis) {
        LogDebug("RPCTwinMuxRawToDigi") << "RPCDigi " << rpc_digi.first.rawId()
                                        << ", " << rpc_digi.second.strip() << ", " << rpc_digi.second.bx();
        if (rpc_digi.first != rpc_det_id) {
            if (!local_digis.empty()) {
                rpc_digi_collection->put(RPCDigiCollection::Range(local_digis.begin(), local_digis.end()), rpc_det_id);
                local_digis.clear();
            }
            rpc_det_id = rpc_digi.first;
        }
        local_digis.push_back(rpc_digi.second);
    }
    if (!local_digis.empty()) {
        rpc_digi_collection->put(RPCDigiCollection::Range(local_digis.begin(), local_digis.end()), rpc_det_id);
    }

    event.put(std::move(rpc_digi_collection));
}

Member Data Documentation

int RPCTwinMuxRawToDigi::bx_max_

protected

Definition at line 79 of file RPCTwinMuxRawToDigi.h.

Referenced by processTwinMux().

int RPCTwinMuxRawToDigi::bx_min_

protected

Definition at line 79 of file RPCTwinMuxRawToDigi.h.

Referenced by processTwinMux().

bool RPCTwinMuxRawToDigi::calculate_crc_

protected

Definition at line 78 of file RPCTwinMuxRawToDigi.h.

Referenced by processBlock(), processCDFHeaders(), processTwinMux(), and produce().

edm::ESHandle<RPCLBLinkMap> RPCTwinMuxRawToDigi::es_lb_link_map_

protected

Definition at line 84 of file RPCTwinMuxRawToDigi.h.

Referenced by processRPCRecord(), and produce().

edm::ESHandle<RPCAMCLinkMap> RPCTwinMuxRawToDigi::es_tm_link_map_

protected

Definition at line 83 of file RPCTwinMuxRawToDigi.h.

Referenced by beginRun(), processRPCRecord(), and produce().

edm::ESWatcher<RPCTwinMuxLinkMapRcd> RPCTwinMuxRawToDigi::es_tm_link_map_watcher_

protected

Definition at line 81 of file RPCTwinMuxRawToDigi.h.

Referenced by beginRun().

std::vector<int> RPCTwinMuxRawToDigi::feds_

protected

Definition at line 82 of file RPCTwinMuxRawToDigi.h.

Referenced by beginRun(), and produce().

bool RPCTwinMuxRawToDigi::fill_counters_

protected

Definition at line 78 of file RPCTwinMuxRawToDigi.h.

Referenced by processBlock(), processCDFHeaders(), processCDFTrailers(), processRPCRecord(), processTwinMux(), produce(), and RPCTwinMuxRawToDigi().

edm::EDGetTokenT<FEDRawDataCollection> RPCTwinMuxRawToDigi::raw_token_

protected

Definition at line 76 of file RPCTwinMuxRawToDigi.h.

Referenced by produce(), and RPCTwinMuxRawToDigi().