buildyn 1.0.0__py3-none-any.whl

buildyn/__init__.py

@@ -0,0 +1,2 @@
+from .fmu import FMU
+from .buildyn import BuilDyn

buildyn/buildyn.py

@@ -0,0 +1,129 @@
+from buildyn.fmu import FMU
+from typing import Dict
+from buildyn.walker.walker import Walker
+from buildyn.walker.interval_walker import IntervalWalker
+from buildyn.distributions.distribution import Distribution
+from buildyn.distributions.discrete.discrete_distribution import DiscreteDistribution
+
+from copy import copy
+import itertools
+
+class BuilDyn:
+
+    def __init__(self, 
+                 fmu: FMU,
+                 observables: list = []
+                 ):
+
+        self.variation_distributions: Dict[str, Distribution] = dict()
+
+        self.walker_distributions: Dict[str, IntervalWalker | DiscreteDistribution] = dict()
+
+        self.fmu: FMU = fmu
+
+        self.observables = observables
+
+
+    def add_variation_distribution(self, variable: str, distribution: Distribution):
+
+        self.variation_distributions[variable] = distribution
+
+
+    def add_walker_distribution(self, variable: str, distribution: IntervalWalker | DiscreteDistribution):
+
+        self.walker_distributions[variable] = distribution
+
+
+    def sample_one(self,
+                   start_time: int = 0,
+                   stop_time: int = 86_400,
+                   step_size: int = 900):
+        
+
+        # Sample one fmu with random variation
+        fmu = self.sample_one_fmu()
+
+        # Sample the walker from the correpnding walker distributions
+        walker: Dict[str, Walker] = dict()
+
+        for param, walker_dist in self.walker_distributions.items():
+            
+            if isinstance(walker_dist, IntervalWalker):
+
+                walker[param] = walker_dist
+                continue
+
+            walker[param] = walker_dist.sample_one()
+
+        res = fmu.simulate(
+                    start_time=start_time,
+                    stop_time=stop_time,
+                    step_size=step_size,
+                    observables=self.observables,
+                    walker=walker
+                )
+
+        return res
+    
+
+    def sample_one_fmu(self):
+
+        fmu = self.fmu.__copy__()
+
+        fmu_initial_variables = dict()
+
+        # Sample the variations from the corresponding distributions
+        for param, distirbution in self.variation_distributions.items():
+
+            variable_value = distirbution.sample_one()
+
+            fmu_initial_variables[param] = variable_value
+
+            fmu.set_initial_variables(variables=fmu_initial_variables)
+
+        return fmu
+    
+
+    def sample_all_fmus(self):
+
+        all_fmus = []
+        all_samples = {}
+
+        # Check if all distributions in this class are Discrete, else it would not be possible to really sample all.
+
+        for variable, distribution in self.variation_distributions.items():
+
+            if not isinstance(distribution, DiscreteDistribution):
+
+                return TypeError(f"Sampling all FMUs in not possible because {distribution.__class__.__name__} is not a discrete distribution.")
+            
+            all_samples[variable] = distribution.sample_all()
+
+        keys = list(all_samples.keys())
+        values = list(all_samples.values())
+
+        # Making the cartesian product of the sample_all
+        for combination in itertools.product(*values):
+
+            variation_dict = dict(zip(keys, combination))
+
+            fmu = copy(self.fmu)
+            fmu.set_initial_variables(variation_dict)
+
+            all_fmus.append(fmu)
+
+        return all_fmus
+
+
+
+        
+
+
+
+            
+
+            
+
+        
+
+

buildyn/converter/__init__.py

@@ -0,0 +1,2 @@
+from .converter_function import ConverterFunction
+from .converter import Converter

buildyn/converter/converter.py

