// @(#)root/tmva $Id$
// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss
/**********************************************************************************
* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
* Package: TMVA *
* Class : Rule *
* *
* Description: *
* A class describing a 'rule cut' *
* *
* *
* Authors (alphabetical): *
* Fredrik Tegenfeldt <Fredrik.Tegenfeldt@cern.ch> - Iowa State U., USA *
* *
* Copyright (c) 2005: *
* CERN, Switzerland *
* Iowa State U. *
* *
* Redistribution and use in source and binary forms, with or without *
* modification, are permitted according to the terms listed in LICENSE *
* (http://tmva.sourceforge.net/LICENSE) *
**********************************************************************************/
#ifndef ROOT_TMVA_RuleCut
#define ROOT_TMVA_RuleCut
#ifndef ROOT_TMVA_Event
#include "TMVA/Event.h"
#endif
namespace TMVA {
class Node;
class MsgLogger;
class RuleCut {
public:
// main constructor
RuleCut( const std::vector< const TMVA::Node * > & nodes );
// copy constructor
RuleCut( const RuleCut & other ) { Copy( other ); }
// empty constructor
RuleCut();
// destructor
virtual ~RuleCut();
// evaluate an event
inline Bool_t EvalEvent( const Event &eve );
// get cut range for a given selector
Bool_t GetCutRange(Int_t sel,Double_t &rmin, Double_t &rmax, Bool_t &dormin, Bool_t &dormax) const;
// number of cuts
UInt_t GetNcuts() const;
// set members
inline void SetNvars( UInt_t nc );
void SetNeve( Double_t n ) { fCutNeve = n; }
void SetPurity( Double_t ssb ) { fPurity = ssb; }
void SetSelector( Int_t i, UInt_t s ) { fSelector[i] = s; }
void SetCutMin( Int_t i, Double_t v ) { fCutMin[i] = v; }
void SetCutMax( Int_t i, Double_t v ) { fCutMax[i] = v; }
void SetCutDoMin( Int_t i, Bool_t v ) { fCutDoMin[i] = v; }
void SetCutDoMax( Int_t i, Bool_t v ) { fCutDoMax[i] = v; }
// accessors
UInt_t GetNvars() const { return fSelector.size(); }
UInt_t GetSelector(Int_t is) const { return fSelector[is]; }
Double_t GetCutMin(Int_t is) const { return fCutMin[is]; }
Double_t GetCutMax(Int_t is) const { return fCutMax[is]; }
Char_t GetCutDoMin(Int_t is) const { return fCutDoMin[is]; }
Char_t GetCutDoMax(Int_t is) const { return fCutDoMax[is]; }
Double_t GetCutNeve() const { return fCutNeve; }
Double_t GetPurity() const { return fPurity; }
private:
// copy
inline void Copy( const RuleCut & other);
// make the cuts from the array of nodes
void MakeCuts( const std::vector< const TMVA::Node * > & nodes );
std::vector<UInt_t> fSelector; // array of selectors (expressions)
std::vector<Double_t> fCutMin; // array of lower limits
std::vector<Double_t> fCutMax; // array of upper limits
std::vector<Char_t> fCutDoMin; // array of usage flags for lower limits <--- stores boolean
std::vector<Char_t> fCutDoMax; // array of usage flags for upper limits <--- stores boolean
Double_t fCutNeve; // N(events) after cut (possibly weighted)
Double_t fPurity; // S/(S+B) on training data
mutable MsgLogger* fLogger; // message logger
MsgLogger& Log() const { return *fLogger; }
};
}
//_______________________________________________________________________
inline void TMVA::RuleCut::Copy( const TMVA::RuleCut & other )
{
// copy from another
if (&other != this) {
for (UInt_t ns=0; ns<other.GetNvars(); ns++) {
fSelector.push_back( other.GetSelector(ns) );
fCutMin.push_back( other.GetCutMin(ns) );
fCutMax.push_back( other.GetCutMax(ns) );
fCutDoMin.push_back( other.GetCutDoMin(ns) );
fCutDoMax.push_back( other.GetCutDoMax(ns) );
}
fCutNeve = other.GetCutNeve();
fPurity = other.GetPurity();
}
}
//_______________________________________________________________________
inline Bool_t TMVA::RuleCut::EvalEvent( const Event &eve )
{
// evaluate event using the cut
// Loop over all cuts
Int_t sel;
Double_t val;
Bool_t done=kFALSE;
Bool_t minOK, cutOK;
UInt_t nc=0;
while (!done) {
sel = fSelector[nc];
val = eve.GetVal(sel);
minOK = (fCutDoMin[nc] ? (val>fCutMin[nc]):kTRUE); // min cut ok
cutOK = (minOK ? ((fCutDoMax[nc] ? (val<fCutMax[nc]):kTRUE)) : kFALSE); // cut ok
nc++;
done = ((!cutOK) || (nc==fSelector.size())); // done if
}
// return ( cutOK ? 1.0: 0.0 );
return cutOK;
}
//_______________________________________________________________________
inline void TMVA::RuleCut::SetNvars( UInt_t nc )
{
// set the number of cuts
fSelector.clear();
fCutMin.clear();
fCutMax.clear();
fCutDoMin.clear();
fCutDoMax.clear();
//
fSelector.resize(nc);
fCutMin.resize(nc);
fCutMax.resize(nc);
fCutDoMin.resize(nc);
fCutDoMax.resize(nc);
}
#endif