jsoncollector::DataPoint Class Reference

#include <DataPoint.h>

Inheritance diagram for jsoncollector::DataPoint:

Public Member Functions
	DataPoint ()
	DataPoint (std::string const &source, std::string const &definition, bool fast=false)
void	deserialize (Json::Value &root) override
void	discardCollected (unsigned int forLumi)
std::string	fastOutCSV (int sid=-1)
std::vector< std::string > &	getData ()
std::string &	getDefinition ()
std::string const &	getName () const
void	makeStreamLumiMap (unsigned int size)
JsonMonitorable *	mergeAndRetrieveValue (unsigned int forLumi)
void	mergeAndSerialize (Json::Value &jsonRoot, unsigned int lumi, bool initJsonValue, int sid)
void	serialize (Json::Value &root) const override
void	serialize (Json::Value &root, bool rootInit, std::string const &input) const
void	setNBins (unsigned int *nBins)
void	setOperation (OperationType op)
void	setStreamLumiPtr (std::vector< unsigned int > *streamLumiPtr)
void	snap (unsigned int lumi)
void	snapGlobal (unsigned int lumi)
void	snapStreamAtomic (unsigned int lumi, unsigned int streamID)
void	trackDummy (std::string const &name, bool setNAifZeroUpdates)
void	trackMonitorable (JsonMonitorable const *monitorable, bool NAifZeroUpdates)
void	trackVectorUInt (std::string const &name, std::vector< unsigned int > const *monvec, bool NAifZeroUpdates)
void	trackVectorUIntAtomic (std::string const &name, std::vector< AtomicMonUInt *> const *monvec, bool NAifZeroUpdates)
void	updateDefinition (std::string const &definition)
	~DataPoint () override
Public Member Functions inherited from jsoncollector::JsonSerializable
virtual	~JsonSerializable ()

Static Public Attributes
static const std::string	DATA = "data"
static const std::string	DEFINITION = "definition"
static const std::string	SOURCE = "source"

Protected Attributes
uint32_t *	buf_ = nullptr
unsigned int	bufLen_ = 0
int	cacheI_
std::vector< std::string >	data_
std::string	definition_
unsigned int	fastIndex_ = 0
MonPtrMap	globalDataMap_
bool	isAtomic_ = false
bool	isCached_ = false
bool	isDummy_ = false
bool	isFastOnly_
bool	isStream_ = false
MonType	monType_
bool	NAifZeroUpdates_ = false
std::string	name_
unsigned int *	nBinsPtr_ = nullptr
OperationType	opType_
std::string	source_
std::vector< MonPtrMap >	streamDataMaps_
std::vector< unsigned int > *	streamLumisPtr_ = nullptr
void const *	tracked_ = nullptr

Detailed Description

Definition at line 36 of file DataPoint.h.

Constructor & Destructor Documentation

DataPoint() [1/2]

jsoncollector::DataPoint::DataPoint ( )

inline

Definition at line 38 of file DataPoint.h.

{}

DataPoint() [2/2]

jsoncollector::DataPoint::DataPoint ( std::string const &  source, std::string const &  definition, bool  fast = false  )

inline

Definition at line 40 of file DataPoint.h.

        : source_(source), definition_(definition), isFastOnly_(fast) {}

~DataPoint()

DataPoint::~DataPoint ( )

override

Definition at line 29 of file DataPoint.cc.

References buf_.

                      {
  if (buf_)
    delete[] buf_;
}

Member Function Documentation

deserialize()

void DataPoint::deserialize ( Json::Value &  root )

overridevirtual

JSON deserialization procedure for this class

Implements jsoncollector::JsonSerializable.

Definition at line 51 of file DataPoint.cc.

References DATA, data_, DEFINITION, definition_, mps_fire::i, SOURCE, and source_.

                                           {
  source_ = root.get(SOURCE, "").asString();
  definition_ = root.get(DEFINITION, "").asString();
  if (root.get(DATA, "").isArray()) {
    unsigned int size = root.get(DATA, "").size();
    for (unsigned int i = 0; i < size; i++) {
      data_.push_back(root.get(DATA, "")[i].asString());
    }
  }
}

discardCollected()

void DataPoint::discardCollected

(

unsigned int

forLumi

)

Definition at line 405 of file DataPoint.cc.

