SubGraphID.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Jakob Lettenbichler (jakob.lettenbichler@oeaw.ac.at)     *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <framework/logging/Logger.h>
#include <tracking/dataobjects/FullSecID.h>
 
#include <string>
#include <vector>
 
namespace Belle2 {
  class SubGraphID {
  protected:
    std::vector<unsigned> m_idChain; 
    bool areTheSameSector(unsigned a, unsigned b) const
    {
      FullSecID idA(a);
      FullSecID idB(b);
      return idA.getVxdID() == idB.getVxdID() and idA.getSecID() == idB.getSecID();
    }
 
  public:
 
    bool operator==(const SubGraphID& b) const
    {
      unsigned chainsize = m_idChain.size();
      if (b.size() != chainsize) { return false; }
 
      for (unsigned i = 0; i < chainsize; i++) {
        if (b.m_idChain[i] != m_idChain[i]) { return false; }
      }
 
      return true;
    }
 
 
    bool operator<(const SubGraphID& b)  const
    {
      // sorting: if outermost (== first) sector > of b.outermost this > b. If outermost == b.outermost, step is repeated until end of chain length is reached. last straw: longer chain is bigger.
      unsigned chainsize = m_idChain.size() < b.size() ? m_idChain.size() : b.size();
      for (unsigned i = 0 ; i < chainsize; i++) {
        if (m_idChain[i] < b.m_idChain[i]) return true;
        if (m_idChain[i] == b.m_idChain[i]) continue;
        return false;
      }
      return m_idChain.size() < b.size();
    }
 
 
    explicit SubGraphID(const std::vector<unsigned>& idChain) : m_idChain(idChain)
    {
      if (m_idChain.empty()) { B2FATAL("SubGraphID-Constructor, given idChain is empty - illegal usage!"); }
    }
 
 
    unsigned size() const { return m_idChain.size(); }
 
 
    std::vector<unsigned>::const_iterator begin() const { return m_idChain.begin(); }
 
 
    std::vector<unsigned>::const_iterator end() const { return m_idChain.end(); }
 
 
    bool checkSharesTrunk(const SubGraphID& b) const
    {
      unsigned chainsize = m_idChain.size();
      if (b.size() != chainsize) { return false; }
 
      for (unsigned i = 0; i < chainsize - 1; i++) {
        if (b.m_idChain[i] != m_idChain[i]) { return false; }
      }
 
      return true;
    }
 
 
    std::string print() const
    {
      std::string out;
      for (unsigned iD : m_idChain) {
        out += FullSecID(iD).getFullSecString() + " ";
      }
      return out;
    }
 
 
    unsigned isElementOf(const SubGraphID& b) const
    { return isElementOf(b.m_idChain); }
 
 
    unsigned isElementOf(const std::vector<unsigned>& b) const
    {
      if (size() < b.size()) return 0;
 
      unsigned nIdentical = 0;
      for (unsigned idA : m_idChain) {
        for (unsigned idB : b) {
          if (areTheSameSector(idA, idB)) nIdentical++;
        }
      }
      return nIdentical;
    }
 
 
    bool hasElement(unsigned b) const
    {
      for (unsigned idA : m_idChain) {
        if (areTheSameSector(idA, b)) return true;
      }
      return false;
    }
 
 
    bool areTheSameSectors(const SubGraphID& b) const
    {
      if (size() != b.size()) return false;
      for (unsigned i = 0; i < size(); i++) {
        if (areTheSameSector(m_idChain[i], b.m_idChain[i]) == false) return false;
      }
      return true;
    }
 
 
    std::vector<unsigned> hasSharedLayer() const
    {
      B2DEBUG(1, "hasSharedLayer-start with iD " << print() << ":");
      std::vector<unsigned> outerOnes;
      for (unsigned i = 0; i < size() - 1; i++) { // i: outer iD i+1: inner iD
        B2DEBUG(1, "found layerIDs for outer/inner: " << FullSecID(m_idChain[i]).getLayerID() << "/" << FullSecID(
                  m_idChain[i + 1]).getLayerID());
        if (FullSecID(m_idChain[i]).getLayerID() == FullSecID(m_idChain[i + 1]).getLayerID()) {
          outerOnes.push_back(m_idChain[i]);
          B2DEBUG(1, "hasSharedLayer good combi found with inner: " << FullSecID(m_idChain[i + 1]).getFullSecString() << ", storing outer: "
                  << FullSecID(m_idChain[i]).getFullSecString());
        }
      }
      return outerOnes;
    }
 
 
    bool updateID(unsigned newID)
    {
      for (unsigned& secID : m_idChain) {
        if (areTheSameSector(newID, secID) == false) continue;
        FullSecID tempID(secID);
        secID = FullSecID(tempID.getVxdID(), true, tempID.getSecID()).getFullSecID();
        return true;
      }
 
      return false;
    }
 
 
    std::vector<FullSecID> getFullSecIDs() const
    {
      std::vector<FullSecID> ids;
 
      for (auto& id : m_idChain) {
        ids.push_back(FullSecID(id));
      }
      return ids;
    }
  }; // class SubGraphID
 
 
} // namespace Belle2
 
namespace std {
  template <> struct hash<Belle2::SubGraphID> {
    std::size_t operator()(const Belle2::SubGraphID& graphID) const
    {
      std::size_t hashVal = 0;
      for (unsigned iD : graphID) {
        hashVal = std::hash<unsigned>()(iD) ^ hashVal;
        ++hashVal;
      }
      return hashVal;
    }
  };
}