RawSecMapMergerModule.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/core/Module.h>
 
#include <tracking/trackFindingVXD/filterMap/filterFramework/Shortcuts.h>
#include <tracking/trackFindingVXD/environment/VXDTFFilters.h>
#include <tracking/dataobjects/SectorMapConfig.h>
#include <tracking/trackFindingVXD/filterMap/map/FiltersContainer.h>
 
#include <tracking/trackFindingVXD/sectorMapTools/BranchInterface.h>
#include <tracking/trackFindingVXD/sectorMapTools/SectorGraph.h>
#include <tracking/trackFindingVXD/sectorMapTools/SubGraph.h>
#include <tracking/spacePointCreation/SpacePoint.h>
 
// stl:
#include <string>
#include <vector>
#include <unordered_map>
#include <utility> // std::pair
#include <memory> // std::unique_ptr
 
#include <TChain.h>
 
namespace Belle2 {
  class RawSecMapMergerModule : public Module {
  protected:
 
    std::vector<std::string> m_PARAMrootFileNames;
 
    std::vector<std::string> m_PARAMmapNames;
 
    bool m_PARAMprintFullGraphs;
 
    int m_RelThreshold;
    // ///////////////////////////////////////////////////////////////////////////////// member variables END:
  public:
 
    RawSecMapMergerModule();
 
 
    ~RawSecMapMergerModule() {}
 
 
    std::vector<std::string> getRootFiles(std::string mapName);
 
 
    std::unique_ptr<TChain> createTreeChain(const SectorMapConfig& configuration, const std::string& nHitString);
 
 
    template<class ValueType> std::vector<BranchInterface<ValueType>> getBranches(
          std::unique_ptr<TChain>& chain,
          const std::vector<std::string>& branchNames);
 
 
    std::string prepareNHitSpecificStuff(
      unsigned nHits,
      const SectorMapConfig& config,
      std::vector<std::string>& secBranchNames,
      std::vector<std::string>& filterBranchNames);
 
 
    std::vector<unsigned> getSecIDs(std::vector<BranchInterface<unsigned>>& secBranches, Long64_t entry)
    {
      std::vector<unsigned> iDs;
      for (BranchInterface<unsigned>& branch : secBranches) {
        branch.update(entry);
        iDs.push_back(branch.value);
      }
      return iDs;
    }
 
 
    template <class FilterType> void trainGraph(
      SectorGraph<FilterType>& mainGraph,
      std::unique_ptr<TChain>& chain,
      std::vector<BranchInterface<unsigned>>& sectorBranches,
      std::vector<BranchInterface<double>>& filterBranches);
 
 
    template <class FilterType> SectorGraph<FilterType> buildGraph(
      std::unique_ptr<TChain>& chain,
      std::vector<BranchInterface<unsigned>>& sectorBranches,
      std::vector<BranchInterface<double>>& filterBranches);
 
 
    void printData(
      std::unique_ptr<TChain>& chain,
      std::vector<BranchInterface<unsigned>>& sectorBranches,
      std::vector<BranchInterface<double>>& filterBranches);
 
 
    void printVXDTFFilters(const VXDTFFilters<SpacePoint>& filters, std::string configName,
                           unsigned int nHitCombinations, bool print2File);
 
 
 
