cond::payloadInspector Namespace Reference

Classes
class	Histogram1
class	Histogram2D
class	HistoryPlot
struct	ModuleVersion
class	Plot2D
class	Plot3D
struct	PlotAnnotations
class	PlotBase
class	PlotImage
class	PlotImpl
class	PlotImpl< MULTI_IOV, 0 >
class	PlotImpl< SINGLE_IOV, 0 >
class	PlotImpl< UNSPECIFIED_IOV, 0 >
class	PlotImpl< UNSPECIFIED_IOV, 1 >
class	PlotImpl< UNSPECIFIED_IOV, NTAGS >
class	RunHistoryPlot
class	ScatterPlot
struct	TagReference
class	TimeHistoryPlot

Typedefs
template<typename PayloadType , IOVMultiplicity IOV_M = UNSPECIFIED_IOV>
using	Histogram1D = Histogram1< float, PayloadType, UNSPECIFIED_IOV >
template<typename PayloadType , IOVMultiplicity IOV_M = UNSPECIFIED_IOV>
using	Histogram1DD = Histogram1< double, PayloadType, UNSPECIFIED_IOV >

Enumerations
enum	IOVMultiplicity { UNSPECIFIED_IOV = 0, MULTI_IOV = 1, SINGLE_IOV = 2 }

Functions
std::string	serialize (const PlotAnnotations &annotations, const std::string &imageFileName)
template<typename X , typename Y >
std::string	serialize (const PlotAnnotations &annotations, const std::vector< std::tuple< X, Y >> &data)
template<typename X , typename Y , typename Z >
std::string	serialize (const PlotAnnotations &annotations, const std::vector< std::tuple< X, Y, Z >> &data)
std::string	serializeAnnotations (const PlotAnnotations &annotations)
template<typename V >
std::string	serializeValue (const std::string &entryLabel, const std::pair< V, V > &value)
template<>
std::string	serializeValue (const std::string &entryLabel, const std::string &value)
template<typename V >
std::string	serializeValue (const std::string &entryLabel, const std::tuple< V, std::string > &value)
template<typename V >
std::string	serializeValue (const std::string &entryLabel, const V &value)
void	setAnnotations (const std::string &type, const std::string &title, IOVMultiplicity IOV_M, int NTAGS, PlotAnnotations &target)

Variables
static const char *const	JSON_FORMAT_VERSION = "1.0"

Typedef Documentation

Histogram1D

template<typename PayloadType , IOVMultiplicity IOV_M = UNSPECIFIED_IOV>

using cond::payloadInspector::Histogram1D = typedef Histogram1<float, PayloadType, UNSPECIFIED_IOV>

Definition at line 790 of file PayloadInspector.h.

Histogram1DD

template<typename PayloadType , IOVMultiplicity IOV_M = UNSPECIFIED_IOV>

using cond::payloadInspector::Histogram1DD = typedef Histogram1<double, PayloadType, UNSPECIFIED_IOV>

Definition at line 793 of file PayloadInspector.h.

Enumeration Type Documentation

IOVMultiplicity

enum cond::payloadInspector::IOVMultiplicity

Enumerator
UNSPECIFIED_IOV
MULTI_IOV
SINGLE_IOV

Definition at line 295 of file PayloadInspector.h.

{ UNSPECIFIED_IOV = 0, MULTI_IOV = 1, SINGLE_IOV = 2 };

Function Documentation

serialize() [1/3]

std::string cond::payloadInspector::serialize ( const PlotAnnotations &  annotations, const std::string &  imageFileName  )

inline

Definition at line 182 of file PayloadInspector.h.

                                                                                                   {
      std::stringstream ss;
      ss << "{";
      ss << serializeAnnotations(annotations);
      ss << ",";
      ss << "\"file\": \"" << imageFileName << "\"";
      ss << "}";
      return ss.str();
    }

References serializeAnnotations(), and contentValuesCheck::ss.

serialize() [2/3]

template<typename X , typename Y >

std::string cond::payloadInspector::serialize	(	const PlotAnnotations &	annotations,
		const std::vector< std::tuple< X, Y >> &	data
	)

Definition at line 132 of file PayloadInspector.h.

                                                                                                   {
      // prototype implementation...
      std::stringstream ss;
      ss << "{";
      ss << serializeAnnotations(annotations);
      ss << ",";
      ss << "\"data\": [";
      bool first = true;
      for (auto d : data) {
        auto serializedX = serializeValue("x", std::get<0>(d));
        auto serializedY = serializeValue("y", std::get<1>(d));
 
        // N.B.:
        //  we output to JSON only if the stringstream
        //  from serializeValue is not empty
 
        if (!serializedY.empty()) {
          if (!first) {
            ss << ",";
          }
          ss << " { " << serializedX << ", " << serializedY << " }";
          first = false;
        }
      }
      ss << "]";
      ss << "}";
      return ss.str();
    }

References ztail::d, data, first, serializeAnnotations(), serializeValue(), and contentValuesCheck::ss.

Referenced by cond::payloadInspector::Plot2D< PayloadType, X, Y, MULTI_IOV, 1 >::serializeData(), cond::payloadInspector::Plot3D< PayloadType, float, float, float, IOV_M, 1 >::serializeData(), and cond::payloadInspector::PlotImage< PayloadType >::serializeData().

serialize() [3/3]

template<typename X , typename Y , typename Z >

std::string cond::payloadInspector::serialize	(	const PlotAnnotations &	annotations,
		const std::vector< std::tuple< X, Y, Z >> &	data
	)