References globalDataMap_, mps_fire::i, and streamDataMaps_.

                                                  {
  for (unsigned int i = 0; i < streamDataMaps_.size(); i++) {
    auto itr = streamDataMaps_[i].find(lumi);
    if (itr != streamDataMaps_[i].end())
      streamDataMaps_[i].erase(lumi);
  }

  auto itr = globalDataMap_.find(lumi);
  if (itr != globalDataMap_.end())
    globalDataMap_.erase(lumi);
}

fastOutCSV()

std::string DataPoint::fastOutCSV

(

int

sid = -1

)

Definition at line 244 of file DataPoint.cc.

References fastIndex_, isAtomic_, isStream_, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, and tracked_.

                                       {
  if (tracked_) {
    if (isStream_) {
      std::stringstream ss;
      if (sid < 0) {
        if (isAtomic_) {
          //        if ATOMIC_LEVEL>0
          //        ss << (unsigned int) (static_cast<std::vector<AtomicMonUInt*>*>(tracked_))->at(fastIndex_)->load(std::memory_order_relaxed);

          ss << (unsigned int)*((static_cast<std::vector<AtomicMonUInt *> const *>(tracked_))->at(fastIndex_));
          fastIndex_ = (fastIndex_ + 1) % (static_cast<std::vector<AtomicMonUInt *> const *>(tracked_))->size();
        } else {
          ss << (static_cast<std::vector<unsigned int> const *>(tracked_))->at(fastIndex_);
          fastIndex_ = (fastIndex_ + 1) % (static_cast<std::vector<unsigned int> const *>(tracked_))->size();
        }

      } else {
        if (isAtomic_)
          ss << (unsigned int)*((static_cast<std::vector<AtomicMonUInt *> const *>(tracked_))->at(unsigned(sid)));
        else
          ss << (static_cast<std::vector<unsigned int> const *>(tracked_))->at(unsigned(sid));
      }
      return ss.str();
    }
    return (static_cast<JsonMonitorable const *>(tracked_))->toString();
  }
  return std::string("");
}

getData()

std::vector<std::string>& jsoncollector::DataPoint::getData ( void  )

inline

Definition at line 56 of file DataPoint.h.

References data_.

{ return data_; }

getDefinition()

std::string& jsoncollector::DataPoint::getDefinition ( )

inline

Definition at line 57 of file DataPoint.h.

References definition_.

{ return definition_; }

getName()

std::string const& jsoncollector::DataPoint::getName ( void  ) const

inline

Definition at line 111 of file DataPoint.h.

References name_.

Referenced by plotting.Plot::draw().

{ return name_; }

makeStreamLumiMap()

void DataPoint::makeStreamLumiMap

(

unsigned int

size

)

Definition at line 105 of file DataPoint.cc.

References mps_fire::i, and streamDataMaps_.

Referenced by trackVectorUInt(), and trackVectorUIntAtomic().

                                                   {
  for (unsigned int i = 0; i < size; i++) {
    streamDataMaps_.push_back(MonPtrMap());
  }
}

mergeAndRetrieveValue()

JsonMonitorable * DataPoint::mergeAndRetrieveValue

(

unsigned int

forLumi

)

Definition at line 273 of file DataPoint.cc.

References jsoncollector::IntJ::add(), cms::cuda::assert(), cacheI_, mps_fire::i, isCached_, isStream_, monType_, streamDataMaps_, jsoncollector::TYPEUINT, relativeConstraints::value, and jsoncollector::IntJ::value().

                                                                   {
  assert(monType_ == TYPEUINT && isStream_);  //for now only support UINT and SUM for stream variables
  IntJ *newJ = new IntJ;
  for (unsigned int i = 0; i < streamDataMaps_.size(); i++) {
    auto itr = streamDataMaps_[i].find(lumi);
    if (itr != streamDataMaps_[i].end()) {
      newJ->add(static_cast<IntJ *>(itr->second.get())->value());
    }
  }
  cacheI_ = newJ->value();
  isCached_ = true;
  return newJ;  //assume the caller takes care of deleting the object
}

mergeAndSerialize()

void DataPoint::mergeAndSerialize	(	Json::Value &	jsonRoot,
		unsigned int	lumi,
		bool	initJsonValue,
		int	sid
	)

Definition at line 287 of file DataPoint.cc.

