Ejemplo n.º 1
0
    def test_generic_invest_limit(self):
        """
        """
        bus = solph.Bus(label='bus_1')

        solph.Source(
            label='source_0',
            outputs={
                bus:
                solph.Flow(investment=solph.Investment(ep_costs=50, space=4))
            })

        solph.Source(
            label='source_1',
            outputs={
                bus:
                solph.Flow(investment=solph.Investment(ep_costs=100, space=1))
            })

        solph.Source(label='source_2',
                     outputs={
                         bus:
                         solph.Flow(investment=solph.Investment(ep_costs=75))
                     })

        om = self.get_om()

        om = solph.constraints.additional_investment_flow_limit(om,
                                                                "space",
                                                                limit=20)

        self.compare_lp_files('generic_invest_limit.lp', my_om=om)
Ejemplo n.º 2
0
def source_dispatchable_fix(model, dict_asset, **kwargs):
    r"""
    Defines a dispatchable source with a fixed capacity.

    See :py:func:`~.source` for more information, including parameters.

    Notes
    -----
    Tested with:
    - test_source_dispatchable_fix_normalized_timeseries()
    - test_source_dispatchable_fix_timeseries_not_normalized_timeseries()

    Returns
    -------
    Indirectly updated `model` and dict of asset in `kwargs` with the source object.

    """
    if TIMESERIES_NORMALIZED in dict_asset:
        outputs = {
            kwargs[OEMOF_BUSSES][dict_asset[OUTFLOW_DIRECTION]]:
            solph.Flow(
                label=dict_asset[LABEL],
                max=dict_asset[TIMESERIES_NORMALIZED],
                existing=dict_asset[INSTALLED_CAP][VALUE],
                variable_costs=dict_asset[DISPATCH_PRICE][VALUE],
                # add emission_factor for emission contraint
                emission_factor=dict_asset[EMISSION_FACTOR][VALUE],
            )
        }
        source_dispatchable = solph.Source(
            label=dict_asset[LABEL],
            outputs=outputs,
        )
    else:
        if TIMESERIES in dict_asset:
            logging.info(
                f"Asset {dict_asset[LABEL]} is introduced as a dispatchable source with an availability schedule."
            )
            logging.debug(
                f"The availability schedule is solely introduced because the key {TIMESERIES_NORMALIZED} was not in the asset´s dictionary. \n"
                f"It should only be applied to DSO sources. "
                f"If the asset should not have this behaviour, please create an issue.",
            )
        outputs = {
            kwargs[OEMOF_BUSSES][dict_asset[OUTFLOW_DIRECTION]]:
            solph.Flow(
                label=dict_asset[LABEL],
                existing=dict_asset[INSTALLED_CAP][VALUE],
                variable_costs=dict_asset[DISPATCH_PRICE][VALUE],
            )
        }
        source_dispatchable = solph.Source(
            label=dict_asset[LABEL],
            outputs=outputs,
        )
    model.add(source_dispatchable)
    kwargs[OEMOF_SOURCE].update({dict_asset[LABEL]: source_dispatchable})
    logging.debug(
        f"Added: Dispatchable source {dict_asset[LABEL]} (fixed capacity) to bus {dict_asset[OUTFLOW_DIRECTION]}."
    )
Ejemplo n.º 3
0
 def define_emission_limit():
     bel = solph.Bus(label='electricityBus')
     solph.Source(label='source1', outputs={bel: solph.Flow(
         nominal_value=100, emission=0.8)})
     solph.Source(label='source2', outputs={bel: solph.Flow(
         nominal_value=100)})
     om = self.get_om()
     solph.constraints.emission_limit(om, om.flows, limit=777)
Ejemplo n.º 4
0
 def test_flow_without_emission_for_emission_constraint_no_error(self):
     """
     """
     bel = solph.Bus(label='electricityBus')
     solph.Source(label='source1', outputs={bel: solph.Flow(
         nominal_value=100, emission=0.8)})
     solph.Source(label='source2', outputs={bel: solph.Flow(
         nominal_value=100)})
     om = self.get_om()
     solph.constraints.emission_limit(om, limit=777)
Ejemplo n.º 5
0
def must_run_source(param, data, busses):
    r"""
    Get must run source for Generic Model energy system.

    Parameters
    ----------
    param : dict
        JSON parameter file of user defined constants.

    data : pandas.DataFrame
        csv file of user defined time dependent parameters.

    busses : dict of solph.Bus
        Busses of the energy system.

    Note
    ----
    Must run source uses the following parameters:
    - 'active' is a binary parameter wether is used or not
    - 'type' defines wether it is used constant or time dependent
    - 'op_cost_var' are the variable operational costs in €/MWh
    - 'Q_N' is the constant nominal value in MWh
    - 'Q_MR' is the time series of nominal value in MWh

    Topology
    --------
    Input: none

    Output: High temperature heat network (wnw)
    """
    if param['MR']['active']:
        if param['MR']['type'] == 'constant':
            must_run_source = solph.Source(
                label='Mustrun',
                outputs={
                    busses['wnw']:
                    solph.Flow(variable_costs=param['MR']['op_cost_var'],
                               nominal_value=float(param['MR']['Q_N']),
                               actual_value=1)
                })
            return must_run_source
        elif param['MR']['type'] == 'time series':
            must_run_source = solph.Source(
                label='Mustrun',
                outputs={
                    busses['wnw']:
                    solph.Flow(variable_costs=param['MR']['op_cost_var'],
                               nominal_value=1,
                               actual_value=data['Q_MR'])
                })
            return must_run_source
Ejemplo n.º 6
0
def create_fuel_bus_with_source(nodes, fuel, region, input_data):
    """

    Parameters
    ----------
    nodes
    fuel
    region
    input_data

    Returns
    -------

    """
    fuel = fuel.replace("_", " ")
    cs_data = input_data["commodity sources"].loc[region, fuel]
    bus_label = Label("bus", "commodity", fuel, region)
    if bus_label not in nodes:
        nodes[bus_label] = solph.Bus(label=bus_label)

    cs_label = Label("source", "commodity", fuel, region)

    co2_price = float(input_data["general"]["co2 price"])

    variable_costs = cs_data["emission"] / 1000 * co2_price + cs_data["costs"]

    if cs_data.get("annual limit", float("inf")) != float("inf"):
        if cs_label not in nodes:
            nodes[cs_label] = solph.Source(
                label=cs_label,
                outputs={
                    nodes[bus_label]: solph.Flow(
                        variable_costs=variable_costs,
                        emission=cs_data["emission"],
                        nominal_value=cs_data["annual limit"],
                        summed_max=1,
                    )
                },
            )

    else:
        if cs_label not in nodes:
            nodes[cs_label] = solph.Source(
                label=cs_label,
                outputs={
                    nodes[bus_label]: solph.Flow(
                        variable_costs=variable_costs,
                        emission=cs_data["emission"],
                    )
                },
            )
Ejemplo n.º 7
0
    def test_fixed_source_invest_sink(self):
        """ Wrong constraints for fixed source + invest sink w. `summed_max`.
        """

        bel = solph.Bus(label='electricityBus')

        solph.Source(label='wind',
                     outputs={
                         bel:
                         solph.Flow(actual_value=[12, 16, 14],
                                    nominal_value=1000000,
                                    fixed=True)
                     })

        solph.Sink(label='excess',
                   inputs={
                       bel:
                       solph.Flow(summed_max=2.3,
                                  variable_costs=25,
                                  max=0.8,
                                  investment=solph.Investment(ep_costs=500,
                                                              maximum=10e5,
                                                              existing=50))
                   })

        self.compare_lp_files('fixed_source_invest_sink.lp')
Ejemplo n.º 8
0
def source_non_dispatchable_fix(model, dict_asset, **kwargs):
    r"""
    Defines a non dispatchable source with a fixed capacity.

    See :py:func:`~.source` for more information, including parameters.

    Notes
    -----
    Tested with:
    - test_source_non_dispatchable_fix()

    Returns
    -------
    Indirectly updated `model` and dict of asset in `kwargs` with the source object.

    """
    outputs = {
        kwargs[OEMOF_BUSSES][dict_asset[OUTFLOW_DIRECTION]]:
        solph.Flow(
            label=dict_asset[LABEL],
            fix=dict_asset[TIMESERIES],
            nominal_value=dict_asset[INSTALLED_CAP][VALUE],
            variable_costs=dict_asset[DISPATCH_PRICE][VALUE],
            emission_factor=dict_asset[EMISSION_FACTOR][VALUE],
        )
    }

    source_non_dispatchable = solph.Source(label=dict_asset[LABEL],
                                           outputs=outputs)

    model.add(source_non_dispatchable)
    kwargs[OEMOF_SOURCE].update({dict_asset[LABEL]: source_non_dispatchable})
    logging.debug(
        f"Added: Non-dispatchable source {dict_asset[LABEL]} (fixed capacity) to bus {dict_asset[OUTFLOW_DIRECTION]}.",
    )
Ejemplo n.º 9
0
def gas_source(param, busses):
    r"""
    Get gas source for Generic Model energy system.

    Parameters
    ----------
    param : dict
        JSON parameter file of user defined constants.

    busses : dict of solph.Bus
        Busses of the energy system.

    Note
    ----
    Gas source uses the following parameters:
    - 'gas_price' is the constant price of gas in €/MWh
    - 'co2_price' is the constant price of caused emissions in €/t_co2
    - 'ef_gas' is the constant emission factor of gas in t_co2/MWh

    Topology
    --------
    Input: none

    Output: Gas network (gnw)
    """
    gas_source = solph.Source(
        label='Gasquelle',
        outputs={
            busses['gnw']:
            solph.Flow(variable_costs=(
                param['param']['gas_price'] +
                (param['param']['co2_price'] * param['param']['ef_gas'])))
        })
    return gas_source
Ejemplo n.º 10
0
    def test_equate_variables_constraint(self):
        """Testing the equate_variables function in the constraint module."""
        bus1 = solph.Bus(label='Bus1')
        storage = solph.components.GenericStorage(
            label='storage_constraint',
            invest_relation_input_capacity=0.2,
            invest_relation_output_capacity=0.2,
            inputs={bus1: solph.Flow()},
            outputs={bus1: solph.Flow()},
            investment=solph.Investment(ep_costs=145))
        sink = solph.Sink(
            label='Sink',
            inputs={
                bus1: solph.Flow(investment=solph.Investment(ep_costs=500))
            })
        source = solph.Source(
            label='Source',
            outputs={
                bus1: solph.Flow(investment=solph.Investment(ep_costs=123))
            })
        om = self.get_om()
        solph.constraints.equate_variables(
            om, om.InvestmentFlow.invest[source, bus1],
            om.InvestmentFlow.invest[bus1, sink], 2)
        solph.constraints.equate_variables(
            om, om.InvestmentFlow.invest[source, bus1],
            om.GenericInvestmentStorageBlock.invest[storage])

        self.compare_lp_files('connect_investment.lp', my_om=om)
Ejemplo n.º 11
0
    def test_investment_flow_grouping(self):
        """ Flows of investment sink should be grouped.

        The constraint tests uncovered a spurious error where the flows of an
        investment `Sink` where not put into the `InvestmentFlow` group,
        although the corresponding grouping was present in the energy system.
        The error occured in the case where the investment `Sink` was not
        instantiated directly after the `Bus` it is connected to.

        This test recreates this error scenario and makes sure that the
        `InvestmentFlow` group is not empty.
        """

        b = solph.Bus(label='Bus')

        solph.Source(label='Source', outputs={b: solph.Flow(
            actual_value=[12, 16, 14], nominal_value=1000000,
            fixed=True)})

        solph.Sink(label='Sink', inputs={b: solph.Flow(
            summed_max=2.3, variable_costs=25, max=0.8,
            investment=Investment(ep_costs=500, maximum=10e5))})

        ok_(self.es.groups.get(IF),
            ("Expected InvestmentFlow group to be nonempty.\n" +
             "Got: {}").format(self.es.groups.get(IF)))
