#include <CSCFileReader.h>

Inheritance diagram for CSCFileReader:

Public Member Functions
	CSCFileReader (const edm::ParameterSet &pset)

virtual int	fillRawData (edm::Event &e, FEDRawDataCollection *&data)

void	produce (edm::Event &, edm::EventSetup const &) override

	~CSCFileReader (void) override

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Public Attributes
bool	fFirstReadBug

Private Member Functions
int	buildEventFromRUIs (FEDRawDataCollection *data)

int	nextEventFromFUs (FEDRawDataCollection *data)

int	readFU (int fu, const unsigned short *&buf, size_t &length)

int	readRUI (int rui, const unsigned short *&buf, size_t &length)

Private Attributes
std::vector< std::string >::const_iterator	currentFile [40]

int	currentL1A [40]

int	expectedNextL1A

std::map< unsigned int, std::list< unsigned int > >	FED

std::vector< std::string >	fileNames [40]

int	firstEvent

FileReaderDCC	FU [4]

const unsigned short *	fuEvent [4]

size_t	fuEventSize [4]

int	nActiveFUs

int	nActiveRUIs

int	nEvents

const unsigned short *	ruBuf [40]

size_t	ruBufSize [40]

FileReaderDDU	RUI [40]

unsigned int	runNumber

int	tfDDUnumber

unsigned short *	tmpBuf

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Definition at line 19 of file CSCFileReader.h.

Constructor & Destructor Documentation

◆ CSCFileReader()

CSCFileReader::CSCFileReader ( const edm::ParameterSet & pset )

Legacy first read EDM EvendID bug (fixed?). Currently disabled to fix number of events with data Added as configurable parameter