References cms::cuda::assert(), buf_, bufLen_, cacheI_, DATA, DEFINITION, definition_, jsoncollector::JsonMonitorable::getUpdates(), globalDataMap_, mps_fire::i, createfilelist::int, isCached_, isDummy_, isStream_, dqmiolumiharvest::j, monType_, NAifZeroUpdates_, nBinsPtr_, jsoncollector::OPHISTO, opType_, SOURCE, source_, contentValuesCheck::ss, streamDataMaps_, jsoncollector::TYPESTRING, jsoncollector::TYPEUINT, relativeConstraints::value, and jsoncollector::HistoJ< T >::value().

                                                                                                 {
  if (initJsonValue) {
    root[SOURCE] = source_;
    root[DEFINITION] = definition_;
  }

  if (isDummy_) {
    root[DATA].append("N/A");
    return;
  }
  if (!isStream_) {
    auto itr = globalDataMap_.find(lumi);
    if (itr != globalDataMap_.end()) {
      root[DATA].append(itr->second.get()->toString());
    } else {
      if (NAifZeroUpdates_)
        root[DATA].append("N/A");
      else if (monType_ == TYPESTRING)
        root[DATA].append("");
      else
        root[DATA].append("0");
    }
    return;
  } else {
    assert(monType_ == TYPEUINT);
    if (isCached_) {
      std::stringstream ss;
      ss << cacheI_;
      root[DATA].append(ss.str());
      return;
    }
    if (opType_ != OPHISTO) {  //sum is default
      std::stringstream ss;
      unsigned int updates = 0;
      unsigned int sum = 0;
      if (sid < 1)
        for (unsigned int i = 0; i < streamDataMaps_.size(); i++) {
          auto itr = streamDataMaps_[i].find(lumi);
          if (itr != streamDataMaps_[i].end()) {
            sum += static_cast<IntJ *>(itr->second.get())->value();
            updates++;
          }
        }
      else {
        auto itr = streamDataMaps_[unsigned(sid)].find(lumi);
        if (itr != streamDataMaps_[unsigned(sid)].end()) {
          sum += static_cast<IntJ *>(itr->second.get())->value();
          updates++;
        }
      }
      if (!updates && NAifZeroUpdates_)
        ss << "N/A";
      ss << sum;
      root[DATA].append(ss.str());
      return;
    }
    if (opType_ == OPHISTO) {
      if (nBinsPtr_ == nullptr) {
        root[DATA].append("N/A");
        return;
      }
      if (*nBinsPtr_ > bufLen_) {
        if (buf_)
          delete[] buf_;
        bufLen_ = *nBinsPtr_;
        buf_ = new uint32_t[bufLen_];
      }
      memset(buf_, 0, bufLen_ * sizeof(uint32_t));
      unsigned int updates = 0;
      if (sid < 1)
        for (unsigned int i = 0; i < streamDataMaps_.size(); i++) {
          auto itr = streamDataMaps_[i].find(lumi);
          if (itr != streamDataMaps_[i].end()) {
            HistoJ<unsigned int> *monObj = static_cast<HistoJ<unsigned int> *>(itr->second.get());
            updates += monObj->getUpdates();
            auto &hvec = monObj->value();
            for (unsigned int j = 0; j < hvec.size(); j++) {
              unsigned int thisbin = (unsigned int)hvec[j];
              if (thisbin < *nBinsPtr_) {
                buf_[thisbin]++;
              }
            }
          }
        }
      else {
        auto itr = streamDataMaps_[unsigned(sid)].find(lumi);
        if (itr != streamDataMaps_[unsigned(sid)].end()) {
          HistoJ<unsigned int> *monObj = static_cast<HistoJ<unsigned int> *>(itr->second.get());
          updates += monObj->getUpdates();
          auto &hvec = monObj->value();
          for (unsigned int j = 0; j < hvec.size(); j++) {
            unsigned int thisbin = (unsigned int)hvec[j];
            if (thisbin < *nBinsPtr_) {
              buf_[thisbin]++;
            }
          }
        }
      }
      std::stringstream ss;
      if (!*nBinsPtr_ || (!updates && NAifZeroUpdates_))
        ss << "N/A";
      else {
        ss << "[";
        if (*nBinsPtr_) {
          for (unsigned int i = 0; i < *nBinsPtr_ - 1; i++) {
            ss << buf_[i] << ",";
          }
          ss << buf_[*nBinsPtr_ - 1];
        }
        ss << "]";
      }
      root[DATA].append(ss.str());
      return;
    }
  }
}

serialize() [1/2]

