PndMvaTools.h

Go to the documentation of this file.

/* ********************************************
 * MVA Tools and function definitions.        *
 * Author: M.Babai@rug.nl                     *
 * Version:                                   *
 * License:                                   *
 * *******************************************
 */
#pragma once
#ifndef PND_MVA_TOOLS_H
#define PND_MVA_TOOLS_H

// C++
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <algorithm>
#include <limits>

// ROOT
#include "TFile.h"
#include "TTree.h"

struct ClassifierOutPuts
{
  //public:
  // Constructors
  explicit ClassifierOutPuts()
  : realLabel ("ALABEL"),
    givenLabel("NOLABEL"),
    sgValue(0.00),
    bgValue(0.00),
    mom(0.00)
  {};
  
  explicit ClassifierOutPuts(std::string const& Rlabel,
                             std::string const& Glabel,
                             float sgVal, float bgVal, float p)
  : realLabel(Rlabel),
    givenLabel(Glabel),
    sgValue(sgVal),
    bgValue(bgVal),
    mom(p)
  {};
  
  // Destructor
  virtual ~ClassifierOutPuts()
  {};
  
  // Copy Const
  ClassifierOutPuts(ClassifierOutPuts const& ot)
  : realLabel(ot.realLabel),
    givenLabel(ot.givenLabel),
    sgValue(ot.sgValue),
    bgValue(ot.bgValue),
    mom(ot.mom)
  {};

  // Operators.  
  ClassifierOutPuts& operator=(ClassifierOutPuts const& ot)
  {
    // check for self-assignment
    if( this != &ot )
    {
      // Copy (deep)
      this->realLabel  = ot.realLabel;
      this->givenLabel = ot.givenLabel;
      this->sgValue    = ot.sgValue;
      this->bgValue    = ot.bgValue;
      this->mom        = ot.mom;
    }
    return (*this);
  };
  
  inline bool operator> (ClassifierOutPuts const& ot) const
  {
    return (this->sgValue > ot.sgValue);
  };
  
  inline bool operator< (ClassifierOutPuts const& ot) const
  {
    return (this->sgValue < ot.sgValue);
  };

  // Variables
  std::string realLabel;// Original label
  std::string givenLabel;// Given label
  float sgValue;// Classifier output for label signal
  float bgValue;// Classifier output for label background
  float mom; // Momentum (reco.)

  //protected:
private:
  //==
  inline bool operator==(ClassifierOutPuts const& ot) const;
};

struct ROCPoints
{
  // Constructors
  explicit ROCPoints()
    : FP_rate(0.0),
      TP_rate(0.0),
      TN_rate(0.0),
      FN_rate(0.0),
      fp(0),
      tp(0),
      fn(0),
      tn(0),
      thr(0.0)
  {};
  explicit ROCPoints(float  const fpr, float  const tpr,
                     float  const tnr, float  const fnr,
                     size_t const nfp, size_t const ntp,
                     size_t const nfn, size_t const ntn,
                     float const curThr)
    : FP_rate(fpr),
      TP_rate(tpr),
      TN_rate(tnr),
      FN_rate(fnr),
      fp(nfp),
      tp(ntp),
      fn(nfn),
      tn(ntn),
      thr(curThr)
  {};
  
  // Destructor
  virtual ~ROCPoints()
  {};
  
  // Copy Const
  ROCPoints(ROCPoints const& ot)
    : FP_rate(ot.FP_rate),
      TP_rate(ot.TP_rate),
      TN_rate(ot.TN_rate),
      FN_rate(ot.FN_rate),
      fp(ot.fp),
      tp(ot.tp),
      fn(ot.fn),
      tn(ot.tn),
      thr(ot.thr)
  {};
  
  // Operators.  
  ROCPoints& operator=(ROCPoints const& ot)
  {
    // check for self-assignment
    if(this != &ot)
    {
      this->FP_rate = ot.FP_rate;
      this->TP_rate = ot.TP_rate;
      this->TN_rate = ot.TN_rate;
      this->FN_rate = ot.FN_rate;
      this->fp      = ot.fp;
      this->tp      = ot.tp;
      this->fn      = ot.fn;
      this->tn      = ot.tn;
      this->thr     = ot.thr;
    }
    return (*this);
  };
  
  // Variables
  float FP_rate;// False positief rate
  float TP_rate;// True positief rate
  float TN_rate;// True negatief rate
  float FN_rate;// False negatief rate
  size_t fp;// False positief count
  size_t tp;// True positief count
  size_t fn;// False negatief
  size_t tn;// True negatief
  float  thr;// Treshold value

  //  protected:
  
private:
  bool operator==(ROCPoints const& ot) const;
  bool operator>( ROCPoints const& ot) const;
  bool operator<( ROCPoints const& ot) const;
};

//____________ Functions and modifiers.
//______________________________________________________________
void Produce_ROC(std::vector< ClassifierOutPuts >& input,
                 std::string const& SigName, std::string const& BgName,
                 size_t sigCnt, size_t bgCnt, std::vector< ROCPoints >& Roc);
void print(std::vector< ClassifierOutPuts > const& OutPutList);

void print(std::map<std::string, float> const& ClsMapOut);

std::map<std::string, size_t>* readEvents(char const* infile,
                                          std::vector<std::string> const& varNames,
                                          std::vector<std::string> const& classNames,
                                          std::vector<std::pair<std::string, std::vector<float>* > >& Outcontainer);

void printRoc(std::vector< ROCPoints > const& RocList);
  
void WriteRocToFile( std::string const& FileName,
                     std::vector< ROCPoints > const& RocList);

//____________________ C style function declarations
#ifdef __cplusplus
extern "C"
{
#endif
  // Place your C code and/or C headers here.  
#ifdef __cplusplus
}
#endif

#endif
//interface definition
/*
  Test for GCC > 3.2.0 
  #if __GNUC__ > 3 || (__GNUC__ == 3 && (__GNUC_MINOR__ > 2 || (__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ > 0) ) )
*/