Manage collection of histograms, load histogram definitions from XML file and book histograms by calling MonitorObjectProvider routines. More...

#include <CSCDQM_Collection.h>

Public Types
typedef xercesc::DOMDocument	DOMDocument
typedef xercesc::DOMElement	DOMElement
typedef xercesc::DOMNamedNodeMap	DOMNamedNodeMap
typedef xercesc::DOMNode	DOMNode
typedef xercesc::DOMNodeList	DOMNodeList
typedef xercesc::XercesDOMParser	XercesDOMParser
typedef xercesc::XMLException	XMLException
typedef xercesc::XMLPlatformUtils	XMLPlatformUtils
typedef xercesc::XMLString	XMLString
Public Member Functions
void	bookCSCHistos (const HwId crateId, const HwId dmbId) const
	Book Chamber Histograms.
void	bookCSCHistos (const HistoId hid, const HwId crateId, const HwId dmbId, const HwId addId) const
	Book Chamber Histogram with additional identifier (On Demand)
void	bookDDUHistos (const HwId dduId) const
	Book DDU histograms.
void	bookEMUHistos () const
	Book EMU histograms.
void	bookFEDHistos (const HwId fedId) const
	Book FED histograms.
	Collection (Configuration *const p_config)
	Constructor.
const bool	isOnDemand (const HistoName &name) const
	Check if the histogram is on demand (by histogram name)
void	load ()
	Load XML file and fill definition map(s)
void	printCollection () const
	Print collection of available histograms and their parameters.
Private Member Functions
void	book (const HistoDef &h, const CoHistoProps &p, const std::string &folder) const
	Book histogram.
Static Private Member Functions
static const bool	checkHistoValue (const CoHistoProps &h, const std::string &name, std::string &value)
	Find string histogram value in map.
static const bool	checkHistoValue (const CoHistoProps &h, const std::string &name, int &value)
	get Histogram int value out of the map and return boolean result
static const bool	checkHistoValue (const CoHistoProps &h, const std::string name, double &value)
	get Histogram double value out of the map and return boolean result
static std::string &	getHistoValue (const CoHistoProps &h, const std::string &name, std::string &value, const std::string &def_value="")
	Find string histogram value in map.
static int &	getHistoValue (const CoHistoProps &h, const std::string &name, int &value, const int &def_value=0)
	get Histogram int value out of the map and
static double &	getHistoValue (const CoHistoProps &h, const std::string name, double &value, const int def_value=0.0)
	get Histogram double value out of the map and
static void	getNodeProperties (DOMNode *&node, CoHistoProps &hp)
	Extract and write single histogram properties from XML node to map.
static const int	ParseAxisLabels (const std::string &s, std::map< int, std::string > &labels)
	Parse Axis label string and return values in vector.
Private Attributes
CoHistoMap	collection
Configuration *	config

Detailed Description

Manage collection of histograms, load histogram definitions from XML file and book histograms by calling MonitorObjectProvider routines.

Definition at line 73 of file CSCDQM_Collection.h.

Member Typedef Documentation

typedef xercesc::DOMDocument cscdqm::Collection::DOMDocument

Definition at line 76 of file CSCDQM_Collection.h.

typedef xercesc::DOMElement cscdqm::Collection::DOMElement

Definition at line 77 of file CSCDQM_Collection.h.

typedef xercesc::DOMNamedNodeMap cscdqm::Collection::DOMNamedNodeMap

Definition at line 80 of file CSCDQM_Collection.h.

typedef xercesc::DOMNode cscdqm::Collection::DOMNode

Definition at line 78 of file CSCDQM_Collection.h.

typedef xercesc::DOMNodeList cscdqm::Collection::DOMNodeList

Definition at line 79 of file CSCDQM_Collection.h.

typedef xercesc::XercesDOMParser cscdqm::Collection::XercesDOMParser

Definition at line 84 of file CSCDQM_Collection.h.

typedef xercesc::XMLException cscdqm::Collection::XMLException

Definition at line 81 of file CSCDQM_Collection.h.

typedef xercesc::XMLPlatformUtils cscdqm::Collection::XMLPlatformUtils

Definition at line 83 of file CSCDQM_Collection.h.

typedef xercesc::XMLString cscdqm::Collection::XMLString

