emtf::Tree Class Reference

#include <Tree.h>

Public Member Functions
void	addXMLAttributes (TXMLEngine *xml, Node *node, XMLNodePointer_t np)
void	buildTree (int nodeLimit)
void	calcError ()
Node *	filterEvent (Event *e)
Node *	filterEventRecursive (Node *node, Event *e)
void	filterEvents (std::vector< Event * > &tEvents)
void	filterEventsRecursive (Node *node)
double	getBoostWeight (void) const
int	getNumTerminalNodes ()
Node *	getRootNode ()
void	getSplitValues (std::vector< std::vector< double >> &v)
void	getSplitValuesRecursive (Node *node, std::vector< std::vector< double >> &v)
std::list< Node * > &	getTerminalNodes ()
void	loadFromCondPayload (const L1TMuonEndCapForest::DTree &tree)
void	loadFromCondPayloadRecursive (const L1TMuonEndCapForest::DTree &tree, const L1TMuonEndCapForest::DTreeNode &node, Node *tnode)
void	loadFromXML (const char *filename)
void	loadFromXMLRecursive (TXMLEngine *xml, XMLNodePointer_t node, Node *tnode)
Tree &	operator= (const Tree &tree)
void	rankVariables (std::vector< double > &v)
void	rankVariablesRecursive (Node *node, std::vector< double > &v)
void	saveToXML (const char *filename)
void	saveToXMLRecursive (TXMLEngine *xml, Node *node, XMLNodePointer_t np)
void	setBoostWeight (double wgt)
void	setRootNode (Node *sRootNode)
void	setTerminalNodes (std::list< Node * > &sTNodes)
	Tree ()
	Tree (const Tree &tree)
	Tree (std::vector< std::vector< Event * >> &cEvents)
	Tree (Tree &&tree)
	~Tree ()

Private Member Functions
Node *	copyFrom (const Node *local_root)
void	findLeafs (Node *local_root, std::list< Node * > &tn)

Private Attributes
double	boostWeight
int	numTerminalNodes
double	rmsError
Node *	rootNode
std::list< Node * >	terminalNodes
unsigned	xmlVersion

Detailed Description

Definition at line 15 of file Tree.h.

Constructor & Destructor Documentation

Tree() [1/4]

Tree::Tree

(

)

Definition at line 30 of file Tree.cc.

           {
  rootNode = new Node("root");
 
  terminalNodes.push_back(rootNode);
  numTerminalNodes = 1;
  boostWeight = 0;
  xmlVersion = 2017;
}

References boostWeight, numTerminalNodes, rootNode, terminalNodes, and xmlVersion.

Tree() [2/4]

Tree::Tree

(

std::vector< std::vector< Event * >> &

cEvents

)

Definition at line 39 of file Tree.cc.

                                                {
  rootNode = new Node("root");
  rootNode->setEvents(cEvents);
 
  terminalNodes.push_back(rootNode);
  numTerminalNodes = 1;
  boostWeight = 0;
  xmlVersion = 2017;
}

References boostWeight, numTerminalNodes, rootNode, emtf::Node::setEvents(), terminalNodes, and xmlVersion.

~Tree()

Tree::~Tree

(

)

Definition at line 52 of file Tree.cc.

            {
  // When the tree is destroyed it will delete all of the nodes in the tree.
  // The deletion begins with the rootnode and continues recursively.
  if (rootNode)
    delete rootNode;
}

References rootNode.

Tree() [3/4]

Tree::Tree

(

const Tree &

tree

)

if( numTerminalNodes != terminalNodes.size() ) throw std::runtime_error();

Definition at line 59 of file Tree.cc.

                           {
  // unfortunately, authors of these classes didn't use const qualifiers
  rootNode = copyFrom(const_cast<Tree&>(tree).getRootNode());
  numTerminalNodes = tree.numTerminalNodes;
  rmsError = tree.rmsError;
  boostWeight = tree.boostWeight;
  xmlVersion = tree.xmlVersion;
 
  terminalNodes.resize(0);
  // find new leafs
  findLeafs(rootNode, terminalNodes);
 
}

References boostWeight, copyFrom(), findLeafs(), getRootNode(), numTerminalNodes, rmsError, rootNode, terminalNodes, and xmlVersion.

