ebm 0.99.3__py3-none-any.whl

ebm/data/holiday_home_energy_consumption.csv

@@ -0,0 +1,24 @@
+year,electricity,fuelwood,fossilfuel
+2001,1128,,
+2002,1173,,
+2003,1183,,
+2004,1161,,
+2005,1235,,
+2006,1317,880.0,100.0
+2007,1407,1050.0,
+2008,1522,1140.0,
+2009,1635,1090.0,
+2010,1931,1180.0,
+2011,1818,990.0,
+2012,1929,700.0,
+2013,2141,1000.0,
+2014,2006,900.0,
+2015,2118,1180.0,
+2016,2278,1100.0,
+2017,2350,1070.0,
+2018,2417,1230.0,
+2019,2384,1170.0,
+2020,2467,1450.0,
+2021,2819,1270.0,
+2022,2318,1390.0,
+2023,2427,1390.0,

ebm/data/holiday_home_stock.csv

@@ -0,0 +1,25 @@
+"year","Existing buildings Chalet, summerhouses and other holiday houses","Existing buildings Detached houses and farmhouses used as holiday houses"
+"2001",354060,23267
+"2002",358997,26514
+"2003",363889,26758
+"2004",368933,26998
+"2005",374470,27376
+"2006",379169,27604
+"2007",383112,27927
+"2008",388938,28953
+"2009",394102,29593
+"2010",398884,30209
+"2011",405883,32374
+"2012",410333,32436
+"2013",413318,32600
+"2014",416621,32539
+"2015",419449,32559
+"2016",423041,32727
+"2017",426932,32808
+"2018",431028,32891
+"2019",434809,32869
+"2020",437833,32906
+"2021",440443,33099
+"2022",445715,33283
+"2023",449009,32819
+"2024",450492,32442

ebm/data/improvement_building_upgrade.csv

@@ -0,0 +1,9 @@
+building_category,building_code,purpose,building_condition,reduction_share
+default,default,heating_rv,original_condition,0.0
+default,default,heating_rv,small_measure,0.07
+default,default,heating_rv,renovation,0.2
+default,default,heating_rv,renovation_and_small_measure,0.25
+default,TEK17,heating_rv,original_condition,0.0
+default,TEK17,heating_rv,small_measure,0.02
+default,TEK17,heating_rv,renovation,0.05
+default,TEK17,heating_rv,renovation_and_small_measure,0.07

ebm/data/new_buildings_residential.csv

@@ -0,0 +1,32 @@
+"year",new_house_share,new_apartment_block_share,floor_area_new_house,flood_area_new_apartment_block
+"2020","0.4532258064516","0.5467741935484","175","75"
+"2021","0.4514516129032","0.5485483870968","175","75"
+"2022","0.4496774193548","0.5503225806452","175","75"
+"2023","0.4479032258065","0.5520967741935","175","75"
+"2024","0.4461290322581","0.5538709677419","175","75"
+"2025","0.4443548387097","0.5556451612903","175","75"
+"2026","0.4425806451613","0.5574193548387","175","75"
+"2027","0.4408064516129","0.5591935483871","175","75"
+"2028","0.4390322580645","0.5609677419355","175","75"
+"2029","0.4372580645161","0.5627419354839","175","75"
+"2030","0.4354838709677","0.5645161290323","175","75"
+"2031","0.4337096774194","0.5662903225806","175","75"
+"2032","0.4319354838710","0.5680645161290","175","75"
+"2033","0.4301612903226","0.5698387096774","175","75"
+"2034","0.4283870967742","0.5716129032258","175","75"
+"2035","0.4266129032258","0.5733870967742","175","75"
+"2036","0.4248387096774","0.5751612903226","175","75"
+"2037","0.4230645161290","0.5769354838710","175","75"
+"2038","0.4212903225806","0.5787096774194","175","75"
+"2039","0.4195161290323","0.5804838709677","175","75"
+"2040","0.4177419354839","0.5822580645161","175","75"
+"2041","0.4159677419355","0.5840322580645","175","75"
+"2042","0.4141935483871","0.5858064516129","175","75"
+"2043","0.4124193548387","0.5875806451613","175","75"
+"2044","0.4106451612903","0.5893548387097","175","75"
+"2045","0.4088709677419","0.5911290322581","175","75"
+"2046","0.4070967741935","0.5929032258065","175","75"
+"2047","0.4053225806452","0.5946774193548","175","75"
+"2048","0.4035483870968","0.5964516129032","175","75"
+"2049","0.4017741935484","0.5982258064516","175","75"
+"2050","0.4000000000000","0.6000000000000","175","75"

