ROOT logo
ROOT » TMVA » TMVA::Event

class TMVA::Event

Function Members (Methods)

public:
~Event()
static voidClearDynamicVariables()
voidCopyVarValues(const TMVA::Event& other)
TMVA::EventEvent()
TMVA::EventEvent(const TMVA::Event&)
TMVA::EventEvent(const vector<Float_t*>*&)
TMVA::EventEvent(const vector<Float_t>&, UInt_t theClass, Float_t weight = 1.0, Float_t boostweight = 1.0)
TMVA::EventEvent(const vector<Float_t>&, const vector<Float_t>& targetValues, UInt_t theClass = 0, Float_t weight = 1.0, Float_t boostweight = 1.0)
TMVA::EventEvent(const vector<Float_t>&, const vector<Float_t>& targetValues, const vector<Float_t>& spectatorValues, UInt_t theClass = 0, Float_t weight = 1.0, Float_t boostweight = 1.0)
Float_tGetBoostWeight() const
UInt_tGetClass() const
UInt_tGetNSpectators() const
UInt_tGetNTargets() const
UInt_tGetNVariables() const
UInt_tGetNVars() const
Float_tGetOriginalWeight() const
Int_tGetSignalClass() const
Float_tGetSpectator(UInt_t ivar) const
vector<Float_t>&GetSpectators() const
Float_tGetTarget(UInt_t itgt) const
vector<Float_t>&GetTargets() const
UInt_tGetType() const
Float_tGetVal(UInt_t ivar) const
Float_tGetValue(UInt_t ivar) const
const vector<Float_t>&GetValues() const
Float_tGetWeight() const
Bool_tIsSignal() const
TMVA::Event&operator=(const TMVA::Event&)
voidPrint(ostream& o) const
voidScaleBoostWeight(Float_t s)
voidScaleWeight(Float_t s)
voidSetBoostWeight(Float_t w)
voidSetClass(UInt_t t)
voidSetSignalClass(UInt_t cls)
voidSetSpectator(UInt_t ivar, Float_t value)
voidSetTarget(UInt_t itgt, Float_t value)
voidSetType(Int_t t)
voidSetType(TMVA::Types::ESBType t)
voidSetVal(UInt_t ivar, Float_t val)
voidSetValFloatNoCheck(UInt_t ivar, Float_t val)
voidSetWeight(Float_t w)
UInt_tType() const

Data Members

private:
Float_tfBoostWeightinternal weight to be set by boosting algorithm
UInt_tfClasssignal or background type: signal=1, background=0
Bool_tfDynamicis set when the dynamic values are taken
UInt_tfSignalClassintermediate solution to keep IsSignal() of Event working. TODO: remove IsSignal() from Event
vector<Float_t>fSpectators"visisting" variables which are never used for any calculation
vector<Float_t>fTargetstarget values for regression
vector<Float_t>fValuesthe event values
Float_tfWeightevent weight (product of global and individual weights)
static Int_tfgCountcount instances of Event
static vector<Float_t*>*fgValuesDynamicthe event values

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

Event()
 copy constructor
Event(const vector<Float_t>& , const vector<Float_t>& targetValues, UInt_t theClass = 0, Float_t weight = 1.0, Float_t boostweight = 1.0)
 constructor
Event(const vector<Float_t>& , const vector<Float_t>& targetValues, const vector<Float_t>& spectatorValues, UInt_t theClass = 0, Float_t weight = 1.0, Float_t boostweight = 1.0)
 constructor
Event(const vector<Float_t>& , UInt_t theClass, Float_t weight = 1.0, Float_t boostweight = 1.0)
 constructor
Event( const std::vector<Float_t*>*& evdyn )
Event( const Event& event )
 copy constructor
~Event()
 Event destructor
void ClearDynamicVariables()
 clear global variable
void CopyVarValues(const TMVA::Event& other)
 copies only the variable values
Float_t GetVal(UInt_t ivar) const
 return value of i'th variable
const std::vector<Float_t>& GetValues() const
 return va;lue vector
void SetVal(UInt_t ivar, Float_t val)
 set variable ivar to val
void Print(ostream& o) const
 print method
Bool_t IsSignal() const
 accessors
{ return (fClass==fSignalClass); }
Float_t GetWeight() const
{ return fWeight*fBoostWeight; }
Float_t GetOriginalWeight() const
{ return fWeight; }
Float_t GetBoostWeight() const
{ return TMath::Max(Float_t(0.0001),fBoostWeight); }
UInt_t GetType() const
{ return GetClass(); }
UInt_t GetClass() const
{ return fClass; }
UInt_t Type() const
{ return fClass; }
UInt_t GetNVariables() const
{ return fValues.size(); }
UInt_t GetNTargets() const
{ return fTargets.size(); }
UInt_t GetNSpectators() const
{ return fSpectators.size(); }
UInt_t GetNVars() const
{ return fValues.size(); }
Int_t GetSignalClass() const
{ return fSignalClass; }
Float_t GetValue(UInt_t ivar) const
{ return GetVal( ivar ); }
void ScaleWeight(Float_t s)
{ fWeight*=s; }
void SetWeight(Float_t w)
{ fWeight=w; }
void SetBoostWeight(Float_t w)
{ fBoostWeight=w; }
void ScaleBoostWeight(Float_t s)
{ fBoostWeight *= s; }
void SetType( Int_t t )
{ SetClass(t); }
void SetClass(UInt_t t)
{ fClass=t; }
void SetType( Types::ESBType t )
{ fClass=(t==Types::kSignal) ? 1 : 0; }
void SetValFloatNoCheck(UInt_t ivar, Float_t val)
{ fValues[ivar] = val; }
void SetSignalClass(UInt_t cls)
{ fSignalClass = cls; }
void SetTarget(UInt_t itgt, Float_t value)
std::vector<Float_t>& GetTargets() const
{ return fTargets; }
Float_t GetTarget(UInt_t itgt) const
{ return fTargets.at(itgt); }
void SetSpectator(UInt_t ivar, Float_t value)
std::vector<Float_t>& GetSpectators() const
{ return fSpectators; }
Float_t GetSpectator(UInt_t ivar) const
{ return fSpectators.at(ivar); }