#include <SiStripRawToDigiUnpacker.h>

Classes
class	Registry
	private class to register start and end index of digis in a collection More...

Public Types
typedef edm::DetSetVector< SiStripDigi >	Digis

typedef edm::DetSetVector< SiStripRawDigi >	RawDigis

Public Member Functions
void	createDigis (const SiStripFedCabling &, const FEDRawDataCollection &, SiStripEventSummary &, RawDigis &scope_mode, RawDigis &virgin_raw, RawDigis &proc_raw, Digis &zero_suppr, DetIdCollection &, RawDigis &common_mode)
	creates digis More...

void	doAPVEmulatorCheck (bool)

void	doFullCorruptBufferChecks (bool)

void	extractCm (bool)

void	legacy (bool)

void	locateStartOfFedBuffer (const uint16_t &fed_id, const FEDRawData &input, FEDRawData &output)
	Removes any data appended prior to FED buffer and reorders 32-bit words if swapped. More...

void	printWarningSummary () const

void	quiet (bool)
	verbosity More...

	RawToDigiUnpacker (int16_t appended_bytes, int16_t fed_buffer_dump_freq, int16_t fed_event_dump_freq, int16_t trigger_fed_id, bool using_fed_key, bool unpack_bad_channels, bool mark_missing_feds, const uint32_t errorThreshold)
	constructor More...

	RawToDigiUnpacker ()=delete
	private default constructor More...

void	triggerFed (const FEDRawDataCollection &, SiStripEventSummary &, const uint32_t &event)
	trigger info More...

void	useDaqRegister (bool)
	EventSummary update request -> not yet implemented for FEDBuffer class. More...

	~RawToDigiUnpacker ()
	default constructor More...

Private Member Functions
void	cleanupWorkVectors ()
	method to clear registries and digi collections More...

sistrip::FedBufferFormat	fedBufferFormat (const uint16_t &register_value)
	returns buffer format More...

sistrip::FedReadoutMode	fedReadoutMode (const uint16_t &register_value)
	returns buffer readout mode More...

void	physicalOrder (uint16_t &readout_order, uint16_t &physical_order)
	order of strips More...

void	readoutOrder (uint16_t &physical_order, uint16_t &readout_order)
	order of strips More...

void	update (RawDigis &scope_mode, RawDigis &virgin_raw, RawDigis &proc_raw, Digis &zero_suppr, RawDigis &common_mode)
	fill DetSetVectors using registries More...

void	updateEventSummary (const sistrip::FEDBuffer &, SiStripEventSummary &)
	sets the SiStripEventSummary -> not yet implemented for FEDBuffer class More...

Static Private Member Functions
static void	dumpRawData (uint16_t fed_id, const FEDRawData &, std::stringstream &)
	dumps raw data to stdout (NB: payload is byte-swapped,headers/trailer are not). More...

Private Attributes
std::vector< SiStripRawDigi >	cm_work_digis_

std::vector< Registry >	cm_work_registry_

bool	doAPVEmulatorCheck_

bool	doFullCorruptBufferChecks_

uint32_t	errorThreshold_

uint32_t	event_
	other values More...

bool	extractCm_

int16_t	fedBufferDumpFreq_

int16_t	fedEventDumpFreq_

bool	first_

int16_t	headerBytes_
	configurables More...

bool	legacy_

bool	markMissingFeds_

bool	once_

std::vector< SiStripRawDigi >	proc_work_digis_

std::vector< Registry >	proc_work_registry_

bool	quiet_

std::vector< SiStripRawDigi >	scope_work_digis_

std::vector< Registry >	scope_work_registry_

int16_t	triggerFedId_

bool	unpackBadChannels_

bool	useDaqRegister_

bool	useFedKey_

std::vector< SiStripRawDigi >	virgin_work_digis_

std::vector< Registry >	virgin_work_registry_

WarningSummary	warnings_

std::vector< SiStripDigi >	zs_work_digis_
	digi collections More...

std::vector< Registry >	zs_work_registry_
	registries More...

Friends
class	RawToClustersLazyUnpacker

Detailed Description

Definition at line 31 of file SiStripRawToDigiUnpacker.h.

Member Typedef Documentation

◆ Digis

typedef edm::DetSetVector<SiStripDigi> sistrip::RawToDigiUnpacker::Digis

Definition at line 35 of file SiStripRawToDigiUnpacker.h.

◆ RawDigis

typedef edm::DetSetVector<SiStripRawDigi> sistrip::RawToDigiUnpacker::RawDigis

Definition at line 36 of file SiStripRawToDigiUnpacker.h.

Constructor & Destructor Documentation

◆ RawToDigiUnpacker() [1/2]

sistrip::RawToDigiUnpacker::RawToDigiUnpacker	(	int16_t	appended_bytes,
		int16_t	fed_buffer_dump_freq,
		int16_t	fed_event_dump_freq,
		int16_t	trigger_fed_id,
		bool	using_fed_key,
		bool	unpack_bad_channels,
		bool	mark_missing_feds,
		const uint32_t	errorThreshold
	)

constructor

Definition at line 27 of file SiStripRawToDigiUnpacker.cc.

References edm::isDebugEnabled(), LogTrace, and unpackBadChannels_.

       : headerBytes_(appended_bytes),
         fedBufferDumpFreq_(fed_buffer_dump_freq),
         fedEventDumpFreq_(fed_event_dump_freq),
         triggerFedId_(trigger_fed_id),
         useFedKey_(using_fed_key),
         unpackBadChannels_(unpack_bad_channels),
         markMissingFeds_(mark_missing_feds),
         event_(0),
         once_(true),
         first_(true),
         useDaqRegister_(false),
         quiet_(true),
         extractCm_(false),
         doFullCorruptBufferChecks_(false),
         doAPVEmulatorCheck_(true),
         errorThreshold_(errorThreshold),
         warnings_(sistrip::mlRawToDigi_, "[sistrip::RawToDigiUnpacker::createDigis]", edm::isDebugEnabled()) {
     if (edm::isDebugEnabled()) {
       LogTrace("SiStripRawToDigi") << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
                                    << " Constructing object...";
     }
     if (unpackBadChannels_) {
       edm::LogWarning("SiStripRawToDigi")
           << "Warning: Unpacking of bad channels enabled. Only enable this if you know what you are doing. "
           << std::endl;
     }
   }

◆ RawToDigiUnpacker() [2/2]

sistrip::RawToDigiUnpacker::RawToDigiUnpacker ( )

delete

private default constructor

◆ ~RawToDigiUnpacker()

sistrip::RawToDigiUnpacker::~RawToDigiUnpacker ( )

default constructor

Definition at line 63 of file SiStripRawToDigiUnpacker.cc.

References edm::isDebugEnabled(), and LogTrace.

                                         {
     if (edm::isDebugEnabled()) {
       LogTrace("SiStripRawToDigi") << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
                                    << " Destructing object...";
     }
   }

Member Function Documentation

◆ cleanupWorkVectors()

void sistrip::RawToDigiUnpacker::cleanupWorkVectors ( )

private

method to clear registries and digi collections

Definition at line 709 of file SiStripRawToDigiUnpacker.cc.

References cms::cuda::assert(), cm_work_digis_, cm_work_registry_, proc_work_digis_, proc_work_registry_, scope_work_digis_, scope_work_registry_, virgin_work_digis_, virgin_work_registry_, zs_work_digis_, and zs_work_registry_.

