dunedaq::timing Namespace Reference

< Message parameters More...

Namespaces
namespace	python
namespace	timingendpointinfo
namespace	timingfirmware
namespace	timingfirmwareinfo
namespace	timinghardwareinfo

Classes
struct	ActiveEndpointConfig
class	BoreasDesign
	Class for timing master with integrated HSI designs. More...
class	CDCLVD110Node
	uhal::Node implementing CDCLVD110 interface More...
class	CDRMuxDesignInterface
	Base class for timing endpoint design nodes. More...
class	ChronosDesign
	Class for timing master with integrated HSI designs. More...
class	ClockGeneratorInterface
	uhal::Node implementing clock gen. interface More...
class	DACNode
	uhal::Node implementing single I2C Master Slave connection to control SFP expander chips. More...
class	DACSlave
	Class for dac node. More...
class	EchoMonitorNode
	Class for master global node. More...
class	EndpointDesign
	Base class for timing endpoint design nodes. More...
class	EndpointDesignInterface
	Base class for timing endpoint design nodes. More...
class	EndpointNode
	Base class for timing IO nodes. More...
class	EndpointNodeInterface
	Base class for timing IO nodes. More...
class	FanoutDesign
	Class for timing fanout designs. More...
class	FIBIONode
	Class for the FIB board. More...
class	FIBV2IONode
	Class for the FIB board. More...
class	FLCmdGeneratorNode
	Class for master global node. More...
class	FMCIONode
	Class for the timing FMC board. More...
class	FrequencyCounterNode
	Base class for timing IO nodes. More...
class	GaiaDesign
	Class for timing fanout designs. More...
class	GIBIONode
	Class for the timing FMC board. More...
class	GIBV2IONode
	Class for the timing FMC board. More...
class	GIBV3IONode
	Class for the timing FMC board. More...
class	HadesDesign
	Class for timing master with integrated HSI designs. More...
class	HSIDesignInterface
	Base class for timing hsi design nodes. More...
class	HSINode
	Class for HSI nodes. More...
class	I2CMasterNode
class	I2CSFPNode
class	I2CSFPSlave
	I2C slave class to control SFP transceivers. More...
class	I2CSlave
class	IONode
	Base class for timing IO nodes. More...
class	IRIGTimestampNode
	Class for timestamp generator node. More...
class	KerberosDesign
	Class for timing fanout designs. More...
class	LM75Node
class	LTC2945Node
class	MasterDesign
	Base class for timing master designs. More...
class	MasterDesignInterface
	Base class for timing master designs. More...
class	MasterGlobalNode
	Class for master global node. More...
class	MasterMuxDesign
	Class for PDI timing master design on mux board. More...
class	MasterNode
	Class for PD-II/DUNE master timing nodes. More...
class	MasterNodeInterface
	Base class for timing IO nodes. More...
class	MIBIONode
	Class for the timing FMC board. More...
class	MIBV2IONode
	Class for the timing FMC board. More...
class	MuxDesignInterface
	Base class for timing endpoint design nodes. More...
class	OuroborosDesign
	Class for PDI timing master design (known as overlord). More...
class	OuroborosMuxDesign
	Class for PDI ouroboros timing master design. More...
class	PC059IONode
	Class for the PC059 board. More...
class	SFPMuxDesignInterface
	Class for timing fanout designs. More...
class	SFPMuxIONode
	Base class for boards which have a physical SFP mux. More...
class	SIChipSlave
	Utility class to interface to SI chips. More...
class	SIMIONode
	Class for the timing simulation IO. More...
struct	stol
struct	stoul
class	SwitchyardNode
	Class for master global node. More...
class	TimingNode
	Base class for timing nodes. More...
class	TimingSourceMuxDesignInterface
	Base class for timing endpoint design nodes. More...
class	TLUIONode
	Class for the TLU board. More...
class	TopDesign
	Base class for timing top design nodes with IO class. More...
class	TopDesignInterface
	Base class for timing top design nodes. More...
class	UpstreamCDRNode
	Class for master global node. More...
class	VLCmdGeneratorNode
	Class for master global node. More...

Typedefs
typedef std::map< std::string, uint32_t >	Snapshot

