examples

You can find more examples in the example package of the TEASER distribution. e.g.:

[PathOfYourPythonDistribution/Lib/site-packages/teaser]

archetype.py

This module contains an example how to create an archetype Building, to retrofit that building and to export that building to internal XML and a Modelica record

First thing we need to do is to import our Project API module:

from teaser.project import Project

We instantiate the Project class. The parameter load_data = True indicates that we load the XML data bases into our Project. This can take a few sec.:

prj = Project(load_data = True)

The five functions starting with type_bldg giving us the opportunity to create the specific type building (e.g. type_bldg_residential). The function automatically calculates all the necessary parameter. If not specified different it uses vdi calculation method:

prj.type_bldg_residential(
    name="ResidentialBuilding",
    year_of_construction=1988,
    number_of_floors=2,
    height_of_floors=3.5,
    net_leased_area=100,
    with_ahu=True,
    residential_layout=1,
    neighbour_buildings=1,
    attic=1,
    cellar=1,
    construction_type="heavy",
    dormer=1)

prj.type_bldg_office(
    name="Office1",
    year_of_construction=1988,
    number_of_floors=2,
    height_of_floors=3.5,
    net_leased_area=100,
    office_layout=1,
    window_layout=1,
    with_ahu=True,
    construction_type="heavy")

We need to set the projects calculation method. The library we want to use is AixLib, we are using a two element model and want an extra resistance for the windows. To export the parameters to a Modelica record, we use the export_aixlib function. path = None indicates, that we want to store the records in TEASER’S Output folder:

prj.used_library_calc = 'AixLib'
prj.number_of_elements_calc = 2
prj.merge_windows_calc = False
prj.calc_all_buildings()
prj.export_aixlib(
    building_model="MultizoneEquipped",
    zone_model="ThermalZoneEquipped",
    corG=True,
    internal_id=None,
    path=None)

For OpenModelica you need to exclude the centralAHU (because it uses state machines). Therefore use the building_model “Multizone”:

prj.export_aixlib(building_model="Multizone",
    zone_model="ThermalZoneEquipped",
    corG=True,
    internal_id=None,
    path=None)

We could also use Annex60 models with same calculation method, which exports one model per zone:

prj.used_library_calc = "Annex60"
prj.calc_all_buildings()
prj.export_annex(number_of_elements=2,
                 merge_windows=False,
                 internal_id=None,
                 path=None)

Now we retrofit all buildings in the year 2015 (EnEV2014). That includes new insulation layer and new windows. The name is changed to Retrofit:

prj.name = "Project_Retrofit"
prj.retrofit_all_buildings(2015)

Again, we need to export the model, ou could also change the exports here as seen above:

prj.export_aixlib(
    building_model="MultizoneEquipped",
    zone_model="ThermalZoneEquipped",
    corG=True,
    internal_id=None,
    path=None)

To load our retrofitted building in TEASER later on, we can save the project into a XML file:

prj.save_project("Retrofit_Building", path=None)

singlebuilding.py

This module shows how to create a building from scratch (or arbitrary sources) calculate parameters for a Modelica model and save this example building in a XML based format. The used classes are imported one after another. Of course you can import all the classes at the beginning:

from teaser.logic.buildingobjects.building import Building
from teaser.logic.buildingobjects.buildingphysics.groundfloor import\
    GroundFloor
from teaser.logic.buildingobjects.buildingphysics.innerwall import InnerWall
from teaser.logic.buildingobjects.buildingphysics.layer import Layer
from teaser.logic.buildingobjects.buildingphysics.material import Material
from teaser.logic.buildingobjects.buildingphysics.outerwall import OuterWall
from teaser.logic.buildingobjects.buildingphysics.rooftop import Rooftop
from teaser.logic.buildingobjects.buildingphysics.window import Window
from teaser.logic.buildingobjects.thermalzone import ThermalZone
from teaser.logic.buildingobjects.boundaryconditions.boundaryconditions \
    import BoundaryConditions