Definition at line 82 of file CSCDQM_Collection.h.

Constructor & Destructor Documentation

data refman pasoursint CMSSW_6_1_1 src DQM CSCMonitorModule plugins CSCDQM_Collection cc cscdqm::Collection::Collection ( Configuration *const p_config )

Constructor.

Parameters:

p_config Pointer to Global configuration object

Definition at line 28 of file CSCDQM_Collection.cc.

Member Function Documentation

void cscdqm::Collection::book	(	const HistoDef &	h,
		const CoHistoProps &	p,
		const std::string &	folder
	)		const `[private]`

Book histogram.

Parameters:

h	Histogram definition to book
p	Map of Histogram properties
folder	folder to book histograms to

Returns:

Check if this histogram is included in booking by filters

Put histogram into cache

Definition at line 416 of file CSCDQM_Collection.cc.

References config, cscdqm::Configuration::fnPutHisto, and LOG_INFO.

Referenced by bookCSCHistos(), bookDDUHistos(), bookEMUHistos(), and bookFEDHistos().

                                              {
      LOG_INFO << "MOFilter excluded " << name << " from booking"; 
      config->fnPutHisto(h, me);
      return;
    }

    int i1, i2, i3;
    double d1, d2, d3, d4, d5, d6;
    bool ondemand = (getHistoValue(p, XML_BOOK_ONDEMAND, s, XML_BOOK_ONDEMAND_FALSE) == XML_BOOK_ONDEMAND_TRUE ? true : false);
      
    if (!checkHistoValue(p, XML_BOOK_HISTO_TYPE, type))   { throw Exception("Histogram does not have type!"); }
    checkHistoValue(p, XML_BOOK_HISTO_TITLE, title);

    if (ondemand) {
      title = h.processTitle(title);
    }

    if (type == "h1") {
      me = config->fnBook(
        HistoBookRequest(h, H1D, type, folder, title,
          getHistoValue(p, "XBins", i1, 1),
          getHistoValue(p, "XMin",  d1, 0),
          getHistoValue(p, "XMax",  d2, 1)));
    } else
    if(type == "h2") {
      me = config->fnBook(
        HistoBookRequest(h, H2D, type, folder, title,
          getHistoValue(p, "XBins", i1, 1),
          getHistoValue(p, "XMin",  d1, 0),
          getHistoValue(p, "XMax",  d2, 1),
          getHistoValue(p, "YBins", i2, 1),
          getHistoValue(p, "YMin",  d3, 0),
          getHistoValue(p, "YMax",  d4, 1)));
    } else
    if(type == "h3") {
      me = config->fnBook(
        HistoBookRequest(h, H3D, type, folder, title,
          getHistoValue(p, "XBins", i1, 1),
          getHistoValue(p, "XMin",  d1, 0),
          getHistoValue(p, "XMax",  d2, 1),
          getHistoValue(p, "YBins", i2, 1),
          getHistoValue(p, "YMin",  d3, 0),
          getHistoValue(p, "YMax",  d4, 1),
          getHistoValue(p, "ZBins", i3, 1),
          getHistoValue(p, "ZMin",  d5, 0),
          getHistoValue(p, "ZMax",  d6, 1)));
    } else
    if(type == "hp") {
      me = config->fnBook(
        HistoBookRequest(h, PROFILE, type, folder, title,
          getHistoValue(p, "XBins", i1, 1),
          getHistoValue(p, "XMin",  d1, 0),
          getHistoValue(p, "XMax",  d2, 1)));
        /*
        HistoBookRequest(h, PROFILE, type, folder, title,
          getHistoValue(p, "XBins", i1, 1),
          getHistoValue(p, "XMin",  d1, 0),
          getHistoValue(p, "XMax",  d2, 1),
          getHistoValue(p, "YBins", i2, 1),
          getHistoValue(p, "YMin",  d3, 0),
          getHistoValue(p, "YMax",  d4, 1)));
        */
    } else
    if(type == "hp2") {
      me = config->fnBook(
        HistoBookRequest(h, PROFILE2D, type, folder, title,
          getHistoValue(p, "XBins", i1, 1),
          getHistoValue(p, "XMin",  d1, 0),
          getHistoValue(p, "XMax",  d2, 1),
          getHistoValue(p, "YBins", i2, 1),
          getHistoValue(p, "YMin",  d3, 0),
          getHistoValue(p, "YMax",  d4, 1),
          getHistoValue(p, "ZBins", i3, 1),
          getHistoValue(p, "ZMin",  d5, 0),
          getHistoValue(p, "ZMax",  d6, 1)));
    } else { 
      throw Exception("Can not book histogram with type: " + type);
    }

    if(me != NULL) {

      LockType lock(me->mutex);
      TH1 *th = me->getTH1Lock();

      if(checkHistoValue(p, "XTitle", s)) {
        if (ondemand) {
          s = h.processTitle(s);
        }
        me->setAxisTitle(s, 1);
      }

      if(checkHistoValue(p, "YTitle", s)) {
        if (ondemand) {
          s = h.processTitle(s);
        }
        me->setAxisTitle(s, 2);
      }

      if(checkHistoValue(p, "ZTitle", s)) {
        if (ondemand) {
          s = h.processTitle(s);
        }
          me->setAxisTitle(s, 3);
        }

      if(checkHistoValue(p, "SetOption", s)) th->SetOption(s.c_str());
      if(checkHistoValue(p, "SetStats", i1)) th->SetStats(i1);
      th->SetFillColor(getHistoValue(p, "SetFillColor", i1, DEF_HISTO_COLOR));
      if(checkHistoValue(p, "SetXLabels", s)) {
        std::map<int, std::string> labels;
        ParseAxisLabels(s, labels);
        for (std::map<int, std::string>::iterator l_itr = labels.begin(); l_itr != labels.end(); ++l_itr) {
          th->GetXaxis()->SetBinLabel(l_itr->first, l_itr->second.c_str());
        }
      }
      if(checkHistoValue(p, "SetYLabels", s)) {
        std::map<int, std::string> labels;
        ParseAxisLabels(s, labels);
        for (std::map<int, std::string>::iterator l_itr = labels.begin(); l_itr != labels.end(); ++l_itr) {
          th->GetYaxis()->SetBinLabel(l_itr->first, l_itr->second.c_str());
        }
      }
      if(checkHistoValue(p, "LabelOption", s)) {
        std::vector<std::string> v;
        if(2 == Utility::tokenize(s, v, ",")) {
          th->LabelsOption(v[0].c_str(), v[1].c_str());
        }
      }
      if(checkHistoValue(p, "SetLabelSize", s)) {
        std::vector<std::string> v;
        if(2 == Utility::tokenize(s, v, ",")) {
          th->SetLabelSize((double) atof(v[0].c_str()), v[1].c_str());
        }
      }
      if(checkHistoValue(p, "SetTitleOffset", s)) {
        std::vector<std::string> v;
        if(2 == Utility::tokenize(s, v, ",")) {
          th->SetTitleOffset((double) atof(v[0].c_str()), v[1].c_str());
        }
      }
      if(checkHistoValue(p, "SetMinimum", d1)) th->SetMinimum(d1);
      if(checkHistoValue(p, "SetMaximum", d1)) me->SetMaximum(d1);
      if(checkHistoValue(p, "SetNdivisionsX", i1)) {
        th->SetNdivisions(i1, "X");
        th->GetXaxis()->CenterLabels(true);
      }
      if(checkHistoValue(p, "SetNdivisionsY", i1)) {
        th->SetNdivisions(i1, "Y");
        th->GetYaxis()->CenterLabels(true);
      }
      if(checkHistoValue(p, "SetTickLengthX", d1)) th->SetTickLength(d1, "X");
      if(checkHistoValue(p, "SetTickLengthY", d1)) th->SetTickLength(d1, "Y");
      if(checkHistoValue(p, "SetLabelSizeX", d1)) th->SetLabelSize(d1, "X");
      if(checkHistoValue(p, "SetLabelSizeY", d1)) th->SetLabelSize(d1, "Y");
      if(checkHistoValue(p, "SetLabelSizeZ", d1)) th->SetLabelSize(d1, "Z");
      if(checkHistoValue(p, "SetErrorOption", s)) reinterpret_cast<TProfile*>(th)->SetErrorOption(s.c_str());

      lock.unlock();

    }

    LOG_DEBUG << "[Collection::book] booked " << h.getFullPath() << " (" << me << ")"; 

    config->fnPutHisto(h, me);

  }

