#include <Node.h>

Public Member Functions
void	calcOptimumSplit ()

void	filterEventsToDaughters ()

Node *	filterEventToDaughter (Event *e)

double	getAvgError ()

double	getErrorReduction ()

std::vector< std::vector< Event * > > &	getEvents ()

double	getFitValue ()

Node *	getLeftDaughter ()

std::string	getName ()

int	getNumEvents ()

Node *	getParent ()

Node *	getRightDaughter ()

double	getSplitValue ()

int	getSplitVariable ()

double	getTotalError ()

void	listEvents ()

	Node ()

	Node (std::string cName)

	Node (Node &&)=default

void	setAvgError (double sAvgError)

void	setErrorReduction (double sErrorReduction)

void	setEvents (std::vector< std::vector< Event * > > &sEvents)

void	setFitValue (double sFitValue)

void	setLeftDaughter (Node *sLeftDaughter)

void	setName (std::string sName)

void	setNumEvents (int sNumEvents)

void	setParent (Node *sParent)

void	setRightDaughter (Node *sLeftDaughter)

void	setSplitValue (double sSplitValue)

void	setSplitVariable (int sSplitVar)

void	setTotalError (double sTotalError)

void	theMiracleOfChildBirth ()

	~Node ()

Private Member Functions
	Node (const Node &)=delete

Node &	operator= (const Node &)=delete

Private Attributes
double	avgError

double	errorReduction

std::vector< std::vector< Event * > >	events

double	fitValue

Node *	leftDaughter

std::string	name

int	numEvents

Node *	parent

Node *	rightDaughter

double	splitValue

int	splitVariable

double	totalError

Detailed Description

Definition at line 12 of file Node.h.

Constructor & Destructor Documentation

Node::Node ( )

Definition at line 32 of file Node.cc.

References avgError, errorReduction, leftDaughter, name, parent, rightDaughter, splitValue, splitVariable, and totalError.

Referenced by theMiracleOfChildBirth().

 {
     name = "";
     leftDaughter = nullptr;
     rightDaughter = nullptr;
     parent = nullptr;
     splitValue = -99;
     splitVariable = -1;
     avgError = -1;
     totalError = -1;
     errorReduction = -1;
 }

Node::Node ( std::string cName )

Definition at line 45 of file Node.cc.

References avgError, errorReduction, leftDaughter, name, parent, rightDaughter, splitValue, splitVariable, and totalError.

 {
     name = cName;
     leftDaughter = nullptr;
     rightDaughter = nullptr;
     parent = nullptr;
     splitValue = -99;
     splitVariable = -1;
     avgError = -1;
     totalError = -1;
     errorReduction = -1;
 }

Node::~Node ( )

Definition at line 62 of file Node.cc.

References leftDaughter, and rightDaughter.

 {
 // Recursively delete all nodes in the tree.
     if(leftDaughter)  delete leftDaughter;
     if(rightDaughter) delete rightDaughter;
 }

emtf::Node::Node ( Node && )

default

emtf::Node::Node ( const Node & )

privatedelete

Member Function Documentation

void Node::calcOptimumSplit ( )

Definition at line 214 of file Node.cc.

References avgError, data, errorReduction, events, fitValue, mps_fire::i, numEvents, splitValue, splitVariable, SUM, edmPickEvents::target, totalError, and findQualityFiles::v.