Enumerations
enum	BoardType {   kBoardFMC , kBoardSim , kBoardPC059 , kBoardMicrozed ,   kBoardTLU , kBoardFIB , kBoardMIB , kBoardPC069 ,   kBoardGIB , kBoardGIBV3 , kBoardUnknown = 256 }
enum	CarrierType {   kCarrierEnclustraA35 , kCarrierKC705 , kCarrierMicrozed , kCarrierATFC ,   kCarrierAFC , kCarrierNexusVideo , kCarrierTrenzTE0712 , kCarrierUnknown = 256 }
enum	DesignType {   kDesignMaster , kDesignOuroborosSim , kDesignOuroboros , kDesignTest ,   kDesignEndpoint , kDesignFanout , kDesignOverlord , kDesignEndpoBICRT ,   kDesignChronos , kDesignBoreas , kDesignKerberos , kDesignGaia ,   kDesignCharon , kDesignHades , kDesignUnknown = 256 }
enum	BoardRevision {   kFMCRev1 , kFMCRev2 , kFMCRev3 , kFMCRev4 ,   kPC059Rev1 , kTLURev1 , kSIMRev1 , kFIBRev1 ,   kMIBRev1 , kPC069a , kMIBRev2 , kGIBRev1 ,   kPC069b , kFIBRev2 , kPC069c , kBoardRevisionUnknown = 256 }
enum	FixedLengthCommandType {   TimeSync , Echo , SpillStart , SpillStop ,   RunStart , RunStop , WibCalib , SSPCalib ,   FakeTrig0 , FakeTrig1 , FakeTrig2 , FakeTrig3 ,   BeamTrig , NoBeamTrig , ExtFakeTrig }
enum	ClockSource {   kInput0 = 0 , kInput1 = 1 , kInput2 = 2 , kInput3 = 3 ,   kFreeRun = 255 }
enum	TimestampSource { kUpstream = 0 , kSoftware = 1 , kMixed = 2 }
enum	TimestampEpoch { kUNIX = 0 , kCustom = 1 }
enum	TimestampTimebase { kTAI = 0 , kUTC = 1 }

Functions
template<typename T >
std::string	to_string (const T &v)
template<typename M >
bool	map_value_comparator (typename M::value_type &p1, typename M::value_type &p2)
template<typename T >
std::vector< T >	sanitize (const std::vector< T > &vec)
template<typename T , typename U >
T	safe_enum_cast (const U &value, const std::vector< T > &valid, const T &def)
template<typename C >
std::string	join (const C &strings, const std::string &delimiter=" ")
	Converts a vector of strings in a delimiter-separated string.
template<class T >
std::string	format_reg_value (T reg_value, uint32_t base)
template<>
std::string	format_reg_value (std::string reg_value, uint32_t)
template<>
std::string	format_reg_value (uhal::ValWord< uint32_t > reg_value, uint32_t base)
template<class T >
std::string	format_reg_table (T data, std::string title="", std::vector< std::string > headers={ "Register", "Value" })
	Format reg-value table.
template<class T >
std::string	format_counters_table (std::vector< T > counters, std::vector< std::string > counter_node_titles={}, std::string table_title="", std::vector< std::string > counter_labels={}, std::string counter_labels_header="Cmd")
	Format reg-value table.
template<typename T >
std::string	vec_fmt (const std::vector< T > &vec)
template<typename T >
std::string	short_vec_fmt (const std::vector< T > &vec)
template<typename T , typename U >
T	safe_enum_cast (const U &value, const std::vector< T > &valid)
Snapshot	snapshot (const uhal::Node &node)
	Walk & read the node structure.
Snapshot	snapshot (const uhal::Node &node, const std::string &regex)
	Walk & read the sub-nodes whose IDs match this regex.
void	millisleep (const double &time_in_milliseconds)
std::string	strprintf (const char *fmt,...)
std::vector< std::string >	shell_expand_paths (const std::string &path)
std::string	shellExpandPath (const std::string &path)
void	throw_if_not_file (const std::string &path)
uint8_t	dec_rng (uint8_t word, uint8_t ibit, uint8_t nbits=1)
uint64_t	tstamp2int (uhal::ValVector< uint32_t > raw_timestamp)
int64_t	get_milliseconds_since_epoch ()
int64_t	get_seconds_since_epoch ()
std::string	format_timestamp (uhal::ValVector< uint32_t > raw_timestamp, uint32_t clock_frequency_hz)
std::string	format_timestamp (uint64_t raw_timestamp, uint32_t clock_frequency_hz)
double	convert_bits_to_float (uint64_t bits, bool is_double_precision=false)
BoardType	convert_value_to_board_type (uint32_t Board_type)
CarrierType	convert_value_to_carrier_type (uint32_t darrier_type)
DesignType	convert_value_to_design_type (uint32_t design_type)
std::string	format_firmware_version (uint32_t firmware_version)
uint32_t	locate (float xx[], unsigned long n, float x)

Detailed Description

< Message parameters

Typedef Documentation

Snapshot

typedef std::map<std::string, uint32_t> dunedaq::timing::Snapshot

Definition at line 27 of file definitions.hpp.

Enumeration Type Documentation

BoardRevision

enum dunedaq::timing::BoardRevision

Enumerator
kFMCRev1
kFMCRev2
kFMCRev3
kFMCRev4
kPC059Rev1
kTLURev1
kSIMRev1
kFIBRev1
kMIBRev1
kPC069a
kMIBRev2
kGIBRev1
kPC069b
kFIBRev2
kPC069c
kBoardRevisionUnknown

Definition at line 75 of file definitions.hpp.

{
  kFMCRev1,
  kFMCRev2,
  kFMCRev3,
  kFMCRev4,
  kPC059Rev1,
  kTLURev1,
  kSIMRev1,
  kFIBRev1,
  kMIBRev1,
  kPC069a,
  kMIBRev2,
  kGIBRev1,
  kPC069b,
  kFIBRev2,
  kPC069c,
  kBoardRevisionUnknown = 256
};

BoardType

enum dunedaq::timing::BoardType

