#include <CTPPSTotemDataFormatter.h>

Classes
struct	PPSStripIndex

Public Types
typedef std::vector< TotemRPDigi >	DetDigis

typedef std::unordered_map< cms_uint32_t, DetDigis >	Digis

typedef std::unordered_map< int, FEDRawData >	RawData

Public Member Functions
	CTPPSTotemDataFormatter (std::map< TotemFramePosition, TotemVFATInfo > const &mapping)

void	formatRawData (unsigned int lvl1_ID, RawData &fedRawData, const Digis &digis, std::vector< PPSStripIndex > v_iDdet2fed)

int	nDigis () const

int	nWords () const

std::string	print (const Word64 &word) const

Static Public Member Functions
static bool	compare (const PPSStripIndex &a, const PPSStripIndex &b)

Private Types
typedef uint16_t	Word16

typedef uint32_t	Word32

typedef uint64_t	Word64

Private Attributes
int	m_DigiCounter

int	m_WordCounter

Detailed Description

Definition at line 37 of file CTPPSTotemDataFormatter.h.

Member Typedef Documentation

◆ DetDigis

typedef std::vector<TotemRPDigi> CTPPSTotemDataFormatter::DetDigis

Definition at line 48 of file CTPPSTotemDataFormatter.h.

◆ Digis

typedef std::unordered_map<cms_uint32_t, DetDigis> CTPPSTotemDataFormatter::Digis

Definition at line 49 of file CTPPSTotemDataFormatter.h.

◆ RawData

typedef std::unordered_map<int, FEDRawData> CTPPSTotemDataFormatter::RawData

Definition at line 47 of file CTPPSTotemDataFormatter.h.

◆ Word16

typedef uint16_t CTPPSTotemDataFormatter::Word16

private

Definition at line 39 of file CTPPSTotemDataFormatter.h.

◆ Word32

typedef uint32_t CTPPSTotemDataFormatter::Word32

private

Definition at line 40 of file CTPPSTotemDataFormatter.h.

◆ Word64

typedef uint64_t CTPPSTotemDataFormatter::Word64

private

Definition at line 41 of file CTPPSTotemDataFormatter.h.

Constructor & Destructor Documentation

◆ CTPPSTotemDataFormatter()

CTPPSTotemDataFormatter::CTPPSTotemDataFormatter ( std::map< TotemFramePosition, TotemVFATInfo > const & mapping )

Definition at line 31 of file CTPPSTotemDataFormatter.cc.

     : m_WordCounter(0), m_DigiCounter(0) {
   int s32 = sizeof(Word32);
   int s64 = sizeof(Word64);
   int s8 = sizeof(char);
   if (s8 != 1 || s32 != 4 * s8 || s64 != 2 * s32) {
     LogError("UnexpectedSizes") << " unexpected sizes: "
                                 << "  size of char is: " << s8 << ", size of Word32 is: " << s32
                                 << ", size of Word64 is: " << s64 << ", send exception";
   }
 }

Member Function Documentation

◆ compare()

static bool CTPPSTotemDataFormatter::compare	(	const PPSStripIndex &	a,
		const PPSStripIndex &	b
	)

inlinestatic

Definition at line 69 of file CTPPSTotemDataFormatter.h.

69 { return a.id < b.id; }

References a, and b.

Referenced by formatRawData(), and CTPPSTotemDigiToRaw::produce().

◆ formatRawData()

void CTPPSTotemDataFormatter::formatRawData	(	unsigned int	lvl1_ID,
		RawData &	fedRawData,
		const Digis &	digis,
		std::vector< PPSStripIndex >	v_iDdet2fed
	)

