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

from src.topupopt.data.misc.utils import generate_pseudo_unique_key

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

class TestNetwork:

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

    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()

            assert arc_tech.is_isotropic(reverse_none_means_isotropic=True)

            assert not arc_tech.is_isotropic(reverse_none_means_isotropic=False)

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

            # TypeError: The static losses should be given as a dict or None.

            error_triggered = False
            try:
                _ = 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=tuple(
                        [k for k in range(number_time_intervals)]
                        for o in range(number_options)
                    ),
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError('The static losses should be specified for each arc
            # option.')

            error_triggered = False
            try:
                _ = 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={
                        (
                            h,
                            q,
                        ): 1
                        for h in range(number_options)
                        for q in range(number_scenarios)
                    },
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # TypeError('The static losses must be specified via a list of lists.')

            error_triggered = False
            try:
                _ = 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=[
                        tuple(k for k in range(number_time_intervals))
                        for o in range(number_options)
                    ],
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError('The static loss values are inconsistent with the number '
            # 'of options, scenarios and intervals.')

            error_triggered = False
            try:
                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={
                        (h, q, k): 1
                        for h in range(number_options)
                        for q in range(number_scenarios)
                        for k in range(number_time_intervals - 1)
                    },
                    validate=True,
                )

                arc_tech.validate_sizes(
                    number_options=number_options,
                    number_scenarios=number_scenarios,
                    number_intervals=[
                        number_time_intervals for _ in range(number_scenarios)
                    ],
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # TypeError('The static losses were not provided as numbers.')

            error_triggered = False
            try:
                _ = 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={
                        (h, q, k): str(3.54)
                        for h in range(number_options)
                        for q in range(number_scenarios)
                        for k in range(number_time_intervals)
                    },
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError('The static losses must be positive or zero.')

            error_triggered = False
            try:
                _ = 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={
                        (h, q, k): -random.randint(0, 1) * random.random()
                        for h in range(number_options)
                        for q in range(number_scenarios)
                        for k in range(number_time_intervals)
                    },
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # TypeError: The static loss dict keys must be tuples

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=None,
                    efficiency_reverse=None,
                    static_loss={k: 1 for k in range(number_time_intervals)},
                    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,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError( 'The static loss dict keys must be tuples of size 3.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=None,
                    efficiency_reverse=None,
                    static_loss={(k, 3): 1 for k in range(number_time_intervals)},
                    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,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # TypeError(The staticl osses should be given as a dict or None.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=None,
                    efficiency_reverse=None,
                    static_loss=[1 for k in range(number_time_intervals)],
                    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,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError(
            #     'No static loss values were provided. There should be one'+
            #     ' value per option, scenario and time interval.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=None,
                    efficiency_reverse=None,
                    static_loss={},
                    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,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

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

    def test_arc_technologies(self):
        # *********************************************************************

        # create arc technology using instantaneous capacities

        number_scenarios = 2
        number_options = 4
        number_time_intervals = 3

        efficiency_dict = {
            (q, k): 0.85
            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,
                static_loss=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,
                validate=True,
            )

            assert arc_tech.has_proportional_losses()

            assert not 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)

            assert arc_tech.has_constant_efficiency()

            # create arc technology with only one option

            arc_tech = Arcs(
                name="any",
                efficiency=efficiency_dict,
                efficiency_reverse=None,
                static_loss=None,
                capacity=(1,),
                minimum_cost=(1,),
                specific_capacity_cost=1,
                capacity_is_instantaneous=capacity_is_instantaneous,
                validate=True,
            )

            assert arc_tech.has_proportional_losses()

            assert not 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)

            assert arc_tech.has_constant_efficiency()

            # create arc technology for one time interval

            arc_tech = Arcs(
                name="any",
                efficiency={(0, 0): 0.95},
                efficiency_reverse=None,
                static_loss=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,
                validate=True,
            )

            assert arc_tech.has_proportional_losses()

            assert not 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)

            assert arc_tech.has_constant_efficiency()

            # create arc technology for one time interval and isotropic

            arc_tech = Arcs(
                name="any",
                efficiency={(0, 0): 0.95},
                efficiency_reverse={(0, 0): 0.95},
                static_loss=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,
                validate=True,
            )

            assert arc_tech.has_proportional_losses()

            assert not 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)

            assert arc_tech.has_constant_efficiency()

            # create arc technology for one time interval and anisotropic

            arc_tech = Arcs(
                name="any",
                efficiency={(0, 0): 0.95},
                efficiency_reverse={(0, 0): 1},
                static_loss=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,
                validate=True,
            )

            assert arc_tech.has_proportional_losses()

            assert not arc_tech.has_static_losses()

            assert not arc_tech.is_infinite_capacity()

            assert not arc_tech.has_been_selected()

            assert not arc_tech.is_isotropic(reverse_none_means_isotropic=True)

            assert not arc_tech.is_isotropic(reverse_none_means_isotropic=False)

            assert not arc_tech.has_constant_efficiency()

            # create arc technology for one time interval and anisotropic

            arc_tech = Arcs(
                name="any",
                efficiency={(0, 0): 1},
                efficiency_reverse={(0, 0): 0.95},
                static_loss=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,
                validate=True,
            )

            assert arc_tech.has_proportional_losses()

            assert not arc_tech.has_static_losses()

            assert not arc_tech.is_infinite_capacity()

            assert not arc_tech.has_been_selected()

            assert not arc_tech.is_isotropic(reverse_none_means_isotropic=True)

            assert not arc_tech.is_isotropic(reverse_none_means_isotropic=False)

            assert not arc_tech.has_constant_efficiency()

            # create arc technology for one time interval and anisotropic

            arc_tech = Arcs(
                name="any",
                efficiency={(0, 0): 0.95},
                efficiency_reverse={(0, 0): 0.95},
                static_loss=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,
                validate=True,
            )

            assert arc_tech.has_proportional_losses()

            assert not 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)

            assert arc_tech.has_constant_efficiency()

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

            # trigger errors

            # TypeError('The name attribute is not hashable.')

            error_triggered = False
            try:
                _ = Arcs(
                    name=[1, 2, 3],
                    efficiency=efficiency_dict,
                    efficiency_reverse=None,
                    static_loss=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,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # TypeError:The efficiency dict keys must be (scenario, interval) tuples

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency={k: 1 for k in range(number_time_intervals)},
                    efficiency_reverse=None,
                    static_loss=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,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError( 'The efficiency dict keys must be tuples of size 2.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency={(k, 3, 4): 1 for k in range(number_time_intervals)},
                    efficiency_reverse=None,
                    static_loss=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,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # TypeError(The efficiency should be given as a dict or None.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=[1 for k in range(number_time_intervals)],
                    efficiency_reverse=None,
                    static_loss=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,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # TypeError('The reverse efficiency has to match the nominal'+
            #     ' one when there are no proportional losses.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=None,
                    efficiency_reverse={},
                    static_loss=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,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # TypeError:'The reverse efficiency should be given as a dict or None.'

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse=[1 for k in range(number_time_intervals)],
                    static_loss=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,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError(
            #     'No efficiency values were provided. There should be '+
            #     'one value per scenario and time interval.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse={},
                    static_loss=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,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # ValueError: The keys for the efficiency dicts do not match.

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse={
                        (key[1], key[0]): value
                        for key, value in efficiency_dict.items()
                    },
                    static_loss=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,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # TypeError: Efficiency values must be provided as numeric types.

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse={
                        (key[0], key[1]): str(value)
                        for key, value in efficiency_dict.items()
                    },
                    static_loss=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,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError('Efficiency values must be positive.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse={
                        (key[0], key[1]): -1 for key, value in efficiency_dict.items()
                    },
                    static_loss=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,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # TypeError('The capacity should be given as a list or tuple.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse=None,
                    static_loss=None,
                    capacity={o: 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,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # TypeError: The minimum cost values should be given as a list or tuple

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse=None,
                    static_loss=None,
                    capacity=tuple(1 + o for o in range(number_options)),
                    minimum_cost={o: 1 + o for o in range(number_options)},
                    specific_capacity_cost=1,
                    capacity_is_instantaneous=capacity_is_instantaneous,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # TypeError: The specific capacity cost was not given as a numeric type

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse=None,
                    static_loss=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,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError:The number of capacity and minimum cost entries must match

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse=None,
                    static_loss=None,
                    capacity=tuple(1 + o for o in range(number_options + 1)),
                    minimum_cost=tuple(1 + o for o in range(number_options)),
                    specific_capacity_cost=1,
                    capacity_is_instantaneous=capacity_is_instantaneous,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # ValueError: No entries for capacity and minimum cost were provided.
            # At least one option should be provided.

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse=None,
                    static_loss=None,
                    capacity=tuple(),
                    minimum_cost=tuple(),
                    specific_capacity_cost=1,
                    capacity_is_instantaneous=capacity_is_instantaneous,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # ValueError: No entries for efficiency were provided. There should be
            # one entry per time interval.

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency={},
                    efficiency_reverse=None,
                    static_loss=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,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # ValueError('The number of efficiency values must match the number of
            # time intervals.')

            arc_tech = Arcs(
                name="hey",
                efficiency={
                    (q, k): 0.85
                    for q in range(number_scenarios)
                    for k in range(number_time_intervals + 1)
                },
                efficiency_reverse=None,
                static_loss=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,
                validate=True,
            )

            error_triggered = False
            try:
                arc_tech.validate_sizes(
                    number_options=number_options,
                    number_scenarios=number_scenarios,
                    number_intervals=[
                        number_time_intervals for _ in range(number_scenarios)
                    ],
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # ValueError('The number of efficiency values must match the number of
            # time intervals.')

            error_triggered = False
            try:
                arc_tech = Arcs(
                    name="hey",
                    efficiency={
                        (q, k): 0.85
                        for q in range(number_scenarios)
                        for k in range(number_time_intervals)
                    },
                    efficiency_reverse={
                        (q, k): 0.85
                        for q in range(number_scenarios)
                        for k in range(number_time_intervals - 1)
                    },
                    static_loss=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,
                    validate=True,
                )
                arc_tech.validate_sizes(
                    number_options=number_options,
                    number_scenarios=number_scenarios,
                    number_intervals=[
                        number_time_intervals for _ in range(number_scenarios)
                    ],
                )
            except ValueError:
                error_triggered = True
            assert error_triggered