l1t::demo Namespace Reference

Namespaces
	codecs

Classes
class	BoardData
	Class representing information that's stored in the input or output buffers on a phase-2 board. More...
class	BoardDataReader
class	BoardDataWriter
struct	ChannelSpec
class	EventData
	Class representing information phase-2 ATCA I/O data corresponding to a single event, with logical channel IDs (essentially string-uint pairs, e.g. tracks-0 to tracks-17). More...
struct	Frame
struct	LinkId
	Logical ID for link within any given time slice (e.g. ["tracks", 0] -> ["tracks", 17] for links from TF) More...

Enumerations
enum	FileFormat { FileFormat::APx, FileFormat::EMP, FileFormat::X20 }

Functions
bool	operator< (const LinkId &, const LinkId &)
std::ostream &	operator<< (std::ostream &, FileFormat)
FileFormat	parseFileFormat (const std::string &)
BoardData	read (const std::string &filePath, const FileFormat)
BoardData	read (std::istream &, const FileFormat)
BoardData	readAPxFile (std::istream &, const FileFormat)
BoardData	readEMPFile (std::istream &, const FileFormat)
BoardData	readX20File (std::istream &, const FileFormat)
void	write (const BoardData &, const std::string &filePath, const FileFormat)
void	write (const BoardData &, std::ostream &, const FileFormat)
void	writeAPxFile (const BoardData &, std::ostream &, const FileFormat)
void	writeEMPFile (const BoardData &, std::ostream &, const FileFormat)
void	writeX20File (const BoardData &, std::ostream &, const FileFormat)

Enumeration Type Documentation

FileFormat

enum l1t::demo::FileFormat

strong

Enumerator
APx
EMP
X20

Definition at line 9 of file FileFormat.h.

{ APx, EMP, X20 };

Function Documentation

operator<()

bool l1t::demo::operator<	(	const LinkId &	x,
		const LinkId &	y
	)

Definition at line 6 of file LinkId.cc.

References HltBtagPostValidation_cff::c, and x.

                                                   {
    int c = x.interface.compare(y.interface);
    return c == 0 ? (x.channel < y.channel) : (c < 0);
  }

operator<<()

std::ostream & l1t::demo::operator<<	(	std::ostream &	os,
		FileFormat	format
	)

Definition at line 8 of file FileFormat.cc.

References APx, EMP, and X20.

                                                            {
    switch (format) {
      case FileFormat::APx:
        os << "APx";
        break;
      case FileFormat::EMP:
        os << "EMP";
        break;
      case FileFormat::X20:
        os << "X20";
    }
    return os;
  }

parseFileFormat()

FileFormat l1t::demo::parseFileFormat

(

const std::string &

s

)

Definition at line 70 of file utilities.cc.

References APx, EMP, alignCSCRings::s, and X20.

Referenced by L1TCorrelatorLayer1PatternFileWriter::L1TCorrelatorLayer1PatternFileWriter(), and L1TCtL2EgProducer::PatternWriter::PatternWriter().

                                                 {
    static const std::unordered_map<std::string, FileFormat> kFormatStringMap({{"EMP", FileFormat::EMP},
                                                                               {"emp", FileFormat::EMP},
                                                                               {"APx", FileFormat::APx},
                                                                               {"apx", FileFormat::APx},
                                                                               {"X20", FileFormat::X20},
                                                                               {"x20", FileFormat::X20}});

    const auto it = kFormatStringMap.find(s);
    if (it == kFormatStringMap.end())
      throw std::runtime_error("Could not convert '" + s + "' to FileFormat enum value");

    return it->second;
  }

read() [1/2]

BoardData l1t::demo::read	(	const std::string &	filePath,
		const FileFormat	format
	)

Definition at line 91 of file utilities.cc.

References geometryDiff::file, and dt4ml_dqm_sourceclient-live_cfg::filePath.

Referenced by l1t::demo::BoardDataReader::BoardDataReader().

                                                                     {
    std::ifstream file(filePath);

    if (not file.is_open())
      throw std::runtime_error("Could not open file '" + filePath + "'");

    return read(file, format);
  }

read() [2/2]

BoardData l1t::demo::read	(	std::istream &	file,
		const FileFormat	format
	)

Definition at line 100 of file utilities.cc.