Tree() [4/4]

Tree::Tree

(

Tree &&

tree

)

Definition at line 138 of file Tree.cc.

                      {
  if (rootNode)
    delete rootNode;  // this line is the only reason not to use default move constructor
  rootNode = tree.rootNode;
  terminalNodes = std::move(tree.terminalNodes);
  numTerminalNodes = tree.numTerminalNodes;
  rmsError = tree.rmsError;
  boostWeight = tree.boostWeight;
  xmlVersion = tree.xmlVersion;
}

References boostWeight, eostools::move(), numTerminalNodes, rmsError, rootNode, terminalNodes, and xmlVersion.

Member Function Documentation

addXMLAttributes()

void Tree::addXMLAttributes	(	TXMLEngine *	xml,
		Node *	node,
		XMLNodePointer_t	np
	)

Definition at line 381 of file Tree.cc.

                                                                            {
  // Convert Node members into XML attributes
  // and add them to the XMLEngine.
  xml->NewAttr(np, nullptr, "splitVar", numToStr(node->getSplitVariable()).c_str());
  xml->NewAttr(np, nullptr, "splitVal", numToStr(node->getSplitValue()).c_str());
  xml->NewAttr(np, nullptr, "fitVal", numToStr(node->getFitValue()).c_str());
}

References emtf::Node::getFitValue(), emtf::Node::getSplitValue(), emtf::Node::getSplitVariable(), np, and emtf::numToStr().

Referenced by saveToXML(), and saveToXMLRecursive().

buildTree()

void Tree::buildTree

(

int

nodeLimit

)

Definition at line 185 of file Tree.cc.

                                  {
  // We greedily pick the best terminal node to split.
  double bestNodeErrorReduction = -1;
  Node* nodeToSplit = nullptr;
 
  if (numTerminalNodes == 1) {
    rootNode->calcOptimumSplit();
    calcError();
    //        std::cout << std::endl << "  " << numTerminalNodes << " Nodes : " << rmsError << std::endl;
  }
 
  for (std::list<Node*>::iterator it = terminalNodes.begin(); it != terminalNodes.end(); it++) {
    if ((*it)->getErrorReduction() > bestNodeErrorReduction) {
      bestNodeErrorReduction = (*it)->getErrorReduction();
      nodeToSplit = (*it);
    }
  }
 
  //std::cout << "nodeToSplit size = " << nodeToSplit->getNumEvents() << std::endl;
 
  // If all of the nodes have one event we can't add any more nodes and reduce the error.
  if (nodeToSplit == nullptr)
    return;
 
  // Create daughter nodes, and link the nodes together appropriately.
  nodeToSplit->theMiracleOfChildBirth();
 
  // Get left and right daughters for reference.
  Node* left = nodeToSplit->getLeftDaughter();
  Node* right = nodeToSplit->getRightDaughter();
 
  // Update the list of terminal nodes.
  terminalNodes.remove(nodeToSplit);
  terminalNodes.push_back(left);
  terminalNodes.push_back(right);
  numTerminalNodes++;
 
  // Filter the events from the parent into the daughters.
  nodeToSplit->filterEventsToDaughters();
 
  // Calculate the best splits for the new nodes.
  left->calcOptimumSplit();
  right->calcOptimumSplit();
 
  // See if the error reduces as we add more nodes.
  calcError();
 
  if (numTerminalNodes % 1 == 0) {
    //        std::cout << "  " << numTerminalNodes << " Nodes : " << rmsError << std::endl;
  }
 
  // Repeat until done.
  if (numTerminalNodes < nodeLimit)
    buildTree(nodeLimit);
}

References calcError(), emtf::Node::calcOptimumSplit(), emtf::Node::filterEventsToDaughters(), emtf::Node::getLeftDaughter(), emtf::Node::getRightDaughter(), numTerminalNodes, rootNode, terminalNodes, and emtf::Node::theMiracleOfChildBirth().

calcError()

void Tree::calcError

(

)

Definition at line 171 of file Tree.cc.

                     {
  // Loop through the separate predictive regions (terminal nodes) and
  // add up the errors to get the error of the entire space.
 
  double totalSquaredError = 0;
 
  for (std::list<Node*>::iterator it = terminalNodes.begin(); it != terminalNodes.end(); it++) {
    totalSquaredError += (*it)->getTotalError();
  }
  rmsError = sqrt(totalSquaredError / rootNode->getNumEvents());
}