void cscdqm::Collection::bookCSCHistos	(	const HwId	crateId,
		const HwId	dmbId
	)		const

Book Chamber Histograms.

Parameters:

crateId	CSC Crate Id
dmbId	CSC DMB Id

Returns:

Definition at line 365 of file CSCDQM_Collection.cc.

References book(), checkHistoValue(), config, cscdqm::HistoDef::getHistoIdByName(), getHistoValue(), j, gen::k, AlCaHLTBitMon_QueryRunRegistry::string, cscdqm::XML_BOOK_NAME_FROM, cscdqm::XML_BOOK_NAME_TO, cscdqm::XML_BOOK_ONDEMAND, and cscdqm::XML_BOOK_ONDEMAND_FALSE.

                               {
      const CoHisto hs = i->second;
      for (CoHisto::const_iterator j = hs.begin(); j != hs.end(); j++) {
        std::string s = "";
        HistoId hid = 0;
        if (HistoDef::getHistoIdByName(j->first, hid)) {
          if (getHistoValue(j->second, XML_BOOK_ONDEMAND, s, XML_BOOK_ONDEMAND_FALSE) == XML_BOOK_ONDEMAND_FALSE) {
            CSCHistoDef hdef(hid, crateId, dmbId);
            book(hdef, j->second, config->getFOLDER_CSC());
          } else {
            int from = 0, to = 0;
            if (checkHistoValue(j->second, XML_BOOK_NAME_FROM, from) && checkHistoValue(j->second, XML_BOOK_NAME_TO, to)) {
              for (int k = from; k <= to; k++) {
                CSCHistoDef hdef(hid, crateId, dmbId, k);
                book(hdef, j->second, config->getFOLDER_CSC());
              }
            }
          }
        }
      }
    }
  }