Referenced by createDigis().

                                              {
     // Clear working areas and registries
 
     localRA.update(zs_work_digis_.size());
     zs_work_registry_.clear();
     zs_work_digis_.clear();
     zs_work_digis_.shrink_to_fit();
     assert(zs_work_digis_.capacity() == 0);
     virgin_work_registry_.clear();
     virgin_work_digis_.clear();
     proc_work_registry_.clear();
     proc_work_digis_.clear();
     scope_work_registry_.clear();
     scope_work_digis_.clear();
     cm_work_registry_.clear();
     cm_work_digis_.clear();
   }

◆ createDigis()

void sistrip::RawToDigiUnpacker::createDigis	(	const SiStripFedCabling &	cabling,
		const FEDRawDataCollection &	buffers,
		SiStripEventSummary &	summary,
		RawDigis &	scope_mode,
		RawDigis &	virgin_raw,
		RawDigis &	proc_raw,
		Digis &	zero_suppr,
		DetIdCollection &	detids,
		RawDigis &	common_mode
	)

creates digis

extract readout mode

FED channel

Definition at line 84 of file SiStripRawToDigiUnpacker.cc.

Referenced by sistrip::RawToDigiModule::produce().

                                                            {
     // Clear done at the end
     assert(zs_work_digis_.empty());
     zs_work_digis_.reserve(localRA.upper());
     // Reserve space in bad module list
     detids.reserve(100);
 
     // Check if FEDs found in cabling map and event data
     if (cabling.fedIds().empty()) {
       warnings_.add("No FEDs found in cabling map!");
       if (edm::isDebugEnabled()) {
         // Check which FED ids have non-zero size buffers
         std::vector<uint16_t> feds;
         for (uint16_t ifed = FEDNumbering::MINSiStripFEDID; ifed < FEDNumbering::MAXSiStripFEDID; ifed++) {
           if (ifed != triggerFedId_ && buffers.FEDData(static_cast<int>(ifed)).size()) {
             feds.push_back(ifed);
           }
         }
         LogTrace("SiStripRawToDigi") << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
                                      << " Found " << feds.size() << " FED buffers with non-zero size!";
       }
     }
 
     // Flag for EventSummary update using DAQ register
     bool first_fed = true;
 
     // Retrieve FED ids from cabling map and iterate through
     std::vector<uint16_t>::const_iterator ifed = cabling.fedIds().begin();
     for (; ifed != cabling.fedIds().end(); ifed++) {
       // ignore trigger FED
       if (*ifed == triggerFedId_) {
         continue;
       }
 
       // Retrieve FED raw data for given FED
       const FEDRawData& input = buffers.FEDData(static_cast<int>(*ifed));
 
       // Some debug on FED buffer size
       if (edm::isDebugEnabled()) {
         if (first_ && input.data()) {
           std::stringstream ss;
           ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
              << " Found FED id " << std::setw(4) << std::setfill(' ') << *ifed << " in FEDRawDataCollection"
              << " with non-zero pointer 0x" << std::hex << std::setw(8) << std::setfill('0')
              << reinterpret_cast<const uint32_t*>(input.data()) << std::dec << " and size " << std::setw(5)
              << std::setfill(' ') << input.size() << " chars";
           LogTrace("SiStripRawToDigi") << ss.str();
         }
       }
 
       // Dump of FEDRawData to stdout
       if (edm::isDebugEnabled()) {
         if (fedBufferDumpFreq_ && !(event_ % fedBufferDumpFreq_)) {
           std::stringstream ss;
           dumpRawData(*ifed, input, ss);
           edm::LogVerbatim(sistrip::mlRawToDigi_) << ss.str();
         }
       }
 
       // get the cabling connections for this FED
       auto conns = cabling.fedConnections(*ifed);
       // check FEDRawData pointer, size, and more
       const auto st_buffer = preconstructCheckFEDBuffer(input);
       // construct FEDBuffer
       if (FEDBufferStatusCode::SUCCESS != st_buffer) {
         if (FEDBufferStatusCode::BUFFER_NULL == st_buffer) {
           warnings_.add("NULL pointer to FEDRawData for FED", fmt::format("id {0}", *ifed));
         } else if (!input.size()) {
           warnings_.add("FEDRawData has zero size for FED", fmt::format("id {0}", *ifed));
         } else {
           warnings_.add("Exception caught when creating FEDBuffer object for FED",
                         fmt::format("id {0}: {1}", *ifed, st_buffer));
         }
         // FED buffer is bad and should not be unpacked. Skip this FED and mark all modules as bad.
         maskFED(detids, conns);
         continue;
       }
       FEDBuffer buffer{input};
       const auto st_chan = buffer.findChannels();
       if (FEDBufferStatusCode::SUCCESS != st_chan) {
         warnings_.add("Exception caught when creating FEDBuffer object for FED",
                       fmt::format("id {0}: {1}", *ifed, st_chan));
         maskFED(detids, conns);
         continue;
       }
       buffer.setLegacyMode(legacy_);
       if ((!buffer.doChecks(true)) && (!unpackBadChannels_ || !buffer.checkNoFEOverflows())) {
         warnings_.add("Exception caught when creating FEDBuffer object for FED",
                       fmt::format("id {0}: FED Buffer check fails for FED ID {0}.", *ifed));
         maskFED(detids, conns);
         continue;
       }
       if (doFullCorruptBufferChecks_ && !buffer.doCorruptBufferChecks()) {
         warnings_.add("Exception caught when creating FEDBuffer object for FED",
                       fmt::format("id {0}: FED corrupt buffer check fails for FED ID {0}.", *ifed));
         maskFED(detids, conns);
         continue;
       }
 
       // Check if EventSummary ("trigger FED info") needs updating
       if (first_fed && useDaqRegister_) {
         updateEventSummary(buffer, summary);
         first_fed = false;
       }
 
       // Check to see if EventSummary info is set
       if (!quiet_ && !summary.isSet()) {
         warnings_.add(
             "EventSummary is not set correctly! Missing information from both \"trigger FED\" and \"DAQ registers\"!");
       }
 
       // Check to see if event is to be analyzed according to EventSummary
       if (!summary.valid()) {
         if (edm::isDebugEnabled()) {
           LogTrace("SiStripRawToDigi") << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
                                        << " EventSummary is not valid: skipping...";
         }
         continue;
       }
 
       const sistrip::FEDReadoutMode mode = buffer.readoutMode();
       const sistrip::FEDLegacyReadoutMode lmode =
           (legacy_) ? buffer.legacyReadoutMode() : sistrip::READOUT_MODE_LEGACY_INVALID;
 
       // Retrive run type
       const sistrip::RunType runType_ = summary.runType();
       if (runType_ == sistrip::APV_LATENCY || runType_ == sistrip::FINE_DELAY) {
         useFedKey_ = false;
       }
 
       // Dump of FED buffer
       if (edm::isDebugEnabled()) {
         if (fedEventDumpFreq_ && !(event_ % fedEventDumpFreq_)) {
           std::stringstream ss;
           buffer.dump(ss);
           edm::LogVerbatim(sistrip::mlRawToDigi_) << ss.str();
         }
       }
 
       // Iterate through FED channels, extract payload and create Digis
       std::vector<FedChannelConnection>::const_iterator iconn = conns.begin();
       for (; iconn != conns.end(); iconn++) {
         uint16_t chan = iconn->fedCh();
 
         // Check if fed connection is valid
         if (!iconn->isConnected()) {
           continue;
         }
 
         // Check DetId is valid (if to be used as key)
         if (!useFedKey_ && (!iconn->detId() || iconn->detId() == sistrip::invalid32_)) {
           continue;
         }
 
         // Check FED channel
         if (!buffer.channelGood(iconn->fedCh(), doAPVEmulatorCheck_)) {
           if (!unpackBadChannels_ || !(buffer.fePresent(iconn->fedCh() / FEDCH_PER_FEUNIT) &&
                                        buffer.feEnabled(iconn->fedCh() / FEDCH_PER_FEUNIT))) {
             detids.push_back(iconn->detId());  //@@ Possible multiple entries (ok for Giovanni)
             continue;
           }
         }
 
         // Determine whether FED key is inferred from cabling or channel loop
         const uint32_t fed_key =
             (summary.runType() == sistrip::FED_CABLING)
                 ? ((*ifed & sistrip::invalid_) << 16) | (chan & sistrip::invalid_)
                 : ((iconn->fedId() & sistrip::invalid_) << 16) | (iconn->fedCh() & sistrip::invalid_);
 
         // Determine whether DetId or FED key should be used to index digi containers
         const uint32_t key = (useFedKey_ || (!legacy_ && mode == sistrip::READOUT_MODE_SCOPE) ||
                               (legacy_ && lmode == sistrip::READOUT_MODE_LEGACY_SCOPE))
                                  ? fed_key
                                  : iconn->detId();
 
         // Determine APV std::pair number (needed only when using DetId)
         const uint16_t ipair = (useFedKey_ || (!legacy_ && mode == sistrip::READOUT_MODE_SCOPE) ||
                                 (legacy_ && lmode == sistrip::READOUT_MODE_LEGACY_SCOPE))
                                    ? 0
                                    : iconn->apvPairNumber();
 
         const auto& fedChannel = buffer.channel(iconn->fedCh());
 
 #ifdef EDM_ML_DEBUG
         std::stringstream smode;
         if (!legacy_)
           smode << mode;
         else
           smode << lmode;
         LogDebug("SiStripRawToDigi") << "Unpacking FED " << *ifed << " channel " << iconn->fedCh()
                                      << ((!legacy_) ? " " : " legacy ") << "data in mode " << smode.str()
                                      << " for module " << iconn->detId() << " pair " << ipair;
 #endif
         if (fedchannelunpacker::isZeroSuppressed(mode, legacy_, lmode)) {
           Registry regItem(key, 0, zs_work_digis_.size(), 0);
           const auto isNonLite = fedchannelunpacker::isNonLiteZS(mode, legacy_, lmode);
           const uint8_t pCode = (isNonLite ? buffer.packetCode(legacy_, iconn->fedCh()) : 0);
           if (isNonLite)
             LogDebug("SiStripRawToDigi") << "Non-lite zero-suppressed mode. Packet code=0x" << std::hex
                                          << uint16_t(pCode) << std::dec;
           const auto st_ch = fedchannelunpacker::unpackZeroSuppressed(
               fedChannel, std::back_inserter(zs_work_digis_), ipair * 256, isNonLite, mode, legacy_, lmode, pCode);
           if (fedchannelunpacker::StatusCode::ZERO_PACKET_CODE == st_ch ||
               fedchannelunpacker::StatusCode::BAD_PACKET_CODE == st_ch) {
             warnings_.add(fmt::format("Invalid packet code {0:#x} for zero-suppressed data", uint16_t(pCode)),
                           fmt::format("FED {0} channel {1}", *ifed, iconn->fedCh()));
           } else if (fedchannelunpacker::StatusCode::SUCCESS != st_ch) {
             warnings_.add("Clusters are not ordered",
                           fmt::format("FED {0} channel {1}: {2}", *ifed, iconn->fedCh(), toString(st_ch)));
             detids.push_back(iconn->detId());  //@@ Possible multiple entries (ok for Giovanni)
             continue;
           }
           if (regItem.index != zs_work_digis_.size()) {
             regItem.length = zs_work_digis_.size() - regItem.index;
             regItem.first = zs_work_digis_[regItem.index].strip();
             zs_work_registry_.push_back(regItem);
           }
           // Common mode values
           if (isNonLite && extractCm_) {
             if ((pCode == PACKET_CODE_ZERO_SUPPRESSED) || (pCode == PACKET_CODE_ZERO_SUPPRESSED10) ||
                 (pCode == PACKET_CODE_ZERO_SUPPRESSED8_BOTBOT) || (pCode == PACKET_CODE_ZERO_SUPPRESSED8_TOPBOT)) {
               Registry regItem2(key, 2 * ipair, cm_work_digis_.size(), 2);
               cm_work_digis_.push_back(SiStripRawDigi(fedChannel.cmMedian(0)));
               cm_work_digis_.push_back(SiStripRawDigi(fedChannel.cmMedian(1)));
               cm_work_registry_.push_back(regItem2);
             } else {
               detids.push_back(iconn->detId());  //@@ Possible multiple entries (ok for Giovanni)
               warnings_.add("Problem extracting common modes",
                             fmt::format("FED {0} channel {1}:\n Request for CM median from channel with non-ZS "
                                         "packet code. Packet code is {2}.",
                                         *ifed,
                                         iconn->fedCh(),
                                         pCode));
             }
           }
         } else {
           auto st_ch = fedchannelunpacker::StatusCode::SUCCESS;
           if (fedchannelunpacker::isVirginRaw(mode, legacy_, lmode)) {
             Registry regItem(key, 256 * ipair, virgin_work_digis_.size(), 0);
             LogDebug("SiStripRawToDigi") << "Virgin raw packet code: 0x" << std::hex
                                          << uint16_t(buffer.packetCode(legacy_)) << "  0x"
                                          << uint16_t(fedChannel.packetCode()) << std::dec;
             st_ch = fedchannelunpacker::unpackVirginRaw(
                 fedChannel, std::back_inserter(virgin_work_digis_), buffer.packetCode(legacy_));
             if (regItem.index != virgin_work_digis_.size()) {
               regItem.length = virgin_work_digis_.size() - regItem.index;
               virgin_work_registry_.push_back(regItem);
             }
           } else if (fedchannelunpacker::isProcessedRaw(mode, legacy_, lmode)) {
             Registry regItem(key, 256 * ipair, proc_work_digis_.size(), 0);
             st_ch = fedchannelunpacker::unpackProcessedRaw(fedChannel, std::back_inserter(proc_work_digis_));
             if (regItem.index != proc_work_digis_.size()) {
               regItem.length = proc_work_digis_.size() - regItem.index;
               proc_work_registry_.push_back(regItem);
             }
           } else if (fedchannelunpacker::isScopeMode(mode, legacy_, lmode)) {
             Registry regItem(key, 0, scope_work_digis_.size(), 0);
             st_ch = fedchannelunpacker::unpackScope(fedChannel, std::back_inserter(scope_work_digis_));
             if (regItem.index != scope_work_digis_.size()) {
               regItem.length = scope_work_digis_.size() - regItem.index;
               scope_work_registry_.push_back(regItem);
             }
           } else {  // Unknown readout mode! => assume scope mode
             warnings_.add(fmt::format("Unknown FED readout mode ({0})! Assuming SCOPE MODE...", mode));
             Registry regItem(key, 0, scope_work_digis_.size(), 0);
             st_ch = fedchannelunpacker::unpackScope(fedChannel, std::back_inserter(scope_work_digis_));
             if (regItem.index != scope_work_digis_.size()) {
               regItem.length = scope_work_digis_.size() - regItem.index;
               scope_work_registry_.push_back(regItem);
               if (edm::isDebugEnabled()) {
                 std::stringstream ss;
                 ss << "Extracted " << regItem.length
                    << " SCOPE MODE digis (samples[0] = " << scope_work_digis_[regItem.index] << ") from FED id/ch "
                    << iconn->fedId() << "/" << iconn->fedCh();
                 LogTrace("SiStripRawToDigi") << ss.str();
               }
             } else {
               warnings_.add("No SM digis found!");
             }
           }
           if (fedchannelunpacker::StatusCode::SUCCESS != st_ch) {
             warnings_.add(toString(st_ch), fmt::format("FED {0} channel {1}:", *ifed, iconn->fedCh()));
           }
         }
       }  // channel loop
     }    // fed loop
 
     // bad channels warning
     unsigned int detIdsSize = detids.size();
     if (edm::isDebugEnabled() && detIdsSize) {
       std::ostringstream ss;
       ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
          << " Problems were found in data and " << detIdsSize << " channels could not be unpacked. "
          << "See output of FED Hardware monitoring for more information. ";
       edm::LogWarning(sistrip::mlRawToDigi_) << ss.str();
     }
     if ((errorThreshold_ != 0) && (detIdsSize > errorThreshold_)) {
       edm::LogError("TooManyErrors") << "Total number of errors = " << detIdsSize;
     }
 
     // update DetSetVectors
     update(scope_mode, virgin_raw, proc_raw, zero_suppr, cm_values);
 
     // increment event counter
     event_++;
 
     // no longer first event!
     if (first_) {
       first_ = false;
     }
 
     // final cleanup, just in case
     cleanupWorkVectors();
   }