@@ -0,0 +1,35 @@
+from buildyn.converter.converter_function import ConverterFunction
+
+class Converter:
+
+    def __init__(self):
+
+        self.converter_functions: set[ConverterFunction] = []
+
+        # For variables that should be used in the variation step of an fmu.
+        self.converter_variables: dict[str, str | bool | float | int] = {}
+
+
+    def add_converter_function(self, converter_function: ConverterFunction = None):
+
+        if not converter_function:
+            return
+        
+        self.converter_functions.append(converter_function)
+
+
+    def get_converter_functions(self) -> list[ConverterFunction]:
+
+        return self.converter_functions
+    
+
+    def update_converter_variables(self, d: dict[str, str | bool | float | int]):
+
+        self.converter_variables.update(d)
+
+
+    def get_converter_variables(self) -> dict[str, str | bool | float | int]:
+
+        return self.converter_variables
+
+        

buildyn/converter/converter_function.py

@@ -0,0 +1,12 @@
+from abc import ABC
+
+class ConverterFunction(ABC):
+
+    def __init__(self):
+
+        pass
+
+
+    def convert(self, var_dict: dict):
+
+        return NotImplementedError("Function convert not implemented in this ConverterFunction. Please override this method first.")

buildyn/distributions/__init__.py

@@ -0,0 +1 @@
+from .distribution import Distribution

buildyn/distributions/continuous/__init__.py

@@ -0,0 +1,2 @@
+from .continuous_distribution import ContinuousDistribution
+from .gauss_distribution import GaussDistribution

buildyn/distributions/continuous/continuous_distribution.py

@@ -0,0 +1,5 @@
+from buildyn.distributions.distribution import Distribution
+
+class ContinuousDistribution(Distribution):
+
+    pass

buildyn/distributions/continuous/gauss_distribution.py

@@ -0,0 +1,35 @@
+from buildyn.distributions.continuous.continuous_distribution import ContinuousDistribution
+import random
+
+class GaussDistribution(ContinuousDistribution):
+
+    def __init__(self, mu, sigma, min: float = None, max: float = None):
+
+        super().__init__()
+
+        self.mu = mu
+        self.sigma = sigma
+        self.min = min
+        self.max = max
+
+
+    def sample_one(self):
+
+        # No bounds → return normally
+        if self.min is None and self.max is None:
+            return random.gauss(self.mu, self.sigma)
+
+        # Otherwise, keep sampling until value is within bounds
+        for _ in range(999):
+            value = random.gauss(self.mu, self.sigma)
+
+            if self.min is not None and value < self.min:
+                continue
+            if self.max is not None and value > self.max:
+                continue
+
+            return value
+        
+        # We assume that the min-max is near-impossible to hit.
+        raise Exception(f"Gauss distribution: Not realistic with min {self.min} and max {self.max}")
+    

buildyn/distributions/discrete/__init__.py

@@ -0,0 +1,2 @@
+from .discrete_distribution import DiscreteDistribution
+from .random_choice import RandomChoiceDistribution

buildyn/distributions/discrete/discrete_distribution.py

@@ -0,0 +1,10 @@
+from abc import abstractmethod
+
+from buildyn.distributions.distribution import Distribution
+
+class DiscreteDistribution(Distribution):
+
+    @abstractmethod
+    def sample_all(self):
+
+        pass

buildyn/distributions/discrete/random_choice.py

@@ -0,0 +1,21 @@
+from buildyn.distributions.discrete.discrete_distribution import DiscreteDistribution
+import random
+
+class RandomChoiceDistribution(DiscreteDistribution):
+
+    def __init__(self, choices: list | set):
+
+        super().__init__()
+
+        self.choices = choices
+
+
+    def sample_one(self):
+        
+        return random.choice(self.choices)
+    
+
+    def sample_all(self):
+        
+        return self.choices
+    

buildyn/distributions/distribution.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+class Distribution(ABC):
+
+    @abstractmethod
+    def sample_one(self):
+
+        pass
+    
+
+    def sample_multiple(self, n: int):
+
+        return [self.sample_one() for _ in range(n)]