void cscdqm::Collection::bookCSCHistos	(	const HistoId	hid,
		const HwId	crateId,
		const HwId	dmbId,
		const HwId	addId
	)		const

Book Chamber Histogram with additional identifier (On Demand)

Parameters:

hid	Histogram Identifier
crateId	CSC Crate Id
dmbId	CSC DMB Id
addId	CSC Additional identifier, ex. Layer Id, ALCT Id, etc.

Returns:

Definition at line 398 of file CSCDQM_Collection.cc.

References book(), config, j, and cscdqm::h::names.

                               {
      CoHisto::const_iterator j = i->second.find(h::names[hid]);
      if (j != i->second.end()) {
        CSCHistoDef hdef(hid, crateId, dmbId, addId);
        book(hdef, j->second, config->getFOLDER_CSC());
      }
    }
  }

void cscdqm::Collection::bookDDUHistos ( const HwId dduId ) const

Book DDU histograms.

Parameters:

dduId DDU Id

Returns:

Definition at line 342 of file CSCDQM_Collection.cc.

References book(), config, cscdqm::HistoDef::getHistoIdByName(), getHistoValue(), j, AlCaHLTBitMon_QueryRunRegistry::string, cscdqm::XML_BOOK_ONDEMAND, and cscdqm::XML_BOOK_ONDEMAND_FALSE.

                               {
      const CoHisto hs = i->second;
      for (CoHisto::const_iterator j = hs.begin(); j != hs.end(); j++) {
        std::string s = "";
        if (getHistoValue(j->second, XML_BOOK_ONDEMAND, s, XML_BOOK_ONDEMAND_FALSE) == XML_BOOK_ONDEMAND_FALSE) {
          HistoId hid = 0;
          if (HistoDef::getHistoIdByName(j->first, hid)) {
            DDUHistoDef hdef(hid, dduId);
            book(hdef, j->second, config->getFOLDER_DDU());
          }
        }
      }
    }
  }

void cscdqm::Collection::bookEMUHistos ( ) const

Book EMU histograms.

Returns:

Definition at line 298 of file CSCDQM_Collection.cc.

