#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	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () 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::ESGetToken< RPCLBLinkMap, RPCLBLinkMapRcd >	es_lb_link_map_token_

edm::ESHandle< RPCAMCLinkMap >	es_tm_link_map_

edm::ESGetToken< RPCAMCLinkMap, RPCTwinMuxLinkMapRcd >	es_tm_link_map_br_token_

edm::ESGetToken< RPCAMCLinkMap, RPCTwinMuxLinkMapRcd >	es_tm_link_map_token_

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 32 of file RPCTwinMuxRawToDigi.h.

Constructor & Destructor Documentation

◆ RPCTwinMuxRawToDigi()

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

Definition at line 23 of file RPCTwinMuxRawToDigi.cc.

     : calculate_crc_(config.getParameter<bool>("calculateCRC")),
       fill_counters_(config.getParameter<bool>("fillCounters")),
       bx_min_(config.getParameter<int>("bxMin")),
       bx_max_(config.getParameter<int>("bxMax")),
       es_tm_link_map_br_token_(esConsumes<RPCAMCLinkMap, RPCTwinMuxLinkMapRcd, edm::Transition::BeginRun>()),
       es_tm_link_map_token_(esConsumes<RPCAMCLinkMap, RPCTwinMuxLinkMapRcd>()),
       es_lb_link_map_token_(esConsumes<RPCLBLinkMap, RPCLBLinkMapRcd>()) {
   produces<RPCDigiCollection>();
   if (fill_counters_) {
     produces<RPCAMCLinkCounters>();
   }
   raw_token_ = consumes<FEDRawDataCollection>(config.getParameter<edm::InputTag>("inputTag"));
 }

References fill_counters_, and raw_token_.

◆ ~RPCTwinMuxRawToDigi()

RPCTwinMuxRawToDigi::~RPCTwinMuxRawToDigi ( )

override

Definition at line 38 of file RPCTwinMuxRawToDigi.cc.

38 {}

Member Function Documentation

◆ beginRun()

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

override

Definition at line 58 of file RPCTwinMuxRawToDigi.cc.

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

References edm::ESWatcher< T >::check(), es_tm_link_map_br_token_, es_tm_link_map_watcher_, l1tstage2emulator_dqm_sourceclient-live_cfg::feds, feds_, and singleTopDQM_cfi::setup.

◆ compute_crc_64bit()

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

static

Definition at line 40 of file RPCTwinMuxRawToDigi.cc.

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

References evf::compute_crc_8bit().

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

◆ fillDescriptions()

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

static

Definition at line 48 of file RPCTwinMuxRawToDigi.cc.

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

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and HLT_FULL_cff::InputTag.

◆ processBlock()

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 216 of file RPCTwinMuxRawToDigi.cc.

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

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().

◆ processCDFHeaders()

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 139 of file RPCTwinMuxRawToDigi.cc.

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

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

Referenced by produce().

◆ processCDFTrailers()

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 177 of file RPCTwinMuxRawToDigi.cc.

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

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().

◆ processRPCRecord()

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 391 of file RPCTwinMuxRawToDigi.cc.

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

References RPCAMCLinkCounters::add(), RPCAMCLinkEvents::amc_event_, RPCAMCLinkEvents::amc_link_invalid_, l1GtPatternGenerator_cfi::bx, data, TauDecayModes::dec, es_lb_link_map_, es_tm_link_map_, fill_counters_, RPCLBLinkMap::getMap(), RPCAMCLinkMap::getMap(), RPCFebConnector::getRPCDetId(), RPCFebConnector::getStrip(), RPCAMCLinkEvents::input_connector_invalid_, RPCAMCLinkEvents::input_connector_not_used_, RPCAMCLinkEvents::input_eod_, RPCAMCLinkEvents::input_event_, RPCAMCLinkEvents::input_lb_invalid_, RPCAMCLinkEvents::input_link_ack_fail_, RPCAMCLinkEvents::input_link_error_, createfilelist::int, MainPageGenerator::link, LogDebug, RPCLBLink::max_connector_, RPCLBLink::max_linkboard_, GlobalPosition_Frontier_DevDB_cff::record, RPCLBLink::setConnector(), RPCLBLink::setLinkBoard(), digitizers_cfi::strip, and testProducerWithPsetDescEmpty_cfi::x1.

Referenced by processTwinMux().

◆ processTwinMux()

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 275 of file RPCTwinMuxRawToDigi.cc.

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

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::TwinMuxRecord::getType(), 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().

◆ produce()

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

override

Definition at line 69 of file RPCTwinMuxRawToDigi.cc.

                                                                              {
   // Get EventSetup Electronics Maps
   es_tm_link_map_ = setup.getHandle(es_tm_link_map_token_);
   es_lb_link_map_ = setup.getHandle(es_lb_link_map_token_);
  
   // 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));
   }
 }

