-
 """
 copied from https://github.com/architecture-building-systems/RC_BuildingSimulator
 Tool to Evaluate Radiation incident on a surface of a set angle
 """
 

 import math
 import datetime
 
 
 __authors__ = "Prageeth Jayathissa"
-__copyright__ = "Copyright 2016, Architecture and Building Systems - ETH Zurich"
+__copyright__ = (
+    "Copyright 2016, Architecture and Building Systems - ETH Zurich"
+)
 __credits__ = ["pysolar, Quaschning Volker,  Rolf Hanitsch, Linus Walker"]
 __license__ = "MIT"
 __version__ = "0.1"
 __maintainer__ = "Prageeth Jayathissa"
 __email__ = "p.jayathissa@gmail.com"
 __status__ = "production"
 
 
 def sunPositionReader(SunPosition_path):
-
-    sun_labels = ['altitude', 'azimuth']  # 'HOY',
-#
-#    result = pd.read_csv(SunPosition_path, skiprows=1, header=None, names=epw_labels).drop('datasource', axis=1)
-#    result['dayofyear'] = pd.date_range('1/1/2010', periods=8760, freq='H').dayofyear
-#    result['ratio_diffhout'] = result['difhorrad_Whm2']/result['glohorrad_Whm2']
+    sun_labels = ["altitude", "azimuth"]  # 'HOY',
+    #
+    #    result = pd.read_csv(SunPosition_path, skiprows=1, header=None, names=epw_labels).drop('datasource', axis=1)
+    #    result['dayofyear'] = pd.date_range('1/1/2010', periods=8760, freq='H').dayofyear
+    #    result['ratio_diffhout'] = result['difhorrad_Whm2']/result['glohorrad_Whm2']
 
     result = pd.read_csv(SunPosition_path, skiprows=1, names=sun_labels)
 
     return
-class Location(object, ):
+
+
+class Location(
+    object,
+):
     """Set the Location of the Simulation with an Energy Plus Weather File"""
 
-    def __init__(self, epwfile_path, mannheim :bool):
-
+    def __init__(self, epwfile_path, mannheim: bool):
         # Set EPW Labels and import epw file
         if mannheim:
-            epw_labels = ['hour', 'drybulb_C', 'dewpoint_C',
-                          'relhum_percent',
-                          'atmos_Pa', 'exthorrad_Whm2', 'extdirrad_Whm2', 'horirsky_Whm2', 'glohorrad_Whm2',
-                          'dirnorrad_Whm2', 'difhorrad_Whm2', 'glohorillum_lux', 'dirnorillum_lux', 'difhorillum_lux',
-                          'zenlum_lux', 'winddir_deg', 'windspd_ms', 'totskycvr_tenths', 'opaqskycvr_tenths',
-                          'visibility_km',
-                          'ceiling_hgt_m', 'presweathobs', 'presweathcodes', 'precip_wtr_mm', 'aerosol_opt_thousandths',
-                          'snowdepth_cm', 'days_last_snow', 'Albedo', 'liq_precip_depth_mm', 'liq_precip_rate_Hour']
+            epw_labels = [
+                "hour",
+                "drybulb_C",
+                "dewpoint_C",
+                "relhum_percent",
+                "atmos_Pa",
+                "exthorrad_Whm2",
+                "extdirrad_Whm2",
+                "horirsky_Whm2",
+                "glohorrad_Whm2",
+                "dirnorrad_Whm2",
+                "difhorrad_Whm2",
+                "glohorillum_lux",
+                "dirnorillum_lux",
+                "difhorillum_lux",
+                "zenlum_lux",
+                "winddir_deg",
+                "windspd_ms",
+                "totskycvr_tenths",
+                "opaqskycvr_tenths",
+                "visibility_km",
+                "ceiling_hgt_m",
+                "presweathobs",
+                "presweathcodes",
+                "precip_wtr_mm",
+                "aerosol_opt_thousandths",
+                "snowdepth_cm",
+                "days_last_snow",
+                "Albedo",
+                "liq_precip_depth_mm",
+                "liq_precip_rate_Hour",
+            ]
             self.weather_data = pd.read_csv(
-                epwfile_path, header=None, names=epw_labels)
+                epwfile_path, header=None, names=epw_labels
+            )
         else:
-            epw_labels = ['year', 'month', 'day', 'hour', 'minute', 'datasource', 'drybulb_C', 'dewpoint_C', 'relhum_percent',
-                          'atmos_Pa', 'exthorrad_Whm2', 'extdirrad_Whm2', 'horirsky_Whm2', 'glohorrad_Whm2',
-                          'dirnorrad_Whm2', 'difhorrad_Whm2', 'glohorillum_lux', 'dirnorillum_lux', 'difhorillum_lux',
-                          'zenlum_lux', 'winddir_deg', 'windspd_ms', 'totskycvr_tenths', 'opaqskycvr_tenths', 'visibility_km',
-                          'ceiling_hgt_m', 'presweathobs', 'presweathcodes', 'precip_wtr_mm', 'aerosol_opt_thousandths',
-                          'snowdepth_cm', 'days_last_snow', 'Albedo', 'liq_precip_depth_mm', 'liq_precip_rate_Hour']
+            epw_labels = [
+                "year",
+                "month",
+                "day",
+                "hour",
+                "minute",
+                "datasource",
+                "drybulb_C",
+                "dewpoint_C",
+                "relhum_percent",
+                "atmos_Pa",
+                "exthorrad_Whm2",
+                "extdirrad_Whm2",
+                "horirsky_Whm2",
+                "glohorrad_Whm2",
+                "dirnorrad_Whm2",
+                "difhorrad_Whm2",
+                "glohorillum_lux",
+                "dirnorillum_lux",
+                "difhorillum_lux",
+                "zenlum_lux",
+                "winddir_deg",
+                "windspd_ms",
+                "totskycvr_tenths",
+                "opaqskycvr_tenths",
+                "visibility_km",
+                "ceiling_hgt_m",
+                "presweathobs",
+                "presweathcodes",
+                "precip_wtr_mm",
+                "aerosol_opt_thousandths",
+                "snowdepth_cm",
+                "days_last_snow",
+                "Albedo",
+                "liq_precip_depth_mm",
+                "liq_precip_rate_Hour",
+            ]
             self.weather_data = pd.read_csv(
-                epwfile_path, skiprows=8, header=None, names=epw_labels).drop('datasource', axis=1)
-
+                epwfile_path, skiprows=8, header=None, names=epw_labels
+            ).drop("datasource", axis=1)
 
     def calc_sun_position(self, latitude_deg, longitude_deg, year, hoy):
         """
         Calculates the Sun Position for a specific hour and location
         :param latitude_deg: Geographical Latitude in Degrees

         day_of_year = utc_datetime.timetuple().tm_yday
 
         # Calculate the declination angle: The variation due to the earths tilt
         # http://www.pveducation.org/pvcdrom/properties-of-sunlight/declination-angle
         declination_rad = math.radians(
-            23.45 * math.sin((2 * math.pi / 365.0) * (day_of_year - 81)))
+            23.45 * math.sin((2 * math.pi / 365.0) * (day_of_year - 81))
+        )
 
         # Normalise the day to 2*pi
         # There is some reason as to why it is 364 and not 365.26
         angle_of_day = (day_of_year - 81) * (2 * math.pi / 364)
 
         # The deviation between local standard time and true solar time
-        equation_of_time = (9.87 * math.sin(2 * angle_of_day)) - \
-            (7.53 * math.cos(angle_of_day)) - (1.5 * math.sin(angle_of_day))
+        equation_of_time = (
+            (9.87 * math.sin(2 * angle_of_day))
+            - (7.53 * math.cos(angle_of_day))
+            - (1.5 * math.sin(angle_of_day))
+        )
 
         # True Solar Time
-        solar_time = ((utc_datetime.hour * 60) + utc_datetime.minute +
-                      (4 * longitude_deg) + equation_of_time) / 60.0
+        solar_time = (
+            (utc_datetime.hour * 60)
+            + utc_datetime.minute
+            + (4 * longitude_deg)
+            + equation_of_time
+        ) / 60.0
 
         # Angle between the local longitude and longitude where the sun is at
         # higher altitude
         hour_angle_rad = math.radians(15 * (12 - solar_time))
 
         # Altitude Position of the Sun in Radians
-        altitude_rad = math.asin(math.cos(latitude_rad) * math.cos(declination_rad) * math.cos(hour_angle_rad) +
-                                 math.sin(latitude_rad) * math.sin(declination_rad))
+        altitude_rad = math.asin(
+            math.cos(latitude_rad)
+            * math.cos(declination_rad)
+            * math.cos(hour_angle_rad)
+            + math.sin(latitude_rad) * math.sin(declination_rad)
+        )
 
         # Azimuth Position fo the sun in radians
         azimuth_rad = math.asin(
-            math.cos(declination_rad) * math.sin(hour_angle_rad) / math.cos(altitude_rad))
+            math.cos(declination_rad)
+            * math.sin(hour_angle_rad)
+            / math.cos(altitude_rad)
+        )
 
         # I don't really know what this code does, it has been imported from
         # PySolar
-        if(math.cos(hour_angle_rad) >= (math.tan(declination_rad) / math.tan(latitude_rad))):
+        if math.cos(hour_angle_rad) >= (
+            math.tan(declination_rad) / math.tan(latitude_rad)
+        ):
             return math.degrees(altitude_rad), math.degrees(azimuth_rad)
         else:
-            return math.degrees(altitude_rad), (180 - math.degrees(azimuth_rad))
+            return math.degrees(altitude_rad), (
+                180 - math.degrees(azimuth_rad)
+            )
 
 
 class Window(object):
     """docstring for Window"""
 
-    def __init__(self, azimuth_tilt, alititude_tilt=90, glass_solar_transmittance=0.7,
-                 glass_light_transmittance=0.8, area=1):
-
+    def __init__(
+        self,
+        azimuth_tilt,
+        alititude_tilt=90,
+        glass_solar_transmittance=0.7,
+        glass_light_transmittance=0.8,
+        area=1,
+    ):
         self.alititude_tilt_rad = math.radians(alititude_tilt)
         self.azimuth_tilt_rad = math.radians(azimuth_tilt)
         self.glass_solar_transmittance = glass_solar_transmittance
         self.glass_light_transmittance = glass_light_transmittance
         self.area = area
 
-    def calc_solar_gains(self, sun_altitude, sun_azimuth, normal_direct_radiation, horizontal_diffuse_radiation):
+    def calc_solar_gains(
+        self,
+        sun_altitude,
+        sun_azimuth,
+        normal_direct_radiation,
+        horizontal_diffuse_radiation,
+    ):
         """
         Calculates the Solar Gains in the building zone through the set Window
         :param sun_altitude: Altitude Angle of the Sun in Degrees
         :type sun_altitude: float
         :param sun_azimuth: Azimuth angle of the sun in degrees

         :return: self.incident_solar, Incident Solar Radiation on window
         :return: self.solar_gains - Solar gains in building after transmitting through the window
         :rtype: float
         """
 
-        direct_factor = self.calc_direct_solar_factor(sun_altitude, sun_azimuth,)
+        direct_factor = self.calc_direct_solar_factor(
+            sun_altitude,
+            sun_azimuth,
+        )
         diffuse_factor = self.calc_diffuse_solar_factor()
 
         direct_solar = direct_factor * normal_direct_radiation
         diffuse_solar = horizontal_diffuse_radiation * diffuse_factor
         self.incident_solar = (direct_solar + diffuse_solar) * self.area
 
         self.solar_gains = self.incident_solar * self.glass_solar_transmittance
 
-    def calc_illuminance(self, sun_altitude, sun_azimuth, normal_direct_illuminance, horizontal_diffuse_illuminance):
+    def calc_illuminance(
+        self,
+        sun_altitude,
+        sun_azimuth,
+        normal_direct_illuminance,
+        horizontal_diffuse_illuminance,
+    ):
         """
         Calculates the Illuminance in the building zone through the set Window
         :param sun_altitude: Altitude Angle of the Sun in Degrees
         :type sun_altitude: float
         :param sun_azimuth: Azimuth angle of the sun in degrees

         :return: self.incident_illuminance, Incident Illuminance on window [Lumens]
         :return: self.transmitted_illuminance - Illuminance in building after transmitting through the window [Lumens]
         :rtype: float
         """
 
-        direct_factor = self.calc_direct_solar_factor(sun_altitude, sun_azimuth,)
+        direct_factor = self.calc_direct_solar_factor(
+            sun_altitude,
+            sun_azimuth,
+        )
         diffuse_factor = self.calc_diffuse_solar_factor()
 
         direct_illuminance = direct_factor * normal_direct_illuminance
         diffuse_illuminance = diffuse_factor * horizontal_diffuse_illuminance
 
         self.incident_illuminance = (
-            direct_illuminance + diffuse_illuminance) * self.area
-        self.transmitted_illuminance = self.incident_illuminance * \
-            self.glass_light_transmittance
+            direct_illuminance + diffuse_illuminance
+        ) * self.area
+        self.transmitted_illuminance = (
+            self.incident_illuminance * self.glass_light_transmittance
+        )
 
     def calc_direct_solar_factor(self, sun_altitude, sun_azimuth):
         """
         Calculates the cosine of the angle of incidence on the window
         """

         """
         Proportion of the radiation incident on the window (cos of the incident ray)
         ref:Quaschning, Volker, and Rolf Hanitsch. "Shade calculations in photovoltaic systems."
         ISES Solar World Conference, Harare. 1995.
         """
-        direct_factor = math.cos(sun_altitude_rad) * math.sin(self.alititude_tilt_rad) * \
-            math.cos(sun_azimuth_rad - self.azimuth_tilt_rad) + \
-            math.sin(sun_altitude_rad) * math.cos(self.alititude_tilt_rad)
+        direct_factor = math.cos(sun_altitude_rad) * math.sin(
+            self.alititude_tilt_rad
+        ) * math.cos(sun_azimuth_rad - self.azimuth_tilt_rad) + math.sin(
+            sun_altitude_rad
+        ) * math.cos(
+            self.alititude_tilt_rad
+        )
 
         # If the sun is in front of the window surface
-        if(math.degrees(math.acos(direct_factor)) > 90):
+        if math.degrees(math.acos(direct_factor)) > 90:
             direct_factor = 0
 
         else:
             pass
 

         """Calculates the proportion of diffuse radiation"""
         # Proportion of incident light on the window surface
         return (1 + math.cos(self.alititude_tilt_rad)) / 2
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     pass

 from tabula_reader import Building
 
 import oemof.solph as solph
 from oemof.solph import views
 from oemof.tools import logger
+
 """
 General description
 -------------------
 This examples optimizes the internal building temperature.
 It is suppose to show how to use the component GenericBuilding.

 """
 
 __copyright__ = "oemof developer group"
 __license__ = "MIT"
 
+
 def main():
     #  create solver
     solver = "cbc"  # 'glpk', 'gurobi',....
     debug = False  # Set number_of_timesteps to 3 to get a readable lp-file.
     solver_verbose = False  # show/hide solver output
     number_of_time_steps = 8760
-    mainPath = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
-
-    #Generates 5RC Building-Model
+    mainPath = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+
+    # Generates 5RC Building-Model
     building_status = "no_refurbishment"
     if building_status == "no_refurbishment":
-        building_example = Building (tabula_building_code ='DE.N.SFH.04.Gen.ReEx.001.001',
-                                     class_building = "average",
-                                     number_of_time_steps=number_of_time_steps)
+        building_example = Building(
+            tabula_building_code="DE.N.SFH.04.Gen.ReEx.001.001",
+            class_building="average",
+            number_of_time_steps=number_of_time_steps,
+        )
     elif building_status == "usual_refurbishment":
-        building_example = Building (tabula_building_code ='DE.N.SFH.04.Gen.ReEx.001.002',
-                                     class_building = "average",
-                                     number_of_time_steps=number_of_time_steps)
+        building_example = Building(
+            tabula_building_code="DE.N.SFH.04.Gen.ReEx.001.002",
+            class_building="average",
+            number_of_time_steps=number_of_time_steps,
+        )
     elif building_status == "advanced_refurbishment":
-        building_example = Building (tabula_building_code ='DE.N.SFH.04.Gen.ReEx.001.003',
-                                     class_building = "average",
-                                     number_of_time_steps=number_of_time_steps)
+        building_example = Building(
+            tabula_building_code="DE.N.SFH.04.Gen.ReEx.001.003",
+            class_building="average",
+            number_of_time_steps=number_of_time_steps,
+        )
     building_example.calculate_all_parameters()
 
     # Pre-Calculation of solar gains with weather_data and building_data
-    Mannheim = calculate_gain_by_Sun.Location(mannheim=True, epwfile_path=os.path.join(mainPath, 'thermal_building_model', 'DEU_BW_Mannheim_107290_TRY2010_12_Jahr_BBSR.csv'))
-    solar_gains = building_example.calc_solar_gaings_through_windows(object_location_of_building = Mannheim)
-    t_outside = pd.read_csv(os.path.join(mainPath, 'thermal_building_model', 'DEU_BW_Mannheim_107290_TRY2010_12_Jahr_BBSR.csv') ,header=None)[1].tolist()
+    Mannheim = calculate_gain_by_Sun.Location(
+        mannheim=True,
+        epwfile_path=os.path.join(
+            mainPath,
+            "thermal_building_model",
+            "DEU_BW_Mannheim_107290_TRY2010_12_Jahr_BBSR.csv",
+        ),
+    )
+    solar_gains = building_example.calc_solar_gaings_through_windows(
+        object_location_of_building=Mannheim
+    )
+    t_outside = pd.read_csv(
+        os.path.join(
+            mainPath,
+            "thermal_building_model",
+            "DEU_BW_Mannheim_107290_TRY2010_12_Jahr_BBSR.csv",
+        ),
+        header=None,
+    )[1].tolist()
 
     # Internal gains of residents, machines (f.e. fridge, computer,...) and lights have to be added manually
-    internal_gains=[]
+    internal_gains = []
     for _ in range(number_of_time_steps):
         internal_gains.append(0)
     # initiate the logger (see the API docs for more information)
     logger.define_logging(
         logfile="oemof_example.log",
         screen_level=logging.INFO,
         file_level=logging.INFO,
     )
 
     logging.info("Initialize the energy system")
-    date_time_index = solph.create_time_index(2012,
-                                              number=number_of_time_steps)
-    es = solph.EnergySystem(timeindex=date_time_index,
-                            infer_last_interval=False)
-
+    date_time_index = solph.create_time_index(
+        2012, number=number_of_time_steps
+    )
+    es = solph.EnergySystem(
+        timeindex=date_time_index, infer_last_interval=False
+    )
 
     b_heat = solph.buses.Bus(label="b_heat")
     es.add(b_heat)
     b_cool = solph.buses.Bus(label="b_cool")
     es.add(b_cool)

     b_elect = solph.buses.Bus(label="electricity_from_grid")
     es.add(b_elect)
     building_temp = solph.buses.Bus(label="building_temp")
     es.add(building_temp)
 
-    es.add(solph.components.Source(
+    es.add(
+        solph.components.Source(
             label="elect_from_grid",
             outputs={b_elect: solph.flows.Flow(variable_costs=30)},
         )
     )
 
-    es.add(solph.components.Sink(
+    es.add(
+        solph.components.Sink(
             label="elect_into_grid",
             inputs={b_elect: solph.flows.Flow(variable_costs=10)},
         )
     )
 
     es.add(
         solph.components.Transformer(
             label="ElectricalHeater",
             inputs={b_elect: solph.flows.Flow()},
             outputs={b_heat: solph.flows.Flow(nominal_value=65000)},
-            conversion_factors={b_elect: 1}
+            conversion_factors={b_elect: 1},
         )
     )
     es.add(
         solph.components.Transformer(
             label="ElectricalCooler",
             inputs={b_cool: solph.flows.Flow()},
             outputs={b_elect: solph.flows.Flow(nominal_value=65000)},
-            conversion_factors={b_elect: 1}
+            conversion_factors={b_elect: 1},
         )
     )
 
     es.add(
         solph.components.experimental.GenericBuilding(
             label="GenericBuilding",
-            inputs={b_heat: solph.flows.Flow(variable_costs=0) },
-            outputs={b_cool: solph.flows.Flow(variable_costs=0) },
+            inputs={b_heat: solph.flows.Flow(variable_costs=0)},
+            outputs={b_cool: solph.flows.Flow(variable_costs=0)},
             solar_gains=solar_gains,
             t_outside=t_outside,
             internal_gains=internal_gains,
             t_set_heating=20,
-            t_set_cooling = 30,
+            t_set_cooling=30,
             building_config=building_example.building_config,
             t_inital=20,
         )
     )
 

     es.results["meta"] = solph.processing.meta_results(model)
     results = es.results["main"]
     custom_building = views.node(results, "GenericBuilding")
 
     fig, ax = plt.subplots(figsize=(10, 5))
-    custom_building['sequences'][(('GenericBuilding', 'None'), 't_air')].plot(
+    custom_building["sequences"][(("GenericBuilding", "None"), "t_air")].plot(
         ax=ax, kind="line", drawstyle="steps-post"
     )
 
     ax.set_ylabel("t_air in Celsius")
     plt.show()
 
     fig, ax = plt.subplots(figsize=(10, 5))
     custom_building = views.node(results, "GenericBuilding")
-    custom_building['sequences'][(('b_heat', 'GenericBuilding'), 'flow')].plot(
+    custom_building["sequences"][(("b_heat", "GenericBuilding"), "flow")].plot(
         ax=ax, kind="line", drawstyle="steps-post"
     )
     ax.set_ylabel("heat demand in Watt")
 
     fig, ax = plt.subplots(figsize=(10, 5))
     custom_building = views.node(results, "GenericBuilding")
-    custom_building['sequences'][(('GenericBuilding', 'b_cool'), 'flow')].plot(
+    custom_building["sequences"][(("GenericBuilding", "b_cool"), "flow")].plot(
         ax=ax, kind="line", drawstyle="steps-post"
     )
     ax.set_ylabel("cooling demand in Watt")
     plt.show()
 
     # print the solver results
     print("********* Meta results *********")
     pp.pprint(es.results["meta"])
     print("")
 
+
 if __name__ == "__main__":
     main()

 
 """
 import pandas as pd
 from calculate_gain_by_Sun import Location
 from calculate_gain_by_Sun import Window