Ejemplo n.º 12
0
def check_oemof_installation(silent=False):
    date_time_index = pd.date_range('1/1/2012', periods=5, freq='H')

    energysystem = solph.EnergySystem(timeindex=date_time_index)

    bgas = solph.Bus(label="natural_gas")
    bel = solph.Bus(label="electricity")
    solph.Sink(label='excess_bel', inputs={bel: solph.Flow()})
    solph.Source(label='rgas', outputs={bgas: solph.Flow()})
    solph.Sink(label='demand', inputs={bel: solph.Flow(
        actual_value=[10, 20, 30, 40, 50], fixed=True, nominal_value=1)})
    solph.Transformer(
        label="pp_gas",
        inputs={bgas: solph.Flow()},
        outputs={bel: solph.Flow(nominal_value=10e10, variable_costs=50)},
        conversion_factors={bel: 0.58})
    om = solph.Model(energysystem)

    # check solvers
    solver = dict()
    for s in ['cbc', 'glpk', 'gurobi', 'cplex']:
        try:
            om.solve(solver=s)
            solver[s] = "working"
        except Exception:
            solver[s] = "not working"

    if not silent:
        print("*********")
        print('Solver installed with oemof:')
        for s, t in solver.items():
            print("{0}: {1}".format(s, t))
        print("*********")
        print("oemof successfully installed.")
Ejemplo n.º 13
0
def add_sources(it, labels, gd, nodes, busd):

    for i, cs in it.iterrows():
        labels['l_3'] = 'source'

        if cs['active']:
            labels['l_2'] = cs['label_2']
            outflow_args = {}

            if cs['cost_series']:
                print('error: noch nicht angepasst!')

            else:
                outflow_args['variable_costs'] = cs['variable costs']

            nodes.append(
                solph.Source(
                    label=oh.Label(labels['l_1'], labels['l_2'], labels['l_3'],
                                   labels['l_4']),
                    outputs={
                        busd[(labels['l_1'], cs['label_2'], 'bus', labels['l_4'])]:
                        solph.Flow(**outflow_args)
                    }))

    return nodes, busd
Ejemplo n.º 14
0
    def test_nominal_value_to_zero(self):
        """If the nominal value is set to zero nothing should happen.
        """
        bel = solph.Bus(label='electricityBus')

        solph.Source(label='s1', outputs={bel: solph.Flow(nominal_value=0)})
        self.compare_lp_files('nominal_value_to_zero.lp')
Ejemplo n.º 15
0
 def create_oemof_model(self, busses, _):
     from_grid = solph.Source(label=self.name,
                              outputs={
                                  busses[self.bus_out]:
                                  solph.Flow(nominal_value=self.power_max,
                                             variable_costs=self.current_ac)
                              })
     return from_grid
Ejemplo n.º 16
0
def test_special():
    date_time_index = pd.date_range('1/1/2012', periods=5, freq='H')
    energysystem = solph.EnergySystem(timeindex=date_time_index)
    bel = solph.Bus(label='electricityBus')
    flow1 = solph.Flow(nominal_value=100, my_factor=0.8)
    flow2 = solph.Flow(nominal_value=50)
    src1 = solph.Source(label='source1', outputs={bel: flow1})
    src2 = solph.Source(label='source2', outputs={bel: flow2})
    energysystem.add(bel, src1, src2)
    model = solph.Model(energysystem)
    flow_with_keyword = {
        (src1, bel): flow1,
    }
    solph.constraints.generic_integral_limit(model,
                                             "my_factor",
                                             flow_with_keyword,
                                             limit=777)
Ejemplo n.º 17
0
    def test_flow_count_limit(self):
        """
        """
        bel = solph.Bus(label='electricityBus')

        solph.Source(label='source1',
                     outputs={
                         bel:
                         solph.Flow(nonconvex=solph.NonConvex(),
                                    nominal_value=100,
                                    emission_factor=[0.5, -1.0, 2.0])
                     })
        solph.Source(label='source2',
                     outputs={
                         bel:
                         solph.Flow(nonconvex=solph.NonConvex(),
                                    nominal_value=100,
                                    emission_factor=3.5)
                     })

        # Should be ignored because emission_factor is not defined.
        solph.Source(label='source3',
                     outputs={
                         bel:
                         solph.Flow(nonconvex=solph.NonConvex(),
                                    nominal_value=100)
                     })

        # Should be ignored because it is not NonConvex.
        solph.Source(label='source4',
                     outputs={
                         bel:
                         solph.Flow(emission_factor=1.5,
                                    min=0.3,
                                    nominal_value=100)
                     })

        om = self.get_om()

        # one of the two flows has to be active
        solph.constraints.limit_active_flow_count_by_keyword(om,
                                                             "emission_factor",
                                                             lower_limit=1,
                                                             upper_limit=2)

        self.compare_lp_files('flow_count_limit.lp', my_om=om)
Ejemplo n.º 18
0
def test_that_the_solph_source_warnings_actually_get_raised():
    """ Source doesn't warn about potentially erroneous usage.
    """
    look_out = network.Bus()
    msg = "`Source` 'solph_sink' constructed without `outputs`."
    with warnings.catch_warnings(record=True) as w:
        solph.Source(label="solph_sink", inputs={look_out: "A typo!"})
        ok_(len(w) == 1)
        eq_(msg, str(w[-1].message))
Ejemplo n.º 19
0
    def test_emission_constraints(self):
        """
        """
        bel = solph.Bus(label='electricityBus')

        solph.Source(label='source1', outputs={bel: solph.Flow(
            nominal_value=100, emission=0.5)})
        solph.Source(label='source2', outputs={bel: solph.Flow(
            nominal_value=100, emission=0.8)})

        # Should be ignored because the emission attribute is not defined.
        solph.Source(label='source3', outputs={bel: solph.Flow(
            nominal_value=100)})

        om = self.get_om()

        solph.constraints.emission_limit(om, limit=777)

        self.compare_lp_files('emission_limit.lp', my_om=om)
Ejemplo n.º 20
0
 def create_oemof_model(self, busses, _):
     energy_source_from_csv = solph.Source(
         label=self.name,
         outputs={
             busses[self.bus_out]:
             solph.Flow(
                 actual_value=self.data.iloc[self.sim_params.i_interval],
                 nominal_value=self.nominal_value,
                 fixed=True)
         })
     return energy_source_from_csv
Ejemplo n.º 21
0
    def test_gradient(self):
        """
        """
        bel = solph.Bus(label='electricityBus')

        solph.Source(label='powerplant', outputs={bel: solph.Flow(
            nominal_value=999, variable_costs=23,
            positive_gradient={'ub': 0.03, 'costs': 7},
            negative_gradient={'ub': 0.05, 'costs': 8})})

        self.compare_lp_files('source_with_gradient.lp')
