2280705279

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/oemof/demandlib/commit/<a class=hub.com/oemof/demandlib/commit/<a class="double-link" href="https://git"><a class=hub.com/oemof/demandlib/commit/<a class="double-link" href="https://git"><a class=hub.com/oemof/demandlib/commit/ae3a368b53d11c5bb5586df50e9a7a77e029d5de">ae3a368b5<a href="https://github.com/oemof/demandlib/commit/ae3a368b53d11c5bb5586df50e9a7a77e029d5de">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/oemof/demandlib/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/demandlib/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/demandlib/commit/ae3a368b53d11c5bb5586df50e9a7a77e029d5de&quot;&gt;ae3a368b5&lt;/a&gt;&lt;a href=&quot;https://github.com/oemof/demandlib/commit/ae3a368b53d11c5bb5586df50e9a7a77e029d5de&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/oemof/demandlib/commit/ae3a368b53d11c5bb5586df50e9a7a77&lt;/a&gt;e029d5de">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/demandlib/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/demandlib/commit/<a class="double-link" href="https://github.com/oemof/demandlib/commit/5d7500192004ab211a5c6a1672f6a44e3f802bdd">5d7500192</a><a href="https://github.com/oemof/demandlib/commit/ae3a368b53d11c5bb5586df50e9a7a77e029d5de">&amp;quot;&amp;gt;5d7500192&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;5d7500192&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/oemof/demandlib/commit/ae3a368b53d11c5bb5586df50e9a7a77e029d&lt;/a&gt;5de&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/demandlib/commit/<a class="double-link" href="https://github.com/oemof/demandlib/commit/c088f1488">c088f1488">c088f1488</a>

Pull Request Pull Request #50: Add VDI profiles based on lpagg

Run Details

84 of 108 branches covered (77.78%)

Branch coverage included in aggregate %.

231 of 231 new or added lines in 4 files covered. (100.0%)

448 of 492 relevant lines covered (91.06%)

2.73 hits per line

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

83.73

/src/demandlib/vdi/regions.py

"""
The region module combines profiles from VDI 4655 for heat and power demand of
houses within one region.


Module VDI 4655
---------------
This is an implementation of the calculation of economic efficiency
using the annuity method defined in the German VDI 4655.

    **VDI 4655**

    **Reference load profiles of single-family and
    multi-family houses for the use of CHP systems**

    *May 2008 (ICS 91.140.01)*

    *Verein Deutscher Ingenieure e.V.*

    *VDI Standards Department*

    *VDI-Platz 1, 40468 Duesseldorf, Germany*

Reproduced with the kind permission of the Verein Deutscher Ingenieure e.V.

Notes
-----
This script creates full year energy demand time series of domestic buildings
for use in simulations. This is achieved by an implementation of the VDI 4655,
which gives sample energy demands for a number of typical days ('Typtage').
The energy demand contains heating, hot water and electricity.

For a given year, the typical days can be matched to the actual calendar days,
based on the following conditions:
    - Season: summer, winter or transition
    - Day: weekday or sunday (Or holiday, which counts as sunday)
    - Cloud coverage: cloudy or not cloudy
    - House type: single-family houses or multi-family houses (EFH or MFH)

The holidays are loaded from an Excel file, the weather conditions are loaded
from weather data (e.g. DWD TRY).
Most of the settings for this script are controlled with a configuration file
called 'config_file', the location of which is defined down below.

SPDX-FileCopyrightText: Joris Zimmermann
SPDX-FileCopyrightText: Uwe Krien

SPDX-License-Identifier: MIT
"""

import calendar
import datetime
import os
import warnings

import pandas as pd

from demandlib import config as cfg
from demandlib.tools import add_weekdays2df
from demandlib.vdi import dwd_try