References emtf::Node::getNumEvents(), rmsError, rootNode, mathSSE::sqrt(), and terminalNodes.

Referenced by buildTree().

copyFrom()

Node * Tree::copyFrom ( const Node *  local_root )

private

Definition at line 93 of file Tree.cc.

                                           {
  // end-case
  if (!local_root)
    return nullptr;
 
  Node* lr = const_cast<Node*>(local_root);
 
  // recursion
  Node* left_new_child = copyFrom(lr->getLeftDaughter());
  Node* right_new_child = copyFrom(lr->getRightDaughter());
 
  // performing main work at this level
  Node* new_local_root = new Node(lr->getName());
  if (left_new_child)
    left_new_child->setParent(new_local_root);
  if (right_new_child)
    right_new_child->setParent(new_local_root);
  new_local_root->setLeftDaughter(left_new_child);
  new_local_root->setRightDaughter(right_new_child);
  new_local_root->setErrorReduction(lr->getErrorReduction());
  new_local_root->setSplitValue(lr->getSplitValue());
  new_local_root->setSplitVariable(lr->getSplitVariable());
  new_local_root->setFitValue(lr->getFitValue());
  new_local_root->setTotalError(lr->getTotalError());
  new_local_root->setAvgError(lr->getAvgError());
  new_local_root->setNumEvents(lr->getNumEvents());
  //    new_local_root->setEvents( lr->getEvents() ); // no ownership assumed for the events anyways
 
  return new_local_root;
}

References emtf::Node::getAvgError(), emtf::Node::getErrorReduction(), emtf::Node::getFitValue(), emtf::Node::getLeftDaughter(), emtf::Node::getName(), emtf::Node::getNumEvents(), emtf::Node::getRightDaughter(), emtf::Node::getSplitValue(), emtf::Node::getSplitVariable(), emtf::Node::getTotalError(), and emtf::Node::setParent().

Referenced by operator=(), and Tree().

filterEvent()

Node * Tree::filterEvent

(

Event *

e

)

Definition at line 276 of file Tree.cc.

                                {
  // Use trees which have already been built to fit a bunch of events
  // given by the tEvents vector.
 
  // Filter the event into a predictive region (terminal node).
  Node* node = filterEventRecursive(rootNode, e);
  return node;
}

References MillePedeFileConverter_cfg::e, filterEventRecursive(), and rootNode.

filterEventRecursive()

Node * Tree::filterEventRecursive	(	Node *	node,
		Event *	e
	)

Definition at line 287 of file Tree.cc.

                                                     {
  // Filter the event repeatedly into the daughter nodes until it
  // falls into a terminal node.
 
  Node* nextNode = node->filterEventToDaughter(e);
  if (nextNode == nullptr)
    return node;
 
  return filterEventRecursive(nextNode, e);
}

References MillePedeFileConverter_cfg::e, and emtf::Node::filterEventToDaughter().

Referenced by filterEvent().

filterEvents()

void Tree::filterEvents

(

std::vector< Event * > &

tEvents

)

Definition at line 243 of file Tree.cc.

                                                  {
  // Use trees which have already been built to fit a bunch of events
  // given by the tEvents vector.
 
  // Set the events to be filtered.
  rootNode->getEvents() = std::vector<std::vector<Event*>>(1);
  rootNode->getEvents()[0] = tEvents;
 
  // The tree now knows about the events it needs to fit.
  // Filter them into a predictive region (terminal node).
  filterEventsRecursive(rootNode);
}

References filterEventsRecursive(), emtf::Node::getEvents(), and rootNode.

filterEventsRecursive()

void Tree::filterEventsRecursive

(

Node *

node

)

Definition at line 258 of file Tree.cc.

                                           {
  // Filter the events repeatedly into the daughter nodes until they
  // fall into a terminal node.
 
  Node* left = node->getLeftDaughter();
  Node* right = node->getRightDaughter();
 
  if (left == nullptr || right == nullptr)
    return;
 
  node->filterEventsToDaughters();
 
  filterEventsRecursive(left);
  filterEventsRecursive(right);
}

