SectorGraph< FilterType > Class Template Reference

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 occurances 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 occurances.
int	getAbsThreshold (int relThreshold)
	Get the absolute treshold (# nfound) given a relative threshold.
unsigned	pruneGraphBeforeTraining (int absThreshold)
	returns removed occurances.
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

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()

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

inlineexplicit

constructor expects filterIDs.

Definition at line 39 of file SectorGraph.h.

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

Member Function Documentation

add()

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()

Iterator begin ( )

inline

returns begin of subGraphs.

Definition at line 49 of file SectorGraph.h.

{ return m_subgraphs.begin(); }

end()

Iterator end ( )

inline

returns end of subGraphs.

Definition at line 52 of file SectorGraph.h.

{ return m_subgraphs.end(); }

find()

Iterator find ( SubGraphID  idChain )

inline

find entry.

returns end() if not found.

Definition at line 46 of file SectorGraph.h.

{ return m_subgraphs.find(idChain); }

getAbsThreshold()

int getAbsThreshold ( int  relThreshold )

inline

Get the absolute treshold (# 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()

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()

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.

{ return m_filterIDs; }

nFoundTotal()

unsigned long nFoundTotal ( ) const

inline

returns number of occurances 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()

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()

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()

unsigned pruneGraph ( double  rarenessCut )

inline

returns removed occurances.

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 occurances 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()

unsigned pruneGraphBeforeTraining ( int  absThreshold )

inline

returns removed occurances.

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()

unsigned size ( ) const

inline

returns number of collected subgraphs so far.

Definition at line 55 of file SectorGraph.h.

{ return m_subgraphs.size(); }

updateSubLayerIDs()

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

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

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