#!/usr/bin/env python3
""" Classify 7-series nodes and generate channels for required nodes.

Rough structure:

Create initial database import by importing tile types, tile wires, tile pips,
site types and site pins.  After importing tile types, imports the grid of
tiles.  This uses tilegrid.json, tile_type_*.json and site_type_*.json.

Once all tiles are imported, all wires in the grid are added and nodes are
formed from the sea of wires based on the tile connections description
(tileconn.json).

In order to determine what each node is used for, site pins and pips are counted
on each node (count_sites_and_pips_on_nodes).  Depending on the site pin and
pip count, the nodes are classified into one of 4 buckets:

    NULL - An unconnected node
    CHANNEL - A routing node
    EDGE_WITH_MUX - An edge between an IPIN and OPIN.
    EDGES_TO_CHANNEL - An edge between an IPIN/OPIN and a CHANNEL.

Then all CHANNEL are grouped into tracks (form_tracks) and graph nodes are
created for the CHANNELs.  Graph edges are added to connect graph nodes that are
part of the same track.

Note that IPIN and OPIN graph nodes are not added yet, as pins have not been
assigned sides of the VPR tiles yet.  This occurs in
prjxray_assign_tile_pin_direction.


"""
import argparse
import csv
import prjxray.db
import prjxray.tile
from prjxray.timing import PvtCorner
from lib import progressbar_utils
import tile_splitter.grid
from lib.rr_graph import points
from lib.rr_graph import tracks
from lib.rr_graph import graph2
import datetime
import os
import os.path
from lib.connection_database import NodeClassification, create_tables, node_to_site_pins

from prjxray_db_cache import DatabaseCache
from prjxray_define_segments import SegmentWireMap

SINGLE_PRECISION_FLOAT_MIN = 2**-126
VCC_NET = 'VCC_NET'
GND_NET = 'GND_NET'


def import_site_type(db, write_cur, site_types, site_type_name):
    assert site_type_name not in site_types
    site_type = db.get_site_type(site_type_name)

    if site_type_name in site_types:
        return

    write_cur.execute(
        "INSERT INTO site_type(name) VALUES (?)", (site_type_name, )
    )
    site_types[site_type_name] = write_cur.lastrowid

    for site_pin in site_type.get_site_pins():
        pin_info = site_type.get_site_pin(site_pin)

        write_cur.execute(
            """
INSERT INTO site_pin(name, site_type_pkey, direction)
VALUES
  (?, ?, ?)""", (
                pin_info.name, site_types[site_type_name],
                pin_info.direction.value
            )
        )


def create_get_switch(conn):
    """ Returns functions to get or create switches with various timing.

    Every switch that requires different timing is given it's own switch
    in VPR.  get_switch returns a switch a pip.  get_switch_timing returns
    a switch given a particular timing.

    """
    write_cur = conn.cursor()

    pip_cache = {}

    write_cur.execute(
        "SELECT pkey FROM switch WHERE name = ?",
        ("__vpr_delayless_switch__", )
    )
    pip_cache[(False, 0.0, 0.0, 0.0)] = write_cur.fetchone()[0]

    def get_switch_timing(
            is_pass_transistor, delay, internal_capacitance, drive_resistance
    ):
        """ Return a switch that matches provided timing.

        Arguments
        ---------
        is_pass_transistor : bool-like
            If true, this switch should be represented as a "pass_gate".

        delay : float or convertable to float
            Intrinsic delay through switch (seconds)

        internal_capacitance : float or convertable to float
            Internal capacitance to switch (Farads).

        drive_resistance : float or convertable to float
            Drive resistance from switch (Ohms).

        Returns
        -------
        switch_pkey : int
            Switch primary key that represents provided arguments.

        """
        key = (
            bool(is_pass_transistor), float(delay), float(drive_resistance),
            float(internal_capacitance)
        )

        if key not in pip_cache:
            name = 'routing'
            switch_type = 'mux'
            if is_pass_transistor:
                name = 'pass_transistor'
                switch_type = 'pass_gate'

            name = '{}_R{}_C{}_Tdel{}'.format(
                name, drive_resistance, internal_capacitance, delay
            )

            write_cur.execute(
                """
INSERT INTO
    switch(
        name, internal_capacitance, drive_resistance, intrinsic_delay, switch_type
    )
VALUES
    (?, ?, ?, ?, ?)""", (
                    name, internal_capacitance, drive_resistance, delay,
                    switch_type
                )
            )
            pip_cache[key] = write_cur.lastrowid

            write_cur.connection.commit()

        return pip_cache[key]

    def get_switch(pip, pip_timing):
        """ Return switch_pkey for given pip timing.

        Arguments
        ---------
        pip : tile.Pip object
            Pip being modelled
        pip_timing : tile.PipTiming object
            Pip timing being modelled

        Returns
        -------
        switch_pkey : int
            Switch primary key that represents provided arguments.

        """
        delay = 0.0
        drive_resistance = 0.0
        internal_capacitance = 0.0

        if pip_timing is not None:
            if pip_timing.delays is not None:
                # Use the largest intristic delay for now.
                # This conservative on slack timing, but not on hold timing.
                #
                # nanosecond -> seconds
                delay = pip_timing.delays[PvtCorner.SLOW].max / 1e9

            if pip_timing.internal_capacitance is not None:
                # microFarads -> Farads
                internal_capacitance = pip_timing.internal_capacitance / 1e6

            if pip_timing.drive_resistance is not None:
                # milliOhms -> Ohms
                drive_resistance = pip_timing.drive_resistance / 1e3

        return get_switch_timing(
            pip.is_pass_transistor, delay, internal_capacitance,
            drive_resistance
        )

    return get_switch, get_switch_timing


def build_pss_object_mask(db, tile_type_name):
    """
    Looks for objects present in PSS* tiles of Zynq7 and masks out those
    that are purely PS related and not configued by the PL.
    """

    tile_type = db.get_tile_type(tile_type_name)
    sites = tile_type.get_sites()

    masked_wires = []
    masked_pips = []

    # Get all IOPADS for MIO and DDR signals
    iopad_sites = [s for s in sites if s.type == "IOPAD"]
    for site in iopad_sites:

        # Get pins/wires
        site_pins = [p for p in site.site_pins if p.name == "IO"]
        for site_pin in site_pins:

            # Mask the wire
            masked_wires.append(site_pin.wire)

            # Find a PIP(s) for this wire, mask them as well as wires on
            # their other sides.
            for p in tile_type.get_pips():
                if p.net_from == site_pin.wire:
                    masked_pips.append(p.name)
                    masked_wires.append(p.net_to)
                if p.net_to == site_pin.wire:
                    masked_pips.append(p.name)
                    masked_wires.append(p.net_from)

    # Masked sites names
    masked_sites = [(s.prefix, s.name) for s in iopad_sites]

    return masked_sites, masked_wires, masked_pips


def import_tile_type(
        db, write_cur, tile_types, site_types, tile_type_name, get_switch
):
    assert tile_type_name not in tile_types
    tile_type = db.get_tile_type(tile_type_name)

    # For Zynq7 PSS* tiles build a list of sites, wires and PIPs to ignore
    if tile_type_name.startswith("PSS"):
        masked_sites, masked_wires, masked_pips = build_pss_object_mask(
            db, tile_type_name
        )

    else:
        masked_sites = []
        masked_wires = []
        masked_pips = []

    write_cur.execute(
        "INSERT INTO tile_type(name) VALUES (?)", (tile_type_name, )
    )
    tile_types[tile_type_name] = write_cur.lastrowid

    wires = {}
    for wire, wire_rc_element in tile_type.get_wires().items():
        if wire in masked_wires:
            continue

        capacitance = 0.0
        resistance = 0.0

        if wire_rc_element is not None:
            # microFarads -> Farads
            capacitance = wire_rc_element.capacitance / 1e6

            # milliOhms -> Ohms
            resistance = wire_rc_element.resistance / 1e3

        write_cur.execute(
            """
INSERT INTO wire_in_tile(name, phy_tile_type_pkey, tile_type_pkey, capacitance, resistance)
VALUES
  (?, ?, ?, ?, ?)""", (
                wire, tile_types[tile_type_name], tile_types[tile_type_name],
                capacitance, resistance
            )
        )
        wires[wire] = write_cur.lastrowid

    for pip in tile_type.get_pips():
        if pip.name in masked_pips:
            continue

        switch_pkey = get_switch(pip, pip.timing)
        backward_switch_pkey = get_switch(pip, pip.backward_timing)

        write_cur.execute(
            """
INSERT INTO pip_in_tile(
  name, tile_type_pkey, src_wire_in_tile_pkey,
  dest_wire_in_tile_pkey, can_invert, is_directional, is_pseudo,
  is_pass_transistor, switch_pkey, backward_switch_pkey
)
VALUES
  (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""", (
                pip.name, tile_types[tile_type_name], wires[pip.net_from],
                wires[pip.net_to
                      ], pip.can_invert, pip.is_directional, pip.is_pseudo,
                pip.is_pass_transistor, switch_pkey, backward_switch_pkey
            )
        )
        pip_pkey = write_cur.lastrowid

        write_cur.execute(
            """
INSERT INTO undirected_pips(
    wire_in_tile_pkey, pip_in_tile_pkey, other_wire_in_tile_pkey)
VALUES
    (?, ?, ?), (?, ?, ?);""", (
                wires[pip.net_from],
                pip_pkey,
                wires[pip.net_to],
                wires[pip.net_to],
                pip_pkey,
                wires[pip.net_from],
            )
        )

    for site in tile_type.get_sites():
        if (site.prefix, site.name) in masked_sites:
            continue

        if site.type not in site_types:
            import_site_type(db, write_cur, site_types, site.type)


def add_wire_to_site_relation(
        db, write_cur, tile_types, site_types, tile_type_name,
        get_switch_timing
):
    tile_type = db.get_tile_type(tile_type_name)
    for site in tile_type.get_sites():

        if site.type not in site_types:
            continue

        write_cur.execute(
            """
INSERT INTO site(name, x_coord, y_coord, site_type_pkey, tile_type_pkey)
VALUES
  (?, ?, ?, ?, ?)""", (
                site.name, site.x, site.y, site_types[site.type],
                tile_types[tile_type_name]
            )
        )

        site_pkey = write_cur.lastrowid

        for site_pin in site.site_pins:
            write_cur.execute(
                """
SELECT
  pkey
FROM
  site_pin
WHERE
  name = ?
  AND site_type_pkey = ?""", (site_pin.name, site_types[site.type])
            )
            result = write_cur.fetchone()
            site_pin_pkey = result[0]

            intrinsic_delay = 0
            drive_resistance = 0
            capacitance = 0

            if site_pin.timing is not None:
                # Use the largest intristic delay for now.
                # This conservative on slack timing, but not on hold timing.
                #
                # nanosecond -> seconds
                intrinsic_delay = site_pin.timing.delays[PvtCorner.SLOW
                                                         ].max / 1e9

                if isinstance(site_pin.timing, prjxray.tile.OutPinTiming):
                    # milliOhms -> Ohms
                    drive_resistance = site_pin.timing.drive_resistance / 1e3
                elif isinstance(site_pin.timing, prjxray.tile.InPinTiming):
                    # microFarads -> Farads
                    capacitance = site_pin.timing.capacitance / 1e6
                else:
                    assert False, site_pin
            else:
                # Use min value instead of 0 to prevent
                # VPR from freaking out over a zero net delay.
                #
                # Note this is the single precision float minimum, because VPR
                # uses single precision, not double precision.
                intrinsic_delay = SINGLE_PRECISION_FLOAT_MIN

            site_pin_switch_pkey = get_switch_timing(
                is_pass_transistor=False,
                delay=intrinsic_delay,
                internal_capacitance=capacitance,
                drive_resistance=drive_resistance,
            )

            write_cur.execute(
                """
UPDATE
  wire_in_tile
SET
  site_pkey = ?,
  site_pin_pkey = ?,
  site_pin_switch_pkey = ?
WHERE
  name = ?
  and tile_type_pkey = ?;""", (
                    site_pkey, site_pin_pkey, site_pin_switch_pkey,
                    site_pin.wire, tile_types[tile_type_name]
                )
            )


def build_tile_type_indicies(write_cur):
    write_cur.execute(
        "CREATE INDEX site_pin_index ON site_pin(name, site_type_pkey);"
    )
    write_cur.execute(
        "CREATE INDEX wire_name_index ON wire_in_tile(name, tile_type_pkey);"
    )
    write_cur.execute(
        "CREATE INDEX wire_tile_site_index ON wire_in_tile(tile_type_pkey, site_pkey);"
    )
    write_cur.execute(
        "CREATE INDEX wire_site_pin_index ON wire_in_tile(site_pin_pkey);"
    )
    write_cur.execute(
        "CREATE INDEX tile_type_index ON phy_tile(tile_type_pkey);"
    )
    write_cur.execute(
        "CREATE INDEX pip_tile_type_index ON pip_in_tile(tile_type_pkey);"
    )
    write_cur.execute(
        "CREATE INDEX src_pip_index ON pip_in_tile(src_wire_in_tile_pkey);"
    )
    write_cur.execute(
        "CREATE INDEX dest_pip_index ON pip_in_tile(dest_wire_in_tile_pkey);"
    )
    write_cur.execute(
        """CREATE INDEX undirected_pip_index ON
undirected_pips(wire_in_tile_pkey, other_wire_in_tile_pkey);"""
    )


def build_other_indicies(write_cur):
    write_cur.execute("CREATE INDEX phy_tile_name_index ON phy_tile(name);")
    write_cur.execute(
        "CREATE INDEX phy_tile_location_index ON phy_tile(grid_x, grid_y);"
    )
    write_cur.execute(
        "CREATE INDEX site_instance_index on site_instance(name);"
    )


def import_phy_grid(db, grid, conn, get_switch, get_switch_timing):
    write_cur = conn.cursor()

    tile_types = {}
    site_types = {}

    for tile in grid.tiles():
        gridinfo = grid.gridinfo_at_tilename(tile)

        if gridinfo.tile_type not in tile_types:
            if gridinfo.tile_type in tile_types:
                continue

            import_tile_type(
                db, write_cur, tile_types, site_types, gridinfo.tile_type,
                get_switch
            )

    write_cur.connection.commit()

    build_tile_type_indicies(write_cur)
    write_cur.connection.commit()

    for tile_type in tile_types:
        add_wire_to_site_relation(
            db, write_cur, tile_types, site_types, tile_type, get_switch_timing
        )

    clock_regions = {}

    for tile in grid.tiles():
        gridinfo = grid.gridinfo_at_tilename(tile)

        clock_region_pkey = None
        if gridinfo.clock_region is not None:
            if gridinfo.clock_region.name not in clock_regions:
                write_cur.execute(
                    """
INSERT INTO clock_region(name, x_coord, y_coord)
VALUES (?, ?, ?)""", (
                        gridinfo.clock_region.name,
                        gridinfo.clock_region.x,
                        gridinfo.clock_region.y,
                    )
                )
                clock_regions[gridinfo.clock_region.name] = write_cur.lastrowid

            clock_region_pkey = clock_regions[gridinfo.clock_region.name]

        loc = grid.loc_of_tilename(tile)
        # tile: pkey name tile_type_pkey grid_x grid_y
        write_cur.execute(
            """
INSERT INTO phy_tile(name, tile_type_pkey, grid_x, grid_y, clock_region_pkey)
VALUES
  (?, ?, ?, ?, ?)""", (
                tile,
                tile_types[gridinfo.tile_type],
                loc.grid_x,
                loc.grid_y,
                clock_region_pkey,
            )
        )
        phy_tile_pkey = write_cur.lastrowid

        tile_type = db.get_tile_type(gridinfo.tile_type)
        for site, instance_site in zip(tile_type.sites,
                                       tile_type.get_instance_sites(gridinfo)):
            write_cur.execute(
                """
INSERT INTO site_instance(name, x_coord, y_coord, site_pkey, phy_tile_pkey)
SELECT ?, ?, ?, site.pkey, ?
FROM site
WHERE
    site.name = ?
AND
    site.x_coord = ?
AND
    site.y_coord = ?
AND
    site.site_type_pkey = (SELECT pkey FROM site_type WHERE name = ?)
AND
    tile_type_pkey = ?;
                """, (
                    instance_site.name,
                    instance_site.x,
                    instance_site.y,
                    phy_tile_pkey,
                    site.name,
                    site.x,
                    site.y,
                    site.type,
                    tile_types[gridinfo.tile_type],
                )
            )

            site_instance_pkey = write_cur.lastrowid

            write_cur.execute(
                "UPDATE site_instance SET prohibited = ? WHERE pkey = ?", (
                    instance_site.name in gridinfo.prohibited_sites,
                    site_instance_pkey,
                )
            )

    build_other_indicies(write_cur)
    write_cur.connection.commit()


def import_nodes(db, grid, conn):
    # Some nodes are just 1 wire, so start by enumerating all wires.

    cur = conn.cursor()
    write_cur = conn.cursor()
    write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")

    tile_wire_map = {}
    wires = {}
    for tile in progressbar_utils.progressbar(grid.tiles()):
        gridinfo = grid.gridinfo_at_tilename(tile)
        tile_type = db.get_tile_type(gridinfo.tile_type)

        cur.execute(
            """SELECT pkey, tile_type_pkey FROM phy_tile WHERE name = ?;""",
            (tile, )
        )
        phy_tile_pkey, tile_type_pkey = cur.fetchone()

        for wire in tile_type.get_wires():
            # pkey node_pkey tile_pkey wire_in_tile_pkey
            cur.execute(
                """
SELECT pkey FROM wire_in_tile WHERE name = ? and tile_type_pkey = ?;""",
                (wire, tile_type_pkey)
            )

            wire_in_tile_pkey = cur.fetchone()
            if wire_in_tile_pkey is None:
                continue
            wire_in_tile_pkey = wire_in_tile_pkey[0]

            write_cur.execute(
                """
INSERT INTO wire(phy_tile_pkey, wire_in_tile_pkey)
VALUES
  (?, ?);""", (phy_tile_pkey, wire_in_tile_pkey)
            )

            assert (tile, wire) not in tile_wire_map
            wire_pkey = write_cur.lastrowid
            tile_wire_map[(tile, wire)] = wire_pkey
            wires[wire_pkey] = None

    write_cur.execute("""COMMIT TRANSACTION;""")

    connections = db.connections()

    for connection in progressbar_utils.progressbar(
            connections.get_connections()):
        a_pkey = tile_wire_map[
            (connection.wire_a.tile, connection.wire_a.wire)]
        b_pkey = tile_wire_map[
            (connection.wire_b.tile, connection.wire_b.wire)]

        a_node = wires[a_pkey]
        b_node = wires[b_pkey]

        if a_node is None:
            a_node = set((a_pkey, ))

        if b_node is None:
            b_node = set((b_pkey, ))

        if a_node is not b_node:
            a_node |= b_node

            for wire in a_node:
                wires[wire] = a_node

    nodes = {}
    for wire_pkey, node in wires.items():
        if node is None:
            node = set((wire_pkey, ))

        assert wire_pkey in node

        nodes[id(node)] = node

    wires_assigned = set()
    for node in progressbar_utils.progressbar(nodes.values()):
        write_cur.execute("""INSERT INTO node(number_pips) VALUES (0);""")
        node_pkey = write_cur.lastrowid

        for wire_pkey in node:
            wires_assigned.add(wire_pkey)
            write_cur.execute(
                """
            UPDATE wire
                SET node_pkey = ?
                WHERE pkey = ?
            ;""", (node_pkey, wire_pkey)
            )

    assert len(set(wires.keys()) ^ wires_assigned) == 0

    del tile_wire_map
    del nodes
    del wires

    write_cur.execute(
        "CREATE INDEX wire_in_tile_index ON wire(wire_in_tile_pkey);"
    )
    write_cur.execute(
        "CREATE INDEX wire_index ON wire(phy_tile_pkey, wire_in_tile_pkey);"
    )
    write_cur.execute("CREATE INDEX wire_node_index ON wire(node_pkey);")

    write_cur.connection.commit()


def count_sites_and_pips_on_nodes(conn):
    cur = conn.cursor()

    print("{}: Counting sites on nodes".format(datetime.datetime.now()))
    cur.execute(
        """
WITH node_sites(node_pkey, number_site_pins) AS (
  SELECT
    wire.node_pkey,
    count(wire_in_tile.site_pin_pkey)
  FROM
    wire_in_tile
    INNER JOIN wire ON wire.wire_in_tile_pkey = wire_in_tile.pkey
  WHERE
    wire_in_tile.site_pin_pkey IS NOT NULL
  GROUP BY
    wire.node_pkey
)
SELECT
  max(node_sites.number_site_pins)
FROM
  node_sites;
"""
    )

    # Nodes are only expected to have 1 site
    assert cur.fetchone()[0] == 1

    print("{}: Assigning site wires for nodes".format(datetime.datetime.now()))
    cur.execute(
        """
WITH site_wires(wire_pkey, node_pkey) AS (
  SELECT
    wire.pkey,
    wire.node_pkey
  FROM
    wire_in_tile
    INNER JOIN wire ON wire.wire_in_tile_pkey = wire_in_tile.pkey
  WHERE
    wire_in_tile.site_pin_pkey IS NOT NULL
)
UPDATE
  node
SET
  site_wire_pkey = (
    SELECT
      site_wires.wire_pkey
    FROM
      site_wires
    WHERE
      site_wires.node_pkey = node.pkey
  );
      """
    )

    print("{}: Counting pips on nodes".format(datetime.datetime.now()))
    cur.execute(
        """
    CREATE TABLE node_pip_count(
      node_pkey INT,
      number_pips INT,
      FOREIGN KEY(node_pkey) REFERENCES node(pkey)
    );"""
    )
    cur.execute(
        """
INSERT INTO node_pip_count(node_pkey, number_pips)
SELECT
  wire.node_pkey,
  count(pip_in_tile.pkey)
FROM
  pip_in_tile
  INNER JOIN wire
WHERE
  pip_in_tile.is_pseudo = 0 AND (
  pip_in_tile.src_wire_in_tile_pkey = wire.wire_in_tile_pkey
  OR pip_in_tile.dest_wire_in_tile_pkey = wire.wire_in_tile_pkey)
GROUP BY
  wire.node_pkey;"""
    )
    cur.execute("CREATE INDEX pip_count_index ON node_pip_count(node_pkey);")

    print("{}: Inserting pip counts".format(datetime.datetime.now()))
    cur.execute(
        """
UPDATE
  node
SET
  number_pips = (
    SELECT
      node_pip_count.number_pips
    FROM
      node_pip_count
    WHERE
      node_pip_count.node_pkey = node.pkey
  )
WHERE
  pkey IN (
    SELECT
      node_pkey
    FROM
      node_pip_count
  );"""
    )

    cur.execute("""DROP TABLE node_pip_count;""")

    cur.connection.commit()


def check_edge_with_mux_timing(
        conn, get_switch_timing, src_wire_pkey, dest_wire_pkey, pip_pkey
):
    """ Check if edge with mux timing can be "lumped" into the switch.

    Returns
    -------
    switch_pkey : int
        Switch primary key to model EDGE_WITH_MUX connection.

    """

    cur = conn.cursor()

    cur.execute(
        """
SELECT site_pin_switch_pkey, resistance, capacitance FROM wire_in_tile WHERE pkey = (
    SELECT wire_in_tile_pkey FROM wire WHERE pkey = ?
    )""", (src_wire_pkey, )
    )

    src_site_pin_switch_pkey, src_wire_resistance, src_wire_capacitance = cur.fetchone(
    )

    assert src_wire_resistance == 0, src_wire_pkey

    cur.execute(
        """
SELECT intrinsic_delay, drive_resistance FROM switch WHERE pkey = ?
        """, (src_site_pin_switch_pkey, )
    )
    src_site_pin_intrinsic_delay, src_site_pin_drive_resistance = cur.fetchone(
    )

    cur.execute(
        """
SELECT site_pin_switch_pkey, resistance, capacitance FROM wire_in_tile WHERE pkey = (
    SELECT wire_in_tile_pkey FROM wire WHERE pkey = ?
    )""", (dest_wire_pkey, )
    )

    dest_site_pin_switch_pkey, dest_wire_resistance, dest_wire_capacitance = cur.fetchone(
    )

    assert dest_wire_resistance == 0, dest_wire_pkey

    cur.execute(
        """
SELECT intrinsic_delay, internal_capacitance FROM switch WHERE pkey = ?
        """, (dest_site_pin_switch_pkey, )
    )
    dest_site_pin_intrinsic_delay, dest_site_pin_capacitance = cur.fetchone()

    cur.execute(
        """
SELECT name, switch_pkey FROM pip_in_tile WHERE pkey = ?""", (pip_pkey, )
    )
    pip_name, switch_pkey = cur.fetchone()

    cur.execute(
        """
SELECT
    name, intrinsic_delay, internal_capacitance, drive_resistance, switch_type
FROM switch WHERE pkey = ?
        """, (switch_pkey, )
    )
    (
        switch_name, switch_intrinsic_delay, switch_internal_capacitance,
        switch_drive_resistance, switch_type
    ) = cur.fetchone()

    assert switch_type in ["mux", "pass_gate"], (switch_pkey, switch_type)

    zero_delay_to_switch = src_site_pin_drive_resistance == 0 or (
        switch_internal_capacitance == 0 and src_wire_capacitance == 0
    )
    zero_delay_from_switch = switch_drive_resistance == 0 or (
        dest_wire_capacitance == 0 and dest_site_pin_capacitance == 0
    )

    if zero_delay_to_switch and zero_delay_from_switch and \
            src_site_pin_intrinsic_delay == 0 and \
            dest_site_pin_intrinsic_delay == 0:
        return get_switch_timing(
            is_pass_transistor=False,
            delay=switch_intrinsic_delay,
            internal_capacitance=0,
            drive_resistance=0,
        )

    if switch_type == "mux":
        switch_delay = src_site_pin_intrinsic_delay
        switch_delay += src_site_pin_drive_resistance * (
            switch_internal_capacitance + src_wire_capacitance
        )
        switch_delay += switch_intrinsic_delay
        switch_delay += switch_drive_resistance * (
            dest_wire_capacitance + dest_site_pin_capacitance
        )
        switch_delay += dest_site_pin_intrinsic_delay
    else:
        assert switch_type == "pass_gate"
        assert switch_intrinsic_delay == 0
        assert switch_drive_resistance == 0

        switch_delay = src_site_pin_intrinsic_delay
        switch_delay += src_site_pin_drive_resistance * (
            src_wire_capacitance + switch_internal_capacitance +
            dest_wire_capacitance + dest_site_pin_capacitance
        )
        switch_delay += dest_site_pin_intrinsic_delay

    return get_switch_timing(
        is_pass_transistor=False,
        delay=switch_delay,
        internal_capacitance=0,
        drive_resistance=0
    )


