#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::Tree ( )

Definition at line 29 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::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 ( )

Definition at line 54 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::Tree ( const Tree & tree )

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

Definition at line 61 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::Tree ( Tree && tree )

Definition at line 139 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

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

Definition at line 417 of file Tree.cc.

References emtf::Node::getFitValue(), emtf::Node::getSplitValue(), emtf::Node::getSplitVariable(), 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());
 }

void Tree::buildTree ( int nodeLimit )

Definition at line 203 of file Tree.cc.

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

Referenced by emtf::Forest::doRegression().

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

void Tree::calcError ( )

Definition at line 187 of file Tree.cc.

References emtf::Node::getNumEvents(), 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() ); 
 } 

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

private

Definition at line 95 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;
 }

Node * Tree::filterEvent ( Event * e )

Definition at line 298 of file Tree.cc.

References filterEventRecursive(), and rootNode.

Referenced by emtf::Forest::appendCorrection().

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

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

Definition at line 310 of file Tree.cc.

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

void Tree::filterEvents ( std::vector< Event * > & tEvents )

Definition at line 264 of file Tree.cc.

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

Referenced by emtf::Forest::appendCorrection().

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

void Tree::filterEventsRecursive ( Node * node )

Definition at line 280 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);
 }

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

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

inline

Definition at line 56 of file Tree.h.

References boostWeight.

Referenced by L1TMuonEndCapForestESProducer::produce().

56 { return boostWeight; }

emtf::Tree::boostWeight

double boostWeight

Definition: Tree.h:64

int Tree::getNumTerminalNodes ( )

Definition at line 178 of file Tree.cc.

References numTerminalNodes.

 {
     return numTerminalNodes;
 }

Node * Tree::getRootNode ( )

Definition at line 159 of file Tree.cc.

References rootNode.

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

 {
      return rootNode;
 }

void Tree::getSplitValues ( std::vector< std::vector< double >> & v )

Definition at line 396 of file Tree.cc.

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

 {
     getSplitValuesRecursive(rootNode, v);
 }

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

Definition at line 366 of file Tree.cc.

References gather_cfg::cout, emtf::Node::getLeftDaughter(), emtf::Node::getRightDaughter(), emtf::Node::getSplitValue(), emtf::Node::getSplitVariable(), 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); 
 
 }

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

Definition at line 171 of file Tree.cc.

References terminalNodes.

Referenced by emtf::Forest::updateEvents(), and emtf::Forest::updateRegTargets().

 {
     return terminalNodes;
 }

void Tree::loadFromCondPayload ( const L1TMuonEndCapForest::DTree & tree )

Definition at line 586 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);
 }

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

Definition at line 596 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);
 }

void Tree::loadFromXML ( const char * filename )

Definition at line 476 of file Tree.cc.

References boostWeight, loadFromXMLRecursive(), rootNode, AlCaHLTBitMon_QueryRunRegistry::string, cmsPerfSuiteHarvest::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);
         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;
 }

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

Definition at line 516 of file Tree.cc.

References emtf::Node::getLeftDaughter(), emtf::Node::getRightDaughter(), mps_fire::i, numTerminalNodes, emtf::Node::setFitValue(), emtf::Node::setSplitValue(), emtf::Node::setSplitVariable(), 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,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);
 }

Tree & Tree::operator= ( const Tree & tree )

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

Definition at line 77 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;
 }

void Tree::rankVariables ( std::vector< double > & v )

Definition at line 358 of file Tree.cc.

References rankVariablesRecursive(), and rootNode.

 {
     rankVariablesRecursive(rootNode, v);
 }

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

Definition at line 325 of file Tree.cc.

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

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

void Tree::saveToXML ( const char * filename )

Definition at line 428 of file Tree.cc.

References addXMLAttributes(), emtf::Node::getName(), rootNode, saveToXMLRecursive(), and cmsPerfSuiteHarvest::xmldoc.

Referenced by emtf::Forest::doRegression().

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

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

Definition at line 454 of file Tree.cc.

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

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