Definition at line 33 of file CSCFileReader.cc.

                                                         {
   runNumber = pset.getUntrackedParameter<unsigned int>("runNumber", 1);
   LogDebug("CSCFileReader|ctor") << "Started ...";
   // Below some data members are recycled for both cases: RUIs and FUs
   //  this is ok as long as eighter of RUI or FU are are provided in .cfg (not both)
   nActiveRUIs = 0;
   nActiveFUs = 0;
  
   // fFirstReadBug = true;
   fFirstReadBug = pset.getUntrackedParameter<bool>("FirstReadBug", false);
   for (int unit = 0; unit < nRUIs; unit++) {
     std::ostringstream ruiName, fuName;
     ruiName << "RUI" << (unit < 10 ? "0" : "") << unit << std::ends;
     fuName << "FU" << unit << std::ends;
     std::vector<std::string> ruiFiles =
         pset.getUntrackedParameter<std::vector<std::string> >(ruiName.str().c_str(), std::vector<std::string>(0));
     std::vector<std::string> fuFiles =
         pset.getUntrackedParameter<std::vector<std::string> >(fuName.str().c_str(), std::vector<std::string>(0));
     if (ruiFiles.begin() != ruiFiles.end())
       nActiveRUIs++;
     if (fuFiles.begin() != fuFiles.end())
       nActiveFUs++;
   }
   if (nActiveFUs && nActiveRUIs)
     throw cms::Exception("CSCFileReader|configuration")
         << "RUIs and FUs in conflict: either RUI or FU may be defined at a time, not both";
   if (!nActiveFUs && !nActiveRUIs)
     throw cms::Exception("CSCFileReader|configuration") << "Module lacks configuration";
  
   // Get list of RUI input files from cfg file
   for (int rui = 0; rui < nRUIs && !nActiveFUs; rui++) {
     std::ostringstream name;
     name << "RUI" << (rui < 10 ? "0" : "") << rui << std::ends;
  
     // Obtain list of files associated with current RUI
     fileNames[rui] =
         pset.getUntrackedParameter<std::vector<std::string> >(name.str().c_str(), std::vector<std::string>(0));
     currentFile[rui] = fileNames[rui].begin();
  
     // If list of files is not empty, open first file
     if (currentFile[rui] != fileNames[rui].end()) {
       try {
         RUI[rui].open(currentFile[rui]->c_str());
       } catch (std::runtime_error &err) {
         throw cms::Exception("CSCFileReader") << "InputFileMissing: " << err.what() << " (errno=" << errno << ")";
       }
       nActiveRUIs++;
     }
  
     // Filter out possible corruptions
     RUI[rui].reject(FileReaderDDU::DDUoversize | FileReaderDDU::FFFF | FileReaderDDU::Unknown);
     // Do not select anything in particular
     RUI[rui].select(0);
  
     currentL1A[rui] = -1;
   }
  
   // Get list of FU input files from .cfg file
   for (int fu = 0; fu < nFUs && !nActiveRUIs; fu++) {
     std::ostringstream name;
     name << "FU" << fu << std::ends;
  
     // Obtain list of files associated with current FU
     fileNames[fu] =
         pset.getUntrackedParameter<std::vector<std::string> >(name.str().c_str(), std::vector<std::string>(0));
     currentFile[fu] = fileNames[fu].begin();
  
     // If list of files is not empty, open first file
     if (currentFile[fu] != fileNames[fu].end()) {
       try {
         FU[fu].open(currentFile[fu]->c_str());
       } catch (std::runtime_error &err) {
         throw cms::Exception("CSCFileReader") << "InputFileMissing: " << err.what() << " (errno=" << errno << ")";
       }
       nActiveFUs++;
     }
  
     // Filter out possible corruptions
     FU[fu].reject(FileReaderDCC::DCCoversize | FileReaderDCC::FFFF | FileReaderDCC::Unknown);
     // Do not select anything in particular
     FU[fu].select(0);
  
     currentL1A[fu] = -1;
   }
  
   if (nActiveRUIs && !nActiveFUs) {
     // Assign RUIs to FEDs
     for (int fed = FEDNumbering::MINCSCFEDID; fed <= FEDNumbering::MAXCSCFEDID; fed++) {
       std::ostringstream name;
       name << "FED" << fed << std::ends;
       std::vector<std::string> rui_list =
           pset.getUntrackedParameter<std::vector<std::string> >(name.str().c_str(), std::vector<std::string>(0));
       for (std::vector<std::string>::const_iterator rui = rui_list.begin(); rui != rui_list.end(); rui++)
         FED[fed].push_back((unsigned int)atoi(rui->c_str() + rui->length() - 2));
     }
     for (int fed = FEDNumbering::MINCSCDDUFEDID; fed <= FEDNumbering::MAXCSCDDUFEDID; fed++) {
       std::ostringstream name;
       name << "FED" << fed << std::ends;
       std::vector<std::string> rui_list =
           pset.getUntrackedParameter<std::vector<std::string> >(name.str().c_str(), std::vector<std::string>(0));
       for (std::vector<std::string>::const_iterator rui = rui_list.begin(); rui != rui_list.end(); rui++)
         FED[fed].push_back((unsigned int)atoi(rui->c_str() + rui->length() - 2));
     }
  
     // Do the same for Track-Finder FED
     for (int fed = FEDNumbering::MINCSCTFFEDID; fed <= FEDNumbering::MAXCSCTFFEDID; fed++) {
       std::ostringstream name;
       name << "FED" << fed << std::ends;
       std::vector<std::string> rui_list =
           pset.getUntrackedParameter<std::vector<std::string> >(name.str().c_str(), std::vector<std::string>(0));
       for (std::vector<std::string>::const_iterator rui = rui_list.begin(); rui != rui_list.end(); rui++)
         FED[fed].push_back((unsigned int)atoi(rui->c_str() + rui->length() - 2));
     }
   }
   // Starting point
   firstEvent = pset.getUntrackedParameter<int>("firstEvent", 0);
   nEvents = 0;
   expectedNextL1A = -1;
  
   // If Track-Finder was in readout specify its position in the record or set -1 otherwise
   //  Current agriment is that if there is a TF event it is first DDU record
   tfDDUnumber = pset.getUntrackedParameter<int>("tfDDUnumber", -1);
  
   // For efficiency reasons create this big chunk of data only once
   tmpBuf = new unsigned short[200000 * nRUIs + 4 * 4];
   // Event buffer and its length for every FU
   fuEvent[0] = nullptr;
   fuEventSize[0] = 0;
   fuEvent[1] = nullptr;
   fuEventSize[1] = 0;
   fuEvent[2] = nullptr;
   fuEventSize[2] = 0;
   fuEvent[3] = nullptr;
   fuEventSize[3] = 0;
   // Event buffer and its length for every RU
   for (int rui = 0; rui < nRUIs; rui++) {
     ruBuf[rui] = nullptr;
     ruBufSize[rui] = 0;
   }
   LogDebug("CSCFileReader|ctor") << "... and finished";
   produces<FEDRawDataCollection>();
 }

