936193449

Build # 936193449

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/oemof/feedinlib/commit/<a class=hub.com/oemof/feedinlib/commit/<a class="double-link" href="https://git"><a class=hub.com/oemof/feedinlib/commit/<a class="double-link" href="https://git"><a class=hub.com/oemof/feedinlib/commit/fe881ced9ed6c84606dc5509bfbcaf16d241925f">fe881ced9<a href="https://github.com/oemof/feedinlib/commit/fe881ced9ed6c84606dc5509bfbcaf16d241925f">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/oemof/feedinlib/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/feedinlib/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/oemof/feedinlib/commit/fe881ced9ed6c84606dc5509bfbcaf16d241925f&quot;&gt;fe881ced9&lt;/a&gt;&lt;a href=&quot;https://github.com/oemof/feedinlib/commit/fe881ced9ed6c84606dc5509bfbcaf16d241925f&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/oemof/feedinlib/commit/fe881ced9ed6c84606dc5509bfbcaf16&lt;/a&gt;d241925f">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/feedinlib/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/feedinlib/commit/<a class="double-link" href="https://github.com/oemof/feedinlib/commit/5d8998770675a7805da33796b2444ecf03fb4e06">5d8998770</a><a href="https://github.com/oemof/feedinlib/commit/fe881ced9ed6c84606dc5509bfbcaf16d241925f">&amp;quot;&amp;gt;5d8998770&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;5d8998770&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/oemof/feedinlib/commit/fe881ced9ed6c84606dc5509bfbcaf16d2419&lt;/a&gt;25f&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/feedinlib/commit/<a class="double-link" href="https://github.com/oemof/feedinlib/commit/f5ef50e84">f5ef50e84">f5ef50e84</a>

Pull Request Pull Request #58: Revise the feedinlib structure following the structure of the other oemof packages

Run Details

102 of 273 branches covered (37.36%)

Branch coverage included in aggregate %.

122 of 122 new or added lines in 12 files covered. (100.0%)

584 of 869 relevant lines covered (67.2%)

1.34 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.27

/tests/test_models.py

from copy import deepcopy

import pandas as pd
import pytest
from pandas.util.testing import assert_frame_equal
from windpowerlib import WindTurbine as WindpowerlibWindTurbine

from feedinlib import GeometricSolar
from feedinlib import Photovoltaic
from feedinlib import Pvlib
from feedinlib import WindpowerlibTurbine
from feedinlib import WindpowerlibTurbineCluster
from feedinlib import WindPowerPlant
from feedinlib.models.geometric_solar import solar_angles


class Fixtures:
    """
    Class providing all fixtures for model tests.
    """

    @pytest.fixture
    def pvlib_weather(self):
        """
        Returns a test weather dataframe to use in tests for pvlib model.
        """
        return pd.DataFrame(
            data={
                "wind_speed": [5.0],
                "temp_air": [10.0],
                "dhi": [150.0],
                "ghi": [300],
            },
            index=pd.date_range("1/1/1970 12:00", periods=1, tz="UTC"),
        )

    @pytest.fixture
    def windpowerlib_weather(self):
        """
        Returns a test weather dataframe to use in tests for windpowerlib
        model.
        """
        return pd.DataFrame(
            data={
                ("wind_speed", 10): [5.0],
                ("temperature", 2): [270.0],
                ("roughness_length", 0): [0.15],
                ("pressure", 0): [98400.0],
            },
            index=pd.date_range("1/1/1970 12:00", periods=1, tz="UTC"),
        )

    @pytest.fixture
    def pvlib_pv_system(self):
        """
        Returns a test PV system setup to use in tests for pvlib model.
        """
        return {
            "module_name": "Yingli_YL210__2008__E__",
            "inverter_name": "ABB__MICRO_0_25_I_OUTD_US_208__208V_",
            "azimuth": 180,
            "tilt": 30,
            "albedo": 0.2,
        }

    @pytest.fixture
    def windpowerlib_turbine(self):
        """
        Returns a test wind power plant to use in tests for windpowerlib model.
        """
        return {"turbine_type": "E-82/3000", "hub_height": 135}

    @pytest.fixture
    def windpowerlib_turbine_2(self):
        """
        Returns a test wind power plant to use in tests for windpowerlib model.
        """
        return {
            "turbine_type": "V90/2000",
            "hub_height": 120,
            "rotor_diameter": 80,
        }

    @pytest.fixture
    def windpowerlib_farm(self, windpowerlib_turbine, windpowerlib_turbine_2):
        """
        Returns a test wind farm to use in tests for windpowerlib model.
        """
        return {
            "wind_turbine_fleet": pd.DataFrame(
                {
                    "wind_turbine": [
                        windpowerlib_turbine,
                        windpowerlib_turbine_2,
                    ],
                    "number_of_turbines": [6, None],
                    "total_capacity": [None, 3 * 2e6],
                }
            )
        }

    @pytest.fixture
    def windpowerlib_farm_2(self, windpowerlib_turbine):
        """
        Returns a test wind farm to use in tests for windpowerlib model.
        """
        return {
            "wind_turbine_fleet": [
                WindpowerlibWindTurbine(**windpowerlib_turbine).to_group(1)
            ]
        }

    @pytest.fixture
    def windpowerlib_farm_3(
        self, windpowerlib_turbine, windpowerlib_turbine_2
    ):
        """
        Returns a test wind farm to use in tests for windpowerlib model.
        """

        return {
            "wind_turbine_fleet": pd.DataFrame(
                {
                    "wind_turbine": [
                        WindPowerPlant(**windpowerlib_turbine),
                        WindPowerPlant(**windpowerlib_turbine_2),
                    ],
                    "number_of_turbines": [6, 3],
                }
            )
        }

    @pytest.fixture
    def windpowerlib_turbine_cluster(
        self, windpowerlib_farm, windpowerlib_farm_2
    ):
        """
        Returns a test wind turbine cluster to use in tests for windpowerlib
        model.
        """
        return {"wind_farms": [windpowerlib_farm, windpowerlib_farm_2]}


