def test_get_param_with_building_id(self): filename = os.path.abspath( "tests/system_parameters/data/system_params_1.json") sdp = SystemParameters(filename) value = sdp.get_param_by_building_id("abcd1234", "ets.system") self.assertEqual(value, "Booster Heater")
def test_errors(self): data = { "buildings": { "default": { "load_model": "rc", "load_model_parameters": { "rc": { "order": 6 } }, } } } with self.assertRaises(Exception) as exc: SystemParameters.loadd(data) self.assertRegex(str(exc.exception), "Invalid system parameter file.*") sp = SystemParameters.loadd(data, validate_on_load=False) self.assertEqual(len(sp.validate()), 6) self.assertIn("'fraction_latent_person' is a required property", sp.validate()) self.assertIn("'mos_weather_filename' is a required property", sp.validate()) self.assertIn("'temp_hw_supply' is a required property", sp.validate()) self.assertIn("'temp_setpoint_cooling' is a required property", sp.validate()) self.assertIn("'temp_setpoint_heating' is a required property", sp.validate()) self.assertIn("6 is not one of [1, 2, 3, 4]", sp.validate())
def test_csv_to_sys_param(self): output_sys_param_file = self.output_dir / 'test_sys_param.json' SystemParameters.csv_to_sys_param( model_type='time_series', scenario_dir=self.scenario_dir, feature_file=self.feature_file, sys_param_filename=output_sys_param_file) self.assertTrue(output_sys_param_file.exists())
def test_get_param_with_none_building_id(self): filename = self.data_dir / 'system_params_1.json' sdp = SystemParameters(filename) self.maxDiff = None with self.assertRaises(SystemExit) as context: sdp.get_param_by_building_id(None, "ets_model", "Not None") self.assertIn( "No building_id submitted. Please retry and include the feature_id", str(context.exception))
def setUp(self): self.project_name = 'mixed_loads' _, self.output_dir = self.set_up( Path(__file__).parent, self.project_name) filename = self.SHARED_DATA_DIR / 'mixed_loads_district' / 'geojson.json' self.gj = UrbanOptGeoJson(filename) # load system parameter data filename = self.SHARED_DATA_DIR / 'mixed_loads_district' / 'system_params.json' self.sys_params = SystemParameters(filename)
def test_to_modelica_defaults(self): self.results_path = os.path.abspath("tests/output/geojson_urbanopt") if os.path.exists(self.results_path): shutil.rmtree(self.results_path) filename = os.path.abspath( "tests/geojson/data/example_geojson_13buildings.json") gj = GeoJsonModelicaTranslator.from_geojson(filename) sys_params = SystemParameters() gj.set_system_parameters(sys_params) gj.to_modelica("geojson_urbanopt", "tests/output") # go through the generated buildings and ensure that the resources are created resource_names = [ "InternalGains_Floor", "InternalGains_ICT", "InternalGains_Meeting", "InternalGains_Office", "InternalGains_Restroom", "InternalGains_Storage", ] for b in gj.buildings: for resource_name in resource_names: # TEASER 0.7.2 used .txt for schedule files path = os.path.join( gj.scaffold.loads_path.files_dir, "Resources", "Data", b.dirname, f"{resource_name}.txt", ) self.assertTrue(os.path.exists(path), f"Path not found: {path}")
def test_load_system_parameters_1(self): filename = os.path.abspath( "tests/system_parameters/data/system_params_1.json") sdp = SystemParameters(filename) self.assertEqual( sdp.data["buildings"]["default"]["load_model_parameters"]["rc"] ["order"], 2)
def test_to_modelica_defaults(self): feature_json_file = self.data_dir / f"{self.project_name}.json" gj = GeoJsonModelicaTranslator.from_geojson(feature_json_file) sys_params_json_file = self.data_dir / 'spawn_system_params.json' gj.set_system_parameters(SystemParameters(sys_params_json_file)) gj.process_loads() self.assertEqual(len(gj.loads), 2) gj.to_modelica(self.project_name, self.output_dir) self.assertTrue(self.results_path / "Loads" / "Resources" / "Data" / "B5a6b99ec37f4de7f94020090" / "RefBldgSmallOfficeNew2004_Chicago.idf") # noqa mr = ModelicaRunner() file_to_run = Path(gj.scaffold.loads_path.files_dir ) / 'B5a6b99ec37f4de7f94020090' / 'coupling.mo' run_path = Path(gj.scaffold.project_path).parent exitcode = mr.run_in_docker(file_to_run, run_path=run_path, project_name=gj.scaffold.project_name) self.assertEqual(0, exitcode) results_path = Path(run_path / f"{gj.scaffold.project_name}_results") self.assertTrue(Path(results_path) / 'stdout.log') self.assertTrue( Path(results_path) / 'spawn_single_Loads_B5a6b99ec37f4de7f94020090_SpawnCouplingETS.fmu' )
def test_district_system(self): project_name = "chilled_water_plant_stub" self.data_dir, self.output_dir = self.set_up(os.path.dirname(__file__), project_name) # load in the example geojson with a single office building filename = os.path.join(self.data_dir, "time_series_ex1.json") self.gj = UrbanOptGeoJson(filename) # load system parameter data filename = os.path.join(self.data_dir, "time_series_system_params_ets.json") sys_params = SystemParameters(filename) cooling_plant = CoolingPlant(sys_params) # create chilled water stub for the ets chilled_water_stub = NetworkChilledWaterStub(sys_params) cp_cw_coupling = Coupling(cooling_plant, chilled_water_stub) graph = CouplingGraph([ cp_cw_coupling, ]) district = District(root_dir=self.output_dir, project_name=project_name, system_parameters=sys_params, coupling_graph=graph) district.to_modelica() root_path = os.path.abspath( os.path.join(district._scaffold.districts_path.files_dir)) self.run_and_assert_in_docker( os.path.join(root_path, 'DistrictEnergySystem.mo'), project_path=district._scaffold.project_path, project_name=district._scaffold.project_name)
def test_heating_indirect(self): project_name = "heating_indirect" self.data_dir, self.output_dir = self.set_up(os.path.dirname(__file__), project_name) # load in the example geojson with a single office building filename = os.path.join(self.data_dir, "time_series_ex1.json") self.gj = UrbanOptGeoJson(filename) # scaffold the project ourselves scaffold = Scaffold(self.output_dir, project_name) scaffold.create() # load system parameter data filename = os.path.join(self.data_dir, "time_series_system_params_ets.json") sys_params = SystemParameters(filename) # currently we must setup the root project before we can run to_modelica package = PackageParser.new_from_template(scaffold.project_path, scaffold.project_name, order=[]) package.save() # now test the connector (independent of the larger geojson translator) geojson_load_id = self.gj.buildings[0].feature.properties["id"] self.heating_indirect = HeatingIndirect(sys_params, geojson_load_id) self.heating_indirect.to_modelica(scaffold) root_path = os.path.abspath( os.path.join(scaffold.substations_path.files_dir)) geojson_id = self.gj.buildings[0].feature.properties["id"] model_filepath = os.path.join(root_path, f'HeatingIndirect_{geojson_id}.mo') self.assertTrue(os.path.exists(model_filepath), f"File does not exist: {model_filepath}")
def test_csv_to_sys_param_does_not_overwrite(self): with self.assertRaises(Exception) as context: output_sys_param_file = self.output_dir / 'test_overwriting_sys_param.json' SystemParameters.csv_to_sys_param( model_type='time_series', scenario_dir=self.scenario_dir, feature_file=self.feature_file, sys_param_filename=output_sys_param_file, overwrite=True) SystemParameters.csv_to_sys_param( model_type='time_series', scenario_dir=self.scenario_dir, feature_file=self.feature_file, sys_param_filename=output_sys_param_file, overwrite=False) self.assertIn("Output file already exists and overwrite is False:", str(context.exception))
def test_get_param_with_default(self): data = {"buildings": {"default": {"load_model": "Spawn"}}} sp = SystemParameters.loadd(data) value = sp.get_param( "buildings.default.load_model_parameters.rc.order", default=2) self.assertEqual(value, 2) value = sp.get_param("not.a.real.path", default=2) self.assertEqual(value, 2)
def test_get_param_with_default(self): data = {"buildings": {"default": {"load_model": "spawn"}}} sp = SystemParameters.loadd(data) # this path doesn't exist, but there is a default value = sp.get_param( "buildings.default.load_model_parameters.rc.order", default=2) self.assertEqual(2, value) value = sp.get_param("not.a.real.path", default=2) self.assertEqual(2, value)
def test_validate_sys_param_template(self): output_sys_param_file = self.output_dir / 'bogus_sys_param.json' with self.assertRaises(Exception) as context: SystemParameters.csv_to_sys_param( scenario_dir=self.scenario_dir, feature_file=self.feature_file, sys_param_filename=output_sys_param_file) self.assertIn( "csv_to_sys_param() missing 1 required positional argument: 'model_type'", str(context.exception)) with self.assertRaises(Exception) as context: bogus_template_type = 'openstudio' SystemParameters.csv_to_sys_param( model_type=bogus_template_type, scenario_dir=self.scenario_dir, feature_file=self.feature_file, sys_param_filename=output_sys_param_file) self.assertIn( f"No template found. {bogus_template_type} is not a valid template", str(context.exception))
def setUp(self): self.project_name = 'district_heating_and_cooling_systems' self.data_dir, self.output_dir = self.set_up(Path(__file__).parent, self.project_name) # load in the example geojson with a single office building filename = Path(self.data_dir) / "time_series_ex1.json" self.gj = UrbanOptGeoJson(filename) # load system parameter data filename = Path(self.data_dir) / "time_series_system_params_ets.json" self.sys_params = SystemParameters(filename)
def test_errors(self): data = { "buildings": { "default": { "load_model": "ROM/RC", "load_model_parameters": { "rc": { "order": 6 } }, } } } with self.assertRaises(Exception) as exc: SystemParameters.loadd(data) self.assertRegex(str(exc.exception), "Invalid system parameter file.*") sp = SystemParameters.loadd(data, validate_on_load=False) self.assertEqual(sp.validate()[0], "6 is not one of [1, 2, 3, 4]")
def test_to_modelica_defaults(self): self.results_path = os.path.abspath("tests/output/geojson_1") if os.path.exists(self.results_path): shutil.rmtree(self.results_path) filename = os.path.abspath("tests/geojson/data/geojson_1.json") gj = GeoJsonModelicaTranslator.from_geojson(filename) sys_params = SystemParameters() gj.set_system_parameters(sys_params) gj.to_modelica("geojson_1", "tests/output") # setup what we are going to check model_names = [ "Floor", "ICT", "Meeting", "Office", "package", "Restroom", "Storage", ] building_paths = [ os.path.join(gj.scaffold.loads_path.files_dir, b.dirname) for b in gj.buildings ] path_checks = [ f"{os.path.sep.join(r)}.mo" for r in itertools.product(building_paths, model_names) ] for p in path_checks: self.assertTrue(os.path.exists(p), f"Path not found {p}") # go through the generated buildings and ensure that the resources are created resource_names = [ "InternalGains_Floor", "InternalGains_ICT", "InternalGains_Meeting", "InternalGains_Office", "InternalGains_Restroom", "InternalGains_Storage", ] for b in gj.buildings: for resource_name in resource_names: # TEASER 0.7.2 used .txt for schedule files path = os.path.join( gj.scaffold.loads_path.files_dir, "Resources", "Data", b.dirname, f"{resource_name}.txt", ) self.assertTrue(os.path.exists(path), f"Path not found: {path}")
def setUp(self): self.project_name = 'teaser_district_heating_and_cooling_systems' self.data_dir, self.output_dir = self.set_up( Path(__file__).parent, self.project_name) filename = Path(self.data_dir) / "teaser_geojson_two_loads.json" self.gj = UrbanOptGeoJson(filename) # load system parameter data filename = Path(self.data_dir) / "teaser_system_params_two_loads.json" self.sys_params = SystemParameters(filename)
class GeoJsonModelicaTranslator(object): """ Main class for using the GeoJSON to Modelica Translator. """ def __init__( self, geojson_filepath, sys_params_filepath, root_dir, project_name, ): """Create an instance of this class :param geojson_filepath: str, path to GeoJSON file :param sys_params_filepath: str, path to system parameters file :param root_dir: str, where to create the package :project_name: str, name of the package """ if not Path(geojson_filepath).exists(): raise FileNotFoundError( f'GeoJSON file path does not exist: {geojson_filepath}') if not Path(sys_params_filepath).exists(): raise FileNotFoundError( f'System parameters file path does not exist: {sys_params_filepath}' ) self._system_parameters = SystemParameters(sys_params_filepath) geojson_ids = self._system_parameters.get_default( '$.buildings.custom[*].geojson_id', []) self._geojson = UrbanOptGeoJson(geojson_filepath, geojson_ids) self._root_dir = root_dir self._project_name = project_name self._couplings = _parse_couplings(self._geojson, self._system_parameters) self._coupling_graph = CouplingGraph(self._couplings) self._district = District(self._root_dir, self._project_name, self._system_parameters, self._coupling_graph) self._package_created = False def to_modelica(self): """Generate the modelica package. Call `simulate` method on the result to run the package :return: ModelicaPackage """ self._district.to_modelica() return ModelicaPackage(self._district.district_model_filepath, self._root_dir, self._project_name)
def test_missing_files(self): with self.assertRaises(Exception) as context: output_sys_param_file = self.output_dir / 'going_to_fail_first.json' missing_scenario_dir = self.scenario_dir / 'foobar' SystemParameters.csv_to_sys_param( model_type='time_series', scenario_dir=missing_scenario_dir, feature_file=self.feature_file, sys_param_filename=output_sys_param_file) self.assertIn( f"Unable to find your scenario. The path you provided was: {missing_scenario_dir}", str(context.exception)) with self.assertRaises(Exception) as context: missing_feature_file = self.data_dir / 'sdk_output_skeleton' / 'foobar.json' SystemParameters.csv_to_sys_param( model_type='time_series', scenario_dir=self.scenario_dir, feature_file=missing_feature_file, sys_param_filename=output_sys_param_file) self.assertIn( f"Unable to find your feature file. The path you provided was: {missing_feature_file}", str(context.exception))
def build_sys_param(model_type: str, sys_param_filename: Path, scenario_file: Path, feature_file: Path, overwrite: bool): """ Create system parameters file using uo_sdk output SYS_PARAM_FILENAME: Path/name to sys-param file be created. Be sure to include the ".json" suffix. SCENARIO_FILE: Path to sdk scenario file. FEATURE_FILE: Path to sdk json feature file with data about the buildings. \b MODEL_TYPE: selection for which kind of simulation this sys-param file will support. Valid choices for MODEL_TYPE: "time_series" \f :param model_type: string, selection of which model type to use in the GMT :param sys_param_filename: Path, location & name of json output file to save :param scenario_file: Path, location of SDK scenario_file :param feature_file: Path, location of SDK feature_file :param overwrite: Boolean, flag to overwrite an existing file of the same name/location """ # Use scenario_file to be consistent with sdk scenario_name = Path(scenario_file).stem scenario_dir = Path(scenario_file).parent / 'run' / scenario_name SystemParameters.csv_to_sys_param( model_type=model_type, sys_param_filename=Path(sys_param_filename), scenario_dir=Path(scenario_dir), feature_file=Path(feature_file), overwrite=overwrite ) if Path(sys_param_filename).exists(): print(f"\nSystem parameters file {sys_param_filename} successfully created.") else: raise SystemExit(f"{sys_param_filename} failed. Please check your inputs and try again.")
def __init__( self, geojson_filepath, sys_params_filepath, root_dir, project_name, ): """Create an instance of this class :param geojson_filepath: str, path to GeoJSON file :param sys_params_filepath: str, path to system parameters file :param root_dir: str, where to create the package :project_name: str, name of the package """ if not Path(geojson_filepath).exists(): raise FileNotFoundError( f'GeoJSON file path does not exist: {geojson_filepath}') if not Path(sys_params_filepath).exists(): raise FileNotFoundError( f'System parameters file path does not exist: {sys_params_filepath}' ) self._system_parameters = SystemParameters(sys_params_filepath) geojson_ids = self._system_parameters.get_default( '$.buildings.custom[*].geojson_id', []) self._geojson = UrbanOptGeoJson(geojson_filepath, geojson_ids) self._root_dir = root_dir self._project_name = project_name self._couplings = _parse_couplings(self._geojson, self._system_parameters) self._coupling_graph = CouplingGraph(self._couplings) self._district = District(self._root_dir, self._project_name, self._system_parameters, self._coupling_graph) self._package_created = False
def test_get_param(self): data = { "buildings": { "default": { "load_model": "rc", "load_model_parameters": { "rc": { "order": 4, "mos_weather_filename": "path-to-file", "fraction_latent_person": 1.25, "temp_hw_supply": 40, "temp_setpoint_heating": 40, "temp_setpoint_cooling": 24 } }, } } } sp = SystemParameters.loadd(data) # $.buildings.*[?load_model=spawn].load_model_parameters.spawn.idf_filename value = sp.get_param( "$.buildings.default.load_model_parameters.rc.order") self.assertEqual(value, 4) value = sp.get_param("buildings.default.load_model") self.assertEqual(value, "rc") value = sp.get_param("buildings.default") self.assertDictEqual( value, { "load_model": "rc", "load_model_parameters": { "rc": { "order": 4, "mos_weather_filename": "path-to-file", "fraction_latent_person": 1.25, "temp_hw_supply": 40, "temp_setpoint_heating": 40, "temp_setpoint_cooling": 24 } } }) value = sp.get_param("") self.assertIsNone(value) value = sp.get_param("not.a.real.path") self.assertIsNone(value)
def test_Teaser_heating(self): project_name = 'teaser_district_heating' self.data_dir, self.output_dir = self.set_up(os.path.dirname(__file__), project_name) # load in the example geojson with a single office building filename = os.path.join(self.data_dir, "teaser_geojson_two_loads.json") self.gj = UrbanOptGeoJson(filename) # load system parameter data filename = os.path.join(self.data_dir, "teaser_system_params_two_loads.json") sys_params = SystemParameters(filename) # create network and plant network = Network2Pipe(sys_params) heating_plant = HeatingPlantWithOptionalCHP(sys_params) # create our our load/ets/stubs all_couplings = [Coupling(network, heating_plant)] for geojson_load in self.gj.buildings: teaser_load = Teaser(sys_params, geojson_load) geojson_load_id = geojson_load.feature.properties["id"] heating_indirect_system = HeatingIndirect(sys_params, geojson_load_id) cold_water_stub = EtsColdWaterStub(sys_params) all_couplings.append(Coupling(teaser_load, heating_indirect_system)) all_couplings.append(Coupling(teaser_load, cold_water_stub)) all_couplings.append(Coupling(heating_indirect_system, network)) # create the couplings and graph graph = CouplingGraph(all_couplings) district = District(root_dir=self.output_dir, project_name=project_name, system_parameters=sys_params, coupling_graph=graph) district.to_modelica() root_path = os.path.abspath( os.path.join(district._scaffold.districts_path.files_dir)) self.run_and_assert_in_docker( os.path.join(root_path, 'DistrictEnergySystem.mo'), project_path=district._scaffold.project_path, project_name=district._scaffold.project_name)
def test_district_system(self): project_name = "district_system" self.data_dir, self.output_dir = self.set_up(os.path.dirname(__file__), project_name) # load in the example geojson with a single office building filename = os.path.join(self.data_dir, "time_series_ex1.json") self.gj = UrbanOptGeoJson(filename) # load system parameter data filename = os.path.join(self.data_dir, "time_series_system_params_ets.json") sys_params = SystemParameters(filename) # Create the time series load, ets and their coupling time_series_load = TimeSeries(sys_params, self.gj.buildings[0]) geojson_load_id = self.gj.buildings[0].feature.properties["id"] cooling_indirect_system = CoolingIndirect(sys_params, geojson_load_id) ts_ci_coupling = Coupling(time_series_load, cooling_indirect_system) # create chilled water stub for the ets chilled_water_stub = NetworkChilledWaterStub(sys_params) ci_cw_coupling = Coupling(cooling_indirect_system, chilled_water_stub) # create hot water stub for the load hot_water_stub = EtsHotWaterStub(sys_params) ts_hw_coupling = Coupling(time_series_load, hot_water_stub) graph = CouplingGraph([ ts_ci_coupling, ci_cw_coupling, ts_hw_coupling, ]) district = District(root_dir=self.output_dir, project_name=project_name, system_parameters=sys_params, coupling_graph=graph) district.to_modelica() root_path = os.path.abspath( os.path.join(district._scaffold.districts_path.files_dir)) self.run_and_assert_in_docker( os.path.join(root_path, 'DistrictEnergySystem.mo'), project_path=district._scaffold.project_path, project_name=district._scaffold.project_name)
def test_no_ets_and_run(self): project_name = "time_series_no_ets" self.data_dir, self.output_dir = self.set_up(os.path.dirname(__file__), project_name) # load in the example geojson with a single office building filename = os.path.join(self.data_dir, "time_series_ex1.json") self.gj = UrbanOptGeoJson(filename) # scaffold the project ourselves scaffold = Scaffold(self.output_dir, project_name) scaffold.create() # load system parameter data filename = os.path.join(self.data_dir, "time_series_system_params_no_ets.json") sys_params = SystemParameters(filename) # now test the connector (independent of the larger geojson translator) self.time_series = TimeSeries(sys_params, self.gj.buildings[0]) self.assertIsNotNone(self.time_series) self.assertIsNotNone(self.time_series.building) self.assertEqual( "time_series", self.time_series.system_parameters.get_param("buildings.custom")[0] ["load_model"]) # currently we must setup the root project before we can run to_modelica package = PackageParser.new_from_template(scaffold.project_path, scaffold.project_name, order=[]) package.save() self.time_series.to_modelica(scaffold) root_path = os.path.abspath( os.path.join(scaffold.loads_path.files_dir, 'B5a6b99ec37f4de7f94020090')) files = [ os.path.join(root_path, 'building.mo'), ] # verify that there are only 2 files that matter (coupling and building) for file in files: self.assertTrue(os.path.exists(file), f"File does not exist: {file}")
def test_to_modelica_defaults(self): feature_json_file = self.data_dir / f"{self.project_name}.json" gj = GeoJsonModelicaTranslator.from_geojson(feature_json_file) sys_params_json_file = self.data_dir / 'geojson_8_system_params.json' sys_params = SystemParameters(sys_params_json_file) gj.set_system_parameters(sys_params) gj.process_loads() self.assertEqual(len(gj.loads), 8) all_couplings = [] for geojson_load in gj.json_loads: teaser_load = Teaser(sys_params, geojson_load) hot_stub = EtsHotWaterStub(sys_params) cold_stub = EtsColdWaterStub(sys_params) all_couplings.append(Coupling(teaser_load, hot_stub)) all_couplings.append(Coupling(teaser_load, cold_stub)) graph = CouplingGraph(all_couplings) district = District( root_dir=self.output_dir, project_name=self.project_name, system_parameters=sys_params, coupling_graph=graph ) district.to_modelica() # run a single file to make sure it simulates mr = ModelicaRunner() root_path = os.path.abspath(os.path.join(district._scaffold.districts_path.files_dir)) exitcode = mr.run_in_docker(os.path.join(root_path, 'DistrictEnergySystem.mo'), run_path=Path(district._scaffold.project_path).resolve().parent, project_name=district._scaffold.project_name) self.assertEqual(0, exitcode)
def test_get_param(self): data = { "buildings": { "default": { "load_model": "ROM/RC", "load_model_parameters": { "rc": { "order": 4 } }, } } } sp = SystemParameters.loadd(data) value = sp.get_param( "buildings.default.load_model_parameters.rc.order") self.assertEqual(value, 4) value = sp.get_param("buildings.default.load_model") self.assertEqual(value, "ROM/RC") value = sp.get_param("buildings.default") self.assertDictEqual( value, { "load_model": "ROM/RC", "load_model_parameters": { "rc": { "order": 4 } } }, ) value = sp.get_param("") self.assertIsNone(value) value = sp.get_param("not.a.real.path") self.assertIsNone(value)
def test_chp_system(self): self.project_name = 'heat_with_chp' self.data_dir, self.output_dir = self.set_up( Path(__file__).parent, self.project_name) # load in the example geojson with a single office building filename = Path(self.data_dir) / "time_series_ex1.json" self.gj = self.gj = UrbanOptGeoJson(filename) # load system parameter data filename = Path(self.data_dir) / "time_series_system_params_chp.json" self.sys_params = SystemParameters(filename) # create network and plant network = Network2Pipe(self.sys_params) heating_plant = HeatingPlantWithOptionalCHP(self.sys_params) # create our our load/ets/stubs all_couplings = [Coupling(network, heating_plant)] for geojson_load in self.gj.buildings: time_series_load = TimeSeries(self.sys_params, geojson_load) geojson_load_id = geojson_load.feature.properties["id"] heating_indirect_system = HeatingIndirect(self.sys_params, geojson_load_id) cold_water_stub = EtsColdWaterStub(self.sys_params) all_couplings.append( Coupling(time_series_load, heating_indirect_system)) all_couplings.append(Coupling(time_series_load, cold_water_stub)) all_couplings.append(Coupling(heating_indirect_system, network)) # create the couplings and graph graph = CouplingGraph(all_couplings) district = District(root_dir=self.output_dir, project_name=self.project_name, system_parameters=self.sys_params, coupling_graph=graph) district.to_modelica()
def setUp(self): root_dir, project_name = "tests/model_connectors/output", "spawn_two_building" if os.path.exists(os.path.join(root_dir, project_name)): shutil.rmtree(os.path.join(root_dir, project_name)) # load in the example geojson with a single offie building filename = os.path.abspath( "tests/model_connectors/data/spawn_geojson_ex2.json") self.gj = GeoJsonModelicaTranslator.from_geojson(filename) self.gj.scaffold_directory( root_dir, project_name ) # use the GeoJson translator to scaffold out the directory # load system parameter data filename = os.path.abspath( "tests/model_connectors/data/spawn_system_params_ex2.json") sys_params = SystemParameters(filename) # now test the spawn connector (independent of the larger geojson translator self.spawn = SpawnConnector(sys_params) for b in self.gj.buildings: self.spawn.add_building(b)