References book(), config, cscdqm::HistoDef::getHistoIdByName(), getHistoValue(), j, AlCaHLTBitMon_QueryRunRegistry::string, cscdqm::XML_BOOK_ONDEMAND, and cscdqm::XML_BOOK_ONDEMAND_FALSE.

                               {
      const CoHisto hs = i->second;
      for (CoHisto::const_iterator j = hs.begin(); j != hs.end(); j++) {
        std::string s = "";
        if (getHistoValue(j->second, XML_BOOK_ONDEMAND, s, XML_BOOK_ONDEMAND_FALSE) == XML_BOOK_ONDEMAND_FALSE) {
          HistoId hid = 0;
          if (HistoDef::getHistoIdByName(j->first, hid)) {
            EMUHistoDef hdef(hid);
            book(hdef, j->second, config->getFOLDER_EMU());
          }
        }
      }
    }
  }

void cscdqm::Collection::bookFEDHistos ( const HwId fedId ) const

Book FED histograms.

Parameters:

fedId FED Id

Returns:

Definition at line 320 of file CSCDQM_Collection.cc.

References book(), config, cscdqm::HistoDef::getHistoIdByName(), getHistoValue(), j, AlCaHLTBitMon_QueryRunRegistry::string, cscdqm::XML_BOOK_ONDEMAND, and cscdqm::XML_BOOK_ONDEMAND_FALSE.

Referenced by cscdqm::Dispatcher::getHisto().

                               {
      const CoHisto hs = i->second;
      for (CoHisto::const_iterator j = hs.begin(); j != hs.end(); j++) {
        std::string s = "";
        if (getHistoValue(j->second, XML_BOOK_ONDEMAND, s, XML_BOOK_ONDEMAND_FALSE) == XML_BOOK_ONDEMAND_FALSE) {
          HistoId hid = 0;
          if (HistoDef::getHistoIdByName(j->first, hid)) {
            FEDHistoDef hdef(hid, fedId);
            book(hdef, j->second, config->getFOLDER_FED());
          }
        }
      }
    }
  }

const bool cscdqm::Collection::checkHistoValue	(	const CoHistoProps &	h,
		const std::string &	name,
		std::string &	value
	)		`[static, private]`

Find string histogram value in map.

Parameters:

h	Histogram map
name	parameter name
value	handler for parameter value

Returns:: true if parameter found and filled, false - otherwise

Definition at line 176 of file CSCDQM_Collection.cc.

Referenced by bookCSCHistos().

                     {
      return false;
    }
    value = i->second;
    return true;
  }

const bool cscdqm::Collection::checkHistoValue	(	const CoHistoProps &	h,
		const std::string &	name,
		int &	value
	)		`[static, private]`

get Histogram int value out of the map and return boolean result

Parameters:

h	Histogram map
name	parameter name
value	handler for parameter value

Returns:: true if parameter found and filled, false - otherwise

Definition at line 192 of file CSCDQM_Collection.cc.

                     {
      return false;
    } 
    if(EOF == std::sscanf(i->second.c_str(), "%d", &value)) {
      return false;
    }
    return true;
  }

const bool cscdqm::Collection::checkHistoValue	(	const CoHistoProps &	h,
		const std::string	name,
		double &	value
	)		`[static, private]`

get Histogram double value out of the map and return boolean result

Parameters:

h	Histogram map
name	parameter name
value	handler for parameter value

Returns:: true if parameter found and filled, false - otherwise

Definition at line 211 of file CSCDQM_Collection.cc.

                     {
      return false;
    }
    if(EOF == std::sscanf(i->second.c_str(), "%lf", &value)) {
      return false;
    }
    return true;
  }

int & cscdqm::Collection::getHistoValue	(	const CoHistoProps &	h,
		const std::string &	name,
		int &	value,
		const int &	def_value = `0`
	)		`[static, private]`

get Histogram int value out of the map and

Parameters:

h	Histogram map
name	parameter name
value	handler for parameter value
def_value	default value if parameter not found

Returns:: pointer to value

Definition at line 245 of file CSCDQM_Collection.cc.

                                          {
      value = def_value;
    }
    return value;
  }

std::string & cscdqm::Collection::getHistoValue	(	const CoHistoProps &	h,
		const std::string &	name,
		std::string &	value,
		const std::string &	def_value = `""`
	)		`[static, private]`

Find string histogram value in map.

Parameters:

h	Histogram map
name	parameter name
value	handler for parameter value
def_value	default value if parameter not found

Returns:: pointer to value

Definition at line 230 of file CSCDQM_Collection.cc.

