
 // -*- C++ -*-


 namespace KNIK {

 /*! \namespace    KNIK
  *  \brief        The namespace dedicated to Knik.
  *
  *  \section      secUsefulDefines Useful defines
  *
  *
  *  \anchor       KNIK_USECONGESTION
  *  \define       __USE_CONGESTION__
  *  \defineD      if defined, algorithms will use congestion, useful for edge cost
  *  \defineEND
  *
  *  \anchor       KNIK_USESTATIC
  *  \define       __USE_STATIC_PRECONGESTION__
  *  \defineD      if defined, algorithms will use static precongestion which means that precongestion will
  *                be computed but NOT UPDATED
  *  \defineEND
  *  
  *  \anchor       KNIK_USEDYNAMIC
  *  \define       __USE_DYNAMIC_PRECONGESTION__
  *  \defineD      if defined, algorithms will use dynamic precongestion which means taht precongestion,
  *                once computed, will be updated considering the current routing congestion
  *  \defineEND
  *  \note         The 2 last variables are mutually exclusive
  */

 /*! \mainpage     Global Router Documentation
  *
  *                This is the documentation of \c Knik which is a global router for Coriolis platform.
  *
  * \section       secGlobalDesciption Description
  *                This global router is written to be (I hope) a fast and efficient algorithm so it can be use is a refinment loop.
  *                To solve the global routing problem, it uses monotonic routing algorithm (for bi-point nets) and Dijkstra's algorithm.
  *                It also uses an efficient congestion estimation based on Steiner trees generation.
  *
  * \section       secGlobalOverview Overview
  *                Let's have an overview of the general algorithm of \c Knik :
  * \code          
  * Knik::InitGlobalRouting ();
  * // This function prepares everything that the global routing algorithms will need :
  * // - creates the routing graph
  * // - fills the _nets_to_route vector by selecting nets that have to be routed
  *
  * Graph::SetNetStamp (1);
  * // initializes the netStamp of the first net that will be routed on the routingGraph
  * 
  * for each net in Knik::_nets_to_route :
  *     netDegree = Graph::InitRouting ( net );
  *     // this function works on the routingGraph and prepares it for routing a specific net
  *     // - creates each connex component of the net and add a vertex of each connex component to the Graph::_vertexes_to_route vector
  *     // - it returns _vertexes_to_route.size() which is the degree of the net
  *
  *     // the choice of the global routing algorithm is done based on the degree of the net
  *     switch ( netDegree )
  *         // if netDegree is equal to 0 or 1 : there is nothing to be done
  *         case 0:
  *         case 1:
  *             break;
  *         // if netDegree is equal to 2 : the Monotonic routing algorithm will be used
  *         case 2:
  *             Graph::Monotonic ();
  *             break;
  *         // if netDegree is equal to 3 or more : the Dijkstra's algorithm will be used
  *         default:
  *             Graph::Dijkstra ();  
  *             break;
  *
  *     Graph::IncNetStamp ();       // Increments Graph::_netStamp
  *     Graph::CleanRoutingState (); // Cleans the routing graph structure so it can be propoerly reuse with next net
  * \endcode
  *
  */

 }

