2155726232

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/32486d87a6cc416a172fa479a831e1fea1830530">32486d87a<a href="https://github.com/oemof/demandlib/commit/32486d87a6cc416a172fa479a831e1fea1830530">&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/32486d87a6cc416a172fa479a831e1fea1830530&quot;&gt;32486d87a&lt;/a&gt;&lt;a href=&quot;https://github.com/oemof/demandlib/commit/32486d87a6cc416a172fa479a831e1fea1830530&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/oemof/demandlib/commit/32486d87a6cc416a172fa479a831e1fe&lt;/a&gt;a1830530">&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/4eeed80bb646dd02875cb7e3ca2f5295e8728991">4eeed80bb</a><a href="https://github.com/oemof/demandlib/commit/32486d87a6cc416a172fa479a831e1fea1830530">&amp;quot;&amp;gt;4eeed80bb&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;4eeed80bb&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/oemof/demandlib/commit/32486d87a6cc416a172fa479a831e1fea1830&lt;/a&gt;530&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

75 of 96 branches covered (78.13%)

Branch coverage included in aggregate %.

186 of 186 new or added lines in 3 files covered. (100.0%)

415 of 447 relevant lines covered (92.84%)

2.79 hits per line

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

83.5

/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)*

Copyright:

    *Verein Deutscher Ingenieure e.V.*

    *VDI Standards Department*

    *VDI-Platz 1, 40468 Duesseldorf, Germany*

Reproduced with the permission of the Verein Deutscher Ingenieure e.V.,
for non-commercial use only.

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

oemof / demandlib / 2155726232

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