References currentFile, currentL1A, FileReaderDCC::DCCoversize, FileReaderDDU::DDUoversize, mps_fire::end, submitPVResolutionJobs::err, Exception, expectedNextL1A, FED, FileReaderDDU::FFFF, FileReaderDCC::FFFF, fFirstReadBug, fileNames, firstEvent, FU, fuEvent, fuEventSize, LogDebug, FEDNumbering::MAXCSCDDUFEDID, FEDNumbering::MAXCSCFEDID, FEDNumbering::MAXCSCTFFEDID, FEDNumbering::MINCSCDDUFEDID, FEDNumbering::MINCSCFEDID, FEDNumbering::MINCSCTFFEDID, nActiveFUs, nActiveRUIs, Skims_PA_cff::name, nEvents, nFUs, nRUIs, FileReaderDCC::open(), FileReaderDDU::open(), muonDTDigis_cfi::pset, FileReaderDCC::reject(), FileReaderDDU::reject(), ruBuf, ruBufSize, RUI, runNumber, FileReaderDCC::select(), FileReaderDDU::select(), tfDDUnumber, tmpBuf, unit(), FileReaderDDU::Unknown, and FileReaderDCC::Unknown.

◆ ~CSCFileReader()

CSCFileReader::~CSCFileReader ( void )

override

Definition at line 179 of file CSCFileReader.cc.

                                   {
   if (tmpBuf)
     delete[] tmpBuf;
 }

References tmpBuf.

Member Function Documentation

◆ buildEventFromRUIs()

int CSCFileReader::buildEventFromRUIs ( FEDRawDataCollection * data )

private