Enumerator
kBoardFMC
kBoardSim
kBoardPC059
kBoardMicrozed
kBoardTLU
kBoardFIB
kBoardMIB
kBoardPC069
kBoardGIB
kBoardGIBV3
kBoardUnknown

Definition at line 29 of file definitions.hpp.

{
  kBoardFMC,
  kBoardSim,
  kBoardPC059,
  kBoardMicrozed,
  kBoardTLU,
  kBoardFIB,
  kBoardMIB,
  kBoardPC069,
  kBoardGIB,
  kBoardGIBV3,
  kBoardUnknown = 256
};

CarrierType

enum dunedaq::timing::CarrierType

Enumerator
kCarrierEnclustraA35
kCarrierKC705
kCarrierMicrozed
kCarrierATFC
kCarrierAFC
kCarrierNexusVideo
kCarrierTrenzTE0712
kCarrierUnknown

Definition at line 44 of file definitions.hpp.

{
  kCarrierEnclustraA35,
  kCarrierKC705,
  kCarrierMicrozed,
  kCarrierATFC,
  kCarrierAFC,
  kCarrierNexusVideo,
  kCarrierTrenzTE0712, // include fpga part number?
  kCarrierUnknown = 256
};

ClockSource

enum dunedaq::timing::ClockSource

Enumerator
kInput0
kInput1
kInput2
kInput3
kFreeRun

Definition at line 114 of file definitions.hpp.

{
  kInput0 = 0,
  kInput1 = 1,
  kInput2 = 2,
  kInput3 = 3,
  kFreeRun = 255
};

DesignType

enum dunedaq::timing::DesignType

Enumerator
kDesignMaster
kDesignOuroborosSim
kDesignOuroboros
kDesignTest
kDesignEndpoint
kDesignFanout
kDesignOverlord
kDesignEndpoBICRT
kDesignChronos
kDesignBoreas
kDesignKerberos
kDesignGaia
kDesignCharon
kDesignHades
kDesignUnknown

Definition at line 56 of file definitions.hpp.

{
  kDesignMaster,
  kDesignOuroborosSim,
  kDesignOuroboros,
  kDesignTest,
  kDesignEndpoint,
  kDesignFanout,
  kDesignOverlord,
  kDesignEndpoBICRT,
  kDesignChronos,
  kDesignBoreas,
  kDesignKerberos,
  kDesignGaia,
  kDesignCharon,
  kDesignHades,
  kDesignUnknown = 256
};

FixedLengthCommandType

enum dunedaq::timing::FixedLengthCommandType

Enumerator
TimeSync
Echo
SpillStart
SpillStop
RunStart
RunStop
WibCalib
SSPCalib
FakeTrig0
FakeTrig1
FakeTrig2
FakeTrig3
BeamTrig
NoBeamTrig
ExtFakeTrig

Definition at line 95 of file definitions.hpp.

{
  TimeSync,  
  Echo,      
  SpillStart, 
  SpillStop,  
  RunStart,
  RunStop,   
  WibCalib,  
  SSPCalib,   
  FakeTrig0,  
  FakeTrig1,
  FakeTrig2, 
  FakeTrig3, 
  BeamTrig,   
  NoBeamTrig, 
  ExtFakeTrig
};

TimestampEpoch

enum dunedaq::timing::TimestampEpoch

Enumerator
kUNIX
kCustom

Definition at line 130 of file definitions.hpp.

{
  kUNIX = 0,
  kCustom = 1
};

TimestampSource

enum dunedaq::timing::TimestampSource

Enumerator
kUpstream
kSoftware
kMixed

Definition at line 123 of file definitions.hpp.

{
  kUpstream = 0,
  kSoftware = 1,
  kMixed = 2
};

TimestampTimebase

enum dunedaq::timing::TimestampTimebase

Enumerator
kTAI
kUTC

Definition at line 136 of file definitions.hpp.

{
  kTAI = 0,
  kUTC = 1
};

Function Documentation

convert_bits_to_float()

double dunedaq::timing::convert_bits_to_float	(	uint64_t	bits,
		bool	is_double_precision = false )

""

Returns

Definition at line 242 of file toolbox.cpp.

{
  uint32_t mantissa_shift = is_double_precision ? 52 : 23;                        // NOLINT(build/unsigned)
  uint64_t exponent_mask = is_double_precision ? 0x7FF0000000000000 : 0x7f800000; // NOLINT(build/unsigned)
  uint32_t bias = is_double_precision ? 1023 : 127;                              // NOLINT(build/unsigned)
  uint32_t sign_shift = is_double_precision ? 63 : 31;                            // NOLINT(build/unsigned)
 
  int32_t sign = (bits >> sign_shift) & 0x01;
  uint32_t exponent_biased = ((bits & exponent_mask) >> mantissa_shift); // NOLINT(build/unsigned)
  int32_t exponent = exponent_biased - bias;
 
  int32_t power = -1;
  double mantissa = 0.0;
  for (uint32_t i = 0; i < mantissa_shift; ++i) {                       // NOLINT(build/unsigned)
    uint64_t mantissa_bit = (bits >> (mantissa_shift - i - 1)) & 0x01; // NOLINT(build/unsigned)
    mantissa += mantissa_bit * pow(2.0, power);
    --power;
  }
 
  if (exponent_biased == 0) {
    ++exponent;
    if (mantissa == 0)
      return 0;
  } else {
    mantissa += 1.0;
  }
  return (sign ? -1 : 1) * pow(2.0, exponent) * mantissa;
}

