ebm 0.99.5__py3-none-any.whl

ebm/cmd/result_handler.py

@@ -0,0 +1,272 @@
+import pathlib
+import time
+
+from loguru import logger
+import pandas as pd
+
+from ebm.cmd.run_calculation import (calculate_building_category_area_forecast,
+                                     calculate_building_category_energy_requirements,
+                                     calculate_heating_systems)
+from ebm.model import bema
+from ebm.model.calibrate_heating_systems import group_heating_systems_by_energy_carrier
+from ebm.model.building_category import BuildingCategory
+from ebm.model.data_classes import YearRange
+from ebm.model.database_manager import DatabaseManager
+from ebm.services.spreadsheet import detect_format_from_values, find_max_column_width
+
+
+def transform_model_to_horizontal(model, value_column = 'm2'):
+    hz = model.reset_index().copy()
+    if 'energy_requirement' in hz.columns:
+        value_column = 'GWh'
+        hz['GWh'] = hz['energy_requirement'] / 10**6
+    hz = hz.groupby(by=['building_category', 'building_code', 'building_condition', 'year'], as_index=False).sum()[
+        ['building_category', 'building_code', 'building_condition', 'year', value_column]]
+    hz = hz.pivot(columns=['year'], index=['building_category', 'building_code', 'building_condition'], values=[
+        value_column]).reset_index()
+
+    hz = hz.sort_values(by=['building_category', 'building_code', 'building_condition'], key=bema.map_sort_order)
+    hz.insert(3, 'U', value_column)
+    hz.columns = ['building_category', 'building_code', 'building_condition', 'U'] + [y for y in range(2020, 2051)]
+
+    return hz
+
+
+def transform_to_sorted_heating_systems(df: pd.DataFrame, holiday_homes: pd.DataFrame,
+                                        building_column: str='building_category',
+                                        ) -> pd.DataFrame:
+    category_order = {'bloig': 100,
+                      'Bolig': 100,
+                      'Fritidsboliger': 200,
+                      'fritidsboliger': 200,
+                      'yrkesbygg': 300,
+                      'Yrkesbygg': 300}
+    energy_source = {'Elektrisitet': 10, 'Fjernvarme': 11,  'Bio': 12, 'Fossil': 13, 'Solar': 13,
+                     'Luft/luft': 24,  'Vannbåren varme': 25}
+
+    rs = pd.concat([df, holiday_homes]).reindex()
+    rs = rs.sort_values(by=[building_column, 'energy_source'],
+                   key=lambda x: x.map(category_order) if x.name == building_column else x.map(
+                       energy_source) if x.name == 'energy_source' else x)
+
+    hz = pd.concat([rs[~rs['energy_source'].isin(['Luft/luft', 'Vannbåren varme'])],
+                      rs[rs['energy_source'].isin(['Luft/luft', 'Vannbåren varme'])]])
+    hz.insert(2, 'U', 'GWh')
+    return hz
+
+
+def transform_heating_systems_to_horizontal(model: pd.DataFrame):
+    hs2 = model
+    energy_carrier_by_building_group = group_heating_systems_by_energy_carrier(hs2)
+
+    r2 = energy_carrier_by_building_group.reset_index()[['building_category', 'energy_source', 'year', 'energy_use']]
+    hz = r2.pivot(columns=['year'], index=['building_category', 'energy_source'],
+                  values=['energy_use']).reset_index()
+
+    hz.columns = ['building_category', 'energy_source'] + [y for y in range(2020, 2051)]
+    return hz
+
+
+def write_result(output_file, csv_delimiter, output, sheet_name='area forecast'):
+    logger.debug(f'Writing to {output_file}')
+    write_start = time.time()
+    if str(output_file) == '-':
+        try:
+            print(output.to_markdown())
+        except ImportError:
+            print(output.to_string())
+    elif output_file.suffix == '.csv':
+        output.to_csv(output_file, sep=csv_delimiter)
+        logger.success('Wrote {filename}', filename=output_file)
+    else:
+        excel_writer = pd.ExcelWriter(output_file, engine='openpyxl')
+        output.to_excel(excel_writer, sheet_name=sheet_name, merge_cells=False, freeze_panes=(1, 3))
+        excel_writer.close()
+        logger.success('Wrote {filename}', filename=output_file)
+
+    logger.debug(f'  wrote {output_file.stat().st_size/1000:.0} in {time.time() - write_start:.4} seconds')
+
+
+def append_result(output_file: pathlib.Path, df: pd.DataFrame, sheet_name='Sheet 1'):
+    """
+    Write df to output_file using sheet_name. If output_file already exists the sheet will be added tp ouput_file rather
+    than replacing the entire content.
+
+    Parameters
+    ----------
+    output_file :
+    df :
+    sheet_name :
+
+    Returns
+    -------
+
+    """
+    more_options = {'mode': 'w'}
+    if output_file.is_file():
+        more_options = {'if_sheet_exists': 'replace', 'mode': 'a'}
+
+    with pd.ExcelWriter(output_file, engine='openpyxl', **more_options) as writer:
+        df.to_excel(writer, sheet_name=sheet_name, index=False)
+        sheet = writer.sheets[sheet_name]
+
+        columns = sheet.iter_cols(min_row=1, max_row=sheet.max_row, min_col=1, max_col=sheet.max_column)
+
+        logger.debug('Formatting cell')
+        for col, (col_name, col_values) in zip(columns, df.items()):
+            cell_format = detect_format_from_values(col_name, col_values, df)
+            if cell_format:
+                for row in col[1:]:
+                    row.number_format = cell_format
+
+        logger.debug('Adjust columns width')
+        for col in sheet.iter_cols(min_col=1):
+            adjusted_width = find_max_column_width(col)
+            sheet.column_dimensions[col[0].column_letter].width = adjusted_width
+        logger.debug(f'Closing {output_file} {sheet_name}')
+    logger.debug(f'Wrote {output_file} {sheet_name}')
+
+
+class EbmDefaultHandler:
+    def extract_model(self,
+                      year_range: YearRange,
+                      building_categories: list[BuildingCategory] | None,
+                      database_manager: DatabaseManager,
+                      step_choice: str='energy-use') -> pd.DataFrame:
+        """
+        Extract dataframe for a certain step in the ebm model.
+
+        Possible steps are energy_use (default), heating-systems, energy-use, area-forecast
+
+        Parameters
+        ----------
+        year_range : ebm.model.dataclasses.YearRange
+        building_categories : list[BuildingCategory]
+        database_manager : ebm.model.database_manager.DatabaseManager
+        step_choice : str, optional
+
+        Returns
+        -------
+        pd.DataFrame
+        """
+        b_c = building_categories if building_categories else [e for e in BuildingCategory]
+        area_forecast = self.extract_area_forecast(b_c,
+                                                   database_manager,
+                                                   period=year_range)
+        area_forecast = area_forecast.set_index(['building_category', 'building_code', 'building_condition', 'year'])
+        df = area_forecast
+
+        if 'energy-requirements' in step_choice or 'heating-systems' in step_choice or 'energy-use' in step_choice:
+            logger.debug('Extracting area energy requirements')
+            energy_requirements_result = self.extract_energy_requirements(b_c,
+                                                                          database_manager,
+                                                                          area_forecast,
+                                                                          period=year_range)
+            df = energy_requirements_result
+
+            if 'heating-systems' in step_choice or 'energy-use' in step_choice:
+                logger.debug('Extracting heating systems')
+                df = calculate_heating_systems(energy_requirements=energy_requirements_result,
+                                               database_manager=database_manager)
+        return df
+
+    # noinspection PyTypeChecker
+    @staticmethod
+    def extract_energy_requirements(building_categories,
+                                    database_manager: DatabaseManager,
+                                    area_forecast: pd.DataFrame,
+                                    period: YearRange) -> pd.DataFrame:
+        """
+        Extracts energy needs for building_categories and period
+
+        Parameters
+        ----------
+        building_categories : list[BuildingCategory]
+        database_manager : ebm.model.database_manager.DatabaseManager
+        area_forecast : pd.DataFrame
+        period :ebm.model.dataclasses.YearRange
+
+        Returns
+        -------
+        pd.DataFrame
+
+        """
+        energy_requirements_result = calculate_building_category_energy_requirements(
+            building_category=building_categories,
+            area_forecast=area_forecast,
+            database_manager=database_manager,
+            start_year=period.start,
+            end_year=period.end)
+        return energy_requirements_result
+
+
+    @staticmethod
+    def extract_area_forecast(building_categories,
+                              database_manager: DatabaseManager,
+                              period: YearRange) -> pd.DataFrame:
+
+        area_forecast = calculate_building_category_area_forecast(
+                database_manager=database_manager,
+                start_year=period.start,
+                end_year=period.end)
+
+        return area_forecast
+
+    @staticmethod
+    def write_tqdm_result(output_file: pathlib.Path, output: pd.DataFrame, csv_delimiter: str=',', reset_index=True):
+        try:
+            from tqdm import tqdm
+        except ImportError:
+            # When tqdm is not installed we use write_result instead
+            write_result(output_file, csv_delimiter, output)
+            return
+
+        logger.debug(f'Writing to {output_file}')
+
+        if str(output_file) == '-':
+            try:
+                print(output.to_markdown())
+            except ImportError:
+                print(output.to_string())
+                return
+
+        if reset_index:
+            logger.debug('Resetting dataframe index')
+            output = output.reset_index()
+
+        chunk_size = 2000
+        logger.debug(f'{chunk_size=}')
+
+        closing_file = time.time()
+        with tqdm(total=len(output), desc="Writing to spreadsheet") as pbar:
+            write_file = time.time()
+            if output_file.suffix == '.csv':
+                for i in range(0, len(output), chunk_size):  # Adjust the chunk size as needed
+                    building_category = output.iloc[i].building_category
+                    pbar.update(chunk_size)
+                    output.iloc[i:i + chunk_size].to_csv(output_file, mode='a', header=(i == 0), index=False,
+                                                         sep=csv_delimiter)
+                    pbar.display(f'Writing {building_category}')
+                closing_file = time.time()
+                pbar.display(f'Wrote {output_file}')
+            else:
+                with pd.ExcelWriter(output_file, engine='xlsxwriter') as excel_writer:
+                    for i in range(0, len(output), chunk_size):  # Adjust the chunk size as needed
+                        building_category = output.iloc[i].name[0] if 'building_category' not in output.columns else \
+                        output.building_category.iloc[i]
+                        pbar.set_description(f'Writing {building_category}')
+                        start_row = 0 if i == 0 else i + 1
+                        page_start = i
+                        page_end = min(i + chunk_size, len(output))
+                        logger.trace(f'{start_row=} {page_start=} {page_end=}')
+                        output.iloc[page_start:page_end].to_excel(excel_writer, startrow=start_row, header=(i == 0),
+                                                                  merge_cells=True, index=not reset_index)
+                        pbar.update(chunk_size)
+                    pbar.set_description(f'Closing {output_file}')
+                    closing_file = time.time()
+        logger.success('Wrote {filename}', filename=output_file)
+        logger.debug(f'  wrote dataframe in { closing_file - write_file:.4} seconds')
+        logger.debug(f'  closed file in {time.time() - closing_file:.4} seconds')
+        logger.debug(f'  wrote {int(output_file.stat().st_size/1_000_000):_d} MB in {time.time() - write_file:.4} seconds')
+
+