Referenced by emtf::Tree::buildTree().

 {
 // Determines the split variable and split point which would most reduce the error for the given node (region).
 // In the process we calculate the fitValue and Error. The general aglorithm is based upon  Luis Torgo's thesis.
 // Check out the reference for a more in depth outline. This part is chapter 3.
 
     // Intialize some variables.
     double bestSplitValue = 0;
     int bestSplitVariable = -1; 
     double bestErrorReduction = -1;
 
     double SUM = 0;
     double SSUM = 0;
     numEvents = events[0].size();
 
     double candidateErrorReduction = -1;
 
     // Calculate the sum of the target variables and the sum of
     // the target variables squared. We use these later.
     for(unsigned int i=0; i<events[0].size(); i++)
     {   
         double target = events[0][i]->data[0];
         SUM += target;
         SSUM += target*target;
     }  
 
     unsigned int numVars = events.size();
 
     // Calculate the best split point for each variable
     for(unsigned int variableToCheck = 1; variableToCheck < numVars; variableToCheck++)
     { 
 
         // The sum of the target variables in the left, right nodes
         double SUMleft = 0;
         double SUMright = SUM;
 
         // The number of events in the left, right nodes
         int nleft = 1;
         int nright = events[variableToCheck].size()-1;
 
         int candidateSplitVariable = variableToCheck;
 
         std::vector<Event*>& v = events[variableToCheck];
 
         // Find the best split point for this variable 
         for(unsigned int i=1; i<v.size(); i++)
         {
             // As the candidate split point interates, the number of events in the 
             // left/right node increases/decreases and SUMleft/right increases/decreases.
 
             SUMleft = SUMleft + v[i-1]->data[0];
             SUMright = SUMright - v[i-1]->data[0];
              
             // No need to check the split point if x on both sides is equal
             if(v[i-1]->data[candidateSplitVariable] < v[i]->data[candidateSplitVariable])
             {
                 // Finding the maximum error reduction for Least Squares boils down to maximizing
                 // the following statement.
                 candidateErrorReduction = SUMleft*SUMleft/nleft + SUMright*SUMright/nright - SUM*SUM/numEvents;
 //                std::cout << "candidateErrorReduction= " << candidateErrorReduction << std::endl << std::endl;
                 
                 // if the new candidate is better than the current best, then we have a new overall best.
                 if(candidateErrorReduction > bestErrorReduction)
                 {
                     bestErrorReduction = candidateErrorReduction;
                     bestSplitValue = (v[i-1]->data[candidateSplitVariable] + v[i]->data[candidateSplitVariable])/2;
                     bestSplitVariable = candidateSplitVariable;
                 }
             }
 
             nright = nright-1;
             nleft = nleft+1;
         }
     }
  
     // Store the information gained from our computations.
 
     // The fit value is the average for least squares.
     fitValue = SUM/numEvents;
 //    std::cout << "fitValue= " << fitValue << std::endl;
 
     // n*[ <y^2>-k^2 ]
     totalError = SSUM - SUM*SUM/numEvents;
 //    std::cout << "totalError= " << totalError << std::endl;
 
     // [ <y^2>-k^2 ]
     avgError = totalError/numEvents;
 //    std::cout << "avgError= " << avgError << std::endl;
     
 
     errorReduction = bestErrorReduction;
 //    std::cout << "errorReduction= " << errorReduction << std::endl;
 
     splitVariable = bestSplitVariable;
 //    std::cout << "splitVariable= " << splitVariable << std::endl;
 
     splitValue = bestSplitValue;
 //    std::cout << "splitValue= " << splitValue << std::endl;
 
     //if(bestSplitVariable == -1) std::cout << "splitVar = -1. numEvents = " << numEvents << ". errRed = " << errorReduction << std::endl;
 }

void Node::filterEventsToDaughters ( )

Definition at line 350 of file Node.cc.

References emtf::Event::data, MillePedeFileConverter_cfg::e, events, getEvents(), mps_fire::i, checklumidiff::l, leftDaughter, alignCSCRings::r, rightDaughter, setNumEvents(), splitValue, splitVariable, and pfDeepBoostedJetPreprocessParams_cfi::sv.

Referenced by emtf::Tree::buildTree(), and emtf::Tree::filterEventsRecursive().

 {
 // Keeping sorted copies of the event vectors allows us to save on
 // computation time. That way we don't have to resort the events
 // each time we calculate the splitpoint for a node. We sort them once.
 // Every time we split a node, we simply filter them down correctly
 // preserving the order. This way we have O(n) efficiency instead
 // of O(nlogn) efficiency.
 
 // Anyways, this function takes events from the parent node
 // and filters an event into the left or right daughter
 // node depending on whether it is < or > the split point
 // for the given split variable. 
 
     int sv = splitVariable;
     double sp = splitValue;
 
     Node* left = leftDaughter;
     Node* right = rightDaughter;
 
     std::vector< std::vector<Event*> > l(events.size());
     std::vector< std::vector<Event*> > r(events.size());
 
     for(unsigned int i=0; i<events.size(); i++)
     {
         for(unsigned int j=0; j<events[i].size(); j++)
         {
             Event* e = events[i][j];
             if(e->data[sv] < sp) l[i].push_back(e);
             if(e->data[sv] > sp) r[i].push_back(e);
         }
     }
 
     events = std::vector< std::vector<Event*> >();    
 
     left->getEvents().swap(l);
     right->getEvents().swap(r);    
 
     // Set the number of events in the node.
     left->setNumEvents(left->getEvents()[0].size());
     right->setNumEvents(right->getEvents()[0].size());
 }