class Region:
    def __init__(
        self,
        year,
        try_region,
        seasons=None,
        holidays=None,
        houses=None,
        resample_rule=None,
    ):
        """

        Parameters
        ----------
        year : int
            Year of the profile.
        try_region : int
            The number of the TRY (test reference year of the DWD) region.
        seasons : dict (optional)
            The times of the seasons if fixed seasons are used. In the VDI
            norm seasons are defined by the daily average temperature: Winter
            below 5 degree Celsius, Spring between 5 and 15 degree Celsius and
            summer above 15 degree Celsius.
        holidays : dict or list
            In case of a dictionary the keys are datetime objects and the
            values are strings with the name of the holiday. Otherwise a list
            of datetime objects should be passed.
        houses : list
            A list of dictionaries in which each house is defined the
            dictionary need to have the following keys.
        resample_rule : str
            Time interval to resample the profile e.g. 1H (1 hour) or 15min.
            The value will be passed to the pandas resample method.
        """
        if calendar.isleap(year):
            self.hoy = 8784
        else:
            self.hoy = 8760
        self._datapath = os.path.join(os.path.dirname(__file__), "bdew_data")

        self._seasons = {
            "summer1": [5, 15, 9, 14],  # summer: 15.05. to 14.09
            "transition1": [3, 21, 5, 14],  # transition1 :21.03. to 14.05
            "transition2": [9, 15, 10, 31],  # transition2 :15.09. to 31.10
            "winter1": [1, 1, 3, 20],  # winter1:  01.01. to 20.03
            "winter2": [11, 1, 12, 31],  # winter2: 01.11. to 31.12
        }

        if seasons is not None:
            self._seasons.update(seasons)

        self._try_region = try_region

        self._year = year
        self.weather = None
        self.type_days = self._get_typical_days(holidays)
        self._load_profiles = self._load_profile_factors()

        self.houses = []
        if houses is not None:
            self.add_houses(houses)

        if resample_rule is not None:
            self._resample_profiles(resample_rule)

    def _resample_profiles(self, rule):
        self._load_profiles = self._load_profiles.resample(rule).sum()
        self.type_days = self.type_days.resample(rule).first()

    def _get_typical_days(self, holidays, set_season="temperature"):
        """
        Find the code for the typical days from dwd. The code consists of three
        letters:

          1. Season: W (winter), S (summer), U (transition)
          2. Day of the week: W (weekday), S (sunday/holiday)
          3. Cloud coverage for winter and transition: B (covered), H (partly
             clouded/sunny)

        Parameters
        ----------
        holidays
        set_season

        Returns
        -------

        """
        # Create the default time index
        date_time_index = pd.date_range(
            datetime.datetime(self._year, 1, 1, 0),
            periods=self.hoy / 24,
            freq="D",
        )
        days = pd.DataFrame(index=date_time_index)

        # Set season by fixed dates
        for p in self._seasons:
            a = datetime.datetime(
                self._year, self._seasons[p][0], self._seasons[p][1], 0, 0
            )
            b = datetime.datetime(
                self._year, self._seasons[p][2], self._seasons[p][3], 23, 59
            )
            days.loc[a:b, "season_fix"] = p[:-1]

        # Set weekdays and holidays
        days = add_weekdays2df(days, holidays=holidays, holiday_is_sunday=True)
        days.pop("date")

        # Fetch weather data
        fn_weather = os.path.join(
            os.path.dirname(__file__),
            "resources_weather",
            "TRY2010_{:02d}_Jahr.dat".format(self._try_region),
        )
        self.weather = dwd_try.read_dwd_weather_file(fn_weather)
        self.weather = (
            self.weather.set_index(
                pd.date_range(
                    datetime.datetime(self._year, 1, 1, 0),
                    periods=self.hoy,
                    freq="H",
                )
            )
            .resample("D")
            .mean()
        )
        days = pd.concat([days, self.weather], axis=1)

        # 1. Set first letter of type days (season) from fixed season or season
        # by temperature.
        seasons_dict = {
            "summer": "S",
            "winter": "W",
            "transition": "U",
        }
        days.replace(to_replace=seasons_dict, inplace=True)
        wtl = cfg.get("VDI", "winter_temperature_limit")
        stl = cfg.get("VDI", "summer_temperature_limit")
        days.loc[days["TAMB"] < wtl, "season_t"] = "W"
        days.loc[days["TAMB"] >= wtl, "season_t"] = "U"
        days.loc[days["TAMB"] > stl, "season_t"] = "S"
        days.pop("TAMB")

        if set_season == "temperature":
            days["season"] = days.pop("season_t")
            days.pop("season_fix")
        elif set_season == "fix":
            days["season"] = days.pop("season_fix")
            days.pop("season_t")
        else:
            msg = "Method <{0}> for the season does not exist."
            raise NotImplementedError(msg.format(set_season))

        # 2. Set second letter of type days: Day of the week
        days.loc[days["weekday"] == 7, "day_of_week"] = "S"
        days.loc[days["weekday"] < 7, "day_of_week"] = "W"
        days.pop("weekday")

        # 3. Set third letter of type days: Cloud coverage
        days.loc[days["CCOVER"] >= 5, "cloud_coverage"] = "B"
        days.loc[days["CCOVER"] < 5, "cloud_coverage"] = "H"
        days.loc[days["season"] == "S", "cloud_coverage"] = "X"
        days.pop("CCOVER")

        # Combine the three letters in one column
        days["day_types"] = (
            days["season"] + days["day_of_week"] + days["cloud_coverage"]
        )
        days.drop(
            ["season", "day_of_week", "cloud_coverage"], axis=1, inplace=True
        )
        return days

    def _load_profile_factors(self):
        """Run VDI 4655 - Step 2.

        Match 'typtag' keys and reference load profile factors for each
        timestep (for each 'typtag' key, one load profile is defined by
        VDI 4655)
        """

        # Load data of typical days from VDI
        fn_typtage = os.path.join(
            os.path.dirname(__file__), "vdi_data", "VDI_4655_Typtage.csv"
        )
        typtage_df = pd.read_csv(fn_typtage, index_col=[0, 1])

        # Extract list of house types (expect: EFH, MFH)
        house_types = list(typtage_df.index.get_level_values(0).unique())

        # Convert time into datetime format
        typtage_df["time"] = pd.to_datetime(
            typtage_df.pop("Zeit"), format="%H:%M:%S"
        )

        # Calculate minutes of the day for every time step
        typtage_df["minute_of_day"] = (
            pd.to_timedelta(
                typtage_df["time"]
                - pd.Series(index=typtage_df.index, data=typtage_df["time"][0])
            )
            .dt.total_seconds()
            .div(60)
            .astype(int)
        )

        # Add columns to merge with (house types and day_types)
        typtage_df["ht"] = typtage_df.index.get_level_values(0)
        typtage_df["day_types"] = typtage_df.index.get_level_values(1)

        # Create a table for every minute of the year
        minute_table = pd.DataFrame(
            index=pd.date_range(
                f"1/1/{self._year}", periods=525600, freq="Min"
            )
        )

        # Set reference time (first hour of the day) to calculate minutes of
        # the day.
        self.type_days["ref_dt"] = self.type_days.index

        # Fill data into the large table with minute index
        self.type_days = pd.concat(
            [self.type_days, minute_table], axis=1
        ).ffill()

        # Add columns to merge with (house types, minute of day and day_types)
        self.type_days["datetime"] = self.type_days.index
        self.type_days["minute_of_day"] = (
            pd.to_timedelta(
                self.type_days.pop("datetime")
                - pd.Series(
                    index=self.type_days.index,
                    data=self.type_days.pop("ref_dt"),
                )
            )
            .dt.total_seconds()
            .div(60)
            .astype(int)
        )

        # Merge table for both house type to get the value of every minute of
        # the typical days for every minute of the year.
        house_profiles = {}
        for house_type in house_types:
            self.type_days["ht"] = house_type
            house_profiles[house_type] = self.type_days.merge(
                typtage_df,
                how="left",
                left_on=["day_types", "minute_of_day", "ht"],
                right_on=["day_types", "minute_of_day", "ht"],
            ).sort_index()

        # Combine the table of both house type
        load_profile = (
            pd.concat(
                [
                    house_profiles["EFH"][
                        ["F_el_n_TT", "F_Heiz_n_TT", "F_TWW_n_TT"]
                    ],
                    house_profiles["MFH"][
                        ["F_el_n_TT", "F_Heiz_n_TT", "F_TWW_n_TT"]
                    ],
                ],
                keys=["EFH", "MFH"],
                axis=1,
            )
            # .swaplevel(0, 1, axis=1)
            .sort_index(axis=1)
        )

        # Set time index to make it possible to reshape the table
        load_profile = load_profile.set_index(minute_table.index)
        load_profile.ffill(inplace=True)
        load_profile.loc[:, ("MFH", slice(None))] *= 1 / 15
        return load_profile

    def add_houses(self, houses):
        """

        Parameters
        ----------
        houses : list
            A list of dictionaries that describes the houses.

        """
        houses_wrong = [
            h for h in houses if h["house_type"] not in ["EFH", "MFH"]
        ]
        houses = [h for h in houses if h["house_type"] in ["EFH", "MFH"]]
        for h in houses_wrong:
            msg = "<{0}> is a not supported house type and will be " "removed."
            warnings.warn(msg.format(h["house_type"]), UserWarning)

        if len(houses) > 0:
            self.houses.extend(houses)

    def get_daily_energy_demand_houses(self):
        """Determine the houses' energy demand values for each 'typtag'.

        .. note::
            "The factors ``F_el_TT`` and ``F_TWW_TT`` are negative in some
            cases as they represent a variation from a one-year average. The
            values for the daily demand for electrical energy, ``W_TT``, and
            DHW energy, ``Q_TWW_TT``, usually remain positive. It is only in
            individual cases that the calculation for the typical-day category
            ``SWX`` can yield a negative value of the DHW demand. In that case,
            assume ``F_TWW_SWX`` = 0." (VDI 4655, page 16)

            This occurs when ``N_Pers`` or ``N_WE`` are too large.

        """
        # typtage_combinations = settings["typtage_combinations"]
        # houses_list = settings["houses_list_VDI"]

        # Load the file containing the energy factors of the different typical
        # radiation year (TRY) regions, house types and 'typtage'. In VDI 4655,
        # these are the tables 10 to 24.
        fn_energy_factors = os.path.join(
            os.path.dirname(__file__),
            "vdi_data",
            "VDI_4655_Typtag-Faktoren.csv",
        )
        energy_factors = pd.read_csv(
            fn_energy_factors,
            index_col=[0, 1, 2],
        )

        # if settings.get("zero_summer_heat_demand", None) is not None:
        #     # Reduze the value of 'F_Heiz_TT' to zero.
        #     # For modern houses, this eliminates the heat demand in summer
        #     energy_factors_df.loc[
        #         (slice(None), slice(None), "F_Heiz_TT"), ("SWX", "SSX")
        #     ] = 0

        # Create a new DataFrame with multiindex.
        # It has two levels of columns: houses and energy
        # The DataFrame stores the individual energy demands for each house in
        # each time step
        energy_demands_types = ["Q_Heiz_TT", "W_TT", "Q_TWW_TT"]
        house_names = [n["name"] for n in self.houses]
        iterables = [house_names, energy_demands_types]
        multiindex = pd.MultiIndex.from_product(
            iterables, names=["house", "energy"]
        )
        typtage_combinations = self.type_days["day_types"].unique()

        daily_energy_demand_houses = pd.DataFrame(
            index=multiindex, columns=typtage_combinations
        )

        # Fill the DataFrame daily_energy_demand_houses
        for house in self.houses:
            house_type = house["house_type"]
            n_pers = house["N_Pers"]
            n_we = house["N_WE"]
            try_region = self._try_region

            # Savety check:
            if try_region not in energy_factors.index.get_level_values(0):
                msg = (
                    "Error! TRY "
                    + str(try_region)
                    + " not contained in file "
                    + fn_energy_factors
                )
                msg2 = '       Skipping house "' + house["name"] + '"!'
                warnings.warn(msg + "/n" + msg2, UserWarning)
                continue  # 'Continue' skips the rest of the current for-loop

            # Get yearly energy demands
            q_heiz_a = house["Q_Heiz_a"]
            w_a = house["W_a"]
            q_tww_a = house["Q_TWW_a"]

            # (6.4) Do calculations according to VDI 4655 for each 'typtag'
            for typtag in typtage_combinations:
                f_heiz_tt = energy_factors.loc[
                    try_region, house_type, "F_Heiz_TT"
                ][typtag]
                f_el_tt = energy_factors.loc[
                    try_region, house_type, "F_el_TT"
                ][typtag]
                f_tww_tt = energy_factors.loc[
                    try_region, house_type, "F_TWW_TT"
                ][typtag]

                q_heiz_tt = q_heiz_a * f_heiz_tt

                if house_type == "EFH":
                    n_pers_we = n_pers
                elif house_type == "MFH":
                    n_pers_we = n_we
                else:
                    n_pers_we = None

                w_tt = w_a * (1.0 / 365.0 + n_pers_we * f_el_tt)
                q_tww_tt = q_tww_a * (1.0 / 365.0 + n_pers_we * f_tww_tt)

                if w_tt < 0:
                    msg = (
                        "Warning:     W_TT for "
                        + house["name"]
                        + " and "
                        + typtag
                        + " was negative, see VDI 4655 page 16"
                    )
                    warnings.warn(msg, UserWarning)
                    w_tt = w_a * (1.0 / 365.0 + n_pers_we * 0)

                if q_tww_tt < 0:
                    msg = (
                        "Warning: Q_TWW_TT for "
                        + house["name"]
                        + " and "
                        + typtag
                        + " was negative, see VDI 4655 page 16"
                    )
                    warnings.warn(msg, UserWarning)
                    q_tww_tt = q_tww_a * (1.0 / 365.0 + n_pers_we * 0)

                # Write values into DataFrame
                daily_energy_demand_houses.loc[house["name"], "Q_Heiz_TT"][
                    typtag
                ] = q_heiz_tt
                daily_energy_demand_houses.loc[house["name"], "W_TT"][
                    typtag
                ] = w_tt
                daily_energy_demand_houses.loc[house["name"], "Q_TWW_TT"][
                    typtag
                ] = q_tww_tt

            #    print(daily_energy_demand_houses)
        return daily_energy_demand_houses

    def get_load_curve_houses(self):
        """Generate the houses' energy demand values for each timestep.

        Get the energy demand values for all days.

        This functions works through the lists houses_list and
        energy_factor_types day by day and multiplies the current load profile
        value with the daily energy demand. It returns the result: the energy
        demand values for all houses and energy types (in kWh)
        """
        daily_energy_demand_houses = self.get_daily_energy_demand_houses()

        house_profiles = {}

        for house in self.houses:
            df_typ = self.type_days.merge(
                daily_energy_demand_houses.T[house["name"]],
                left_on="day_types",
                right_index=True,
            ).sort_index()
            df_typ.drop(
                ["day_types", "minute_of_day", "ht"], axis=1, inplace=True
            )

            load_profile_df = self._load_profiles.rename(
                columns={
                    "F_Heiz_n_TT": "Q_Heiz_TT",
                    "F_el_n_TT": "W_TT",
                    "F_TWW_n_TT": "Q_TWW_TT",
                }
            )

            # df = pd.concat([df_typ, mytime], axis=1).ffill()
            # df.drop(df.head(1).index, inplace=True)

            load_curve_house = df_typ.mul(load_profile_df[house["house_type"]])

            # The typical day calculation inherently does not add up to the
            # desired total energy demand of the full year. Here we fix that:
            # houses_dict = {h["name"]: h for h in self.houses}
            for column in load_curve_house.columns:
                q_a = house[column.replace("TT", "a")]
                sum_ = load_curve_house[column].sum()
                if sum_ > 0:  # Would produce NaN otherwise
                    load_curve_house[column] = (
                        load_curve_house[column] / sum_ * q_a
                    )
            load_curve_house.columns = pd.MultiIndex.from_product(
                [
                    [house["house_type"]],
                    load_curve_house.columns,
                ]
            )
            house_profiles[house["name"]] = load_curve_house
        return pd.concat(
            house_profiles.values(), keys=house_profiles.keys(), axis=1
        )