Ejemplo n.º 22
0
def run_model(params, wind_invest=False, pv_invest=False, storage_invest=False):
    logging.info('Initialize the energy system')
    energysystem = solph.EnergySystem(timeindex=date_time_index)
    Node.registry = energysystem
    logging.info('Create oemof objects')
    bgas = solph.Bus(label="natural_gas")
    bel = solph.Bus(label="electricity")

    solph.Sink(label='excess_bel', inputs={bel: solph.Flow()})

    solph.Source(label='rgas', outputs={bgas: solph.Flow(nominal_value=params['rgas_nom_val'],
                                                         summed_max=1)})

    solph.Source(label='wind', outputs={bel: solph.Flow(
            actual_value=data['wind'], nominal_value=params['wind_nom_val'], fixed=True)})

    solph.Source(label='pv', outputs={bel: solph.Flow(
           actual_value=data['pv'], nominal_value=params['pv_nom_val'], fixed=True)})

    solph.Sink(label='demand', inputs={bel: solph.Flow(
        actual_value=data['demand_el'], fixed=True, nominal_value=1)})

    solph.Transformer(
        label="pp_gas",
        inputs={bgas: solph.Flow()},
        outputs={bel: solph.Flow(nominal_value=10e10, variable_costs=50)},
        conversion_factors={bel: 0.58})


    logging.info('Optimise the energy system')

    om = solph.Model(energysystem)

    logging.info('Solve the optimization problem')
    om.solve(solver='cbc')

    energysystem.results['main'] = processing.convert_keys_to_strings(processing.results(om))
    energysystem.results['param'] = processing.convert_keys_to_strings(processing.param_results(energysystem))


    return energysystem, om
Ejemplo n.º 23
0
    def test_fixed_source_variable_sink(self):
        """Constraint test with a fixed source and a variable sink.
        """

        bel = solph.Bus(label='electricityBus')

        solph.Source(label='wind', outputs={bel: solph.Flow(
            actual_value=[.43, .72, .29], nominal_value=10e5, fixed=True)})

        solph.Sink(label='excess', inputs={bel: solph.Flow(variable_costs=40)})

        self.compare_lp_files('fixed_source_variable_sink.lp')
Ejemplo n.º 24
0
    def test_max_source_min_sink(self):
        """
        """
        bel = solph.Bus(label='electricityBus')

        solph.Source(label='wind', outputs={
            bel: solph.Flow(nominal_value=54, max=(.85, .95, .61))})

        solph.Sink(label='minDemand', inputs={bel: solph.Flow(
            nominal_value=54, min=(.84, .94, .59), variable_costs=14)})

        self.compare_lp_files('max_source_min_sink.lp')
Ejemplo n.º 25
0
def source_non_dispatchable_optimize(model, dict_asset, **kwargs):
    r"""
    Defines a non dispatchable source with a capacity to be optimized.

    See :py:func:`~.source` for more information, including parameters.

    Notes
    -----
    Tested with:
    - test_source_non_dispatchable_optimize()

    Returns
    -------
    Indirectly updated `model` and dict of asset in `kwargs` with the source object.

    """
    if MAXIMUM_ADD_CAP_NORMALIZED in dict_asset:
        maximum = dict_asset[MAXIMUM_ADD_CAP_NORMALIZED][VALUE]
    else:
        maximum = dict_asset[MAXIMUM_ADD_CAP][VALUE]
    if INSTALLED_CAP_NORMALIZED in dict_asset:
        existing = dict_asset[INSTALLED_CAP_NORMALIZED][VALUE]
    else:
        existing = dict_asset[INSTALLED_CAP][VALUE]
    outputs = {
        kwargs[OEMOF_BUSSES][dict_asset[OUTFLOW_DIRECTION]]:
        solph.Flow(
            label=dict_asset[LABEL],
            fix=dict_asset[TIMESERIES_NORMALIZED],
            investment=solph.Investment(
                ep_costs=dict_asset[SIMULATION_ANNUITY][VALUE] /
                dict_asset[TIMESERIES_PEAK][VALUE],
                maximum=maximum,
                existing=existing,
            ),
            # variable_costs are devided by time series peak as normalized time series are used as actual_value
            variable_costs=dict_asset[DISPATCH_PRICE][VALUE] /
            dict_asset[TIMESERIES_PEAK][VALUE],
            # add emission_factor for emission contraint
            emission_factor=dict_asset[EMISSION_FACTOR][VALUE],
        )
    }

    source_non_dispatchable = solph.Source(label=dict_asset[LABEL],
                                           outputs=outputs)

    model.add(source_non_dispatchable)
    kwargs[OEMOF_SOURCE].update({dict_asset[LABEL]: source_non_dispatchable})
    logging.debug(
        f"Added: Non-dispatchable source {dict_asset[LABEL]} (capacity to be optimized) to bus {dict_asset[OUTFLOW_DIRECTION]}."
    )