    // TODO: remove
    // std::vector<VxdID> getCompatibleVxdIDs(const SectorMapConfig& config);
 
 
    template <class FilterType> void getSegmentFilters(
      const SectorMapConfig& config,
      SectorGraph<FilterType>& mainGraph,
      VXDTFFilters<SpacePoint>* xHitFilters,
      int nSecChainLength);
 
 
    template <class FilterType> void add2HitFilters(VXDTFFilters<SpacePoint>& filterContainer,
                                                    SubGraph<FilterType>& subGraph, const SectorMapConfig&  config);
 
 
    template <class FilterType> void add3HitFilters(VXDTFFilters<SpacePoint>& filterContainer,
                                                    SubGraph<FilterType>& subGraph, const SectorMapConfig&  config);
 
 
    template <class FilterType> void add4HitFilters(VXDTFFilters<SpacePoint>& filterContainer,
                                                    SubGraph<FilterType>& subGraph, const SectorMapConfig&  config);
 
 
    template <class FilterType> unsigned updateFilterSubLayerIDs(SectorGraph<FilterType>& mainGraph,
        VXDTFFilters<SpacePoint>& segFilters);
 
 
    void processSectorCombinations(const SectorMapConfig& config, VXDTFFilters<SpacePoint>* xHitFilters,
                                   unsigned secChainLength)
    {
      B2INFO("processSectorCombinations: training map " << config.secMapName << " with secChainLength: " << secChainLength);
 
      // branch-names sorted from outer to inner:
      std::vector<std::string> secBranchNames;
      // filter names are different for different secChainLengths:
      std::vector<std::string> filterBranchNames;
      std::string nHit = prepareNHitSpecificStuff(secChainLength, config, secBranchNames, filterBranchNames);
 
      // contains the raw data
      std::unique_ptr<TChain> chain = createTreeChain(config, nHit);
      if (chain->GetEntries() == 0) {
        B2WARNING("raw data for map " << config.secMapName << " with " << nHit << " is empty! skipping");
        return;
      }
 
      // prepare links to branches branches:
      std::vector<BranchInterface<unsigned>> sectorBranches = getBranches<unsigned>(chain, secBranchNames);
      std::vector<BranchInterface<double>> filterBranches = getBranches<double>(chain, filterBranchNames);
 
      // for debugging: print data for crosschecks:
      printData(chain, sectorBranches, filterBranches);
 
      // create graph containing all sector-chains occured in the training sample
      SectorGraph<std::string> mainGraph = buildGraph<std::string>(chain, sectorBranches, filterBranches);
 
      // use rareness-threshold to find sector-combinations which are very rare and remove them:
      unsigned nKilled = mainGraph.pruneGraph(config.rarenessThreshold);
 
      B2INFO("processSectorCombinations: nKilled after graph-pruning: " << nKilled);
 
      // get the raw data and determine the cuts for the filters/selectionVariable
      for (auto& subgraph : mainGraph) {
        subgraph.second.prepareDataCollection(config.quantiles); // TODO small-sample-case!
      }
 
      // Get the absolute threshold (nfound) from the relative threshold
      int absThreshold = mainGraph.getAbsThreshold(m_RelThreshold);
 
      // Prune the sector map
      nKilled += mainGraph.pruneGraphBeforeTraining(absThreshold);
 
      B2INFO("processSectorCombinations: nKilled before the training: " << nKilled);
 
      trainGraph(mainGraph, chain, sectorBranches, filterBranches);
 
      // checks for sectors which have inner neighbour and updates the sublayerID of the sensors.
      // TODO: check if all FullSecIDs are updated and not only those in the corresponding graphs as this may cause problems in a later step
      mainGraph.updateSubLayerIDs();
 
      B2INFO("processSectorCombinations: training finished.\n" << mainGraph.print(m_PARAMprintFullGraphs););
 
      getSegmentFilters(config, mainGraph, xHitFilters, secChainLength);
 
      if (xHitFilters->size() == 0) {
        // thou shall not delete the filters!
        // delete xHitFilters;
        B2FATAL("processSectorCombinations: an empty VXDTFFilters was returned, training data did not work!");
      }
 
      return;
 
    }
 
 
 
    void initialize() override
    {
      FiltersContainer<SpacePoint>& filtersContainer = Belle2::FiltersContainer<SpacePoint>::getInstance();
      B2INFO("RawSecMapMerger::initialize():");
 
      // loop over all the setups in the filtersContainer:
      for (auto& setup : filtersContainer.getAllSetups()) {
 
        // TODO: remove the config from all the following functions as it is contained in the filters!
        auto config = setup.second->getConfig();
        B2INFO("RawSecMapMerger::initialize(): loading mapName: " << config.secMapName);
 
        VXDTFFilters<SpacePoint>* xHitFilters = setup.second;
 
        B2INFO("\n\nRawSecMapMerger::initialize(): for mapName " << config.secMapName << ": process 2-hit-combinations:\n\n");
        processSectorCombinations(config, xHitFilters, 2);
 
        // for debugging:
        printVXDTFFilters(*xHitFilters, config.secMapName, 2, true);
 
 
        // catching case of empty xHitFilters:
        // TODO: check if that causes problems as these are the filters from bootstrapping
        //       this statement is useless as the filters from bootstrapping have already sectors added so the size is !=0
        if (xHitFilters->size() == 0) {
          B2FATAL("This should not happen!");
        }
        B2INFO("\n\nRawSecMapMerger::initialize(): for mapName " << config.secMapName << ": process 3-hit-combinations:\n\n");
        processSectorCombinations(config, xHitFilters, 3);
 
        /* // return; // TODO WARNING DEBUG we do not want to run more than one run yet! */
 
      }
    }
 
    bool good(const std::vector< unsigned>& ids);
  };
 
}