1	"""
2	The region module combines profiles from VDI 4655 for heat and power demand of
3	houses within one region.
4
5
6	Module VDI 4655
7	---------------
8	This is an implementation of the calculation of economic efficiency
9	using the annuity method defined in the German VDI 4655.
10
11	VDI 4655
12
13	**Reference load profiles of single-family and
14	multi-family houses for the use of CHP systems**
15
16	May 2008 (ICS 91.140.01)
17
18	Verein Deutscher Ingenieure e.V.
19
20	VDI Standards Department
21
22	VDI-Platz 1, 40468 Duesseldorf, Germany
23
24	Reproduced with the kind permission of the Verein Deutscher Ingenieure e.V.
25
26	Notes
27	-----
28	This script creates full year energy demand time series of domestic buildings
29	for use in simulations. This is achieved by an implementation of the VDI 4655,
30	which gives sample energy demands for a number of typical days ('Typtage').
31	The energy demand contains heating, hot water and electricity.
32
33	For a given year, the typical days can be matched to the actual calendar days,
34	based on the following conditions:
35	- Season: summer, winter or transition
36	- Day: weekday or sunday (Or holiday, which counts as sunday)
37	- Cloud coverage: cloudy or not cloudy
38	- House type: single-family houses or multi-family houses (EFH or MFH)
39
40	The holidays are loaded from an Excel file, the weather conditions are loaded
41	from weather data (e.g. DWD TRY).
42	Most of the settings for this script are controlled with a configuration file
43	called 'config_file', the location of which is defined down below.
44
45	SPDX-FileCopyrightText: Joris Zimmermann
46	SPDX-FileCopyrightText: Uwe Krien
47
48	SPDX-License-Identifier: MIT
49	"""
50
51	import calendar	3✔
52	import datetime	3✔
53	import os	3✔
54	import warnings	3✔
55
56	import pandas as pd	3✔
57
58	from demandlib import config as cfg	3✔
59	from demandlib.tools import add_weekdays2df	3✔
60	from demandlib.vdi import dwd_try	3✔
61
62
63	class Region:	3✔
64	def __init__(	3✔
65	self,
66	year,
67	try_region,
68	seasons=None,
69	holidays=None,
70	houses=None,
71	resample_rule=None,
72	):
73	"""
74
75	Parameters
76	----------
77	year : int
78	Year of the profile.
79	try_region : int
80	The number of the TRY (test reference year of the DWD) region.
81	seasons : dict (optional)
82	The times of the seasons if fixed seasons are used. In the VDI
83	norm seasons are defined by the daily average temperature: Winter
84	below 5 degree Celsius, Spring between 5 and 15 degree Celsius and
85	summer above 15 degree Celsius.
86	holidays : dict or list
87	In case of a dictionary the keys are datetime objects and the
88	values are strings with the name of the holiday. Otherwise a list
89	of datetime objects should be passed.
90	houses : list
91	A list of dictionaries in which each house is defined the
92	dictionary need to have the following keys.
93	resample_rule : str
94	Time interval to resample the profile e.g. 1H (1 hour) or 15min.
95	The value will be passed to the pandas resample method.
96	"""
97	if calendar.isleap(year):	3!
98	self.hoy = 8784	×
99	else:
100	self.hoy = 8760	3✔
101	self._datapath = os.path.join(os.path.dirname(__file__), "bdew_data")	3✔
102
103	self._seasons = {	3✔
104	"summer1": [5, 15, 9, 14], # summer: 15.05. to 14.09
105	"transition1": [3, 21, 5, 14], # transition1 :21.03. to 14.05
106	"transition2": [9, 15, 10, 31], # transition2 :15.09. to 31.10
107	"winter1": [1, 1, 3, 20], # winter1: 01.01. to 20.03
108	"winter2": [11, 1, 12, 31], # winter2: 01.11. to 31.12
109	}
110
111	if seasons is not None:	3!
112	self._seasons.update(seasons)	×
113
114	self._try_region = try_region	3✔
115
116	self._year = year	3✔
117	self.weather = None	3✔
118	self.type_days = self._get_typical_days(holidays)	3✔
119	self._load_profiles = self._load_profile_factors()	3✔
120
121	self.houses = []	3✔
122	if houses is not None:	3!
123	self.add_houses(houses)	3✔
124
125	if resample_rule is not None:	3!
126	self._resample_profiles(resample_rule)	3✔
127
128	def _resample_profiles(self, rule):	3✔
129	self._load_profiles = self._load_profiles.resample(rule).sum()	3✔
130	self.type_days = self.type_days.resample(rule).first()	3✔
131
132	def _get_typical_days(self, holidays, set_season="temperature"):	3✔
133	"""
134	Find the code for the typical days from dwd. The code consists of three
135	letters:
136
137	1. Season: W (winter), S (summer), U (transition)
138	2. Day of the week: W (weekday), S (sunday/holiday)
139	3. Cloud coverage for winter and transition: B (covered), H (partly
140	clouded/sunny)
141
142	Parameters
143	----------
144	holidays
145	set_season
146
147	Returns
148	-------
149
150	"""
151	# Create the default time index
152	date_time_index = pd.date_range(	3✔
153	datetime.datetime(self._year, 1, 1, 0),
154	periods=self.hoy / 24,
155	freq="D",
156	)
157	days = pd.DataFrame(index=date_time_index)	3✔
158
159	# Set season by fixed dates
160	for p in self._seasons:	3✔
161	a = datetime.datetime(	3✔
162	self._year, self._seasons[p][0], self._seasons[p][1], 0, 0
163	)
164	b = datetime.datetime(	3✔
165	self._year, self._seasons[p][2], self._seasons[p][3], 23, 59
166	)
167	days.loc[a:b, "season_fix"] = p[:-1]	3✔
168
169	# Set weekdays and holidays
170	days = add_weekdays2df(days, holidays=holidays, holiday_is_sunday=True)	3✔
171	days.pop("date")	3✔
172
173	# Fetch weather data
174	fn_weather = os.path.join(	3✔
175	os.path.dirname(__file__),
176	"resources_weather",
177	"TRY2010_{:02d}_Jahr.dat".format(self._try_region),
178	)
179	self.weather = dwd_try.read_dwd_weather_file(fn_weather)	3✔
180	self.weather = (	3✔
181	self.weather.set_index(
182	pd.date_range(
183	datetime.datetime(self._year, 1, 1, 0),
184	periods=self.hoy,
185	freq="H",
186	)
187	)
188	.resample("D")
189	.mean()
190	)
191	days = pd.concat([days, self.weather], axis=1)	3✔
192
193	# 1. Set first letter of type days (season) from fixed season or season
194	# by temperature.
195	seasons_dict = {	3✔
196	"summer": "S",
197	"winter": "W",
198	"transition": "U",
199	}
200	days.replace(to_replace=seasons_dict, inplace=True)	3✔
201	wtl = cfg.get("VDI", "winter_temperature_limit")	3✔
202	stl = cfg.get("VDI", "summer_temperature_limit")	3✔
203	days.loc[days["TAMB"] < wtl, "season_t"] = "W"	3✔
204	days.loc[days["TAMB"] >= wtl, "season_t"] = "U"	3✔
205	days.loc[days["TAMB"] > stl, "season_t"] = "S"	3✔
206	days.pop("TAMB")	3✔
207
208	if set_season == "temperature":	3!
209	days["season"] = days.pop("season_t")	3✔
210	days.pop("season_fix")	3✔
211	elif set_season == "fix":	×
212	days["season"] = days.pop("season_fix")	×
213	days.pop("season_t")	×
214	else:
215	msg = "Method <{0}> for the season does not exist."	×
216	raise NotImplementedError(msg.format(set_season))	×
217
218	# 2. Set second letter of type days: Day of the week
219	days.loc[days["weekday"] == 7, "day_of_week"] = "S"	3✔
220	days.loc[days["weekday"] < 7, "day_of_week"] = "W"	3✔
221	days.pop("weekday")	3✔
222
223	# 3. Set third letter of type days: Cloud coverage
224	days.loc[days["CCOVER"] >= 5, "cloud_coverage"] = "B"	3✔
225	days.loc[days["CCOVER"] < 5, "cloud_coverage"] = "H"	3✔
226	days.loc[days["season"] == "S", "cloud_coverage"] = "X"	3✔
227	days.pop("CCOVER")	3✔
228
229	# Combine the three letters in one column
230	days["day_types"] = (	3✔
231	days["season"] + days["day_of_week"] + days["cloud_coverage"]
232	)
233	days.drop(	3✔
234	["season", "day_of_week", "cloud_coverage"], axis=1, inplace=True
235	)
236	return days	3✔
237
238	def _load_profile_factors(self):	3✔
239	"""Run VDI 4655 - Step 2.
240
241	Match 'typtag' keys and reference load profile factors for each
242	timestep (for each 'typtag' key, one load profile is defined by
243	VDI 4655)
244	"""
245
246	# Load data of typical days from VDI
247	fn_typtage = os.path.join(	3✔
248	os.path.dirname(__file__), "vdi_data", "VDI_4655_Typtage.csv"
249	)
250	typtage_df = pd.read_csv(fn_typtage, index_col=[0, 1])	3✔
251
252	# Extract list of house types (expect: EFH, MFH)
253	house_types = list(typtage_df.index.get_level_values(0).unique())	3✔
254
255	# Convert time into datetime format
256	typtage_df["time"] = pd.to_datetime(	3✔
257	typtage_df.pop("Zeit"), format="%H:%M:%S"
258	)
259
260	# Calculate minutes of the day for every time step
261	typtage_df["minute_of_day"] = (	3✔
262	pd.to_timedelta(
263	typtage_df["time"]
264	- pd.Series(index=typtage_df.index, data=typtage_df["time"][0])
265	)
266	.dt.total_seconds()
267	.div(60)
268	.astype(int)
269	)
270
271	# Add columns to merge with (house types and day_types)
272	typtage_df["ht"] = typtage_df.index.get_level_values(0)	3✔
273	typtage_df["day_types"] = typtage_df.index.get_level_values(1)	3✔
274
275	# Create a table for every minute of the year
276	minute_table = pd.DataFrame(	3✔
277	index=pd.date_range(
278	f"1/1/{self._year}", periods=525600, freq="Min"
279	)
280	)
281
282	# Set reference time (first hour of the day) to calculate minutes of
283	# the day.
284	self.type_days["ref_dt"] = self.type_days.index	3✔
285
286	# Fill data into the large table with minute index
287	self.type_days = pd.concat(	3✔
288	[self.type_days, minute_table], axis=1
289	).ffill()
290
291	# Add columns to merge with (house types, minute of day and day_types)
292	self.type_days["datetime"] = self.type_days.index	3✔
293	self.type_days["minute_of_day"] = (	3✔
294	pd.to_timedelta(
295	self.type_days.pop("datetime")
296	- pd.Series(
297	index=self.type_days.index,
298	data=self.type_days.pop("ref_dt"),
299	)
300	)
301	.dt.total_seconds()
302	.div(60)
303	.astype(int)
304	)
305
306	# Merge table for both house type to get the value of every minute of
307	# the typical days for every minute of the year.
308	house_profiles = {}	3✔
309	for house_type in house_types:	3✔
310	self.type_days["ht"] = house_type	3✔
311	house_profiles[house_type] = self.type_days.merge(	3✔
312	typtage_df,
313	how="left",
314	left_on=["day_types", "minute_of_day", "ht"],
315	right_on=["day_types", "minute_of_day", "ht"],
316	).sort_index()
317
318	# Combine the table of both house type
319	load_profile = (	3✔
320	pd.concat(
321	[
322	house_profiles["EFH"][
323	["F_el_n_TT", "F_Heiz_n_TT", "F_TWW_n_TT"]
324	],
325	house_profiles["MFH"][
326	["F_el_n_TT", "F_Heiz_n_TT", "F_TWW_n_TT"]
327	],
328	],
329	keys=["EFH", "MFH"],
330	axis=1,
331	)
332	# .swaplevel(0, 1, axis=1)
333	.sort_index(axis=1)
334	)
335
336	# Set time index to make it possible to reshape the table
337	load_profile = load_profile.set_index(minute_table.index)	3✔
338	load_profile.ffill(inplace=True)	3✔
339	load_profile.loc[:, ("MFH", slice(None))] *= 1 / 15	3✔
340	return load_profile	3✔
341
342	def add_houses(self, houses):	3✔
343	"""
344
345	Parameters
346	----------
347	houses : list
348	A list of dictionaries that describes the houses.
349
350	"""
351	houses_wrong = [	3✔
352	h for h in houses if h["house_type"] not in ["EFH", "MFH"]
353	]
354	houses = [h for h in houses if h["house_type"] in ["EFH", "MFH"]]	3✔
355	for h in houses_wrong:	3!
356	msg = "<{0}> is a not supported house type and will be " "removed."	×
357	warnings.warn(msg.format(h["house_type"]), UserWarning)	×
358
359	if len(houses) > 0:	3!
360	self.houses.extend(houses)	3✔
361
362	def get_daily_energy_demand_houses(self):	3✔
363	"""Determine the houses' energy demand values for each 'typtag'.
364
365	.. note::
366	"The factors ``F_el_TT`` and ``F_TWW_TT`` are negative in some
367	cases as they represent a variation from a one-year average. The
368	values for the daily demand for electrical energy, ``W_TT``, and
369	DHW energy, ``Q_TWW_TT``, usually remain positive. It is only in
370	individual cases that the calculation for the typical-day category
371	``SWX`` can yield a negative value of the DHW demand. In that case,
372	assume ``F_TWW_SWX`` = 0." (VDI 4655, page 16)
373
374	This occurs when ``N_Pers`` or ``N_WE`` are too large.
375
376	"""
377	# typtage_combinations = settings["typtage_combinations"]
378	# houses_list = settings["houses_list_VDI"]
379
380	# Load the file containing the energy factors of the different typical
381	# radiation year (TRY) regions, house types and 'typtage'. In VDI 4655,
382	# these are the tables 10 to 24.
383	fn_energy_factors = os.path.join(	3✔
384	os.path.dirname(__file__),
385	"vdi_data",
386	"VDI_4655_Typtag-Faktoren.csv",
387	)
388	energy_factors = pd.read_csv(	3✔
389	fn_energy_factors,
390	index_col=[0, 1, 2],
391	)
392
393	# if settings.get("zero_summer_heat_demand", None) is not None:
394	# # Reduze the value of 'F_Heiz_TT' to zero.
395	# # For modern houses, this eliminates the heat demand in summer
396	# energy_factors_df.loc[
397	# (slice(None), slice(None), "F_Heiz_TT"), ("SWX", "SSX")
398	# ] = 0
399
400	# Create a new DataFrame with multiindex.
401	# It has two levels of columns: houses and energy
402	# The DataFrame stores the individual energy demands for each house in
403	# each time step
404	energy_demands_types = ["Q_Heiz_TT", "W_TT", "Q_TWW_TT"]	3✔
405	house_names = [n["name"] for n in self.houses]	3✔
406	iterables = [house_names, energy_demands_types]	3✔
407	multiindex = pd.MultiIndex.from_product(	3✔
408	iterables, names=["house", "energy"]
409	)
410	typtage_combinations = self.type_days["day_types"].unique()	3✔
411
412	daily_energy_demand_houses = pd.DataFrame(	3✔
413	index=multiindex, columns=typtage_combinations
414	)
415
416	# Fill the DataFrame daily_energy_demand_houses
417	for house in self.houses:	3✔
418	house_type = house["house_type"]	3✔
419	n_pers = house["N_Pers"]	3✔
420	n_we = house["N_WE"]	3✔
421	try_region = self._try_region	3✔
422
423	# Savety check:
424	if try_region not in energy_factors.index.get_level_values(0):	3!
425	msg = (	×
426	"Error! TRY "
427	+ str(try_region)
428	+ " not contained in file "
429	+ fn_energy_factors
430	)
431	msg2 = ' Skipping house "' + house["name"] + '"!'	×
432	warnings.warn(msg + "/n" + msg2, UserWarning)	×
433	continue # 'Continue' skips the rest of the current for-loop	×
434
435	# Get yearly energy demands
436	q_heiz_a = house["Q_Heiz_a"]	3✔
437	w_a = house["W_a"]	3✔
438	q_tww_a = house["Q_TWW_a"]	3✔
439
440	# (6.4) Do calculations according to VDI 4655 for each 'typtag'
441	for typtag in typtage_combinations:	3✔
442	f_heiz_tt = energy_factors.loc[	3✔
443	try_region, house_type, "F_Heiz_TT"
444	][typtag]
445	f_el_tt = energy_factors.loc[	3✔
446	try_region, house_type, "F_el_TT"
447	][typtag]
448	f_tww_tt = energy_factors.loc[	3✔
449	try_region, house_type, "F_TWW_TT"
450	][typtag]
451
452	q_heiz_tt = q_heiz_a * f_heiz_tt	3✔
453
454	if house_type == "EFH":	3✔
455	n_pers_we = n_pers	3✔
456	elif house_type == "MFH":	3!
457	n_pers_we = n_we	3✔
458	else:
459	n_pers_we = None	×
460
461	w_tt = w_a * (1.0 / 365.0 + n_pers_we * f_el_tt)	3✔
462	q_tww_tt = q_tww_a * (1.0 / 365.0 + n_pers_we * f_tww_tt)	3✔
463
464	if w_tt < 0:	3!
465	msg = (	×
466	"Warning: W_TT for "
467	+ house["name"]
468	+ " and "
469	+ typtag
470	+ " was negative, see VDI 4655 page 16"
471	)
472	warnings.warn(msg, UserWarning)	×
473	w_tt = w_a * (1.0 / 365.0 + n_pers_we * 0)	×
474
475	if q_tww_tt < 0:	3!
476	msg = (	×
477	"Warning: Q_TWW_TT for "
478	+ house["name"]
479	+ " and "
480	+ typtag
481	+ " was negative, see VDI 4655 page 16"
482	)
483	warnings.warn(msg, UserWarning)	×
484	q_tww_tt = q_tww_a * (1.0 / 365.0 + n_pers_we * 0)	×
485
486	# Write values into DataFrame
487	daily_energy_demand_houses.loc[house["name"], "Q_Heiz_TT"][	3✔
488	typtag
489	] = q_heiz_tt
490	daily_energy_demand_houses.loc[house["name"], "W_TT"][	3✔
491	typtag
492	] = w_tt
493	daily_energy_demand_houses.loc[house["name"], "Q_TWW_TT"][	3✔
494	typtag
495	] = q_tww_tt
496
497	# print(daily_energy_demand_houses)
498	return daily_energy_demand_houses	3✔
499
500	def get_load_curve_houses(self):	3✔
501	"""Generate the houses' energy demand values for each timestep.
502
503	Get the energy demand values for all days.
504
505	This functions works through the lists houses_list and
506	energy_factor_types day by day and multiplies the current load profile
507	value with the daily energy demand. It returns the result: the energy
508	demand values for all houses and energy types (in kWh)
509	"""
510	daily_energy_demand_houses = self.get_daily_energy_demand_houses()	3✔
511
512	house_profiles = {}	3✔
513
514	for house in self.houses:	3✔
515	df_typ = self.type_days.merge(	3✔
516	daily_energy_demand_houses.T[house["name"]],
517	left_on="day_types",
518	right_index=True,
519	).sort_index()
520	df_typ.drop(	3✔
521	["day_types", "minute_of_day", "ht"], axis=1, inplace=True
522	)
523
524	load_profile_df = self._load_profiles.rename(	3✔
525	columns={
526	"F_Heiz_n_TT": "Q_Heiz_TT",
527	"F_el_n_TT": "W_TT",
528	"F_TWW_n_TT": "Q_TWW_TT",
529	}
530	)
531
532	# df = pd.concat([df_typ, mytime], axis=1).ffill()
533	# df.drop(df.head(1).index, inplace=True)
534
535	load_curve_house = df_typ.mul(load_profile_df[house["house_type"]])	3✔
536
537	# The typical day calculation inherently does not add up to the
538	# desired total energy demand of the full year. Here we fix that:
539	# houses_dict = {h["name"]: h for h in self.houses}
540	for column in load_curve_house.columns:	3✔
541	q_a = house[column.replace("TT", "a")]	3✔
542	sum_ = load_curve_house[column].sum()	3✔
543	if sum_ > 0: # Would produce NaN otherwise	3!
544	load_curve_house[column] = (	3✔
545	load_curve_house[column] / sum_ * q_a
546	)
547	load_curve_house.columns = pd.MultiIndex.from_product(	3✔
548	[
549	[house["house_type"]],
550	load_curve_house.columns,
551	]
552	)
553	house_profiles[house["name"]] = load_curve_house	3✔
554	return pd.concat(	3✔
555	house_profiles.values(), keys=house_profiles.keys(), axis=1
556	)

oemof / demandlib / 2280705279

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