buildyn/examples/builda/builda_fmu.py

@@ -0,0 +1,104 @@
+from buildyn.converter import Converter
+from buildyn.examples.builda.converter_functions.Component_configurator import Component_configurator
+from buildyn.examples.builda.converter_functions.Link_resolver import Link_resolver
+from buildyn.examples.builda.converter_functions.Miscellaneous_handler import Miscellaneous_handler
+from buildyn.examples.builda.converter_functions.Model_compatibility_layer import Model_compatibility_layer
+from buildyn.examples.builda.converter_functions.Nominal_cooling_power_calculator import Nominal_cooling_power_calculator
+from buildyn.examples.builda.converter_functions.Nominal_heating_power_calculator import Nominal_heating_power_calculator
+from buildyn.examples.builda.converter_functions.RC_Distribution_Configurator import RC_Distribution_Configurator
+from buildyn.examples.builda.converter_functions.Zone_dimensions_calculator import Zone_dimensions_calculator
+from buildyn.examples.builda.converter_functions.Component_properties_calculator import Component_properties_calculator
+
+
+# Helper function to retrieve the pre-configured BuilDa FMU with all converter functions and default values set.
+def get_configured_builda_fmu(internal_controller: bool = False):
+
+    converter = Converter()
+
+    # All the converter functiosn from BuilDa 2.0
+    converter_functions = [Link_resolver, Miscellaneous_handler, Model_compatibility_layer, Zone_dimensions_calculator, Component_configurator, RC_Distribution_Configurator, Component_properties_calculator, Nominal_heating_power_calculator, Nominal_cooling_power_calculator]
+
+    for cf in converter_functions:
+        converter.add_converter_function(cf())
+
+    converter_variables = {
+        "zone_length": 9.4125,
+        "zone_width": 8,
+        "floor_height": 3.04,
+        "n_floors": 2,
+        "fAWin_south": 0.14056,
+        "fAWin_west": 0.14056,
+        "fAWin_north": 0.14056,
+        "fAWin_east": 0.14056,
+        "fATransToAWindow": 0.9,
+        "fARoofToAFloor": 1.63612217795485,
+        "fAInt": 1.238235294117647,
+        "heatCapacity_furniture_per_m2": 2230,
+        "UExt": 0.665,
+        "heatCapacity_wall": 192000,
+        "UFloor": 0.514,
+        "heatCapacity_floor": 483840,
+        "UInt": 1,
+        "heatCapacity_internalWall": 145154,
+        "URoof": 0.402,
+        "heatCapacity_roof": 81240,
+        "UWin": 3.2,
+        "thermalZone.gWin": 0.7,
+        "heatRecoveryRate": 0,
+        "airChangeRate": 0.3,
+        "heatingCurve_steepness": 1,
+        "relative_heatPump_efficiency": 0.8,
+        "internalGainsConvectiveFraction": 0.4,
+        "heatingConvectiveFraction": 1,
+        "weaDat.fileName": "resources/Munich.mos",
+        "internalGain.fileName": "resources/NoActivity.txt",
+        "hygienicalWindowOpening.fileName": "resources/no_opening.txt",
+        "roomTempLowerSetpoint": 18,
+        "roomTempUpperSetpoint": 22,
+        #"UseInternalController": 0,
+        "extWall_C_distribution": "monolythic",
+        "floor_C_distribution": [478800, 5040, 0.001],
+        "roof_C_distribution": [22440, 58800, 0.001],
+        "extWall_R_distribution": "monolythic",
+        "floor_R_distribution": [0.0525, 0.0525, 0.1579, 0.0001],
+        "roof_R_distribution": [1.1085, 1.1085, 0.1, 0.0001],
+        "intWall_R_distribution": "monolythic",
+        "intWall_C_distribution": "monolythic",
+        "Rsi_extWall": 0.13333333333333333,
+        "Rsi_intWall": 0.13333333333333333,
+        "Rsi_floor": 0.17543859649122806,
+        "Rsi_roof": 0.1,
+        "Rse_extWall": 0.04,
+        "Rse_roof": 0.04,
+        "Rsi_window": 0.13333333333333333,
+        "Rse_window": 0.05,
+        "ta_min": None,
+        "ti_set": None
+    }
+
+    # Set the converter variables in the converter. This also updates previously set variables.
+    converter.update_converter_variables(converter_variables)
+
+    from buildyn import FMU
+    import json
+
+    # Example FMU from BuilDa 2.0
+    fmu_path = "resources/building.fmu"
+
+    # Initial variables from the BuilDa 2.0 FMU -> Needs extra variables here because the BuilDa FMU is weird. For other use-cases you don't have to do this.
+    with open("resources/fmu_state_dict.json", "r") as f:
+        start_variables = json.load(f)
+
+    start_variables.update({
+        "weaDat.filNam": "resources/Munich.mos",
+        "internalGain.fileName": "resources/NoActivity.txt",
+        "hygienicalWindowOpening.fileName": "resources/no_opening.txt",
+        "UseInternalController.k": 1 if internal_controller else 0
+    })
+
+    # FMU object from the buil_dyn package
+    fmu = FMU(fmu_file=fmu_path, init_values=start_variables)
+
+    fmu.set_converter(converter=converter)
+
+    return fmu