convert_value_to_board_type()

BoardType dunedaq::timing::convert_value_to_board_type

(

uint32_t

Board_type

)

Definition at line 274 of file toolbox.cpp.

{
  // not pleasnt, but works for now
  if (board_type >= kBoardUnknown) {
    throw UnknownBoardType(ERS_HERE, format_reg_value(board_type));
  } else {
    return static_cast<BoardType>(board_type);
  }
}

convert_value_to_carrier_type()

CarrierType dunedaq::timing::convert_value_to_carrier_type

(

uint32_t

darrier_type

)

Definition at line 287 of file toolbox.cpp.

{
  // not pleasnt, but works for now
  if (carrier_type >= kCarrierUnknown) {
    throw UnknownCarrierType(ERS_HERE, format_reg_value(carrier_type));
  } else {
    return static_cast<CarrierType>(carrier_type);
  }
}

convert_value_to_design_type()

DesignType dunedaq::timing::convert_value_to_design_type

(

uint32_t

design_type

)

Definition at line 300 of file toolbox.cpp.

{
  // not pleasnt, but works for now
  if (design_type >= kDesignUnknown) {
    throw UnknownDesignType(ERS_HERE, format_reg_value(design_type));
  } else {
    return static_cast<DesignType>(design_type);
  }
}

dec_rng()

uint8_t dunedaq::timing::dec_rng	(	uint8_t	word,
		uint8_t	ibit,
		uint8_t	nbits = 1 )

Expand the path

Parameters

path	path to expand

Returns

vector of expanded paths

Definition at line 167 of file toolbox.cpp.

{
  return (word >> ibit) & ((1 << nbits) - 1);
}

format_counters_table()

template<class T >

std::string dunedaq::timing::format_counters_table	(	std::vector< T >	counters,
		std::vector< std::string >	counter_node_titles = {},
		std::string	table_title = "",
		std::vector< std::string >	counter_labels = {},
		std::string	counter_labels_header = "Cmd" )

Format reg-value table.

Returns

Definition at line 216 of file toolbox.hxx.

{
 
  uint32_t counter_nodes_number = counter_nodes.size();
  uint32_t table_width = 4 + (counter_nodes_number * 3);
 
  std::vector<std::string> counter_node_titles_to_use;
 
  if (!counter_node_titles.size()) {
    for (uint32_t i = 0; i < counter_nodes.size(); ++i) {
      counter_node_titles_to_use.push_back("Counters");
    }
  } else if (counter_nodes.size() != counter_node_titles.size()) {
    throw FormatCountersTableNodesTitlesMismatch(ERS_HERE);
  } else {
    counter_node_titles_to_use = counter_node_titles;
  }
 
  uint32_t counter_number;
  uint32_t counter_label_column_width = 0;
 
  std::stringstream table_stream;
  counter_number = counter_labels.size();
 
  for (auto it = counter_labels.begin(); it != counter_labels.end(); ++it) {
    counter_label_column_width = counter_label_column_width > it->size() ? counter_label_column_width : it->size();
  }
  counter_label_column_width =
    counter_label_column_width > counter_labels_header.size() ? counter_label_column_width : counter_labels_header.size();
 
  typedef std::vector<std::pair<std::string, std::string>> CounterValuesContainer;
 
  std::vector<CounterValuesContainer> counter_value_containers;
  std::vector<std::pair<uint32_t, uint32_t>> counter_value_column_widths;
 
  for (auto node_iter = counter_nodes.begin(); node_iter != counter_nodes.end(); ++node_iter) {
 
    CounterValuesContainer counter_values;
 
    uint32_t counter_value_dec_column_width = 5;
    uint32_t counter_value_hex_column_width = 5;
 
    for (auto counter_iter = node_iter->begin(); counter_iter != node_iter->end(); ++counter_iter) {
 
      std::string counter_value_dec = format_reg_value(*counter_iter, 10);
      std::string counter_value_hex = format_reg_value(*counter_iter, 16);
 
      counter_value_dec_column_width =
        counter_value_dec_column_width > counter_value_dec.size() ? counter_value_dec_column_width : counter_value_dec.size();
      counter_value_hex_column_width =
        counter_value_hex_column_width > counter_value_hex.size() ? counter_value_hex_column_width : counter_value_hex.size();
 
      counter_values.push_back(std::make_pair(counter_value_dec, counter_value_hex));
    }
 
    counter_value_containers.push_back(counter_values);
    counter_value_column_widths.push_back(std::make_pair(counter_value_dec_column_width, counter_value_hex_column_width));
  }
 
  std::vector<uint32_t> counter_node_title_sizes;
  // titles and border
  std::stringstream counter_titles_row;
  counter_titles_row << boost::format("| %=s |") % boost::io::group(std::setw(counter_label_column_width), "");
  table_width = table_width + counter_label_column_width;
  for (uint32_t i = 0; i < counter_nodes_number; ++i) {
    uint32_t dec_width = counter_value_column_widths.at(i).first;
    uint32_t hex_width = counter_value_column_widths.at(i).second;
 
    uint32_t counter_title_size = counter_node_titles_to_use.at(i).size();
 
    if (counter_title_size > (dec_width + hex_width + 3)) {
 
      if ((counter_title_size - 3) % 2)
        ++counter_title_size;
 
      counter_value_column_widths.at(i).first = (counter_title_size - 3) / 2;
      counter_value_column_widths.at(i).second = (counter_title_size - 3) / 2;
 
    } else {
      counter_title_size = (dec_width + hex_width + 3);
    }
    counter_titles_row << boost::format(" %=s |") %
                           boost::io::group(std::setw(counter_title_size), counter_node_titles_to_use.at(i));
    counter_node_title_sizes.push_back(counter_title_size);
    table_width = table_width + counter_title_size;
  }
  counter_titles_row << std::endl;
 
  std::stringstream title_row_border;
  title_row_border << boost::format("+-%=s-+") %
                       boost::io::group(std::setw(counter_label_column_width), std::setfill('-'), "");
  for (uint32_t i = 0; i < counter_nodes_number; ++i) {
    title_row_border << boost::format("-%=s-+") %
                         boost::io::group(std::setw(counter_node_title_sizes.at(i)), std::setfill('-'), "");
  }
  title_row_border << std::endl;
 
  if (table_title.size())
    table_stream << boost::format("%=s\n") % boost::io::group(std::setw(table_width), std::setfill('-'), table_title);
 
  table_stream << title_row_border.str();
  table_stream << counter_titles_row.str();
  table_stream << title_row_border.str();
  //
 
  // headers
  std::stringstream counter_headers;
  counter_headers << boost::format("| %=s |") %
                       boost::io::group(std::setw(counter_label_column_width), counter_labels_header);
  for (uint32_t j = 0; j < counter_nodes_number; ++j) {
    uint32_t dec_width = counter_value_column_widths.at(j).first;
    uint32_t hex_width = counter_value_column_widths.at(j).second;
    counter_headers << boost::format(" %=s | %=s |") % boost::io::group(std::setw(dec_width), "cnts") %
                         boost::io::group(std::setw(hex_width), "hex");
  }
  table_stream << counter_headers.str() << std::endl;
  //
 
  // top counter row border
  std::stringstream row_border;
  row_border << boost::format("+-%=s-+") % boost::io::group(std::setw(counter_label_column_width), std::setfill('-'), "");
  for (uint32_t j = 0; j < counter_nodes_number; ++j) {
    uint32_t dec_width = counter_value_column_widths.at(j).first;
    uint32_t hex_width = counter_value_column_widths.at(j).second;
    row_border << boost::format("-%=s-+-%=s-+") % boost::io::group(std::setw(dec_width), std::setfill('-'), "") %
                    boost::io::group(std::setw(hex_width), std::setfill('-'), "");
  }
  row_border << std::endl;
  table_stream << row_border.str();
  //
 
  // counter rows
  for (uint32_t i = 0; i < counter_number; ++i) {
    std::stringstream table_row_stream;
 
    table_row_stream << boost::format("| %=s |") %
                         boost::io::group(std::setw(counter_label_column_width), counter_labels.at(i));
 
    for (uint32_t j = 0; j < counter_nodes_number; ++j) {
      uint32_t dec_width = counter_value_column_widths.at(j).first;
      uint32_t hex_width = counter_value_column_widths.at(j).second;
 
      std::string dec_value = counter_value_containers.at(j).at(i).first;
      std::string hex_value = counter_value_containers.at(j).at(i).second;
 
      table_row_stream << boost::format(" %=s | %=s |") % boost::io::group(std::setw(dec_width), dec_value) %
                           boost::io::group(std::setw(hex_width), hex_value);
    }
    table_stream << table_row_stream.str() << std::endl;
  }
  //
 
  // bottom counter row border
  table_stream << row_border.str();
 
  return table_stream.str();
}

format_firmware_version()

std::string dunedaq::timing::format_firmware_version

(

uint32_t

firmware_version

)

Definition at line 352 of file toolbox.cpp.

{
  int major_firmware_version = (firmware_version >> 16) & 0xff;
  int minor_firmware_version = (firmware_version >> 8) & 0xff;
  int patch_firmware_version = (firmware_version >> 0) & 0xff;
 
  std::stringstream firmware_version_stream;
  firmware_version_stream << "v" << major_firmware_version << "." << minor_firmware_version << "." << patch_firmware_version;
  return firmware_version_stream.str();
}

format_reg_table()

template<class T >

std::string dunedaq::timing::format_reg_table	(	T	data,
		std::string	title = "",
		std::vector< std::string >	headers = { "Register", "Value" } )

Format reg-value table.

Returns

Definition at line 166 of file toolbox.hxx.

