SubGraph.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
 
#include <framework/logging/Logger.h>
#include <tracking/trackFindingVXD/sectorMapTools/RawDataCollectedMinMax.h>
#include <tracking/trackFindingVXD/sectorMapTools/MinMax.h>
#include <tracking/trackFindingVXD/sectorMapTools/SubGraphID.h>
#include <tracking/dataobjects/FullSecID.h>
 
#include <string>
#include <vector>
#include <unordered_map>
#include <utility>
 
 
namespace Belle2 {

  template<class FilterType> class SubGraph {
  protected:
    std::unordered_map<FilterType, MinMax> m_minMaxValues;
 
    SubGraphID m_id; 
 
    std::unordered_map<FilterType, RawDataCollectedMinMax>* m_rawDataCollected = nullptr; 
 
    unsigned m_found = 1; 

    void updateID(const SubGraphID& newID)
    { m_id = newID; }
  public:

    bool operator==(const SubGraph<FilterType>& b) const
    { return (m_id == b.m_id); }

    using Iterator = typename std::unordered_map<FilterType, MinMax>::iterator;

    SubGraph(SubGraphID& id, const std::vector<FilterType>& fIDs) : m_id(id)
    {
      for (auto& iD : fIDs) {
        m_minMaxValues.insert({iD, MinMax()});
      }
    }

    ~SubGraph() { if (m_rawDataCollected != nullptr) delete m_rawDataCollected; }

    bool checkAndReplaceIfMinMax(FilterType fID, double value)
    {
      Iterator pos = m_minMaxValues.find(fID);
      if (pos == m_minMaxValues.end()) {
        B2WARNING("FilterID " << fID << " not known to this subgraph " << m_id.print() << " - nothing added!");
        return false;
      }
      return pos->second.checkAndReplaceIfMinMax(value);
    }
 
    void wasFound() { m_found++; } 
 
    unsigned getFound() const { return m_found; } 

    bool checkSharesTrunk(const SubGraph<FilterType>& b) const { return (m_id.checkSharesTrunk(b.m_id)); }

    std::string print() const
    {
      std::string out = "id: " + m_id.print() + " was found " + std::to_string(m_found) + " times. Filters with values collected:\n";
      for (const auto& entry : m_minMaxValues) {
        out += entry.first + " " + entry.second.print() + " _||_ ";
      }
      return out;
    }

    const SubGraphID& getID() const { return m_id; }

    void prepareDataCollection(std::pair<double, double> quantiles)
    {
      if (m_rawDataCollected != nullptr) delete m_rawDataCollected;
      m_rawDataCollected = new std::unordered_map<FilterType, RawDataCollectedMinMax>();
 
      for (const auto& entry : m_minMaxValues) {
        m_rawDataCollected->insert({entry.first, RawDataCollectedMinMax(m_found, quantiles)});
      }
    }

    void addValue(FilterType fID, double value)
    {
      if (m_rawDataCollected == nullptr) { B2FATAL("SubGraph::addValue: attempt to add data before prepareDataCollection(...) was executed! Aborting illegal procedure."); }
      auto pos = m_rawDataCollected->find(fID);
      if (pos == m_rawDataCollected->end()) {
        B2WARNING("addValue: FilterID " << fID << " not known to this subgraph " << m_id.print() << " - nothing added!");
        return;
      }
      pos->second.add(value);
      return;
    }

    const std::unordered_map<FilterType, MinMax>& getFinalQuantileValues()
    {
      for (auto& entry : *m_rawDataCollected) {
        std::pair<double, double> results = entry.second.getMinMax();
        checkAndReplaceIfMinMax(entry.first, results.first);
        checkAndReplaceIfMinMax(entry.first, results.second);
      }
 
      std::string out;
      for (auto& entry : m_minMaxValues) {
        out += entry.first + " " + entry.second.print() + "  ";
      }
      B2DEBUG(20, "SubGraph::getFinalQuantileValues: minMaxFound:\n" << out);
      return m_minMaxValues;
    }

    unsigned idCheckAndUpdate(const std::vector<unsigned>& ids)
    {
      unsigned nUpdated = 0;
      for (unsigned id : ids) {
 
        if (m_id.hasElement(id)) {
          m_id.updateID(id);
          nUpdated++;
        }
      }
      return nUpdated;
    }

    std::vector<FullSecID> getSectorsOfSensor(const VxdID& sensor)
    {
      std::vector<FullSecID> foundIDs;
 
      for (auto& sector : m_id) {
        if (sensor != FullSecID(sector).getVxdID()) continue;
        foundIDs.push_back(FullSecID(sector));
      }
      return foundIDs;
    }
  };
}