◆ doAPVEmulatorCheck()

void sistrip::RawToDigiUnpacker::doAPVEmulatorCheck ( bool do_APVEmulator_check )

inline

Definition at line 205 of file SiStripRawToDigiUnpacker.h.

Referenced by sistrip::RawToDigiModule::RawToDigiModule().

                                                                            {
   doAPVEmulatorCheck_ = do_APVEmulator_check;
 }

◆ doFullCorruptBufferChecks()

void sistrip::RawToDigiUnpacker::doFullCorruptBufferChecks ( bool do_full_corrupt_buffer_checks )

inline

Definition at line 201 of file SiStripRawToDigiUnpacker.h.

Referenced by sistrip::RawToDigiModule::RawToDigiModule().

                                                                                            {
   doFullCorruptBufferChecks_ = do_full_corrupt_buffer_checks;
 }

◆ dumpRawData()

void sistrip::RawToDigiUnpacker::dumpRawData	(	uint16_t	fed_id,
		const FEDRawData &	buffer,
		std::stringstream &	ss
	)

staticprivate

dumps raw data to stdout (NB: payload is byte-swapped,headers/trailer are not).

Definition at line 1012 of file SiStripRawToDigiUnpacker.cc.

References edmScanValgrind::buffer, TauDecayModes::dec, relativeConstraints::empty, mps_fire::i, sistrip::invalid32_, and contentValuesCheck::ss.

