def save_project(self, file_name=None, path=None): """Saves the project to a tXML file calls the function save_teaser_xml in data.TeaserXML.py Parameters ---------- file_name : string name of the new file path : string if the Files should not be stored in OutputData, an alternative can be specified """ if file_name is None: name = self.name else: name = file_name if path is None: new_path = os.path.join(utilities.get_default_path(), name) else: new_path = os.path.join(utilities.get_default_path(), name) utilities.create_path(utilities.get_full_path(path)) txml_out.save_teaser_xml(new_path, self)
def test_save_use_conditions(self): '''test of save_use_conditions, no parameter checking''' import os try: os.remove(utilities.get_default_path() + "\\" + "UseCondUT.xml") except: pass path = utilities.get_default_path() use_cond = prj.buildings[-1].thermal_zones[-1].use_conditions use_cond.parent = None use_cond.save_use_conditions(path=path, file_name="UseCondUT")
def test_save_use_conditions(self): '''test of save_use_conditions, no parameter checking''' import os try: os.remove(utilities.get_default_path() + "/" + "UseCondUT.xml") except: pass path = utilities.get_default_path() use_cond = prj.buildings[-1].thermal_zones[-1].use_conditions use_cond.parent = None use_cond.save_use_conditions(path=path, file_name="UseCondUT")
def test_save_use_conditions(self): """Test of save_use_conditions, no parameter checking.""" try: os.remove( os.path.join(utilities.get_default_path(), "UseCondUT.json")) except OSError: pass path = os.path.join(utilities.get_default_path(), "UseCondUT.json") prj.data.path_uc = path prj.data.load_uc_binding() use_cond = prj.buildings[-1].thermal_zones[-1].use_conditions use_cond.save_use_conditions(data_class=prj.data)
def main(): this_path = os.path.dirname(__file__) input_path = os.path.join(this_path, 'ExampleInputFiles', 'MelatenXML') output_path = utilitis.get_default_path() info_list = read_XMLs(input_path) prj = create_reference_project(info_list) prj.number_of_elements_calc = 2 prj.merge_windows_calc = False prj.used_library_calc = "AixLib" 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) prj.retrofit_all_buildings(2015) prj.export_aixlib(building_model="MultizoneEquipped", zone_model="ThermalZoneEquipped", corG=True, internal_id=None, path=None) """or we could also use the Annex60 models"""
def main(): this_path = os.path.dirname(__file__) input_path = os.path.join(this_path, 'examplefiles', 'MelatenXML') output_path = utilitis.get_default_path() info_list = read_XMLs(input_path) prj = create_reference_project(info_list) prj.number_of_elements_calc = 2 prj.merge_windows_calc = False prj.used_library_calc = "AixLib" 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) prj.retrofit_all_buildings(2015) prj.export_aixlib(building_model="MultizoneEquipped", zone_model="ThermalZoneEquipped", corG=True, internal_id=None, path=None) """or we could also use the Annex60 models"""
def export_annex(self, internal_id=None, path=None): """Exports values to a record file for Modelica simulation Parameters ---------- internal_id : float setter of the used building which will be exported, if None then all buildings will be exported path : string if the Files should not be stored in OutputData, an alternative path can be specified as a full and absolute path """ if path is None: path = utilitis.get_default_path() + "/" + self.name else: path = path + "/" + self.name utilitis.create_path(path) annex60_output.export_annex60(prj=self, number_of_elements=self.number_of_elements_calc, merge_windows=self.merge_windows_calc, internal_id=internal_id, path=path)
def save_citygml(self, file_name=None, path=None): """Saves the project to a CityGML file calls the function save_gml in data.CityGML we make use of CityGML core and EnergyADE to store semantic information Parameters ---------- file_name : string name of the new file path : string if the Files should not be stored in OutputData, an alternative can be specified """ if file_name is None: name = self.name else: name = file_name if path is None: new_path = os.path.join(utilities.get_default_path(), name) else: new_path = os.path.join(path, name) utilities.create_path(utilities.get_full_path(path)) citygml_out.save_gml(self, new_path)
def save_citygml(self, file_name=None, path=None): '''Saves the project to a citygml file calls the function save_gml in data.CityGML we make use of CityGML core and EnergyADE to store semantic information Parameters ---------- file_name : string name of the new file path : string if the Files should not be stored in OutputData, an alternative can be specified ''' if file_name is None: name = self.name else: name = file_name if path is None: new_path = os.path.join(utilitis.get_default_path(), name) else: new_path = path + "/" + name utilitis.create_path(utilitis.get_full_path(path)) citygml_out.save_gml(self, new_path)
def save_project(self, file_name=None, path=None): '''Saves the project to a tXML file calls the function save_teaser_xml in data.TeaserXML.py Parameters ---------- file_name : string name of the new file path : string if the Files should not be stored in OutputData, an alternative can be specified ''' if file_name is None: name = self.name else: name = file_name if path is None: new_path = os.path.join(utilitis.get_default_path(), name) else: new_path = path + "/" + name utilitis.create_path(utilitis.get_full_path(path)) txml_out.save_teaser_xml(new_path, self)
def example_save(): """"This function demonstrates different saving options of TEASER""" # In e1_generate_archetype we created a Project with three archetype # buildings to get this Project we rerun this example prj = e1.example_generate_archetype() # First option is to use TEASERs own XML format to save all relevant # data into a more or less human readable format. The corresponding # function is called Project().save_project() you can specify a file name # and a save path. If both are non (as in this case) it will use the # projects name and default path in your home folder. prj.save_project(file_name=None, path=None) # Second option is to use pickle from Python Standard Library , # which will save the whole Python classes and all attributes into a # binary file. There is no specific API function for this, but you can # simply create an empty file with open() and then use pickle.dump(). # Make sure you specify your path correctly. In this case we want to use # the default path of TEASERs output. import pickle pickle_file = os.path.join( utilities.get_default_path(), 'teaser_pickle.p') pickle.dump(prj, open(pickle_file, "wb"))
def export_aixlib( self, building_model=None, zone_model=None, corG=None, internal_id=None, path=None): """Exports values to a record file for Modelica simulation Exports one (if internal_id is not None) or all buildings for AixLib.ThermalZones.ReducedOrder.Multizone.MultizoneEquipped models using the ThermalZoneEquipped model with a correction of g-value ( double pane glazing) and supporting models, like tables and weather model. In contrast to versions < 0.5 TEASER now does not support any model options, as we observed no need, since single ThermalZones are identically with IBPSA models. If you miss one of the old options please contact us. Parameters ---------- internal_id : float setter of a specific building which will be exported, if None then all buildings will be exported path : string if the Files should not be stored in default output path of TEASER, an alternative path can be specified as a full path """ if building_model is not None or zone_model is not None or corG is \ not None: warnings.warn("building_model, zone_model and corG are no longer " "supported for AixLib export and have no effect. " "The keywords will be deleted within the next " "version, consider rewriting your code.") if path is None: path = os.path.join( utilities.get_default_path(), self.name) else: path = os.path.join( path, self.name) utilities.create_path(path) if internal_id is None: aixlib_output.export_multizone( buildings=self.buildings, prj=self, path=path) else: for bldg in self.buildings: if bldg.internal_id == internal_id: aixlib_output.export_multizone( buildings=[bldg], prj=self, path=path)
def save_project(self, file_name=None, path=None): """Saves the project to a JSON file Calls the function save_teaser_json in data.output.teaserjson_output Parameters ---------- file_name : string name of the new file path : string if the Files should not be stored in OutputData, an alternative can be specified """ if file_name is None: name = self.name else: name = file_name if path is None: new_path = os.path.join(utilities.get_default_path(), name) else: new_path = os.path.join(path, name) tjson_out.save_teaser_json(new_path, self)
def example_save(): """"This function demonstrates different loading options of TEASER""" # In example e4_save we saved two TEASER projects using *.teaserXML and # Python package pickle. This example shows how to import these # information into your python environment again. # To load data from *.teaserXML we can use a simple API function. So # first we need to instantiate our API (similar to example # e1_generate_archetype). The XML file is called # `ArchetypeExample.teaserXML` and saved in the default path. You need to # run e4 first before you can load this example file. from teaser.project import Project prj = Project() load_xml = os.path.join(utilities.get_default_path(), 'ArchetypeExample.teaserXML') prj.load_project(path=load_xml) prj = Project() prj.load_project( utilities.get_full_path("examples/examplefiles/new.teaserXML")) prj.save_project(file_name="new", path=None) # To reload data from a pickle file, we do not need to instantiate an # API, as pickle will automatically instantiate all classes as they have # been saved. The saved file from example e4 is called ´teaser_pickle.p´ import pickle load_pickle = os.path.join(utilities.get_default_path(), 'teaser_pickle.p') pickle_prj = pickle.load(open(load_pickle, "rb")) # The last option to import data into TEASER is using a CityGML file. The # import of CityGML underlies some limitations e.g. concerning data # given in the file and the way the buildings are modeled. prj_gml = Project() load_gml = utilities.get_full_path( os.path.join('examples', 'examplefiles', 'CityGMLSample.gml')) prj_gml.load_citygml(path=load_gml)
def modelica_AHU_boundary(self, path=None): """Create .txt file for AHU boundary conditions (building). This function creates a txt for building AHU boundary conditions 1. Column : time step 2. Column : desired AHU profile temperature 3. Column : Desired minimal relative humidity 4. Column : desired maximal relative humidity 5. Column : AHU status (On/Off) Parameters ---------- path : str optional path, when matfile is exported separately Attributes ---------- temperature_profile : [float] timeline of temperatures requirements for AHU simulation min_relative_humidity_profile : [float] timeline of relative humidity requirements for AHU simulation max_relative_humidity_profile : [float] timeline of relative humidity requirements for AHU simulation v_flow_profile : [int] timeline of desired relative v_flow of the AHU simulation (0..1) """ if path is None: path = utilities.get_default_path() else: pass utilities.create_path(path) path = os.path.join(path, self.file_ahu) if self.parent.with_ahu is True: export = self.parent.central_ahu.schedules else: # Dummy values for Input Table export = pd.DataFrame(index=pd.date_range( "2019-01-01 00:00:00", periods=8760, freq="H").to_series().dt.strftime("%m-%d %H:%M:%S")) export["temperature_profile"] = list( islice(cycle([293.15, 293.15]), 8760)) export["min_relative_humidity_profile"] = list( islice(cycle([0, 0]), 8760)) export["max_relative_humidity_profile"] = list( islice(cycle([1, 1]), 8760)) export["v_flow_profile"] = list(islice(cycle([0, 1]), 8760)) export.index = [(i + 1) * 3600 for i in range(8760)] self._delete_file(path=path) with open(path, "a") as f: f.write("#1\n") f.write("double AHU({}, {})\n".format(8760, 5)) export.to_csv(f, sep="\t", header=False, index_label=False)
def test_save_use_conditions(self): '''test of save_use_conditions, no parameter checking''' import os path = os.path.join(utilities.get_default_path(), 'UseCondUT.xml') prj.data.path_uc = path prj.data.load_uc_binding() use_cond = prj.buildings[-1].thermal_zones[-1].use_conditions use_cond.save_use_conditions(data_class=prj.data)
def modelica_gains_boundary(self, path=None): """Create .txt file for internal gains boundary conditions. This function creates a matfile (-v4) for building internal gains boundary conditions. It collects all internal gain profiles of the zones and stores them into one file. The file is extended for each zone. Only applicable if zones are defined 1. Column : time step 2,5,8,... Column : profile_persons 3,6,9,... Column : profile_machines 4,7,10,... Column : profile_lighting Note ---------- When time line is created, we need to add a 0 to first element of all boundaries. This is due to to expected format in Modelica. Parameters ---------- path : str optional path, when matfile is exported separately """ if path is None: path = utilities.get_default_path() else: pass utilities.create_path(path) path = os.path.join(path, self.file_internal_gains) export = pd.DataFrame( index=pd.date_range("2019-01-01 00:00:00", periods=8760, freq="H" ).to_series().dt.strftime("%m-%d %H:%M:%S")) for zone_count in self.parent.thermal_zones: export["person_{}".format( zone_count.name )] = zone_count.use_conditions.schedules["persons_profile"] export["machines_{}".format( zone_count.name )] = zone_count.use_conditions.schedules["machines_profile"] export["lighting_{}".format( zone_count.name )] = zone_count.use_conditions.schedules["lighting_profile"] export.index = [(i + 1) * 3600 for i in range(8760)] self._delete_file(path=path) with open(path, "a") as f: f.write("#1\n") f.write("double Internals({}, {})\n".format( 8760, (len(self.parent.thermal_zones) * 3 + 1))) export.to_csv(f, sep="\t", header=False, index_label=False)
def test_save_type_element(self): '''test of save_type_element, no parameter checking''' import os try: os.remove(utilities.get_default_path() + "/" + "unitTestTB.xml") except: pass # test load function therm_zone = prj.buildings[-1].thermal_zones[-1] path = utilities.get_default_path() therm_zone.outer_walls[0].parent = None therm_zone.outer_walls[0].save_type_element(path=path, file_name="unitTestTB") therm_zone.inner_walls[0].parent = None therm_zone.inner_walls[0].save_type_element(path=path, file_name="unitTestTB") therm_zone.windows[0].parent = None therm_zone.windows[0].save_type_element(path=path, file_name="unitTestTB")
def test_save_type_element(self): '''test of save_type_element, no parameter checking''' import os try: os.remove(utilities.get_default_path() + "\\" + "unitTestTB.xml") except: pass # test load function therm_zone = prj.buildings[-1].thermal_zones[-1] path = utilities.get_default_path() therm_zone.outer_walls[0].parent = None therm_zone.outer_walls[0].save_type_element(path=path, file_name="unitTestTB") therm_zone.inner_walls[0].parent = None therm_zone.inner_walls[0].save_type_element(path=path, file_name="unitTestTB") therm_zone.windows[0].parent = None therm_zone.windows[0].save_type_element(path=path, file_name="unitTestTB")
def test_save_type_element(self): '''test of save_type_element, no parameter checking''' import os # test load function therm_zone = prj.buildings[-1].thermal_zones[-1] path = os.path.join(utilities.get_default_path(), 'unitTestTB.xml') prj.data.path_tb = path prj.data.load_tb_binding() therm_zone.outer_walls[0].save_type_element(data_class=prj.data) therm_zone.inner_walls[0].save_type_element(data_class=prj.data) therm_zone.windows[0].save_type_element(data_class=prj.data)
def export_ibpsa(self, library="AixLib", internal_id=None, path=None): """Exports values to a record file for Modelica simulation For Annex 60 Library Parameters ---------- library : str Used library within the framework of IBPSA library. The models are identical in each library, but IBPSA Modelica library is just a core set of models and should not be used standalone. Valid values are 'AixLib' (default), 'Buildings', 'BuildingSystems' and 'IDEAS'. internal_id : float setter of a specific building which will be exported, if None then all buildings will be exported path : string if the Files should not be stored in default output path of TEASER, an alternative path can be specified as a full path """ ass_error_1 = ("library for IBPSA export has to be 'AixLib', " "'Buildings', 'BuildingSystems' or 'IDEAS'") assert library in [ "AixLib", "Buildings", "BuildingSystems", "IDEAS", ], ass_error_1 if path is None: path = os.path.join(utilities.get_default_path(), self.name) else: path = os.path.join(path, self.name) utilities.create_path(path) if internal_id is None: ibpsa_output.export_ibpsa(buildings=self.buildings, prj=self, path=path, library=library) else: for bldg in self.buildings: if bldg.internal_id == internal_id: ibpsa_output.export_ibpsa(buildings=[bldg], prj=self, path=path) return path
def example_load(): """"This function demonstrates different loading options of TEASER""" # In example e4_save we saved two TEASER projects using *.teaserjson and # Python package pickle. This example shows how to import these # information into your python environment again. # To load data from *.teaserjson we can use a simple API function. So # first we need to instantiate our API (similar to example # e1_generate_archetype). The json file is called # `ArchetypeExample.teaserjson` and saved in the default path. You need to # run e4 first before you can load this example file. from teaser.project import Project prj = Project() load_json = os.path.join(utilities.get_default_path(), "ArchetypeExample.json") prj.load_project(path=load_json) prj = Project() prj.load_project( utilities.get_full_path("examples/examplefiles/unitTest.json")) prj.save_project(file_name="unitTest", path=None) # To reload data from a pickle file, we do not need to instantiate an # API, as pickle will automatically instantiate all classes as they have # been saved. The saved file from example e4 is called ´teaser_pickle.p´ import pickle load_pickle = os.path.join(utilities.get_default_path(), "teaser_pickle.p") pickle_prj = pickle.load(open(load_pickle, "rb")) print(pickle_prj)
def export_parameters_txt(self, path=None): '''Exports parameters of all buildings in a readable text file Parameters ---------- path : string if the Files should not be stored in OutputData, an alternative can be specified ''' if path is None: path = os.path.join(utilitis.get_default_path(), self.name) else: path = path+"/"+self.name text_out.export_parameters_txt(prj=self, path=path)
def export_ibpsa( self, internal_id=None, path=None): """Exports values to a record file for Modelica simulation For Annex 60 Library Parameters ---------- internal_id : float setter of a specific building which will be exported, if None then all buildings will be exported path : string if the Files should not be stored in default output path of TEASER, an alternative path can be specified as a full path """ if path is None: path = os.path.join( utilities.get_default_path(), self.name) else: path = os.path.join( path, self.name) utilities.create_path(path) if internal_id is None: ibpsa_output.export_ibpsa( buildings=self.buildings, prj=self, path=path) else: for bldg in self.buildings: if bldg.internal_id == internal_id: ibpsa_output.export_ibpsa( buildings=[bldg], prj=self, path=path)
def modelica_set_temp(bldg, path = None): '''creates .mat file for set temperatures for each zone This function creates a matfile (-v4) for set temperatures of each zone !AixLib sepcific! 1. Row: heat set temperature of all zones 2. Row: cool set temperature of all zones Parameters ---------- path : str optional path, when matfile is exported seperately ''' if bldg.file_set_t is None: bldg.file_set_t = "\\Tset_"+bldg.name+".mat" else: pass if path is None: path = utilitis.get_default_path() else: pass utilitis.create_path(path) path = path + bldg.file_set_t t_set_heat = [0] for zone_count in bldg.thermal_zones: t_set_heat.append(zone_count.use_conditions.set_temp_heat) scipy.io.savemat(path, mdict={'Tset': [t_set_heat]}, appendmat = False, format = '4')
def export_aixlib(self, building_model="None", zone_model="None", corG=None, internal_id=None, path=None): """Exports values to a record file for Modelica simulation Parameters ---------- building_model : string setter of the used Aixlib building model (None, MultizoneEquipped, Multizone) zone_model : string setter of the used Aixlib zone model (ThermalZoneEquipped, ThermalZone) corG : boolean setter of the used g value calculation in the model internal_id : float setter of the used building which will be exported, if None then all buildings will be exported path : string if the Files should not be stored in OutputData, an alternative path can be specified as a full and absolute path """ if path is None: path = utilitis.get_default_path() + "\\" + self.name else: path = path + "\\" + self.name utilitis.create_path(path) aixlib_output.export_aixlib(prj=self, building_model=building_model, zone_model=zone_model, corG=corG, internal_id=internal_id, path=path)
def modelica_set_temp_cool(self, path=None): """Create .txt file for set temperatures cooling. This function creates a txt for set temperatures for cooling of each zone, that are all saved into one matrix. Parameters ---------- path : str optional path, when matfile is exported separately """ if path is None: path = utilities.get_default_path() else: pass utilities.create_path(path) path = os.path.join(path, self.file_set_t_cool) export = pd.DataFrame( index=pd.date_range( "2019-01-01 00:00:00", periods=8760, freq="H").to_series().dt.strftime("%m-%d %H:%M:%S"), columns=[zone.name for zone in self.parent.thermal_zones], ) for zone_count in self.parent.thermal_zones: export[zone_count.name] = zone_count.use_conditions.schedules[ "cooling_profile"] export.index = [(i + 1) * 3600 for i in range(8760)] self._delete_file(path=path) with open(path, "a") as f: f.write("#1\n") f.write("double Tset({}, {})\n".format( 8760, len(self.parent.thermal_zones) + 1)) export.to_csv(f, sep="\t", header=False, index_label=False)
def export_parameters_txt(self, path=None): """Exports parameters of all buildings in a readable text file Parameters ---------- path : string if the Files should not be stored in OutputData, an alternative can be specified """ if path is None: path = os.path.join( utilities.get_default_path(), self.name) else: path = os.path.join( path, self.name) text_out.export_parameters_txt( prj=self, path=path)
def export_annex(self, number_of_elements=2, merge_windows=False, internal_id=None, path=None): """Exports values to a record file for Modelica simulation Parameters ---------- number_of_elements : int defines the number of elements, that area aggregated, between 1 and 4, default is 2 merge_windows : bool True for merging the windows into the outer walls, False for separate resistance for window, default is False internal_id : float setter of the used building which will be exported, if None then all buildings will be exported path : string if the Files should not be stored in OutputData, an alternative path can be specified as a full and absolute path """ if path is None: path = utilitis.get_default_path() + "\\" + self.name else: path = path + "\\" + self.name utilitis.create_path(path) annex60_output.export_annex60( prj=self, number_of_elements=self.number_of_elements_calc, merge_windows=self.merge_windows_calc, internal_id=internal_id, path=path)
def export_annex(self, number_of_elements=2, merge_windows=False, internal_id=None, path=None): """Exports values to a record file for Modelica simulation Parameters ---------- number_of_elements : int defines the number of elements, that area aggregated, between 1 and 4, default is 2 merge_windows : bool True for merging the windows into the outer walls, False for separate resistance for window, default is False internal_id : float setter of the used building which will be exported, if None then all buildings will be exported path : string if the Files should not be stored in OutputData, an alternative path can be specified as a full and absolute path """ if path is None: path = utilitis.get_default_path() + "\\" + self.name else: path = path + "\\" + self.name utilitis.create_path(path) annex60_output.export_annex60(prj=self, number_of_elements=self.number_of_elements_calc, merge_windows=self.merge_windows_calc, internal_id=internal_id, path=path)
def modelica_gains_boundary(self, zone, path=None): """creates .mat file for internal gains boundary conditions This function creates a matfile (-v4) for building internal gains boundary conditions. It collects internal gain profiles of a specific zones and stores them into one file. It also calculates the internal gains from relative presence and values for heat output into W for direct usage in Annex models. Only person (convective and radiative) and machines (convective) are used in the simple Annex 60 examples. 1. Column : time step 2 Column : profile_persons, radiative 3 Column : profile_persons, convective 4 Column : profile_machines, convective Note ---------- When time line is created, we need to add a 0 to first element of all boundaries. This is due to to expected format in Modelica. Parameters ---------- zone : ThermalZone() TEASER instance of ThermalZone. As IBPSA computes single models for single zones, we need to generate individual files for zones and internal gains path : str optional path, when matfile is exported separately """ if path is None: path = utilities.get_default_path() else: pass utilities.create_path(path) path = os.path.join(path, self.file_internal_gains) export = pd.DataFrame( index=pd.date_range("2019-01-01 00:00:00", periods=8760, freq="H") .to_series() .dt.strftime("%m-%d %H:%M:%S") ) export["person_rad_{}".format(zone.name)] = ( zone.use_conditions.schedules["persons_profile"] * (1 - zone.use_conditions.ratio_conv_rad_persons) * zone.use_conditions.fixed_heat_flow_rate_persons * zone.use_conditions.persons * zone.area ) export["person_conv_{}".format(zone.name)] = ( zone.use_conditions.schedules["persons_profile"] * zone.use_conditions.ratio_conv_rad_persons * zone.use_conditions.fixed_heat_flow_rate_persons * zone.use_conditions.persons * zone.area ) export["machines_conv_{}".format(zone.name)] = ( zone.use_conditions.schedules["machines_profile"] * zone.use_conditions.ratio_conv_rad_machines * zone.use_conditions.machines * zone.area ) export.index = [(i + 1) * 3600 for i in range(8760)] self._delete_file(path=path) with open(path, "a") as f: f.write("#1\n") f.write( "double Internals({}, {})\n".format( 8760, (len(self.parent.thermal_zones) * 3 + 1) ) ) export.to_csv(f, sep="\t", header=False, index_label=False)
def modelica_gains_boundary(bldg, time_line = None, path = None): '''creates .mat file for internal gains boundary conditions (building) This function creates a matfile (-v4) for building internal gains boundary conditions. It collects all internal gain profiles of the zones and stores them into one file. The file is extended for each zone. Only applicable if zones are defined !AixLib sepcific! 1. Column : time step 2,5,8,... Column : profile_persons 3,6,9,... Column : profile_machines 4,7,10,... Column : profile_lighting Note ---------- When time line is created, we need to add a 0 to first element of all boundaries. This is due to to expected format in Modelica. Parameters ---------- time_line :[[int]] list of time steps path : str optional path, when matfile is exported seperately ''' if bldg.file_internal_gains is None: bldg.file_internal_gains = "\\InternalGains_"+bldg.name+".mat" else: pass if path is None: path = utilitis.get_default_path() else: pass utilitis.create_path(path) path = path + bldg.file_internal_gains for zone_count in bldg.thermal_zones: if time_line is None: duration= len(zone_count.use_conditions.profile_persons) * \ 3600 time_line = create_timeline(bldg=bldg, duration_profile = duration) # zone_count.use_conditions.profile_persons.insert(0,0) # zone_count.use_conditions.profile_machines.insert(0,0) # zone_count.use_conditions.profile_lighting.insert(0,0) ass_error_1 = "time line and input have to have the same length" assert len(time_line)-1 == len(zone_count.use_conditions.profile_persons), \ (ass_error_1 + ",profile_persons") assert len(time_line)-1 == len(zone_count.use_conditions.profile_machines), \ (ass_error_1 + ",profile_machines") assert len(time_line)-1 == len(zone_count.use_conditions.profile_lighting), \ (ass_error_1 + ",profile_lighting") for i, time in enumerate(time_line): if i == 0: time.append(0) time.append(0) time.append(0) else: time.append(zone_count.use_conditions.profile_persons[i-1]) time.append(zone_count.use_conditions.profile_machines[i-1]) time.append(zone_count.use_conditions.profile_lighting[i-1]) # zone_count.use_conditions.profile_persons.pop(0) # zone_count.use_conditions.profile_machines.pop(0) # zone_count.use_conditions.profile_lighting.pop(0) internal_boundary = np.array(time_line) scipy.io.savemat(path, mdict={'Internals': internal_boundary}, appendmat=False, format='4')
def main(): this_path = os.path.dirname(__file__) input_path = os.path.join(this_path, 'examplefiles', 'MelatenXML') output_path = utilitis.get_default_path() info_list = read_XMLs(input_path) prj = create_reference_project(info_list) prj.name = "Melaten_Ref" ''' 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() prj.name = "Melaten_Retrofit" prj.retrofit_all_buildings(2015) '''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)
def modelica_AHU_boundary(bldg, time_line = None, path = None): '''creates .mat file for AHU boundary conditions (building) This function creates a matfile (-v4) for building AHU boundary conditions !AixLib sepcific! Known limitation: 1. Column : time step 2. Column : desired AHU profile temperature 3. Column : Desired minimal relative humidity 4. Column : desired maximal relative humidity 5. Columb : AHU status (On/Off) Parameters ---------- time_line :[[int]] list of time steps path : str optional path, when matfile is exported seperately Attributes ---------- profile_temperature : [float] timeline of temperatures requirements for AHU simulation profile_min_relative_humidity : [float] timeline of relative humidity requirements for AHU simulation profile_max_relative_humidity : [float] timeline of relative humidity requirements for AHU simulation profile_v_flow : [int] timeline of desired relative v_flow of the AHU simulation (0..1) ''' if bldg.file_ahu is None: bldg.file_ahu = "\\AHU_"+bldg.name+".mat" else: pass if path is None: path = utilitis.get_default_path() else: pass utilitis.create_path(path) path = path + bldg.file_ahu if time_line is None: time_line = create_timeline(bldg) if bldg.with_ahu is True: profile_temperature = \ bldg.central_ahu.profile_temperature profile_min_relative_humidity = \ bldg.central_ahu.profile_min_relative_humidity profile_max_relative_humidity = \ bldg.central_ahu.profile_max_relative_humidity profile_v_flow = \ bldg.central_ahu.profile_v_flow else: #Dummy values for Input Table (based on discussion with pme) time_line = [[0],[3600]] profile_temperature = [293.15,293.15] profile_min_relative_humidity = [0,0] profile_max_relative_humidity = [1,1] profile_v_flow = [0,1] ass_error_1 = "time line and input have to have the same length" assert len(time_line) == len(profile_temperature), \ (ass_error_1 + ",profile_temperature_AHU") assert len(time_line) == len(profile_min_relative_humidity), \ (ass_error_1 + ",profile_min_relative_humidity") assert len(time_line) == len(profile_max_relative_humidity), \ (ass_error_1 + ",profile_max_relative_humidity") assert len(time_line) == len(profile_v_flow), \ (ass_error_1 + ",profile_status_AHU") for i, time in enumerate(time_line): time.append(profile_temperature[i]) time.append(profile_min_relative_humidity[i]) time.append(profile_max_relative_humidity[i]) time.append(profile_v_flow[i]) ahu_boundary = np.array(time_line) scipy.io.savemat(path, mdict={'AHU': ahu_boundary}, appendmat = False, format = '4')
def from_scratch( number_of_elements, save=False, path=utilities.get_default_path()): """This function creates the test room from scratch. Notes: The standard defines an solar absorption coefficient for interior surfaces of 0.6. We do not consider this, but we could by multiplying the solar radiation after the window by 0.6. Parameters ---------- number_of_elements: int Number of elements of model path: str (optional) Path where Project should be stored as .teaserXML save: bool (optional) True if Project should be stored as .teaserXML at path Returns ------- prj: Project Project that contains the building with the test room """ prj = Project(load_data=True) prj.name = "ASHRAE140Verification" bldg = Building(parent=prj) bldg.name = "TestBuilding" tz = ThermalZone(parent=bldg) tz.name = "TestRoom900" tz.area = 8.0 * 6.0 tz.volume = tz.area * 2.7 tz.infiltration_rate = 0.41 tz.use_conditions = BoundaryConditions(parent=tz) roof = Rooftop(parent=tz) roof.name = "Roof" roof.area = 8.0 * 6.0 roof.orientation = -1.0 roof.tilt = 0.0 roof.inner_convection = 1 roof.outer_convection = 24.67 roof.inner_radiation = 5.13 roof.outer_radiation = 4.63 layer_r1 = Layer(parent=roof, id=0) layer_r1.thickness = 0.01 material_r1 = Material(layer_r1) material_r1.name = "Plasterboard" material_r1.density = 950.0 material_r1.heat_capac = 840.0 / 1000 material_r1.thermal_conduc = 0.16 material_r1.ir_emissivity = 0.9 layer_r2 = Layer(parent=roof, id=1) layer_r2.thickness = 0.1118 material_r2 = Material(layer_r2) material_r2.name = "Fiberglass" material_r2.density = 12 material_r2.heat_capac = 840 / 1000 material_r2.thermal_conduc = 0.04 layer_r3 = Layer(parent=roof, id=2) layer_r3.thickness = 0.019 material_r3 = Material(layer_r3) material_r3.name = "Roofdeck" material_r3.density = 530 material_r3.heat_capac = 900 / 1000 material_r3.thermal_conduc = 0.14 material_r3.solar_absorp = 0.6 material_r3.ir_emissivity = 0.9 out_wall_north = OuterWall(parent=tz) out_wall_north.name = "OuterWallNorth" out_wall_north.area = 8.0 * 2.7 out_wall_north.orientation = 0.0 out_wall_north.tilt = 90.0 out_wall_north.inner_convection = 3.16 out_wall_north.outer_convection = 24.67 out_wall_north.inner_radiation = 5.13 out_wall_north.outer_radiation = 4.63 layer_own1 = Layer(parent=out_wall_north, id=0) layer_own1.thickness = 0.1 material_own1 = Material(layer_own1) material_own1.name = "Concrete" material_own1.density = 1400.0 material_own1.heat_capac = 1000 / 1000 material_own1.thermal_conduc = 0.51 material_own1.ir_emissivity = 0.9 layer_own2 = Layer(parent=out_wall_north, id=1) layer_own2.thickness = 0.062 material_own2 = Material(layer_own2) material_own2.name = "FoamInsulation" material_own2.density = 10 material_own2.heat_capac = 1400 / 1000 material_own2.thermal_conduc = 0.04 layer_own3 = Layer(parent=out_wall_north, id=2) layer_own3.thickness = 0.009 material_own3 = Material(layer_own3) material_own3.name = "WoodSiding" material_own3.density = 530 material_own3.heat_capac = 900 / 1000 material_own3.thermal_conduc = 0.14 material_own3.solar_absorp = 0.6 material_own3.ir_emissivity = 0.9 out_wall_east = OuterWall(parent=tz) out_wall_east.name = "OuterWallEast" out_wall_east.area = 6.0 * 2.7 out_wall_east.orientation = 90.0 out_wall_east.tilt = 90.0 out_wall_east.inner_convection = 3.16 out_wall_east.outer_convection = 24.67 out_wall_east.inner_radiation = 5.13 out_wall_east.outer_radiation = 4.63 layer_owe1 = Layer(parent=out_wall_east, id=0) layer_owe1.thickness = 0.1 material_owe1 = Material(layer_owe1) material_owe1.name = "Concrete" material_owe1.density = 1400.0 material_owe1.heat_capac = 1000 / 1000 material_owe1.thermal_conduc = 0.51 material_owe1.ir_emissivity = 0.9 layer_owe2 = Layer(parent=out_wall_east, id=1) layer_owe2.thickness = 0.062 material_owe2 = Material(layer_owe2) material_owe2.name = "FoamInsulation" material_owe2.density = 10 material_owe2.heat_capac = 1400 / 1000 material_owe2.thermal_conduc = 0.04 layer_owe3 = Layer(parent=out_wall_east, id=2) layer_owe3.thickness = 0.009 material_owe3 = Material(layer_owe3) material_owe3.name = "WoodSiding" material_owe3.density = 530 material_owe3.heat_capac = 900 / 1000 material_owe3.thermal_conduc = 0.14 material_owe3.solar_absorp = 0.6 material_owe3.ir_emissivity = 0.9 out_wall_south = OuterWall(parent=tz) out_wall_south.name = "OuterWallSouth" out_wall_south.area = (8.0 * 2.7) - 2 * (3 * 2) # minus two windows out_wall_south.orientation = 180.0 out_wall_south.tilt = 90.0 out_wall_south.inner_convection = 3.16 out_wall_south.outer_convection = 24.67 out_wall_south.inner_radiation = 5.13 out_wall_south.outer_radiation = 4.63 layer_ows1 = Layer(parent=out_wall_south, id=0) layer_ows1.thickness = 0.1 material_ows1 = Material(layer_ows1) material_ows1.name = "Concrete" material_ows1.density = 1400.0 material_ows1.heat_capac = 1000.0 / 1000 material_ows1.thermal_conduc = 0.51 material_ows1.ir_emissivity = 0.9 layer_ows2 = Layer(parent=out_wall_south, id=1) layer_ows2.thickness = 0.062 material_ows2 = Material(layer_ows2) material_ows2.name = "FoamInsulation" material_ows2.density = 10 material_ows2.heat_capac = 1400 / 1000 material_ows2.thermal_conduc = 0.04 layer_ows3 = Layer(parent=out_wall_south, id=2) layer_ows3.thickness = 0.009 material_ows3 = Material(layer_ows3) material_ows3.name = "WoodSiding" material_ows3.density = 530 material_ows3.heat_capac = 900 / 1000 material_ows3.thermal_conduc = 0.14 material_ows3.solar_absorp = 0.6 material_ows3.ir_emissivity = 0.9 out_wall_west = OuterWall(parent=tz) out_wall_west.name = "OuterWallWest" out_wall_west.area = 6 * 2.7 out_wall_west.orientation = 270.0 out_wall_west.tilt = 90.0 out_wall_west.inner_convection = 3.16 out_wall_west.outer_convection = 24.67 out_wall_west.inner_radiation = 5.13 out_wall_west.outer_radiation = 4.63 layer_oww1 = Layer(parent=out_wall_west, id=0) layer_oww1.thickness = 0.1 material_oww1 = Material(layer_oww1) material_oww1.name = "Concrete" material_oww1.density = 1400.0 material_oww1.heat_capac = 1000.0 / 1000 material_oww1.thermal_conduc = 0.51 material_oww1.ir_emissivity = 0.9 layer_oww2 = Layer(parent=out_wall_west, id=1) layer_oww2.thickness = 0.062 material_oww2 = Material(layer_oww2) material_oww2.name = "FoamInsulation" material_oww2.density = 10 material_oww2.heat_capac = 1400 / 1000 material_oww2.thermal_conduc = 0.04 layer_oww3 = Layer(parent=out_wall_west, id=2) layer_oww3.thickness = 0.009 material_oww3 = Material(layer_oww3) material_oww3.name = "WoodSiding" material_oww3.density = 530 material_oww3.heat_capac = 900 / 1000 material_oww3.thermal_conduc = 0.14 material_oww3.solar_absorp = 0.6 material_oww3.ir_emissivity = 0.9 in_wall_floor = Floor(parent=tz) in_wall_floor.name = "InnerWallFloor" in_wall_floor.area = 6 * 8 in_wall_floor.orientation = -2.0 in_wall_floor.tilt = 0.0 in_wall_floor.inner_convection = 4.13 in_wall_floor.inner_radiation = 5.13 layer_iwf1 = Layer(parent=in_wall_floor, id=0) layer_iwf1.thickness = 0.025 material_iwf1 = Material(layer_iwf1) material_iwf1.name = "Concrete" material_iwf1.density = 1400 material_iwf1.heat_capac = 1000 / 1000 material_iwf1.thermal_conduc = 1.13 material_iwf1.ir_emissivity = 0.9 layer_iwf2 = Layer(parent=in_wall_floor, id=1) layer_iwf2.thickness = 1.007 material_iwf2 = Material(layer_iwf2) material_iwf2.name = "Insulation" material_iwf2.density = 0.000000000001 # 0.0001, as small as possible material_iwf2.heat_capac = 0.000000000001 # 0.0001, as small as possible material_iwf2.thermal_conduc = 0.04 win_1 = Window(parent=tz) win_1.name = "WindowSouthLeft" win_1.area = 3 * 2 win_1.tilt = 90.0 win_1.orientation = 180.0 win_1.inner_convection = 3.16 win_1.inner_radiation = 5.13 win_1.outer_convection = 16.37 win_1.outer_radiation = 4.63 win_1.g_value = 0.789 win_1.a_conv = 0.03 # for the given U-value extracted from VDI 6007-2/-3 win_1_layer = Layer(parent=win_1) win_1_layer.id = 1 win_1_layer.thickness = 0.024 win_1_material = Material(win_1_layer) win_1_material.name = "GlasWindow" win_1_material.thermal_conduc = 0.15 win_1_material.transmittance = 0.907 win_1_material.ir_emissivity = 0.9 win_2 = Window(parent=tz) win_2.name = "WindowSouthRight" win_2.area = 3 * 2 win_2.tilt = 90.0 win_2.orientation = 180.0 win_2.inner_convection = 3.16 win_2.inner_radiation = 5.13 win_2.outer_convection = 16.37 win_2.outer_radiation = 4.63 win_2.g_value = 0.789 win_2.a_conv = 0.03 # for the given U-value extracted from VDI 6007-2/-3 win_2_layer = Layer(parent=win_2) win_2_layer.id = 1 win_2_layer.thickness = 0.024 win_2_material = Material(win_2_layer) win_2_material.name = "GlasWindow" win_2_material.thermal_conduc = 0.15 win_2_material.transmittance = 0.907 win_2_material.ir_emissivity = 0.9 # This is a dummy ground floor to export three and four elements models. # Please set values for floor plate in three element and four element # models to default. if number_of_elements >= 3: out_wall_gf = GroundFloor(parent=tz) out_wall_gf.name = "ExtWallGroundFloor" out_wall_gf.area = 6 * 8 out_wall_gf.orientation = -2.0 out_wall_gf.tilt = 0.0 out_wall_gf.inner_convection = 4.13 out_wall_gf.inner_radiation = 5.13 layer_ofgw1 = Layer(parent=out_wall_gf, id=0) layer_ofgw1.thickness = 1.003 material_ofgw1 = Material(layer_ofgw1) material_ofgw1.name = "Insulation" material_ofgw1.density = 0.0001 # as small as possible material_ofgw1.heat_capac = 0.0001 # as small as possible material_ofgw1.thermal_conduc = 0.04 if save: prj.save_project(file_name='ASHRAE140_900', path=path) return prj
def modelica_gains_boundary( self, time_line=None, path=None): """creates .mat file for internal gains boundary conditions This function creates a matfile (-v4) for building internal gains boundary conditions. It collects all internal gain profiles of the zones and stores them into one file. The file is extended for each zone. Only applicable if zones are defined 1. Column : time step 2,5,8,... Column : profile_persons 3,6,9,... Column : profile_machines 4,7,10,... Column : profile_lighting Note ---------- When time line is created, we need to add a 0 to first element of all boundaries. This is due to to expected format in Modelica. Parameters ---------- time_line :[[int]] list of time steps path : str optional path, when matfile is exported separately """ if path is None: path = utilities.get_default_path() else: pass utilities.create_path(path) path = os.path.join(path, self.file_internal_gains) for zone_count in self.parent.thermal_zones: if time_line is None: duration = len(zone_count.use_conditions.profile_persons) * \ 3600 time_line = self.create_profile(duration_profile=duration) ass_error_1 = "time line and input have to have the same length" assert len(time_line) - 1 == len( zone_count.use_conditions.profile_persons), \ (ass_error_1 + ",profile_persons") assert len(time_line) - 1 == len( zone_count.use_conditions.profile_machines), \ (ass_error_1 + ",profile_machines") assert len(time_line) - 1 == len( zone_count.use_conditions.profile_lighting), \ (ass_error_1 + ",profile_lighting") for i, time in enumerate(time_line): if i == 0: time.append( zone_count.use_conditions.profile_persons[i + 1]) time.append( zone_count.use_conditions.profile_machines[i + 1]) time.append( zone_count.use_conditions.profile_lighting[i + 1]) else: time.append( zone_count.use_conditions.profile_persons[i - 1]) time.append( zone_count.use_conditions.profile_machines[i - 1]) time.append( zone_count.use_conditions.profile_lighting[i - 1]) internal_boundary = np.array(time_line) scipy.io.savemat( path, mdict={'Internals': internal_boundary}, appendmat=False, format='4') return internal_boundary
def modelica_set_temp(self, path=None): """creates .mat file for set temperatures This function creates a matfile (-v4) for set temperatures of each zone, that are all saved into one matrix. 1. Row: heat set temperature of all zones 2. Row: cool set temperature of all zones Parameters ---------- path : str optional path, when matfile is exported separately """ if path is None: path = utilities.get_default_path() else: pass utilities.create_path(path) path = os.path.join(path, self.file_set_t) time_line = self.create_profile(double=True) for zone_count in self.parent.thermal_zones: for i in range(len(time_line)): if self.use_set_back is False: time_line[i].append(zone_count.use_conditions.set_temp_heat) else: i -= 1 if i % 2 == 0: if zone_count.use_conditions.heating_time[0] == 0: time_line[i].append( zone_count.use_conditions.set_temp_heat) time_line[i + 1].append( zone_count.use_conditions.set_temp_heat) elif time_line[i][0] < \ zone_count.use_conditions.heating_time[0] * 3600: time_line[i].append( zone_count.use_conditions.set_temp_heat - zone_count.use_conditions.temp_set_back) time_line[i + 1].append( zone_count.use_conditions.set_temp_heat - zone_count.use_conditions.temp_set_back) elif time_line[i][0] == \ zone_count.use_conditions.heating_time[0] * 3600: time_line[i].append( zone_count.use_conditions.set_temp_heat - zone_count.use_conditions.temp_set_back) time_line[i + 1].append( zone_count.use_conditions.set_temp_heat) elif time_line[i][0] == \ (zone_count.use_conditions.heating_time[1] + 1) * \ 3600: time_line[i].append( zone_count.use_conditions.set_temp_heat) time_line[i + 1].append( zone_count.use_conditions.set_temp_heat - zone_count.use_conditions.temp_set_back) elif time_line[i][0] > \ (zone_count.use_conditions.heating_time[1] + 1) * \ 3600: time_line[i].append( zone_count.use_conditions.set_temp_heat - zone_count.use_conditions.temp_set_back) time_line[i + 1].append( zone_count.use_conditions.set_temp_heat - zone_count.use_conditions.temp_set_back) else: time_line[i].append( zone_count.use_conditions.set_temp_heat) time_line[i + 1].append( zone_count.use_conditions.set_temp_heat) else: pass scipy.io.savemat( path, mdict={'Tset': time_line}, appendmat=False, format='4')
def modelica_gains_boundary(self, zone, time_line=None, path=None): """creates .mat file for internal gains boundary conditions This function creates a matfile (-v4) for building internal gains boundary conditions. It collects internal gain profiles of a specific zones and stores them into one file. It also calculates the internal gains from relative presence and values for heat output into W for direct usage in Annex models. Only person (convective and radiative) and machines (convective) are used in the simple Annex 60 examples. 1. Column : time step 2 Column : profile_persons, radiative 3 Column : profile_persons, convective 4 Column : profile_machines, convective Note ---------- When time line is created, we need to add a 0 to first element of all boundaries. This is due to to expected format in Modelica. Parameters ---------- zone : ThermalZone() TEASER instance of ThermalZone. As IBPSA computes single models for single zones, we need to generate individual files for zones and internal gains time_line :[[int]] list of time steps path : str optional path, when matfile is exported separately """ if path is None: path = utilities.get_default_path() else: pass utilities.create_path(path) path = os.path.join(path, self.file_internal_gains) if time_line is None: duration = len(zone.use_conditions.profile_persons) * \ 3600 time_line = self.create_profile(duration_profile=duration) ass_error_1 = "time line and input have to have the same length" assert len(time_line) - 1 == len( zone.use_conditions.profile_persons), \ (ass_error_1 + ",profile_persons") assert len(time_line) - 1 == len( zone.use_conditions.profile_machines), \ (ass_error_1 + ",profile_machines") for i, time in enumerate(time_line): if i == 0: time.append(0) time.append(0) time.append(0) else: time.append(zone.use_conditions.profile_persons[i - 1] * zone.use_conditions.persons * zone.use_conditions.activity_type_persons * 50 * (1 - zone.use_conditions.ratio_conv_rad_persons)) time.append(zone.use_conditions.profile_persons[i - 1] * zone.use_conditions.persons * zone.use_conditions.activity_type_persons * 50 * zone.use_conditions.ratio_conv_rad_persons) time.append(zone.use_conditions.profile_machines[i - 1] * zone.use_conditions.machines * zone.use_conditions.activity_type_machines * 50) internal_boundary = np.array(time_line) scipy.io.savemat(path, mdict={'Internals': internal_boundary}, appendmat=False, format='4')