contains all subgraphs. More...

#include <SectorGraph.h>

Public Types
using	Iterator = typename std::unordered_map<SubGraphID, SubGraph<FilterType>>::iterator
	for better readability.

Public Member Functions
	SectorGraph (const std::vector< FilterType > &fIDs)
	constructor expects filterIDs.

Iterator	find (SubGraphID idChain)
	find entry.

Iterator	begin ()
	returns begin of subGraphs.

Iterator	end ()
	returns end of subGraphs.

unsigned	size () const
	returns number of collected subgraphs so far.

unsigned long	nFoundTotal () const
	returns number of occurrences for all subGraphs found together.

Iterator	add (SubGraphID &newID)
	add new subgraph if not added already.

std::string	print (bool fullPrint=true) const
	returns a string giving an overview of the graph.

unsigned	pruneGraph (double rarenessCut)
	returns removed occurrences.

int	getAbsThreshold (int relThreshold)
	Get the absolute threshold (# nfound) given a relative threshold.

unsigned	pruneGraphBeforeTraining (int absThreshold)
	returns removed occurrences.

void	output_nfound ()
	Output in a txt file id & nfound of subgraphs.

void	updateSubLayerIDs ()
	finds sectors having inner sectors in same layer and update them in the subGraph-ID.

std::vector< FullSecID >	getAllFullSecIDsOfSensor (VxdID sensor)
	returns a Vector containing all FullSecIDs found for given sensor.

const std::vector< FilterType > &	getFilterTypes () const
	returns a const reference to the filterTypes stored in this graph

Protected Attributes
std::unordered_map< SubGraphID, SubGraph< FilterType > >	m_subgraphs
	contains all subgraphs.

std::vector< FilterType >	m_filterIDs
	ids of all filterTypes to be stored by subGraphs.

Detailed Description

template<class FilterType>
class Belle2::SectorGraph< FilterType >

contains all subgraphs.

The ids used for the subgraphs have to be sorted from outer to inner sectors.

Definition at line 31 of file SectorGraph.h.

Member Typedef Documentation

◆ Iterator

template<class FilterType>

using Iterator = typename std::unordered_map<SubGraphID, SubGraph<FilterType>>::iterator

for better readability.

Definition at line 43 of file SectorGraph.h.

Constructor & Destructor Documentation

◆ SectorGraph()

template<class FilterType>

SectorGraph ( const std::vector< FilterType > & fIDs )

inlineexplicit

constructor expects filterIDs.

Definition at line 39 of file SectorGraph.h.

39 : m_filterIDs(fIDs)

40 { if (m_filterIDs.empty()) { B2FATAL("SectorGraph-constructor: passed filterIDs are empty, this is an illegal usage of this class!"); } }

Member Function Documentation

◆ add()

template<class FilterType>

Iterator add ( SubGraphID & newID )

inline

add new subgraph if not added already.

Definition at line 66 of file SectorGraph.h.

    {
      if (m_subgraphs.find(newID) != end())
      { B2WARNING("SectorGraph::add: given ID " << newID.print() << " is already in graph, not added again..."); return end(); }
      std::pair<Iterator, bool> pos = m_subgraphs.insert({newID, SubGraph<FilterType>(newID, m_filterIDs)});
      B2DEBUG(20, "SectorGraph::add: new subgraph added: " << pos.first->second.print());
      return pos.first;
    }

◆ begin()

template<class FilterType>

Iterator begin ( )

inline

returns begin of subGraphs.

Definition at line 49 of file SectorGraph.h.

49{ return m_subgraphs.begin(); }

◆ end()

template<class FilterType>

Iterator end ( )

inline

returns end of subGraphs.

Definition at line 52 of file SectorGraph.h.

52{ return m_subgraphs.end(); }

◆ find()

template<class FilterType>

Iterator find ( SubGraphID idChain )

inline

find entry.

returns end() if not found.

Definition at line 46 of file SectorGraph.h.

46{ return m_subgraphs.find(idChain); }

◆ getAbsThreshold()

template<class FilterType>

int getAbsThreshold ( int relThreshold )

inline

Get the absolute threshold (# nfound) given a relative threshold.

Definition at line 168 of file SectorGraph.h.

    {
      if (relThreshold == 0) {return 0;}
      B2INFO("Relative threshold : " << relThreshold << " %");
      int xmax = 100000;
 
      TH1D* h_nfound = new TH1D("h", "# times that subgraphs were found n_found times", xmax, 0, xmax);
 
      for (auto& subGraphEntry : m_subgraphs) {
        SubGraph<FilterType>& graph = subGraphEntry.second;
        h_nfound->Fill(graph.getFound());
      }
 
      if (h_nfound->GetEntries() == 0) {
        B2ERROR("nfound histogram empty.");
        delete h_nfound;
        return 0;
      }
 
      TH1* hc_nfound = h_nfound->GetCumulative();
      hc_nfound->Scale(1 / h_nfound->GetEntries());
 
      for (int nfound = 1; nfound < hc_nfound->GetNbinsX(); nfound++) {
        if (hc_nfound->GetBinContent(nfound) > relThreshold / 100.) {
          B2INFO("Absolute threshold : remove every graph with nfound < " << nfound);
          delete h_nfound;
          delete hc_nfound;
          return nfound;
        }
      }
 
      // In case no value for nfound is found
      B2ERROR("No nfound value found.");
      delete h_nfound;
      delete hc_nfound;
      return 0;
    }

◆ getAllFullSecIDsOfSensor()

template<class FilterType>

std::vector< FullSecID > getAllFullSecIDsOfSensor ( VxdID sensor )

inline

returns a Vector containing all FullSecIDs found for given sensor.

Definition at line 300 of file SectorGraph.h.

    {
      std::vector<FullSecID> foundIDs;
 
      for (auto& subGraph : m_subgraphs) {
        std::vector<FullSecID> sectorsFound = subGraph.second.getSectorsOfSensor(sensor);
        if (sectorsFound.empty()) continue;
        foundIDs.insert(foundIDs.end(), sectorsFound.begin(), sectorsFound.end());
      }
      B2DEBUG(20, "getAllFullSecIDsOfSensor: VxdID " << sensor << " has " << foundIDs.size() << " sectors in this graph");
      return foundIDs;
    }

◆ getFilterTypes()

template<class FilterType>

const std::vector< FilterType > & getFilterTypes ( ) const

inline

returns a const reference to the filterTypes stored in this graph

Definition at line 314 of file SectorGraph.h.

314{ return m_filterIDs; }

◆ nFoundTotal()

template<class FilterType>

unsigned long nFoundTotal ( ) const

inline

returns number of occurrences for all subGraphs found together.

Definition at line 58 of file SectorGraph.h.

    {
      unsigned long nFound = 0;
      for (auto& pack : m_subgraphs) { nFound += pack.second.getFound(); }
      return nFound;
    }

◆ output_nfound()

template<class FilterType>

void output_nfound ( )

inline

Output in a txt file id & nfound of subgraphs.

Definition at line 231 of file SectorGraph.h.

    {
      std::ofstream out;
      out.open("output_nfound.txt");
      for (auto& subGraphEntry : m_subgraphs) {
        SubGraph<FilterType>& graph = subGraphEntry.second;
        out << graph.print() << std::endl;
      }
      out.close();
    }

◆ print()

template<class FilterType>

std::string print ( bool fullPrint = true ) const

inline

returns a string giving an overview of the graph.

Definition at line 76 of file SectorGraph.h.

    {
      unsigned nSubgraphs = m_subgraphs.size();
      std::string out = "graph has got " + std::to_string(nSubgraphs) + " entries:\n";
      out += "now printing " + (fullPrint ? std::string("full") : std::string("short version of the")) + " graph:\n";
      for (const auto& entry : m_subgraphs) {
        if (!fullPrint and nSubgraphs % 100 != 0) continue; // printing only 100 subgraphs of mainGraph for the short version.
        out += entry.second.print() + "\n";
      }
      return out;
    }

◆ pruneGraph()

template<class FilterType>

unsigned pruneGraph ( double rarenessCut )

inline

returns removed occurrences.

vector of trunks (= outer sector(s)):

Definition at line 89 of file SectorGraph.h.

    {
      //sanity checks:
      if (rarenessCut < 0 or rarenessCut >= 1)
      { B2WARNING("pruneGraph: rarenessCut is rubbish: " << rarenessCut << ", stopping prune-process."); return 0; }
      if (rarenessCut == 0) { B2DEBUG(20, "pruneGraph: nothing to be done, stopping prune-process."); return 0; }
      // .first counts total number of occurrences of branches of this trunk (= outer sector(s))
      // .second is a vector of pointers to the subgraphs of that trunk.
      std::vector< std::pair<unsigned, std::vector<SubGraph<FilterType>*> >> trunks;
 
      // find those sharing a trunk (trunkTotal) and cluster them in these trunks:
      for (auto& subGraphEntry : m_subgraphs) {
        SubGraph<FilterType>& graph = subGraphEntry.second;
        bool found = false;
        for (auto& trunk : trunks) {
          if (graph.checkSharesTrunk(*(trunk.second.at(0)))) {
            trunk.first += graph.getFound();
            trunk.second.push_back(&graph);
            found = true;
            continue;
          }
 
          if (found) continue;
          // this should really be avoided but it in this case it seems to be on purpose (push_back to container that is iterated)
          // tell cppcheck it is fine..
          // cppcheck-suppress invalidContainerLoop
          trunks.push_back({graph.getFound(), {&graph} });
        }
      }
 
      unsigned long nFoundB4 = nFoundTotal(), nKilled = 0;
      unsigned sizeb4 = size();
      B2DEBUG(20, "pruneGraph - before pruning: graph of size " << sizeb4 << " has " << trunks.size() << " trunks with " << nFoundB4 <<
              " total found.");
 
      // collect subGraphs (=branches) to be deleted:
      std::vector<SubGraph<FilterType>*> deadBranches;
      for (auto& trunk : trunks) {
        double trunkCut = rarenessCut * double(trunk.first);
 
        // sort branches of trunk by rareness (rarest one first):
        std::sort(trunk.second.begin(),
                  trunk.second.end(),
                  [](const SubGraph<FilterType>* a, const SubGraph<FilterType>* b)
                  -> bool { return a->getFound() < b->getFound(); });
 
        // skip trunk, if there are no rare branches.
        auto pos = trunk.second.begin();
        if (double((**pos).getFound()) >= trunkCut) continue;
 
        // collect branches to be killed starting with the smallest one and stop when reaching those which have been slipping above the threshold in the process:
        while (pos != trunk.second.end()) {
          // mark the most rarest entry:
          deadBranches.push_back(*pos);
          trunkCut -= double((**pos).getFound()) * rarenessCut;
 
          // reached the point when all graphs left are now good enough for us: -> stopping loop.
          if (double((**pos).getFound()) >= trunkCut) break;
          ++pos;
        }
      } // looping over trunks
 
      if (deadBranches.empty()) { B2DEBUG(20, "pruneGraph: no rare branches found - stopping pruning process."); return 0; }
 
      // kill selected ones:
      for (auto* graph : deadBranches) {
        nKilled += graph->getFound();
        m_subgraphs.erase(graph->getID());
      }
 
      B2DEBUG(20, "pruneGraph - after pruning graph with size (before/after " << sizeb4 << "/" << size() <<
              ") and nFound (before/after/killed " << nFoundB4 << "/" << nFoundTotal() << "/" << nKilled);
 
      return nKilled;
    }

◆ pruneGraphBeforeTraining()

template<class FilterType>

unsigned pruneGraphBeforeTraining ( int absThreshold )

inline

returns removed occurrences.

Definition at line 207 of file SectorGraph.h.

    {
      if (absThreshold == 0) {return 0;}
 
      int killed = 0;
 
      std::vector<SubGraph<FilterType>*> deadBranches;
 
      for (auto& subGraphEntry : m_subgraphs) {
        SubGraph<FilterType>& graph = subGraphEntry.second;
        if (int(graph.getFound()) <= absThreshold) {
          deadBranches.push_back(&graph);
        }
      }
 
      for (auto& graph : deadBranches) {
        m_subgraphs.erase(graph->getID());
        killed ++;
      }
 
      return killed;
    }

◆ size()

template<class FilterType>

unsigned size ( ) const

inline

returns number of collected subgraphs so far.

Definition at line 55 of file SectorGraph.h.

55{ return m_subgraphs.size(); }

◆ updateSubLayerIDs()

template<class FilterType>

void updateSubLayerIDs ( )

inline

finds sectors having inner sectors in same layer and update them in the subGraph-ID.

Definition at line 245 of file SectorGraph.h.

    {
      unsigned nUpdated = 0, // counts sectors which shall be updated
               nFound = 0, // counts sectors which were found (without double entry removal)
               nGraphsUpdated = 0; // counts graphs which were updated
 
      // collects the secIDs which have got inner sectors on same sensor:
      std::vector<unsigned> idsFound;
      std::string idsPrinted;
 
      // collect all SecIDs where SubLayer has to be updated.
      for (auto& subGraphEntry : m_subgraphs) {
        SubGraphID graphID = subGraphEntry.second.getID();
        std::vector<unsigned> found = graphID.hasSharedLayer();
        if (found.empty()) continue;
        idsFound.insert(idsFound.end(), found.begin(), found.end());
      }
      for (unsigned id : idsFound) { idsPrinted += FullSecID(id).getFullSecString() + " "; }
      B2DEBUG(20, "updateSubLayerIDs: before unique of found ids, following IDs are recorded: \n" << idsPrinted);
      nFound += idsFound.size();
      std::sort(idsFound.begin(), idsFound.end());
      idsFound.erase(std::unique(idsFound.begin(), idsFound.end()), idsFound.end());
      nUpdated += idsFound.size();
 
      idsPrinted = "";
      for (unsigned id : idsFound) { idsPrinted += FullSecID(id).getFullSecString() + " "; }
      B2DEBUG(20, "updateSubLayerIDs: before updating Subgraphs, following IDs have to be updated: \n" << idsPrinted);
 
 
      // update all subGraphIDs where subLayerID has to be increased:
      for (auto& subGraphEntry : m_subgraphs) {
        SubGraph<FilterType>& graph = subGraphEntry.second;
        unsigned nSecsUpdated = graph.idCheckAndUpdate(idsFound);
        if (nSecsUpdated == 0) {
          B2DEBUG(25, "updateSubLayerIDs: was _not_ updated: " << graph.getID().print());
          continue;
        }
        nGraphsUpdated++;
        B2DEBUG(25, "updateSubLayerIDs: was updated " << nSecsUpdated << " times: " << graph.getID().print());
      }
 
      B2DEBUG(20, "updateSubLayerIDs: nSectors found/updated: " << nFound << "/" << nUpdated << ", nSubgraphs updated: " <<
              nGraphsUpdated);
 
      // create new map of Subgraphs with updated LayerIDs
      // subGraph: copy with updated iD.
      // SubGraphID: a.isElementOf(SubGraphID& b) <- checks if given sectorPack ( >= 1 sector) is part of a, ignores subLayerID.
      // SubGraphID: a.replaceElement(SubGraphID& b) <- checks if given sectorPack ( >= 1 sector) is part of a, ignores subLayerID. if yes, replaces element(s). WARNING only works with complete replacement of SubGraphID (entries are const).
      // SubGraphID: a.areTheSameSectors(SubGraphID& b) <- checks if sectors are identical (while ignoring the subLayerID)
      // SubGraphID: a.sharesLayer() <- returns IDs of entries being inner friend of sectors on same layer.
 
      // return new map of Subgraphs.
    }

Member Data Documentation

◆ m_filterIDs

template<class FilterType>

std::vector<FilterType> m_filterIDs

protected

ids of all filterTypes to be stored by subGraphs.

Definition at line 35 of file SectorGraph.h.

◆ m_subgraphs

template<class FilterType>

std::unordered_map<SubGraphID, SubGraph<FilterType> > m_subgraphs

protected

contains all subgraphs.

Definition at line 33 of file SectorGraph.h.

The documentation for this class was generated from the following file:

tracking/trackFindingVXD/sectorMapTools/include/SectorGraph.h

Public Types

Public Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ Iterator

Constructor & Destructor Documentation

◆ SectorGraph()

Member Function Documentation

◆ add()

◆ begin()

◆ end()

◆ find()

◆ getAbsThreshold()

◆ getAllFullSecIDsOfSensor()

◆ getFilterTypes()

◆ nFoundTotal()

◆ output_nfound()

◆ print()

◆ pruneGraph()

◆ pruneGraphBeforeTraining()

◆ size()

◆ updateSubLayerIDs()

Member Data Documentation

◆ m_filterIDs

◆ m_subgraphs