PndMvaUtil.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

/* ********************************************
 * MVA Utility functions and data definitions.*
 * Author: M.Babai@rug.nl                     *
 * Version:                                   *
 * License:                                   *
 * *******************************************
 */
//#pragma once
#ifndef PND_MVA_UTIL_H
#define PND_MVA_UTIL_H

#include <typeinfo>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <cmath>
#include <cassert>

// =========================================================
struct StepError {
  StepError() : m_step(0), m_trErr(0.0), m_tsErr(0.0), m_MisClsTest(std::map<std::string, float>()), m_MisClsTrain(std::map<std::string, float>()){};

  explicit StepError(size_t step, float trErr, float tsErr, std::map<std::string, float> const &MisClsTest, std::map<std::string, float> const &MisClsTrain)
    : m_step(step), m_trErr(trErr), m_tsErr(tsErr), m_MisClsTest(MisClsTest), m_MisClsTrain(MisClsTrain){};

  virtual ~StepError(){};

  StepError(StepError const &ot) : m_step(ot.m_step), m_trErr(ot.m_trErr), m_tsErr(ot.m_tsErr), m_MisClsTest(ot.m_MisClsTest), m_MisClsTrain(ot.m_MisClsTrain){};

  StepError &operator=(StepError const &ot)
  {
    // check for self-assignment
    if (this != &ot) { // Not equal, thus deep copy
      this->m_step = ot.m_step;
      this->m_trErr = ot.m_trErr;
      this->m_tsErr = ot.m_tsErr;
      this->m_MisClsTest = ot.m_MisClsTest;
      this->m_MisClsTrain = ot.m_MisClsTrain;
    }
    return (*this);
  };

  unsigned int m_step;                        
  float m_trErr;                              
  float m_tsErr;                              
  std::map<std::string, float> m_MisClsTest;  
  std::map<std::string, float> m_MisClsTrain; 
 private:
  inline bool operator<(StepError const &other) const;
  inline bool operator>(StepError const &other) const;
};
// ========================================================================

struct PndMvaDistObj {
  explicit PndMvaDistObj() : m_idx(0), m_dist(0.0), m_cls("UNKNOWN_LABEL"){};

  explicit PndMvaDistObj(size_t const id, float const dist, std::string const &cls) : m_idx(id), m_dist(dist), m_cls(cls){};

  // Copy
  PndMvaDistObj(PndMvaDistObj const &ot) : m_idx(ot.m_idx), m_dist(ot.m_dist), m_cls(ot.m_cls){};

  // Destructor
  virtual ~PndMvaDistObj(){};

  PndMvaDistObj &operator=(PndMvaDistObj const &ot)
  {
    // check for self-assignment
    if (this != &ot) { // Not equal, thus deep copy
      this->m_idx = ot.m_idx;
      this->m_dist = ot.m_dist;
      this->m_cls = ot.m_cls;
    }
    return (*this);
  };

  inline bool operator<(PndMvaDistObj const &other) const { return (this->m_dist < other.m_dist); };

  inline bool operator>(PndMvaDistObj const &other) const { return (this->m_dist > other.m_dist); };

  size_t m_idx;      
  float m_dist;      
  std::string m_cls; 
 private:
  bool operator==(PndMvaDistObj const &ot) const;
}; // End interface PndMvaDistObj

inline bool CompLess(PndMvaDistObj const *a, PndMvaDistObj const *b)
{
  assert(a && b);
  return ((*a).m_dist < (*b).m_dist);
};

// ========================================================================

template <typename T>
inline T const &minFunct(T const &a, T const &b)
{
  // or: return comp(a,b)?a:b; for the comp version
  return (a < b) ? a : b;
};

template <typename T>
inline bool compareL(T const *l, T const *r)
{
  assert(l && r);
  return ((*l) < (*r));
};

template <typename Set1, typename Set2>
bool is_disjoint(Set1 const &set1, Set2 const &set2)
{
  // IF one of the sets is empty. O(1) true on empty sets per
  // definition.
  if (set1.empty() || set2.empty()) {
    return true;
  }
  // Start and end iterators of the first sequence.
  typename Set1::const_iterator it1 = set1.begin();
  typename Set1::const_iterator it1End = set1.end();

  // Start and end iterators of the second sequence.
  typename Set2::const_iterator it2 = set2.begin();
  typename Set2::const_iterator it2End = set2.end();

  // This holds because the sequences are pre-sorted. O(1)
  if (*it1 > *set2.rbegin() || *it2 > *set1.rbegin()) {
    return true;
  }

  // Investigate element-wise.
  while ((it1 != it1End) && (it2 != it2End)) {
    if (*it1 == *it2) {
      return false;
    }

    if (*it1 < *it2) {
      it1++;
    } else {
      it2++;
    }
  } // WHILE
  return true;
}

float ComputeDist(std::vector<float> const &EvtData, std::vector<float> const &Example);

// Convert string to int or size_t
int str2int(std::string const &str);
unsigned int str2Uint(std::string const &str);

// Convert int to string
std::string int2str(int n);

//______________ C style function declarations
#ifdef __cplusplus
extern "C" {
#endif
// Place your C code here.

#ifdef __cplusplus
}
#endif

#endif // interface definition