References APx, EMP, geometryDiff::file, readAPxFile(), readEMPFile(), and readX20File().

                                                            {
    if (format == FileFormat::APx)
      return readAPxFile(file, format);
    else if (format == FileFormat::EMP)
      return readEMPFile(file, format);
    else
      return readX20File(file, format);
  }

readAPxFile()

BoardData l1t::demo::readAPxFile	(	std::istream &	file,
		const FileFormat	format
	)

Definition at line 109 of file utilities.cc.

References submitPVResolutionJobs::count, geometryDiff::file, dqmdumpme::indices, mps_splice::line, or, AlCaHLTBitMon_QueryRunRegistry::string, cond::impl::to_string(), and unpackBuffers-CaloStage2::token.

Referenced by read().

                                                                   {
    std::string line;

    // Complain if file is empty
    if (not std::getline(file, line))
      throw std::runtime_error("Specified file is empty!");

    // If first line is sideband, skip it and move onto 2nd line
    if (line.find("#Sideband") == 0) {
      if (not std::getline(file, line))
        throw std::runtime_error("APx file has incorrect format: Link labels and data missing!");
    }

    // Parse link labels
    if (line.find("#LinkLabel") != 0)
      throw std::runtime_error(
          "APx file has incorrect format: Link header does not start with '#LinkLabel' (line is '" + line + "')");

    std::vector<size_t> indices;
    const std::regex delimiterRegex("\\s+");
    std::sregex_token_iterator it(line.begin() + 10, line.end(), delimiterRegex, -1);
    for (; it != std::sregex_token_iterator(); it++) {
      const std::string token(it->str());
      if (token.empty())
        continue;

      if (token.find("LINK_") != 0)
        throw std::runtime_error("Link column name '" + token + "' (does not start with 'LINK_')");
      if (token.size() == 5)
        throw std::runtime_error("Link column name '" + token + "' is too short");
      if (not std::all_of(token.begin() + 5, token.end(), ::isdigit))
        throw std::runtime_error("Link column name '" + token + "' does not end with a number");

      indices.push_back(std::stoul(token.substr(5)));
    }

    // Check for '#BeginData' line
    if (not std::getline(file, line))
      throw std::runtime_error("APx file has incorrect format: Data missing!");
    if (line != "#BeginData")
      throw std::runtime_error("APx file has incorrect format: '#BeginData' line missing (found '" + line + "')");

    // Parse link data
    std::vector<std::vector<l1t::demo::Frame>> dataRows;
    while (std::getline(file, line)) {
      it = std::sregex_token_iterator(line.begin(), line.end(), delimiterRegex, -1);
      size_t count = 0;
      for (; it != std::sregex_token_iterator(); it++, count++) {
        const std::string token(it->str());

        if ((token.find("0x") != 0) or (not std::all_of(token.begin() + 2, token.end(), ::isxdigit)))
          throw std::runtime_error("APx file has incorrect format: Data token '" + token +
                                   "' is not hexadecimal number");

        if (count == 0) {
          size_t rowIndex = std::stoul(token, nullptr, 16);
          if (rowIndex != dataRows.size())
            throw std::runtime_error("APx file has incorrect format: Expected data row " +
                                     std::to_string(dataRows.size()) + ", but found row " + std::to_string(rowIndex));
          dataRows.push_back(std::vector<l1t::demo::Frame>(indices.size()));
        }
        // Sideband info
        else if ((count % 2) == 1) {
          uint16_t sbValue = std::stoul(token, nullptr, 16);
          dataRows.back().at((count - 1) / 2).valid = (sbValue & 0x1);
          dataRows.back().at((count - 1) / 2).start = ((sbValue >> 1) & 0x1);
          dataRows.back().at((count - 1) / 2).end = ((sbValue >> 3) & 0x1);
        }
        // Data word
        else
          dataRows.back().at((count - 1) / 2).data = ap_uint<64>(std::stoull(token, nullptr, 16));
      }

      if (count != (2 * indices.size() + 1))
        throw std::runtime_error("APx file has incorrect format: Line has incorrect number of tokens (expected " +
                                 std::to_string(2 * indices.size() + 1) + ", found " + std::to_string(count) + "!");
    }

    return createBoardDataFromRows("", indices, dataRows);
  }

readEMPFile()

BoardData l1t::demo::readEMPFile	(	std::istream &	file,
		const FileFormat	format
	)

Definition at line 190 of file utilities.cc.

References ewkTauDQM_cfi::channels, geometryDiff::file, l1ctLayer2EG_cff::id, mps_splice::line, muonTagProbeFilters_cff::matched, or, hcallasereventfilter2012_cfi::prefix, alignCSCRings::s, str, AlCaHLTBitMon_QueryRunRegistry::string, unpackBuffers-CaloStage2::token, HcalDetIdTransform::transform(), and relativeConstraints::value.

Referenced by read().

                                                                   {
    // 1) Search for ID string
    std::string id, line;
    while (getline(file, line)) {
      if (line.empty())
        continue;
      if (line[0] == '#')
        continue;

      if (line.rfind("Board ", 0) != std::string::npos) {
        id = line.substr(6);
        break;
      } else
        throw std::logic_error("Found unexpected line found when searching for board ID: \"" + line + "\"");
    }

    // 2) Search for column labels (i.e. list of channels/links)
    searchAndTokenize(file, "Quad/Chan :");
    const auto tokens = searchAndTokenize(file, "Link :");
    std::vector<size_t> channels;
    std::transform(tokens.begin(), tokens.end(), std::back_inserter(channels), [](const std::string& s) {
      return std::stoull(s);
    });

    // 3) Read the main data rows
    const std::regex delimiterRegex("\\s+");
    static const std::regex frameRegex("([01]s)?([01]v)([0-9a-fA-F]{16})");
    std::vector<std::vector<Frame>> dataRows;
    while (file.good() and getline(file, line)) {
      if (line.empty() or line[0] == '#')
        continue;

      std::ostringstream prefixStream;
      prefixStream << "Frame ";
      prefixStream << std::setw(4) << std::setfill('0') << dataRows.size();
      prefixStream << " :";

      const std::string prefix(prefixStream.str());
      if (line.rfind(prefix, 0) == std::string::npos)
        throw std::logic_error("Found unexpected line found when searching for \"" + prefix + "\": \"" + line + "\"");

      std::vector<l1t::demo::Frame> row;
      std::sregex_token_iterator it(line.begin() + prefix.size(), line.end(), delimiterRegex, -1);
      for (; it != std::sregex_token_iterator(); it++) {
        const std::string token(it->str());
        if (token.empty())
          continue;

        std::smatch what;
        if (not std::regex_match(token, what, frameRegex))
          throw std::logic_error("Token '" + token + "' doesn't match the valid format");

        l1t::demo::Frame value;
        // Import strobe if the strobe group is matched
        if (what[1].matched) {
          value.strobe = (what[1] == "1s");
        }

        value.valid = (what[2] == "1v");
        value.data = ap_uint<64>(std::stoull(what[3].str(), nullptr, 16));

        row.push_back(value);
      }

      dataRows.push_back(row);
    }

    return createBoardDataFromRows(id, channels, dataRows);
  }

readX20File()

BoardData l1t::demo::readX20File	(	std::istream &	file,
		const FileFormat	format
	)

Definition at line 260 of file utilities.cc.

Referenced by read().

                                                                   {
    throw std::runtime_error("Reading X20 file format not yet implemented. Will be done ASAP.");
  }

write() [1/2]

void l1t::demo::write	(	const BoardData &	data,
		const std::string &	filePath,
		const FileFormat	format
	)

Definition at line 270 of file utilities.cc.

References gather_cfg::cout, data, HLT_2023v11_cff::distance, geometryDiff::file, and dt4ml_dqm_sourceclient-live_cfg::filePath.

Referenced by l1t::demo::BoardDataWriter::flush().

                                                                                        {
    // Open file
#ifdef CMSSW_GIT_HASH
    edm::LogInfo("L1TDemonstratorTools")
#else
    std::cout
#endif
        << "Writing board data (" << std::distance(data.begin(), data.end()) << " channels, "
        << data.begin()->second.size() << " frames) to file '" << filePath << "' (format: " << format << ")"
        << std::endl;
    std::ofstream file(filePath);

    if (not file.is_open())
      throw std::runtime_error("Could not open file '" + filePath + "'");

    write(data, file, format);
  }

write() [2/2]

void l1t::demo::write	(	const BoardData &	data,
		std::ostream &	file,
		const FileFormat	format
	)

Definition at line 288 of file utilities.cc.