-from  dataclasses import dataclass
+from dataclasses import dataclass
 import os
-mainPath = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
-tabula_df = pd.DataFrame(pd.read_csv(os.path.join(mainPath, 'thermal_building_model', 'tabula_data_sorted.csv'),low_memory=False))
+
+mainPath = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+tabula_df = pd.DataFrame(
+    pd.read_csv(
+        os.path.join(
+            mainPath, "thermal_building_model", "tabula_data_sorted.csv"
+        ),
+        low_memory=False,
+    )
+)
+
 
 @dataclass
 class BuildingConfig:
     r"""
     The BuildingConfig gets generated by the function build_building_config of the building class

     Notes
     -----
     Examples
     --------
     """
-    total_internal_area : float
-    h_ve : float
-    h_tr_w : float
+    total_internal_area: float
+    h_ve: float
+    h_tr_w: float
     h_tr_em: float
-    h_tr_is : float
-    mass_area : float
-    h_tr_ms : float
-    c_m : float
-    floor_area : float
-    heat_transfer_coefficient_ventilation : float
-    total_air_change_rate : float
+    h_tr_is: float
+    mass_area: float
+    h_tr_ms: float
+    c_m: float
+    floor_area: float
+    heat_transfer_coefficient_ventilation: float
+    total_air_change_rate: float
+
 
 class Building:
-    def __init__(self,
-                 tabula_building_code : str,
-                 class_building : str,
-                 number_of_time_steps : float):
+    def __init__(
+        self,
+        tabula_building_code: str,
+        class_building: str,
+        number_of_time_steps: float,
+    ):
         self.tabula_building_code = tabula_building_code
         self.class_building = class_building
         self.number_of_time_steps = number_of_time_steps
         # DIN 13790: 12.3.1.2
-        self.list_class_buildig = {"very light": {"a_m_var": 2.5, "c_m_var": 80000},
-                                   "light": {"a_m_var": 2.5, "c_m_var": 110000},
-                                   "average": {"a_m_var": 2.5, "c_m_var": 165000},
-                                   "heavy": {"a_m_var": 3.0, "c_m_var": 260000},
-                                   "very heavy": {"a_m_var": 3.0, "c_m_var": 370000}}
+        self.list_class_buildig = {
+            "very light": {"a_m_var": 2.5, "c_m_var": 80000},
+            "light": {"a_m_var": 2.5, "c_m_var": 110000},
+            "average": {"a_m_var": 2.5, "c_m_var": 165000},
+            "heavy": {"a_m_var": 3.0, "c_m_var": 260000},
+            "very heavy": {"a_m_var": 3.0, "c_m_var": 370000},
+        }
         self.building_config = {}
 
     def calculate_all_parameters(self):
         self.get_building_parameters_from_csv()
-        self.total_internal_area : float = self.calc_internal_area()
-        self.h_ve : float = self.calc_h_ve()
-        self.h_tr_w : float = self.calc_h_tr_w()
-        self.h_tr_em : float = self.calc_h_tr_em()
-        self.h_tr_is : float = self.calf_h_tr_is()
-        self.mass_area : float = self.calc_mass_area()
-        self.h_tr_ms : float= self.calf_h_tr_ms()
-        self.c_m : float = self.calc_c_m()
-        #self.solar_gains : list  = self.calc_solar_gaings_through_windows()
+        self.total_internal_area: float = self.calc_internal_area()
+        self.h_ve: float = self.calc_h_ve()
+        self.h_tr_w: float = self.calc_h_tr_w()
+        self.h_tr_em: float = self.calc_h_tr_em()
+        self.h_tr_is: float = self.calf_h_tr_is()
+        self.mass_area: float = self.calc_mass_area()
+        self.h_tr_ms: float = self.calf_h_tr_ms()
+        self.c_m: float = self.calc_c_m()
+        # self.solar_gains : list  = self.calc_solar_gaings_through_windows()
         self.building_config = self.build_building_config()
 
     def build_building_config(self):
-        building_config = BuildingConfig(total_internal_area = self.total_internal_area,
-                           h_ve = self.h_ve ,
-                           h_tr_w = self.h_tr_w ,
-                           h_tr_em = self.h_tr_em ,
-                           h_tr_is = self.h_tr_is ,
-                           mass_area = self.mass_area ,
-                           h_tr_ms = self.h_tr_ms ,
-                           c_m = self.c_m ,
-                           floor_area = self.floor_area ,
-                           heat_transfer_coefficient_ventilation = self.heat_transfer_coefficient_ventilation,
-                           #solar_gains = self.solar_gains,
-                           total_air_change_rate = self.total_air_change_rate)
+        building_config = BuildingConfig(
+            total_internal_area=self.total_internal_area,
+            h_ve=self.h_ve,
+            h_tr_w=self.h_tr_w,
+            h_tr_em=self.h_tr_em,
+            h_tr_is=self.h_tr_is,
+            mass_area=self.mass_area,
+            h_tr_ms=self.h_tr_ms,
+            c_m=self.c_m,
+            floor_area=self.floor_area,
+            heat_transfer_coefficient_ventilation=self.heat_transfer_coefficient_ventilation,
+            # solar_gains = self.solar_gains,
+            total_air_change_rate=self.total_air_change_rate,
+        )
         return building_config
 
     def get_building_parameters_from_csv(self):