ebm/cmd/run_calculation.py

@@ -0,0 +1,221 @@
+import os
+import pathlib
+from typing import Dict
+
+import pandas as pd
+from loguru import logger
+
+from ebm.extractors import extract_area_forecast
+from ebm.model.building_category import BuildingCategory
+
+from ebm.model.data_classes import YearRange
+from ebm.model.database_manager import DatabaseManager
+from ebm.model.energy_requirement import EnergyRequirement
+from ebm.energy_consumption import EnergyConsumption
+from ebm.heating_system_forecast import HeatingSystemsForecast
+from ebm.s_curve import calculate_s_curves
+
+
+def area_forecast_result_to_dataframe(forecast: pd.DataFrame) -> pd.DataFrame:
+    """
+    Create a dataframe from a forecast
+
+    Parameters
+    ----------
+    forecast : Dict[str, list[float]]
+
+    Returns dataframe : pd.Dataframe
+        A dataframe of all area values in forecast indexed by building_category, tek and year
+    -------
+
+    """
+    return forecast
+
+
+# noinspection PyTypeChecker
+def result_to_horizontal_dataframe(result: pd.DataFrame) -> pd.DataFrame:
+    """
+    Create a dataframe from a forecast with years listed horizontally start to end year
+
+    Parameters
+    ----------
+    result : pd.DataFrame:
+
+    Returns
+    -------
+    dataframe : pd.Dataframe
+        A dataframe of all area values in forecast indexed by building_category, tek and year
+
+
+    """
+    stacked = result.stack().to_frame().reset_index()
+
+    columns = 'year'
+    index = list(filter(lambda x: x != columns and x != 'index' and x not in [0], stacked.columns))
+    values = stacked.columns[-1]
+
+    df = stacked.pivot(columns=columns, index=index, values=values)
+
+    df.index.names = df.index.names[:-1] + ['unit']
+    return df
+
+
+def validate_years(start_year: int, end_year: int) -> YearRange:
+    """
+    Validates the start and end year arguments and returns a YearRange
+
+    Parameters
+    ----------
+    end_year : int
+        The end year to validate.
+    start_year : int
+        The start year to validate.
+
+    Returns
+    -------
+    YearRange
+        from start_year to end_year
+
+    Raises
+    ------
+    ValueError
+        If `start_year` is greater than or equal to `end_year`.
+        If `end_year` is not exactly 40 years after `start_year`.
+        If `start_year` is not 2010 or `end_year` is not 2050.
+    """
+    if start_year >= end_year:
+        msg = f'Unexpected input start year ({start_year} is greater than end year ({end_year})'
+        raise ValueError(msg)
+    if start_year < 2010:
+        msg = f'Unexpected start_year={start_year}. The minimum start year is 2010'
+        raise ValueError(msg)
+    if end_year > 2070:
+        msg = f'Unexpected end_year={end_year}. Max end_year year is 2070'
+        raise ValueError(msg)
+    return YearRange(start_year, end_year)
+
+
+def calculate_building_category_energy_requirements(building_category: BuildingCategory,
+                                                    area_forecast,
+                                                    database_manager: DatabaseManager,
+                                                    start_year: int,
+                                                    end_year: int,
+                                                    calibration_year: int = 2019) -> pd.DataFrame:
+    """
+    Calculate energy need by building_category, TEK, building_condition and purpose.
+
+    The parameter building_category is not used and should be removed.
+
+    Parameters
+    ----------
+    building_category : BuildingCategory, unused
+    area_forecast : pd.DataFrame
+    database_manager : DatabaseManager
+    start_year : int
+    end_year : int
+    calibration_year : int, optional
+
+    Returns
+    -------
+    pd.DataFrame
+    """
+    energy_requirement = EnergyRequirement.new_instance(
+        period=YearRange(start_year, end_year),
+        calibration_year=calibration_year if calibration_year > start_year else start_year,
+        database_manager=database_manager)
+    df = energy_requirement.calculate_for_building_category(database_manager=database_manager)
+
+    df = df.set_index(['building_category', 'building_code', 'purpose', 'building_condition', 'year'])
+
+    q = area_forecast.reset_index()
+
+    q = q.set_index(['building_category', 'building_code', 'building_condition', 'year'])
+
+    merged = q.merge(df, left_index=True, right_index=True)
+    merged['energy_requirement'] = merged.kwh_m2 * merged.m2
+
+    return merged
+
+
+def write_to_disk(constructed_floor_area, building_category: BuildingCategory):
+    """Writes constructed_floor_area to disk if the environment variable EBM_WRITE_TO_DISK is True"""
+    if os.environ.get('EBM_WRITE_TO_DISK', 'False').upper() == 'TRUE':
+        df = result_to_horizontal_dataframe(constructed_floor_area)
+        df.insert(0, 'building_category', building_category)
+        file_path = pathlib.Path('output/construction.xlsx')
+        df.index.name = 'series'
+
+        if building_category == BuildingCategory.HOUSE or not file_path.is_file():
+            df.to_excel(file_path, sheet_name='construction')
+            logger.debug(f'Wrote {file_path}')
+        else:
+            with pd.ExcelWriter(file_path, engine='openpyxl', mode='a', if_sheet_exists='overlay') as writer:
+                start_row = writer.sheets['construction'].max_row
+                df.to_excel(writer, sheet_name='construction', index=True, header=False, startrow=start_row)
+            logger.debug(f'Added {building_category} to {file_path}')
+
+
+def calculate_building_category_area_forecast(database_manager: DatabaseManager,
+                                              start_year: int,
+                                              end_year: int) -> pd.DataFrame:
+    """
+    Calculates the area forecast for a given building category from start to end year (including).
+
+    Parameters
+    ----------
+    database_manager : DatabaseManager
+        The database manager used to interact with the database.
+    start_year : int
+        The starting year of the forecast period.
+    end_year : int
+        The ending year of the forecast period.
+
+    Returns
+    -------
+    pd.DataFrame
+        A dictionary where keys are strings representing different area categories and values are lists of floats
+            representing the forecasted areas for each year in the specified period.
+
+    Notes
+    -----
+    This function builds the buildings for the specified category, calculates the area forecast, and accounts for
+        demolition and construction over the specified period.
+    """
+    building_code_parameters = database_manager.file_handler.get_building_code()
+    years = YearRange(start_year, end_year)
+    scurve_params = database_manager.get_scurve_params()
+    s_curves_by_condition = calculate_s_curves(scurve_params, building_code_parameters, years)
+
+    area_forecast = extract_area_forecast(years,
+                                          building_code_parameters=building_code_parameters,
+                                          area_parameters=database_manager.get_area_parameters(),
+                                          s_curves_by_condition=s_curves_by_condition,
+                                          database_manager=database_manager)
+
+    return area_forecast
+
+
+def calculate_heating_systems(energy_requirements, database_manager: DatabaseManager) -> pd.DataFrame:
+    """
+    Calculate heating systems projection, efficiencies and multiplies by energy_requirements for total energy use
+    by building_category, TEK, building_condition, purpose and heating_system.
+
+    Parameters
+    ----------
+    energy_requirements : pd.DataFrame
+    database_manager : ebm.model.database_manager.DatabaseManager
+
+    Returns
+    -------
+    pd.DataFrame
+
+    """
+    projection_period = YearRange(2023, 2050)
+    hsp = HeatingSystemsForecast.new_instance(projection_period, database_manager)
+    hf = hsp.calculate_forecast()
+    hf = hsp.pad_projection(hf, YearRange(2020, 2022))
+    calculator = EnergyConsumption(hf)
+    calculator.heating_systems_parameters = calculator.grouped_heating_systems()
+    df = calculator.calculate(energy_requirements)
+
+    return df