ebm/data/population_forecast.csv

@@ -0,0 +1,51 @@
+year,population,household_size
+2001,4503436,
+2002,4524066,
+2003,4552252,
+2004,4577457,
+2005,4606363,
+2006,4640219,
+2007,4681134,
+2008,4737171,
+2009,4799252,
+2010,4858199,2.22
+2011,4920305,2.22
+2012,4985870,2.22
+2013,5051275,2.2
+2014,5109056,2.2
+2015,5165802,2.2
+2016,5213985,2.19
+2017,5258317,2.19
+2018,5295619,2.17
+2019,5328212,2.16
+2020,5367580,2.15
+2021,5391369,2.14
+2022,5425270,2.13
+2023,5488984,2.12
+2024,5550203,2.115
+2025,5600121,2.11
+2026,5638838,2.105
+2027,5666689,2.1
+2028,5694657,2.095
+2029,5722427,2.09
+2030,5749712,2.085
+2031,5776723,2.081
+2032,5803284,2.077
+2033,5829350,2.073
+2034,5855072,2.07
+2035,5880318,2.067
+2036,5905184,2.064
+2037,5928866,2.062
+2038,5951491,2.06
+2039,5973100,2.059
+2040,5993766,2.058
+2041,6013501,2.057
+2042,6032325,2.056
+2043,6050194,2.055
+2044,6067121,2.054
+2045,6083032,2.053
+2046,6097893,2.052
+2047,6111684,2.051
+2048,6124356,2.05
+2049,6135899,2.05
+2050,6146321,2.05

ebm/data/s_curve.csv

@@ -0,0 +1,40 @@
+building_category,condition,earliest_age_for_measure,average_age_for_measure,rush_period_years,last_age_for_measure,rush_share,never_share
+apartment_block,small_measure,5,20,20,50,0.8,0.1
+apartment_block,renovation,10,30,14,60,0.6,0.15
+apartment_block,demolition,60,90,40,150,0.7,0.05
+house,small_measure,3,23,30,80,0.8,0.01
+house,renovation,10,37,24,75,0.65,0.05
+house,demolition,60,90,40,150,0.7,0.05
+kindergarten,small_measure,3,25,20,50,0.8,0.01
+kindergarten,renovation,10,50,40,90,0.7,0.05
+kindergarten,demolition,50,100,30,130,0.7,0.05
+school,small_measure,5,25,20,50,0.8,0.01
+school,renovation,10,50,44,90,0.65,0.05
+school,demolition,50,100,30,130,0.7,0.05
+university,small_measure,5,25,20,50,0.8,0.01
+university,renovation,15,60,30,100,0.6,0.05
+university,demolition,50,100,30,130,0.7,0.05
+office,small_measure,3,20,20,50,0.8,0.01
+office,renovation,5,55,40,95,0.5,0.1
+office,demolition,50,100,30,130,0.7,0.05
+retail,small_measure,3,20,20,50,0.8,0.01
+retail,renovation,5,48,34,80,0.6,0.1
+retail,demolition,50,100,30,130,0.7,0.05
+hotel,small_measure,3,20,20,50,0.8,0.01
+hotel,renovation,5,45,30,80,0.65,0.02
+hotel,demolition,50,100,30,130,0.7,0.05
+hospital,small_measure,3,20,20,50,0.8,0.01
+hospital,renovation,10,55,30,90,0.7,0.05
+hospital,demolition,50,100,30,130,0.7,0.05
+nursing_home,small_measure,3,20,20,50,0.8,0.01
+nursing_home,renovation,5,45,40,80,0.7,0.05
+nursing_home,demolition,50,100,30,130,0.7,0.05
+culture,small_measure,3,20,20,50,0.8,0.01
+culture,renovation,5,65,40,100,0.75,0.05
+culture,demolition,50,100,30,130,0.7,0.05
+sports,small_measure,3,20,20,50,0.8,0.01
+sports,renovation,15,70,40,120,0.65,0.05
+sports,demolition,50,100,30,130,0.7,0.05
+storage_repairs,small_measure,3,20,20,50,0.8,0.01
+storage_repairs,renovation,5,45,40,80,0.7,0.05
+storage_repairs,demolition,50,100,30,130,0.7,0.05