void DataPoint::serialize ( Json::Value &  root ) const

overridevirtual

JSON serialization procedure for this class

Implements jsoncollector::JsonSerializable.

Definition at line 40 of file DataPoint.cc.

References mps_setup::append, DATA, data_, DEFINITION, definition_, mps_fire::i, SOURCE, and source_.

                                               {
  if (!source_.empty()) {
    root[SOURCE] = source_;
  }
  if (!definition_.empty()) {
    root[DEFINITION] = definition_;
  }
  for (unsigned int i = 0; i < data_.size(); i++)
    root[DATA].append(data_[i]);
}

serialize() [2/2]

void DataPoint::serialize	(	Json::Value &	root,
		bool	rootInit,
		std::string const &	input
	)		const

Functions specific to new monitoring implementation

Definition at line 111 of file DataPoint.cc.

References DATA, DEFINITION, definition_, input, SOURCE, and source_.

                                                                                      {
  if (rootInit) {
    if (!source_.empty())
      root[SOURCE] = source_;
    if (!definition_.empty())
      root[DEFINITION] = definition_;
  }
  root[DATA].append(input);
}

setNBins()

void jsoncollector::DataPoint::setNBins ( unsigned int *  nBins )

inline

Definition at line 109 of file DataPoint.h.

References seedmultiplicitymonitor_newtracking_cfi::nBins, and nBinsPtr_.

{ nBinsPtr_ = nBins; }

setOperation()

void jsoncollector::DataPoint::setOperation ( OperationType  op )

inline

Definition at line 91 of file DataPoint.h.

References findAndChange::op, and opType_.

{ opType_ = op; }

setStreamLumiPtr()

void jsoncollector::DataPoint::setStreamLumiPtr ( std::vector< unsigned int > *  streamLumiPtr )

inline

Definition at line 94 of file DataPoint.h.

References streamLumisPtr_.

{ streamLumisPtr_ = streamLumiPtr; }

snap()

void DataPoint::snap

(

unsigned int

lumi

)

Definition at line 121 of file DataPoint.cc.

References cms::cuda::assert(), mps_fire::i, isAtomic_, isCached_, isStream_, MAXUPDATES, monType_, nBinsPtr_, cms::cuda::nh, jsoncollector::OPHISTO, opType_, snapGlobal(), streamDataMaps_, streamLumisPtr_, tracked_, jsoncollector::TYPEINT, jsoncollector::TYPEUINT, and jsoncollector::IntJ::update().

                                      {
  isCached_ = false;
  if (isStream_) {
    if (monType_ == TYPEUINT) {
      for (unsigned int i = 0; i < streamDataMaps_.size(); i++) {
        unsigned int streamLumi_ = streamLumisPtr_->at(i);  //get currently processed stream lumi
        unsigned int monVal;

#if ATOMIC_LEVEL > 0
        if (isAtomic_)
          monVal =
              (static_cast<std::vector<AtomicMonUInt *> const *>(tracked_))->at(i)->load(std::memory_order_relaxed);
#else
        if (isAtomic_)
          monVal = *((static_cast<std::vector<AtomicMonUInt *> const *>(tracked_))->at(i));
#endif
        else
          monVal = (static_cast<std::vector<unsigned int> const *>(tracked_))->at(i);

        auto itr = streamDataMaps_[i].find(streamLumi_);
        if (itr == streamDataMaps_[i].end()) {
          if (opType_ == OPHISTO) {
            if (*nBinsPtr_) {
              HistoJ<unsigned int> *nh = new HistoJ<unsigned int>(1, MAXUPDATES);
              nh->update(monVal);
              streamDataMaps_[i][streamLumi_] = nh;
            }
          } else {  //default to SUM
            IntJ *nj = new IntJ;
            nj->update(monVal);
            streamDataMaps_[i][streamLumi_] = nj;
          }
        } else {
          if (opType_ == OPHISTO) {
            if (*nBinsPtr_) {
              (static_cast<HistoJ<unsigned int> *>(itr->second.get()))->update(monVal);
            }
          } else {
            *(static_cast<IntJ *>(itr->second.get())) = monVal;
          }
        }
      }
    } else
      assert(monType_ != TYPEINT);  //not yet implemented, application error
  } else
    snapGlobal(lumi);
}

snapGlobal()

void DataPoint::snapGlobal

(

unsigned int

lumi

)

Definition at line 169 of file DataPoint.cc.

