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 (std::vector< std::vector< Event *>> &cEvents)
	Tree (const Tree &tree)
	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.

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

           {
  rootNode = new Node("root");

  terminalNodes.push_back(rootNode);
  numTerminalNodes = 1;
  boostWeight = 0;
  xmlVersion = 2017;
}

Tree() [2/4]

Tree::Tree

(

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

cEvents

)

Definition at line 39 of file Tree.cc.

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

                                                {
  rootNode = new Node("root");
  rootNode->setEvents(cEvents);

  terminalNodes.push_back(rootNode);
  numTerminalNodes = 1;
  boostWeight = 0;
  xmlVersion = 2017;
}

~Tree()

Tree::~Tree

(

)

Definition at line 52 of file Tree.cc.

References rootNode.

            {
  // 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;
}

Tree() [3/4]

Tree::Tree

(

const Tree &

tree

)

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

Definition at line 59 of file Tree.cc.

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

                           {
  // 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);

}

Tree() [4/4]

Tree::Tree

(

Tree &&

tree

)

Definition at line 138 of file Tree.cc.

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

                      {
  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;
}

Member Function Documentation

addXMLAttributes()

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

Definition at line 381 of file Tree.cc.

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

Referenced by saveToXML(), and saveToXMLRecursive().

                                                                            {
  // 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());
}

buildTree()

void Tree::buildTree

(

int

nodeLimit

)

Definition at line 185 of file Tree.cc.

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

                                  {
  // 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);
}

calcError()

void Tree::calcError

(

)

Definition at line 171 of file Tree.cc.

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

Referenced by buildTree().

                     {
  // 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());
}

copyFrom()

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

private

Definition at line 93 of file Tree.cc.

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().

                                           {
  // 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;
}

filterEvent()

Node * Tree::filterEvent

(

Event *

e

)

Definition at line 276 of file Tree.cc.

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

                                {
  // 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;
}

filterEventRecursive()

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

Definition at line 287 of file Tree.cc.

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

Referenced by filterEvent().

                                                     {
  // 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);
}

filterEvents()

void Tree::filterEvents

(

std::vector< Event *> &

tEvents

)

Definition at line 243 of file Tree.cc.

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

                                                  {
  // 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);
}

filterEventsRecursive()

void Tree::filterEventsRecursive

(

Node *

node

)

Definition at line 258 of file Tree.cc.

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

Referenced by filterEvents().

                                           {
  // 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);
}

findLeafs()

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

private

Definition at line 124 of file Tree.cc.

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

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

                                                         {
  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);
}

getBoostWeight()

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

inline

Definition at line 57 of file Tree.h.

References boostWeight.

Referenced by L1TMuonEndCapForestESProducer::produce().

{ return boostWeight; }

getNumTerminalNodes()

int Tree::getNumTerminalNodes

(

)

Definition at line 165 of file Tree.cc.

References numTerminalNodes.

{ return numTerminalNodes; }

getRootNode()

Node * Tree::getRootNode

(

)

Definition at line 155 of file Tree.cc.

References rootNode.

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

{ return rootNode; }

getSplitValues()

void Tree::getSplitValues

(

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

v

)

Definition at line 364 of file Tree.cc.

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

{ getSplitValuesRecursive(rootNode, v); }

getSplitValuesRecursive()

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

Definition at line 336 of file Tree.cc.

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().

                                                                              {
  // 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);
}

getTerminalNodes()

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

(

)

Definition at line 161 of file Tree.cc.

References terminalNodes.

{ return terminalNodes; }

loadFromCondPayload()

void Tree::loadFromCondPayload

(

const L1TMuonEndCapForest::DTree &

tree

)

Definition at line 550 of file Tree.cc.

References loadFromCondPayloadRecursive(), and rootNode.

                                                                   {
  // 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);
}

loadFromCondPayloadRecursive()

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

Definition at line 560 of file Tree.cc.

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().

                                                     {
  // 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);
}

loadFromXML()

void Tree::loadFromXML

(

const char *

filename

)

Definition at line 437 of file Tree.cc.

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

                                           {
  // 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);
    while (std::string("boostWeight") != xml->GetAttrName(attr)) {
      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;
}

loadFromXMLRecursive()

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

Definition at line 477 of file Tree.cc.

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

Referenced by loadFromXML().

                                                                                    {
  // 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; i < 10; i++) {
      if (std::string("IVar") == xml->GetAttrName(attr)) {
        splitInfo[0] = xml->GetAttrValue(attr);
      }
      if (std::string("Cut") == xml->GetAttrName(attr)) {
        splitInfo[1] = xml->GetAttrValue(attr);
      }
      if (std::string("res") == xml->GetAttrName(attr)) {
        splitInfo[2] = 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);
}

operator=()

Tree & Tree::operator=

(

const Tree &

tree

)

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

Definition at line 74 of file Tree.cc.

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

                                      {
  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;
}

rankVariables()

void Tree::rankVariables

(

std::vector< double > &

v

)

Definition at line 332 of file Tree.cc.

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

{ rankVariablesRecursive(rootNode, v); }

rankVariablesRecursive()

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

Definition at line 300 of file Tree.cc.

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

Referenced by rankVariables().

                                                                  {
  // 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);
}

saveToXML()

void Tree::saveToXML

(

const char *

filename

)

Definition at line 391 of file Tree.cc.

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

                                  {
  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;
}

saveToXMLRecursive()

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

Definition at line 415 of file Tree.cc.

References addXMLAttributes(), emtf::Node::getLeftDaughter(), emtf::Node::getRightDaughter(), MainPageGenerator::l, and np.

Referenced by saveToXML().

                                                                              {
  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);
}

setBoostWeight()

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

inline

Definition at line 58 of file Tree.h.

References boostWeight.

{ boostWeight = wgt; }

setRootNode()

void Tree::setRootNode

(

Node *

sRootNode

)

Definition at line 153 of file Tree.cc.

References rootNode.

{ rootNode = sRootNode; }

setTerminalNodes()

void Tree::setTerminalNodes

(

std::list< Node *> &

sTNodes

)

Definition at line 159 of file Tree.cc.

References terminalNodes.

{ terminalNodes = sTNodes; }

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().