References emtf::Node::filterEventsToDaughters(), emtf::Node::getLeftDaughter(), and emtf::Node::getRightDaughter().

Referenced by filterEvents().

findLeafs()

void Tree::findLeafs ( Node *  local_root, std::list< Node * > &  tn  )

private

Definition at line 124 of file Tree.cc.

                                                         {
  if (!local_root->getLeftDaughter() && !local_root->getRightDaughter()) {
    // leaf or ternimal node found
    tn.push_back(local_root);
    return;
  }
 
  if (local_root->getLeftDaughter())
    findLeafs(local_root->getLeftDaughter(), tn);
 
  if (local_root->getRightDaughter())
    findLeafs(local_root->getRightDaughter(), tn);
}

References emtf::Node::getLeftDaughter(), and emtf::Node::getRightDaughter().

Referenced by operator=(), and Tree().

getBoostWeight()

double emtf::Tree::getBoostWeight ( void  ) const

inline

Definition at line 57 of file Tree.h.

{ return boostWeight; }

References boostWeight.

Referenced by L1TMuonEndCapForestESProducer::produce().

getNumTerminalNodes()

int Tree::getNumTerminalNodes

(

)

Definition at line 165 of file Tree.cc.

{ return numTerminalNodes; }

References numTerminalNodes.

getRootNode()

Node * Tree::getRootNode

(

)

Definition at line 155 of file Tree.cc.

{ return rootNode; }

References rootNode.

Referenced by operator=(), L1TMuonEndCapForestESProducer::produce(), and Tree().

getSplitValues()

void Tree::getSplitValues

(

std::vector< std::vector< double >> &

v

)

Definition at line 364 of file Tree.cc.

{ getSplitValuesRecursive(rootNode, v); }

References getSplitValuesRecursive(), rootNode, and findQualityFiles::v.

getSplitValuesRecursive()

void Tree::getSplitValuesRecursive	(	Node *	node,
		std::vector< std::vector< double >> &	v
	)

Definition at line 336 of file Tree.cc.

                                                                              {
  // We recursively go through all of the nodes in the tree and find the
  // split points used for each split variable.
 
  Node* left = node->getLeftDaughter();
  Node* right = node->getRightDaughter();
 
  // Terminal nodes don't contribute.
  if (left == nullptr || right == nullptr)
    return;
 
  int sv = node->getSplitVariable();
  double sp = node->getSplitValue();
 
  if (sv == -1) {
    std::cout << "ERROR: negative split variable for nonterminal node." << std::endl;
    std::cout << "rankVarRecursive Split Variable = " << sv << std::endl;
  }
 
  // Add the split point to the list for the correct split variable.
  v[sv].push_back(sp);
 
  getSplitValuesRecursive(left, v);
  getSplitValuesRecursive(right, v);
}

References gather_cfg::cout, emtf::Node::getLeftDaughter(), emtf::Node::getRightDaughter(), emtf::Node::getSplitValue(), emtf::Node::getSplitVariable(), pfDeepBoostedJetPreprocessParams_cfi::sv, and findQualityFiles::v.

Referenced by getSplitValues().

getTerminalNodes()

std::list< Node * > & Tree::getTerminalNodes

(

)

Definition at line 161 of file Tree.cc.

{ return terminalNodes; }

References terminalNodes.

loadFromCondPayload()

void Tree::loadFromCondPayload

(

const L1TMuonEndCapForest::DTree &

tree

)

Definition at line 542 of file Tree.cc.

                                                                   {
  // start fresh in case this is not the only call to construct a tree
  if (rootNode)
    delete rootNode;
  rootNode = new Node("root");
 
  const L1TMuonEndCapForest::DTreeNode& mainnode = tree[0];
  loadFromCondPayloadRecursive(tree, mainnode, rootNode);
}

References loadFromCondPayloadRecursive(), and rootNode.

loadFromCondPayloadRecursive()

void Tree::loadFromCondPayloadRecursive	(	const L1TMuonEndCapForest::DTree &	tree,
		const L1TMuonEndCapForest::DTreeNode &	node,
		Node *	tnode
	)