Referenced by bookCSCHistos(), bookDDUHistos(), bookEMUHistos(), bookFEDHistos(), and isOnDemand().

                                          {
      value = def_value;
    }
    return value;
  }

double & cscdqm::Collection::getHistoValue	(	const CoHistoProps &	h,
		const std::string	name,
		double &	value,
		const int	def_value = `0.0`
	)		`[static, private]`

get Histogram double value out of the map and

Parameters:

h	Histogram map
name	parameter name
value	handler for parameter value
def_value	default value if parameter not found

Returns:: pointer to value

Definition at line 260 of file CSCDQM_Collection.cc.

                                          {
      value = def_value;
    }
    return value;
  }

void cscdqm::Collection::getNodeProperties	(	DOMNode *&	node,
		CoHistoProps &	p
	)		`[static, private]`

Extract and write single histogram properties from XML node to map.

Parameters:

node	XML node
p	List of properties to fill

Returns:

Definition at line 149 of file CSCDQM_Collection.cc.

References asciidump::attributes, i, j, mergeVDriftHistosByStation::name, AlCaHLTBitMon_QueryRunRegistry::string, and relativeConstraints::value.

                                                     {
      DOMNode* node = props->item(j);
      if (node->getNodeType() != DOMNode::ELEMENT_NODE) { continue; }
      std::string name  = XMLString::transcode(node->getNodeName());
      std::string value = XMLString::transcode(node->getTextContent());
      DOMNamedNodeMap* attributes = node->getAttributes();
      if (attributes) {
        for (uint32_t i = 0; i < attributes->getLength(); i++) {
          DOMNode* attribute = attributes->item(i);
          std::string aname  = XMLString::transcode(attribute->getNodeName());
          std::string avalue = XMLString::transcode(attribute->getNodeValue());
          p[name + "_" + aname] = avalue;
        }
      }
      p[name] = value;
    }
  }

const bool cscdqm::Collection::isOnDemand ( const HistoName & name ) const

Check if the histogram is on demand (by histogram name)

Parameters:

name	name of the histogram

Returns:: true if this histogram is on demand, false - otherwise

Definition at line 595 of file CSCDQM_Collection.cc.

References getHistoValue(), j, alignCSCRings::s, AlCaHLTBitMon_QueryRunRegistry::string, cscdqm::XML_BOOK_ONDEMAND, cscdqm::XML_BOOK_ONDEMAND_FALSE, and cscdqm::XML_BOOK_ONDEMAND_TRUE.

                               {
      CoHisto hs  = i->second;
      CoHisto::const_iterator j = hs.find(name);
      if (j != hs.end()) { 
        std::string s;
        return (getHistoValue(j->second, XML_BOOK_ONDEMAND, s, XML_BOOK_ONDEMAND_FALSE) == XML_BOOK_ONDEMAND_TRUE);
      }
    }
    return false;
  }

void cscdqm::Collection::load ( )

Load XML file and fill definition map(s)

Returns:

Load histogram definition

Load histogram