Definition at line 43 of file CTPPSTotemDataFormatter.cc.

                                                                                 {
   std::map<int, vector<std::array<uint16_t, 12>>> words;
   for (auto const &itDig : digis) {
     int fedId;
     uint32_t rawId = itDig.first;
     const DetDigis &detDigis = itDig.second;
     std::array<uint16_t, 12> buf, bufCRC;
     std::map<uint32_t, vector<int>> mapIdCh;
     for (auto const &it : detDigis) {
       m_DigiCounter++;
       const int nCH = 128;
       int nStrip = it.stripNumber();
       int chipPosition = nStrip / nCH;
       int channel = nStrip - chipPosition * nCH;        //channel from DIGI
       uint32_t newrawId = rawId + 8192 * chipPosition;  //8192 - distance between chipIds
       mapIdCh[newrawId].push_back(channel);
     }
     for (auto &pId : mapIdCh) {
       PPSStripIndex myTest = {pId.first, 0, 0, 0, 0};
  
       // the range has always at most one element
       auto range = std::equal_range(iDdet2fed.begin(), iDdet2fed.end(), myTest, compare);
       if (range.first != range.second) {
         auto i = range.first - iDdet2fed.begin();
         for (int b = 0; b < 12; b++) {
           buf[b] = 0;
           bufCRC[b] = 0;
         }
         TotemRPDetId chipId(iDdet2fed.at(i).id);
         for (auto &ch : pId.second) {
           int chInWord = ch / 16;
           buf[9 - chInWord] |= (1 << (ch % 16));  //data[8->1]
           bufCRC[chInWord + 1] = buf[9 - chInWord];
         }
         fedId = iDdet2fed.at(i).fedid;
         int idxInFiber = iDdet2fed.at(i).idxinfiber;
         int gohId = iDdet2fed.at(i).gohid;
         unsigned int hFlag = 0x90;                                 //vmRaw
         buf[0] = (hFlag << 8) | (gohId << 4) | (idxInFiber << 0);  //
         buf[1] = (pId.first >> 15);                                //data[9]
         bufCRC[9] = buf[1];
         Word16 crc_fin = 0xffff;
         for (int i = 11; i >= 1; i--)
           crc_fin = VFATFrame::calculateCRC(crc_fin, bufCRC[i]);
         buf[10] = crc_fin;                            //data[0]
         buf[11] = (15 << 12) | (0 << 8) | (12 << 0);  //build trailer as RawDataUnpacker
         m_WordCounter++;
         words[fedId].push_back(buf);
       }  // range
     }    // mapIdCh
   }      //digis
  
   typedef std::map<int, vector<std::array<uint16_t, 12>>>::const_iterator RI;
   std::map<int, vector<uint16_t>> words16;
   for (auto &itFed : words) {
     int fedId = itFed.first;
     int wordsS = words.find(fedId)->second.size();
     //due to OrbitCounter block at RawDataUnpacker
     words16[fedId].push_back(Word16(0));
     words16[fedId].push_back(Word16(0));
     //writing data in 16-bit words
     for (int k = 0; k < wordsS; k++) {
       for (int b = 0; b < 12; b++) {
         words16[fedId].push_back(words.find(fedId)->second.at(k)[b]);
       }
     }
     // since raw words are written in the form of 64-bit packets
     // add extra 16-bit words to make number of words even if necessary
     while (words16.find(fedId)->second.size() % 4 != 0)
       words16[fedId].push_back(Word16(0));
  
     // size in Bytes; create output structure
     auto dataSize = (words16.find(fedId)->second.size()) * sizeof(Word16);
     int nHeaders = 1;
     int nTrailers = 1;
     dataSize += (nHeaders + nTrailers) * sizeof(Word64);
  
     FEDRawData rawData{dataSize};
  
     // get begining of data;
     Word64 *word = reinterpret_cast<Word64 *>(rawData.data());
  
     // write one header
     FEDHeader::set(reinterpret_cast<unsigned char *>(word), 0, lvl1_ID, 0, fedId, 3);
     word++;
  
     // write data
     unsigned int nWord16InFed = words16.find(fedId)->second.size();
     for (unsigned int i = 0; i < nWord16InFed; i += 4) {
       *word = (Word64(words16.find(fedId)->second[i + 3]) << 48) | (Word64(words16.find(fedId)->second[i + 2]) << 32) |
               (Word64(words16.find(fedId)->second[i + 1]) << 16) | words16.find(fedId)->second[i];
       word++;
     }
  
     // write one trailer
     FEDTrailer::set(reinterpret_cast<unsigned char *>(word), dataSize / sizeof(Word64), 0, 0, 0);
     word++;
  
     // check memory
     if (word != reinterpret_cast<Word64 *>(rawData.data() + dataSize)) {
       string s = "** PROBLEM in CTPPSTotemDataFormatter !!!";
       throw cms::Exception(s);
     }
     fedRawData[fedId] = rawData;
   }  // end of rawData
 }