Definition at line 552 of file Tree.cc.

                                                     {
  // Store gathered splitInfo into the node object.
  tnode->setSplitVariable(node.splitVar);
  tnode->setSplitValue(node.splitVal);
  tnode->setFitValue(node.fitVal);
 
  // If there are no daughters we are done.
  if (node.ileft == 0 || node.iright == 0)
    return;  // root cannot be anyone's child
  if (node.ileft >= tree.size() || node.iright >= tree.size())
    return;  // out of range addressing on purpose
 
  // If there are daughters link the node objects appropriately.
  tnode->theMiracleOfChildBirth();
  Node* tleft = tnode->getLeftDaughter();
  Node* tright = tnode->getRightDaughter();
 
  // Update the list of terminal nodes.
  terminalNodes.remove(tnode);
  terminalNodes.push_back(tleft);
  terminalNodes.push_back(tright);
  numTerminalNodes++;
 
  loadFromCondPayloadRecursive(tree, tree[node.ileft], tleft);
  loadFromCondPayloadRecursive(tree, tree[node.iright], tright);
}

References L1TMuonEndCapForest::DTreeNode::fitVal, emtf::Node::getLeftDaughter(), emtf::Node::getRightDaughter(), L1TMuonEndCapForest::DTreeNode::ileft, L1TMuonEndCapForest::DTreeNode::iright, numTerminalNodes, emtf::Node::setFitValue(), emtf::Node::setSplitValue(), emtf::Node::setSplitVariable(), L1TMuonEndCapForest::DTreeNode::splitVal, L1TMuonEndCapForest::DTreeNode::splitVar, terminalNodes, and emtf::Node::theMiracleOfChildBirth().

Referenced by loadFromCondPayload().

loadFromXML()

void Tree::loadFromXML

(

const char *

filename

)

Definition at line 437 of file Tree.cc.

                                           {
  // First create the engine.
  TXMLEngine* xml = new TXMLEngine;
 
  // Now try to parse xml file.
  XMLDocPointer_t xmldoc = xml->ParseFile(filename);
  if (xmldoc == nullptr) {
    delete xml;
    return;
  }
 
  // Get access to main node of the xml file.
  XMLNodePointer_t mainnode = xml->DocGetRootElement(xmldoc);
 
  // the original 2016 pT xmls define the source tree node to be the top-level xml node
  // while in 2017 TMVA's xmls every decision tree is wrapped in an extra block specifying boostWeight parameter
  // I choose to identify the format by checking the top xml node name that is a "BinaryTree" in 2017
  if (std::string("BinaryTree") == xml->GetNodeName(mainnode)) {
    XMLAttrPointer_t attr = xml->GetFirstAttr(mainnode);
    attr = xml->GetNextAttr(attr);
    boostWeight = (attr ? strtod(xml->GetAttrValue(attr), nullptr) : 0);
    // step inside the top-level xml node
    mainnode = xml->GetChild(mainnode);
    xmlVersion = 2017;
  } else {
    boostWeight = 0;
    xmlVersion = 2016;
  }
  // Recursively connect nodes together.
  loadFromXMLRecursive(xml, mainnode, rootNode);
 
  // Release memory before exit
  xml->FreeDoc(xmldoc);
  delete xml;
}

References boostWeight, corrVsCorr::filename, loadFromXMLRecursive(), rootNode, AlCaHLTBitMon_QueryRunRegistry::string, ExtractAppInfoFromXML::xmldoc, and xmlVersion.

loadFromXMLRecursive()

void Tree::loadFromXMLRecursive	(	TXMLEngine *	xml,
		XMLNodePointer_t	node,
		Node *	tnode
	)