Definition at line 37 of file CSCDQM_Collection.cc.

                                               {
      return;
    }

    try {

      XMLPlatformUtils::Initialize();

      {

        XercesDOMParser parser;

        parser.setValidationScheme(XercesDOMParser::Val_Always);
        parser.setDoNamespaces(true);
        parser.setDoSchema(true);
        parser.setExitOnFirstFatalError(true);
        parser.setValidationConstraintFatal(true);
        XMLFileErrorHandler eh;
        parser.setErrorHandler(&eh);

        parser.parse(config->getBOOKING_XML_FILE().c_str());
        DOMDocument *doc = parser.getDocument();
        DOMNode *docNode = (DOMNode*) doc->getDocumentElement();
  
        DOMNodeList *itemList = docNode->getChildNodes();

        CoHisto definitions;
        for (uint32_t i = 0; i < itemList->getLength(); i++) {
  
          DOMNode* node = itemList->item(i);
          if (node->getNodeType() != DOMNode::ELEMENT_NODE) { continue; }

          std::string nodeName = XMLString::transcode(node->getNodeName());

          if (nodeName.compare(XML_BOOK_DEFINITION) == 0) {

            CoHistoProps dp;
            getNodeProperties(node, dp);

            DOMElement* el = dynamic_cast<DOMElement*>(node);
            std::string id(XMLString::transcode(el->getAttribute(XMLString::transcode(XML_BOOK_DEFINITION_ID))));
            definitions.insert(make_pair(id, dp));

          } else

          if (nodeName.compare(XML_BOOK_HISTOGRAM) == 0) {
  
            CoHistoProps hp;

            DOMElement* el = dynamic_cast<DOMElement*>(node);
            if (el->hasAttribute(XMLString::transcode(XML_BOOK_DEFINITION_REF))) {
              std::string id(XMLString::transcode(el->getAttribute(XMLString::transcode(XML_BOOK_DEFINITION_REF))));
              CoHistoProps d = definitions[id];
              for (CoHistoProps::iterator it = d.begin(); it != d.end(); it++) {
                hp[it->first] = it->second;
              }
            }

            getNodeProperties(node, hp);

            std::string name   = hp[XML_BOOK_HISTO_NAME];
            std::string prefix = hp[XML_BOOK_HISTO_PREFIX];

            // Check if this histogram is an ON DEMAND histogram?
            hp[XML_BOOK_ONDEMAND] = (Utility::regexMatch(REGEXP_ONDEMAND, name) ? XML_BOOK_ONDEMAND_TRUE : XML_BOOK_ONDEMAND_FALSE );

            LOG_DEBUG << "[Collection::load] loading " << prefix << "::" << name << " XML_BOOK_ONDEMAND = " << hp[XML_BOOK_ONDEMAND]; 
  
            CoHistoMap::iterator it = collection.find(prefix);
            if (it == collection.end()) {
              CoHisto h;
              h[name] = hp;
              collection[prefix] = h; 
            } else {
              it->second.insert(make_pair(name, hp));
            }

          }
        }

      }

      XMLPlatformUtils::Terminate();

    } catch (XMLException& e) {
      char* message = XMLString::transcode(e.getMessage());
      throw Exception(message);
    }

    for (CoHistoMap::const_iterator i = collection.begin(); i != collection.end(); i++) {
      LOG_INFO << i->second.size() << " " << i->first << " histograms defined";
    }
    
  }

const int cscdqm::Collection::ParseAxisLabels	(	const std::string &	s,
		std::map< int, std::string > &	labels
	)		`[static, private]`

Parse Axis label string and return values in vector.

Parameters:

s	source string to parse
labels	pointer to result vector

Returns:: number of labels found

Definition at line 273 of file CSCDQM_Collection.cc.

References diffTwoXMLs::label, and AlCaHLTBitMon_QueryRunRegistry::string.

                                 {
      std::string label_pair = tmp.substr(0, pos);
      tmp.replace(0, pos + 1, "");
      if (label_pair.find("=") != std::string::npos) {
        int nbin = strtol(label_pair.substr(0, label_pair.find("=")).c_str(), &stopstring, 10);
        std::string label = label_pair.substr(label_pair.find("=") + 1, label_pair.length());
        while (label.find("\'") != std::string::npos) {
          label.erase(label.find("\'"), 1);
        }
        labels[nbin] = label;
      }
      pos = tmp.find("|");
    }
    return labels.size();
  }

void cscdqm::Collection::printCollection ( ) const

Print collection of available histograms and their parameters.

Returns:

Definition at line 612 of file CSCDQM_Collection.cc.

                                                                                              {
      buffer << hdmi->first << " [" << std::endl;
      for(CoHisto::const_iterator hdi = hdmi->second.begin(); hdi != hdmi->second.end(); hdi++) {
        buffer << "   " << hdi->first << " [" << std::endl;
        for(CoHistoProps::const_iterator hi = hdi->second.begin(); hi != hdi->second.end(); hi++) {
          buffer << "     " << hi->first << " = " << hi->second << std::endl;
        }
        buffer << "   ]" << std::endl;
      }
      buffer << " ]" << std::endl;
    }
    LOG_INFO << buffer.str();
  }

Member Data Documentation

CoHistoMap cscdqm::Collection::collection [private]

Definition at line 113 of file CSCDQM_Collection.h.

Configuration* cscdqm::Collection::config [private]

Definition at line 112 of file CSCDQM_Collection.h.

Referenced by book(), bookCSCHistos(), bookDDUHistos(), bookEMUHistos(), and bookFEDHistos().

cscdqm::Collection Class Reference

Public Types

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation