grid_3d.h

/*
 * Copyright 2016 Ophidian
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
 */

#ifndef OPHIDIAN_SRC_ROUTING_GRID_3D_H
#define OPHIDIAN_SRC_ROUTING_GRID_3D_H

#include <lemon/grid_graph.h>

#include <memory>
#include <assert.h>

namespace ophidian{
namespace routing{


class grid_2d
{
    friend class grid_3d;

    lemon::GridGraph m_graph;
    lemon::GridGraph::EdgeMap<unsigned> m_edges_capacities;
    lemon::GridGraph::EdgeMap<unsigned> m_edges_demands;
public:

    grid_2d(int width, int height);
    virtual ~grid_2d();
};


class grid_3d
{
    int m_width;
    int m_height;
    int m_depth;
    std::vector<std::unique_ptr<grid_2d> > m_vector_of_grid_2D;
public:

    grid_3d(int width, int height, int depth);
    ~grid_3d();


    inline int width(){return m_width;}


    inline int height(){return m_height;}


    inline int depth(){return m_depth;}


    void reset_edge_demands();


    inline unsigned get_horizontal_edge_capacity(int x, int y, int z)
    {
        assert(x < m_width-1); //there is no boundary edge
        assert(y < m_height);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.right(grid_2d.m_graph(x, y));
        return grid_2d.m_edges_capacities[arc];
    }


    inline unsigned get_vertical_edge_capacity(int x, int y, int z)
    {
        assert(x < m_width); //there is no boundary edge
        assert(y < m_height-1);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.up(grid_2d.m_graph(x, y));
        return grid_2d.m_edges_capacities[arc];
    }


    inline void set_horizontal_edge_capacity(int x, int y, int z, unsigned capacity)
    {
        assert(x < m_width-1); //there is no boundary edge
        assert(y < m_height);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.right(grid_2d.m_graph(x, y));
        grid_2d.m_edges_capacities[arc] = capacity;
    }


    inline void set_vertical_edge_capacity(int x, int y, int z, unsigned capacity)
    {
        assert(x < m_width); //there is no boundary edge
        assert(y < m_height-1);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.up(grid_2d.m_graph(x, y));
        grid_2d.m_edges_capacities[arc] = capacity;
    }


    inline unsigned get_horizontal_edge_demand(int x, int y, int z)
    {
        assert(x < m_width-1); //there is no boundary edge
        assert(y < m_height);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.right(grid_2d.m_graph(x, y));
        return grid_2d.m_edges_demands[arc];
    }


    unsigned get_vertical_edge_demand(int x, int y, int z)
    {
        assert(x < m_width); //there is no boundary edge
        assert(y < m_height-1);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.up(grid_2d.m_graph(x, y));
        return grid_2d.m_edges_demands[arc];
    }


    inline void set_horizontal_edge_demand(int x, int y, int z, unsigned demand)
    {
        assert(x < m_width-1); //there is no boundary edge
        assert(y < m_height);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.right(grid_2d.m_graph(x, y));
        grid_2d.m_edges_demands[arc] = demand;
    }


    inline void set_vertical_edge_demand(int x, int y, int z, unsigned demand)
    {
        assert(x < m_width); //there is no boundary edge
        assert(y < m_height-1);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.up(grid_2d.m_graph(x, y));
        grid_2d.m_edges_demands[arc] = demand;
    }


    inline void increment_horizontal_edge_demand(int x, int y, int z)
    {
        assert(x < m_width-1); //there is no boundary edge
        assert(y < m_height);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.right(grid_2d.m_graph(x, y));
        grid_2d.m_edges_demands[arc] += 1;
    }


    inline void increment_vertical_edge_demand(int x, int y, int z)
    {
        assert(x < m_width); //there is no boundary edge
        assert(y < m_height-1);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.up(grid_2d.m_graph(x, y));
        grid_2d.m_edges_demands[arc] += 1;
    }


    inline int get_horizontal_edge_utilization_gap(int x, int y, int z)
    {
        assert(x < m_width-1); //there is no boundary edge
        assert(y < m_height);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.right(grid_2d.m_graph(x, y));
        auto capacity = grid_2d.m_edges_capacities[arc];
        auto demand = grid_2d.m_edges_demands[arc];
        return capacity - demand;
    }


    inline int get_vertical_edge_utilization_gap(int x, int y, int z)
    {
        assert(x < m_width); //there is no boundary edge
        assert(y < m_height-1);
        assert(z < m_depth);

        auto & grid_2d = *m_vector_of_grid_2D.at(z);
        auto arc = grid_2d.m_graph.up(grid_2d.m_graph(x, y));
        auto capacity = grid_2d.m_edges_capacities[arc];
        auto demand = grid_2d.m_edges_demands[arc];
        return capacity - demand;
    }


    void get_max_and_total_edges_overflow(int & max_overflow, int & total_overflow);
};

class edge_overflow_calculator{
protected:
    grid_3d & m_grid_3d;
public:
    edge_overflow_calculator(grid_3d & grid_3d);
    virtual ~edge_overflow_calculator();
    void get_max_and_total_edges_overflow(int & max_overflow, int & total_overflow);
};

}  /* namespace routing */
}  /* namespace ophidian */

#endif // OPHIDIAN_SRC_ROUTING_GRID_3D_H