#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 () override

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_crc_64bit (std::uint16_t &crc, std::uint64_t const &word)

static void	fillDescriptions (edm::ConfigurationDescriptions &descs)

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 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

Detailed Description

Definition at line 30 of file RPCTwinMuxRawToDigi.h.

Constructor & Destructor Documentation

RPCTwinMuxRawToDigi::RPCTwinMuxRawToDigi ( edm::ParameterSet const & config )

Definition at line 24 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 ( )

override

Definition at line 37 of file RPCTwinMuxRawToDigi.cc.

38 {}

Member Function Documentation

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

override

Definition at line 60 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 40 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 49 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 227 of file RPCTwinMuxRawToDigi.cc.

References RPCAMCLinkCounters::add(), amc, RPCAMCLinkEvents::amc_amc13_evc_bc_invalid_, calculate_crc_, compute_crc_64bit(), RPCAMCLinkEvents::fed_amc13_block_incomplete_, 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(RPCAMCLinkEvents::fed_amc13_block_incomplete_, 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(RPCAMCLinkEvents::amc_amc13_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 150 of file RPCTwinMuxRawToDigi.cc.

References RPCAMCLinkCounters::add(), calculate_crc_, FEDHeader::check(), compute_crc_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_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(RPCAMCLinkEvents::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(RPCAMCLinkEvents::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 188 of file RPCTwinMuxRawToDigi.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("RPCTwinMuxRawToDigi") << "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("RPCTwinMuxRawToDigi") << "FED Trailer check failed for FED id " << fed;
             --word_end;
             break;
         }
         if (trailer.fragmentLength() != nwords) {
             if (fill_counters_) {
                 counters.add(RPCAMCLinkEvents::fed_trailer_length_mismatch_, RPCAMCLink(fed, RPCAMCLink::wildcard_));
             }
             edm::LogWarning("RPCTwinMuxRawToDigi") << "FED Trailer length " << trailer.fragmentLength()
                                                    << " 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 400 of file RPCTwinMuxRawToDigi.cc.

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(RPCAMCLinkEvents::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(RPCAMCLinkEvents::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(RPCAMCLinkEvents::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(RPCAMCLinkEvents::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(RPCAMCLinkEvents::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(RPCAMCLinkEvents::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(RPCAMCLinkEvents::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(RPCAMCLinkEvents::amc_event_, RPCAMCLink(fed, amc_number));
             counters.add(RPCAMCLinkEvents::input_event_, 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 289 of file RPCTwinMuxRawToDigi.cc.

References RPCAMCLinkCounters::add(), RPCAMCLinkEvents::amc_number_mismatch_, RPCAMCLinkEvents::amc_payload_incomplete_, bx_max_, bx_min_, calculate_crc_, compute_crc_64bit(), TauDecayModes::dec, RPCAMCLinkEvents::fed_amc13_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, SiStripPI::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(RPCAMCLinkEvents::fed_amc13_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(RPCAMCLinkEvents::amc_payload_incomplete_, 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(RPCAMCLinkEvents::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
	)

override

Definition at line 72 of file RPCTwinMuxRawToDigi.cc.

References calculate_crc_, compute_crc_64bit(), FEDTrailer::crc(), FEDRawData::data(), es_lb_link_map_, es_tm_link_map_, RPCAMCLinkEvents::fed_event_, RPCAMCLinkEvents::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(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("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(RPCAMCLinkEvents::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 544 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 519 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));
 }