Definition at line 475 of file Tree.cc.

                                                                                    {
  // Get the split information from xml.
  XMLAttrPointer_t attr = xml->GetFirstAttr(xnode);
  std::vector<std::string> splitInfo(3);
  if (xmlVersion >= 2017) {
    for (unsigned int i = 0, j = 0; i < 10; i++) {
      if (i == 3 || i == 4 || i == 6) {
        splitInfo[j++] = xml->GetAttrValue(attr);
      }
      attr = xml->GetNextAttr(attr);
    }
  } else {
    for (unsigned int i = 0; i < 3; i++) {
      splitInfo[i] = xml->GetAttrValue(attr);
      attr = xml->GetNextAttr(attr);
    }
  }
 
  // Convert strings into numbers.
  std::stringstream converter;
  int splitVar;
  double splitVal;
  double fitVal;
 
  converter << splitInfo[0];
  converter >> splitVar;
  converter.str("");
  converter.clear();
 
  converter << splitInfo[1];
  converter >> splitVal;
  converter.str("");
  converter.clear();
 
  converter << splitInfo[2];
  converter >> fitVal;
  converter.str("");
  converter.clear();
 
  // Store gathered splitInfo into the node object.
  tnode->setSplitVariable(splitVar);
  tnode->setSplitValue(splitVal);
  tnode->setFitValue(fitVal);
 
  // Get the xml daughters of the current xml node.
  XMLNodePointer_t xleft = xml->GetChild(xnode);
  XMLNodePointer_t xright = xml->GetNext(xleft);
 
  // If there are no daughters we are done.
  if (xleft == nullptr || xright == nullptr)
    return;
 
  // If there are daughters link the node objects appropriately.
  tnode->theMiracleOfChildBirth();
  Node* tleft = tnode->getLeftDaughter();
  Node* tright = tnode->getRightDaughter();
 
  // Update the list of terminal nodes.
  terminalNodes.remove(tnode);
  terminalNodes.push_back(tleft);
  terminalNodes.push_back(tright);
  numTerminalNodes++;
 
  loadFromXMLRecursive(xml, xleft, tleft);
  loadFromXMLRecursive(xml, xright, tright);
}

References emtf::Node::getLeftDaughter(), emtf::Node::getRightDaughter(), mps_fire::i, dqmiolumiharvest::j, numTerminalNodes, emtf::Node::setFitValue(), emtf::Node::setSplitValue(), emtf::Node::setSplitVariable(), terminalNodes, emtf::Node::theMiracleOfChildBirth(), and xmlVersion.

Referenced by loadFromXML().

operator=()

Tree & Tree::operator=

(

const Tree &

tree

)

if( numTerminalNodes != terminalNodes.size() ) throw std::runtime_error();

Definition at line 74 of file Tree.cc.

                                      {
  if (rootNode)
    delete rootNode;
  // unfortunately, authors of these classes didn't use const qualifiers
  rootNode = copyFrom(const_cast<Tree&>(tree).getRootNode());
  numTerminalNodes = tree.numTerminalNodes;
  rmsError = tree.rmsError;
  boostWeight = tree.boostWeight;
  xmlVersion = tree.xmlVersion;
 
  terminalNodes.resize(0);
  // find new leafs
  findLeafs(rootNode, terminalNodes);
 
 
  return *this;
}

References boostWeight, copyFrom(), findLeafs(), getRootNode(), numTerminalNodes, rmsError, rootNode, terminalNodes, and xmlVersion.

rankVariables()

void Tree::rankVariables

(

std::vector< double > &

v

)

Definition at line 332 of file Tree.cc.

{ rankVariablesRecursive(rootNode, v); }

References rankVariablesRecursive(), rootNode, and findQualityFiles::v.

rankVariablesRecursive()

void Tree::rankVariablesRecursive	(	Node *	node,
		std::vector< double > &	v
	)

Definition at line 300 of file Tree.cc.

                                                                  {
  // We recursively go through all of the nodes in the tree and find the
  // total error reduction for each variable. The one with the most
  // error reduction should be the most important.
 
  Node* left = node->getLeftDaughter();
  Node* right = node->getRightDaughter();
 
  // Terminal nodes don't contribute to error reduction.
  if (left == nullptr || right == nullptr)
    return;
 
  int sv = node->getSplitVariable();
  double er = node->getErrorReduction();
 
  //if(sv == -1)
  //{
  //std::cout << "ERROR: negative split variable for nonterminal node." << std::endl;
  //std::cout << "rankVarRecursive Split Variable = " << sv << std::endl;
  //std::cout << "rankVarRecursive Error Reduction = " << er << std::endl;
  //}
 
  // Add error reduction to the current total for the appropriate
  // variable.
  v[sv] += er;
 
  rankVariablesRecursive(left, v);
  rankVariablesRecursive(right, v);
}

References emtf::Node::getErrorReduction(), emtf::Node::getLeftDaughter(), emtf::Node::getRightDaughter(), emtf::Node::getSplitVariable(), pfDeepBoostedJetPreprocessParams_cfi::sv, and findQualityFiles::v.