ebm/energy_consumption.py

@@ -0,0 +1,307 @@
+from loguru import logger
+import pandas as pd
+
+from ebm.model.energy_purpose import EnergyPurpose
+from ebm.model.filter_tek import FilterTek
+
+ADJUSTED_REQUIREMENT = 'eq_ts'
+# there are 3 time-of-use zones: peak, shoulder and offpeak.
+HEATING_RV_BASE_TOTAL = 'RV_GL'
+HEATING_RV_PEAK_TOTAL = 'RV_SL'
+HEATING_RV_TERTIARY_TOTAL = 'RV_EL'
+HEAT_PUMP = 'RV_HP'
+COOLING_TOTAL = 'CL_KV'
+DHW_TOTAL = 'DHW_TV'
+OTHER_TOTAL = 'O_SV'
+HEATING_RV = 'heating_rv'
+HEATING_DHW = 'heating_dhw'
+COOLING = 'cooling'
+DHW_EFFICIENCY = 'domestic_hot_water_efficiency'
+
+HEATING_SYSTEMS = 'heating_systems'
+HEATING_SYSTEM_SHARE = 'heating_system_share'
+GRUNNLAST_ANDEL = 'base_load_coverage'
+BASE_LOAD_EFFICIENCY = 'base_load_efficiency'
+COOLING_EFFICIENCY = 'cooling_efficiency'
+SPESIFIKT_ELFORBRUK = 'Spesifikt elforbruk'
+TERTIARY_LOAD_COVERAGE = 'tertiary_load_coverage'
+TERTIARY_LOAD_EFFICIENCY = 'tertiary_load_efficiency'
+PEAK_LOAD_COVERAGE = 'peak_load_coverage'
+PEAK_LOAD_EFFICIENCY = 'peak_load_efficiency'
+
+BASE_LOAD_ENERGY_PRODUCT = 'base_load_energy_product'
+PEAK_LOAD_ENERGY_PRODUCT = 'peak_load_energy_product'
+TERTIARY_LOAD_ENERGY_PRODUCT = 'tertiary_load_energy_product'
+DOMESTIC_HOT_WATER_ENERGY_PRODUCT = 'domestic_hot_water_energy_product'
+HP_ENERGY_SOURCE = 'hp_source'
+
+
+class EnergyConsumption:
+    def __init__(self, heating_systems_parameters: pd.DataFrame = None):
+        self.heating_systems_parameters = heating_systems_parameters
+
+    def grouped_heating_systems(self) -> pd.DataFrame:
+        """
+        Groups and sums heating_system_parameters over building_category, TEK, Oppvarmingstyper. All excess values will
+            be summed.
+
+        Returns
+        -------
+        pd.DataFrame
+            heating_systems_parameters grouped and summed
+        """
+        df = self.heating_systems_parameters
+        df = df.rename(columns={'heating_system_share': HEATING_SYSTEM_SHARE})
+
+        aggregates = {'base_load_energy_product': 'first', 'peak_load_energy_product': 'first',
+                      'tertiary_load_energy_product': 'first', 'domestic_hot_water_energy_product': 'first', HEATING_SYSTEM_SHARE: 'sum',
+                      TERTIARY_LOAD_COVERAGE: 'sum', GRUNNLAST_ANDEL: 'sum', PEAK_LOAD_COVERAGE: 'sum',
+                      BASE_LOAD_EFFICIENCY: 'sum', PEAK_LOAD_EFFICIENCY: 'sum', TERTIARY_LOAD_EFFICIENCY: 'sum',
+                      DHW_EFFICIENCY: 'sum', SPESIFIKT_ELFORBRUK: 'sum', COOLING_EFFICIENCY: 'sum'}
+        grouped = df.groupby(by=['building_category', 'building_code', 'year', HEATING_SYSTEMS]).agg(aggregates)
+        return grouped.reset_index()
+
+    def calculate(self, energy_requirements: pd.DataFrame) -> pd.DataFrame:
+        """
+        calculate energy usage by from energy_requirements and heating_systems_parameters
+
+        Parameters
+        ----------
+        energy_requirements : pd.DataFrame
+
+        Returns
+        -------
+        pd.DataFrame
+
+        """
+        logger.debug('Calculate heating systems')
+        if all([col in energy_requirements.columns for col in ['building_category', 'building_code', 'building_condition', 'year', 'purpose']]):
+            energy_requirements = energy_requirements.set_index(['building_category', 'building_code', 'building_condition', 'year', 'purpose'])
+        energy_requirements = self._remove_building_code_suffix(energy_requirements)
+        energy_requirements = self._group_and_sum_same_building_code(energy_requirements)
+
+        # If _RES of _COM is in building_codethis will not work
+        # energy_requirements.index[energy_requirements.index.str.endswith('_RES')]
+        if energy_requirements.index.get_level_values('building_code').str.endswith(
+                '_RES').any() or energy_requirements.index.get_level_values('building_code').str.endswith('_COM').any():
+            raise ValueError('Found _RES or _COM in energy_requirements')
+        self.heating_systems_parameters = self.heating_systems_parameters.rename(columns={'heating_system_share': HEATING_SYSTEM_SHARE})
+        # Merge energy_requirements and heating_systems into df
+        df = self._merge_energy_requirement_and_heating_systems(energy_requirements)
+
+        # Make column eq_ts for heating_system_share adjusted energy requirement
+        df[ADJUSTED_REQUIREMENT] = (df.energy_requirement * df[HEATING_SYSTEM_SHARE]).astype(float)
+
+        # Zero fill columns before calculating to prevent NaN from messing up sums
+        df.loc[:, [HEATING_RV_BASE_TOTAL, HEATING_RV_PEAK_TOTAL, HEATING_RV_TERTIARY_TOTAL, DHW_TOTAL, COOLING_TOTAL, OTHER_TOTAL,
+                   HEAT_PUMP]] = 0.0
+
+        # Adjust energy requirements by efficiency
+        # heating rv
+
+        df = self.adjust_heat_pump(df)
+        df = self.adjust_heating_rv(df)
+        df = self.adjust_heating_dhw(df)
+        df = self.adjust_cooling(df)
+        df = self.adjust_other(df)
+
+        # sum energy use
+        df.loc[:, 'kwh'] = df.loc[:,
+                           [HEATING_RV_BASE_TOTAL, HEATING_RV_PEAK_TOTAL, HEATING_RV_TERTIARY_TOTAL, DHW_TOTAL, COOLING_TOTAL,
+                            OTHER_TOTAL]].sum(axis=1)
+
+        df.loc[:, 'gwh'] = df.loc[:, 'kwh'] / 10 ** 6
+
+        df = df.sort_index(level=['building_category', 'building_code', 'year', 'building_condition', 'purpose', HEATING_SYSTEMS])
+        return df[[HEATING_SYSTEM_SHARE, ADJUSTED_REQUIREMENT,
+                   HEATING_RV_BASE_TOTAL, BASE_LOAD_ENERGY_PRODUCT, BASE_LOAD_EFFICIENCY,
+                   HEATING_RV_PEAK_TOTAL, PEAK_LOAD_ENERGY_PRODUCT, PEAK_LOAD_EFFICIENCY,
+                   HEATING_RV_TERTIARY_TOTAL, TERTIARY_LOAD_ENERGY_PRODUCT, TERTIARY_LOAD_EFFICIENCY,
+                   DHW_TOTAL, DOMESTIC_HOT_WATER_ENERGY_PRODUCT, COOLING_TOTAL, OTHER_TOTAL, HEAT_PUMP, HP_ENERGY_SOURCE, 'kwh', 'gwh']]
+
+    def adjust_heat_pump(self, df):
+        df[HP_ENERGY_SOURCE] = None
+        gass = ['HP Central heating - Gas']
+        vannbasert = [n for n in df.index.get_level_values('heating_systems').unique() if
+                      n.startswith('HP Central heating')]
+        elektrisk = [n for n in df.index.get_level_values('heating_systems').unique() if
+                     n.startswith('HP') and n not in vannbasert]
+
+        gass_slice = (slice(None), slice(None), slice(None), slice(None), gass)
+        vann_slice = (slice(None), slice(None), ['heating_rv', 'heating_dhw'], slice(None), slice(None),
+                      vannbasert)  # , 'heating_dhw'
+        el_slice = (slice(None), slice(None), ['heating_rv'], slice(None), slice(None), elektrisk)  # 'heating_dhw'
+
+        df.loc[vann_slice, HEAT_PUMP] = df.loc[vann_slice, ADJUSTED_REQUIREMENT] * df.loc[vann_slice, GRUNNLAST_ANDEL]
+        df.loc[vann_slice, HP_ENERGY_SOURCE] = 'Vannbåren varme'
+
+        df.loc[el_slice, HEAT_PUMP] = df.loc[el_slice, ADJUSTED_REQUIREMENT] * df.loc[el_slice, GRUNNLAST_ANDEL]
+        df.loc[el_slice, HP_ENERGY_SOURCE] = 'Luft/luft'
+        return df
+
+    def adjust_other(self, df):
+        # lighting, electrical equipment, fans and pumps energy use is calculated by dividing with spesific electricity
+        # useage
+        other_slice = (slice(None), slice(None), EnergyPurpose.other(), slice(None), slice(None))
+        df.loc[other_slice, OTHER_TOTAL] = df.loc[other_slice, ADJUSTED_REQUIREMENT] / df.loc[
+            other_slice, SPESIFIKT_ELFORBRUK]
+        return df
+
+    def adjust_cooling(self, df):
+        # cooling energy use is calculated by dividing cooling with 'cooling_efficiency'
+        cooling_slice = (slice(None), slice(None), COOLING, slice(None), slice(None))
+        df.loc[cooling_slice, COOLING_TOTAL] = df.loc[cooling_slice, ADJUSTED_REQUIREMENT] / df.loc[
+            cooling_slice, COOLING_EFFICIENCY]
+        return df
+
+    def adjust_heating_dhw(self, df):
+        # heating dhw energy use is calculated by dividing heating_dhw with 'domestic_hot_water_efficiency'
+        heating_dhw_slice = (slice(None), slice(None), HEATING_DHW, slice(None), slice(None))
+        df.loc[heating_dhw_slice, DHW_TOTAL] = df.loc[heating_dhw_slice, ADJUSTED_REQUIREMENT] / df.loc[
+            heating_dhw_slice, DHW_EFFICIENCY]
+        return df
+
+    def adjust_heating_rv(self, df):
+        heating_rv_slice = (slice(None), slice(None), HEATING_RV, slice(None), slice(None))
+        df.loc[heating_rv_slice, HEATING_RV_BASE_TOTAL] = (
+                df.loc[heating_rv_slice, ADJUSTED_REQUIREMENT] * df.loc[heating_rv_slice, GRUNNLAST_ANDEL] / df.loc[
+            heating_rv_slice, BASE_LOAD_EFFICIENCY])
+        df.loc[heating_rv_slice, HEATING_RV_PEAK_TOTAL] = (
+                df.loc[heating_rv_slice, ADJUSTED_REQUIREMENT] * df.loc[heating_rv_slice, PEAK_LOAD_COVERAGE] / df.loc[
+            heating_rv_slice, PEAK_LOAD_EFFICIENCY])
+        df.loc[heating_rv_slice, HEATING_RV_TERTIARY_TOTAL] = (
+                df.loc[heating_rv_slice, ADJUSTED_REQUIREMENT] * df.loc[heating_rv_slice, TERTIARY_LOAD_COVERAGE] / df.loc[
+            heating_rv_slice, TERTIARY_LOAD_EFFICIENCY])
+        return df
+
+    def _merge_energy_requirement_and_heating_systems(self, energy_requirements):
+        df = energy_requirements.reset_index().merge(self.heating_systems_parameters.reset_index(),
+            left_on=['building_category', 'building_code', 'year'], right_on=['building_category', 'building_code', 'year'])[
+            ['building_category', 'building_condition', 'purpose', 'building_code', 'year', 'kwh_m2', 'm2', 'energy_requirement',
+             HEATING_SYSTEMS, HEATING_SYSTEM_SHARE, GRUNNLAST_ANDEL, BASE_LOAD_EFFICIENCY, BASE_LOAD_ENERGY_PRODUCT,
+             PEAK_LOAD_COVERAGE, PEAK_LOAD_EFFICIENCY, PEAK_LOAD_ENERGY_PRODUCT, TERTIARY_LOAD_EFFICIENCY, TERTIARY_LOAD_COVERAGE,
+             TERTIARY_LOAD_ENERGY_PRODUCT, DOMESTIC_HOT_WATER_ENERGY_PRODUCT, DHW_EFFICIENCY, SPESIFIKT_ELFORBRUK, COOLING_EFFICIENCY]]
+        # Unused columns
+        # ,'Innfyrt_energi_kWh','Innfyrt_energi_GWh','Energibehov_samlet_GWh']]
+        df = df.set_index(
+            ['building_category', 'building_condition', 'purpose', 'building_code', 'year', HEATING_SYSTEMS]).sort_index()
+        return df
+
+    @staticmethod
+    def _group_and_sum_same_building_code(energy_requirements):
+        energy_requirements = FilterTek.merge_building_code(energy_requirements, 'TEK69', ['TEK69_1976', 'TEK69_1986'])
+        energy_requirements = FilterTek.merge_building_code(energy_requirements, 'PRE_TEK49',
+                                                  ['PRE_TEK49_1940', 'PRE_TEK49_1950'])
+        energy_requirements = energy_requirements.sort_index()
+        return energy_requirements
+
+    @staticmethod
+    def _remove_building_code_suffix(energy_requirements):
+        energy_requirements = FilterTek.remove_building_code_suffix(energy_requirements, suffix='_RES')
+        energy_requirements = FilterTek.remove_building_code_suffix(energy_requirements, suffix='_COM')
+        return energy_requirements
+
+
+def calibrate_heating_systems(df: pd.DataFrame, factor: pd.DataFrame, multiply=False) -> pd.DataFrame:
+    # When factor is empty or all factors are 1.0, there is no need to change anything.
+    if len(factor) == 0 or (factor.factor == 1.0).all():
+        return df
+    original = df.copy()
+    factor = factor.copy()
+
+    if multiply:
+        factor['factor'] = factor['factor'] * 100
+
+    # Add action and value
+    df_to = original.merge(factor,
+                           left_on=['building_category', 'heating_systems'],
+                           right_on=['building_category', 'to'])
+
+    df_from = original.merge(factor,
+                             left_on=['building_category', 'heating_systems'],
+                             right_on=['building_category', 'from'])
+
+    # Calculate value to add
+    df_to_add = df_to.set_index(['building_category', 'building_code', 'year', 'to'])
+
+    if multiply:
+        df_to_add['v'] = (df_to_add.heating_system_share * df_to_add.factor)/100 - df_to_add.heating_system_share
+    else:
+        df_to_add['v'] = df_to_add.heating_system_share * df_to_add.factor - df_to_add.heating_system_share
+
+    # Calculate value to subtract
+    df_to_subtract = df_from.set_index(['building_category', 'building_code', 'year', 'from', 'to'])
+
+    df_to_subtract = df_to_subtract.sort_index()
+    df_to_subtract.loc[:, 'v'] = -df_to_add.reset_index().groupby(by=['building_category', 'building_code', 'year', 'from', 'to']).agg(
+        {'v': 'sum'})
+
+    # Join add and substract rows
+    addition_grouped = df_to_add.groupby(by=['building_category', 'building_code', 'year', 'to']).agg(
+        {'v': 'sum', 'heating_systems': 'first', 'heating_system_share': 'first', 'factor': 'first', 'from': 'first'})
+    subtraction_grouped = df_to_subtract.groupby(by=['building_category', 'building_code', 'year', 'from']).agg(
+        {'v': 'sum', 'heating_systems': 'first', 'heating_system_share': 'first', 'factor': 'first'})
+
+    df_to_sum = original.set_index(['building_category', 'building_code', 'year', 'heating_systems'])
+    df_to_sum = df_to_sum.sort_index()
+    df_to_sum.loc[:, 'add'] = addition_grouped.loc[:, 'v']
+    df_to_sum.loc[:, 'sub'] = subtraction_grouped.loc[:, 'v'].fillna(0)
+    df_to_sum.loc[:, 'sub'] = df_to_sum.loc[:, 'sub'].fillna(0)
+
+    df_to_sum.heating_system_share = df_to_sum.heating_system_share + df_to_sum['add'].fillna(0) + df_to_sum['sub'].fillna(0)
+
+    calibrated_and_original = pd.concat([df_to_sum.reset_index(), original.reset_index()]).drop_duplicates(
+        ['building_category', 'building_code', 'year', 'heating_systems'],
+        keep='first').drop(columns='index',
+                           errors='ignore')
+
+    columns_to_keep = ['building_category', 'building_code', 'year', 'heating_systems', 'heating_system_share']
+    return calibrated_and_original[columns_to_keep].reset_index(drop=True)
+
+
+def calibrate_heating_systems_adder(df: pd.DataFrame, factor: pd.DataFrame) -> pd.DataFrame:
+    # When factor is empty or all factors are 1.0, there is no need to change anything.
+    if len(factor) == 0 or (factor.factor == 0.0).all():
+        return df
+    original = df.copy()
+    factor = factor.copy()
+
+    # Add action and value
+    df_to = original.merge(factor,
+                           left_on=['building_category', 'heating_systems'],
+                           right_on=['building_category', 'to'])
+
+    df_from = original.merge(factor,
+                             left_on=['building_category', 'heating_systems'],
+                             right_on=['building_category', 'from'])
+
+    # Calculate value to add
+    df_to_add = df_to.set_index(['building_category', 'building_code', 'year', 'to'])
+
+    df_to_add['v'] = df_to_add.factor
+
+    # Calculate value to subtract
+    df_to_subtract = df_from.set_index(['building_category', 'building_code', 'year', 'from', 'to'])
+    df_to_subtract.loc[:, 'v'] = -df_to_add.reset_index().groupby(by=['building_category', 'building_code', 'year', 'from', 'to']).agg(
+        {'v': 'sum'})
+
+    # Join add and substract rows
+    addition_grouped = df_to_add.groupby(by=['building_category', 'building_code', 'year', 'to']).agg(
+        {'v': 'sum', 'heating_systems': 'first', 'heating_system_share': 'first', 'factor': 'first', 'from': 'first'})
+    subtraction_grouped = df_to_subtract.groupby(by=['building_category', 'building_code', 'year', 'from']).agg(
+        {'v': 'sum', 'heating_systems': 'first', 'heating_system_share': 'first', 'factor': 'first'})
+
+    df_to_sum = original.set_index(['building_category', 'building_code', 'year', 'heating_systems'])
+    df_to_sum.loc[:, 'add'] = addition_grouped.loc[:, 'v']
+    df_to_sum.loc[:, 'sub'] = subtraction_grouped.loc[:, 'v'].fillna(0)
+    df_to_sum.loc[:, 'sub'] = df_to_sum.loc[:, 'sub'].fillna(0)
+
+    df_to_sum.heating_system_share = df_to_sum.heating_system_share + df_to_sum['add'].fillna(0) + df_to_sum['sub'].fillna(0)
+
+    calibrated_and_original = pd.concat([df_to_sum.reset_index(), original.reset_index()]).drop_duplicates(
+        ['building_category', 'building_code', 'year', 'heating_systems'],
+        keep='first').drop(columns='index',
+                           errors='ignore')
+
+    columns_to_keep = ['building_category', 'building_code', 'year', 'heating_systems', 'heating_system_share']
+    return calibrated_and_original[columns_to_keep].reset_index(drop=True)