ebm/data/area.csv

@@ -0,0 +1,92 @@
+building_category,building_code,area
+apartment_block,PRE_TEK49,12777246.0
+apartment_block,TEK49,12793316.0
+apartment_block,TEK69,12679268.0
+apartment_block,TEK87,4623808.0
+apartment_block,TEK97,10024890.0
+apartment_block,TEK07,3477435.0
+apartment_block,TEK10,11245568.0
+house,PRE_TEK49,49408249.0
+house,TEK49,71191856.0
+house,TEK69,75010253.0
+house,TEK87,26804616.0
+house,TEK97,24161659.0
+house,TEK07,8933605.0
+house,TEK10,17513757.0
+kindergarten,PRE_TEK49,360687.0
+kindergarten,TEK49,395768.0
+kindergarten,TEK69,465007.0
+kindergarten,TEK87,459412.0
+kindergarten,TEK97,480468.0
+kindergarten,TEK07,445252.0
+kindergarten,TEK10,453523.0
+school,PRE_TEK49,2918530.0
+school,TEK49,3825312.0
+school,TEK69,2939528.0
+school,TEK87,1024007.0
+school,TEK97,1381987.0
+school,TEK07,964171.0
+school,TEK10,1885803.0
+university,PRE_TEK49,470005.0
+university,TEK49,543934.0
+university,TEK69,690131.0
+university,TEK87,521868.0
+university,TEK97,517805.0
+university,TEK07,226949.0
+university,TEK10,186877.0
+office,PRE_TEK49,5055317.0
+office,TEK49,4858542.0
+office,TEK69,6539198.0
+office,TEK87,4264029.0
+office,TEK97,3681521.0
+office,TEK07,1975791.0
+office,TEK10,3055337.0
+retail,PRE_TEK49,4886906.0
+retail,TEK49,6252160.0
+retail,TEK69,7127892.0
+retail,TEK87,3683906.0
+retail,TEK97,4189579.0
+retail,TEK07,2560015.0
+retail,TEK10,3357155.0
+hotel,PRE_TEK49,1940825.0
+hotel,TEK49,1850727.0
+hotel,TEK69,1519726.0
+hotel,TEK87,749441.0
+hotel,TEK97,942380.0
+hotel,TEK07,677755.0
+hotel,TEK10,802546.0
+hospital,PRE_TEK49,701476.0
+hospital,TEK49,674212.0
+hospital,TEK69,635074.0
+hospital,TEK87,357828.0
+hospital,TEK97,576819.0
+hospital,TEK07,82335.0
+hospital,TEK10,414770.0
+nursing_home,PRE_TEK49,991462.0
+nursing_home,TEK49,1383981.0
+nursing_home,TEK69,1481965.0
+nursing_home,TEK87,670938.0
+nursing_home,TEK97,1427901.0
+nursing_home,TEK07,289386.0
+nursing_home,TEK10,630817.0
+culture,PRE_TEK49,1909630.0
+culture,TEK49,1923480.0
+culture,TEK69,1439745.0
+culture,TEK87,781280.0
+culture,TEK97,508477.0
+culture,TEK07,260411.0
+culture,TEK10,378210.0
+sports,PRE_TEK49,531426.0
+sports,TEK49,703080.0
+sports,TEK69,1132460.0
+sports,TEK87,961208.0
+sports,TEK97,1109723.0
+sports,TEK07,581204.0
+sports,TEK10,1451364.0
+storage_repairs,PRE_TEK49,2650280
+storage_repairs,TEK49,3505868
+storage_repairs,TEK69,3577553
+storage_repairs,TEK87,2039191
+storage_repairs,TEK97,3081789
+storage_repairs,TEK07,1953926
+storage_repairs,TEK10,3562046

