test_esipp_network.py

# imports

# standard

import random

from networkx import binomial_tree, MultiDiGraph

# local

from src.topupopt.problems.esipp.network import Arcs, Network

from src.topupopt.problems.esipp.network import ArcsWithoutLosses

from src.topupopt.problems.esipp.network import ArcsWithoutProportionalLosses

from src.topupopt.problems.esipp.network import ArcsWithoutStaticLosses

from src.topupopt.problems.esipp.resource import ResourcePrice

# *****************************************************************************
# *****************************************************************************

# TODO: add test for directed arcs between import and export nodes with static losses

# TODO: add test for undirected arcs involving import and export nodes


class TestNetwork:
    # *************************************************************************
    # *************************************************************************

    def test_tree_topology(self):
        # create a network object with a tree topology

        tree_network = binomial_tree(3, create_using=MultiDiGraph)

        network = Network(tree_network)

        for edge_key in network.edges(keys=True):
            arc = ArcsWithoutLosses(
                name=str(edge_key),
                capacity=[5, 10],
                minimum_cost=[3, 6],
                specific_capacity_cost=0,
                capacity_is_instantaneous=False,
            )

            network.add_edge(*edge_key, **{Network.KEY_ARC_TECH: arc})

        # assert that it does not have a tree topology

        assert not network.has_tree_topology()

        # select all the nodes

        for edge_key in network.edges(keys=True):
            network.edges[edge_key][Network.KEY_ARC_TECH].options_selected[0] = True

        # assert that it has a tree topology

        assert network.has_tree_topology()

    # *************************************************************************
    # *************************************************************************

    def test_arc_technologies_static_losses(self):
        # *********************************************************************
        # *********************************************************************

        number_time_intervals = 3
        number_scenarios = 2
        number_options = 4

        efficiency_dict = {
            (q, k): 0.95
            for q in range(number_scenarios)
            for k in range(number_time_intervals)
        }

        static_loss_dict = {
            (h, q, k): 1
            for h in range(number_options)
            for q in range(number_scenarios)
            for k in range(number_time_intervals)
        }

        for capacity_is_instantaneous in (True, False):
            arc_tech = Arcs(
                name="any",
                efficiency=efficiency_dict,
                efficiency_reverse=None,
                capacity=tuple(1 + o for o in range(number_options)),
                minimum_cost=tuple(1 + o for o in range(number_options)),
                specific_capacity_cost=1,
                capacity_is_instantaneous=capacity_is_instantaneous,
                static_loss=static_loss_dict,
                validate=True,
            )

            assert arc_tech.has_proportional_losses()

            assert arc_tech.has_static_losses()

            assert not arc_tech.is_infinite_capacity()

            assert not arc_tech.has_been_selected()

            assert arc_tech.is_isotropic(reverse_none_means_isotropic=True)

            assert not arc_tech.is_isotropic(reverse_none_means_isotropic=False)

            # isotropic

            arc_tech = Arcs(
                name="any",
                efficiency=None,
                efficiency_reverse=None,
                capacity=tuple(1 + o for o in range(number_options)),
                minimum_cost=tuple(1 + o for o in range(number_options)),
                specific_capacity_cost=1,
                capacity_is_instantaneous=capacity_is_instantaneous,
                static_loss=static_loss_dict,
                validate=True,
            )

            assert not arc_tech.has_proportional_losses()

            assert arc_tech.has_static_losses()

            assert not arc_tech.is_infinite_capacity()

            assert not arc_tech.has_been_selected()

            assert arc_tech.is_isotropic(reverse_none_means_isotropic=True)

            assert arc_tech.is_isotropic(reverse_none_means_isotropic=False)

            # create arc technology with only one option

            arc_tech = Arcs(
                name="any",
                efficiency=efficiency_dict,
                efficiency_reverse=None,
                capacity=(1,),
                minimum_cost=(1,),
                specific_capacity_cost=1,
                capacity_is_instantaneous=capacity_is_instantaneous,
                static_loss={
                    (0, q, k): 1
                    # for h in range(number_options)
                    for q in range(number_scenarios)
                    for k in range(number_time_intervals)
                },
                validate=True,
            )

            assert arc_tech.has_proportional_losses()

            assert arc_tech.has_static_losses()

            assert not arc_tech.is_infinite_capacity()

            assert not arc_tech.has_been_selected()

            assert arc_tech.is_isotropic(reverse_none_means_isotropic=True)

            assert not arc_tech.is_isotropic(reverse_none_means_isotropic=False)

            # create arc technology for one time interval

            arc_tech = Arcs(
                name="any",
                efficiency={
                    (q, 0): 0.5
                    for q in range(number_scenarios)
                    # for k in range(number_time_intervals)
                },
                efficiency_reverse=None,
                capacity=tuple(1 + o for o in range(number_options)),
                minimum_cost=tuple(1 + o for o in range(number_options)),
                specific_capacity_cost=1,
                capacity_is_instantaneous=capacity_is_instantaneous,
                static_loss={
                    (h, q, 0): 1
                    for h in range(number_options)
                    for q in range(number_scenarios)
                    # for k in range(number_time_intervals)
                },
                validate=True,
            )

            assert arc_tech.has_proportional_losses()

            assert arc_tech.has_static_losses()

            assert not arc_tech.is_infinite_capacity()

            assert not arc_tech.has_been_selected()