{
 
  uint32_t table_width = 7;
  uint32_t reg_column_width = 0;
  uint32_t val_column_width = 3;
  std::stringstream table_stream;
 
  for (auto it = data.begin(); it != data.end(); ++it) {
    reg_column_width = reg_column_width > it->first.size() ? reg_column_width : it->first.size();
    val_column_width =
      val_column_width > format_reg_value(it->second).size() ? val_column_width : format_reg_value(it->second).size();
  }
 
  // header vector length check
  reg_column_width = reg_column_width > headers.at(0).size() ? reg_column_width : headers.at(0).size();
  val_column_width = val_column_width > headers.at(1).size() ? val_column_width : headers.at(1).size();
 
  table_width = table_width + reg_column_width + val_column_width;
 
  if (title.size())
    table_stream << boost::format("%=s\n") % boost::io::group(std::setw(table_width), std::setfill('-'), title);
 
  if (headers.at(0).size() || headers.at(1).size()) {
    table_stream << boost::format("+-%=s-+-%=s-+\n") %
                      boost::io::group(std::setw(reg_column_width), std::setfill('-'), "") %
                      boost::io::group(std::setw(val_column_width), std::setfill('-'), "");
    table_stream << boost::format("| %=s | %=s |\n") % boost::io::group(std::setw(reg_column_width), headers.at(0)) %
                      boost::io::group(std::setw(val_column_width), headers.at(1));
  }
 
  table_stream << boost::format("+-%=s-+-%=s-+\n") %
                    boost::io::group(std::setw(reg_column_width), std::setfill('-'), "") %
                    boost::io::group(std::setw(val_column_width), std::setfill('-'), "");
 
  for (auto it = data.begin(); it != data.end(); ++it) {
    table_stream << boost::format("| %=s | %=s |\n") % boost::io::group(std::setw(reg_column_width), it->first) %
                      boost::io::group(std::setw(val_column_width), format_reg_value(it->second));
  }
  table_stream << boost::format("+-%=s-+-%=s-+\n") %
                    boost::io::group(std::setw(reg_column_width), std::setfill('-'), "") %
                    boost::io::group(std::setw(val_column_width), std::setfill('-'), "");
 
  return table_stream.str();
}

format_reg_value() [1/3]

template<>

std::string dunedaq::timing::format_reg_value ( std::string reg_value, uint32_t  )

inline

Definition at line 137 of file toolbox.hxx.

{
  return reg_value;
}

format_reg_value() [2/3]

template<class T >

std::string dunedaq::timing::format_reg_value	(	T	reg_value,
		uint32_t	base = 16 )

Format reg-value

Returns

Definition at line 117 of file toolbox.hxx.

{
  std::stringstream value_stream;
  if (base == 16) {
    value_stream << "0x" << std::hex;
  } else if (base == 10) {
    value_stream << std::dec;
  } else {
    // TODO warning?
    TLOG() << "Unsupported number base: " << base;
    value_stream << std::dec;
  }
  value_stream << reg_value;
  return value_stream.str();
}

format_reg_value() [3/3]

template<>

std::string dunedaq::timing::format_reg_value ( uhal::ValWord< uint32_t > reg_value, uint32_t base )

inline

Definition at line 146 of file toolbox.hxx.

{
  std::stringstream value_stream;
  if (base == 16) {
    value_stream << "0x" << std::hex;
  } else if (base == 10) {
    value_stream << std::dec;
  } else {
    // TODO warning?
    TLOG() << "format_reg_value: unsupported number base: " << base;
    value_stream << std::dec;
  }
  value_stream << reg_value.value();
  return value_stream.str();
}

format_timestamp() [1/2]

std::string dunedaq::timing::format_timestamp	(	uhal::ValVector< uint32_t >	raw_timestamp,
		uint32_t	clock_frequency_hz )

""

Returns

Definition at line 233 of file toolbox.cpp.

{
  uint64_t timestamp = tstamp2int(raw_timestamp); // NOLINT(build/unsigned)
  return format_timestamp(timestamp, clock_frequency_hz);
}

format_timestamp() [2/2]

std::string dunedaq::timing::format_timestamp	(	uint64_t	raw_timestamp,
		uint32_t	clock_frequency_hz )

""

Returns

Definition at line 219 of file toolbox.cpp.

{
  std::time_t sec_from_epoch = raw_timestamp / clock_frequency_hz;
 
  struct tm* time = localtime(&sec_from_epoch); // NOLINT
  char time_buffer[32];
 
  strftime(time_buffer, sizeof time_buffer, "%a, %d %b %Y %H:%M:%S +0000", time);
  return time_buffer;
}

get_milliseconds_since_epoch()

int64_t dunedaq::timing::get_milliseconds_since_epoch

(

)

""

Returns

Definition at line 201 of file toolbox.cpp.

{
  // get the current time
  const auto now = std::chrono::system_clock::now();
 
  // transform the time into a duration since the epoch
  const auto epoch = now.time_since_epoch();
 
  // cast the duration into milliseconds
  const auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(epoch);
 
  // return the number of milliseconds
  return milliseconds.count();
}

get_seconds_since_epoch()

int64_t dunedaq::timing::get_seconds_since_epoch

(

)

""

Returns

Definition at line 183 of file toolbox.cpp.

{
  // get the current time
  const auto now = std::chrono::system_clock::now();
 
  // transform the time into a duration since the epoch
  const auto epoch = now.time_since_epoch();
 
  // cast the duration into seconds
  const auto seconds = std::chrono::duration_cast<std::chrono::seconds>(epoch);
 
  // return the number of seconds
  return seconds.count();
}