ebm/extractors.py

@@ -0,0 +1,115 @@
+import pandas as pd
+from loguru import logger
+
+from ebm.model import area
+from ebm.holiday_home_energy import calculate_energy_use, transform_holiday_homes_to_horizontal
+from ebm.heating_system_forecast import HeatingSystemsForecast
+from ebm.model.construction import ConstructionCalculator
+
+from ebm.model.data_classes import YearRange
+from ebm.model.database_manager import DatabaseManager
+from ebm.model.energy_requirement import EnergyRequirement
+from ebm.s_curve import calculate_s_curves
+
+
+def extract_area_forecast(years: YearRange, s_curves_by_condition: pd.DataFrame, building_code_parameters: pd.DataFrame, area_parameters: pd.DataFrame, database_manager:DatabaseManager):
+    logger.debug('Calculating area by condition')
+
+    s_curve_demolition = s_curves_by_condition['s_curve_demolition']
+    s_curves_by_condition = s_curves_by_condition[[
+        'original_condition',  'small_measure', 'renovation', 'renovation_and_small_measure', 'demolition'
+    ]]
+
+    area_parameters = area_parameters.set_index(['building_category', 'building_code'])
+
+    demolition_floor_area_by_year = area.calculate_demolition_floor_area_by_year(area_parameters, s_curve_demolition)
+
+    building_category_demolition_by_year = area.sum_building_category_demolition_by_year(demolition_floor_area_by_year)
+    construction_floor_area_by_year = ConstructionCalculator.calculate_all_construction(
+        demolition_by_year=building_category_demolition_by_year,
+        database_manager=database_manager,
+        period=years)
+
+    construction_by_building_category_and_year = area.construction_with_building_code(
+        building_category_demolition_by_year=building_category_demolition_by_year,
+        construction_floor_area_by_year=construction_floor_area_by_year,
+        building_code=building_code_parameters,
+        years=years)
+
+    existing_area = area.calculate_existing_area(area_parameters, building_code_parameters, years)
+
+    total_area_floor_by_year = area.merge_total_area_by_year(construction_by_building_category_and_year, existing_area)
+
+    floor_area_forecast = area.multiply_s_curves_with_floor_area(s_curves_by_condition, total_area_floor_by_year)
+
+    return floor_area_forecast
+
+
+def write_scurve(s_curves_by_condition):
+    try:
+        output_file = 'output/s_curves.xlsx'
+        with pd.ExcelWriter(output_file, engine='xlsxwriter') as writer:
+            s_curves_by_condition.to_excel(writer, sheet_name='s_curves_by_condition', merge_cells=False)  # 💾
+            # s_curve_demolition.to_excel(writer, sheet_name='s_curve_demolition', merge_cells=False) # 💾
+    except IOError as ex:
+        logger.exception(ex)
+        logger.info(f'There was an IOError while writing to {output_file}. Moving on!')
+
+
+def extract_energy_need(years: YearRange, dm: DatabaseManager) -> pd.DataFrame:
+    er_calculator = EnergyRequirement.new_instance(period=years, calibration_year=2023,
+                                                   database_manager=dm)
+    energy_need = er_calculator.calculate_for_building_category(database_manager=dm)
+
+    energy_need = energy_need.set_index(['building_category', 'building_code', 'purpose', 'building_condition', 'year'])
+
+    return energy_need
+
+
+def extract_heating_systems_forecast(years: YearRange, database_manager: DatabaseManager) -> pd.DataFrame:
+    forecast_period = YearRange(2023, 2050)
+    hsp = HeatingSystemsForecast.new_instance(forecast_period, database_manager)
+    df: pd.DataFrame = hsp.calculate_forecast()
+    df = hsp.pad_projection(df, YearRange(2020, 2022))
+
+    heating_system_forecast = df.copy()
+    return heating_system_forecast
+
+
+def extract_energy_use_holiday_homes(database_manager):
+    df = transform_holiday_homes_to_horizontal(calculate_energy_use(database_manager)).copy()
+    df = df.rename(columns={'building_category': 'building_group'})
+    df.loc[df.energy_source=='Elektrisitet', 'energy_source'] = 'Electricity'
+    df.loc[df.energy_source=='fossil', 'energy_source'] = 'Fossil'
+    return df
+
+
+def main():
+    from ebm.model.file_handler import FileHandler
+    fh = FileHandler(directory='input')
+    dm = DatabaseManager(fh)
+    years = YearRange(2020, 2050)
+
+    building_code_parameters = fh.get_building_code()
+    scurve_params = dm.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=dm.get_area_parameters(),
+                                          s_curves_by_condition=s_curves_by_condition,
+                                          database_manager=dm)
+
+    print(area_forecast)
+
+    energy_need_kwh_m2 = extract_energy_need(years, dm)
+    print(energy_need_kwh_m2)
+
+    heating_systems_projection = extract_heating_systems_forecast(years, dm)
+    print(heating_systems_projection)
+
+
+
+
+if __name__ == '__main__':
+    main()