Lit::LikeModule Class Reference

#include <LikeModule.h>

List of all members.

Public Types
typedef std::map< int, std::vector< double > >	VarMap
typedef std::map< short, double >	ProbMap
Public Member Functions
	LikeModule ()
	~LikeModule ()
bool	Read (const std::string &filepath, int nevent=0, const std::string &treename="events")
bool	Read (TDirectory *dir, int nevent=0, const std::string &treename="events")
bool	Write (const std::string &filepath, const std::string &treename="events")
void	Write (TDirectory *dir, const std::string &treename="events")
void	Add (const Event &event)
bool	Fill (unsigned short optimize_depth=7, const std::string &option="")
bool	Find (Event event, unsigned int nfind=100) const
bool	Find (unsigned int nfind, const std::string &option) const
const EventVec &	GetEventVec () const
const Result &	GetResult () const
const VarMap &	GetVarMap () const
const std::map< int, double > &	GetMetric () const
void	Print () const
void	Print (std::ostream &os) const
Private Member Functions
Node *	Balance (unsigned int bdepth)
void	ComputeMetric (unsigned int ifrac=10)
const Event	Scale (const Event &event) const
Private Attributes
unsigned int	fDimn
Node *	fTree
std::map< int, double >	fVarScale
Result	fResult
std::map< short, unsigned int >	fCount
EventVec	fEvent
VarMap	fVar

---

Member Typedef Documentation

typedef std::map<short, double> Lit::LikeModule::ProbMap

Definition at line 23 of file LikeModule.h.

typedef std::map<int, std::vector<double> > Lit::LikeModule::VarMap

Definition at line 22 of file LikeModule.h.

---

Constructor & Destructor Documentation

Lit::LikeModule::LikeModule (   )

Definition at line 22 of file LikeModule.cxx. :fDimn(0), fTree(0) { }

Lit::LikeModule::~LikeModule (   )

Definition at line 29 of file LikeModule.cxx. { if(fTree) { delete fTree; } }

---

Member Function Documentation

void Lit::LikeModule::Add (  const Event &  event  )

Definition at line 147 of file LikeModule.cxx. References fCount, fDimn, fEvent, fVar, Lit::Event::GetNVar(), Lit::Event::GetType(), and Lit::Event::GetVar(). Referenced by Fill(), and Read(). { if(fTree) { cerr << "LikeModule::Add() - can not add event: tree is already built" << endl; return; } if(fDimn < 1) { fDimn = event.GetNVar(); } else if(fDimn != event.GetNVar()) { cerr << "LikeModule::Add() - number of dimensions does not match previous events" << endl; return; } fEvent.push_back(event); for(unsigned int ivar = 0; ivar < fDimn; ++ivar) { fVar[ivar].push_back(event.GetVar(ivar)); } std::map<short, unsigned int>::iterator cit = fCount.find(event.GetType()); if(cit == fCount.end()) { fCount[event.GetType()] = 1; } else { ++(cit -> second); } }

Lit::Node * Lit::LikeModule::Balance (  unsigned int  bdepth  )  [private]