join()

template<typename C >

std::string dunedaq::timing::join	(	const C &	strings,
		const std::string &	delimiter = " " )

Converts a vector of strings in a delimiter-separated string.

Parameters

[in]	aStrings	Collection of strings
[in]	aDelimiter	A delimiter

Template Parameters

C	{ description }

Returns

{ description_of_the_return_value }

Definition at line 95 of file toolbox.hxx.

{
 
  if (strings.empty())
    return "";
 
  std::ostringstream string_stream;
 
  string_stream << *strings.begin();
 
  for (auto str_iter = std::next(strings.begin()); str_iter != strings.end(); ++str_iter) {
    string_stream << delimiter;
    string_stream << *str_iter;
  }
 
  return string_stream.str();
}

locate()

uint32_t dunedaq::timing::locate	(	float	xx[],
		unsigned long	n,
		float	x )

Definition at line 318 of file toolbox.cpp.

{
  uint32_t j, ju, jm, jl; // NOLINT(build/unsigned)
  int ascnd;
  jl = 0;                   // Initialize lower
  ju = n + 1;               // and upper limits.
  ascnd = (xx[n] >= xx[1]); // NOLINT
 
  while (ju - jl > 1) // If we are not yet done,
  {
    jm = (ju + jl) >> 1; // compute a midpoint,
 
    if ((x >= xx[jm]) == ascnd) // added additional parenthesis
    {
      jl = jm; // and replace either the lower limit
    } else {
      ju = jm; // or the upper limit, as appropriate.
    }
  } // Repeat until the test condition is satisfied.
 
  if (x == xx[1]) {        // NOLINT
    j = 1;                 // Then set the output
  } else if (x == xx[n]) { // NOLINT
    j = n - 1;
  } else {
    j = jl;
  }
 
  return j;
}

map_value_comparator()

template<typename M >

bool dunedaq::timing::map_value_comparator	(	typename M::value_type &	p1,
		typename M::value_type &	p2 )

Definition at line 58 of file toolbox.hxx.

{
  return p1.second < p2.second;
}

millisleep()

void dunedaq::timing::millisleep

(

const double &

time_in_milliseconds

)

Sleeps for a given number of milliseconds

Parameters

time_in_milliseconds

Number of milliseconds to sleep

Definition at line 83 of file toolbox.cpp.

{
  //  using namespace uhal;
  //  logging();
  double time_in_seconds(time_in_milliseconds / 1e3);
  int integer_part(static_cast<int>(time_in_seconds));
  double fractional_part(time_in_seconds - static_cast<double>(integer_part));
  struct timespec sleep_time, return_time;
  sleep_time.tv_sec = integer_part;
  sleep_time.tv_nsec = static_cast<long>(fractional_part * 1e9); // NOLINT
  nanosleep(&sleep_time, &return_time);
}

safe_enum_cast() [1/2]

template<typename T , typename U >

T dunedaq::timing::safe_enum_cast	(	const U &	value,
		const std::vector< T > &	valid )

safe_enum_cast() [2/2]

template<typename T , typename U >

T dunedaq::timing::safe_enum_cast	(	const U &	value,
		const std::vector< T > &	valid,
		const T &	def )

Definition at line 85 of file toolbox.hxx.

{
  typename std::vector<T>::const_iterator it = std::find(valid.begin(), valid.end(), static_cast<T>(value));
  return (it != valid.end() ? *it : def);
}

sanitize()

template<typename T >

std::vector< T > dunedaq::timing::sanitize

(

const std::vector< T > &

vec

)

Definition at line 67 of file toolbox.hxx.

{
  // Sanitise the inputs, by copying
  std::vector<uint32_t> sorted(vec);
 
  // ...sorting...
  std::sort(sorted.begin(), sorted.end());
 
  // and delete the duplicates (erase+unique require a sorted vector to delete duplicates)
  sorted.erase(std::unique(sorted.begin(), sorted.end()), sorted.end());
 
  return sorted;
}

shell_expand_paths()

std::vector< std::string > dunedaq::timing::shell_expand_paths

(

const std::string &

path

)

Expand the path

Parameters

path	path to expand

Returns

vector of expanded paths

Definition at line 114 of file toolbox.cpp.

{
 
  std::vector<std::string> paths;
  wordexp_t substituted_path;
  int code = wordexp(path.c_str(), &substituted_path, WRDE_NOCMD);
  if (code)
    throw runtime_error("Failed expanding path: " + path);
 
  for (std::size_t i = 0; i != substituted_path.we_wordc; i++)
    paths.push_back(substituted_path.we_wordv[i]);
 
  wordfree(&substituted_path);
 
  return paths;
}

shellExpandPath()

std::string dunedaq::timing::shellExpandPath

(

const std::string &

path

)

Performs variable subsitutition on path

Parameters

path	Path to expand

Returns

Expanded path

Definition at line 134 of file toolbox.cpp.

{
  std::vector<std::string> paths = shell_expand_paths(path);
 
  if (paths.size() > 1)
    throw runtime_error("Failed to expand: multiple matches found");
 
  return paths[0];
}