from teaser.project import Project

prj = Project(load_data=True)
bldg = Building(parent=prj)

Set some building parameters:

bldg.name = "SuperBuilding"
bldg.street_name = "Awesome Avenue 42"
bldg.city = "46325 Fantastic Town"
bldg.year_of_construction = 1988

Instantiate a ThermalZone class, with building as parent and set some parameters of the thermal zone:

tz = ThermalZone(parent=bldg)
tz.name = "Living Room"
tz.area = 45.0
tz.volume = 123.0
tz.infiltration_rate = 0.5

Instantiate UseConditionsOffice18599 class with thermal zone as parent, and load the use conditions for the usage ‘Living’:

tz.use_conditions = BoundaryConditions(parent=tz)
tz.use_conditions.load_use_conditions("Living")

Define two elements representing a pitched roof and define Layers and Materials explicitly:

roof_south = Rooftop(parent=tz)
roof_south.name = "Roof_South"

roof_north = Rooftop(parent=tz)
roof_north.name = "Roof_North"

Set area, orientation and tilt of South Roof:

roof_south.area = 75.0
roof_south.orientation = 180.0
roof_south.tilt = 55.0

Set coefficient of heat transfer:

roof_south.inner_convection = 1.7
roof_south.outer_convection = 5.0
roof_south.inner_radiation = 20.0
roof_south.outer_radiation = 5.0

Set layer and material. The id indicates the position of the layer from inside to outside:

layer_1s = Layer(parent=roof_south, id=0)
layer_1s.thickness = 0.15

material_1_2 = Material(layer_1s)
material_1_2.name = "Insulation"
material_1_2.density = 120.0
material_1_2.heat_capac = 0.04
material_1_2.thermal_conduc = 1.0

layer_2s = Layer(parent=roof_south, id=1)
layer_2s.thickness = 0.15

material_1_1 = Material(layer_2s)
material_1_1.name = "Tile"
material_1_1.density = 1400.0
material_1_1.heat_capac = 0.6
material_1_1.thermal_conduc = 2.5

Set area, orientation and tilt of North Roof:

roof_north.area = 75.0
roof_north.orientation = 0.0
roof_north.tilt = 55.0

Set coefficient of heat transfer:

roof_north.inner_convection = 1.7
roof_north.outer_convection = 5.0
roof_north.inner_radiation = 20.0
roof_north.outer_radiation = 5.0

Set layer and material:

layer_1n = Layer(parent=roof_north, id=0)
layer_1n.thickness = 0.15

material_1_2 = Material(layer_1n)
material_1_2.name = "Insulation"
material_1_2.density = 120.0
material_1_2.heat_capac = 0.04
material_1_2.thermal_conduc = 1.0

layer_2n = Layer(parent=roof_north, id=1)
layer_2n.thickness = 0.15
layer_2n.position = 1

material_1_1 = Material(layer_2n)
material_1_1.name = "Tile"
material_1_1.density = 1400.0
material_1_1.heat_capac = 0.6
material_1_1.thermal_conduc = 2.5

For the remaining Outer and Inner walls as well as Windows, we save the information in python dicitonaries, iterate them and instantiate the corresponding classes. In addition we are using the load_type_element function to determine the building physics from statistical data The key of the dict is the walls’s name, while the value is a list with parameters the [year of construciton, construction type, area, tilt,orientation]:

out_wall_dict = {"Outer Wall 1": [bldg.year_of_construction, 'heavy',
                                  10.0, 90.0, 0.0],
                 "Outer Wall 2": [bldg.year_of_construction, 'heavy',
                                  14.0, 90.0, 90.0],
                 "Outer Wall 3": [bldg.year_of_construction, 'heavy',
                                  10.0, 90.0, 180.0],
                 "Outer Wall 4": [bldg.year_of_construction, 'heavy',
                                  14.0, 90.0, 270.0]}