Definition at line 426 of file LikeModule.cxx. References fDimn, fVar, Lit::VarType, and Lit::VarVec. Referenced by Fill(). { // Balance() balances binary tree for first bdepth levels // for each depth we split sorted depth % dimension variables // into 2^bdepth parts if(fVar.empty() || fDimn != fVar.size()) { cout << "LikeModule::Balance - can not build a tree" << endl; return 0; } const unsigned int size = (fVar.begin() -> second).size(); if(size < 1) { cout << "LikeModule::Balance - can not build a tree without events" << endl; return 0; } for(VarMap::const_iterator it = fVar.begin(); it != fVar.end(); ++it) { if((it -> second).size() != size) { cout << "LikeModule::Balance - # of variables doesn't match between dimensions" << endl; return 0; } } if(double(fDimn*size) < pow(2.0, double(bdepth))) { cout << "LikeModule::Balance - balance depth exceeds number of events" << endl; return 0; } cout << "Balancing tree for " << fDimn << " variables with " << size << " values" << endl; vector<Node *> pvec, cvec; VarMap::const_iterator it = fVar.find(0); if(it == fVar.end() || (it -> second).size() < 2) { cout << "Missing 0 variable" << endl; return 0; } const Event pevent(VarVec(fDimn, (it -> second)[size/2]), -1.0, -1); Node *tree = new Node(0, pevent, 0); pvec.push_back(tree); for(unsigned int depth = 1; depth < bdepth; ++depth) { const unsigned int mod = depth % fDimn; VarMap::const_iterator vit = fVar.find(mod); if(vit == fVar.end()) { cerr << "Missing " << mod << " variable" << endl; return 0; } const vector<double> &dvec = vit -> second; if(dvec.size() < 2) { cerr << "Missing " << mod << " variable" << endl; return 0; } //cout << "Mod = " << mod << endl; unsigned int ichild = 1; for(vector<Node *>::iterator pit = pvec.begin(); pit != pvec.end(); ++pit) { Node *parent = *pit; const VarType lmedian = dvec[size*ichild/(2*pvec.size() + 1)]; //cout << "ChildL " << setw(2) << ichild << " lmedian " << lmedian << endl; ++ichild; const VarType rmedian = dvec[size*ichild/(2*pvec.size() + 1)]; //cout << "ChildR " << setw(2) << ichild << " rmedian " << rmedian << endl; ++ichild; const Event levent(VarVec(fDimn, lmedian), -1.0, -1); const Event revent(VarVec(fDimn, rmedian), -1.0, -1); Node *lchild = new Node(parent, levent, mod); Node *rchild = new Node(parent, revent, mod); parent -> SetNodeL(lchild); parent -> SetNodeR(rchild); cvec.push_back(lchild); cvec.push_back(rchild); } pvec = cvec; cvec.clear(); } return tree; }

void Lit::LikeModule::ComputeMetric (  unsigned int  ifrac = 10  )  [private]

Definition at line 531 of file LikeModule.cxx. References fEvent, fVar, fVarScale, and Scale(). Referenced by Fill(). { // compute scale factor for each variable (dimension) so that // distance is computed uniformely along each dimension // compute width of interval that includes (100 - 2*ifrac)% of events // below, assume that in fVar each vector of values is sorted if(ifrac > 49) { cerr << "LikeModule::ComputeMetric() - fraction can not exceed 50%" << endl; return; } if(fEvent.empty()) { cerr << "LikeModule::ComputeMetric() - event vector is empty" << endl; return; } if(!fVarScale.empty()) { cerr << "LikeModule::ComputeMetric() - metric is already computed" << endl; return; } cout << "Computing scale for 1d axes: ifrac = " << ifrac << endl; fVarScale.clear(); for(VarMap::const_iterator vit = fVar.begin(); vit != fVar.end(); ++vit) { const vector<double> &dvec = vit -> second; vector<double>::const_iterator beg_it = dvec.end(); vector<double>::const_iterator end_it = dvec.end(); for(vector<double>::const_iterator dit = dvec.begin(); dit != dvec.end(); ++dit) { const int dist = distance(dvec.begin(), dit); if((100*dist)/dvec.size() == ifrac && beg_it == dvec.end()) { beg_it = dit; } if((100*dist)/dvec.size() == 100 - ifrac && end_it == dvec.end()) { end_it = dit; } } if(beg_it == dvec.end() || end_it == dvec.end()) { cerr << "LikeModule::ComputeMetric() - failed to determine scale " << vit -> first << endl; continue; } const double lpos = *beg_it; const double rpos = *end_it; if(!(lpos < rpos)) { cerr << "LikeModule::ComputeMetric() - min value is greater than max value" << endl; continue; } cout << "Variable " << vit -> first << " included " << distance(beg_it, end_it) + 1 << " events: width = " << setfill(' ') << setw(5) << setprecision(3) << rpos - lpos << ", (min, max) = (" << setfill(' ') << setw(5) << setprecision(3) << lpos << ", " << setfill(' ') << setw(5) << setprecision(3) << rpos << ")" << endl; fVarScale[vit -> first] = rpos - lpos; } fVar.clear(); for(unsigned int ievent = 0; ievent < fEvent.size(); ++ievent) { fEvent[ievent] = Scale(fEvent[ievent]); for(unsigned int ivar = 0; ivar < fDimn; ++ivar) { fVar[ivar].push_back(fEvent[ievent].GetVar(ivar)); } } }

bool Lit::LikeModule::Fill (  unsigned short  optimize_depth = 7, const std::string &  option = "" )

Definition at line 184 of file LikeModule.cxx. References Add(), Balance(), ComputeMetric(), Lit::EventVec, fCount, fEvent, fTree, fVar, min, and option. Referenced by Write(). { if(fTree) { cerr << "LikeModule::Fill - tree already have been created" << endl; return false; } // If trim option is set then find class with lowest number of events // and set that as maximum number of events for all other classes. unsigned int min = 0; if(option.find("trim") != string::npos) { for(map<short, unsigned int>::const_iterator it = fCount.begin(); it != fCount.end(); ++it) { if(min == 0 || min > it -> second) { min = it -> second; } } cout << "LikeModule::Fill - trimming all classes to " << min << " events" << endl; for(map<short, unsigned int>::const_iterator it = fCount.begin(); it != fCount.end(); ++it) { cout << "class " << it -> first << " has " << setfill(' ') << setw(8) << it -> second << " events" << endl; } fCount.clear(); fVar.clear(); EventVec evec; for(EventVec::const_iterator event = fEvent.begin(); event != fEvent.end(); ++event) { std::map<short, unsigned int>::iterator cit = fCount.find(event -> GetType()); if(cit == fCount.end()) { fCount[event -> GetType()] = 1; } else if(cit -> second < min) { ++(cit -> second); } else { continue; } for(unsigned int d = 0; d < fDimn; ++d) { fVar[d].push_back(event -> GetVar(d)); } evec.push_back(*event); } cout << "LikeModule::Fill - erased " << fEvent.size() - evec.size() << " events" << endl; fEvent = evec; } //clear event count fCount.clear(); // sort each variable for all events - needs this before Balance() for(VarMap::iterator it = fVar.begin(); it != fVar.end(); ++it) { std::sort((it -> second).begin(), (it -> second).end()); } if(option.find("metric") != string::npos) { ComputeMetric(); // sort again each variable for all events - needs this before Balance() // rescaling has changed variable values for(VarMap::iterator it = fVar.begin(); it != fVar.end(); ++it) { std::sort((it -> second).begin(), (it -> second).end()); } } // If optimize_depth > 0 then fill first optimize_depth levels // with empty nodes that split separating variable in half for // all child nodes. If optimize_depth = 0 then split variable 0 // at the median (in half) and return it as root node fTree = Balance(optimize_depth); if(!fTree) { cout << "LikeModule::Fill - failed to create tree" << endl; return false; } for(EventVec::const_iterator event = fEvent.begin(); event != fEvent.end(); ++event) { fTree -> Add(*event, 0); std::map<short, unsigned int>::iterator cit = fCount.find(event -> GetType()); if(cit == fCount.end()) { fCount[event -> GetType()] = 1; } else { ++(cit -> second); } } for(map<short, unsigned int>::const_iterator it = fCount.begin(); it != fCount.end(); ++it) { cout << "class " << it -> first << " has " << setfill(' ') << setw(8) << it -> second << " events" << endl; } if(option.find("erase") != string::npos) { cout << "Erasing event vector with size " << fEvent.size() << endl; fEvent.clear(); fVar.clear(); } return true; }

bool Lit::LikeModule::Find (  unsigned int  nfind, const std::string &  option )  const

Definition at line 366 of file LikeModule.cxx. References fCount, Find(), fVar, max, min, option, Lit::VarType, and Lit::VarVec. { if(fCount.empty() || !fTree) { return false; } static std::map<short, unsigned int>::const_iterator cit = fCount.end(); if(cit == fCount.end()) { cit = fCount.begin(); } const short etype = (cit++) -> first; if(option == "flat") { VarVec dvec; for(unsigned int d = 0; d < fDimn; ++d) { VarMap::const_iterator vit = fVar.find(d); if(vit == fVar.end()) { return false; } const std::vector<double> &vvec = vit -> second; if(vvec.empty()) { return false; } // assume that vector elements of fVar are sorted const VarType min = vvec.front(); const VarType max = vvec.back(); const VarType width = max - min; if(width < 0.0 || width > 0.0) { dvec.push_back(min + width*double(std::rand())/double(RAND_MAX)); } else { return false; } } const Event event(dvec, 1.0, etype); Find(event, nfind); return true; } return false; }

bool Lit::LikeModule::Find (  Event  event, unsigned int  nfind = 100 )  const

Definition at line 311 of file LikeModule.cxx. References Lit::Result::Clear(), fDimn, Lit::Result::fEvent, Lit::Find(), Lit::Result::fList, Lit::Result::fProbNN, fResult, fTree, fVarScale, Lit::Result::GetList(), Lit::Event::GetNVar(), and Scale(). Referenced by Find(). { // if tree has been filled then search for nfind closest events // if metic (fVarScale map) is computed then rescale event variables // using previsouly computed width of variable distribution if(!fTree) { cerr << "LikeModule::Find() - tree has not been filled" << endl; return false; } if(fDimn != event.GetNVar()) { cerr << "LikeModule::Find() - number of dimension does not match training events" << endl; return false; } if(nfind < 1) { cerr << "LikeModule::Find() - requested 0 nearest neighbors" << endl; return false; } // if variable widths are computed then rescale variable in this event // to same widths as events in stored kd-tree if(!fVarScale.empty()) { event = Scale(event); } fResult.Clear(); fResult.fEvent = event; // recursive kd-tree search for nfind-nearest neighbors Lit::Find(fResult.fList, fTree, event, nfind); for(List::const_iterator lit = fResult.GetList().begin(); lit != fResult.GetList().end(); ++lit) { const Node *node = lit -> first; map<short, double>::iterator pit = fResult.fProbNN.find(node -> GetType()); if(pit == fResult.fProbNN.end()) { fResult.fProbNN[node -> GetType()] = node -> GetWeight()/double(nfind); } else { pit -> second += node -> GetWeight()/double(nfind); } } return true; }

const EventVec & Lit::LikeModule::GetEventVec (   )  const [inline]

Definition at line 82 of file LikeModule.h. References Lit::EventVec. { return fEvent; }

const std::map< int, double > & Lit::LikeModule::GetMetric (   )  const [inline]

Definition at line 90 of file LikeModule.h. { return fVarScale; }

const Result & Lit::LikeModule::GetResult (   )  const [inline]

Definition at line 78 of file LikeModule.h. { return fResult; }

const LikeModule::VarMap & Lit::LikeModule::GetVarMap (   )  const [inline]

Definition at line 86 of file LikeModule.h. { return fVar; }

void Lit::LikeModule::Print (  std::ostream &  os  )  const

Definition at line 664 of file LikeModule.cxx. { os << "---------------------------------------------------------------------------------"<< endl; os << "Dumping stringstream content of LikeModule" << endl; os << "---------------------------------------------------------------------------------"<< endl; }

void Lit::LikeModule::Print (   )  const

Definition at line 658 of file LikeModule.cxx. Referenced by Anp::FillkNN::Find(). { Print(std::cout); }

bool Lit::LikeModule::Read (  TDirectory *  dir, int  nevent = 0, const std::string &  treename = "events" )

Definition at line 108 of file LikeModule.cxx. References Add(), and fEvent. { if(!dir) { cerr << "LikeModule::Read - invalid TDirectory pointer" << endl; return false; } TTree *tree = dynamic_cast<TTree *>(dir -> Get(treename.c_str())); if(!tree) { cout << "LikeModule::Read() - failed to find " << treename << " tree" << endl; return false; } Event *event = new Event(); tree -> SetBranchAddress("event", &event); if(nevent < 1 || nevent > tree -> GetEntries()) { nevent = tree -> GetEntries(); } double size = 0.0; for(int i = 0; i < nevent; ++i) { size += tree -> GetEntry(i); Add(*event); } cout << "LikeModule::Read() - read " << size/1048576.0 << "MB and " << fEvent.size () << " events" << endl; delete event; return true; }

bool Lit::LikeModule::Read (  const std::string &  filepath, int  nevent = 0, const std::string &  treename = "events" )

Definition at line 91 of file LikeModule.cxx. { TFile *file = new TFile(filepath.c_str(), "READ"); if(!file || !file -> IsOpen()) { cout << "LikeModule::Read() - failed to read ROOT file:\n" << filepath << endl; return false; } const bool result = Read(file, nevent, treename); file -> Close(); return result; }

const Lit::Event Lit::LikeModule::Scale (  const Event &  event  )  const [private]

Definition at line 617 of file LikeModule.cxx. References fVarScale, Lit::Event::GetNVar(), Lit::Event::GetTgtVec(), Lit::Event::GetType(), Lit::Event::GetVar(), Lit::Event::GetWeight(), and Lit::VarVec. Referenced by ComputeMetric(), and Find(). { // scale each event variable so that rms of variables is approximately 1.0 // this allows comparisons of variables with distinct scales and units if(fVarScale.empty()) { return event; } if(event.GetNVar() != fVarScale.size()) { cerr << "LikeModule::Scale() - mismatched metric and event size" << endl; return event; } VarVec vvec(event.GetNVar(), 0.0); for(unsigned int ivar = 0; ivar < event.GetNVar(); ++ivar) { map<int, double>::const_iterator fit = fVarScale.find(ivar); if(fit == fVarScale.end()) { cerr << "LikeModule::Scale() - failed to find scale for " << ivar << endl; continue; } if(fit -> second > 0.0) { vvec[ivar] = event.GetVar(ivar)/fit -> second; } else { cerr << "Variable " << ivar << " has zero width" << endl; } } return Event(vvec, event.GetWeight(), event.GetType(), event.GetTgtVec()); }

void Lit::LikeModule::Write (  TDirectory *  dir, const std::string &  treename = "events" )

Definition at line 57 of file LikeModule.cxx. References fEvent, and Fill(). { if(!dir) { cerr << "LikeModule::Write() - null TDirectory pointer" << endl; return; } if(dir -> Get(treename.c_str())) { const string treename_tmp = treename + ";*"; cout << "LikeModule::Write - delete object with name " << treename_tmp << endl; dir -> Delete(treename_tmp.c_str()); } Event *event = new Event(); TTree *tree = new TTree(treename.c_str(), "event tree"); tree -> SetDirectory(dir); tree -> Branch("event", "Lit::Event", &event); double size = 0.0; for(EventVec::const_iterator it = fEvent.begin(); it != fEvent.end(); ++it) { (*event) = (*it); size += tree -> Fill(); } cout << "LikeModule::Write() - filled tree with " << size/1048576.0 << "MB and " << fEvent.size () << " events" << endl; delete event; }

bool Lit::LikeModule::Write (  const std::string &  filepath, const std::string &  treename = "events" )

Definition at line 38 of file LikeModule.cxx. { TFile *file = new TFile(filepath.c_str(), "UPDATE"); if(!file || !file -> IsOpen()) { cout << "LikeModule::Write() - failed to recreate ROOT file:\n" << filepath << endl; return false; } // write out all events in TTree Write(file, treename); file -> Write(); file -> Close(); return true; }

---

Member Data Documentation

std::map<short, unsigned int> Lit::LikeModule::fCount [private]

Definition at line 72 of file LikeModule.h. Referenced by Add(), Fill(), and Find().

unsigned int Lit::LikeModule::fDimn [private]

Definition at line 64 of file LikeModule.h. Referenced by Add(), Balance(), and Find().

EventVec Lit::LikeModule::fEvent [private]

Definition at line 74 of file LikeModule.h. Referenced by Add(), ComputeMetric(), Fill(), Read(), and Write().

Result Lit::LikeModule::fResult [mutable, private]

Definition at line 70 of file LikeModule.h. Referenced by Find().

Node* Lit::LikeModule::fTree [private]

Definition at line 66 of file LikeModule.h. Referenced by Fill(), and Find().

VarMap Lit::LikeModule::fVar [private]

Definition at line 75 of file LikeModule.h. Referenced by Add(), Balance(), ComputeMetric(), Fill(), and Find().

std::map<int, double> Lit::LikeModule::fVarScale [private]

Definition at line 68 of file LikeModule.h. Referenced by ComputeMetric(), Find(), and Scale().

---

The documentation for this class was generated from the following files:

• LikeModule.h
• LikeModule.cxx

---