ebm/data/area_new_residential_buildings.csv

@@ -0,0 +1,3 @@
+year,house,apartment_block
+2020,"0.0","0.0"
+2021,"2733711.49774",1152796

ebm/data/area_per_person.csv

@@ -0,0 +1,12 @@
+building_category,area_per_person
+kindergarten,0.6
+retail,6.0
+hotel,1.6
+sports,1.3
+office,5.5
+culture,1.3
+school,2.8
+nursing_home,1.3
+hospital,0.6
+university,0.6
+storage_repairs,3.4

ebm/data/building_code_parameters.csv

@@ -0,0 +1,9 @@
+building_code,building_year,period_start_year,period_end_year
+PRE_TEK49,1945,0,1948
+TEK49,1962,1949,1968
+TEK69,1977,1969,1986
+TEK87,1991,1987,1996
+TEK97,2002,1997,2006
+TEK07,2012,2007,2010
+TEK10,2018,2011,2019
+TEK17,2025,2020,2050

ebm/data/energy_need_behaviour_factor.csv

@@ -0,0 +1,6 @@
+building_category,building_code,purpose,behaviour_factor,start_year,end_year
+residential,default,default,1,2020,2050
+house,PRE_TEK49+TEK69+TEK87+TEK49+TEK97,default,0.85,,
+house,TEK07+TEK10+TEK17,lighting,0.85,2020,2050
+non_residential,default,default,1.15,,
+retail,default,electrical_equipment,2,,

ebm/data/energy_need_improvements.csv

@@ -0,0 +1,7 @@
+building_category,building_code,purpose,function,start_year,value,end_year
+default,default,cooling,yearly_reduction,2020,0.0,2050
+default,default,electrical_equipment,yearly_reduction,2021,0.01,2050
+default,default,fans_and_pumps,yearly_reduction,2020,0.0,2050
+default,default,heating_dhw,yearly_reduction, 2020,0.0,2050
+default,default,lighting,improvement_at_end_year,2020,0.5555555555555556,2030
+default,default,lighting,yearly_reduction,2031,0.005,2050