:github_url: https://github.com/svenevs/exhale-companion


.. _program_listing_file_ckpttncpp_HierNetlist.hpp:

Program Listing for File HierNetlist.hpp
========================================

|exhale_lsh| :ref:`Return to documentation for file <file_ckpttncpp_HierNetlist.hpp>` (``ckpttncpp/HierNetlist.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   // import networkx as nx
   // #include <algorithm>
   // #include <gsl/span>
   // #include <iterator>
   // #include <py2cpp/py2cpp.hpp>
   // #include <utility>
   // #include <vector>
   // #include <xnetwork/classes/graph.hpp>
   #include "netlist.hpp"
   #include "array_like.hpp"
   
   // using node_t = int;
   
   // struct PartInfo
   // {
   //     std::vector<std::uint8_t> part;
   //     py::set<node_t> extern_nets;
   // };
   
   template <typename graph_t>
   class HierNetlist : public Netlist<graph_t>
   {
     public:
       using nodeview_t = typename graph_t::nodeview_t;
       using node_t = typename graph_t::node_t;
       using index_t = typename nodeview_t::key_type;
   
       /* For multi-level algorithms */
       const Netlist<graph_t>* parent;
       std::vector<node_t> node_up_map;
       std::vector<node_t> node_down_map;
       py::dict<index_t, node_t> cluster_down_map;
       shift_array<std::vector<int>> net_weight{};
   
   
       HierNetlist(graph_t G, const nodeview_t& modules, const nodeview_t& nets);
   
       // HierNetlist(graph_t G, uint32_t numModules, uint32_t numNets);
   
       void projection_down(gsl::span<const std::uint8_t> part,
           gsl::span<std::uint8_t> part_down) const;
   
       void projection_up(gsl::span<const std::uint8_t> part,
           gsl::span<std::uint8_t> part_up) const;
   
       auto get_net_weight(const node_t& net) const -> int
       {
           return this->net_weight.empty() ? 1
                                           :
                                           this->net_weight[net];
       }
   };
   
   template <typename graph_t>
   HierNetlist<graph_t>::HierNetlist(
       graph_t G, const nodeview_t& modules, const nodeview_t& nets)
       : Netlist<graph_t> {std::move(G), modules, nets}
   {
   }
   
   // template <typename graph_t>
   // HierNetlist<graph_t>::HierNetlist(graph_t G, uint32_t numModules, uint32_t numNets)
   //     : Netlist<graph_t> {std::move(G), py::range<uint32_t>(numModules),
   //           py::range<uint32_t>(numModules, numModules + numNets)}
   // {
   // }
   
   using SimpleHierNetlist = HierNetlist<xn::SimpleGraph>;