Referenced by rankVariables().

saveToXML()

void Tree::saveToXML

(

const char *

filename

)

Definition at line 391 of file Tree.cc.

                                  {
  TXMLEngine* xml = new TXMLEngine();
 
  // Add the root node.
  XMLNodePointer_t root = xml->NewChild(nullptr, nullptr, rootNode->getName().c_str());
  addXMLAttributes(xml, rootNode, root);
 
  // Recursively write the tree to XML.
  saveToXMLRecursive(xml, rootNode, root);
 
  // Make the XML Document.
  XMLDocPointer_t xmldoc = xml->NewDoc();
  xml->DocSetRootElement(xmldoc, root);
 
  // Save to file.
  xml->SaveDoc(xmldoc, c);
 
  // Clean up.
  xml->FreeDoc(xmldoc);
  delete xml;
}

References addXMLAttributes(), HltBtagPostValidation_cff::c, emtf::Node::getName(), rootNode, saveToXMLRecursive(), and ExtractAppInfoFromXML::xmldoc.

saveToXMLRecursive()

void Tree::saveToXMLRecursive	(	TXMLEngine *	xml,
		Node *	node,
		XMLNodePointer_t	np
	)

Definition at line 415 of file Tree.cc.

                                                                              {
  Node* l = node->getLeftDaughter();
  Node* r = node->getRightDaughter();
 
  if (l == nullptr || r == nullptr)
    return;
 
  // Add children to the XMLEngine.
  XMLNodePointer_t left = xml->NewChild(np, nullptr, "left");
  XMLNodePointer_t right = xml->NewChild(np, nullptr, "right");
 
  // Add attributes to the children.
  addXMLAttributes(xml, l, left);
  addXMLAttributes(xml, r, right);
 
  // Recurse.
  saveToXMLRecursive(xml, l, left);
  saveToXMLRecursive(xml, r, right);
}

References addXMLAttributes(), emtf::Node::getLeftDaughter(), emtf::Node::getRightDaughter(), cmsLHEtoEOSManager::l, np, and alignCSCRings::r.

Referenced by saveToXML().

setBoostWeight()

void emtf::Tree::setBoostWeight ( double  wgt )

inline

Definition at line 58 of file Tree.h.

{ boostWeight = wgt; }

References boostWeight.

setRootNode()

void Tree::setRootNode

(

Node *

sRootNode

)

Definition at line 153 of file Tree.cc.

{ rootNode = sRootNode; }

References rootNode.

setTerminalNodes()

void Tree::setTerminalNodes

(

std::list< Node * > &

sTNodes

)

Definition at line 159 of file Tree.cc.

{ terminalNodes = sTNodes; }

References terminalNodes.

Member Data Documentation

boostWeight

double emtf::Tree::boostWeight

private

Definition at line 65 of file Tree.h.

Referenced by getBoostWeight(), loadFromXML(), operator=(), setBoostWeight(), and Tree().

numTerminalNodes

int emtf::Tree::numTerminalNodes

private

Definition at line 63 of file Tree.h.

Referenced by buildTree(), getNumTerminalNodes(), loadFromCondPayloadRecursive(), loadFromXMLRecursive(), operator=(), and Tree().

rmsError

double emtf::Tree::rmsError

private

Definition at line 64 of file Tree.h.

Referenced by calcError(), operator=(), and Tree().

rootNode

Node* emtf::Tree::rootNode

private

Definition at line 61 of file Tree.h.

Referenced by buildTree(), calcError(), filterEvent(), filterEvents(), getRootNode(), getSplitValues(), loadFromCondPayload(), loadFromXML(), operator=(), rankVariables(), saveToXML(), setRootNode(), Tree(), and ~Tree().

terminalNodes

std::list<Node*> emtf::Tree::terminalNodes

private

Definition at line 62 of file Tree.h.

Referenced by buildTree(), calcError(), getTerminalNodes(), loadFromCondPayloadRecursive(), loadFromXMLRecursive(), operator=(), setTerminalNodes(), and Tree().

xmlVersion

unsigned emtf::Tree::xmlVersion

private

Definition at line 66 of file Tree.h.

Referenced by loadFromXML(), loadFromXMLRecursive(), operator=(), and Tree().