-        row = tabula_df.loc[tabula_df["Code_BuildingVariant"] == self.tabula_building_code]
-        building_volume = row["V_C"].values[0] #room_vol
-        list_type = ["" , "Measure_" , "Actual_"]
-        t_b = list_type [1]
-        self.opaque_elements = ["wall", "roof", "floor" ]
-
-        self.a_roof = {"a_roof_1" : float(row["A_Roof_1"].values[0]),
-                       "a_roof_2" : float(row["A_Roof_2"].values[0])}
-        self.u_roof = {"u_roof_1" : float(row["U_"+str(t_b)+"Roof_1"].values[0]),
-                       "u_roof_2" : float(row["U_"+str(t_b)+"Roof_2"].values[0])}
-        self.b_roof = {"b_roof_1" : float(row["b_Transmission_Roof_1"].values[0]),
-                       "b_roof_2" : float(row["b_Transmission_Roof_2"].values[0])}
-
-        self.a_floor = {"a_floor_1" : float(row["A_Floor_1"].values[0]),
-                        "a_floor_2" : float(row["A_Floor_2"].values[0])}
-        self.u_floor = {"u_floor_1" : float(row["U_"+str(t_b)+"Floor_1"].values[0]),
-                        "u_floor_2" : float(row["U_"+str(t_b)+"Floor_2"].values[0])}
-        self.b_floor = {"b_floor_1" : float(row["b_Transmission_Floor_1"].values[0]),
-                        "b_floor_2" : float(row["b_Transmission_Floor_2"].values[0])}
-
-        self.a_wall = {"a_wall_1" : float(row["A_Wall_1"].values[0]),
-                       "a_wall_2" : float(row["A_Wall_2"].values[0]),
-                       "a_wall_3" : float(row["A_Wall_3"].values[0])}
-        self.u_wall = {"u_wall_1" : float(row["U_"+str(t_b)+"Wall_1"].values[0]),
-                       "u_wall_2" : float(row["U_"+str(t_b)+"Wall_2"].values[0]),
-                       "u_wall_3" : float(row["U_"+str(t_b)+"Wall_3"].values[0])}
-        self.b_wall = {"b_wall_1" : float(row["b_Transmission_Wall_1"].values[0]),
-                       "b_wall_2" : float(row["b_Transmission_Wall_2"].values[0]),
-                       "b_wall_3" : float(row["b_Transmission_Wall_3"].values[0])}
-
-        self.a_door = {"a_door_1" : float(row["A_Door_1"].values[0])}
-        self.u_door = {"u_door_1" : float(row["U_"+str(t_b)+"Door_1"].values[0])}
-
-        self.a_window = {"a_window_1" : float(row["A_Window_1"].values[0]),
-                         "a_window_2" : float(row["A_Window_2"].values[0])}
-        self.a_window_specific = {"a_window_horizontal" : float(row["A_Window_Horizontal"].values[0]),
-                                  "a_window_east" : float(row["A_Window_East"].values[0]),
-                                  "a_window_south" : float(row["A_Window_South"].values[0]),
-                                  "a_window_west" : float(row["A_Window_West"].values[0]),
-                                  "a_window_north" : float(row["A_Window_North"].values[0])}
-        self.delta_u_thermal_bridiging = {"delta_u_thermal_bridiging" : float(row["delta_U_ThermalBridging"].values[0])}
-        self.u_window = {"u_window_1" : float(row["U_"+str(t_b)+"Window_1"].values[0]),
-                         "u_window_2" : float(row["U_"+str(t_b)+"Window_2"].values[0])}
-
-        self.g_gl_n_window =  {"g_gl_n_window_1" : float(row["g_gl_n_"+str(t_b)+"Window_1"].values[0]),
-                               "g_gl_n_window_2" : float(row["g_gl_n_"+str(t_b)+"Window_2"].values[0])}
+        row = tabula_df.loc[
+            tabula_df["Code_BuildingVariant"] == self.tabula_building_code
+        ]
+        building_volume = row["V_C"].values[0]  # room_vol
+        list_type = ["", "Measure_", "Actual_"]
+        t_b = list_type[1]
+        self.opaque_elements = ["wall", "roof", "floor"]
+
+        self.a_roof = {
+            "a_roof_1": float(row["A_Roof_1"].values[0]),
+            "a_roof_2": float(row["A_Roof_2"].values[0]),
+        }
+        self.u_roof = {
+            "u_roof_1": float(row["U_" + str(t_b) + "Roof_1"].values[0]),
+            "u_roof_2": float(row["U_" + str(t_b) + "Roof_2"].values[0]),
+        }
+        self.b_roof = {
+            "b_roof_1": float(row["b_Transmission_Roof_1"].values[0]),
+            "b_roof_2": float(row["b_Transmission_Roof_2"].values[0]),
+        }
+
+        self.a_floor = {
+            "a_floor_1": float(row["A_Floor_1"].values[0]),
+            "a_floor_2": float(row["A_Floor_2"].values[0]),
+        }
+        self.u_floor = {
+            "u_floor_1": float(row["U_" + str(t_b) + "Floor_1"].values[0]),
+            "u_floor_2": float(row["U_" + str(t_b) + "Floor_2"].values[0]),
+        }
+        self.b_floor = {
+            "b_floor_1": float(row["b_Transmission_Floor_1"].values[0]),
+            "b_floor_2": float(row["b_Transmission_Floor_2"].values[0]),
+        }
+
+        self.a_wall = {
+            "a_wall_1": float(row["A_Wall_1"].values[0]),
+            "a_wall_2": float(row["A_Wall_2"].values[0]),
+            "a_wall_3": float(row["A_Wall_3"].values[0]),
+        }
+        self.u_wall = {
+            "u_wall_1": float(row["U_" + str(t_b) + "Wall_1"].values[0]),
+            "u_wall_2": float(row["U_" + str(t_b) + "Wall_2"].values[0]),
+            "u_wall_3": float(row["U_" + str(t_b) + "Wall_3"].values[0]),
+        }
+        self.b_wall = {
+            "b_wall_1": float(row["b_Transmission_Wall_1"].values[0]),
+            "b_wall_2": float(row["b_Transmission_Wall_2"].values[0]),
+            "b_wall_3": float(row["b_Transmission_Wall_3"].values[0]),
+        }
+
+        self.a_door = {"a_door_1": float(row["A_Door_1"].values[0])}
+        self.u_door = {
+            "u_door_1": float(row["U_" + str(t_b) + "Door_1"].values[0])
+        }
+
+        self.a_window = {
+            "a_window_1": float(row["A_Window_1"].values[0]),
+            "a_window_2": float(row["A_Window_2"].values[0]),
+        }
+        self.a_window_specific = {
+            "a_window_horizontal": float(row["A_Window_Horizontal"].values[0]),
+            "a_window_east": float(row["A_Window_East"].values[0]),
+            "a_window_south": float(row["A_Window_South"].values[0]),
+            "a_window_west": float(row["A_Window_West"].values[0]),
+            "a_window_north": float(row["A_Window_North"].values[0]),
+        }
+        self.delta_u_thermal_bridiging = {
+            "delta_u_thermal_bridiging": float(
+                row["delta_U_ThermalBridging"].values[0]
+            )
+        }
+        self.u_window = {
+            "u_window_1": float(row["U_" + str(t_b) + "Window_1"].values[0]),
+            "u_window_2": float(row["U_" + str(t_b) + "Window_2"].values[0]),
+        }
+
+        self.g_gl_n_window = {
+            "g_gl_n_window_1": float(
+                row["g_gl_n_" + str(t_b) + "Window_1"].values[0]
+            ),
+            "g_gl_n_window_2": float(
+                row["g_gl_n_" + str(t_b) + "Window_2"].values[0]
+            ),
+        }
 
         self.floor_area = float(row["A_C_Ref"].values[0])
-        self.heat_transfer_coefficient_ventilation = float(row["h_Ventilation"].values[0])
+        self.heat_transfer_coefficient_ventilation = float(
+            row["h_Ventilation"].values[0]
+        )
 
         # References to check results
-        self.q_transmission_losses_annual = float(row["q_ht_tr"].values[0] * self.floor_area) #[kWh/a)]
-        self.q_ventilation_losses_annual = float(row["q_ht_ve"].values[0] * self.floor_area) #[kWh/a)]
-        self.q_total_losses_annual = float(row["q_ht"].values[0]) #[kWh/(m²a)]
-        self.q_solar_gains_annual = float (row["q_sol"].values[0]) #[kWh/(m²a)]
-        self.q_internal_gains_annual = float(row["q_int"].values[0]) #[kWh/(m²a)]
-        self.q_internal_gains_annual = float(row["q_int"].values[0])  # [kWh/(m²a)]
-        self.total_air_change_rate = float(row["n_air_use"] + row["n_air_infiltration"]) # [1/h]
-        self.room_height = float(row["h_room"])   # [m]
-        self.q_total_losses = float (row["q_ht"] * self.floor_area) # [kWh/a]
-        self.q_heating_demand_annual = float(row["q_h_nd"] * self.floor_area)  # [kWh/a]
-        self.h_transmission = float(row["h_Transmission"] * self.floor_area)   # [W/K]
-        self.h_ventilation = float (row["h_Ventilation"] * self.floor_area) # [W/K]
+        self.q_transmission_losses_annual = float(
+            row["q_ht_tr"].values[0] * self.floor_area
+        )  # [kWh/a)]
+        self.q_ventilation_losses_annual = float(
+            row["q_ht_ve"].values[0] * self.floor_area
+        )  # [kWh/a)]
+        self.q_total_losses_annual = float(
+            row["q_ht"].values[0]
+        )  # [kWh/(m²a)]
+        self.q_solar_gains_annual = float(
+            row["q_sol"].values[0]
+        )  # [kWh/(m²a)]
+        self.q_internal_gains_annual = float(
+            row["q_int"].values[0]
+        )  # [kWh/(m²a)]
+        self.q_internal_gains_annual = float(
+            row["q_int"].values[0]
+        )  # [kWh/(m²a)]
+        self.total_air_change_rate = float(
+            row["n_air_use"] + row["n_air_infiltration"]
+        )  # [1/h]
+        self.room_height = float(row["h_room"])  # [m]
+        self.q_total_losses = float(row["q_ht"] * self.floor_area)  # [kWh/a]
+        self.q_heating_demand_annual = float(
+            row["q_h_nd"] * self.floor_area
+        )  # [kWh/a]
+        self.h_transmission = float(
+            row["h_Transmission"] * self.floor_area
+        )  # [W/K]
+        self.h_ventilation = float(
+            row["h_Ventilation"] * self.floor_area
+        )  # [W/K]
 
     def calc_internal_area(self):
         # DIN 7.2.2.2
-        var_at = 4.5 # the dimensionless ratio between the surface area of all surfaces facing into the room and the useful area.
+        var_at = 4.5  # the dimensionless ratio between the surface area of all surfaces facing into the room and the useful area.
         total_internal_area = self.floor_area * var_at
         return total_internal_area
 
     def calc_h_tr_em(self):
-        h_tr_em=0
-        a_external=0
-        for x in range(1,len(self.a_wall)+1):
-            h_tr_em = h_tr_em + self.a_wall["a_wall_"+str(x)] *  self.u_wall["u_wall_"+str(x)] * self.b_wall["b_wall_"+str(x)]
-            a_external = a_external + self.a_wall["a_wall_"+str(x)]
-
-        for x in range(1,len(self.a_roof)+1):
-            h_tr_em = h_tr_em + self.a_roof["a_roof_"+str(x)] *  self.u_roof["u_roof_"+str(x)] * self.b_roof["b_roof_"+str(x)]
-            a_external = a_external + self.a_roof["a_roof_"+str(x)]
-
-        for x in range(1,len(self.a_floor)+1):
-            h_tr_em = h_tr_em + self.a_floor["a_floor_"+str(x)] *  self.u_floor["u_floor_"+str(x)] * self.b_floor["b_floor_"+str(x)]
-            a_external = a_external + self.a_floor["a_floor_"+str(x)]
+        h_tr_em = 0
+        a_external = 0
+        for x in range(1, len(self.a_wall) + 1):
+            h_tr_em = (
+                h_tr_em
+                + self.a_wall["a_wall_" + str(x)]
+                * self.u_wall["u_wall_" + str(x)]
+                * self.b_wall["b_wall_" + str(x)]
+            )
+            a_external = a_external + self.a_wall["a_wall_" + str(x)]
+
+        for x in range(1, len(self.a_roof) + 1):
+            h_tr_em = (
+                h_tr_em
+                + self.a_roof["a_roof_" + str(x)]
+                * self.u_roof["u_roof_" + str(x)]
+                * self.b_roof["b_roof_" + str(x)]
+            )
+            a_external = a_external + self.a_roof["a_roof_" + str(x)]
+
+        for x in range(1, len(self.a_floor) + 1):
+            h_tr_em = (
+                h_tr_em
+                + self.a_floor["a_floor_" + str(x)]
+                * self.u_floor["u_floor_" + str(x)]
+                * self.b_floor["b_floor_" + str(x)]
+            )
+            a_external = a_external + self.a_floor["a_floor_" + str(x)]
 
         for x in range(1, len(self.a_door) + 1):
-            h_tr_em = h_tr_em + self.a_door["a_door_" + str(x)] * self.u_door["u_door_" + str(x)]
+            h_tr_em = (
+                h_tr_em
+                + self.a_door["a_door_" + str(x)]
+                * self.u_door["u_door_" + str(x)]
+            )
             a_external = a_external + self.a_door["a_door_" + str(x)]
-        h_tr_em = h_tr_em + self.delta_u_thermal_bridiging["delta_u_thermal_bridiging"] * a_external
-        return h_tr_em #[W/K]
+        h_tr_em = (
+            h_tr_em
+            + self.delta_u_thermal_bridiging["delta_u_thermal_bridiging"]
+            * a_external
+        )
+        return h_tr_em  # [W/K]
 
     def calc_h_tr_w(self):
-        h_tr_w= 0
-        a_window= 0
-        for x in range(1,len(self.a_window)+1):
-            h_tr_w = h_tr_w + self.a_window["a_window_"+str(x)] *  self.u_window["u_window_"+str(x)]
-            a_window = a_window * self.a_window["a_window_"+str(x)]
-        h_tr_w = h_tr_w + self.delta_u_thermal_bridiging["delta_u_thermal_bridiging"] * a_window
-        return h_tr_w #[W/K]
+        h_tr_w = 0
+        a_window = 0
+        for x in range(1, len(self.a_window) + 1):
+            h_tr_w = (
+                h_tr_w
+                + self.a_window["a_window_" + str(x)]
+                * self.u_window["u_window_" + str(x)]
+            )
+            a_window = a_window * self.a_window["a_window_" + str(x)]
+        h_tr_w = (
+            h_tr_w
+            + self.delta_u_thermal_bridiging["delta_u_thermal_bridiging"]
+            * a_window
+        )
+        return h_tr_w  # [W/K]
 
     def calc_h_ve(self):
         # Determine the ventilation conductance, based on DIN13790 9.3.1
-        air_cap_vol_heat= 1200 #volume-related heat storage capacity of the air in [J/(m^3 * K)]
-        total_air_change_per_hour = self.total_air_change_rate * self.room_height * self.floor_area#[m^3 / h]
-
-        h_ve = (air_cap_vol_heat / 3600) *total_air_change_per_hour #[W/K]
+        air_cap_vol_heat = 1200  # volume-related heat storage capacity of the air in [J/(m^3 * K)]
+        total_air_change_per_hour = (
+            self.total_air_change_rate * self.room_height * self.floor_area
+        )  # [m^3 / h]
+
+        h_ve = (air_cap_vol_heat / 3600) * total_air_change_per_hour  # [W/K]
         return h_ve
-        '''
+        """
         # Determine the ventilation conductance, based on RC-Repository
         ach_vent = 1.5
         ach_infl = 0.5
         ventilation_efficiency = 0.6
         ach_tot = ach_infl + ach_vent  # Total Air Changes Per Hour

         # [ISO: E -27]
         b_ek = (1 - (ach_vent / (ach_tot)) * ventilation_efficiency)
         self.h_ve_adj = 1200 * b_ek * self.room_vol * \
             (ach_tot / 3600)  # Conductance through ventilation [W/M]
 
-        '''
+        """
         return h_ve
 
     def calf_h_tr_ms(self):
         h_tr_ms = 9.1 * self.mass_area
         return h_tr_ms

         h_tr_is = 3.45 * self.total_internal_area
         return h_tr_is
 
     def calc_mass_area(self):
         # Based on ISO standard 12.3.1.2
-        mass_area = self.floor_area * self.list_class_buildig[self.class_building]["a_m_var"]
+        mass_area = (
+            self.floor_area
+            * self.list_class_buildig[self.class_building]["a_m_var"]
+        )
         return mass_area
 
     def calc_c_m(self):
         # [kWh/K] Room Capacitance. Based on ISO standard 12.3.1.2
-        c_m = self.floor_area * self.list_class_buildig[self.class_building]["c_m_var"]
+        c_m = (
+            self.floor_area
+            * self.list_class_buildig[self.class_building]["c_m_var"]
+        )
         return c_m
 
     def calc_solar_gaings_through_windows(self, object_location_of_building):
         a_window_total = 0
         g_gl_n_window_avg = 0
-        for x in range(1,len(self.u_window)+1):
-            a_window_total = a_window_total + self.a_window["a_window_"+str(x)]
-
-        for x in range(1,len(self.g_gl_n_window)+1):
-            g_gl_n_window_avg =g_gl_n_window_avg + (self.g_gl_n_window["g_gl_n_window_" + str(x)] * self.a_window["a_window_"+str(x)]) / a_window_total
-
-        compass_directions = {"north" : { "azimuth_tilt": 270 , "alititude_tilt":90},
-                              "east" : { "azimuth_tilt": 90 , "alititude_tilt":90},
-                              "south" : { "azimuth_tilt": 180 , "alititude_tilt":90},
-                              "west" : { "azimuth_tilt": 0 , "alititude_tilt":90},
-                              "horizontal" : { "azimuth_tilt": 0 , "alititude_tilt":0}}
-        list_solar_gains=[]
+        for x in range(1, len(self.u_window) + 1):
+            a_window_total = (
+                a_window_total + self.a_window["a_window_" + str(x)]
+            )
+
+        for x in range(1, len(self.g_gl_n_window) + 1):
+            g_gl_n_window_avg = (
+                g_gl_n_window_avg
+                + (
+                    self.g_gl_n_window["g_gl_n_window_" + str(x)]
+                    * self.a_window["a_window_" + str(x)]
+                )
+                / a_window_total
+            )
+
+        compass_directions = {
+            "north": {"azimuth_tilt": 270, "alititude_tilt": 90},
+            "east": {"azimuth_tilt": 90, "alititude_tilt": 90},
+            "south": {"azimuth_tilt": 180, "alititude_tilt": 90},
+            "west": {"azimuth_tilt": 0, "alititude_tilt": 90},
+            "horizontal": {"azimuth_tilt": 0, "alititude_tilt": 0},
+        }
+        list_solar_gains = []
         for hour in range(self.number_of_time_steps):
-            sum_solar_gains=0
+            sum_solar_gains = 0
             for x in compass_directions:
-                altitude, azimuth = object_location_of_building.calc_sun_position(
-                    latitude_deg=48.16, longitude_deg=46.38, year=2015, hoy=hour)
+                (
+                    altitude,
+                    azimuth,
+                ) = object_location_of_building.calc_sun_position(
+                    latitude_deg=48.16,
+                    longitude_deg=46.38,
+                    year=2015,
+                    hoy=hour,
+                )
                 azimuth_tilt = compass_directions[x]["azimuth_tilt"]
                 alititude_tilt = compass_directions[x]["alititude_tilt"]
-                window_var = Window (azimuth_tilt=azimuth_tilt, alititude_tilt=alititude_tilt,
-                                     glass_solar_transmittance=g_gl_n_window_avg,
-                                     glass_light_transmittance=0.8, area=self.a_window_specific["a_window_" + str(x)])
-
-                window_var.calc_solar_gains(sun_altitude=altitude, sun_azimuth=azimuth,
-                                                 normal_direct_radiation=object_location_of_building.weather_data[
-                                                     'dirnorrad_Whm2'][hour],
-                                                 horizontal_diffuse_radiation=object_location_of_building.weather_data['difhorrad_Whm2'][hour])
+                window_var = Window(
+                    azimuth_tilt=azimuth_tilt,
+                    alititude_tilt=alititude_tilt,
+                    glass_solar_transmittance=g_gl_n_window_avg,
+                    glass_light_transmittance=0.8,
+                    area=self.a_window_specific["a_window_" + str(x)],
+                )
+
+                window_var.calc_solar_gains(
+                    sun_altitude=altitude,
+                    sun_azimuth=azimuth,
+                    normal_direct_radiation=object_location_of_building.weather_data[
+                        "dirnorrad_Whm2"
+                    ][
+                        hour
+                    ],
+                    horizontal_diffuse_radiation=object_location_of_building.weather_data[
+                        "difhorrad_Whm2"
+                    ][
+                        hour
+                    ],
+                )
                 sum_solar_gains = window_var.solar_gains + sum_solar_gains
             list_solar_gains.append(sum_solar_gains)
         return list_solar_gains
-

 
 from ._generic_caes import GenericCAES
 from ._piecewise_linear_converter import PiecewiseLinearConverter
 from ._sink_dsm import SinkDSM
 from ._generic_building import GenericBuilding
+
 __all__ = [
     "GenericCAES",
     "PiecewiseLinearConverter",
     "SinkDSM",
-    "GenericBuilding"
+    "GenericBuilding",
 ]

         solar_gains: List,
         internal_gains: List,
         inputs=None,
         outputs=None,
         phi_m_tot: float = 0,
-        t_set_heating : float = 20,
+        t_set_heating: float = 20,
         t_set_cooling: float = 40,
         t_inital: float = 20,
         t_m: float = 20,
-        t_m_ts: float = 20
+        t_m_ts: float = 20,
     ):
         if inputs is None:
             inputs = {}
         if outputs is None:
             outputs = {}
-        super().__init__(
-            label=label,
-            inputs=inputs,
-            outputs=outputs)
+        super().__init__(label=label, inputs=inputs, outputs=outputs)
 
         self.building_config = building_config
         self.t_e = t_outside
         self.internal_gains = internal_gains
         self.phi_m_tot = phi_m_tot

         self.t_inital = t_inital
         self.t_m = t_m
         self.t_m_ts = t_m_ts
 
         self.floor_area = self.building_config.floor_area  # [m2] Floor Area
-        self.mass_area = self.building_config.mass_area  # [m2] Effective Mass Area DIN 12.3.1.2
-        self.A_t = self.building_config.total_internal_area  # [m2] the area of all surfaces facing the room DIN 7.2.2.2
+        self.mass_area = (
+            self.building_config.mass_area
+        )  # [m2] Effective Mass Area DIN 12.3.1.2
+        self.A_t = (
+            self.building_config.total_internal_area
+        )  # [m2] the area of all surfaces facing the room DIN 7.2.2.2
         self.c_m = self.building_config.c_m  # [kWh/K] Room Capacitance
-        self.ach_tot = self.building_config.total_air_change_rate  # [m3/s]Total Air Changes Per Hour
-
-        self.h_tr_em = self.building_config.h_tr_em  # [W/K] Conductance of opaque surfaces to exterior
-        self.h_tr_w = self.building_config.h_tr_w  # [W/K] Conductance to exterior through glazed surfaces
-        self.h_ve = self.building_config.h_ve  # [W/K] Conductance to ventilation
-        self.h_tr_ms = self.building_config.h_tr_ms  # [W/K] transmittance from the internal air to the thermal mass
-        self.h_tr_is = self.building_config.h_tr_is  # [W/K] Conductance from the conditioned air to interior zone surface
-
-        self.phi_st = []  # [W] Combination of internal and solar gains directly to the internal surfa
-        self.phi_m = []  # [W] Combination of internal and solar gains directly to the medium
-        self.phi_ia = []  # [W] Combination of internal and solar gains to the air
+        self.ach_tot = (
+            self.building_config.total_air_change_rate
+        )  # [m3/s]Total Air Changes Per Hour
+
+        self.h_tr_em = (
+            self.building_config.h_tr_em
+        )  # [W/K] Conductance of opaque surfaces to exterior
+        self.h_tr_w = (
+            self.building_config.h_tr_w
+        )  # [W/K] Conductance to exterior through glazed surfaces
+        self.h_ve = (
+            self.building_config.h_ve
+        )  # [W/K] Conductance to ventilation
+        self.h_tr_ms = (
+            self.building_config.h_tr_ms
+        )  # [W/K] transmittance from the internal air to the thermal mass
+        self.h_tr_is = (
+            self.building_config.h_tr_is
+        )  # [W/K] Conductance from the conditioned air to interior zone surface
+
+        self.phi_st = (
+            []
+        )  # [W] Combination of internal and solar gains directly to the internal surfa
+        self.phi_m = (
+            []
+        )  # [W] Combination of internal and solar gains directly to the medium
+        self.phi_ia = (
+            []
+        )  # [W] Combination of internal and solar gains to the air
         for i in range(len(self.solar_gains)):
-            self.h_tr_1 = self.calc_h_tr_1()  # [W/K] combined heat conductance, see function for definition
-            self.h_tr_2 = self.calc_h_tr_2()  # [W/K] combined heat conductance, see function for definition
-            self.h_tr_3 = self.calc_h_tr_3()  # [W/K] combined heat conductance, see function for definition
+            self.h_tr_1 = (
+                self.calc_h_tr_1()
+            )  # [W/K] combined heat conductance, see function for definition
+            self.h_tr_2 = (
+                self.calc_h_tr_2()
+            )  # [W/K] combined heat conductance, see function for definition
+            self.h_tr_3 = (
+                self.calc_h_tr_3()
+            )  # [W/K] combined heat conductance, see function for definition
             self.phi_ia.append(self.calc_phi_ia(i))
             self.phi_st.append(self.calc_phi_st(i))
             self.phi_m.append(self.calc_phi_m(i))
 
     def calc_h_tr_1(self):

     def calc_phi_st(self, i: float):
         """
         Heat flow in [W] to the surface node
         (based on the breakdown in section C.2) formulas C.1-C.3 in [ISO 13790]
         """
-        return (1 - (self.mass_area / self.A_t) -
-                (self.h_tr_w / (9.1 * self.A_t))) * (0.5 * self.internal_gains[i] + self.solar_gains[i])
+        return (
+            1 - (self.mass_area / self.A_t) - (self.h_tr_w / (9.1 * self.A_t))
+        ) * (0.5 * self.internal_gains[i] + self.solar_gains[i])
 
     def calc_phi_m(self, i: float):
         """
         Heatflow in [W] to the thermal mass node
         (based on the breakdown in section C.2) formulas C.1-C.3 in [ISO 13790]
         """
-        return (self.mass_area / self.A_t) * \
-               (0.5 * self.internal_gains[i] + self.solar_gains[i])
+        return (self.mass_area / self.A_t) * (
+            0.5 * self.internal_gains[i] + self.solar_gains[i]
+        )
 
     def _check_number_of_flows(self):
         """Ensure that there is only one inflow and outflow to the building"""
         msg = "Only one {0} flow allowed in the GenericBuilding {1}."
         check_node_object_for_missing_attribute(self, "inputs")

 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def _create(self, group=None):
-
         m = self.parent_block()
         if group is None:
             return None
 
         i = {n: [i for i in n.inputs][0] for n in group}

                 n.t_set_cooling,
             )
             return bounds
 
         self.t_air = Var(
-            self.BUILDING, m.TIMEPOINTS, bounds=_internal_temperature_bound_rule
-        )
-        self.t_m_ts = Var(
-            self.BUILDING, m.TIMEPOINTS
-        )
-
-        self.phi_m_tot = Var(
-            self.BUILDING, m.TIMEPOINTS
-        )
+            self.BUILDING,
+            m.TIMEPOINTS,
+            bounds=_internal_temperature_bound_rule,
+        )
+        self.t_m_ts = Var(self.BUILDING, m.TIMEPOINTS)
+
+        self.phi_m_tot = Var(self.BUILDING, m.TIMEPOINTS)
 
         # set the initial building temperature
         # ToDo: More elegant code possible?
         for n in group:
             if n.t_inital is not None:
-                self.t_air[n, 0] = (
-                    n.t_inital
-                )
+                self.t_air[n, 0] = n.t_inital
                 self.t_air[n, 0].fix()
 
             if n.t_m_ts is not None:
-                self.t_m_ts[n, 0] = (
-                    n.t_inital
-                )
+                self.t_m_ts[n, 0] = n.t_inital
                 self.t_m_ts[n, 0].fix()
 
             if n.phi_m_tot is not None:
-                self.phi_m_tot[n, 0] = (
-                    0
-                )
+                self.phi_m_tot[n, 0] = 0
                 self.phi_m_tot[n, 0].fix()
 
         def _storage_balance_rule_ts(block, n, p, t):
             t_m_last_ts = block.t_m_ts[n, t]
             phi_m_tot = block.phi_m_tot[n, t + 1]
-            t_m_current_ts = (t_m_last_ts * ((n.c_m / 3600) - 0.5 * (n.h_tr_3 + n.h_tr_em)) + phi_m_tot) / (
-                    (n.c_m / 3600) + 0.5 * (n.h_tr_3 + n.h_tr_em))
+            t_m_current_ts = (
+                t_m_last_ts * ((n.c_m / 3600) - 0.5 * (n.h_tr_3 + n.h_tr_em))
+                + phi_m_tot
+            ) / ((n.c_m / 3600) + 0.5 * (n.h_tr_3 + n.h_tr_em))
 
             return block.t_m_ts[n, t + 1] == t_m_current_ts
 
-        self.balance_t_m_current_t_s = Constraint(self.BUILDING, m.TIMEINDEX, rule=_storage_balance_rule_ts)
+        self.balance_t_m_current_t_s = Constraint(
+            self.BUILDING, m.TIMEINDEX, rule=_storage_balance_rule_ts
+        )
 
         def _storage_balance_rule_phi_m_tot(block, n, p, t):
             phi_hc_heat = m.flow[i[n], n, p, t]
             phi_hc_cool = m.flow[n, o[n], p, t]
             phi_hc_nd = phi_hc_heat - phi_hc_cool
 
-            phi_m_tot = n.phi_m[t] + n.h_tr_em * n.t_e[t] + (n.h_tr_3 / n.h_tr_2) * (
-                n.phi_st[t] + n.h_tr_w * n.t_e[t] + n.h_tr_1 * (((n.phi_ia[t] + phi_hc_nd) / n.h_ve) + n.t_e[t]))
+            phi_m_tot = (
+                n.phi_m[t]
+                + n.h_tr_em * n.t_e[t]
+                + (n.h_tr_3 / n.h_tr_2)
+                * (
+                    n.phi_st[t]
+                    + n.h_tr_w * n.t_e[t]
+                    + n.h_tr_1
+                    * (((n.phi_ia[t] + phi_hc_nd) / n.h_ve) + n.t_e[t])
+                )
+            )
             return block.phi_m_tot[n, t + 1] == phi_m_tot
 
-        self.balance_phi_m_tot = Constraint(self.BUILDING, m.TIMEINDEX, rule=_storage_balance_rule_phi_m_tot)
+        self.balance_phi_m_tot = Constraint(
+            self.BUILDING, m.TIMEINDEX, rule=_storage_balance_rule_phi_m_tot
+        )
 
         def _storage_balance_rule_t_air(block, n, p, t):
             phi_hc_heat = m.flow[i[n], n, p, t]
             phi_hc_cool = m.flow[n, o[n], p, t]
             phi_hc_nd = phi_hc_heat - phi_hc_cool
             t_m_last_ts = block.t_m_ts[n, t]
             t_m_current_ts = block.t_m_ts[n, t + 1]
             t_m = (t_m_last_ts + t_m_current_ts) / 2
 
-            t_s = (n.h_tr_ms * t_m + n.phi_st[t] + n.h_tr_w * n.t_e[t] + n.h_tr_1 * (
-                    n.t_e[t] + (n.phi_ia[t] + phi_hc_nd) / n.h_ve)) / \
-                  (n.h_tr_ms + n.h_tr_w + n.h_tr_1)
-            t_air = (n.h_tr_is * t_s + n.h_ve * n.t_e[t] + n.phi_ia[t] + phi_hc_nd) / (n.h_tr_is + n.h_ve)
+            t_s = (
+                n.h_tr_ms * t_m
+                + n.phi_st[t]
+                + n.h_tr_w * n.t_e[t]
+                + n.h_tr_1 * (n.t_e[t] + (n.phi_ia[t] + phi_hc_nd) / n.h_ve)
+            ) / (n.h_tr_ms + n.h_tr_w + n.h_tr_1)
+            t_air = (
+                n.h_tr_is * t_s + n.h_ve * n.t_e[t] + n.phi_ia[t] + phi_hc_nd
+            ) / (n.h_tr_is + n.h_ve)
             return block.t_air[n, t + 1] == t_air
 
-        self.balance_t_air = Constraint(self.BUILDING, m.TIMEINDEX, rule=_storage_balance_rule_t_air)
+        self.balance_t_air = Constraint(
+            self.BUILDING, m.TIMEINDEX, rule=_storage_balance_rule_t_air
+        )
 
     def _objective_expression(self):
         r"""
         Objective expression for BUILDING with no investment.
         Note: This adds nothing as variable costs are already

         """
         if not hasattr(self, "BUILDING"):
             return 0
 
         return 0
-