Ejemplo n.º 26
0
def test_optimal_solution():
    es = solph.EnergySystem(timeindex=[1])
    bel = solph.Bus(label='bus')
    es.add(bel)
    es.add(
        solph.Sink(
            inputs={
                bel: solph.Flow(nominal_value=5, actual_value=[1], fixed=True)
            }))
    es.add(solph.Source(outputs={bel: solph.Flow(variable_costs=5)}))
    m = solph.models.Model(es, timeincrement=1)
    m.solve('cbc')
    m.results()
    outputlib.processing.meta_results(m)
Ejemplo n.º 27
0
def add_buses(it, labels, nodes, busd):
    """
    :param it:  pd.Dataframe containing tabular information for the creation of
                buses
    :param labels: dict of label strings
    :return:
    """

    for i, b in it.iterrows():

        labels['l_3'] = 'bus'

        if b['active']:
            labels['l_2'] = b['label_2']
            l_bus = oh.Label(labels['l_1'], labels['l_2'], labels['l_3'],
                             labels['l_4'])

            # check if bus already exists (due to infrastructure)
            if l_bus in busd:
                print('bus bereits vorhanden:', l_bus)

            else:
                bus = solph.Bus(label=l_bus)
                nodes.append(bus)

                busd[l_bus] = bus

                if b['excess']:
                    labels['l_3'] = 'excess'
                    nodes.append(
                        solph.Sink(
                            label=oh.Label(labels['l_1'], labels['l_2'],
                                           labels['l_3'], labels['l_4']),
                            inputs={
                                busd[l_bus]:
                                solph.Flow(variable_costs=b['excess costs'])
                            }))

                if b['shortage']:
                    labels['l_3'] = 'shortage'
                    nodes.append(
                        solph.Source(
                            label=oh.Label(labels['l_1'], labels['l_2'],
                                           labels['l_3'], labels['l_4']),
                            outputs={
                                busd[l_bus]:
                                solph.Flow(variable_costs=b['shortage costs'])
                            }))

    return nodes, busd
Ejemplo n.º 28
0
 def test_maximum_shutdowns(self):
     """Testing maximum_shutdowns attribute for nonconvex flows."""
     bus_t = solph.Bus(label='Bus_C')
     solph.Source(label='cheap_plant_maximum_shutdowns',
                  outputs={
                      bus_t:
                      solph.Flow(
                          nominal_value=10,
                          min=0.5,
                          max=1.0,
                          variable_costs=10,
                          nonconvex=solph.NonConvex(maximum_shutdowns=2))
                  })
     self.compare_lp_files('maximum_shutdowns.lp')
Ejemplo n.º 29
0
    def test_invest_source_fixed_sink(self):
        """Constraint test with a fixed sink and a dispatch invest source.
        """

        bel = solph.Bus(label='electricityBus')

        solph.Source(label='pv', outputs={bel: solph.Flow(
            max=[45, 83, 65], variable_costs=13,
            investment=solph.Investment(ep_costs=123))})

        solph.Sink(label='excess', inputs={bel: solph.Flow(
            actual_value=[.5, .8, .3], nominal_value=10e4, fixed=True)})

        self.compare_lp_files('invest_source_fixed_sink.lp')
Ejemplo n.º 30
0
def add_upstream_import_export_nodes(nodes, bus, costs):
    logging.info("Add upstream prices from {0}".format(costs["name"]))
    exp_label = Label("export", "electricity", "all", bus.label.region)
    nodes[exp_label] = solph.Sink(
        label=exp_label,
        inputs={bus: solph.Flow(variable_costs=costs["export"])},
    )

    imp_label = Label("import", "electricity", "all", bus.label.region)
    nodes[imp_label] = solph.Source(
        label=imp_label,
        outputs={bus: solph.Flow(variable_costs=costs["import"])},
    )
    return nodes