def parameter_room10():
""""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)
"""We load the given test room defined in teaserXML-file"""
prj.load_project(utilitis.get_full_path(
"examples\\examplefiles\\VDI6007_Room10.teaserXML"))
"""Then we calculate all parameter with the calculation
core 'vdi', that is exactly as defined in VDI 6007-1."""
prj.calc_all_buildings(number_of_elements=2,
merge_windows=True,
used_library='AixLib')
"""After this, we can export our projects as .txt."""
prj.export_parameters_txt()
def to_modelica(self, scaffold, keep_original_models=False):
"""
Save the TEASER representation of the buildings to the filesystem. The path will
be scaffold.loads_path.files_dir.
:param scaffold: Scaffold object, contains all the paths of the project
:param keep_original_models: boolean, whether or not to remove the models after exporting from Teaser
"""
# Teaser changes the current dir, so make sure to reset it back to where we started
building_names = []
curdir = os.getcwd()
try:
prj = Project(load_data=True)
for building in self.buildings:
building_name = building["building_id"]
prj.add_non_residential(
method="bmvbs",
usage=self.lookup_building_type(building["building_type"]),
name=building_name,
year_of_construction=building["year_built"],
number_of_floors=building["num_stories"],
height_of_floors=building["floor_height"],
net_leased_area=building["area"],
office_layout=1,
window_layout=1,
with_ahu=False,
construction_type="heavy",
)
building_names.append(building_name)
prj.used_library_calc = "IBPSA"
prj.number_of_elements_calc = self.system_parameters.get_param(
"buildings.default.load_model_parameters.rc.order", default=2
)
prj.merge_windows_calc = False
# calculate the properties of all the buildings and export to the Buildings library
prj.calc_all_buildings()
prj.export_ibpsa(library="Buildings", path=os.path.join(curdir, scaffold.loads_path.files_dir))
finally:
os.chdir(curdir)
self.post_process(scaffold, building_names, keep_original_models=keep_original_models)
def parameter_room10():
""""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)
"""We load the given test room defined in teaserXML-file"""
prj.load_project(
utilitis.get_full_path(
"examples\\examplefiles\\VDI6007_Room10.teaserXML"))
"""Then we calculate all parameter with the calculation
core 'vdi', that is exactly as defined in VDI 6007-1."""
prj.calc_all_buildings(number_of_elements=2,
merge_windows=True,
used_library='AixLib')
"""After this, we can export our projects as .txt."""
prj.export_parameters_txt()
def main():
prj = Project(load_data=True)
prj.name = "ResidentialCommunityUK_rad"
# Building types: detached, terrace, office_lowenergy-early1980s, office_highcost-mid1980s.
# Community created based on
prj = load_namespace('teaser_prj_residentialUK')
prj.name = "ResidentialCommunityUK_rad_2elements"
prj.used_library_calc = 'IBPSA'
prj.number_of_elements_calc = 3
prj.weather_file_path = os.path.join('path_to_weather_file', 'Nottingham_TRY.mos')
prj.calc_all_buildings(raise_errors=True)
store_namespace('teaser_prj_residential',prj)
bldg_list=[]
for bldg in prj.buildings:
bldg_list.append(bldg.name)
store_namespace('teaser_bldgs_residential',bldg_list)
prj.export_parameters_txt(path="\\models")
prj.export_ibpsa(
internal_id=None,
path="\models\\"
)
for bldg in prj.buildings:
for zone in bldg.thermal_zones:
path = os.path.join("\models\\", prj.name)
create_ibpsa_mpc_model(prj,bldg,zone,path=path)
create_ibpsa_PI_model(prj,bldg,zone,path=path)
def example_type_building():
""""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)
prj.name = "ArchetypeBuildings_Ref"
"""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()
'''
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()
"""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 = "ArchetypeBuildings_Retrofit"
prj.retrofit_all_buildings(2015)
prj.calc_all_buildings()
'''You 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)
prj.save_project("Retrofit_Building",
path=None)
'''Save the human readable output txt'''
prj.export_parameters_txt(path=None)
'''
Save the human readable output txt
'''
prj.save_citygml(path=None)
os.path.dirname(os.path.dirname(__file__)),
"data",
"input",
"inputdata",
"weatherdata",
"DEU_BW_Mannheim_107290_TRY2010_12_Jahr_BBSR.mos",
)
prj.modelica_info.weekday = 0 # 0-Monday, 6-Sunday
prj.modelica_info.simulation_start = 0 # start time for simulation
PathToExcel = os.path.join(os.path.dirname(__file__), "examplefiles",
"ExcelBuildingData_Sample.xlsx")
prj, Data = import_building_from_excel(prj,
"ExampleImport",
2000,
PathToExcel,
sheet_names=["ImportSheet1"])
prj.modelica_info.current_solver = "dassl"
prj.calc_all_buildings(raise_errors=True)
prj.export_aixlib(internal_id=None, path=result_path)
# if wished, export the zoned DataFrame which is finally used to
# parametrize the teaser classes
Data.to_excel(os.path.join(result_path, prj.name, "ZonedInput.xlsx"))
# if wished, save the current python script to the results folder to
# track the used parameters and reproduce results
shutil.copy(__file__, os.path.join(result_path, prj.name))
print("%s: That's it :)" % prj.name)
def example_create_building():
'''
Instantiate a Project class (with load_data set to true), instantiate a
Building class, with the project as a parent. This automatically adds the
specific building and all its future changes to the project.
'''
prj = Project(load_data=True)
bldg = Building(parent=prj)
'''Set some building parameters'''
bldg.name = "SuperExampleBuilding"
bldg.street_name = "Awesome Avenue 42"
bldg.city = "46325 Fantastic Town"
bldg.year_of_construction = 1988
bldg.number_of_floors = 1
bldg.height_of_floors = 3.5
'''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 = 140.0
tz.volume = tz.area * bldg.number_of_floors * bldg.height_of_floors
tz.infiltration_rate = 0.5
'''Instantiate UseConditions18599 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'''
layer_1s = Layer(parent=roof_south, id=0) # id indicates the order of
# layer from inside to outside
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
'''We save information of the Outer and Inner walls as well as Windows
in dicts, the key is the name, while the value is a list (if applicable)
[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,
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(bldg.year_of_construction, 'heavy')
ground.area = 140.0
'''
We calculate the RC Values according to AixLib procedure
'''
prj.used_library_calc = 'AixLib'
prj.number_of_elements_calc = 2
prj.merge_windows_calc = False
prj.calc_all_buildings()
'''
Export the Modelica Record
'''
prj.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
'''Or we use Annex60 method with for elements'''
#prj.calc_all_buildings(number_of_elements=4,
# merge_windows=False,
# used_library='Annex60')
#prj.export_annex()
'''
Save new TEASER XML and cityGML
'''
prj.save_project("ExampleProject")
prj.save_citygml("ExampleCityGML")
def example_create_building():
'''
Instantiate a Project class (with load_data set to true), instantiate a
Building class, with the project as a parent. This automatically adds the
specific building and all its future changes to the project.
'''
prj = Project(load_data = True)
bldg = Building(parent = prj)
'''Set some building parameters'''
bldg.name = "SuperExampleBuilding"
bldg.street_name = "Awesome Avenue 42"
bldg.city = "46325 Fantastic Town"
bldg.year_of_construction = 1988
bldg.number_of_floors = 1
bldg.height_of_floors = 3.5
'''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 = 140.0
tz.volume = tz.area * bldg.number_of_floors * bldg.height_of_floors
tz.infiltration_rate = 0.5
'''Instantiate UseConditions18599 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")
'''We save information of the Outer and Inner walls as well as Windows
in dicts, the key is the name, while the value is a list (if applicable)
[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
'''Define a Rooftop and a Groundfloor, we don't need to set tilt and
orientation because we take the default values'''
roof = Rooftop(parent = tz)
roof.name = "Roof"
roof.load_type_element(bldg.year_of_construction, 'heavy')
roof.area = 140.0
ground = GroundFloor(parent = tz)
ground.name = "Ground floor"
ground.load_type_element(bldg.year_of_construction, 'heavy')
ground.area = 140.0
'''
We calculate the RC Values according to AixLib procedure
'''
prj.used_library_calc = 'AixLib'
prj.number_of_elements_calc = 2
prj.merge_windows_calc = False
prj.calc_all_buildings()
'''
Export the Modelica Record
'''
prj.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
'''Or we use Annex60 method with for elements'''
#prj.calc_all_buildings(number_of_elements=4,
# merge_windows=False,
# used_library='Annex60')
#prj.export_annex()
'''
Save new TEASER XML
'''
prj.save_gml("ExampleProject")
prj.save_citygml("Easypeasy")
def example_type_building():
""""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)
prj.name = "ArchetypeBuildings"
"""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.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
"""or we could also use the Annex60 models"""
#prj.used_library_calc = "Annex60"
#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)
prj.calc_all_buildings(number_of_elements=2,
merge_windows=False,
used_library='AixLib')
prj.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
prj.save_project("Retrofit_Building",
path=None)
'''Save the human readable output txt'''
prj.export_parameters_txt(path=None)
'''
Save the human readable output txt
'''
prj.save_citygml(path=None)
def example_type_building():
""""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)
prj.name = "ArchetypeBuildings"
"""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.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
"""or we could also use the Annex60 models"""
#prj.used_library_calc = "Annex60"
#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)
prj.calc_all_buildings(number_of_elements=2,
merge_windows=False,
used_library='AixLib')
prj.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
prj.save_project("Retrofit_Building", path=None)
'''Save the human readable output txt'''
prj.export_parameters_txt(path=None)
'''
Save the human readable output txt
'''
prj.save_citygml(path=None)