Referenced by createDigis().

                                                                                                     {
     ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
        << " Dump of buffer for FED id " << fed_id << std::endl
        << " Buffer contains " << buffer.size() << " bytes (NB: payload is byte-swapped)" << std::endl;
 
     if (false) {
       const uint32_t* buffer_u32 = reinterpret_cast<const uint32_t*>(buffer.data());
       unsigned int empty = 0;
 
       ss << "Byte->   4 5 6 7 0 1 2 3\n";
       for (uint32_t i = 0; i < buffer.size() / 8; i++) {
         unsigned int temp0 = buffer_u32[i * 2] & sistrip::invalid32_;
         unsigned int temp1 = buffer_u32[i * 2 + 1] & sistrip::invalid32_;
         if (!temp0 && !temp1) {
           empty++;
         } else {
           if (empty) {
             ss << "        [ empty  words ]" << std::endl;
             empty = 0;
           }
           ss << std::dec << std::setfill(' ') << std::setw(6) << i * 8 << ": " << std::hex << std::setfill('0')
              << std::setw(8) << temp0 << std::setfill('0') << std::setw(8) << temp1 << std::dec << std::endl;
         }
       }
 
     } else {
       ss << "  Byte |  <---- Byte order ----<  | Byte" << std::endl;
       ss << "  cntr |  7  6  5  4  3  2  1  0  | cntr" << std::endl;
       for (uint32_t i = 0; i < buffer.size() / 8; i++) {
         //if ( i>=20 && ((i+4)<(buffer.size()/8)) ) { continue; }
         uint16_t tmp0 = buffer.data()[i * 8 + 0] & 0xFF;
         uint16_t tmp1 = buffer.data()[i * 8 + 1] & 0xFF;
         uint16_t tmp2 = buffer.data()[i * 8 + 2] & 0xFF;
         uint16_t tmp3 = buffer.data()[i * 8 + 3] & 0xFF;
         uint16_t tmp4 = buffer.data()[i * 8 + 4] & 0xFF;
         uint16_t tmp5 = buffer.data()[i * 8 + 5] & 0xFF;
         uint16_t tmp6 = buffer.data()[i * 8 + 6] & 0xFF;
         uint16_t tmp7 = buffer.data()[i * 8 + 7] & 0xFF;
         //  if ( !tmp0 && !tmp1 && !tmp2 && !tmp3 &&
         //       !tmp4 && !tmp5 && !tmp6 && !tmp7 ) { empty++; }
         //  else {
         //    if ( empty ) {
         //      ss << "         [.."
         //         << std::dec << std::setfill('.') << std::setw(4) << empty
         //         << " null words....]" << std::endl;
         //      empty = 0;
         //    }
         ss << std::dec << std::setfill(' ') << std::setw(6) << i * 8 + 7 << " : " << std::hex << std::setfill('0')
            << std::setw(2) << tmp7 << " " << std::setfill('0') << std::setw(2) << tmp6 << " " << std::setfill('0')
            << std::setw(2) << tmp5 << " " << std::setfill('0') << std::setw(2) << tmp4 << " " << std::setfill('0')
            << std::setw(2) << tmp3 << " " << std::setfill('0') << std::setw(2) << tmp2 << " " << std::setfill('0')
            << std::setw(2) << tmp1 << " " << std::setfill('0') << std::setw(2) << tmp0 << std::dec << " :"
            << std::setfill(' ') << std::setw(6) << i * 8 << std::endl;
         //  }
       }
     }
     ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
        << " End of FED buffer";
   }

◆ extractCm()

void sistrip::RawToDigiUnpacker::extractCm ( bool extract_cm )

inline

Definition at line 199 of file SiStripRawToDigiUnpacker.h.

Referenced by sistrip::RawToDigiModule::RawToDigiModule().

199 { extractCm_ = extract_cm; }

sistrip::RawToDigiUnpacker::extractCm_

bool extractCm_

Definition: SiStripRawToDigiUnpacker.h:145

◆ fedBufferFormat()

sistrip::FedBufferFormat sistrip::RawToDigiUnpacker::fedBufferFormat ( const uint16_t & register_value )

inlineprivate

returns buffer format

Definition at line 179 of file SiStripRawToDigiUnpacker.h.

References sistrip::APV_ERROR_FORMAT, sistrip::FULL_DEBUG_FORMAT, sistrip::UNDEFINED_FED_BUFFER_FORMAT, sistrip::UNKNOWN_FED_BUFFER_FORMAT, testProducerWithPsetDescEmpty_cfi::x1, and testProducerWithPsetDescEmpty_cfi::x2.

                                                                                                {
   if ((register_value & 0xF) == 0x1) {
     return sistrip::FULL_DEBUG_FORMAT;
   } else if ((register_value & 0xF) == 0x2) {
     return sistrip::APV_ERROR_FORMAT;
   } else if ((register_value & 0xF) == 0x0) {
     return sistrip::UNDEFINED_FED_BUFFER_FORMAT;
   } else {
     return sistrip::UNKNOWN_FED_BUFFER_FORMAT;
   }
 }

◆ fedReadoutMode()

sistrip::FedReadoutMode sistrip::RawToDigiUnpacker::fedReadoutMode ( const uint16_t & register_value )

inlineprivate

returns buffer readout mode

Definition at line 191 of file SiStripRawToDigiUnpacker.h.

                                                                                              {
   return static_cast<sistrip::FedReadoutMode>(register_value & 0xF);
 }

◆ legacy()

void sistrip::RawToDigiUnpacker::legacy ( bool legacy )

inline

Definition at line 209 of file SiStripRawToDigiUnpacker.h.

Referenced by sistrip::RawToDigiModule::RawToDigiModule().

209 { legacy_ = legacy; }

sistrip::RawToDigiUnpacker::legacy

void legacy(bool)

Definition: SiStripRawToDigiUnpacker.h:209

sistrip::RawToDigiUnpacker::legacy_

bool legacy_

Definition: SiStripRawToDigiUnpacker.h:148

◆ locateStartOfFedBuffer()

void sistrip::RawToDigiUnpacker::locateStartOfFedBuffer	(	const uint16_t &	fed_id,
		const FEDRawData &	input,
		FEDRawData &	output
	)

Removes any data appended prior to FED buffer and reorders 32-bit words if swapped.

Definition at line 840 of file SiStripRawToDigiUnpacker.cc.

References TauDecayModes::dec, funct::false, newFWLiteAna::found, headerBytes_, input, edm::isDebugEnabled(), LogTrace, sistrip::mlRawToDigi_, hltrates_dqm_sourceclient-live_cfg::offset, convertSQLitetoXML_cfg::output, and contentValuesCheck::ss.

                                                                                                                     {
     // Check size of input buffer
     if (input.size() < 24) {
       output.resize(input.size());  // Return UNadjusted buffer start position and size
       memcpy(output.data(), input.data(), input.size());
       if (edm::isDebugEnabled()) {
         std::stringstream ss;
         ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "] "
            << "Input FEDRawData with FED id " << fed_id << " has size " << input.size();
         edm::LogWarning(sistrip::mlRawToDigi_) << ss.str();
       }
       return;
     }
 
     // Iterator through buffer to find DAQ header
     bool found = false;
     uint16_t ichar = 0;
     while (ichar < input.size() - 16 && !found) {
       uint16_t offset =
           headerBytes_ < 0 ? ichar : headerBytes_;  // Negative value means use "search mode" to find DAQ header
       const uint32_t* input_u32 = reinterpret_cast<const uint32_t*>(input.data() + offset);
       const uint32_t* fed_trailer = reinterpret_cast<const uint32_t*>(input.data() + input.size() - 8);
 
       // see info on FED 32-bit swapping at end-of-file
 
       bool old_vme_header = (input_u32[0] & 0xF0000000) == 0x50000000 && (fed_trailer[0] & 0xF0000000) == 0xA0000000 &&
                             ((fed_trailer[0] & 0x00FFFFFF) * 0x8) == (input.size() - offset);
 
       bool old_slink_header = (input_u32[1] & 0xF0000000) == 0x50000000 &&
                               (fed_trailer[1] & 0xF0000000) == 0xA0000000 &&
                               ((fed_trailer[1] & 0x00FFFFFF) * 0x8) == (input.size() - offset);
 
       bool old_slink_payload = (input_u32[3] & 0xFF000000) == 0xED000000;
 
       bool new_buffer_format = (input_u32[2] & 0xFF000000) == 0xC5000000;
 
       if (old_vme_header) {
         // Found DAQ header at byte position 'offset'
         found = true;
         output.resize(input.size() - offset);
         memcpy(output.data(),           // target
                input.data() + offset,   // source
                input.size() - offset);  // nbytes
         if (headerBytes_ < 0) {
           if (edm::isDebugEnabled()) {
             std::stringstream ss;
             ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
                << " Buffer for FED id " << fed_id << " has been found at byte position " << offset << " with a size of "
                << input.size() - offset << " bytes."
                << " Adjust the configurable 'AppendedBytes' to " << offset;
             LogTrace("SiStripRawToDigi") << ss.str();
           }
         }
 
       } else if (old_slink_header) {
         if (old_slink_payload) {
           // Found DAQ header (with MSB and LSB 32-bit words swapped) at byte position 'offset'
           found = true;
           output.resize(input.size() - offset);
           uint32_t* output_u32 = reinterpret_cast<uint32_t*>(output.data());
           uint16_t iter = offset;
           while (iter < output.size() / sizeof(uint32_t)) {
             output_u32[iter] = input_u32[iter + 1];
             output_u32[iter + 1] = input_u32[iter];
             iter += 2;
           }
           if (headerBytes_ < 0) {
             if (edm::isDebugEnabled()) {
               std::stringstream ss;
               ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
                  << " Buffer (with MSB and LSB 32-bit words swapped) for FED id " << fed_id
                  << " has been found at byte position " << offset << " with a size of " << output.size() << " bytes."
                  << " Adjust the configurable 'AppendedBytes' to " << offset;
               LogTrace("SiStripRawToDigi") << ss.str();
             }
           }
 
         } else if (new_buffer_format) {
           // Found DAQ header at byte position 'offset'
           found = true;
           output.resize(input.size() - offset);
           memcpy(output.data(),           // target
                  input.data() + offset,   // source
                  input.size() - offset);  // nbytes
           if (headerBytes_ < 0) {
             if (edm::isDebugEnabled()) {
               std::stringstream ss;
               ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
                  << " Buffer for FED id " << fed_id << " has been found at byte position " << offset
                  << " with a size of " << input.size() - offset << " bytes."
                  << " Adjust the configurable 'AppendedBytes' to " << offset;
               LogTrace("SiStripRawToDigi") << ss.str();
             }
           }
 
         } else {
           headerBytes_ < 0 ? found = false : found = true;
         }
       } else {
         headerBytes_ < 0 ? found = false : found = true;
       }
       ichar++;
     }
 
     // Check size of output buffer
     if (output.size() == 0) {
       // Did not find DAQ header after search => return buffer with null size
       output.resize(0);                        //@@ NULL SIZE
       memcpy(output.data(), input.data(), 0);  //@@ NULL SIZE
       if (edm::isDebugEnabled()) {
         std::stringstream ss;
         if (headerBytes_ < 0) {
           ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
              << " DAQ header not found within buffer for FED id: " << fed_id;
         } else {
           const uint32_t* input_u32 = reinterpret_cast<const uint32_t*>(input.data());
           ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
              << " DAQ header not found at expected location for FED id: " << fed_id << std::endl
              << " First 64-bit word of buffer is 0x" << std::hex << std::setfill('0') << std::setw(8) << input_u32[0]
              << std::setfill('0') << std::setw(8) << input_u32[1] << std::dec << std::endl
              << " Adjust 'AppendedBytes' configurable to '-1' to activate 'search mode'";
         }
         edm::LogWarning(sistrip::mlRawToDigi_) << ss.str();
       }
 
     } else if (output.size() < 24) {  // Found DAQ header after search, but too few words
 
       if (edm::isDebugEnabled()) {
         std::stringstream ss;
         ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
            << " Unexpected buffer size! FEDRawData with FED id " << fed_id << " has size " << output.size();
         edm::LogWarning(sistrip::mlRawToDigi_) << ss.str();
       }
     }
   }

◆ physicalOrder()