References APx, data, EMP, geometryDiff::file, mps_fire::i, cond::impl::to_string(), writeAPxFile(), writeEMPFile(), writeX20File(), and X20.

                                                                               {
    // Check that number of frames is same for every channel
    const auto firstChannel = data.begin();

    for (const auto& channel : data) {
      const auto i = channel.first;
      const auto channelData = channel.second;
      if (channelData.size() != firstChannel->second.size())
        throw std::runtime_error("Cannot write board data to file - channels do not all have the same length (" +
                                 std::to_string(channelData.size()) + " words on channel " + std::to_string(i) +
                                 ", but " + std::to_string(firstChannel->second.size()) + " words on channel " +
                                 std::to_string(firstChannel->first) + ")");
    }

    // Call relevant write function
    switch (format) {
      case FileFormat::APx:
        writeAPxFile(data, file, format);
        return;
      case FileFormat::EMP:
        writeEMPFile(data, file, format);
        return;
      case FileFormat::X20:
        writeX20File(data, file, format);
        return;
    }
  }

writeAPxFile()

void l1t::demo::writeAPxFile	(	const BoardData &	data,
		std::ostream &	file,
		const FileFormat	format
	)

Definition at line 316 of file utilities.cc.

References data, geometryDiff::file, and mps_fire::i.

Referenced by write().

                                                                                      {
    // Note: APx sideband encoding
    //   Short-term, simulation only:
    //     0 -> Valid
    //     1 -> EOF
    //   Planned (from ~ May 2021)
    //     0 -> Valid
    //     1 -> SOF (Start Of Frame)
    //     2 -> FFO (First Frame of Orbit)
    //     3 -> EOF (End Of Frame)
    //     4 -> FERR (Frame Error)
    //     5 -> RSV1
    //     6 -> RSV2
    //     7 -> RSV3

    file << std::setfill('0');
    file << "#Sideband ON" << std::endl;

    // Channel header
    file << "#LinkLabel";
    for (const auto& channel : data) {
      const auto i = channel.first;
      file << "                LINK_" << std::setw(2) << i << "    ";
    }
    file << std::endl;

    file << "#BeginData" << std::endl;

    // Frames
    file << std::hex;
    const auto firstChannel = data.begin();
    for (size_t i = 0; i < firstChannel->second.size(); i++) {
      file << "0x" << std::setw(4) << i;
      for (const auto& channel : data) {
        //const auto j = channel.first;
        const auto channelData = channel.second;
        uint16_t sideband = channelData.at(i).valid;
        sideband |= channelData.at(i).start << 1;
        sideband |= channelData.at(i).end << 3;
        file << "    0x" << std::setw(2) << sideband;
        file << " 0x" << std::setw(16) << uint64_t(channelData.at(i).data);
      }
      file << std::endl;
    }
  }

writeEMPFile()

void l1t::demo::writeEMPFile	(	const BoardData &	data,
		std::ostream &	file,
		const FileFormat	format
	)

Definition at line 362 of file utilities.cc.

References data, TauDecayModes::dec, geometryDiff::file, and mps_fire::i.

Referenced by write().

                                                                                      {
    file << std::setfill('0');

    // Board name/id
    file << "Board CMSSW" << std::endl;

    // Quad/chan header
    file << " Quad/Chan :";
    for (const auto& channel : data) {
      const auto i = channel.first;
      file << "         q" << std::setw(2) << i / 4 << 'c' << std::setw(1) << i % 4 << "       ";
    }
    file << std::endl;

    // Link header
    file << "      Link :";
    for (const auto& channel : data) {
      const auto i = channel.first;
      file << "          " << std::setw(3) << i << "        ";
    }
    file << std::endl;

    // Frames
    const auto firstChannel = data.begin();
    for (size_t i = 0; i < firstChannel->second.size(); i++) {
      file << "Frame " << std::setw(4) << i << " :";
      for (const auto& channel : data) {
        //const auto j = channel.first;
        const auto channelData = channel.second;
        file << " ";
        //TODO: Add strobe if zero anywhere on channel
        file << "  ";
        file << std::setw(1) << channelData.at(i).valid << "v" << std::setw(16) << std::hex
             << uint64_t(channelData.at(i).data);
      }
      file << std::endl << std::dec;
    }
  }

writeX20File()

void l1t::demo::writeX20File	(	const BoardData &	data,
		std::ostream &	file,
		const FileFormat	format
	)

Definition at line 401 of file utilities.cc.

Referenced by write().

                                                                                      {
    throw std::runtime_error("Writing X20 file format not yet implemented. Will be done ASAP.");
  }