Node * Node::filterEventToDaughter ( Event * e )

Definition at line 395 of file Node.cc.

References emtf::Event::data, leftDaughter, rightDaughter, splitValue, splitVariable, and pfDeepBoostedJetPreprocessParams_cfi::sv.

Referenced by emtf::Tree::filterEventRecursive().

 {
 // Anyways, this function takes an event from the parent node
 // and filters an event into the left or right daughter
 // node depending on whether it is < or > the split point
 // for the given split variable. 
 
     int sv = splitVariable;
     double sp = splitValue;
 
     Node* left = leftDaughter;
     Node* right = rightDaughter;
     Node* nextNode = nullptr;
 
     if(left ==nullptr || right ==nullptr) return nullptr;
 
     if(e->data[sv] <  sp) nextNode = left;
     if(e->data[sv] >= sp) nextNode = right;
     
     return nextNode;
 }

double Node::getAvgError ( )

Definition at line 180 of file Node.cc.

References avgError.

Referenced by emtf::Tree::copyFrom().

 {
     return avgError;
 }

double Node::getErrorReduction ( )

Definition at line 90 of file Node.cc.

References errorReduction.

Referenced by emtf::Tree::copyFrom(), and emtf::Tree::rankVariablesRecursive().

 {
     return errorReduction;
 }

std::vector< std::vector< Event * > > & Node::getEvents ( )

Definition at line 199 of file Node.cc.

References events.

Referenced by emtf::Tree::filterEvents(), and filterEventsToDaughters().

 {
     return events;
 }

double Node::getFitValue ( )

Definition at line 158 of file Node.cc.

References fitValue.

Referenced by emtf::Tree::addXMLAttributes(), emtf::Forest::appendCorrection(), emtf::Tree::copyFrom(), and L1TMuonEndCapForestESProducer::traverse().

 {
     return fitValue;
 }

Node * Node::getLeftDaughter ( )

Definition at line 102 of file Node.cc.

References leftDaughter.

Referenced by emtf::Tree::buildTree(), emtf::Tree::copyFrom(), emtf::Tree::filterEventsRecursive(), emtf::Tree::findLeafs(), emtf::Tree::getSplitValuesRecursive(), emtf::Tree::loadFromCondPayloadRecursive(), emtf::Tree::loadFromXMLRecursive(), emtf::Tree::rankVariablesRecursive(), emtf::Tree::saveToXMLRecursive(), and L1TMuonEndCapForestESProducer::traverse().

 {
     return leftDaughter;
 }

std::string Node::getName ( void )

Definition at line 78 of file Node.cc.

References name.

Referenced by emtf::Tree::copyFrom(), plotting.Plot::draw(), and emtf::Tree::saveToXML().

 {
     return name;
 }

int Node::getNumEvents ( )

Definition at line 192 of file Node.cc.

References numEvents.

Referenced by emtf::Tree::calcError(), and emtf::Tree::copyFrom().

 {
     return numEvents;
 }

Node * Node::getParent ( )

Definition at line 124 of file Node.cc.

References parent.

 {
     return parent;
 }

Node * Node::getRightDaughter ( )

Definition at line 112 of file Node.cc.

References rightDaughter.

Referenced by emtf::Tree::buildTree(), emtf::Tree::copyFrom(), emtf::Tree::filterEventsRecursive(), emtf::Tree::findLeafs(), emtf::Tree::getSplitValuesRecursive(), emtf::Tree::loadFromCondPayloadRecursive(), emtf::Tree::loadFromXMLRecursive(), emtf::Tree::rankVariablesRecursive(), emtf::Tree::saveToXMLRecursive(), and L1TMuonEndCapForestESProducer::traverse().

 {
     return rightDaughter;
 }

double Node::getSplitValue ( )

Definition at line 136 of file Node.cc.

References splitValue.

Referenced by emtf::Tree::addXMLAttributes(), emtf::Tree::copyFrom(), emtf::Tree::getSplitValuesRecursive(), and L1TMuonEndCapForestESProducer::traverse().

 {
     return splitValue;
 }

int Node::getSplitVariable ( )