void sistrip::RawToDigiUnpacker::physicalOrder	(	uint16_t &	readout_order,
		uint16_t &	physical_order
	)

inlineprivate

order of strips

Definition at line 174 of file SiStripRawToDigiUnpacker.h.

                                                                                               {
   physical_order = ((32 * (readout_order % 4)) + (8 * static_cast<uint16_t>(static_cast<float>(readout_order) / 4.0)) -
                     (31 * static_cast<uint16_t>(static_cast<float>(readout_order) / 16.0)));
 }

◆ printWarningSummary()

void sistrip::RawToDigiUnpacker::printWarningSummary ( ) const

inline

Definition at line 85 of file SiStripRawToDigiUnpacker.h.

Referenced by sistrip::RawToDigiModule::endStream().

85 { warnings_.printSummary(); }

sistrip::RawToDigiUnpacker::warnings_

WarningSummary warnings_

Definition: SiStripRawToDigiUnpacker.h:165

sistrip::WarningSummary::printSummary

void printSummary() const

Definition: WarningSummary.cc:22

◆ quiet()

void sistrip::RawToDigiUnpacker::quiet ( bool quiet )

inline

verbosity

Definition at line 195 of file SiStripRawToDigiUnpacker.h.

Referenced by sistrip::RawToDigiModule::RawToDigiModule().

195 { quiet_ = quiet; }

sistrip::RawToDigiUnpacker::quiet_

bool quiet_

Definition: SiStripRawToDigiUnpacker.h:144

sistrip::RawToDigiUnpacker::quiet

void quiet(bool)

verbosity

Definition: SiStripRawToDigiUnpacker.h:195

◆ readoutOrder()

void sistrip::RawToDigiUnpacker::readoutOrder	(	uint16_t &	physical_order,
		uint16_t &	readout_order
	)

inlineprivate

order of strips

Definition at line 169 of file SiStripRawToDigiUnpacker.h.

                                                                                              {
   readout_order = (4 * ((static_cast<uint16_t>((static_cast<float>(physical_order) / 8.0))) % 4) +
                    static_cast<uint16_t>(static_cast<float>(physical_order) / 32.0) + 16 * (physical_order % 8));
 }

◆ triggerFed()

void sistrip::RawToDigiUnpacker::triggerFed	(	const FEDRawDataCollection &	buffers,
		SiStripEventSummary &	summary,
		const uint32_t &	event
	)

trigger info

Definition at line 727 of file SiStripRawToDigiUnpacker.cc.

References FEDRawData::data(), FEDRawDataCollection::FEDData(), RecoTauValidation_cfi::header, edm::isDebugEnabled(), FEDNumbering::lastFEDId(), FEDHeader::length, FEDTrailer::length, LogTrace, sistrip::mlRawToDigi_, once_, FEDRawData::size(), contentValuesCheck::ss, edmLumisInFiles::summary, groupFilesInBlocks::temp, and triggerFedId_.

Referenced by sistrip::RawToDigiModule::produce().

                                                             {
     // Pointer to data (recast as 32-bit words) and number of 32-bit words
     const uint32_t* data_u32 = nullptr;
     uint32_t size_u32 = 0;
 
     // Search mode
     if (triggerFedId_ < 0) {
       uint16_t ifed = 0;
       while (triggerFedId_ < 0 && ifed < 1 + FEDNumbering::lastFEDId()) {
         const FEDRawData& trigger_fed = buffers.FEDData(ifed);
         if (trigger_fed.data() && trigger_fed.size()) {
           const uint8_t* temp = trigger_fed.data();
           data_u32 = reinterpret_cast<const uint32_t*>(temp) + FEDHeader::length / sizeof(uint32_t) + 1;
           size_u32 = trigger_fed.size() / sizeof(uint32_t) - FEDHeader::length / sizeof(uint32_t) - 1;
           const FEDTrailer fedTrailer(temp + trigger_fed.size() - FEDTrailer::length);
           if (fedTrailer.conscheck() == 0xDEADFACE) {
             triggerFedId_ = ifed;
             if (edm::isDebugEnabled()) {
               std::stringstream ss;
               ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
                  << " Search mode for 'trigger FED' activated!"
                  << " Found 'trigger FED' info with id " << triggerFedId_;
               LogTrace("SiStripRawToDigi") << ss.str();
             }
           }
         }
         ifed++;
       }
       if (triggerFedId_ < 0) {
         triggerFedId_ = 0;
         if (edm::isDebugEnabled()) {
           std::stringstream ss;
           ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
              << " Search mode for 'trigger FED' activated!"
              << " 'Trigger FED' info not found!";
           edm::LogWarning(sistrip::mlRawToDigi_) << ss.str();
         }
       }
     }
 
     // "Trigger FED" id given in .cfg file
     else if (triggerFedId_ > 0) {
       const FEDRawData& trigger_fed = buffers.FEDData(triggerFedId_);
       if (trigger_fed.data() && trigger_fed.size()) {
         const uint8_t* temp = trigger_fed.data();
         data_u32 = reinterpret_cast<const uint32_t*>(temp) + FEDHeader::length / sizeof(uint32_t) + 1;
         size_u32 = trigger_fed.size() / sizeof(uint32_t) - FEDHeader::length / sizeof(uint32_t) - 1;
         const FEDTrailer fedTrailer(temp + trigger_fed.size() - FEDTrailer::length);
         if (fedTrailer.conscheck() != 0xDEADFACE) {
           if (edm::isDebugEnabled()) {
             edm::LogWarning(sistrip::mlRawToDigi_) << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
                                                    << " Unexpected stamp found in DAQ trailer (ie, not 0xDEADFACE)!"
                                                    << " Buffer appears not to contain 'trigger FED' data!";
           }
           triggerFedId_ = 0;
         }
       }
 
     } else {
       triggerFedId_ = 0;
       data_u32 = nullptr;
       size_u32 = 0;
     }
 
     // Populate summary object with commissioning information
     if (triggerFedId_ > 0) {
       // Some checks
       if (!data_u32) {
         if (edm::isDebugEnabled()) {
           std::stringstream ss;
           ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
              << " NULL pointer to 'trigger FED' data";
           edm::LogWarning(sistrip::mlRawToDigi_) << ss.str();
         }
         return;
       }
       if (size_u32 < sizeof(TFHeaderDescription) / sizeof(uint32_t)) {
         if (edm::isDebugEnabled()) {
           std::stringstream ss;
           ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
              << " Unexpected 'Trigger FED' data size [32-bit words]: " << size_u32;
           edm::LogWarning(sistrip::mlRawToDigi_) << ss.str();
         }
         return;
       }
 
       // Write event-specific data to event
       const TFHeaderDescription* header = (const TFHeaderDescription*)data_u32;
       summary.event(static_cast<uint32_t>(header->getFedEventNumber()));
       summary.bx(static_cast<uint32_t>(header->getBunchCrossing()));
 
       // Write commissioning information to event
       uint32_t hsize = sizeof(TFHeaderDescription) / sizeof(uint32_t);
       const uint32_t* head = &data_u32[hsize];
       summary.commissioningInfo(head, event);
       summary.triggerFed(triggerFedId_);
     }
 
     // Some debug
     if (summary.isSet() && once_) {
       if (edm::isDebugEnabled()) {
         std::stringstream ss;
         ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
            << " EventSummary built from \"trigger FED\":" << std::endl
            << summary;
         LogTrace("SiStripRawToDigi") << ss.str();
       }
       once_ = false;
     }
   }

◆ update()

void sistrip::RawToDigiUnpacker::update	(	RawDigis &	scope_mode,
		RawDigis &	virgin_raw,
		RawDigis &	proc_raw,
		Digis &	zero_suppr,
		RawDigis &	common_mode
	)

private

fill DetSetVectors using registries

Definition at line 409 of file SiStripRawToDigiUnpacker.cc.

References cm_work_digis_, cm_work_registry_, filterCSVwithJSON::copy, mps_fire::end, Exception, extractCm_, SiStripPI::min, proc_work_digis_, proc_work_registry_, scope_work_digis_, scope_work_registry_, jetUpdater_cfi::sort, edm::DetSetVector< T >::swap(), virgin_work_digis_, virgin_work_registry_, zs_work_digis_, and zs_work_registry_.

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), createDigis(), progressbar.ProgressBar::finish(), and MatrixUtil.Steps::overwrite().

                                                                                                                 {
     if (!zs_work_registry_.empty()) {
       std::sort(zs_work_registry_.begin(), zs_work_registry_.end());
       std::vector<edm::DetSet<SiStripDigi> > sorted_and_merged;
       sorted_and_merged.reserve(std::min(zs_work_registry_.size(), size_t(17000)));
 
       bool errorInData = false;
       std::vector<Registry>::iterator it = zs_work_registry_.begin(), it2 = it + 1, end = zs_work_registry_.end();
       while (it < end) {
         sorted_and_merged.push_back(edm::DetSet<SiStripDigi>(it->detid));
         std::vector<SiStripDigi>& digis = sorted_and_merged.back().data;
         // first count how many digis we have
         size_t len = it->length;
         for (it2 = it + 1; (it2 != end) && (it2->detid == it->detid); ++it2) {
           len += it2->length;
         }
         // reserve memory
         digis.reserve(len);
         // push them in
         for (it2 = it + 0; (it2 != end) && (it2->detid == it->detid); ++it2) {
           digis.insert(digis.end(), &zs_work_digis_[it2->index], &zs_work_digis_[it2->index + it2->length]);
         }
         it = it2;
       }
 
       // check sorting
       if (!__gnu_cxx::is_sorted(sorted_and_merged.begin(), sorted_and_merged.end())) {
         // this is an error in the code: i DID sort it already!
         throw cms::Exception("Bug Found")
             << "Container must be already sorted!\nat " << __FILE__ << ", line " << __LINE__ << "\n";
       }
 
       std::vector<edm::DetSet<SiStripDigi> >::iterator iii = sorted_and_merged.begin();
       std::vector<edm::DetSet<SiStripDigi> >::iterator jjj = sorted_and_merged.end();
       for (; iii != jjj; ++iii) {
         if (!__gnu_cxx::is_sorted(iii->begin(), iii->end())) {
           // this might be an error in the data, if the raws from one FED are not sorted
           iii->clear();
           errorInData = true;
         }
       }
 
       // output error
       if (errorInData)
         edm::LogWarning("CorruptData")
             << "Some modules contained corrupted ZS raw data, and have been skipped in unpacking\n";
 
       // make output DetSetVector
       edm::DetSetVector<SiStripDigi> zero_suppr_dsv(sorted_and_merged, true);
       zero_suppr.swap(zero_suppr_dsv);
     }
 
     // Populate final DetSetVector container with VR data
     if (!virgin_work_registry_.empty()) {
       std::sort(virgin_work_registry_.begin(), virgin_work_registry_.end());
 
       std::vector<edm::DetSet<SiStripRawDigi> > sorted_and_merged;
       sorted_and_merged.reserve(std::min(virgin_work_registry_.size(), size_t(17000)));
 
       bool errorInData = false;
       std::vector<Registry>::iterator it = virgin_work_registry_.begin(), it2, end = virgin_work_registry_.end();
       while (it < end) {
         sorted_and_merged.push_back(edm::DetSet<SiStripRawDigi>(it->detid));
         std::vector<SiStripRawDigi>& digis = sorted_and_merged.back().data;
 
         bool isDetOk = true;
         // first count how many digis we have
         int maxFirstStrip = it->first;
         for (it2 = it + 1; (it2 != end) && (it2->detid == it->detid); ++it2) {
           // duplicated APV or data corruption. DO NOT 'break' here!
           if (it2->first <= maxFirstStrip) {
             isDetOk = false;
             continue;
           }
           maxFirstStrip = it2->first;
         }
         if (!isDetOk) {
           errorInData = true;
           it = it2;
           continue;
         }  // skip whole det
 
         // make room for 256 * (max_apv_pair + 1) Raw Digis
         digis.resize(maxFirstStrip + 256);
         // push them in
         for (it2 = it + 0; (it2 != end) && (it2->detid == it->detid); ++it2) {
           // data corruption. DO NOT 'break' here
           if (it->length != 256) {
             isDetOk = false;
             continue;
           }
           std::copy(&virgin_work_digis_[it2->index], &virgin_work_digis_[it2->index + it2->length], &digis[it2->first]);
         }
         if (!isDetOk) {
           errorInData = true;
           digis.clear();
           it = it2;
           continue;
         }  // skip whole det
         it = it2;
       }
 
       // output error
       if (errorInData)
         edm::LogWarning("CorruptData")
             << "Some modules contained corrupted virgin raw data, and have been skipped in unpacking\n";
 
       // check sorting
       if (!__gnu_cxx::is_sorted(sorted_and_merged.begin(), sorted_and_merged.end())) {
         // this is an error in the code: i DID sort it already!
         throw cms::Exception("Bug Found")
             << "Container must be already sorted!\nat " << __FILE__ << ", line " << __LINE__ << "\n";
       }
 
       // make output DetSetVector
       edm::DetSetVector<SiStripRawDigi> virgin_raw_dsv(sorted_and_merged, true);
       virgin_raw.swap(virgin_raw_dsv);
     }
 
     // Populate final DetSetVector container with VR data
     if (!proc_work_registry_.empty()) {
       std::sort(proc_work_registry_.begin(), proc_work_registry_.end());
 
       std::vector<edm::DetSet<SiStripRawDigi> > sorted_and_merged;
       sorted_and_merged.reserve(std::min(proc_work_registry_.size(), size_t(17000)));
 
       bool errorInData = false;
       std::vector<Registry>::iterator it = proc_work_registry_.begin(), it2, end = proc_work_registry_.end();
       while (it < end) {
         sorted_and_merged.push_back(edm::DetSet<SiStripRawDigi>(it->detid));
         std::vector<SiStripRawDigi>& digis = sorted_and_merged.back().data;
 
         bool isDetOk = true;
         // first count how many digis we have
         int maxFirstStrip = it->first;
         for (it2 = it + 1; (it2 != end) && (it2->detid == it->detid); ++it2) {
           // duplicated APV or data corruption. DO NOT 'break' here!
           if (it2->first <= maxFirstStrip) {
             isDetOk = false;
             continue;
           }
           maxFirstStrip = it2->first;
         }
         // skip whole det
         if (!isDetOk) {
           errorInData = true;
           it = it2;
           continue;
         }
 
         // make room for 256 * (max_apv_pair + 1) Raw Digis
         digis.resize(maxFirstStrip + 256);
         // push them in
         for (it2 = it + 0; (it2 != end) && (it2->detid == it->detid); ++it2) {
           // data corruption. DO NOT 'break' here
           if (it->length != 256) {
             isDetOk = false;
             continue;
           }
           std::copy(&proc_work_digis_[it2->index], &proc_work_digis_[it2->index + it2->length], &digis[it2->first]);
         }
         // skip whole det
         if (!isDetOk) {
           errorInData = true;
           digis.clear();
           it = it2;
           continue;
         }
         it = it2;
       }
 
       // output error
       if (errorInData)
         edm::LogWarning("CorruptData")
             << "Some modules contained corrupted proc raw data, and have been skipped in unpacking\n";
 
       // check sorting
       if (!__gnu_cxx::is_sorted(sorted_and_merged.begin(), sorted_and_merged.end())) {
         // this is an error in the code: i DID sort it already!
         throw cms::Exception("Bug Found")
             << "Container must be already sorted!\nat " << __FILE__ << ", line " << __LINE__ << "\n";
       }
 
       // make output DetSetVector
       edm::DetSetVector<SiStripRawDigi> proc_raw_dsv(sorted_and_merged, true);
       proc_raw.swap(proc_raw_dsv);
     }
 
     // Populate final DetSetVector container with SM data
     if (!scope_work_registry_.empty()) {
       std::sort(scope_work_registry_.begin(), scope_work_registry_.end());
 
       std::vector<edm::DetSet<SiStripRawDigi> > sorted_and_merged;
       sorted_and_merged.reserve(scope_work_registry_.size());
 
       bool errorInData = false;
       std::vector<Registry>::iterator it, end;
       for (it = scope_work_registry_.begin(), end = scope_work_registry_.end(); it != end; ++it) {
         sorted_and_merged.push_back(edm::DetSet<SiStripRawDigi>(it->detid));
         std::vector<SiStripRawDigi>& digis = sorted_and_merged.back().data;
         digis.insert(digis.end(), &scope_work_digis_[it->index], &scope_work_digis_[it->index + it->length]);
 
         if ((it + 1 != end) && (it->detid == (it + 1)->detid)) {
           errorInData = true;
           // let's skip *all* the detsets for that key, as we don't know which is the correct one!
           do {
             ++it;
           } while ((it + 1 != end) && (it->detid == (it + 1)->detid));
         }
       }
 
       // output error
       if (errorInData)
         edm::LogWarning("CorruptData")
             << "Some fed keys contained corrupted scope mode data, and have been skipped in unpacking\n";
 
       // check sorting
       if (!__gnu_cxx::is_sorted(sorted_and_merged.begin(), sorted_and_merged.end())) {
         // this is an error in the code: i DID sort it already!
         throw cms::Exception("Bug Found")
             << "Container must be already sorted!\nat " << __FILE__ << ", line " << __LINE__ << "\n";
       }
 
       // make output DetSetVector
       edm::DetSetVector<SiStripRawDigi> scope_mode_dsv(sorted_and_merged, true);
       scope_mode.swap(scope_mode_dsv);
     }
 
     // Populate DetSetVector with Common Mode values
     if (extractCm_) {
       // Populate final DetSetVector container with VR data
       if (!cm_work_registry_.empty()) {
         std::sort(cm_work_registry_.begin(), cm_work_registry_.end());
 
         std::vector<edm::DetSet<SiStripRawDigi> > sorted_and_merged;
         sorted_and_merged.reserve(std::min(cm_work_registry_.size(), size_t(17000)));
 
         bool errorInData = false;
         std::vector<Registry>::iterator it = cm_work_registry_.begin(), it2, end = cm_work_registry_.end();
         while (it < end) {
           sorted_and_merged.push_back(edm::DetSet<SiStripRawDigi>(it->detid));
           std::vector<SiStripRawDigi>& digis = sorted_and_merged.back().data;
 
           bool isDetOk = true;
           // first count how many digis we have
           int maxFirstStrip = it->first;
           for (it2 = it + 1; (it2 != end) && (it2->detid == it->detid); ++it2) {
             // duplicated APV or data corruption. DO NOT 'break' here!
             if (it2->first <= maxFirstStrip) {
               isDetOk = false;
               continue;
             }
             maxFirstStrip = it2->first;
           }
           if (!isDetOk) {
             errorInData = true;
             it = it2;
             continue;
           }  // skip whole det
 
           // make room for 2 * (max_apv_pair + 1) Common mode values
           digis.resize(maxFirstStrip + 2);
           // push them in
           for (it2 = it + 0; (it2 != end) && (it2->detid == it->detid); ++it2) {
             // data corruption. DO NOT 'break' here
             if (it->length != 2) {
               isDetOk = false;
               continue;
             }
             std::copy(&cm_work_digis_[it2->index], &cm_work_digis_[it2->index + it2->length], &digis[it2->first]);
           }
           if (!isDetOk) {
             errorInData = true;
             digis.clear();
             it = it2;
             continue;
           }  // skip whole det
           it = it2;
         }
 
         // output error
         if (errorInData)
           edm::LogWarning("CorruptData")
               << "Some modules contained corrupted common mode data, and have been skipped in unpacking\n";
 
         // check sorting
         if (!__gnu_cxx::is_sorted(sorted_and_merged.begin(), sorted_and_merged.end())) {
           // this is an error in the code: i DID sort it already!
           throw cms::Exception("Bug Found")
               << "Container must be already sorted!\nat " << __FILE__ << ", line " << __LINE__ << "\n";
         }
 
         // make output DetSetVector
         edm::DetSetVector<SiStripRawDigi> common_mode_dsv(sorted_and_merged, true);
         common_mode.swap(common_mode_dsv);
       }
     }
   }