def classify_nodes(conn, get_switch_timing):
    write_cur = conn.cursor()

    # Nodes are NULL if they they only have either a site pin or 1 pip, but
    # nothing else.
    write_cur.execute(
        """
UPDATE node SET classification = ?
    WHERE (node.site_wire_pkey IS NULL AND node.number_pips <= 1) OR
          (node.site_wire_pkey IS NOT NULL AND node.number_pips == 0)
    ;""", (NodeClassification.NULL.value, )
    )
    write_cur.execute(
        """
UPDATE node SET classification = ?
    WHERE node.number_pips > 1 and node.site_wire_pkey IS NULL;""",
        (NodeClassification.CHANNEL.value, )
    )
    write_cur.execute(
        """
UPDATE node SET classification = ?
    WHERE node.number_pips > 1 and node.site_wire_pkey IS NOT NULL;""",
        (NodeClassification.EDGES_TO_CHANNEL.value, )
    )

    null_nodes = []
    edges_to_channel = []
    edge_with_mux = []

    cur = conn.cursor()
    cur.execute(
        """
SELECT
  count(pkey)
FROM
  node
WHERE
  number_pips == 1
  AND site_wire_pkey IS NOT NULL;"""
    )
    num_nodes = cur.fetchone()[0]
    with progressbar_utils.ProgressBar(max_value=num_nodes) as bar:
        bar.update(0)
        for idx, (node, site_wire_pkey) in enumerate(cur.execute("""
SELECT
  pkey,
  site_wire_pkey
FROM
  node
WHERE
  number_pips == 1
  AND site_wire_pkey IS NOT NULL;""")):
            bar.update(idx)

            write_cur.execute(
                """
WITH wire_in_node(
  wire_pkey, phy_tile_pkey, wire_in_tile_pkey
) AS (
  SELECT
    wire.pkey,
    wire.phy_tile_pkey,
    wire.wire_in_tile_pkey
  FROM
    wire
  WHERE
    wire.node_pkey = ?
)
SELECT
  pip_in_tile.pkey,
  pip_in_tile.src_wire_in_tile_pkey,
  pip_in_tile.dest_wire_in_tile_pkey,
  wire_in_node.wire_pkey,
  wire_in_node.wire_in_tile_pkey,
  wire_in_node.phy_tile_pkey
FROM
  wire_in_node
  INNER JOIN pip_in_tile
WHERE
  pip_in_tile.is_pseudo = 0 AND (
  pip_in_tile.src_wire_in_tile_pkey = wire_in_node.wire_in_tile_pkey
  OR pip_in_tile.dest_wire_in_tile_pkey = wire_in_node.wire_in_tile_pkey)
LIMIT
  1;
""", (node, )
            )

            (
                pip_pkey, src_wire_in_tile_pkey, dest_wire_in_tile_pkey,
                wire_in_node_pkey, wire_in_tile_pkey, phy_tile_pkey
            ) = write_cur.fetchone()
            assert write_cur.fetchone() is None, node

            assert (
                wire_in_tile_pkey == src_wire_in_tile_pkey
                or wire_in_tile_pkey == dest_wire_in_tile_pkey
            ), (wire_in_tile_pkey, pip_pkey)

            if src_wire_in_tile_pkey == wire_in_tile_pkey:
                other_wire = dest_wire_in_tile_pkey
            else:
                other_wire = src_wire_in_tile_pkey

            write_cur.execute(
                """
            SELECT node_pkey FROM wire WHERE
                wire_in_tile_pkey = ? AND
                phy_tile_pkey = ?;
                """, (other_wire, phy_tile_pkey)
            )

            (other_node_pkey, ) = write_cur.fetchone()
            assert write_cur.fetchone() is None
            assert other_node_pkey is not None, (other_wire, phy_tile_pkey)

            write_cur.execute(
                """
            SELECT site_wire_pkey, number_pips
                FROM node WHERE pkey = ?;
                """, (other_node_pkey, )
            )

            result = write_cur.fetchone()
            assert result is not None, other_node_pkey
            other_site_wire_pkey, other_number_pips = result
            assert write_cur.fetchone() is None

            force_direct = False

            write_cur.execute(
                """
            SELECT name
                FROM pip_in_tile WHERE pkey = ?;
                """, (pip_pkey, )
            )
            pip_name = write_cur.fetchone()[0]

            # A solution for:
            # https://github.com/SymbiFlow/f4pga-arch-defs/issues/1033
            if "PADOUT0" in pip_name and "DIFFI_IN1" in pip_name:
                force_direct = True
            if "PADOUT1" in pip_name and "DIFFI_IN0" in pip_name:
                force_direct = True

            if other_site_wire_pkey is not None and (other_number_pips == 1
                                                     or force_direct):
                if src_wire_in_tile_pkey == wire_in_tile_pkey:
                    src_wire_pkey = site_wire_pkey
                    dest_wire_pkey = other_site_wire_pkey
                else:
                    src_wire_pkey = other_site_wire_pkey
                    dest_wire_pkey = site_wire_pkey

                edge_with_mux.append(
                    (
                        (node, other_node_pkey), src_wire_pkey, dest_wire_pkey,
                        pip_pkey
                    )
                )
            elif other_site_wire_pkey is None and other_number_pips == 1:
                null_nodes.append(node)
                null_nodes.append(other_node_pkey)
                pass
            else:
                edges_to_channel.append(node)

    for nodes, src_wire_pkey, dest_wire_pkey, pip_pkey in progressbar_utils.progressbar(
            edge_with_mux):
        assert len(nodes) == 2

        switch_pkey = check_edge_with_mux_timing(
            conn, get_switch_timing, src_wire_pkey, dest_wire_pkey, pip_pkey
        )
        write_cur.execute(
            """
        UPDATE node SET classification = ?
            WHERE pkey IN (?, ?);""",
            (NodeClassification.EDGE_WITH_MUX.value, nodes[0], nodes[1])
        )

        write_cur.execute(
            """
INSERT INTO edge_with_mux(src_wire_pkey, dest_wire_pkey, pip_in_tile_pkey, switch_pkey)
VALUES
  (?, ?, ?, ?);""", (src_wire_pkey, dest_wire_pkey, pip_pkey, switch_pkey)
        )

    for node in progressbar_utils.progressbar(edges_to_channel):
        write_cur.execute(
            """
        UPDATE node SET classification = ?
            WHERE pkey = ?;""", (
                NodeClassification.EDGES_TO_CHANNEL.value,
                node,
            )
        )

    for null_node in progressbar_utils.progressbar(null_nodes):
        write_cur.execute(
            """
        UPDATE node SET classification = ?
            WHERE pkey = ?;""", (
                NodeClassification.NULL.value,
                null_node,
            )
        )

    write_cur.execute("CREATE INDEX node_type_index ON node(classification);")
    write_cur.execute(
        """
    CREATE INDEX edge_with_mux_index ON edge_with_mux(
        src_wire_pkey,
        dest_wire_pkey,
        pip_in_tile_pkey,
        switch_pkey);"""
    )
    write_cur.connection.commit()


def get_node_rc(conn, node_pkey):
    """ Returns capacitance and resistance for given node.

    Returns
    -------
    capacitance : float
        Node capacitance (Farads)
    resistance : float
        Node resistance (Ohms)

    """
    capacitance = 0
    resistance = 0

    cur = conn.cursor()
    for wire_cap, wire_res in cur.execute("""
SELECT capacitance, resistance FROM wire_in_tile WHERE pkey IN (
    SELECT wire_in_tile_pkey FROM wire WHERE node_pkey = ?
    );""", (node_pkey, )):
        capacitance += wire_cap
        resistance += wire_res

    return capacitance, resistance


def get_segment_for_node(cur, segments, node_pkey):
    """ Attempt to determine the segment for the given node.

    Parameters
    ----------
    conn : sqlite3.Connection
        Connection to channels.db
    segments : SegmentWireMap
        Object for determined segment based on wire names.
    node_pkey : int
        Node to determine segment of.  Is primary key into node table.

    Returns
    -------
    segment_pkey : int
        Primary key to segment table of segment for this node.

    """

    cur.execute(
        """
SELECT name FROM wire_in_tile WHERE pkey IN (
    SELECT wire_in_tile_pkey FROM wire WHERE node_pkey = ?
);""", (node_pkey, )
    )

    segment_name = segments.get_segment_for_wires(
        wire for (wire, ) in cur.fetchall()
    )

    cur.execute(
        """
SELECT pkey FROM segment WHERE name = ?
    """, (segment_name, )
    )

    return cur.fetchone()[0]


def insert_tracks(conn, segments, tracks_to_insert):
    write_cur = conn.cursor()
    write_cur.execute('SELECT pkey FROM switch WHERE name = "short";')
    short_pkey = write_cur.fetchone()[0]

    track_graph_nodes = {}
    track_pkeys = []
    for node, tracks_list, track_conn, tracks_model, seg_pkey in progressbar_utils.progressbar(
            tracks_to_insert):
        write_cur.execute(
            """INSERT INTO track(segment_pkey) VALUES (?)""", (seg_pkey, )
        )
        track_pkey = write_cur.lastrowid
        track_pkeys.append(track_pkey)

        write_cur.execute(
            """UPDATE node SET track_pkey = ? WHERE pkey = ?""",
            (track_pkey, node)
        )

        track_graph_node_pkey = []
        for idx, track in enumerate(tracks_list):
            if track.direction == 'X':
                node_type = graph2.NodeType.CHANX
            elif track.direction == 'Y':
                node_type = graph2.NodeType.CHANY
            else:
                assert False, track.direction

            if idx == 0:
                capacitance, resistance = get_node_rc(conn, node)
            else:
                capacitance = 0
                resistance = 0

            write_cur.execute(
                """
INSERT INTO graph_node(
  graph_node_type, track_pkey, node_pkey,
  x_low, x_high, y_low, y_high, capacity, capacitance, resistance
)
VALUES
  (?, ?, ?, ?, ?, ?, ?, 1, ?, ?)""", (
                    node_type.value, track_pkey, node, track.x_low,
                    track.x_high, track.y_low, track.y_high, capacitance,
                    resistance
                )
            )
            track_graph_node_pkey.append(write_cur.lastrowid)

        track_graph_nodes[node] = track_graph_node_pkey

        for connection in track_conn:
            write_cur.execute(
                """
INSERT INTO graph_edge(
  src_graph_node_pkey, dest_graph_node_pkey,
  switch_pkey, track_pkey
)
VALUES
  (?, ?, ?, ?),
  (?, ?, ?, ?)""", (
                    track_graph_node_pkey[connection[0]],
                    track_graph_node_pkey[connection[1]],
                    short_pkey,
                    track_pkey,
                    track_graph_node_pkey[connection[1]],
                    track_graph_node_pkey[connection[0]],
                    short_pkey,
                    track_pkey,
                )
            )

    conn.commit()

    wire_to_graph = {}
    for node, tracks_list, track_conn, tracks_model, _ in progressbar_utils.progressbar(
            tracks_to_insert):
        track_graph_node_pkey = track_graph_nodes[node]

        write_cur.execute(
            """
WITH wires_from_node(wire_pkey, tile_pkey) AS (
  SELECT
    pkey,
    tile_pkey
  FROM
    wire
  WHERE
    node_pkey = ?
)
SELECT
  wires_from_node.wire_pkey,
  tile.grid_x,
  tile.grid_y
FROM
  tile
  INNER JOIN wires_from_node ON tile.pkey = wires_from_node.tile_pkey;
  """, (node, )
        )

        wires = write_cur.fetchall()

        for wire_pkey, grid_x, grid_y in wires:
            connections = list(
                tracks_model.get_tracks_for_wire_at_coord((grid_x,
                                                           grid_y)).values()
            )
            assert len(connections) > 0, (
                connections, wire_pkey, track_pkey, grid_x, grid_y, node
            )
            graph_node_pkey = track_graph_node_pkey[connections[0]]

            wire_to_graph[wire_pkey] = graph_node_pkey

    for wire_pkey, graph_node_pkey in progressbar_utils.progressbar(
            wire_to_graph.items()):
        write_cur.execute(
            """
        UPDATE wire SET graph_node_pkey = ?
            WHERE pkey = ?""", (graph_node_pkey, wire_pkey)
        )

    conn.commit()

    write_cur.execute(
        """CREATE INDEX graph_node_nodes ON graph_node(node_pkey);"""
    )
    write_cur.execute(
        """CREATE INDEX graph_node_tracks ON graph_node(track_pkey);"""
    )
    write_cur.execute(
        """CREATE INDEX graph_edge_tracks ON graph_edge(track_pkey);"""
    )

    conn.commit()
    return track_pkeys


def create_track(node, unique_pos):
    xs, ys = points.decompose_points_into_tracks(unique_pos)
    tracks_list, track_connections = tracks.make_tracks(xs, ys, unique_pos)
    tracks_model = tracks.Tracks(tracks_list, track_connections)

    return [node, tracks_list, track_connections, tracks_model]


def form_tracks(conn, segments):
    cur = conn.cursor()
    cur2 = conn.cursor()

    cur.execute(
        'SELECT count(pkey) FROM node WHERE classification == ?;',
        (NodeClassification.CHANNEL.value, )
    )
    num_nodes = cur.fetchone()[0]

    tracks_to_insert = []
    with progressbar_utils.ProgressBar(max_value=num_nodes) as bar:
        bar.update(0)
        for idx, (node_pkey, ) in enumerate(cur.execute("""
SELECT pkey FROM node WHERE classification == ?;
""", (NodeClassification.CHANNEL.value, ))):
            bar.update(idx)

            unique_pos = set()

            # Get coordinates for all wires in this node.
            for grid_x, grid_y in cur2.execute("""
SELECT DISTINCT grid_x, grid_y FROM tile WHERE pkey IN (
    SELECT tile_pkey FROM wire WHERE node_pkey = ? AND tile_pkey IS NOT NULL
    )""", (node_pkey, )):
                unique_pos.add((grid_x, grid_y))

            # Find the VPR grid locations that this channel connects to.
            #
            # Algorithm:
            #  1. Identify all pips that connect to or from this node
            #  2. Traverse each pip, and determine if the connected node is a
            #     EDGES_TO_CHANNEL.  NULL nodes are uninteresting, and CHANNEL
            #     nodes are already covered in the earlier loop getting
            #     locations of the
            #     discarded.
            #  3a. For CHANNEL to CHANNEL connections, use the pip location.
            #  3b. For CHANNEL to EDGES_TO_CHANNEL (e.g. site pin connections)
            #      use location of site in VPR grid.

            # 3a loop
            for grid_x, grid_y in cur2.execute("""
-- Get wires from this node
WITH wires_from_node(wire_in_tile_pkey, phy_tile_pkey) AS (
  SELECT
    wire_in_tile_pkey,
    phy_tile_pkey
  FROM
    wire
  WHERE
    node_pkey = ? AND tile_pkey IS NOT NULL
),
  other_wires(phy_tile_pkey, wire_in_tile_pkey) AS (
    SELECT
        wires_from_node.phy_tile_pkey,
        undirected_pips.other_wire_in_tile_pkey
    FROM undirected_pips
    INNER JOIN wires_from_node ON
        undirected_pips.wire_in_tile_pkey = wires_from_node.wire_in_tile_pkey)
SELECT tile.grid_x, tile.grid_y
FROM tile
WHERE pkey IN (
    SELECT wire.tile_pkey FROM wire
    INNER JOIN other_wires ON
        wire.wire_in_tile_pkey = other_wires.wire_in_tile_pkey
    AND
        wire.phy_tile_pkey = other_wires.phy_tile_pkey
        );""", (node_pkey, )):
                unique_pos.add((grid_x, grid_y))

            # 3b loop
            for grid_x, grid_y in cur2.execute("""
-- Get wires from this node
WITH wires_from_node(wire_in_tile_pkey, phy_tile_pkey) AS (
  SELECT
    wire_in_tile_pkey,
    phy_tile_pkey
  FROM
    wire
  WHERE
    node_pkey = ? AND tile_pkey IS NOT NULL
),
  other_wires(phy_tile_pkey, wire_in_tile_pkey) AS (
    SELECT
        wires_from_node.phy_tile_pkey,
        undirected_pips.other_wire_in_tile_pkey
    FROM undirected_pips
    INNER JOIN wires_from_node ON
        undirected_pips.wire_in_tile_pkey = wires_from_node.wire_in_tile_pkey),
  other_nodes(other_node_pkey) AS (
    SELECT wire.node_pkey FROM wire
    INNER JOIN other_wires ON
        wire.wire_in_tile_pkey = other_wires.wire_in_tile_pkey
    AND
        wire.phy_tile_pkey = other_wires.phy_tile_pkey),
  other_tiles(site_wire_pkey) AS (
    SELECT node.site_wire_pkey FROM node
    WHERE
        pkey IN (SELECT other_node_pkey FROM other_nodes)
    AND
        classification = ?
  )
SELECT tile.grid_x, tile.grid_y
FROM tile
WHERE pkey IN (
    SELECT DISTINCT tile_pkey
    FROM wire
    WHERE pkey IN (
        SELECT other_tiles.site_wire_pkey FROM other_tiles
        )
    );
  """, (node_pkey, NodeClassification.EDGES_TO_CHANNEL.value)):
                unique_pos.add((grid_x, grid_y))

            # Determine segment for each routing resource.
            segment_pkey = get_segment_for_node(cur2, segments, node_pkey)

            tracks_to_insert.append(
                create_track(node_pkey, unique_pos) + [segment_pkey]
            )

    # Create constant tracks
    vcc_track_to_insert, gnd_track_to_insert = create_constant_tracks(conn)

    # Assign constant networks special segments to given them dedicated
    # router lookaheads.
    cur.execute("SELECT pkey FROM segment WHERE name = ?", (VCC_NET, ))
    vcc_segment_pkey = cur.fetchone()[0]

    cur.execute("SELECT pkey FROM segment WHERE name = ?", (GND_NET, ))
    gnd_segment_pkey = cur.fetchone()[0]

    vcc_idx = len(tracks_to_insert)
    tracks_to_insert.append(vcc_track_to_insert + [vcc_segment_pkey])
    gnd_idx = len(tracks_to_insert)
    tracks_to_insert.append(gnd_track_to_insert + [gnd_segment_pkey])

    track_pkeys = insert_tracks(conn, segments, tracks_to_insert)
    vcc_track_pkey = track_pkeys[vcc_idx]
    gnd_track_pkey = track_pkeys[gnd_idx]

    write_cur = conn.cursor()
    write_cur.execute(
        """
INSERT INTO constant_sources(vcc_track_pkey, gnd_track_pkey) VALUES (?, ?)
        """, (
            vcc_track_pkey,
            gnd_track_pkey,
        )
    )

    # Create synthetic physical tile for constant network to assign a
    # canonical location too.
    #
    # This location is not important, but exists for uniformity with other
    # routing nodes.
    write_cur.execute(
        """
INSERT INTO phy_tile(name, grid_x, grid_y) VALUES (?, ?, ?)
        """, ("CONSTANT_SOURCE", 1, 1)
    )
    zero_phy_tile_pkey = write_cur.lastrowid

    write_cur.execute(
        "UPDATE track SET canon_phy_tile_pkey = ? WHERE pkey = ?", (
            zero_phy_tile_pkey,
            vcc_track_pkey,
        )
    )
    write_cur.execute(
        "UPDATE track SET canon_phy_tile_pkey = ? WHERE pkey = ?", (
            zero_phy_tile_pkey,
            gnd_track_pkey,
        )
    )

    conn.commit()

    connect_hardpins_to_constant_network(conn, vcc_track_pkey, gnd_track_pkey)