Definition at line 235 of file CSCFileReader.cc.

                                                                 {
   int eventNumber = -1;  // Will determine below
  
   do {
     // Read next event from RUIs
     for (int rui = 0; rui < nRUIs; rui++) {
       // read event from the RUI only in two cases:
       //     1) it is readable (currentL1A>0) and we expect next event from the RUI
       //     2) it is first time (expectedNextL1A<0)
       if ((currentL1A[rui] > 0 && currentL1A[rui] < expectedNextL1A) || expectedNextL1A < 0) {
         currentL1A[rui] = readRUI(rui, ruBuf[rui], ruBufSize[rui]);
         //      std::cout << "read rui" << rui << " l1a: " << currentL1A[rui] << " size: " << ruBufSize[rui] << std::endl;
       }
     }
     eventNumber = -1;
  
     // Select lowest L1A from all RUIs and don't expect next event from RUIs that currently hold higher L1A
     for (int rui = 0; rui < nRUIs; rui++)
       if (currentL1A[rui] >= 0 && (eventNumber > currentL1A[rui] || eventNumber == -1))
         eventNumber = currentL1A[rui];
     // No readable RUIs => fall out
     if (eventNumber < 0)
       return -1;
     // Expect next event to be incremented by 1 wrt. to the current event
     expectedNextL1A = eventNumber + 1;
  
   } while (nEvents++ < firstEvent);
  
   for (std::map<unsigned int, std::list<unsigned int> >::const_iterator fed = FED.begin(); fed != FED.end(); fed++)
     if (fed->first < (unsigned int)FEDNumbering::MINCSCTFFEDID) {
       // Now let's pretend that DDU data were wrapped with DCC Header (2 64-bit words) and Trailer (2 64-bit words):
       unsigned short *dccBuf = tmpBuf, *dccCur = dccBuf;
       dccCur[3] = 0x5000;
       dccCur[2] = 0x0000;
       dccCur[1] = 0x0000;
       dccCur[0] = 0x005F;  // Fake DCC Header 1
       dccCur[7] = 0xD900;
       dccCur[6] = 0x0000;
       dccCur[5] = 0x0000;
       dccCur[4] = 0x0017;  // Fake DCC Header 2
       dccCur += 8;
  
       for (std::list<unsigned int>::const_iterator rui = fed->second.begin(); rui != fed->second.end(); rui++) {
         //cout<<"Event:"<<eventNumber<<"  FED:"<<fed->first<<"  RUI:"<<*(fed->second.begin())<<" currL1A:"<<currentL1A[*rui]<<endl;
         if (currentL1A[*rui] == eventNumber) {
           if (dccCur - dccBuf + ruBufSize[*rui] >= 200000 * nRUIs + 8)
             throw cms::Exception("CSCFileReader|eventBuffer")
                 << "OutOfBuffer: Event size exceeds maximal size allowed!";
           memcpy(dccCur, ruBuf[*rui], ruBufSize[*rui] * sizeof(unsigned short));
           dccCur += ruBufSize[*rui];
         }
       }
       dccCur[3] = 0xEF00;
       dccCur[2] = 0x0000;
       dccCur[1] = 0x0000;
       dccCur[0] = 0x0000;  // Fake DCC Trailer 2
       dccCur[7] = 0xAF00;
       dccCur[6] = 0x0000;
       dccCur[5] = 0x0000;
       dccCur[4] = 0x0007;  // Fake DCC Trailer 2
       dccCur += 8;
  
       FEDRawData &fedRawData = data->FEDData(fed->first);
       fedRawData.resize((dccCur - dccBuf) * sizeof(unsigned short));
       std::copy((unsigned char *)dccBuf, (unsigned char *)dccCur, fedRawData.data());
     } else {
       for (std::list<unsigned int>::const_iterator rui = fed->second.begin(); rui != fed->second.end(); rui++) {
         FEDRawData &fedRawData = data->FEDData(fed->first);
         fedRawData.resize(ruBufSize[*rui] * sizeof(unsigned short));
         std::copy((unsigned char *)ruBuf[*rui], (unsigned char *)(ruBuf[*rui] + ruBufSize[*rui]), fedRawData.data());
       }
     }
  
   return eventNumber;
 }

References filterCSVwithJSON::copy, currentL1A, data, Exception, expectedNextL1A, FED, l1t_dqm_sourceclient-live_cfg::fedRawData, firstEvent, genParticles_cff::map, FEDNumbering::MINCSCTFFEDID, nEvents, nRUIs, readRUI(), ruBuf, ruBufSize, and tmpBuf.

Referenced by fillRawData().

◆ fillRawData()

int CSCFileReader::fillRawData	(	edm::Event &	e,
		FEDRawDataCollection *&	data
	)

virtual

Definition at line 413 of file CSCFileReader.cc.

                                                                          {
   edm::EventID eID = e.id();
   data = new FEDRawDataCollection();
  
   if (fFirstReadBug) {
     eID = edm::EventID(runNumber, 1U, 1);
     fFirstReadBug = false;
     return true;
   }
  
   // int runNumber   = 0; // Unknown at the level of EMu local DAQ
   int eventNumber = -1;  // Will determine below
  
   if (!nActiveFUs && nActiveRUIs) {
     eventNumber = buildEventFromRUIs(data);
     //      std::cout << eventNumber << std::endl;
   } else {
     eventNumber = nextEventFromFUs(data);
   }
  
   if (eventNumber < 0)
     return false;
  
   eID = edm::EventID(runNumber, 1U, eventNumber);
  
   return true;
 }

References buildEventFromRUIs(), data, MillePedeFileConverter_cfg::e, EcalFEDMonitor_cfi::FEDRawDataCollection, fFirstReadBug, nActiveFUs, nActiveRUIs, nextEventFromFUs(), runNumber, and mitigatedMETSequence_cff::U.

Referenced by produce().

◆ nextEventFromFUs()

int CSCFileReader::nextEventFromFUs ( FEDRawDataCollection * data )

private

Definition at line 311 of file CSCFileReader.cc.

                                                               {
   int eventNumber = -1;  // Will determine below
  
   // If this is a first time - read one event from each FU
   if (expectedNextL1A < 0)
     for (int fu = 0; fu < nFUs; fu++)
       currentL1A[fu] = readFU(fu, fuEvent[fu], fuEventSize[fu]);
  
   // Keep buffers for every FU ready at all times
   // When buffer from some FU is ready to go as the next event,
   //  release it, but read next one
   int readyToGo = -1;
   for (int fu = 0; fu < nFUs; fu++) {
     // If FU is readable and (first loop of this cycle or current FU holds smallest L1A)
     if (currentL1A[fu] >= 0 && (eventNumber < 0 || currentL1A[fu] < eventNumber)) {
       readyToGo = fu;
       eventNumber = currentL1A[fu];
     }
   }
   // No readable FUs => fall out
   if (readyToGo < 0)
     return -1;
  
   expectedNextL1A = eventNumber + 1;
  
   // Compose event from DDC record striped of Track-Finder DDU and a separate TF DDU event
   unsigned long long *start = (unsigned long long *)fuEvent[readyToGo];
   unsigned long long *end = nullptr;
   enum { Header = 1, Trailer = 2 };
   unsigned int eventStatus = 0;
   for (int dduRecord = 0; dduRecord <= tfDDUnumber; dduRecord++) {
     unsigned long long word_0 = 0, word_1 = 0, word_2 = 0;
     size_t dduWordCount = 0;
     while (!end && dduWordCount < fuEventSize[readyToGo]) {
       unsigned long long *dduWord = start;
  
       while (dduWordCount < fuEventSize[readyToGo]) {
         word_0 = word_1;    // delay by 2 DDU words
         word_1 = word_2;    // delay by 1 DDU word
         word_2 = *dduWord;  // current DDU word
         if ((word_2 & 0xFFFFFFFFFFFF0000LL) == 0x8000000180000000LL) {
           if (eventStatus & Header)  // Second header
           {
             word_2 = word_1;
             end = dduWord;
             break;
           }
           start = dduWord;
         }
         if ((word_0 & 0xFFFFFFFFFFFF0000LL) == 0x8000FFFF80000000LL) {
           eventStatus |= Trailer;
           end = ++dduWord;
           break;
         }
         // Increase counters by one DDU word
         dduWord++;
         dduWordCount++;
       }
     }
     // If reach max length
     if (dduWordCount == fuEventSize[readyToGo]) {
       end = (unsigned long long *)(fuEvent[readyToGo] + fuEventSize[readyToGo]);
       break;
     }
   }
   // Include 0x5xxx preHeader if exists
   if (start > (unsigned long long *)fuEvent[readyToGo] && (*(start - 1) & 0xF000000000000000LL) == 0x5000000000000000LL)
     start--;
  
   // If Track-Finder DDU was in readout
   if (tfDDUnumber >= 0) {
     // Cut out Track-Finder DDU from the buffer
     if (!end)
       throw cms::Exception("CSCFileReader|lookingForTF") << " Sanity check failed (end==0)! Should never happen";
  
     FEDRawData &tfRawData = data->FEDData(FEDNumbering::MINCSCTFFEDID);
     tfRawData.resize((end - start) * sizeof(unsigned long long));
     std::copy((unsigned char *)start, (unsigned char *)end, tfRawData.data());
  
     // Create a new buffer from everything before and after TF DDU
     unsigned short *event = tmpBuf;
     memcpy(event, fuEvent[readyToGo], ((unsigned short *)start - fuEvent[readyToGo]) * sizeof(unsigned short));
     event += ((unsigned short *)start - fuEvent[readyToGo]);
     memcpy(event, end, (fuEvent[readyToGo] + fuEventSize[readyToGo] - (unsigned short *)end) * sizeof(unsigned short));
     event += fuEvent[readyToGo] + fuEventSize[readyToGo] - (unsigned short *)end;
     FEDRawData &fedRawData = data->FEDData(FEDNumbering::MINCSCFEDID);
     fedRawData.resize((fuEventSize[readyToGo] - ((unsigned short *)end - (unsigned short *)start)) *
                       sizeof(unsigned short));
     std::copy((unsigned char *)tmpBuf, (unsigned char *)event, fedRawData.data());
   } else {
     FEDRawData &fedRawData = data->FEDData(FEDNumbering::MINCSCFEDID);
     fedRawData.resize((fuEventSize[readyToGo]) * sizeof(unsigned short));
     std::copy((unsigned char *)fuEvent[readyToGo],
               (unsigned char *)(fuEvent[readyToGo] + fuEventSize[readyToGo]),
               fedRawData.data());
   }
  
   currentL1A[readyToGo] = readFU(readyToGo, fuEvent[readyToGo], fuEventSize[readyToGo]);
  
   return eventNumber;
 }