Definition at line 162 of file PayloadInspector.h.

                                                                                                      {
      // prototype implementation...
      std::stringstream ss;
      ss << "{";
      ss << serializeAnnotations(annotations);
      ss << ",";
      ss << "\"data\": [";
      bool first = true;
      for (auto d : data) {
        if (!first)
          ss << ",";
        ss << " { " << serializeValue("x", std::get<0>(d)) << ", " << serializeValue("y", std::get<1>(d)) << ", "
           << serializeValue("z", std::get<2>(d)) << " }";
        first = false;
      }
      ss << "]";
      ss << "}";
      return ss.str();
    }

References ztail::d, data, first, serializeAnnotations(), serializeValue(), and contentValuesCheck::ss.

serializeAnnotations()

std::string cond::payloadInspector::serializeAnnotations ( const PlotAnnotations &  annotations )

inline

Definition at line 116 of file PayloadInspector.h.

                                                                              {
      std::stringstream ss;
      ss << "\"version\": \"" << JSON_FORMAT_VERSION << "\",";
      ss << "\"annotations\": {";
      bool first = true;
      for (const auto& a : annotations.m) {
        if (!first)
          ss << ",";
        ss << "\"" << a.first << "\":\"" << a.second << "\"";
        first = false;
      }
      ss << "}";
      return ss.str();
    }

References a, first, JSON_FORMAT_VERSION, cond::payloadInspector::PlotAnnotations::m, and contentValuesCheck::ss.

Referenced by serialize().

serializeValue() [1/4]

template<typename V >

std::string cond::payloadInspector::serializeValue	(	const std::string &	entryLabel,
		const std::pair< V, V > &	value
	)

Definition at line 108 of file PayloadInspector.h.

                                                                                      {
      std::stringstream ss;
      ss << serializeValue(entryLabel, value.first);
      ss << ", ";
      ss << serializeValue(entryLabel + "_err", value.second);
      return ss.str();
    }

References serializeValue(), and contentValuesCheck::ss.

serializeValue() [2/4]

template<>

std::string cond::payloadInspector::serializeValue ( const std::string &  entryLabel, const std::string &  value  )

inline

Definition at line 90 of file PayloadInspector.h.

                                                                                         {
      std::stringstream ss;
      ss << "\"" << entryLabel << "\":\"" << value << "\"";
      return ss.str();
    }

References contentValuesCheck::ss.

serializeValue() [3/4]

template<typename V >

std::string cond::payloadInspector::serializeValue	(	const std::string &	entryLabel,
		const std::tuple< V, std::string > &	value
	)

Definition at line 98 of file PayloadInspector.h.

                                                                                               {
      std::stringstream ss;
      ss << serializeValue(entryLabel, std::get<0>(value));
      ss << ", ";
      ss << serializeValue(entryLabel + "_label", std::get<1>(value));
      return ss.str();
    }

References serializeValue(), and contentValuesCheck::ss.

serializeValue() [4/4]

template<typename V >

std::string cond::payloadInspector::serializeValue	(	const std::string &	entryLabel,
		const V &	value
	)

Definition at line 65 of file PayloadInspector.h.

                                                                          {
      std::stringstream ss;
 
      // N.B.:
      //  This hack is to output a line to stringstream only in case the
      //  return type of getFromPayload is a std::pair<bool, float>
      //  and the bool is true. This allows to control which points should
      //  enter the trend and which should not.
 
      if constexpr (std::is_same_v<V, std::pair<bool, float>>) {
        if (value.first) {
          ss << "\"" << entryLabel << "\":" << value.second;
        }
      } else if constexpr (std::is_same_v<V, double>) {
        if ((value - int(value)) == 0) {
          ss.precision(0);
        }
        ss << "\"" << entryLabel << "\":" << std::fixed << value;
      } else {
        ss << "\"" << entryLabel << "\":" << value;
      }
      return ss.str();
    }

References alignBH_cfg::fixed, contentValuesCheck::ss, cms::cuda::V, and relativeConstraints::value.

Referenced by serialize(), and serializeValue().

setAnnotations()

void cond::payloadInspector::setAnnotations ( const std::string &  type, const std::string &  title, IOVMultiplicity  IOV_M, int  NTAGS, PlotAnnotations &  target  )

inline

Definition at line 297 of file PayloadInspector.h.

                                                                                                                  {
      target.m[PlotAnnotations::PLOT_TYPE_K] = type;
      target.m[PlotAnnotations::TITLE_K] = title;
      target.ntags = NTAGS;
      target.singleIov = (IOV_M == SINGLE_IOV);
    }

References cond::payloadInspector::PlotAnnotations::PLOT_TYPE_K, SINGLE_IOV, filterCSVwithJSON::target, runGCPTkAlMap::title, and cond::payloadInspector::PlotAnnotations::TITLE_K.

Referenced by cond::payloadInspector::PlotImpl< IOV_M, 0 >::PlotImpl(), cond::payloadInspector::PlotImpl< UNSPECIFIED_IOV, NTAGS >::PlotImpl(), cond::payloadInspector::PlotImpl< MULTI_IOV, 0 >::PlotImpl(), cond::payloadInspector::PlotImpl< SINGLE_IOV, 0 >::PlotImpl(), cond::payloadInspector::PlotImpl< UNSPECIFIED_IOV, 0 >::PlotImpl(), and cond::payloadInspector::PlotImpl< UNSPECIFIED_IOV, 1 >::PlotImpl().

Variable Documentation

JSON_FORMAT_VERSION

const char* const cond::payloadInspector::JSON_FORMAT_VERSION = "1.0"

static

Definition at line 61 of file PayloadInspector.h.

Referenced by serializeAnnotations().