def connect_hardpins_to_constant_network(conn, vcc_track_pkey, gnd_track_pkey):
    """ Connect TIEOFF HARD1 and HARD0 pins.

    Update nodes connected to to HARD1 or HARD0 pins to point to the new
    VCC or GND track.  This should connect the pips to the constant
    network instead of the TIEOFF site.
    """

    cur = conn.cursor()
    cur.execute(
        """
SELECT pkey FROM site_type WHERE name = ?
""", ("TIEOFF", )
    )
    results = cur.fetchall()
    assert len(results) == 1, results
    tieoff_site_type_pkey = results[0][0]

    cur.execute(
        """
SELECT pkey FROM site_pin WHERE site_type_pkey = ? and name = ?
""", (tieoff_site_type_pkey, "HARD1")
    )
    vcc_site_pin_pkey = cur.fetchone()[0]
    cur.execute(
        """
SELECT pkey FROM wire_in_tile WHERE site_pin_pkey = ?
""", (vcc_site_pin_pkey, )
    )

    cur.execute(
        """
SELECT pkey FROM wire_in_tile WHERE site_pin_pkey = ?
""", (vcc_site_pin_pkey, )
    )

    write_cur = conn.cursor()
    write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")

    for (wire_in_tile_pkey, ) in cur:
        write_cur.execute(
            """
UPDATE node SET track_pkey = ? WHERE pkey IN (
    SELECT node_pkey FROM wire WHERE wire_in_tile_pkey = ?
)
            """, (
                vcc_track_pkey,
                wire_in_tile_pkey,
            )
        )

    cur.execute(
        """
SELECT pkey FROM site_pin WHERE site_type_pkey = ? and name = ?
""", (tieoff_site_type_pkey, "HARD0")
    )
    gnd_site_pin_pkey = cur.fetchone()[0]

    cur.execute(
        """
SELECT pkey FROM wire_in_tile WHERE site_pin_pkey = ?
""", (gnd_site_pin_pkey, )
    )
    for (wire_in_tile_pkey, ) in cur:
        write_cur.execute(
            """
UPDATE node SET track_pkey = ? WHERE pkey IN (
    SELECT node_pkey FROM wire WHERE wire_in_tile_pkey = ?
)
            """, (
                gnd_track_pkey,
                wire_in_tile_pkey,
            )
        )

    write_cur.execute("""COMMIT TRANSACTION""")


def traverse_pip(conn, wire_in_tile_pkey):
    """ Given a generic wire, find (if any) the wire on the other side of a pip.

    Returns None if no wire or pip connects to this wire.

    """
    cur = conn.cursor()

    cur.execute(
        """
SELECT src_wire_in_tile_pkey FROM pip_in_tile WHERE
    is_pseudo = 0 AND
    dest_wire_in_tile_pkey = ?
    ;""", (wire_in_tile_pkey, )
    )

    result = cur.fetchone()
    if result is not None:
        return result[0]

    cur.execute(
        """
SELECT dest_wire_in_tile_pkey FROM pip_in_tile WHERE
    is_pseudo = 0 AND
    src_wire_in_tile_pkey = ?
    ;""", (wire_in_tile_pkey, )
    )

    result = cur.fetchone()
    if result is not None:
        return result[0]

    return None


def update_wire_in_tile_types(
        cur, write_cur, empty_tile_type_pkey, wire_in_tile_pkey_to_update
):
    # Check if each wire in tile pkey can point to one logical tile type.
    wire_in_tile_pkey_to_tile_type_pkey = {}

    for tile_type_pkey, wire_in_tile_pkeys in wire_in_tile_pkey_to_update.items(
    ):
        for wire_in_tile_pkey in wire_in_tile_pkeys:
            if wire_in_tile_pkey not in wire_in_tile_pkey_to_tile_type_pkey:
                wire_in_tile_pkey_to_tile_type_pkey[wire_in_tile_pkey] = set()

            wire_in_tile_pkey_to_tile_type_pkey[wire_in_tile_pkey].add(
                tile_type_pkey
            )

    wire_in_tile_pkey_to_updates = list(
        wire_in_tile_pkey_to_tile_type_pkey.keys()
    )
    wire_in_tile_pkey_updates = []
    for wire_in_tile_pkey in wire_in_tile_pkey_to_updates:
        cur.execute(
            "SELECT phy_tile_type_pkey FROM wire_in_tile WHERE pkey = ?",
            (wire_in_tile_pkey, )
        )
        phy_tile_type_pkey = cur.fetchone()[0]
        if phy_tile_type_pkey == empty_tile_type_pkey:
            del wire_in_tile_pkey_to_tile_type_pkey[wire_in_tile_pkey]
            continue

        tile_type_pkeys = wire_in_tile_pkey_to_tile_type_pkey[wire_in_tile_pkey
                                                              ]
        assert len(tile_type_pkeys) == 1, (wire_in_tile_pkey, tile_type_pkeys)

        wire_in_tile_pkey_updates.append(
            (list(tile_type_pkeys)[0], wire_in_tile_pkey)
        )

    write_cur.executemany(
        """
    UPDATE wire_in_tile
    SET tile_type_pkey = ?
    WHERE pkey = ?;""", wire_in_tile_pkey_updates
    )


def create_vpr_grid(conn, grid_map_output):
    """ Create VPR grid from prjxray grid. """
    cur = conn.cursor()
    cur2 = conn.cursor()

    slice_types = {}

    write_cur = conn.cursor()
    write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")

    # Insert synthetic tile types for CLB sites and iopad sites.
    for name in [
            'SLICEL',
            'SLICEM',
            'LIOPAD_M',
            'LIOPAD_S',
            'LIOPAD_SING',
            'RIOPAD_M',
            'RIOPAD_S',
            'RIOPAD_SING',
    ]:
        write_cur.execute('INSERT INTO tile_type(name) VALUES (?);', (name, ))
        slice_types[name] = write_cur.lastrowid

    write_cur.execute("""COMMIT TRANSACTION;""")

    tiles_to_merge = {
        'LIOB33_SING': tile_splitter.grid.EAST,
        'LIOB33': tile_splitter.grid.EAST,
        'RIOB33_SING': tile_splitter.grid.WEST,
        'RIOB33': tile_splitter.grid.WEST,
    }

    tiles_to_split = {
        'LIOI3': tile_splitter.grid.NORTH,
        'LIOI3_TBYTESRC': tile_splitter.grid.NORTH,
        'LIOI3_TBYTETERM': tile_splitter.grid.NORTH,
        'LIOI3_SING': tile_splitter.grid.NORTH,
        'RIOI3': tile_splitter.grid.NORTH,
        'RIOI3_TBYTESRC': tile_splitter.grid.NORTH,
        'RIOI3_TBYTETERM': tile_splitter.grid.NORTH,
        'RIOI3_SING': tile_splitter.grid.NORTH,
    }

    liopad_ms_split = {
        1: slice_types['LIOPAD_M'],
        0: slice_types['LIOPAD_S'],
    }
    riopad_ms_split = {
        1: slice_types['RIOPAD_M'],
        0: slice_types['RIOPAD_S'],
    }

    split_styles = {
        'LIOI3': ('y_split', liopad_ms_split),
        'LIOI3_TBYTESRC': ('y_split', liopad_ms_split),
        'LIOI3_TBYTETERM': ('y_split', liopad_ms_split),
        'RIOI3': ('y_split', riopad_ms_split),
        'RIOI3_TBYTESRC': ('y_split', riopad_ms_split),
        'RIOI3_TBYTETERM': ('y_split', riopad_ms_split),
        'LIOI3_SING': ('y_split', {
            0: slice_types['LIOPAD_SING']
        }),
        'RIOI3_SING': ('y_split', {
            0: slice_types['RIOPAD_SING']
        }),
    }
    # Create initial grid using sites and locations from phy_tile's
    # Also build up tile_to_tile_type_pkeys, which is a map from original
    # tile_type_pkey, to array of split tile type pkeys, (e.g. SLICEL/SLICEM).
    tile_to_tile_type_pkeys = {}
    split_map = {}

    grid_loc_map = {}

    for phy_tile_pkey, tile_type_pkey, grid_x, grid_y in progressbar_utils.progressbar(
            cur.execute("""
        SELECT pkey, tile_type_pkey, grid_x, grid_y FROM phy_tile;
        """)):

        cur2.execute(
            "SELECT name FROM tile_type WHERE pkey = ?;", (tile_type_pkey, )
        )
        tile_type_name = cur2.fetchone()[0]

        sites = []
        site_pkeys = set()
        for (site_pkey, ) in cur2.execute("""
SELECT site_pkey FROM wire_in_tile WHERE tile_type_pkey = ? AND site_pkey IS NOT NULL;""",
                                          (tile_type_pkey, )):
            site_pkeys.add(site_pkey)

        for site_pkey in site_pkeys:
            cur2.execute(
                """
                SELECT x_coord, y_coord, site_type_pkey
                FROM site WHERE pkey = ?;""", (site_pkey, )
            )
            result = cur2.fetchone()
            assert result is not None, (tile_type_pkey, site_pkey)
            x, y, site_type_pkey = result

            cur2.execute(
                "SELECT name FROM site_type WHERE pkey = ?;",
                ((site_type_pkey, ))
            )
            site_type_name = cur2.fetchone()[0]

            sites.append(
                tile_splitter.grid.Site(
                    name=site_type_name,
                    phy_tile_pkey=phy_tile_pkey,
                    tile_type_pkey=tile_type_pkey,
                    site_type_pkey=site_type_pkey,
                    site_pkey=site_pkey,
                    x=x,
                    y=y
                )
            )

        sites = sorted(sites, key=lambda s: (s.x, s.y))

        if tile_type_name in tiles_to_split:
            tile_type_pkeys = []
            tile_split_map = {}

            if split_styles[tile_type_name][0] == 'site_as_tile':
                for idx, site in enumerate(sites):
                    tile_type_pkeys.append(slice_types[site.name])
                    tile_split_map[site.x, site.y] = idx
            elif split_styles[tile_type_name][0] == 'y_split':
                ys = set()

                for site in sites:
                    ys.add(site.y)

                ys = sorted(ys)

                tile_type_pkeys = [
                    split_styles[tile_type_name][1][y] for y in ys
                ]
                for site in sites:
                    tile_split_map[site.x, site.y] = ys.index(site.y)
            else:
                assert False, split_styles[tile_type_name]

            if tile_type_name in tile_to_tile_type_pkeys:
                assert tile_to_tile_type_pkeys[
                    tile_type_name] == tile_type_pkeys, (tile_type_name, )
                assert split_map[tile_type_name] == tile_split_map, (
                    tile_type_name,
                )
            else:
                tile_to_tile_type_pkeys[tile_type_name] = tile_type_pkeys
                split_map[tile_type_name] = tile_split_map

        grid_loc_map[(grid_x, grid_y)] = tile_splitter.grid.Tile(
            root_phy_tile_pkeys=[phy_tile_pkey],
            phy_tile_pkeys=[phy_tile_pkey],
            tile_type_pkey=tile_type_pkey,
            sites=sites
        )

    cur.execute('SELECT pkey FROM tile_type WHERE name = "NULL";')
    empty_tile_type_pkey = cur.fetchone()[0]

    tile_types = {}
    tile_type_names = {}
    for tile_type, _ in tiles_to_merge.items():
        cur.execute(
            'SELECT pkey FROM tile_type WHERE name = ?;', (tile_type, )
        )
        tile_type_pkey = cur.fetchone()
        if tile_type_pkey is not None:
            tile_type_pkey = tile_type_pkey[0]
            tile_types[tile_type] = tile_type_pkey
            tile_type_names[tile_type_pkey] = tile_type

    for tile_type, _ in tiles_to_split.items():
        cur.execute(
            'SELECT pkey FROM tile_type WHERE name = ?;', (tile_type, )
        )
        tile_type_pkey = cur.fetchone()
        if tile_type_pkey is not None:
            tile_type_pkey = tile_type_pkey[0]
            tile_types[tile_type] = tile_type_pkey
            tile_type_names[tile_type_pkey] = tile_type

    vpr_grid = tile_splitter.grid.Grid(
        grid_loc_map=grid_loc_map, empty_tile_type_pkey=empty_tile_type_pkey
    )

    # Merge tiles first, so any splits account for sites the show up after a
    # merge.
    for tile_type, merge_direction in progressbar_utils.progressbar(
            tiles_to_merge.items()):
        if tile_type in tile_types:
            vpr_grid.merge_tile_type(
                tile_type_pkey=tile_types[tile_type],
                merge_direction=merge_direction,
            )

    for tile_type, split_direction in progressbar_utils.progressbar(
            tiles_to_split.items()):
        if tile_type in tile_types:
            vpr_grid.split_tile_type(
                tile_type_pkey=tile_types[tile_type],
                tile_type_pkeys=tile_to_tile_type_pkeys[tile_type],
                split_direction=split_direction,
                split_map=split_map[tile_type],
            )

    new_grid = vpr_grid.output_grid()

    shifted_grid = {}
    for (grid_x, grid_y), tile in new_grid.items():
        # Shift grid away from 0 edges, which have limitations in VPR that
        # complicate the rrgraph import process.
        grid_x += 1
        grid_y += 1
        shifted_grid[(grid_x, grid_y)] = tile

    new_grid = shifted_grid

    write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")

    # Create tile rows for each tile in the VPR grid.  As provide map entries
    # to physical grid and alias map from split tile type to original tile
    # type.
    for (grid_x, grid_y), tile in new_grid.items():
        if tile.split_sites and len(tile.sites) == 1:
            write_cur.execute(
                """
SELECT pkey, parent_tile_type_pkey FROM site_as_tile WHERE tile_type_pkey = ? AND site_pkey = ?""",
                (tile.sites[0].tile_type_pkey, tile.sites[0].site_pkey)
            )
            result = write_cur.fetchone()

            if result is None:
                write_cur.execute(
                    """
INSERT INTO
    site_as_tile(parent_tile_type_pkey, tile_type_pkey, site_pkey)
VALUES
    (?, ?, ?);""", (
                        tile.tile_type_pkey, tile.sites[0].tile_type_pkey,
                        tile.sites[0].site_pkey
                    )
                )
                site_as_tile_pkey = write_cur.lastrowid
            else:
                site_as_tile_pkey, parent_tile_type_pkey = result
                assert parent_tile_type_pkey == tile.tile_type_pkey

            # Mark that this tile is split by setting the site_as_tile_pkey.
            write_cur.execute(
                """
INSERT INTO tile(phy_tile_pkey, tile_type_pkey, site_as_tile_pkey, grid_x, grid_y) VALUES (
        ?, ?, ?, ?, ?)""", (
                    tile.phy_tile_pkeys[0], tile.tile_type_pkey,
                    site_as_tile_pkey, grid_x, grid_y
                )
            )
        else:
            phy_tile_pkey = None
            if len(tile.phy_tile_pkeys) > 0:
                phy_tile_pkey = tile.phy_tile_pkeys[0]

            write_cur.execute(
                """
INSERT INTO tile(phy_tile_pkey, tile_type_pkey, grid_x, grid_y) VALUES (
        ?, ?, ?, ?)""", (phy_tile_pkey, tile.tile_type_pkey, grid_x, grid_y)
            )

        tile_pkey = write_cur.lastrowid

        # Build the phy_tile <-> tile map.
        for phy_tile_pkey in tile.phy_tile_pkeys:
            write_cur.execute(
                """
INSERT INTO tile_map(tile_pkey, phy_tile_pkey) VALUES (?, ?)
                """, (tile_pkey, phy_tile_pkey)
            )

        # First assign all wires at the root_phy_tile_pkeys to this tile_pkey.
        # This ensures all wires, (including wires without sites) have a home.

        for root_phy_tile_pkey in tile.root_phy_tile_pkeys:

            write_cur.execute(
                """
UPDATE
    wire
SET
    tile_pkey = ?
WHERE
    phy_tile_pkey = ?
    ;""", (tile_pkey, root_phy_tile_pkey)
            )

    write_cur.execute(
        "CREATE INDEX tile_location_index ON tile(grid_x, grid_y);"
    )
    write_cur.execute("CREATE INDEX tile_to_phy_map ON tile_map(tile_pkey);")
    write_cur.execute(
        "CREATE INDEX phy_to_tile_map ON tile_map(phy_tile_pkey);"
    )
    write_cur.execute("""COMMIT TRANSACTION;""")

    write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")

    # Track wire_in_tile_pkey's to update to new tile types.
    wire_in_tile_pkey_to_update = {}

    # At this point all wires have a tile_pkey that corrisponds to the old root
    # tile.  Wires belonging to sites need to be reassigned to their respective
    # tiles.
    for (grid_x, grid_y), tile in new_grid.items():
        cur2.execute(
            "SELECT pkey, tile_type_pkey FROM tile WHERE grid_x = ? AND grid_y = ?;",
            (grid_x, grid_y)
        )
        tile_pkey, tile_type_pkey = cur2.fetchone()

        for site in tile.sites:
            # Find all wires that belong to the new tile location.
            for wire_pkey, wire_in_tile_pkey in cur2.execute("""
WITH wires(wire_pkey, wire_in_tile_pkey) AS (
    SELECT
        pkey, wire_in_tile_pkey
    FROM
        wire
    WHERE
        phy_tile_pkey = ?
)
SELECT
    wires.wire_pkey, wires.wire_in_tile_pkey
FROM
    wires
INNER JOIN
    wire_in_tile
ON
    wire_in_tile.pkey = wires.wire_in_tile_pkey
WHERE
    wire_in_tile.site_pkey = ?
    ;""", (site.phy_tile_pkey, site.site_pkey)):
                # Move the wire to the new tile_pkey.
                write_cur.execute(
                    """
UPDATE
    wire
SET
    tile_pkey = ?
WHERE
    pkey = ?;""", (
                        tile_pkey,
                        wire_pkey,
                    )
                )

                if tile_type_pkey not in wire_in_tile_pkey_to_update:
                    wire_in_tile_pkey_to_update[tile_type_pkey] = set()

                wire_in_tile_pkey_to_update[tile_type_pkey].add(
                    wire_in_tile_pkey
                )

                # Wires connected to the site via a pip require traversing the
                # pip.
                other_wire_in_tile_pkey = traverse_pip(conn, wire_in_tile_pkey)
                if other_wire_in_tile_pkey is not None:
                    cur.execute(
                        """
SELECT classification
FROM node
WHERE pkey = (
    SELECT node_pkey
    FROM wire
    WHERE
        phy_tile_pkey = ?
    AND
        wire_in_tile_pkey = ?
)
                        ;""", (site.phy_tile_pkey, other_wire_in_tile_pkey)
                    )
                    classification = NodeClassification(cur.fetchone()[0])

                    if classification != NodeClassification.CHANNEL:
                        continue

                    # A wire was found connected to the site via pip, reassign
                    # tile_pkey.
                    write_cur.execute(
                        """
UPDATE
    wire
SET
    tile_pkey = ?
WHERE
    phy_tile_pkey = ?
AND
    wire_in_tile_pkey = ?
    ;""", (tile_pkey, site.phy_tile_pkey, other_wire_in_tile_pkey)
                    )

    # Now that final wire <-> tile assignments are made, create the index.
    write_cur.execute(
        "CREATE INDEX tile_wire_index ON wire(wire_in_tile_pkey, tile_pkey, node_pkey);"
    )
    write_cur.execute(
        "CREATE INDEX node_tile_wire_index ON wire(node_pkey, tile_pkey, wire_in_tile_pkey);"
    )

    # Update tile_type_pkey in wire_in_tile table.
    update_wire_in_tile_types(
        cur, write_cur, empty_tile_type_pkey, wire_in_tile_pkey_to_update
    )

    write_cur.execute("""COMMIT TRANSACTION;""")

    write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")
    write_cur.execute("ANALYZE")
    write_cur.execute("""COMMIT TRANSACTION;""")

    # Now that the final VPR grid is generated, we need a fast lookup to easily
    # access to the canonical to VPR grid mapping.
    #
    # Furthermore, information on the internal tile connections between sites belonging
    # to the same tile, which are treated as heterogeneous tiles. These connections are
    # required to correctly instruct VPR on the presence of direct connections between
    # sites at the same X, Y coordinate, but with different sub tile coordinates.
    fieldnames = [
        "site_name",
        "site_type",
        "physical_tile",
        "vpr_x",
        "vpr_y",
        "canon_x",
        "canon_y",
        "clock_region",
        "connected_to_site",
    ]
    csv_writer = csv.DictWriter(grid_map_output, fieldnames=fieldnames)
    csv_writer.writeheader()

    # Find all sites that have direct connections with other sites in the same tile.
    sites_with_direct = dict()
    for src_wire_pkey, dest_wire_pkey, pip_in_tile_pkey in \
            progressbar_utils.progressbar(
            cur.execute("""
SELECT
    src_wire_pkey,
    dest_wire_pkey,
    pip_in_tile_pkey
FROM
    edge_with_mux""")):

        cur2.execute(
            """
SELECT node_pkey FROM wire WHERE pkey = ?""", (src_wire_pkey, )
        )
        (src_node_pkey, ) = cur2.fetchone()

        # Find the wire connected to the source.
        src_wire = list(node_to_site_pins(conn, src_node_pkey))
        assert len(src_wire) == 1
        _, src_tile_pkey, src_wire_in_tile_pkey = src_wire[0]

        cur2.execute(
            """
SELECT tile_type_pkey, grid_x, grid_y FROM tile WHERE pkey = ?""",
            (src_tile_pkey, )
        )

        res = cur2.fetchone()
        src_tile_type_pkey, src_grid_x, src_grid_y = res

        # Get the node that is attached to the sink.
        cur2.execute(
            """
SELECT node_pkey FROM wire WHERE pkey = ?""", (dest_wire_pkey, )
        )
        (dest_node_pkey, ) = cur2.fetchone()

        # Find the wire connected to the sink.
        dest_wire = list(node_to_site_pins(conn, dest_node_pkey))
        assert len(dest_wire) == 1
        _, dest_tile_pkey, dest_wire_in_tile_pkey = dest_wire[0]

        cur2.execute(
            """
SELECT tile_type_pkey, grid_x, grid_y FROM tile WHERE pkey = ?;""",
            (dest_tile_pkey, )
        )

        res = cur2.fetchone()
        dest_tile_type_pkey, dest_grid_x, dest_grid_y = res

        if dest_grid_x == src_grid_x and dest_grid_y == src_grid_y:
            tile = new_grid[(dest_grid_x, dest_grid_y)]

            cur2.execute(
                "SELECT site_pkey FROM wire_in_tile WHERE pkey = ?",
                (src_wire_in_tile_pkey, )
            )
            src_site_pkey = cur2.fetchone()[0]

            cur2.execute(
                "SELECT site_pkey FROM wire_in_tile WHERE pkey = ?",
                (dest_wire_in_tile_pkey, )
            )
            dest_site_pkey = cur2.fetchone()[0]

            src_site_instance = None
            dest_site_instance = None
            for site in tile.sites:
                cur2.execute(
                    "SELECT name FROM site_instance WHERE site_pkey = ? AND phy_tile_pkey = ?"
                    "", (
                        site.site_pkey,
                        site.phy_tile_pkey,
                    )
                )

                res = cur2.fetchone()[0]

                if site.site_pkey == src_site_pkey:
                    src_site_instance = res
                elif site.site_pkey == dest_site_pkey:
                    dest_site_instance = res

            assert src_site_instance and dest_site_instance

            sites_with_direct[src_site_instance] = dest_site_instance

    # Build the Canonical to VPR grid mapping
    for (grid_x, grid_y), tile in new_grid.items():
        for site in tile.sites:
            cur.execute(
                "SELECT name FROM site_instance WHERE site_pkey = ? AND phy_tile_pkey = ?",
                (
                    site.site_pkey,
                    site.phy_tile_pkey,
                )
            )

            site_name = cur.fetchone()[0]

            cur.execute(
                "SELECT name, clock_region_pkey, grid_x, grid_y FROM phy_tile WHERE pkey = ?",
                (site.phy_tile_pkey, )
            )

            phy_tile_name, clock_region, canon_x, canon_y = cur.fetchone()

            cur.execute(
                "SELECT name FROM site_type WHERE pkey = ?",
                (site.site_type_pkey, )
            )

            site_type = cur.fetchone()[0]

            # This is a site which is directly connected to the current site
            # and will be implemented as a sub_tile. This information is relevant
            # to generate correct placement constraints for sub_tiles directly
            # connected within the same physical tile
            connected_to_site = sites_with_direct.get(site_name, None)

            csv_writer.writerow(
                {
                    "site_name": site_name,
                    "site_type": site_type,
                    "physical_tile": phy_tile_name,
                    "vpr_x": grid_x,
                    "vpr_y": grid_y,
                    "canon_x": canon_x,
                    "canon_y": canon_y,
                    "clock_region": clock_region,
                    "connected_to_site": connected_to_site
                }
            )