class TestPowerplants(Fixtures):
    """
    Class to test some basic functionalities of the power plant classes.
    """

    def test_powerplant_requirements(self, pvlib_pv_system, pvlib_weather):
        """
        Test that attribute error is not raised in case a valid model is
        specified when calling feedin method.
        """
        test_module = Photovoltaic(**pvlib_pv_system)
        feedin = test_module.feedin(
            weather=pvlib_weather, model=Pvlib, location=(52, 13)
        )
        assert 143.39361 == pytest.approx(feedin.values[0], 1e-5)

    def test_powerplant_requirements_2(self, pvlib_pv_system, pvlib_weather):
        """
        Test that attribute error is raised in case required power plant
        parameters are missing when feedin is called with a different model
        than initially specified.
        """
        test_module = Photovoltaic(**pvlib_pv_system)
        msg = "The specified model 'windpowerlib_single_turbine' requires"
        with pytest.raises(AttributeError, match=msg):
            test_module.feedin(
                weather=pvlib_weather,
                model=WindpowerlibTurbine,
                location=(52, 13),
            )

    def test_pv_feedin_scaling(self, pvlib_pv_system, pvlib_weather):
        """
        Test that PV feedin timeseries are scaled correctly.
        """
        test_module = Photovoltaic(**pvlib_pv_system)
        feedin = test_module.feedin(
            weather=pvlib_weather, location=(52, 13), scaling="peak_power"
        )
        assert 0.67511 == pytest.approx(feedin.values[0], 1e-5)
        feedin = test_module.feedin(
            weather=pvlib_weather, location=(52, 13), scaling="area"
        )
        assert 84.34918 == pytest.approx(feedin.values[0], 1e-5)

    def test_wind_feedin_scaling(
        self, windpowerlib_turbine, windpowerlib_weather
    ):
        """
        Test that wind feedin timeseries are scaled correctly.
        """
        test_turbine = WindPowerPlant(**windpowerlib_turbine)
        feedin = test_turbine.feedin(
            weather=windpowerlib_weather, scaling="nominal_power"
        )
        assert 833050.32551 / 3e6 == pytest.approx(feedin.values[0], 1e-5)


class TestGeometricSolar(Fixtures):
    """
    Class to test GeometricSolar model and functions it depends on.
    """

    def test_geometric_angles(self):
        # c.f. example 1.6.1 from DB13
        incidence_0, _ = solar_angles(
            datetime=pd.date_range("1970-02-13 10:30", periods=1, tz="UTC"),
            surface_azimuth=15,
            tilt=45,
            latitude=43,
            longitude=0,
        )
        assert incidence_0 == pytest.approx(0.7838, 1e-4)

        plant1 = GeometricSolar(
            tilt=0, azimuth=0, longitude=0, latitude=0, system_efficiency=1
        )
        incidence_a, solar_zenith_a = plant1.solar_angles(
            datetime=pd.date_range(
                "3/20/2017 09:00", periods=12, freq="0.5H", tz="UTC"
            )
        )
        # For tilt=0, both angles are the same (by day).
        assert incidence_a == pytest.approx(solar_zenith_a)

        plant2 = GeometricSolar(
            tilt=180, azimuth=0, longitude=180, latitude=0, system_efficiency=1
        )
        incidence_b, solar_zenith_b = plant2.solar_angles(
            datetime=pd.date_range(
                "3/20/2017 09:00", periods=12, freq="0.5H", tz="UTC"
            )
        )
        # Zenith angles at other side of the world are inverted.
        assert solar_zenith_a == pytest.approx(-solar_zenith_b, 1e-5)

        # Blocking by the horizon is not considered for angle calculation.
        # Thus, incidence for a collector facing down at
        # the opposite side of the world are the same.
        assert incidence_a == pytest.approx(incidence_b, 1e-5)

    def test_geometric_radiation(self):
        # For calculation of radiation, direct radiation is blocked at night.
        # So if there is neither reflection (albedo) nor diffuse radiation,
        # total radiation should be 0.
        plant3 = GeometricSolar(
            tilt=60,
            azimuth=0,
            latitude=40,
            longitude=0,
            system_efficiency=0.9,
            albedo=0,
            nominal_peak_power=300,
        )

        data_weather_night = pd.DataFrame(
            data={
                "wind_speed": [0],
                "temp_air": [25],
                "dni": [100],
                "dhi": [0],
            },
            index=pd.date_range(
                "1970-01-01 00:00:00", periods=1, freq="h", tz="UTC"
            ),
        )

        assert plant3.geometric_radiation(data_weather_night)[
            0
        ] == pytest.approx(0, 1e-5)
        assert plant3.feedin(data_weather_night)[0] == pytest.approx(0, 1e-5)

        # c.f. example 1.16.1 from DB13
        plant4 = GeometricSolar(
            tilt=60,
            azimuth=0,
            latitude=40,
            longitude=0,
            system_efficiency=0.9,
            albedo=0.6,
            nominal_peak_power=300,
        )

        data_weather_test = pd.DataFrame(
            data={
                "wind_speed": [0],
                "temp_air": [25],
                "dni": [67.8],
                "dhi": [221.1],
            },
            index=pd.date_range(
                "1970-02-20 09:43:44", periods=1, freq="h", tz="UTC"
            ),
        )

        assert plant4.geometric_radiation(data_weather_test)[
            0
        ] == pytest.approx(302.86103, 1e-5)

        # extra test for feedin
        assert plant4.feedin(data_weather_test)[0] == pytest.approx(
            78.67677, 1e-5
        )

        # check giving same weather with temperature in Kelvin
        data_weather_kelvin = pd.DataFrame(
            data={
                "wind_speed": [0],
                "temperature": [25 + 273.15],
                "dni": [67.8],
                "dhi": [221.1],
            },
            index=pd.date_range(
                "1970-02-20 09:43:44", periods=1, freq="h", tz="UTC"
            ),
        )

        assert (
            plant4.feedin(data_weather_test)[0]
            == plant4.feedin(data_weather_kelvin)[0]
        )

        # check if problematic data (dhi > ghi) is detected
        erroneous_weather = pd.DataFrame(
            data={
                "wind_speed": [5.0],
                "temp_air": [10.0],
                "dhi": [500],
                "ghi": [300],
            },
            index=pd.date_range(
                "1/1/1970 12:00", periods=1, freq="H", tz="UTC"
            ),
        )

        with pytest.raises(ValueError):
            assert plant4.feedin(weather=erroneous_weather)

    def test_pvlib_feedin(self, pvlib_weather):
        test_module = GeometricSolar(
            tilt=60,
            azimuth=0,
            latitude=52,
            longitude=13,
            system_efficiency=0.9,
            albedo=0.6,
            nominal_peak_power=210,
        )
        feedin = test_module.feedin(weather=pvlib_weather, location=(52, 0))

        assert 214.225104 == pytest.approx(feedin.values[0], 1e-5)


class TestPvlib(Fixtures):
    """
    Class to test Pvlib model.
    """

    def test_pvlib_feedin(self, pvlib_pv_system, pvlib_weather):
        """
        Test basic feedin calculation using pvlib.
        It is also tested if dictionary with PV system parameters remains the
        same to make sure it could be further used to calculate feed-in with
        a different model.
        """
        test_copy = deepcopy(pvlib_pv_system)
        test_module = Photovoltaic(**pvlib_pv_system)
        feedin = test_module.feedin(weather=pvlib_weather, location=(52, 13))
        assert 143.39361 == pytest.approx(feedin.values[0], 1e-5)
        assert test_copy == pvlib_pv_system

    def test_pvlib_feedin_with_surface_type(
        self, pvlib_pv_system, pvlib_weather
    ):
        """
        Test basic feedin calculation using pvlib and providing surface type
        instead of albedo.
        """
        del pvlib_pv_system["albedo"]
        pvlib_pv_system["surface_type"] = "grass"
        test_module = Photovoltaic(**pvlib_pv_system)
        feedin = test_module.feedin(weather=pvlib_weather, location=(52, 13))
        assert 143.39361 == pytest.approx(feedin.values[0], 1e-5)

    def test_pvlib_feedin_with_optional_pp_parameter(
        self, pvlib_pv_system, pvlib_weather
    ):
        """
        Test basic feedin calculation using pvlib and providing an optional
        PV system parameter.
        """
        pvlib_pv_system["strings_per_inverter"] = 2
        test_module = Photovoltaic(**pvlib_pv_system)
        feedin = test_module.feedin(weather=pvlib_weather, location=(52, 13))
        # power output is in this case limited by the inverter, which is why
        # power output with 2 strings is not twice as high as power output of
        # one string
        assert 250.0 == pytest.approx(feedin.values[0], 1e-5)

    def test_pvlib_feedin_with_optional_model_parameters(
        self, pvlib_pv_system, pvlib_weather
    ):
        """
        Test basic feedin calculation using pvlib and providing an optional
        PV system parameter.
        """
        pvlib_pv_system["strings_per_inverter"] = 2
        test_module = Photovoltaic(**pvlib_pv_system)
        feedin = test_module.feedin(
            weather=pvlib_weather, location=(52, 13), mode="dc"
        )
        # power output is in this case limited by the inverter, which is why
        # power output with 2 strings is not twice as high as power output of
        # one string
        assert 298.27921 == pytest.approx(feedin.values[0], 1e-5)

    def test_pvlib_missing_powerplant_parameter(self, pvlib_pv_system):
        """
        Test if initialization of powerplant fails in case of missing power
        plant parameter.
        """
        del pvlib_pv_system["albedo"]
        msg = "The specified model 'pvlib' requires"
        with pytest.raises(AttributeError, match=msg):
            Photovoltaic(**pvlib_pv_system)


class TestWindpowerlibSingleTurbine(Fixtures):
    """
    Class to test WindpowerlibTurbine model.
    """

    def test_windpowerlib_single_turbine_feedin(
        self, windpowerlib_turbine, windpowerlib_weather
    ):
        """
        Test basic feedin calculation using windpowerlib single turbine.
        It is also tested if dictionary with turbine parameters remains the
        same to make sure it could be further used to calculate feed-in with
        a different model.
        """
        test_copy = deepcopy(windpowerlib_turbine)
        test_turbine = WindPowerPlant(**windpowerlib_turbine)
        feedin = test_turbine.feedin(weather=windpowerlib_weather)
        assert 833050.32551 == pytest.approx(feedin.values[0], 1e-5)
        assert test_copy == windpowerlib_turbine

    def test_windpowerlib_single_turbine_feedin_with_optional_pp_parameter(
        self, windpowerlib_turbine, windpowerlib_weather
    ):
        """
        Test basic feedin calculation using windpowerlib single turbine and
        using optional parameters for power plant and modelchain.
        """
        windpowerlib_turbine["rotor_diameter"] = 82
        test_turbine = WindPowerPlant(**windpowerlib_turbine)
        feedin = test_turbine.feedin(
            weather=windpowerlib_weather,
            power_output_model="power_coefficient_curve",
        )
        assert 847665.85209 == pytest.approx(feedin.values[0], 1e-5)

    def test_windpowerlib_missing_powerplant_parameter(
        self, windpowerlib_turbine
    ):
        """
        Test if initialization of powerplant fails in case of missing power
        plant parameter.
        """
        del windpowerlib_turbine["turbine_type"]
        msg = "The specified model 'windpowerlib_single_turbine' requires"
        with pytest.raises(AttributeError, match=msg):
            WindPowerPlant(**windpowerlib_turbine)