References filterCSVwithJSON::copy, currentL1A, FEDRawData::data(), data, mps_fire::end, Exception, expectedNextL1A, l1t_dqm_sourceclient-live_cfg::fedRawData, fuEvent, fuEventSize, L1DTConfigBti_cff::LL, FEDNumbering::MINCSCFEDID, FEDNumbering::MINCSCTFFEDID, nFUs, readFU(), FEDRawData::resize(), command_line::start, tfDDUnumber, and tmpBuf.

Referenced by fillRawData().

◆ produce()

void CSCFileReader::produce	(	edm::Event &	e,
		edm::EventSetup const &	es
	)

overridevirtual

Implements edm::EDProducer.

Definition at line 441 of file CSCFileReader.cc.

                                                                 {
   edm::Handle<FEDRawDataCollection> rawdata;
   FEDRawDataCollection *fedcoll = nullptr;
   fillRawData(e, fedcoll);
   std::unique_ptr<FEDRawDataCollection> bare_product(fedcoll);
   e.put(std::move(bare_product));
 }

References MillePedeFileConverter_cfg::e, fillRawData(), and eostools::move().

◆ readFU()

int CSCFileReader::readFU	(	int	fu,
		const unsigned short *&	buf,
		size_t &	length
	)

private

Definition at line 209 of file CSCFileReader.cc.

                                                                             {
   if (currentFile[fu] == fileNames[fu].end())
     return -1;
   do {
     try {
       length = FU[fu].next(buf);
     } catch (std::runtime_error &err) {
       throw cms::Exception("CSCFileReader|reading") << "EndOfStream: " << err.what() << " (errno=" << errno << ")";
     }
     if (length == 0)  // end of file, try next one
     {
       if (++currentFile[fu] != fileNames[fu].end()) {
         try {
           FU[fu].open(currentFile[fu]->c_str());
         } catch (std::runtime_error &err) {
           throw cms::Exception("CSCFileReader|reading")
               << "InputFileMissing: " << err.what() << " (errno=" << errno << ")";
         }
       } else
         return -1;
     }
   } while (length == 0);
   // Take L1A from first DDU header in the DCC record (shift=8)
   return buf[2 + 8] | ((buf[3 + 8] & 0xFF) << 16);
 }

References visDQMUpload::buf, currentFile, mps_fire::end, submitPVResolutionJobs::err, Exception, fileNames, FU, FileReaderDCC::next(), and FileReaderDCC::open().

Referenced by nextEventFromFUs().

◆ readRUI()

int CSCFileReader::readRUI	(	int	rui,
		const unsigned short *&	buf,
		size_t &	length
	)

private

Definition at line 184 of file CSCFileReader.cc.

                                                                               {
   if (currentFile[rui] == fileNames[rui].end())
     return -1;
   do {
     try {
       length = RUI[rui].next(buf);
     } catch (std::runtime_error &err) {
       throw cms::Exception("CSCFileReader|reading") << "EndOfStream: " << err.what() << " (errno=" << errno << ")";
     }
     if (length == 0)  // end of file, try next one
     {
       if (++currentFile[rui] != fileNames[rui].end()) {
         try {
           RUI[rui].open(currentFile[rui]->c_str());
         } catch (std::runtime_error &err) {
           throw cms::Exception("CSCFileReader|reading")
               << "InputFileMissing: " << err.what() << " (errno=" << errno << ")";
         }
       } else
         return -1;
     }
   } while (length == 0);
   return buf[2] | ((buf[3] & 0xFF) << 16);
 }