References edm::service::monitor_file_utilities::concatenate(), globalDataMap_, isCached_, isStream_, BXlumiParameters_cfi::lumi, monType_, tracked_, jsoncollector::TYPEDOUBLE, jsoncollector::TYPEINT, jsoncollector::TYPESTRING, update, jsoncollector::IntJ::update(), jsoncollector::DoubleJ::update(), jsoncollector::StringJ::update(), and relativeConstraints::value.

Referenced by snap().

                                            {
  isCached_ = false;
  if (isStream_)
    return;
  auto itr = globalDataMap_.find(lumi);
  if (itr == globalDataMap_.end()) {
    if (monType_ == TYPEINT) {
      IntJ *ij = new IntJ;
      ij->update((static_cast<IntJ const *>(tracked_))->value());
      globalDataMap_[lumi] = ij;
    }
    if (monType_ == TYPEDOUBLE) {
      DoubleJ *dj = new DoubleJ;
      dj->update((static_cast<DoubleJ const *>(tracked_))->value());
      globalDataMap_[lumi] = dj;
    }
    if (monType_ == TYPESTRING) {
      StringJ *sj = new StringJ;
      sj->update((static_cast<StringJ const *>(tracked_))->value());
      globalDataMap_[lumi] = sj;
    }
  } else {
    if (monType_ == TYPEINT)
      static_cast<IntJ *>(itr->second.get())->update((static_cast<IntJ const *>(tracked_))->value());
    else if (monType_ == TYPEDOUBLE)
      static_cast<DoubleJ *>(itr->second.get())->update((static_cast<DoubleJ const *>(tracked_))->value());
    else if (monType_ == TYPESTRING)
      static_cast<StringJ *>(itr->second.get())->concatenate((static_cast<StringJ const *>(tracked_))->value());
  }
}

snapStreamAtomic()

void DataPoint::snapStreamAtomic	(	unsigned int	lumi,
		unsigned int	streamID
	)

Definition at line 200 of file DataPoint.cc.

References cms::cuda::assert(), h, isAtomic_, isCached_, isStream_, BXlumiParameters_cfi::lumi, MAXUPDATES, monType_, nBinsPtr_, jsoncollector::OPHISTO, opType_, streamDataMaps_, tracked_, jsoncollector::TYPEINT, jsoncollector::TYPEUINT, and update.

                                                                         {
  if (!isStream_ || !isAtomic_)
    return;
  isCached_ = false;
  if (monType_ == TYPEUINT) {
    unsigned int monVal;
#if ATOMIC_LEVEL > 0
    if (isAtomic_)
      monVal =
          (static_cast<std::vector<AtomicMonUInt *> const *>(tracked_))->at(streamID)->load(std::memory_order_relaxed);
#else
    if (isAtomic_)
      monVal = *((static_cast<std::vector<AtomicMonUInt *> const *>(tracked_))->at(streamID));
#endif
    else
      monVal = (static_cast<std::vector<unsigned int> const *>(tracked_))->at(streamID);

    auto itr = streamDataMaps_[streamID].find(lumi);
    if (itr == streamDataMaps_[streamID].end())  //insert
    {
      if (opType_ == OPHISTO) {
        if (*nBinsPtr_) {
          HistoJ<unsigned int> *h = new HistoJ<unsigned int>(1, MAXUPDATES);
          h->update(monVal);
          streamDataMaps_[streamID][lumi] = h;
        }
      } else {  //default to SUM

        IntJ *h = new IntJ;
        h->update(monVal);
        streamDataMaps_[streamID][lumi] = h;
      }
    } else {
      if (opType_ == OPHISTO) {
        if (*nBinsPtr_) {
          static_cast<HistoJ<unsigned int> *>(itr->second.get())->update(monVal);
        }
      } else
        *(static_cast<IntJ *>(itr->second.get())) = monVal;
    }
  } else
    assert(monType_ != TYPEINT);  //not yet implemented
}

trackDummy()

void jsoncollector::DataPoint::trackDummy ( std::string const &  name, bool  setNAifZeroUpdates  )

inline

Definition at line 82 of file DataPoint.h.

References isDummy_, NAifZeroUpdates_, Skims_PA_cff::name, and name_.

Referenced by jsoncollector::FastMonitor::commit().

                                                                    {
      name_ = name;
      isDummy_ = true;
      NAifZeroUpdates_ = true;
    }