class TestWindpowerlibCluster(Fixtures):
    """
    Class to test WindpowerlibTurbineCluster model.
    """

    def test_windpowerlib_windfarm_feedin(
        self, windpowerlib_farm, windpowerlib_weather
    ):
        """
        Test basic feedin calculation using windpowerlib wind turbine cluster
        modelchain for a wind farm where wind turbine data is provided in a
        dictionary.
        It is also tested if dataframe with wind turbine fleet remains the
        same to make sure it could be further used to calculate feed-in with
        a different model.
        """
        test_copy = deepcopy(windpowerlib_farm)
        farm = WindPowerPlant(
            **windpowerlib_farm, model=WindpowerlibTurbineCluster
        )
        feedin = farm.feedin(
            weather=windpowerlib_weather, wake_losses_model=None
        )
        assert 7658841.386277 == pytest.approx(feedin.values[0], 1e-5)
        assert_frame_equal(
            test_copy["wind_turbine_fleet"],
            windpowerlib_farm["wind_turbine_fleet"],
        )

    @pytest.mark.skip(reason="We have to fix the circular import to use a"
                             "feedinlib WindPowerPlant object in clusters.")
    def test_windpowerlib_windfarm_feedin_2(
        self, windpowerlib_farm_3, windpowerlib_weather
    ):
        """
        Test basic feedin calculation using windpowerlib wind turbine cluster
        modelchain for a wind farm where wind turbines are provided as
        feedinlib WindPowerPlant objects.
        It is also tested if dataframe with wind turbine fleet remains the
        same to make sure it could be further used to calculate feed-in with
        a different model.
        """
        test_copy = deepcopy(windpowerlib_farm_3)
        farm = WindPowerPlant(
            **windpowerlib_farm_3, model=WindpowerlibTurbineCluster
        )
        feedin = farm.feedin(
            weather=windpowerlib_weather, wake_losses_model=None
        )
        assert 7658841.386277 == pytest.approx(feedin.values[0], 1e-5)
        assert_frame_equal(
            test_copy["wind_turbine_fleet"],
            windpowerlib_farm_3["wind_turbine_fleet"],
        )

    def test_windpowerlib_turbine_cluster_feedin(
        self, windpowerlib_turbine_cluster, windpowerlib_weather
    ):
        """
        Test basic feedin calculation using windpowerlib wind turbine cluster
        modelchain for a wind turbine cluster.
        """
        test_cluster = WindPowerPlant(
            **windpowerlib_turbine_cluster, model=WindpowerlibTurbineCluster
        )
        feedin = test_cluster.feedin(weather=windpowerlib_weather)
        assert 7285008.02048 == pytest.approx(feedin.values[0], 1e-5)

    def test_windpowerlib_windfarm_feedin_with_optional_parameters(
        self, windpowerlib_farm, windpowerlib_weather
    ):
        """
        Test basic feedin calculation using windpowerlib wind turbine cluster
        modelchain and supplying an optional power plant and modelchain
        parameter.
        """

        # test optional parameter
        test_farm = windpowerlib_farm
        test_farm["efficiency"] = 0.9
        farm = WindPowerPlant(**test_farm, model=WindpowerlibTurbineCluster)
        feedin = farm.feedin(
            weather=windpowerlib_weather,
            wake_losses_model="wind_farm_efficiency",
        )
        assert 6892957.24764 == pytest.approx(feedin.values[0], 1e-5)

    def test_windpowerlib_turbine_equals_windfarm(
        self, windpowerlib_turbine, windpowerlib_farm_2, windpowerlib_weather
    ):
        """
        Test if wind turbine feedin calculation yields the same as wind farm
        calculation with one turbine.
        """
        # turbine feedin
        test_turbine = WindPowerPlant(**windpowerlib_turbine)
        feedin = test_turbine.feedin(weather=windpowerlib_weather)
        # farm feedin
        test_farm = WindPowerPlant(
            **windpowerlib_farm_2, model=WindpowerlibTurbineCluster
        )
        feedin_farm = test_farm.feedin(
            weather=windpowerlib_weather, wake_losses_model=None
        )
        assert feedin.values[0] == pytest.approx(feedin_farm.values[0], 1e-5)

    def test_windpowerlib_windfarm_equals_cluster(
        self, windpowerlib_farm, windpowerlib_weather
    ):
        """
        Test if windfarm feedin calculation yields the same as turbine cluster
        calculation with one wind farm.
        """
        # farm feedin
        test_farm = WindPowerPlant(
            **windpowerlib_farm, model=WindpowerlibTurbineCluster
        )
        feedin_farm = test_farm.feedin(weather=windpowerlib_weather)
        # turbine cluster
        test_cluster = {"wind_farms": [windpowerlib_farm]}
        test_cluster = WindPowerPlant(
            **test_cluster, model=WindpowerlibTurbineCluster
        )
        feedin_cluster = test_cluster.feedin(weather=windpowerlib_weather)
        assert feedin_farm.values[0] == pytest.approx(
            feedin_cluster.values[0], 1e-5
        )

