MCVXDPurityInfo.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
// stl:
#include <array>
#include <utility> // std::pair
#include <numeric>      // std::accumulate
#include <sstream>
#include <string>
 
namespace Belle2 {
  class MCVXDPurityInfo {
  protected:
    int m_iD;
 
    std::array<unsigned int, 3> m_nTotalClusters;
 
    std::array<unsigned int, 3> m_nFoundClusters;
 
  public:
 
    MCVXDPurityInfo() :
      m_iD(-1),
      m_nTotalClusters{0, 0, 0},
      m_nFoundClusters{0, 0, 0} {}
 
    MCVXDPurityInfo(int iD,
                    unsigned int nPXDClustersTotal,
                    unsigned int nSVDUClustersTotal,
                    unsigned int nSVDVClustersTotal,
                    unsigned int nPXDClusters,
                    unsigned int nSVDUClusters,
                    unsigned int nSVDVClusters) :
      m_iD(iD),
      m_nTotalClusters({ {nPXDClustersTotal, nSVDUClustersTotal, nSVDVClustersTotal} }),
    m_nFoundClusters({ {nPXDClusters, nSVDUClusters, nSVDVClusters} }) {}
 
    MCVXDPurityInfo(int iD, std::array<unsigned int, 3> nClustersTotal, std::array<unsigned int, 3> nMCClusters) :
      m_iD(iD), m_nTotalClusters(nClustersTotal), m_nFoundClusters(nMCClusters) { }
 
    inline bool operator > (const MCVXDPurityInfo& b) const
    {
      return getPurity().second > b.getPurity().second;
    }
 
 
    inline bool operator < (const MCVXDPurityInfo& b) const
    {
      return getPurity().second < b.getPurity().second;
    }
 
 
    std::pair<int, float> getPurity() const
    {
      unsigned int nTotal = std::accumulate(m_nTotalClusters.begin() + 1, m_nTotalClusters.end(), 0) + 2 * m_nTotalClusters[0];
      unsigned int nFound = std::accumulate(m_nFoundClusters.begin() + 1, m_nFoundClusters.end(), 0) + 2 * m_nFoundClusters[0];
      return {m_iD, (nTotal == 0 ? 0.f : float(nFound) / float(nTotal)) };
    }
 
 
    std::pair<int, float> getPurityPXD() const
    {
      return {m_iD, (m_nTotalClusters[0] == 0 ? 0.f : float(m_nFoundClusters[0]) / float(m_nTotalClusters[0])) };
    }
 
 
    std::pair<int, float> getPuritySVD() const
    {
      unsigned int nTotal = std::accumulate(m_nTotalClusters.begin() + 1, m_nTotalClusters.end(), 0);
      unsigned int nFound = std::accumulate(m_nFoundClusters.begin() + 1, m_nFoundClusters.end(), 0);
      return {m_iD, (nTotal == 0 ? 0.f : float(nFound) / float(nTotal)) };
    }
 
 
    std::pair<int, float> getPuritySVDU() const
    {
      return {m_iD, (m_nTotalClusters[1] == 0 ? 0.f : float(m_nFoundClusters[1]) / float(m_nTotalClusters[1])) };
    }
 
 
    std::pair<int, float> getPuritySVDV() const
    {
      return {m_iD, (m_nTotalClusters[2] == 0 ? 0.f : float(m_nFoundClusters[2]) / float(m_nTotalClusters[2])) };
    }
 
 
    int getParticleID() const { return m_iD; }
 
 
    unsigned int getNClustersTotal() const { return std::accumulate(m_nTotalClusters.begin(), m_nTotalClusters.end(), 0); }
 
 
    unsigned int getNPXDClustersTotal() const { return m_nTotalClusters[0]; }
 
 
    unsigned int getNSVDUClustersTotal() const { return m_nTotalClusters[1]; }
 
 
    unsigned int getNSVDVClustersTotal() const { return m_nTotalClusters[2]; }
 
 
    unsigned int getNClustersFound() const { return std::accumulate(m_nFoundClusters.begin(), m_nFoundClusters.end(), 0); }
 
 
    unsigned int getNPXDClusters() const { return m_nFoundClusters[0]; }
 
 
    unsigned int getNSVDUClusters() const { return m_nFoundClusters[1]; }
 
 
    unsigned int getNSVDVClusters() const { return m_nFoundClusters[2]; }
 
 
    unsigned int getNDFTotal() const { return std::accumulate(m_nTotalClusters.begin() + 1, m_nTotalClusters.end(), 0) + 2 * m_nTotalClusters[0]; }
 
 
    unsigned int getNDFFound() const { return std::accumulate(m_nFoundClusters.begin() + 1, m_nFoundClusters.end(), 0) + 2 * m_nFoundClusters[0]; }
 
 
    unsigned int getNDFPXDTotal() const { return  2 * m_nTotalClusters[0]; }
 
 
    unsigned int getNDFPXDFound() const { return  2 * m_nFoundClusters[0]; }
 
 
    unsigned int getNDFSVDTotal() const { return std::accumulate(m_nTotalClusters.begin() + 1, m_nTotalClusters.end(), 0); }
 
 
    unsigned int getNDFSVDFound() const { return std::accumulate(m_nFoundClusters.begin() + 1, m_nFoundClusters.end(), 0); }
 
 
    unsigned int getNDFSVDUTotal() const { return getNSVDUClustersTotal(); }
 
 
    unsigned int getNDFSVDVTotal() const { return getNSVDVClustersTotal(); }
 
 
    unsigned int getNDFSVDUFound() const { return getNSVDUClusters(); }
 
 
    unsigned int getNDFSVDVFound() const { return getNSVDVClusters(); }
 
 
    std::string dumpToString() const
    {
      std::stringstream s;
      s << "iD: " << m_iD << "\n";
      for (size_t i = 0; i < m_nTotalClusters.size(); ++i) {
        s << "totalClusters[" << i << "]: " << m_nTotalClusters[i] << ", foundClusters[" << i << "]: " << m_nFoundClusters[i] << "\n";
      }
      return s.str();
    }
  };
}