def main():
starttime = time.time()
#create a office typebuilding
prj = Project(load_data=True)
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")
#path where the export is stored
output_path = os.path.join('D:\Temp', 'OutputData')
print(os.path.join(output_path, 'OneBuildingSim'))
prj.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=False,
path=os.path.join(output_path, 'OneBuildingSim'))
"""
Now we need to simulate this, therefore we get the names of the current
buildings in this project
"""
buildingNames = []
for bld in prj.buildings:
buildingNames.append(bld.name)
"""
Now we define the output directory where the simulation results should be
stored, in addition we need to define the path where the exported models
are"""
outputDir = "D:/TestCampusSimulation"
packageDir = output_path + "/OneBuildingSim" + "/Project"
"""
Now we need to create a simulation list for buildingspy
"""
li = []
for bld in prj.buildings:
#this is necessary for the correct names in the simulation script
name = "Project." + bld.name + "." + bld.name
s = si.Simulator(name, "dymola", outputDir, packageDir)
li.append(s)
po = Pool(processes=3)
# i think we can use async here because we do not need a particular order
# of the results
po.map(simulateCase, li)
### Timer
endtime = time.time()
print('Simulation lasts: ', endtime - starttime, ' seconds or ',
(endtime - starttime) / 60, ' minutes! or',
(endtime - starttime) / (60 * 60))
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)
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")
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")
'''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 main():
starttime = time.time()
#create a office typebuilding
prj = Project(load_data=True)
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")
#path where the export is stored
output_path = os.path.join('D:\Temp',
'OutputData')
print(os.path.join(output_path, 'OneBuildingSim'))
prj.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=False,
path=os.path.join(output_path, 'OneBuildingSim'))
"""
Now we need to simulate this, therefore we get the names of the current
buildings in this project
"""
buildingNames = []
for bld in prj.buildings:
buildingNames.append(bld.name)
"""
Now we define the output directory where the simulation results should be
stored, in addition we need to define the path where the exported models
are"""
outputDir = "D:/TestCampusSimulation"
packageDir = output_path + "/OneBuildingSim" + "/Project"
"""
Now we need to create a simulation list for buildingspy
"""
li = []
for bld in prj.buildings:
#this is necessary for the correct names in the simulation script
name = "Project." + bld.name + "." + bld.name
s = si.Simulator(name, "dymola", outputDir, packageDir)
li.append(s)
po = Pool(processes=3)
# i think we can use async here because we do not need a particular order
# of the results
po.map(simulateCase, li)
### Timer
endtime = time.time()
print('Simulation lasts: ', endtime-starttime, ' seconds or ',
(endtime-starttime)/60, ' minutes! or', (endtime-starttime)/(60*60))
def example_type_district():
""""First thing we need to do is to import our Project API module"""
from teaser.project import Project
from random import randint
import buildingspy.simulate.Simulator as Si
import time
from multiprocessing import Pool
"""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."""
starttime = time.time()
prj_est1 = Project(load_data=True)
prj_est1.name = "EST1"
prj_est4 = Project(load_data=True)
prj_est4.name = "EST4"
prj_est7 = Project(load_data=True)
prj_est7.name = "EST7"
"""The 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."""
number_of_buildings_est1 = 14
for building in range(1,round((number_of_buildings_est1)*0.67)+1):
name_help = "Building" + str(building)
year_of_construction_help = randint(1960,1980)
prj_est1.type_bldg_est1a(name=name_help,
year_of_construction=year_of_construction_help,
number_of_floors=2,
height_of_floors=3.15,
net_leased_area=92,
with_ahu=False,
neighbour_buildings=0,
construction_type="heavy")
for building in range(round((number_of_buildings_est1)*0.67)+1,
number_of_buildings_est1+1):
name_help = "Building" + str(building)
year_of_construction_help = randint(1960,1980)
prj_est1.type_bldg_est1b(name=name_help,
year_of_construction=year_of_construction_help,
number_of_floors=2,
height_of_floors=3.15,
net_leased_area=92*2,
with_ahu=False,
neighbour_buildings=0,
construction_type="heavy",
number_of_apartments=2)
number_of_buildings_est4 = 4
for building in range(1,number_of_buildings_est4+1):
name_help = "Building" + str(building)
year_of_construction_help = randint(1960,1980)
prj_est4.type_bldg_est4b(name=name_help,
year_of_construction=year_of_construction_help,
number_of_floors=9,
height_of_floors=2.6,
net_leased_area=417*9,
with_ahu=False,
neighbour_buildings=2,
construction_type="heavy",
number_of_apartments=38)
number_of_buildings_est7 = 29
for building in range(1,round((number_of_buildings_est7)*0.45)+1):
name_help = "Building" + str(building)
year_of_construction_help = randint(1900,1918)
prj_est7.type_bldg_est7(name=name_help,
year_of_construction=year_of_construction_help,
number_of_floors=3,
height_of_floors=3.88,
net_leased_area=65*3,
with_ahu=False,
neighbour_buildings=2,
construction_type="heavy",
number_of_apartments=1)
for building in range(round((number_of_buildings_est7)*0.45)+1,
number_of_buildings_est7+1):
name_help = "Building" + str(building)
year_of_construction_help = randint(1900,1918)
prj_est7.type_bldg_est7(name=name_help,
year_of_construction=year_of_construction_help,
number_of_floors=3,
height_of_floors=3.88,
net_leased_area=65*3,
with_ahu=False,
neighbour_buildings=2,
construction_type="heavy",
number_of_apartments=2)
"""To export the parameters to a Modelica record, we use the export_record
function. path = None indicates, that we want to store the records in \
TEASER'S Output folder"""
prj_est1.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
prj_est4.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
prj_est7.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
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_est1.name = "EST1_Retrofit"
prj_est1.retrofit_all_buildings(2015)
prj_est1.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
prj_est4.name = "EST4_Retrofit"
prj_est4.retrofit_all_buildings(2015)
prj_est4.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
prj_est7.name = "EST7_Retrofit"
prj_est7.retrofit_all_buildings(2015)
prj_est7.export_aixlib(building_model="MultizoneEquipped",
zone_model="ThermalZoneEquipped",
corG=True,
internal_id=None,
path=None)
endtime = time.time()
print('Pre-processing lasts: ', endtime - starttime, ' seconds or ',
(endtime - starttime) / 60, ' minutes! or',
(endtime - starttime) / (60 * 60), 'hours.')
starttime = time.time()
"""
Now we define the output directory where the simulation results should be
stored, in addition we need to define the path where the exported models
are"""
outputdir_est1 = "D:/Dymola_workspace/EST1"
packagedir_est1 = "C:/Users\mla\TEASEROutput/EST1"
outputdir_est1_retrofit = "D:/Dymola_workspace/EST1_Retrofit"
packagedir_est1_retrofit = "C:/Users\mla\TEASEROutput/EST1_Retrofit"
outputdir_est4 = "D:/Dymola_workspace/EST4"
packagedir_est4 = "C:/Users\mla\TEASEROutput/EST4"
outputdir_est4_retrofit = "D:/Dymola_workspace/EST4_Retrofit"
packagedir_est4_retrofit = "C:/Users\mla\TEASEROutput/EST4_Retrofit"
outputdir_est7 = "D:/Dymola_workspace/EST7"
packagedir_est7 = "C:/Users\mla\TEASEROutput/EST7"
outputdir_est7_retrofit = "D:/Dymola_workspace/EST7_Retrofit"
packagedir_est7_retrofit = "C:/Users\mla\TEASEROutput/EST7_Retrofit"
"""
Now we need to create a simulation list for buildingspy
"""
li_est1 = []
for bld in prj_est1.buildings:
# this is necessary for the correct names in the simulation script
name = "EST1." + bld.name + "." + bld.name
s = Si.Simulator(name, "dymola", outputdir_est1, packagedir_est1)
li_est1.append(s)
li_est1_retrofit = []
for bld in prj_est1.buildings:
# this is necessary for the correct names in the simulation script
name = "EST1_Retrofit." + bld.name + "." + bld.name
s = Si.Simulator(name, "dymola", outputdir_est1_retrofit,
packagedir_est1_retrofit)
li_est1_retrofit.append(s)
li_est4 = []
for bld in prj_est4.buildings:
# this is necessary for the correct names in the simulation script
name = "EST4." + bld.name + "." + bld.name
s = Si.Simulator(name, "dymola", outputdir_est4, packagedir_est4)
li_est4.append(s)
li_est4_retrofit = []
for bld in prj_est4.buildings:
# this is necessary for the correct names in the simulation script
name = "EST4_Retrofit." + bld.name + "." + bld.name
s = Si.Simulator(name, "dymola", outputdir_est4_retrofit,
packagedir_est4_retrofit)
li_est4_retrofit.append(s)
li_est7 = []
for bld in prj_est7.buildings:
# this is necessary for the correct names in the simulation script
name = "EST7." + bld.name + "." + bld.name
s = Si.Simulator(name, "dymola", outputdir_est7, packagedir_est7)
li_est7.append(s)
li_est7_retrofit = []
for bld in prj_est7.buildings:
# this is necessary for the correct names in the simulation script
name = "EST7_Retrofit." + bld.name + "." + bld.name
s = Si.Simulator(name, "dymola", outputdir_est7_retrofit,
packagedir_est7_retrofit)
li_est7_retrofit.append(s)
po = Pool(processes=3)
po.map(simulate_case, li_est1)
po.map(simulate_case, li_est1_retrofit)
po.map(simulate_case, li_est4)
po.map(simulate_case, li_est4_retrofit)
po.map(simulate_case, li_est7)
po.map(simulate_case, li_est7_retrofit)
# Timer
endtime = time.time()
print('Simulation lasts: ', endtime - starttime, ' seconds or ', (endtime - starttime) / 60, ' minutes! or',
(endtime - starttime) / (60 * 60), 'hours.')
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)