Definition at line 146 of file Node.cc.

References splitVariable.

Referenced by emtf::Tree::addXMLAttributes(), emtf::Tree::copyFrom(), emtf::Tree::getSplitValuesRecursive(), emtf::Tree::rankVariablesRecursive(), and L1TMuonEndCapForestESProducer::traverse().

 {
     return splitVariable;
 }

double Node::getTotalError ( )

Definition at line 170 of file Node.cc.

References totalError.

Referenced by emtf::Tree::copyFrom().

 {
     return totalError;
 }

void Node::listEvents ( )

Definition at line 318 of file Node.cc.

References gather_cfg::cout, events, and mps_fire::i.

 {
     std::cout << std::endl << "Listing Events... " << std::endl;
 
     for(unsigned int i=0; i < events.size(); i++)
     {   
         std::cout << std::endl << "Variable " << i << " vector contents: " << std::endl;
         for(unsigned int j=0; j < events[i].size(); j++)
         {   
             events[i][j]->outputEvent();
         }   
        std::cout << std::endl;
     }   
 }

Node& emtf::Node::operator= ( const Node & )

privatedelete

void Node::setAvgError ( double sAvgError )

Definition at line 175 of file Node.cc.

References avgError.

 {
     avgError = sAvgError;
 }

void Node::setErrorReduction ( double sErrorReduction )

Definition at line 85 of file Node.cc.

References errorReduction.

 {
     errorReduction = sErrorReduction;
 }

void Node::setEvents ( std::vector< std::vector< Event * > > & sEvents )

Definition at line 204 of file Node.cc.

References events, and numEvents.

Referenced by emtf::Tree::Tree().

 {
     events = sEvents;
     numEvents = events[0].size();
 }

void Node::setFitValue ( double sFitValue )

Definition at line 153 of file Node.cc.

References fitValue.

Referenced by emtf::Tree::loadFromCondPayloadRecursive(), and emtf::Tree::loadFromXMLRecursive().

 {
     fitValue = sFitValue;
 }

void Node::setLeftDaughter ( Node * sLeftDaughter )

Definition at line 97 of file Node.cc.

References leftDaughter.

 {
     leftDaughter = sLeftDaughter;
 }

void Node::setName ( std::string sName )

Definition at line 73 of file Node.cc.

References name.

 {
     name = sName;
 }

void Node::setNumEvents ( int sNumEvents )

Definition at line 187 of file Node.cc.

References numEvents.

Referenced by filterEventsToDaughters().

 {
     numEvents = sNumEvents;
 }

void Node::setParent ( Node * sParent )

Definition at line 119 of file Node.cc.

References parent.

Referenced by lumiQTWidget.LumiCanvas::__init__(), emtf::Tree::copyFrom(), and theMiracleOfChildBirth().

 {
     parent = sParent;
 }

void Node::setRightDaughter ( Node * sLeftDaughter )

Definition at line 107 of file Node.cc.

References rightDaughter.

 {
     rightDaughter = sRightDaughter;
 }

void Node::setSplitValue ( double sSplitValue )

Definition at line 131 of file Node.cc.

References splitValue.

Referenced by emtf::Tree::loadFromCondPayloadRecursive(), and emtf::Tree::loadFromXMLRecursive().

 {
     splitValue = sSplitValue;
 }

void Node::setSplitVariable ( int sSplitVar )

Definition at line 141 of file Node.cc.

References splitVariable.

Referenced by emtf::Tree::loadFromCondPayloadRecursive(), and emtf::Tree::loadFromXMLRecursive().

 {
     splitVariable = sSplitVar;
 }

void Node::setTotalError ( double sTotalError )

Definition at line 165 of file Node.cc.

References totalError.

 {
     totalError = sTotalError;
 }

void Node::theMiracleOfChildBirth ( )

Definition at line 335 of file Node.cc.

References leftDaughter, name, Node(), rightDaughter, and setParent().

Referenced by emtf::Tree::buildTree(), emtf::Tree::loadFromCondPayloadRecursive(), and emtf::Tree::loadFromXMLRecursive().

 { 
     // Create Daughter Nodes 
     Node* left = new Node(name + " left");
     Node* right = new Node(name + " right");
 
     // Link the Nodes Appropriately
     leftDaughter = left;
     rightDaughter = right;
     left->setParent(this);
     right->setParent(this); 
 }