in_wall_dict = {"Inner Wall 1": [bldg.year_of_construction, 'light', 10.0],
                "Inner Wall 2": [bldg.year_of_construction, 'heavy', 14.0],
                "Inner Wall 3": [bldg.year_of_construction, 'light', 10.0]}

win_dict = {"Window 1": [bldg.year_of_construction,
                         5.0, 90.0, 90.0],
            "Window 2": [bldg.year_of_construction,
                         8.0, 90.0, 180.0],
            "Window 3": [bldg.year_of_construction,
                         5.0, 90.0, 270.0]}

for key, value in out_wall_dict.items():
    '''instantiate OuterWall class'''
    out_wall = OuterWall(parent = tz)
    out_wall.name = key
    '''load typical construction, based on year of construction and
    construction type'''
    out_wall.load_type_element(year=value[0],
                               construction=value[1])
    out_wall.area = value[2]
    out_wall.tilt = value[3]
    out_wall.orientation = value[4]

for key, value in in_wall_dict.items():
    '''instantiate InnerWall class'''
    in_wall = InnerWall(parent = tz)
    in_wall.name = key
    '''load typical construction, based on year of construction and
    construction type'''
    in_wall.load_type_element(year=value[0],
                              construction=value[1])
    in_wall.area = value[2]

for key, value in win_dict.items():
    '''instantiate Window class'''
    win = Window(parent = tz)
    win.name = key
    win.area = value[1]
    win.tilt = value[2]
    win.orientation = value[3]

    '''
    We know the exact properties of the window, thus we set them instead
    of loading a typical construction
    '''
    win.inner_convection = 1.7
    win.inner_radiation = 5.0
    win.outer_convection = 20.0
    win.outer_radiation = 5.0
    win.g_value = 0.789
    win.a_conv = 0.03
    win.shading_g_total = 1.0
    win.shading_max_irr = 180.0
    '''Instantiate a Layer class, with window as parent, set attributes'''
    win_layer = Layer(parent = win)
    win_layer.id = 1
    win_layer.thickness = 0.024
    '''Instantiate a Material class, with window layer as parent,
    set attributes'''
    win_material = Material(win_layer)
    win_material.name = "GlasWindow"
    win_material.thermal_conduc = 0.067
    win_material.transmittance = 0.9

For a GroundFloor we are using the load_type_element function explicitly, which needs the year of construction and the construction type (‘heavy’ or ‘light’):

ground = GroundFloor(parent=tz)
ground.name = "Ground floor"
ground.load_type_element(year=1988, construction='heavy')
ground.area = 140.0

We need to set the projects calculation method. The library we want to use is AixLib, we are using a two element model and want an extra resistance for the windows. To export the parameters to a Modelica record, we use the export_aixlib function. path = None indicates, that we want to store the records in TEASER’S Output folder:

prj.used_library_calc = 'AixLib'
prj.number_of_elements_calc = 2
prj.merge_windows_calc = False

prj.calc_all_buildings()

Export the Modelica Record. If you have a Dymola License you can export the model with a central AHU (MultizoneEquipped) (only default for office and institute buildings):

prj.export_aixlib(building_model="MultizoneEquipped",
    zone_model="ThermalZoneEquipped",
    corG=True,
    internal_id=None,
    path=None)

For OpenModelica you need to exclude the centralAHU (because it is using state machines). Therefore use the building_model “Multizone”:

prj.export_aixlib(building_model="Multizone",
    zone_model="ThermalZoneEquipped",
    corG=True,
    internal_id=None,
    path=None)

Or we use Annex60 method (e.g with four elements). Which exports one Model per zone:

prj.used_library_calc = 'Annex60'
prj.number_of_elements_calc = 4
prj.merge_windows_calc = False

prj.calc_all_buildings()
prj.export_annex()

Save teaserXML and CityGML:

prj.save_project(file_name="ExampleProject")
prj.save_citygml(
    file_name="ExampleProject",
    path=None)