def create_constant_tracks(conn):
    """ Create two tracks that go to all TIEOFF sites to route constants.

    Returns (vcc_track_to_insert, gnd_track_to_insert), suitable for insert
    via insert_tracks function.

    """

    # Make constant track available to all tiles.
    write_cur = conn.cursor()
    unique_pos = set()
    write_cur.execute('SELECT grid_x, grid_y FROM tile')
    for grid_x, grid_y in write_cur:
        if grid_x == 0 or grid_y == 0:
            continue
        unique_pos.add((grid_x, grid_y))

    write_cur.execute(
        """
INSERT INTO node(classification) VALUES (?)
""", (NodeClassification.CHANNEL.value, )
    )
    vcc_node = write_cur.lastrowid

    write_cur.execute(
        """
INSERT INTO node(classification) VALUES (?)
""", (NodeClassification.CHANNEL.value, )
    )
    gnd_node = write_cur.lastrowid

    conn.commit()

    return create_track(vcc_node,
                        unique_pos), create_track(gnd_node, unique_pos)


def import_segments(conn, db):
    """ Create segment table, use segment definitions from SegmentWireMap.

    Parameters
    ----------
    conn : sqlite3.Connection
        Connection to channels.db

    db : prjxray.Database
        Project X-Ray database object.

    Returns
    -------
    SegmentWireMap

        SegmentWireMap can be used to detect which segment a wire belongs too.

    """
    write_cur = conn.cursor()

    default_segment = "unknown"
    segments = SegmentWireMap(default_segment=default_segment, db=db)

    # Add some additional useful segments that are not part of the wire map
    # (e.g. the global constant networks).
    for extra_segment in [default_segment, VCC_NET, GND_NET]:
        if extra_segment not in segments.get_segments():
            write_cur.execute(
                """
INSERT INTO segment(name) VALUES (?)
            """, (extra_segment, )
            )

    for segment in segments.get_segments():
        write_cur.execute(
            """
INSERT INTO segment(name) VALUES (?)
            """, (segment, )
        )

    write_cur.execute("CREATE INDEX segment_name_map ON segment(name);")
    conn.commit()

    return segments


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--db_root', help='Project X-Ray Database', required=True
    )
    parser.add_argument('--part', help='FPGA part', required=True)
    parser.add_argument(
        '--connection_database', help='Connection database', required=True
    )
    parser.add_argument(
        '--grid_map_output',
        help='Location of the grid map output',
        required=True
    )

    args = parser.parse_args()
    if os.path.exists(args.connection_database):
        os.remove(args.connection_database)

    with DatabaseCache(args.connection_database) as conn:
        create_tables(conn)

        print("{}: About to load database".format(datetime.datetime.now()))
        db = prjxray.db.Database(args.db_root, args.part)
        grid = db.grid()
        get_switch, get_switch_timing = create_get_switch(conn)
        import_phy_grid(db, grid, conn, get_switch, get_switch_timing)

        segments = import_segments(conn, db)

        print("{}: Initial database formed".format(datetime.datetime.now()))
        import_nodes(db, grid, conn)
        print("{}: Connections made".format(datetime.datetime.now()))
        count_sites_and_pips_on_nodes(conn)
        print("{}: Counted sites and pips".format(datetime.datetime.now()))
        classify_nodes(conn, get_switch_timing)
        print("{}: Create VPR grid".format(datetime.datetime.now()))
        with open(args.grid_map_output, 'w') as f:
            create_vpr_grid(conn, f)
        print("{}: Nodes classified".format(datetime.datetime.now()))
        form_tracks(conn, segments)
        print("{}: Tracks formed".format(datetime.datetime.now()))

        print(
            '{} Flushing database back to file "{}"'.format(
                datetime.datetime.now(), args.connection_database
            )
        )


if __name__ == '__main__':
    main()