buildyn/examples/builda/converter_functions/Component_configurator.py

@@ -0,0 +1,119 @@
+from buildyn.converter.converter_function import ConverterFunction
+import pandas as pd 
+
+
+class Component_configurator(ConverterFunction):
+    '''
+    Sets up preconfigured wall construction profiles comprising U-Value, 
+    heat capacity and R- and C-distributions.
+    Profiles include e.g., 'heavy', 'lightweight',  
+        'pumiceAndBrick', 'baloonFraming'
+    '''
+    def __init__(self):
+        super().__init__()
+        # Definition of Component_constructions_n3, only use, when number of elements n=3,
+        self.Component_constructions_n3={
+
+            "heavy":{               #from ashrae 140-2004 TC900
+                "UExt":0.512,
+                "heatCapacity_wall":145154,
+                "extWall_C_distribution":"heavy",
+                "extWall_R_distribution":"heavy", 
+
+                "URoof":0.318,
+                "heatCapacity_roof":18169.944,
+                "roof_C_distribution":"heavy",
+                "roof_R_distribution":"heavy",                
+                "UFloor":0.039,
+                "heatCapacity_floor":112000.00200000001,
+                "floor_C_distribution":"heavy",
+                "floor_R_distribution":"heavy",
+            },     
+            "lightweight":{               #from ashrae 140-2004 TC600
+                "UExt":0.514,
+                "heatCapacity_wall":14534.28,
+                "extWall_C_distribution":"lightweight",
+                "extWall_R_distribution":"lightweight",
+
+                "URoof":0.318,
+                "heatCapacity_roof":18169.944,
+                "roof_C_distribution":"lightweight",
+                "roof_R_distribution":"lightweight",                
+                "UFloor":0.039,
+                "heatCapacity_floor":29610.239999999998,
+                "floor_C_distribution":"lightweight",
+                "floor_R_distribution":"lightweight",
+                
+            },       
+
+
+            #wall constructrion according to: 
+            # https://www.ubakus.de/u-wert-rechner/index.php?c=2&M0=132061I1&M1=132153I33&l1=0.23&r1=550&name1=Geschosshohe%20Porenbetonplatten&v1=f2f2f2&tex1=gf&M2=77i5&T_i=20&RH_i=50&Te=-5&RH_e=80&outside=0&bt=0&unorm=enev14alt&cq=2947871&name=AW%20Porenbeton%20Fassadenelemente%20GSB%2035%2C%2033%20cm%2C%20ab%201952&fz=14
+            "gasConcrete":{               #from ashrae 140-2004 TC600
+                "UExt":0.615,
+                "heatCapacity_wall":201500,
+                "extWall_C_distribution":"gasConcrete",
+                "extWall_R_distribution":"gasConcrete",
+            },     
+
+
+            #wall constructrion according to: 
+            # https://www.ubakus.de/u-wert-rechner/index.php?c=2&M0=199i15&M1=132261I24&v1=b7b7b7&tex1=0&M2=133477I2&M3=136921i115&v3=cc5c4a&tex3=vz2&T_i=20&RH_i=50&Te=-5&RH_e=80&outside=0&bt=0&Rsi=U&unorm=enev14alt&cq=2947497&name=AW%20Bims-Schwemmstein%2024%20cm%2C%20Schalenfuge%2FVZ-Vormauer%201200%20kg%2Fm%C2%B3%2C%20ab%201952&fz=14
+            "pumiceAndBrick":{ 
+                "UExt":0.9,
+                "heatCapacity_wall":333100,
+                "extWall_C_distribution":"pumiceAndBrick",
+                "extWall_R_distribution":"pumiceAndBrick",
+            },
+
+            #wall constructrion according to: 
+            # https://www.ubakus.de/u-wert-rechner/index.php?c=2&M0=133859i6&M1=36i24&M2=137011i2&M3=86I6&M4=36I9&x4=-0.05&y4=0.2&w4=6&R4=60&M5=132403I3&v5=81674f&tex5=kork&M6=132657i3&M7=90i24&M8=36i24&y8=0&w8=4.8&R8=30&hz8=1&M9=119929i44&T_i=20&RH_i=50&Te=-5&RH_e=80&outside=0&bt=0&unorm=enev14alt&cq=2947513&name=AW%20Einsteins%20Sommerhaus%2C%20Holzrahmen%2012%20cm%2C%203%20cm%20Torfd%C3%A4mmung%2C%201929&fz=14
+            "baloonFraming":{ 
+                "UExt":0.732,
+                "heatCapacity_wall":37176,
+                "extWall_C_distribution":"baloonFraming",
+                "extWall_R_distribution":"baloonFraming",
+            },
+
+            ##Draft for additional Component_constructions_n3 profile:
+            # "templateWall":{ 
+            #     "UExt":*value_of_template_wall*,
+            #     "heatCapacity_wall":*value_of_template_wall*,
+            #     "extWall_C_distribution":*C-Distribution_of_template_wall*,
+            #     "extWall_R_distribution":*R-Distribution_of_template_wall*,
+            #     add other expressions as needed...
+            # },
+        }
+
+        #add components defined in external files
+        import json,glob,os
+        for json_file in glob.glob("resources/componentConstructions/*json"):
+            new_components=json.load(open(json_file,"r"))
+            new_keys=set(new_components.keys()) - set(self.Component_constructions_n3.keys())
+            if len(new_keys)==0:
+                print(f"Nothing added from file {json_file}, as {list(new_components.keys())} already configured.")
+            for key in new_keys:
+                self.Component_constructions_n3.update({key:new_components[key]})
+
+
+    
+
+
+    def convert(self, variable_dict):
+        tr=variable_dict
+        for key in tr.keys():
+            #check if configured parameter value of parameter key is within the 
+            # Component construction profiles, indicating that an existing 
+            # profile should be applied for configuration
+            if type(tr[key]) is str   and   tr[key] in self.Component_constructions_n3.keys():
+                try:
+                    #replace formerly configured link to profile by corresponding 
+                    # value from profile
+                    tr[key]=self.Component_constructions_n3[tr[key]] [key]
+                except KeyError:
+                    #raises an error, if there is no value for the parameter configured
+                    # in profile, except parameter is starting with '#'
+                    if not(key.startswith("#")):
+                        raise IndexError(f"""Could not read out value for parameter '{key}' on component profile '{tr[key]}'. There is none configured.""")        
+        return tr
+