test_esipp_problem.py

# imports

# standard
import math

# local
# import numpy as np
# import networkx as nx
import pyomo.environ as pyo

# import src.topupopt.problems.esipp.utils as utils
from src.topupopt.data.misc.utils import generate_pseudo_unique_key
from src.topupopt.problems.esipp.problem import InfrastructurePlanningProblem
from src.topupopt.problems.esipp.network import Arcs, Network
from src.topupopt.problems.esipp.network import ArcsWithoutStaticLosses
from src.topupopt.problems.esipp.resource import ResourcePrice
# from src.topupopt.problems.esipp.utils import compute_cost_volume_metrics
from src.topupopt.problems.esipp.utils import statistics
from src.topupopt.problems.esipp.time import EconomicTimeFrame
# from src.topupopt.problems.esipp.converter import Converter

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

class TestESIPPProblem:
    
    solver = 'glpk'
    # solver = 'scip'
    # solver = 'cbc'
    
    def build_solve_ipp(
        self,
        solver: str = None,
        solver_options: dict = None,
        use_sos_arcs: bool = False,
        arc_sos_weight_key: str = (InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_NONE),
        arc_use_real_variables_if_possible: bool = False,
        use_sos_sense: bool = False,
        sense_sos_weight_key: int = (
            InfrastructurePlanningProblem.SOS1_SENSE_WEIGHT_NOMINAL_HIGHER
        ),
        sense_use_real_variables_if_possible: bool = False,
        sense_use_arc_interfaces: bool = False,
        perform_analysis: bool = False,
        plot_results: bool = False,
        print_solver_output: bool = False,
        time_frame: EconomicTimeFrame = None,
        networks: dict = None,
        converters: dict = None,
        static_losses_mode=None,
        mandatory_arcs: list = None,
        max_number_parallel_arcs: dict = None,
        arc_groups_dict: dict = None,
        init_aux_sets: bool = False,
        # discount_rates: dict = None,
        assessment_weights: dict = None,
        simplify_problem: bool = False,
    ):
        if type(solver) == type(None):
            solver = self.solver
        
        if type(assessment_weights) != dict:
            assessment_weights = {}  # default

        if type(converters) != dict:
            converters = {}
            
        # time weights

        # relative weight of time period

        # one interval twice as long as the average is worth twice
        # one interval half as long as the average is worth half

        # time_weights = [
        #     [time_period_duration/average_time_interval_duration
        #       for time_period_duration in intraperiod_time_interval_duration]
        #     for p in range(number_periods)]

        time_weights = None  # nothing yet

        normalised_time_interval_duration = None  # nothing yet

        # create problem object

        ipp = InfrastructurePlanningProblem(
            # discount_rates=discount_rates,
            time_frame=time_frame,
            # reporting_periods=time_frame.reporting_periods,
            # time_intervals=time_frame.time_interval_durations,
            time_weights=time_weights,
            normalised_time_interval_duration=normalised_time_interval_duration,
            assessment_weights=assessment_weights,
        )

        # add networks and systems

        for netkey, net in networks.items():
            ipp.add_network(network_key=netkey, network=net)

        # add converters

        for cvtkey, cvt in converters.items():
            ipp.add_converter(converter_key=cvtkey, converter=cvt)

        # define arcs as mandatory

        if type(mandatory_arcs) == list:
            for full_arc_key in mandatory_arcs:
                ipp.make_arc_mandatory(full_arc_key[0], full_arc_key[1:])

        # if make_all_arcs_mandatory:

        #     for network_key in ipp.networks:

        #         for arc_key in ipp.networks[network_key].edges(keys=True):

        #             # preexisting arcs are no good

        #             if ipp.networks[network_key].edges[arc_key][
        #                     Network.KEY_ARC_TECH].has_been_selected():

        #                 continue

        #             ipp.make_arc_mandatory(network_key, arc_key)

        # set up the use of sos for arc selection

        if use_sos_arcs:
            for network_key in ipp.networks:
                for arc_key in ipp.networks[network_key].edges(keys=True):
                    if (
                        ipp.networks[network_key]
                        .edges[arc_key][Network.KEY_ARC_TECH]
                        .has_been_selected()
                    ):
                        continue

                    ipp.use_sos1_for_arc_selection(
                        network_key,
                        arc_key,
                        use_real_variables_if_possible=(
                            arc_use_real_variables_if_possible
                        ),
                        sos1_weight_method=arc_sos_weight_key,
                    )

        # set up the use of sos for flow sense determination

        if use_sos_sense:
            for network_key in ipp.networks:
                for arc_key in ipp.networks[network_key].edges(keys=True):
                    if not ipp.networks[network_key].edges[arc_key][
                        Network.KEY_ARC_UND
                    ]:
                        continue

                    ipp.use_sos1_for_flow_senses(
                        network_key,
                        arc_key,
                        use_real_variables_if_possible=(
                            sense_use_real_variables_if_possible
                        ),
                        use_interface_variables=sense_use_arc_interfaces,
                        sos1_weight_method=sense_sos_weight_key,
                    )

        elif sense_use_arc_interfaces:  # set up the use of arc interfaces w/o sos1
            for network_key in ipp.networks:
                for arc_key in ipp.networks[network_key].edges(keys=True):
                    if (
                        ipp.networks[network_key]
                        .edges[arc_key][Network.KEY_ARC_TECH]
                        .has_been_selected()
                    ):
                        continue

                    ipp.use_interface_variables_for_arc_selection(network_key, arc_key)

        # static losses

        if static_losses_mode == ipp.STATIC_LOSS_MODE_ARR:
            ipp.place_static_losses_arrival_node()

        elif static_losses_mode == ipp.STATIC_LOSS_MODE_DEP:
            ipp.place_static_losses_departure_node()

        elif static_losses_mode == ipp.STATIC_LOSS_MODE_US:
            ipp.place_static_losses_upstream()

        elif static_losses_mode == ipp.STATIC_LOSS_MODE_DS:
            ipp.place_static_losses_downstream()

        else:
            raise ValueError("Unknown static loss modelling mode.")

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

        # groups