trackMonitorable()

void DataPoint::trackMonitorable	(	JsonMonitorable const *	monitorable,
		bool	NAifZeroUpdates
	)

Definition at line 68 of file DataPoint.cc.

References cms::cuda::assert(), jsoncollector::JsonMonitorable::getName(), monType_, NAifZeroUpdates_, name_, tracked_, jsoncollector::TYPEDOUBLE, jsoncollector::TYPEINT, and jsoncollector::TYPESTRING.

                                                                                         {
  name_ = monitorable->getName();
  tracked_ = (void const *)monitorable;
  if (dynamic_cast<IntJ const *>(monitorable))
    monType_ = TYPEINT;
  else if (dynamic_cast<DoubleJ const *>(monitorable))
    monType_ = TYPEDOUBLE;
  else if (dynamic_cast<StringJ const *>(monitorable))
    monType_ = TYPESTRING;
  else
    assert(0);
  NAifZeroUpdates_ = NAifZeroUpdates;
}

trackVectorUInt()

void DataPoint::trackVectorUInt	(	std::string const &	name,
		std::vector< unsigned int > const *	monvec,
		bool	NAifZeroUpdates
	)

Definition at line 82 of file DataPoint.cc.

References isStream_, makeStreamLumiMap(), monType_, NAifZeroUpdates_, Skims_PA_cff::name, name_, tracked_, and jsoncollector::TYPEUINT.

                                                      {
  name_ = name;
  tracked_ = (void const *)monvec;
  isStream_ = true;
  monType_ = TYPEUINT;
  NAifZeroUpdates_ = NAifZeroUpdates;
  makeStreamLumiMap(monvec->size());
}

trackVectorUIntAtomic()

void DataPoint::trackVectorUIntAtomic	(	std::string const &	name,
		std::vector< AtomicMonUInt *> const *	monvec,
		bool	NAifZeroUpdates
	)

Definition at line 93 of file DataPoint.cc.

References isAtomic_, isStream_, makeStreamLumiMap(), monType_, NAifZeroUpdates_, Skims_PA_cff::name, name_, tracked_, and jsoncollector::TYPEUINT.

                                                            {
  name_ = name;
  tracked_ = (void const *)monvec;
  isStream_ = true;
  isAtomic_ = true;
  monType_ = TYPEUINT;
  NAifZeroUpdates_ = NAifZeroUpdates;
  makeStreamLumiMap(monvec->size());
}

updateDefinition()

void jsoncollector::DataPoint::updateDefinition ( std::string const &  definition )

inline

Definition at line 113 of file DataPoint.h.

References definition_.

{ definition_ = definition; }

Member Data Documentation

buf_

uint32_t* jsoncollector::DataPoint::buf_ = nullptr

protected

Definition at line 144 of file DataPoint.h.

Referenced by mergeAndSerialize(), and ~DataPoint().

bufLen_

unsigned int jsoncollector::DataPoint::bufLen_ = 0

protected

Definition at line 145 of file DataPoint.h.

Referenced by mergeAndSerialize().

cacheI_

int jsoncollector::DataPoint::cacheI_

protected

Definition at line 148 of file DataPoint.h.

Referenced by mergeAndRetrieveValue(), and mergeAndSerialize().

DATA

const std::string DataPoint::DATA = "data"

static

Definition at line 118 of file DataPoint.h.

Referenced by deserialize(), L1TriggerJSONMonitoring::globalEndLuminosityBlockSummary(), HLTriggerJSONMonitoring::globalEndLuminosityBlockSummary(), mergeAndSerialize(), and serialize().

data_

std::vector<std::string> jsoncollector::DataPoint::data_

protected

Definition at line 124 of file DataPoint.h.

Referenced by deserialize(), getData(), and serialize().

DEFINITION

const std::string DataPoint::DEFINITION = "definition"

static

Definition at line 117 of file DataPoint.h.

Referenced by deserialize(), L1TriggerJSONMonitoring::globalEndLuminosityBlockSummary(), HLTriggerJSONMonitoring::globalEndLuminosityBlockSummary(), mergeAndSerialize(), and serialize().

definition_

std::string jsoncollector::DataPoint::definition_

protected

Definition at line 123 of file DataPoint.h.

Referenced by deserialize(), getDefinition(), mergeAndSerialize(), serialize(), and updateDefinition().

fastIndex_

unsigned int jsoncollector::DataPoint::fastIndex_ = 0