short_vec_fmt()

template<typename T >

std::string dunedaq::timing::short_vec_fmt

(

const std::vector< T > &

vec

)

Definition at line 399 of file toolbox.hxx.

{
  if (vec.size() == 0)
    return "[]";
  else if (vec.size() == 1)
    return "[" + boost::lexical_cast<std::string>(vec.at(0)) + "]";
 
  std::ostringstream oss;
  oss << "[";
 
  // Initial search range
  T first = vec.at(0);
  T last = first;
  for (typename std::vector<T>::const_iterator it = vec.begin() + 1; it != vec.end(); it++) {
    // if *it is contiguous to last, carry on searching
    if ((*it) == (last + 1)) {
      last = *it;
      continue;
    }
 
    if (first == last)
      // if first and last are the same, this is an isolated number
      oss << first << ",";
    else
      // otherwise it's a range
      oss << first << "-" << last << ",";
 
    // *it is the first value of the new range
    first = *it;
    last = *it;
  }
 
  // Process the last range
  if (first == last)
    oss << first << ",";
  else
    oss << first << "-" << last << ",";
 
  // Is this actually necessary?
  // Replace final "," with a "]"
  oss.seekp(oss.tellp() - 1l);
  oss << "]";
 
  return oss.str();
}

snapshot() [1/2]

Snapshot dunedaq::timing::snapshot

(

const uhal::Node &

node

)

Walk & read the node structure.

snapshot( node ) -> { subnode:value }

snapshot( node ) -> { subnode:value }

Definition at line 42 of file toolbox.cpp.

{
  std::map<string, uhal::ValWord<uint32_t>> value_words; // NOLINT(build/unsigned)
 
  for (string n : node.getNodes()) {
    value_words.insert(make_pair(n, node.getNode(n).read()));
  }
  node.getClient().dispatch();
 
  Snapshot vals;
  std::map<string, uhal::ValWord<uint32_t>>::iterator it; // NOLINT(build/unsigned)
  for (it = value_words.begin(); it != value_words.end(); ++it)
    vals.insert(make_pair(it->first, it->second.value()));
 
  return vals;
}

snapshot() [2/2]

Snapshot dunedaq::timing::snapshot	(	const uhal::Node &	node,
		const std::string &	regex )

Walk & read the sub-nodes whose IDs match this regex.

Definition at line 63 of file toolbox.cpp.

{
  std::map<string, uhal::ValWord<uint32_t>> value_words; // NOLINT(build/unsigned)
 
  for (string n : node.getNodes(regex)) {
    value_words.insert(make_pair(n, node.getNode(n).read()));
  }
  node.getClient().dispatch();
 
  Snapshot vals;
  std::map<string, uhal::ValWord<uint32_t>>::iterator it; // NOLINT(build/unsigned)
  for (it = value_words.begin(); it != value_words.end(); ++it)
    vals.insert(make_pair(it->first, it->second.value()));
 
  return vals;
}

strprintf()

std::string dunedaq::timing::strprintf	(	const char *	fmt,
			... )

Formats a std::string in printf fashion

Parameters

[in]	aFmt	Format string
[in]	...	List of arguments

Returns

A formatted string

Definition at line 99 of file toolbox.cpp.

{
  char* ret;
  va_list ap;
  va_start(ap, fmt);
  vasprintf(&ret, fmt, ap); // NOLINT
  va_end(ap);
  std::string str(ret);
  free(ret);
  return str;
}

throw_if_not_file()

void dunedaq::timing::throw_if_not_file

(

const std::string &

path

)

Checks that the input path corresponds to an existing filesystem item which is a file

Parameters

path	Path to file

Definition at line 147 of file toolbox.cpp.

{
 
  // FIXME: Review the implementation. The function never returns
  namespace fs = boost::filesystem;
 
  // Check that the path exists and that it's not a directory
  fs::path cfgFile(path);
  if (!fs::exists(cfgFile)) {
    throw FileNotFound(ERS_HERE, path);
  } else if (fs::is_directory(cfgFile)) {
    throw FileIsDirectory(ERS_HERE, path);
  }
 
  //    return true;
}

to_string()

template<typename T >

std::string dunedaq::timing::to_string

(

const T &

v

)

Definition at line 49 of file toolbox.hxx.

{
  return boost::lexical_cast<std::string>(v);
}

tstamp2int()

uint64_t dunedaq::timing::tstamp2int

(

uhal::ValVector< uint32_t >

raw_timestamp

)

""

Returns

Definition at line 175 of file toolbox.cpp.

{
  return (uint64_t)raw_timestamp[0] + ((uint64_t)raw_timestamp[1] << 32); // NOLINT(build/unsigned)
}

vec_fmt()

template<typename T >

std::string dunedaq::timing::vec_fmt

(

const std::vector< T > &

vec

)

Definition at line 382 of file toolbox.hxx.

{
  std::ostringstream oss;
  oss << "[";
 
  for (typename std::vector<T>::const_iterator it = vec.begin(); it != vec.end(); it++)
    oss << *it << ",";
  oss.seekp(oss.tellp() - 1l);
  oss << "]";
 
  return oss.str();
}