◆ updateEventSummary()

void sistrip::RawToDigiUnpacker::updateEventSummary	(	const sistrip::FEDBuffer &	fed,
		SiStripEventSummary &	summary
	)

private

sets the SiStripEventSummary -> not yet implemented for FEDBuffer class

Definition at line 976 of file SiStripRawToDigiUnpacker.cc.

References sistrip::FEDDAQHeader::bxID(), sistrip::FEDBufferBase::daqEventType(), sistrip::FEDBufferBase::daqHeader(), sistrip::FEDBuffer::feHeader(), RecoTauValidation_cfi::header, sistrip::HEADER_TYPE_FULL_DEBUG, sistrip::FEDBufferBase::headerType(), sistrip::invalid32_, edm::isDebugEnabled(), sistrip::FEDDAQHeader::l1ID(), LogTrace, once_, contentValuesCheck::ss, edmLumisInFiles::summary, and triggerFedId_.

Referenced by createDigis().

                                                                                                       {
     summary.event(fed.daqHeader().l1ID());
     summary.bx(fed.daqHeader().bxID());
 
     // Retrieve contents of DAQ registers
 
     sistrip::FEDDAQEventType readout_mode = fed.daqEventType();
     uint32_t daq1 = sistrip::invalid32_;
     uint32_t daq2 = sistrip::invalid32_;
 
     if (fed.headerType() == sistrip::HEADER_TYPE_FULL_DEBUG) {
       const sistrip::FEDFullDebugHeader* header = nullptr;
       header = dynamic_cast<const sistrip::FEDFullDebugHeader*>(fed.feHeader());
       daq1 = static_cast<uint32_t>(header->daqRegister());
       daq2 = static_cast<uint32_t>(header->daqRegister2());
     }
 
     // If FED DAQ registers contain info, update (and possibly overwrite) EventSummary
     if (daq1 != 0 && daq1 != sistrip::invalid32_) {
       summary.triggerFed(triggerFedId_);
       summary.fedReadoutMode(readout_mode);
       summary.commissioningInfo(daq1, daq2);
 
       if (summary.isSet() && once_) {
         if (edm::isDebugEnabled()) {
           std::stringstream ss;
           ss << "[sistrip::RawToDigiUnpacker::" << __func__ << "]"
              << " EventSummary built from FED DAQ registers:" << std::endl
              << summary;
           LogTrace("SiStripRawToDigi") << ss.str();
         }
         once_ = false;
       }
     }
   }