protected

Definition at line 151 of file DataPoint.h.

Referenced by fastOutCSV().

globalDataMap_

MonPtrMap jsoncollector::DataPoint::globalDataMap_

protected

Definition at line 127 of file DataPoint.h.

Referenced by discardCollected(), mergeAndSerialize(), and snapGlobal().

isAtomic_

bool jsoncollector::DataPoint::isAtomic_ = false

protected

Definition at line 134 of file DataPoint.h.

Referenced by fastOutCSV(), snap(), snapStreamAtomic(), and trackVectorUIntAtomic().

isCached_

bool jsoncollector::DataPoint::isCached_ = false

protected

Definition at line 149 of file DataPoint.h.

Referenced by mergeAndRetrieveValue(), mergeAndSerialize(), snap(), snapGlobal(), and snapStreamAtomic().

isDummy_

bool jsoncollector::DataPoint::isDummy_ = false

protected

Definition at line 135 of file DataPoint.h.

Referenced by mergeAndSerialize(), and trackDummy().

isFastOnly_

bool jsoncollector::DataPoint::isFastOnly_

protected

Definition at line 137 of file DataPoint.h.

isStream_

bool jsoncollector::DataPoint::isStream_ = false

protected

Definition at line 133 of file DataPoint.h.

Referenced by fastOutCSV(), mergeAndRetrieveValue(), mergeAndSerialize(), snap(), snapGlobal(), snapStreamAtomic(), trackVectorUInt(), and trackVectorUIntAtomic().

monType_

MonType jsoncollector::DataPoint::monType_

protected

Definition at line 139 of file DataPoint.h.

Referenced by mergeAndRetrieveValue(), mergeAndSerialize(), snap(), snapGlobal(), snapStreamAtomic(), trackMonitorable(), trackVectorUInt(), and trackVectorUIntAtomic().

NAifZeroUpdates_

bool jsoncollector::DataPoint::NAifZeroUpdates_ = false

protected

Definition at line 136 of file DataPoint.h.

Referenced by mergeAndSerialize(), trackDummy(), trackMonitorable(), trackVectorUInt(), and trackVectorUIntAtomic().

name_

std::string jsoncollector::DataPoint::name_

protected

Definition at line 141 of file DataPoint.h.

Referenced by getName(), trackDummy(), trackMonitorable(), trackVectorUInt(), and trackVectorUIntAtomic().

nBinsPtr_

unsigned int* jsoncollector::DataPoint::nBinsPtr_ = nullptr

protected

Definition at line 147 of file DataPoint.h.

Referenced by mergeAndSerialize(), setNBins(), snap(), and snapStreamAtomic().

opType_

OperationType jsoncollector::DataPoint::opType_

protected

Definition at line 140 of file DataPoint.h.

Referenced by mergeAndSerialize(), setOperation(), snap(), and snapStreamAtomic().

SOURCE

const std::string DataPoint::SOURCE = "source"

static

Definition at line 116 of file DataPoint.h.

Referenced by deserialize(), L1TriggerJSONMonitoring::globalEndLuminosityBlockSummary(), HLTriggerJSONMonitoring::globalEndLuminosityBlockSummary(), mergeAndSerialize(), and serialize().

source_

std::string jsoncollector::DataPoint::source_

protected

Definition at line 122 of file DataPoint.h.

Referenced by deserialize(), Config.Process::dumpConfig(), Config.Process::dumpPython(), mergeAndSerialize(), serialize(), and Config.Process::splitPython().

streamDataMaps_

std::vector<MonPtrMap> jsoncollector::DataPoint::streamDataMaps_

protected

Definition at line 126 of file DataPoint.h.

Referenced by discardCollected(), makeStreamLumiMap(), mergeAndRetrieveValue(), mergeAndSerialize(), snap(), and snapStreamAtomic().

streamLumisPtr_

std::vector<unsigned int>* jsoncollector::DataPoint::streamLumisPtr_ = nullptr

protected

Definition at line 131 of file DataPoint.h.

Referenced by setStreamLumiPtr(), and snap().

tracked_

void const* jsoncollector::DataPoint::tracked_ = nullptr

protected

Definition at line 128 of file DataPoint.h.

Referenced by fastOutCSV(), snap(), snapGlobal(), snapStreamAtomic(), trackMonitorable(), trackVectorUInt(), and trackVectorUIntAtomic().