References calculate_crc_, compute_crc_64bit(), FEDTrailer::crc(), FEDRawData::data(), es_lb_link_map_, es_lb_link_map_token_, es_tm_link_map_, es_tm_link_map_token_, RPCAMCLinkEvents::fed_event_, RPCAMCLinkEvents::fed_trailer_crc_mismatch_, FEDRawDataCollection::FEDData(), feds_, fill_counters_, LogDebug, eostools::move(), processBlock(), processCDFHeaders(), processCDFTrailers(), putCounters(), putRPCDigis(), raw_token_, singleTopDQM_cfi::setup, FEDRawData::size(), and RPCAMCLink::wildcard_.

◆ putCounters()

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

protected

Definition at line 532 of file RPCTwinMuxRawToDigi.cc.

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

References eostools::move().

Referenced by produce().

◆ putRPCDigis()

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

protected

Definition at line 509 of file RPCTwinMuxRawToDigi.cc.

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

References LogDebug, and eostools::move().

Referenced by produce().

Member Data Documentation

◆ bx_max_

int RPCTwinMuxRawToDigi::bx_max_

protected

Definition at line 87 of file RPCTwinMuxRawToDigi.h.

Referenced by processTwinMux().

◆ bx_min_

int RPCTwinMuxRawToDigi::bx_min_

protected

Definition at line 87 of file RPCTwinMuxRawToDigi.h.

Referenced by processTwinMux().

◆ calculate_crc_

bool RPCTwinMuxRawToDigi::calculate_crc_

protected

Definition at line 86 of file RPCTwinMuxRawToDigi.h.

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

◆ es_lb_link_map_

edm::ESHandle<RPCLBLinkMap> RPCTwinMuxRawToDigi::es_lb_link_map_

protected

Definition at line 92 of file RPCTwinMuxRawToDigi.h.

Referenced by processRPCRecord(), and produce().

◆ es_lb_link_map_token_

edm::ESGetToken<RPCLBLinkMap, RPCLBLinkMapRcd> RPCTwinMuxRawToDigi::es_lb_link_map_token_

protected

Definition at line 95 of file RPCTwinMuxRawToDigi.h.

Referenced by produce().

◆ es_tm_link_map_

edm::ESHandle<RPCAMCLinkMap> RPCTwinMuxRawToDigi::es_tm_link_map_

protected

Definition at line 91 of file RPCTwinMuxRawToDigi.h.

Referenced by processRPCRecord(), and produce().

◆ es_tm_link_map_br_token_

edm::ESGetToken<RPCAMCLinkMap, RPCTwinMuxLinkMapRcd> RPCTwinMuxRawToDigi::es_tm_link_map_br_token_

protected

Definition at line 93 of file RPCTwinMuxRawToDigi.h.

Referenced by beginRun().

◆ es_tm_link_map_token_

edm::ESGetToken<RPCAMCLinkMap, RPCTwinMuxLinkMapRcd> RPCTwinMuxRawToDigi::es_tm_link_map_token_

protected

Definition at line 94 of file RPCTwinMuxRawToDigi.h.

Referenced by produce().

◆ es_tm_link_map_watcher_

edm::ESWatcher<RPCTwinMuxLinkMapRcd> RPCTwinMuxRawToDigi::es_tm_link_map_watcher_

protected

Definition at line 89 of file RPCTwinMuxRawToDigi.h.

Referenced by beginRun().

◆ feds_

std::vector<int> RPCTwinMuxRawToDigi::feds_

protected

Definition at line 90 of file RPCTwinMuxRawToDigi.h.

Referenced by beginRun(), and produce().

◆ fill_counters_

bool RPCTwinMuxRawToDigi::fill_counters_

protected

Definition at line 86 of file RPCTwinMuxRawToDigi.h.

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

◆ raw_token_

edm::EDGetTokenT<FEDRawDataCollection> RPCTwinMuxRawToDigi::raw_token_

protected

Definition at line 84 of file RPCTwinMuxRawToDigi.h.

Referenced by produce(), and RPCTwinMuxRawToDigi().

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ RPCTwinMuxRawToDigi()

◆ ~RPCTwinMuxRawToDigi()

Member Function Documentation

◆ beginRun()

◆ compute_crc_64bit()

◆ fillDescriptions()

◆ processBlock()

◆ processCDFHeaders()

◆ processCDFTrailers()

◆ processRPCRecord()

◆ processTwinMux()

◆ produce()

◆ putCounters()

◆ putRPCDigis()

Member Data Documentation

◆ bx_max_

◆ bx_min_

◆ calculate_crc_

◆ es_lb_link_map_

◆ es_lb_link_map_token_

◆ es_tm_link_map_

◆ es_tm_link_map_br_token_

◆ es_tm_link_map_token_

◆ es_tm_link_map_watcher_

◆ feds_

◆ fill_counters_

◆ raw_token_