1	from copy import deepcopy	2✔
2
3	import pandas as pd	2✔
4	import pytest	2✔
5	from pandas.util.testing import assert_frame_equal	2✔
6	from windpowerlib import WindTurbine as WindpowerlibWindTurbine	2✔
7
8	from feedinlib import GeometricSolar	2✔
9	from feedinlib import Photovoltaic	2✔
10	from feedinlib import Pvlib	2✔
11	from feedinlib import WindpowerlibTurbine	2✔
12	from feedinlib import WindpowerlibTurbineCluster	2✔
13	from feedinlib import WindPowerPlant	2✔
14	from feedinlib.models.geometric_solar import solar_angles	2✔
15
16
17	class Fixtures:	2✔
18	"""
19	Class providing all fixtures for model tests.
20	"""
21
22	@pytest.fixture	2✔
23	def pvlib_weather(self):	1✔
24	"""
25	Returns a test weather dataframe to use in tests for pvlib model.
26	"""
27	return pd.DataFrame(	2✔
28	data={
29	"wind_speed": [5.0],
30	"temp_air": [10.0],
31	"dhi": [150.0],
32	"ghi": [300],
33	},
34	index=pd.date_range("1/1/1970 12:00", periods=1, tz="UTC"),
35	)
36
37	@pytest.fixture	2✔
38	def windpowerlib_weather(self):	1✔
39	"""
40	Returns a test weather dataframe to use in tests for windpowerlib
41	model.
42	"""
43	return pd.DataFrame(	2✔
44	data={
45	("wind_speed", 10): [5.0],
46	("temperature", 2): [270.0],
47	("roughness_length", 0): [0.15],
48	("pressure", 0): [98400.0],
49	},
50	index=pd.date_range("1/1/1970 12:00", periods=1, tz="UTC"),
51	)
52
53	@pytest.fixture	2✔
54	def pvlib_pv_system(self):	1✔
55	"""
56	Returns a test PV system setup to use in tests for pvlib model.
57	"""
58	return {	2✔
59	"module_name": "Yingli_YL210__2008__E__",
60	"inverter_name": "ABB__MICRO_0_25_I_OUTD_US_208__208V_",
61	"azimuth": 180,
62	"tilt": 30,
63	"albedo": 0.2,
64	}
65
66	@pytest.fixture	2✔
67	def windpowerlib_turbine(self):	1✔
68	"""
69	Returns a test wind power plant to use in tests for windpowerlib model.
70	"""
71	return {"turbine_type": "E-82/3000", "hub_height": 135}	2✔
72
73	@pytest.fixture	2✔
74	def windpowerlib_turbine_2(self):	1✔
75	"""
76	Returns a test wind power plant to use in tests for windpowerlib model.
77	"""
78	return {	2✔
79	"turbine_type": "V90/2000",
80	"hub_height": 120,
81	"rotor_diameter": 80,
82	}
83
84	@pytest.fixture	2✔
85	def windpowerlib_farm(self, windpowerlib_turbine, windpowerlib_turbine_2):	1✔
86	"""
87	Returns a test wind farm to use in tests for windpowerlib model.
88	"""
89	return {	2✔
90	"wind_turbine_fleet": pd.DataFrame(
91	{
92	"wind_turbine": [
93	windpowerlib_turbine,
94	windpowerlib_turbine_2,
95	],
96	"number_of_turbines": [6, None],
97	"total_capacity": [None, 3 * 2e6],
98	}
99	)
100	}
101
102	@pytest.fixture	2✔
103	def windpowerlib_farm_2(self, windpowerlib_turbine):	1✔
104	"""
105	Returns a test wind farm to use in tests for windpowerlib model.
106	"""
107	return {	2✔
108	"wind_turbine_fleet": [
109	WindpowerlibWindTurbine(**windpowerlib_turbine).to_group(1)
110	]
111	}
112
113	@pytest.fixture	2✔
114	def windpowerlib_farm_3(	1✔
115	self, windpowerlib_turbine, windpowerlib_turbine_2
116	):
117	"""
118	Returns a test wind farm to use in tests for windpowerlib model.
119	"""
120
121	return {	×
122	"wind_turbine_fleet": pd.DataFrame(
123	{
124	"wind_turbine": [
125	WindPowerPlant(**windpowerlib_turbine),
126	WindPowerPlant(**windpowerlib_turbine_2),
127	],
128	"number_of_turbines": [6, 3],
129	}
130	)
131	}
132
133	@pytest.fixture	2✔
134	def windpowerlib_turbine_cluster(	1✔
135	self, windpowerlib_farm, windpowerlib_farm_2
136	):
137	"""
138	Returns a test wind turbine cluster to use in tests for windpowerlib
139	model.
140	"""
141	return {"wind_farms": [windpowerlib_farm, windpowerlib_farm_2]}	2✔
142
143
144	class TestPowerplants(Fixtures):	2✔
145	"""
146	Class to test some basic functionalities of the power plant classes.
147	"""
148
149	def test_powerplant_requirements(self, pvlib_pv_system, pvlib_weather):	2✔
150	"""
151	Test that attribute error is not raised in case a valid model is
152	specified when calling feedin method.
153	"""
154	test_module = Photovoltaic(**pvlib_pv_system)	2✔
155	feedin = test_module.feedin(	2✔
156	weather=pvlib_weather, model=Pvlib, location=(52, 13)
157	)
158	assert 143.39361 == pytest.approx(feedin.values[0], 1e-5)	2✔
159
160	def test_powerplant_requirements_2(self, pvlib_pv_system, pvlib_weather):	2✔
161	"""
162	Test that attribute error is raised in case required power plant
163	parameters are missing when feedin is called with a different model
164	than initially specified.
165	"""
166	test_module = Photovoltaic(**pvlib_pv_system)	2✔
167	msg = "The specified model 'windpowerlib_single_turbine' requires"	2✔
168	with pytest.raises(AttributeError, match=msg):	2✔
169	test_module.feedin(	2✔
170	weather=pvlib_weather,
171	model=WindpowerlibTurbine,
172	location=(52, 13),
173	)
174
175	def test_pv_feedin_scaling(self, pvlib_pv_system, pvlib_weather):	2✔
176	"""
177	Test that PV feedin timeseries are scaled correctly.
178	"""
179	test_module = Photovoltaic(**pvlib_pv_system)	2✔
180	feedin = test_module.feedin(	2✔
181	weather=pvlib_weather, location=(52, 13), scaling="peak_power"
182	)
183	assert 0.67511 == pytest.approx(feedin.values[0], 1e-5)	2✔
184	feedin = test_module.feedin(	2✔
185	weather=pvlib_weather, location=(52, 13), scaling="area"
186	)
187	assert 84.34918 == pytest.approx(feedin.values[0], 1e-5)	2✔
188
189	def test_wind_feedin_scaling(	2✔
190	self, windpowerlib_turbine, windpowerlib_weather
191	):
192	"""
193	Test that wind feedin timeseries are scaled correctly.
194	"""
195	test_turbine = WindPowerPlant(**windpowerlib_turbine)	2✔
196	feedin = test_turbine.feedin(	2✔
197	weather=windpowerlib_weather, scaling="nominal_power"
198	)
199	assert 833050.32551 / 3e6 == pytest.approx(feedin.values[0], 1e-5)	2✔
200
201
202	class TestGeometricSolar(Fixtures):	2✔
203	"""
204	Class to test GeometricSolar model and functions it depends on.
205	"""
206
207	def test_geometric_angles(self):	2✔
208	# c.f. example 1.6.1 from DB13
209	incidence_0, _ = solar_angles(	2✔
210	datetime=pd.date_range("1970-02-13 10:30", periods=1, tz="UTC"),
211	surface_azimuth=15,
212	tilt=45,
213	latitude=43,
214	longitude=0,
215	)
216	assert incidence_0 == pytest.approx(0.7838, 1e-4)	2✔
217
218	plant1 = GeometricSolar(	2✔
219	tilt=0, azimuth=0, longitude=0, latitude=0, system_efficiency=1
220	)
221	incidence_a, solar_zenith_a = plant1.solar_angles(	2✔
222	datetime=pd.date_range(
223	"3/20/2017 09:00", periods=12, freq="0.5H", tz="UTC"
224	)
225	)
226	# For tilt=0, both angles are the same (by day).
227	assert incidence_a == pytest.approx(solar_zenith_a)	2✔
228
229	plant2 = GeometricSolar(	2✔
230	tilt=180, azimuth=0, longitude=180, latitude=0, system_efficiency=1
231	)
232	incidence_b, solar_zenith_b = plant2.solar_angles(	2✔
233	datetime=pd.date_range(
234	"3/20/2017 09:00", periods=12, freq="0.5H", tz="UTC"
235	)
236	)
237	# Zenith angles at other side of the world are inverted.
238	assert solar_zenith_a == pytest.approx(-solar_zenith_b, 1e-5)	2✔
239
240	# Blocking by the horizon is not considered for angle calculation.
241	# Thus, incidence for a collector facing down at
242	# the opposite side of the world are the same.
243	assert incidence_a == pytest.approx(incidence_b, 1e-5)	2✔
244
245	def test_geometric_radiation(self):	2✔
246	# For calculation of radiation, direct radiation is blocked at night.
247	# So if there is neither reflection (albedo) nor diffuse radiation,
248	# total radiation should be 0.
249	plant3 = GeometricSolar(	2✔
250	tilt=60,
251	azimuth=0,
252	latitude=40,
253	longitude=0,
254	system_efficiency=0.9,
255	albedo=0,
256	nominal_peak_power=300,
257	)
258
259	data_weather_night = pd.DataFrame(	2✔
260	data={
261	"wind_speed": [0],
262	"temp_air": [25],
263	"dni": [100],
264	"dhi": [0],
265	},
266	index=pd.date_range(
267	"1970-01-01 00:00:00", periods=1, freq="h", tz="UTC"
268	),
269	)
270
271	assert plant3.geometric_radiation(data_weather_night)[	2✔
272	0
273	] == pytest.approx(0, 1e-5)
274	assert plant3.feedin(data_weather_night)[0] == pytest.approx(0, 1e-5)	2✔
275
276	# c.f. example 1.16.1 from DB13
277	plant4 = GeometricSolar(	2✔
278	tilt=60,
279	azimuth=0,
280	latitude=40,
281	longitude=0,
282	system_efficiency=0.9,
283	albedo=0.6,
284	nominal_peak_power=300,
285	)
286
287	data_weather_test = pd.DataFrame(	2✔
288	data={
289	"wind_speed": [0],
290	"temp_air": [25],
291	"dni": [67.8],
292	"dhi": [221.1],
293	},
294	index=pd.date_range(
295	"1970-02-20 09:43:44", periods=1, freq="h", tz="UTC"
296	),
297	)
298
299	assert plant4.geometric_radiation(data_weather_test)[	2✔
300	0
301	] == pytest.approx(302.86103, 1e-5)
302
303	# extra test for feedin
304	assert plant4.feedin(data_weather_test)[0] == pytest.approx(	2✔
305	78.67677, 1e-5
306	)
307
308	# check giving same weather with temperature in Kelvin
309	data_weather_kelvin = pd.DataFrame(	2✔
310	data={
311	"wind_speed": [0],
312	"temperature": [25 + 273.15],
313	"dni": [67.8],
314	"dhi": [221.1],
315	},
316	index=pd.date_range(
317	"1970-02-20 09:43:44", periods=1, freq="h", tz="UTC"
318	),
319	)
320
321	assert (	2✔
322	plant4.feedin(data_weather_test)[0]
323	== plant4.feedin(data_weather_kelvin)[0]
324	)
325
326	# check if problematic data (dhi > ghi) is detected
327	erroneous_weather = pd.DataFrame(	2✔
328	data={
329	"wind_speed": [5.0],
330	"temp_air": [10.0],
331	"dhi": [500],
332	"ghi": [300],
333	},
334	index=pd.date_range(
335	"1/1/1970 12:00", periods=1, freq="H", tz="UTC"
336	),
337	)
338
339	with pytest.raises(ValueError):	2✔
340	assert plant4.feedin(weather=erroneous_weather)	2✔
341
342	def test_pvlib_feedin(self, pvlib_weather):	2✔
343	test_module = GeometricSolar(	2✔
344	tilt=60,
345	azimuth=0,
346	latitude=52,
347	longitude=13,
348	system_efficiency=0.9,
349	albedo=0.6,
350	nominal_peak_power=210,
351	)
352	feedin = test_module.feedin(weather=pvlib_weather, location=(52, 0))	2✔
353
354	assert 214.225104 == pytest.approx(feedin.values[0], 1e-5)	2✔
355
356
357	class TestPvlib(Fixtures):	2✔
358	"""
359	Class to test Pvlib model.
360	"""
361
362	def test_pvlib_feedin(self, pvlib_pv_system, pvlib_weather):	2✔
363	"""
364	Test basic feedin calculation using pvlib.
365	It is also tested if dictionary with PV system parameters remains the
366	same to make sure it could be further used to calculate feed-in with
367	a different model.
368	"""
369	test_copy = deepcopy(pvlib_pv_system)	2✔
370	test_module = Photovoltaic(**pvlib_pv_system)	2✔
371	feedin = test_module.feedin(weather=pvlib_weather, location=(52, 13))	2✔
372	assert 143.39361 == pytest.approx(feedin.values[0], 1e-5)	2✔
373	assert test_copy == pvlib_pv_system	2✔
374
375	def test_pvlib_feedin_with_surface_type(	2✔
376	self, pvlib_pv_system, pvlib_weather
377	):
378	"""
379	Test basic feedin calculation using pvlib and providing surface type
380	instead of albedo.
381	"""
382	del pvlib_pv_system["albedo"]	2✔
383	pvlib_pv_system["surface_type"] = "grass"	2✔
384	test_module = Photovoltaic(**pvlib_pv_system)	2✔
385	feedin = test_module.feedin(weather=pvlib_weather, location=(52, 13))	2✔
386	assert 143.39361 == pytest.approx(feedin.values[0], 1e-5)	2✔
387
388	def test_pvlib_feedin_with_optional_pp_parameter(	2✔
389	self, pvlib_pv_system, pvlib_weather
390	):
391	"""
392	Test basic feedin calculation using pvlib and providing an optional
393	PV system parameter.
394	"""
395	pvlib_pv_system["strings_per_inverter"] = 2	2✔
396	test_module = Photovoltaic(**pvlib_pv_system)	2✔
397	feedin = test_module.feedin(weather=pvlib_weather, location=(52, 13))	2✔
398	# power output is in this case limited by the inverter, which is why
399	# power output with 2 strings is not twice as high as power output of
400	# one string
401	assert 250.0 == pytest.approx(feedin.values[0], 1e-5)	2✔
402
403	def test_pvlib_feedin_with_optional_model_parameters(	2✔
404	self, pvlib_pv_system, pvlib_weather
405	):
406	"""
407	Test basic feedin calculation using pvlib and providing an optional
408	PV system parameter.
409	"""
410	pvlib_pv_system["strings_per_inverter"] = 2	2✔
411	test_module = Photovoltaic(**pvlib_pv_system)	2✔
412	feedin = test_module.feedin(	2✔
413	weather=pvlib_weather, location=(52, 13), mode="dc"
414	)
415	# power output is in this case limited by the inverter, which is why
416	# power output with 2 strings is not twice as high as power output of
417	# one string
418	assert 298.27921 == pytest.approx(feedin.values[0], 1e-5)	2✔
419
420	def test_pvlib_missing_powerplant_parameter(self, pvlib_pv_system):	2✔
421	"""
422	Test if initialization of powerplant fails in case of missing power
423	plant parameter.
424	"""
425	del pvlib_pv_system["albedo"]	2✔
426	msg = "The specified model 'pvlib' requires"	2✔
427	with pytest.raises(AttributeError, match=msg):	2✔
428	Photovoltaic(**pvlib_pv_system)	2✔
429
430
431	class TestWindpowerlibSingleTurbine(Fixtures):	2✔
432	"""
433	Class to test WindpowerlibTurbine model.
434	"""
435
436	def test_windpowerlib_single_turbine_feedin(	2✔
437	self, windpowerlib_turbine, windpowerlib_weather
438	):
439	"""
440	Test basic feedin calculation using windpowerlib single turbine.
441	It is also tested if dictionary with turbine parameters remains the
442	same to make sure it could be further used to calculate feed-in with
443	a different model.
444	"""
445	test_copy = deepcopy(windpowerlib_turbine)	2✔
446	test_turbine = WindPowerPlant(**windpowerlib_turbine)	2✔
447	feedin = test_turbine.feedin(weather=windpowerlib_weather)	2✔
448	assert 833050.32551 == pytest.approx(feedin.values[0], 1e-5)	2✔
449	assert test_copy == windpowerlib_turbine	2✔
450
451	def test_windpowerlib_single_turbine_feedin_with_optional_pp_parameter(	2✔
452	self, windpowerlib_turbine, windpowerlib_weather
453	):
454	"""
455	Test basic feedin calculation using windpowerlib single turbine and
456	using optional parameters for power plant and modelchain.
457	"""
458	windpowerlib_turbine["rotor_diameter"] = 82	2✔
459	test_turbine = WindPowerPlant(**windpowerlib_turbine)	2✔
460	feedin = test_turbine.feedin(	2✔
461	weather=windpowerlib_weather,
462	power_output_model="power_coefficient_curve",
463	)
464	assert 847665.85209 == pytest.approx(feedin.values[0], 1e-5)	2✔
465
466	def test_windpowerlib_missing_powerplant_parameter(	2✔
467	self, windpowerlib_turbine
468	):
469	"""
470	Test if initialization of powerplant fails in case of missing power
471	plant parameter.
472	"""
473	del windpowerlib_turbine["turbine_type"]	2✔
474	msg = "The specified model 'windpowerlib_single_turbine' requires"	2✔
475	with pytest.raises(AttributeError, match=msg):	2✔
476	WindPowerPlant(**windpowerlib_turbine)	2✔
477
478
479	class TestWindpowerlibCluster(Fixtures):	2✔
480	"""
481	Class to test WindpowerlibTurbineCluster model.
482	"""
483
484	def test_windpowerlib_windfarm_feedin(	2✔
485	self, windpowerlib_farm, windpowerlib_weather
486	):
487	"""
488	Test basic feedin calculation using windpowerlib wind turbine cluster
489	modelchain for a wind farm where wind turbine data is provided in a
490	dictionary.
491	It is also tested if dataframe with wind turbine fleet remains the
492	same to make sure it could be further used to calculate feed-in with
493	a different model.
494	"""
495	test_copy = deepcopy(windpowerlib_farm)	2✔
496	farm = WindPowerPlant(	2✔
497	**windpowerlib_farm, model=WindpowerlibTurbineCluster
498	)
499	feedin = farm.feedin(	2✔
500	weather=windpowerlib_weather, wake_losses_model=None
501	)
502	assert 7658841.386277 == pytest.approx(feedin.values[0], 1e-5)	2✔
503	assert_frame_equal(	2✔
504	test_copy["wind_turbine_fleet"],
505	windpowerlib_farm["wind_turbine_fleet"],
506	)
507
508	@pytest.mark.skip(reason="We have to fix the circular import to use a"	2✔
509	"feedinlib WindPowerPlant object in clusters.")
510	def test_windpowerlib_windfarm_feedin_2(	1✔
511	self, windpowerlib_farm_3, windpowerlib_weather
512	):
513	"""
514	Test basic feedin calculation using windpowerlib wind turbine cluster
515	modelchain for a wind farm where wind turbines are provided as
516	feedinlib WindPowerPlant objects.
517	It is also tested if dataframe with wind turbine fleet remains the
518	same to make sure it could be further used to calculate feed-in with
519	a different model.
520	"""
521	test_copy = deepcopy(windpowerlib_farm_3)	×
522	farm = WindPowerPlant(	×
523	**windpowerlib_farm_3, model=WindpowerlibTurbineCluster
524	)
525	feedin = farm.feedin(	×
526	weather=windpowerlib_weather, wake_losses_model=None
527	)
528	assert 7658841.386277 == pytest.approx(feedin.values[0], 1e-5)	×
529	assert_frame_equal(	×
530	test_copy["wind_turbine_fleet"],
531	windpowerlib_farm_3["wind_turbine_fleet"],
532	)
533
534	def test_windpowerlib_turbine_cluster_feedin(	2✔
535	self, windpowerlib_turbine_cluster, windpowerlib_weather
536	):
537	"""
538	Test basic feedin calculation using windpowerlib wind turbine cluster
539	modelchain for a wind turbine cluster.
540	"""
541	test_cluster = WindPowerPlant(	2✔
542	**windpowerlib_turbine_cluster, model=WindpowerlibTurbineCluster
543	)
544	feedin = test_cluster.feedin(weather=windpowerlib_weather)	2✔
545	assert 7285008.02048 == pytest.approx(feedin.values[0], 1e-5)	2✔
546
547	def test_windpowerlib_windfarm_feedin_with_optional_parameters(	2✔
548	self, windpowerlib_farm, windpowerlib_weather
549	):
550	"""
551	Test basic feedin calculation using windpowerlib wind turbine cluster
552	modelchain and supplying an optional power plant and modelchain
553	parameter.
554	"""
555
556	# test optional parameter
557	test_farm = windpowerlib_farm	2✔
558	test_farm["efficiency"] = 0.9	2✔
559	farm = WindPowerPlant(**test_farm, model=WindpowerlibTurbineCluster)	2✔
560	feedin = farm.feedin(	2✔
561	weather=windpowerlib_weather,
562	wake_losses_model="wind_farm_efficiency",
563	)
564	assert 6892957.24764 == pytest.approx(feedin.values[0], 1e-5)	2✔
565
566	def test_windpowerlib_turbine_equals_windfarm(	2✔
567	self, windpowerlib_turbine, windpowerlib_farm_2, windpowerlib_weather
568	):
569	"""
570	Test if wind turbine feedin calculation yields the same as wind farm
571	calculation with one turbine.
572	"""
573	# turbine feedin
574	test_turbine = WindPowerPlant(**windpowerlib_turbine)	2✔
575	feedin = test_turbine.feedin(weather=windpowerlib_weather)	2✔
576	# farm feedin
577	test_farm = WindPowerPlant(	2✔
578	**windpowerlib_farm_2, model=WindpowerlibTurbineCluster
579	)
580	feedin_farm = test_farm.feedin(	2✔
581	weather=windpowerlib_weather, wake_losses_model=None
582	)
583	assert feedin.values[0] == pytest.approx(feedin_farm.values[0], 1e-5)	2✔
584
585	def test_windpowerlib_windfarm_equals_cluster(	2✔
586	self, windpowerlib_farm, windpowerlib_weather
587	):
588	"""
589	Test if windfarm feedin calculation yields the same as turbine cluster
590	calculation with one wind farm.
591	"""
592	# farm feedin
593	test_farm = WindPowerPlant(	2✔
594	**windpowerlib_farm, model=WindpowerlibTurbineCluster
595	)
596	feedin_farm = test_farm.feedin(weather=windpowerlib_weather)	2✔
597	# turbine cluster
598	test_cluster = {"wind_farms": [windpowerlib_farm]}	2✔
599	test_cluster = WindPowerPlant(	2✔
600	**test_cluster, model=WindpowerlibTurbineCluster
601	)
602	feedin_cluster = test_cluster.feedin(weather=windpowerlib_weather)	2✔
603	assert feedin_farm.values[0] == pytest.approx(	2✔
604	feedin_cluster.values[0], 1e-5
605	)

oemof / feedinlib / 936193449

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous