11859388015

Committed 15 Nov 2024 03:56PM UTC coverage: 88.158% (-0.1%) from 88.298%

Build # 11859388015

Build Type

Pull #648

github

Committed by

vtnate

Commit Message

regenerate dependency lock file

Pull Request Pull Request #648: Update code & dependencies to address deprecation warnings

Run Details

1045 of 1269 branches covered (82.35%)

Branch coverage included in aggregate %.

10 of 14 new or added lines in 6 files covered. (71.43%)

1 existing line in 1 file now uncovered.

2841 of 3139 relevant lines covered (90.51%)

1.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.52

/geojson_modelica_translator/geojson_modelica_translator.py

# :copyright (c) URBANopt, Alliance for Sustainable Energy, LLC, and other contributors.
# See also https://github.com/urbanopt/geojson-modelica-translator/blob/develop/LICENSE.md

import logging
from pathlib import Path

from geojson_modelica_translator.external_package_utils import load_loop_order
from geojson_modelica_translator.geojson.urbanopt_geojson import UrbanOptGeoJson
from geojson_modelica_translator.model_connectors.couplings import Coupling, CouplingGraph
from geojson_modelica_translator.model_connectors.districts import District
from geojson_modelica_translator.model_connectors.energy_transfer_systems import CoolingIndirect, HeatingIndirect
from geojson_modelica_translator.model_connectors.load_connectors import Spawn, Teaser, TimeSeries, TimeSeriesMFT
from geojson_modelica_translator.model_connectors.networks import Network2Pipe
from geojson_modelica_translator.model_connectors.networks.design_data_series import DesignDataSeries
from geojson_modelica_translator.model_connectors.networks.ground_coupling import GroundCoupling
from geojson_modelica_translator.model_connectors.networks.network_distribution_pump import NetworkDistributionPump
from geojson_modelica_translator.model_connectors.networks.unidirectional_series import UnidirectionalSeries
from geojson_modelica_translator.model_connectors.plants import CoolingPlant
from geojson_modelica_translator.model_connectors.plants.borefield import Borefield
from geojson_modelica_translator.model_connectors.plants.chp import HeatingPlantWithOptionalCHP
from geojson_modelica_translator.modelica.modelica_runner import ModelicaRunner
from geojson_modelica_translator.system_parameters.system_parameters import SystemParameters

_log = logging.getLogger(__name__)


# map the system parameter "load_model" to Python class
LOAD_MODEL_TO_CLASS = {
    "spawn": Spawn,
    "rc": Teaser,
    "time_series": TimeSeries,
    "time_series_massflow_temperature": TimeSeriesMFT,
}


def _parse_couplings(geojson, sys_params, sys_param_district_type):
    """Given config files, construct the necessary models and their couplings which
    can then be passed to CouplingGraph.

    :param geojson: UrbanOptGeoJson
    :param sys_params: SystemParameters
    :param sys_param_district_type: str - type of district ["fourth_generation", "fifth_generation"]
    :return: list[Coupling], list of couplings to be passed to CouplingGraph
    """
    # 4G implementation assumes that all generated district energy system models will have:
    #   - one heating plant
    #   - one cooling plant
    #   - one heating distribution network
    #   - one cooling distribution network
    #   - one heating and cooling ETS per load
    # NOTE: loads can be of any type/combination
    all_couplings = []

    if sys_param_district_type == "fourth_generation":
        # create the plants and networks
        cooling_network = Network2Pipe(sys_params)
        cooling_plant = CoolingPlant(sys_params)
        heating_network = Network2Pipe(sys_params)
        heating_plant = HeatingPlantWithOptionalCHP(sys_params)
        all_couplings += [
            Coupling(cooling_plant, cooling_network),
            Coupling(heating_plant, heating_network),
        ]
    elif sys_param_district_type == "fifth_generation":
        # create ambient water stub
        ambient_water_stub = NetworkDistributionPump(sys_params)
        # create district data
        design_data = DesignDataSeries(sys_params)
        # import loo order
        loop_order = load_loop_order(sys_params.filename)

        if sys_params.get_param("$.district_system.fifth_generation.ghe_parameters"):
            # create ground coupling
            ground_coupling = GroundCoupling(sys_params)
            for loop in loop_order:
                ghe_id = loop["list_ghe_ids_in_group"][0]
                for ghe in sys_params.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.ghe_specific_params"
                ):
                    if ghe_id == ghe["ghe_id"]:
                        borefield = Borefield(sys_params, ghe)
                distribution = UnidirectionalSeries(sys_params)
                for bldg_id in loop["list_bldg_ids_in_group"]:
                    for geojson_load in geojson.buildings:
                        if bldg_id == geojson_load.id:
                            # create the building time series load
                            time_series_load = TimeSeries(sys_params, geojson_load)
                            # couple each time series load to distribution
                            all_couplings.append(
                                Coupling(time_series_load, distribution, district_type="fifth_generation")
                            )
                            all_couplings.append(
                                Coupling(time_series_load, ambient_water_stub, district_type="fifth_generation")
                            )
                            all_couplings.append(
                                Coupling(time_series_load, design_data, district_type="fifth_generation")
                            )
                # couple each borefield and distribution
                all_couplings.append(Coupling(distribution, borefield, district_type="fifth_generation"))
                # couple distribution and ground coupling
                all_couplings.append(Coupling(distribution, ground_coupling, district_type="fifth_generation"))
                # empty couple between borefield and ground
                all_couplings.append(Coupling(ground_coupling, borefield, district_type="fifth_generation"))
            all_couplings.append(Coupling(ambient_water_stub, ambient_water_stub, district_type="fifth_generation"))
        else:
            pass  # Create waste heat components & couplings

    # create the loads and their ETSes
    for building in geojson.buildings:
        load_model_type = sys_params.get_param_by_id(building.id, "load_model")
        load_class = LOAD_MODEL_TO_CLASS[load_model_type]
        load = load_class(sys_params, building)

        if sys_param_district_type is None or sys_param_district_type == "fourth_generation":
            cooling_indirect = CoolingIndirect(sys_params, building.id)
            all_couplings.append(Coupling(load, cooling_indirect))
            all_couplings.append(Coupling(cooling_indirect, cooling_network))

            heating_indirect = HeatingIndirect(sys_params, building.id)
            all_couplings.append(Coupling(load, heating_indirect))
            all_couplings.append(Coupling(heating_indirect, heating_network))

    return all_couplings


class ModelicaPackage:
    """Represents a modelica package which can be simulated"""

    def __init__(self, project_path, project_name):
        self._project_path = project_path
        self._project_name = project_name

    def simulate(self):
        """Simulate the package.

        :return: tuple(bool, pathlib.Path), True or False depending on simulation success
            followed by the path to the results directory
        """
        _log.debug(f"Model name: {self._project_name}.Districts.DistrictEnergySystem")
        _log.debug(f"file to load: {self._project_path / self._project_name / 'package.mo'}")
        _log.debug(f"run path: {self._project_path / self._project_name}")

        modelica_runner = ModelicaRunner()
        return modelica_runner.run_in_docker(
            action="compile_and_run",
            model_name=f"{self._project_name}.Districts.DistrictEnergySystem",
            file_to_load=self._project_path / self._project_name / "package.mo",
            run_path=self._project_path / self._project_name,
        )


class GeoJsonModelicaTranslator:
    """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_param("$.buildings.[*].geojson_id")
        self._geojson = UrbanOptGeoJson(geojson_filepath, geojson_ids)

        # Use different couplings for each district system type
        # The first key of district_system is always the district system type
        sys_param_district_type = next(iter(self._system_parameters.get_param("district_system")))
        self._couplings = _parse_couplings(self._geojson, self._system_parameters, sys_param_district_type)

        self._root_dir = root_dir
        self._project_name = project_name
        self._coupling_graph = CouplingGraph(self._couplings)
        if sys_param_district_type == "fifth_generation":
            self._district = District(
                self._root_dir, self._project_name, self._system_parameters, self._coupling_graph, self._geojson
            )
        else:
            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._root_dir, self._project_name)

1	# :copyright (c) URBANopt, Alliance for Sustainable Energy, LLC, and other contributors.
2	# See also https://github.com/urbanopt/geojson-modelica-translator/blob/develop/LICENSE.md
3
4	import logging	2✔
5	from pathlib import Path	2✔
6
7	from geojson_modelica_translator.external_package_utils import load_loop_order	2✔
8	from geojson_modelica_translator.geojson.urbanopt_geojson import UrbanOptGeoJson	2✔
9	from geojson_modelica_translator.model_connectors.couplings import Coupling, CouplingGraph	2✔
10	from geojson_modelica_translator.model_connectors.districts import District	2✔
11	from geojson_modelica_translator.model_connectors.energy_transfer_systems import CoolingIndirect, HeatingIndirect	2✔
12	from geojson_modelica_translator.model_connectors.load_connectors import Spawn, Teaser, TimeSeries, TimeSeriesMFT	2✔
13	from geojson_modelica_translator.model_connectors.networks import Network2Pipe	2✔
14	from geojson_modelica_translator.model_connectors.networks.design_data_series import DesignDataSeries	2✔
15	from geojson_modelica_translator.model_connectors.networks.ground_coupling import GroundCoupling	2✔
16	from geojson_modelica_translator.model_connectors.networks.network_distribution_pump import NetworkDistributionPump	2✔
17	from geojson_modelica_translator.model_connectors.networks.unidirectional_series import UnidirectionalSeries	2✔
18	from geojson_modelica_translator.model_connectors.plants import CoolingPlant	2✔
19	from geojson_modelica_translator.model_connectors.plants.borefield import Borefield	2✔
20	from geojson_modelica_translator.model_connectors.plants.chp import HeatingPlantWithOptionalCHP	2✔
21	from geojson_modelica_translator.modelica.modelica_runner import ModelicaRunner	2✔
22	from geojson_modelica_translator.system_parameters.system_parameters import SystemParameters	2✔
23
24	_log = logging.getLogger(__name__)	2✔
25
26
27	# map the system parameter "load_model" to Python class
28	LOAD_MODEL_TO_CLASS = {	2✔
29	"spawn": Spawn,
30	"rc": Teaser,
31	"time_series": TimeSeries,
32	"time_series_massflow_temperature": TimeSeriesMFT,
33	}
34
35
36	def _parse_couplings(geojson, sys_params, sys_param_district_type):	2✔
37	"""Given config files, construct the necessary models and their couplings which
38	can then be passed to CouplingGraph.
39
40	:param geojson: UrbanOptGeoJson
41	:param sys_params: SystemParameters
42	:param sys_param_district_type: str - type of district ["fourth_generation", "fifth_generation"]
43	:return: list[Coupling], list of couplings to be passed to CouplingGraph
44	"""
45	# 4G implementation assumes that all generated district energy system models will have:
46	# - one heating plant
47	# - one cooling plant
48	# - one heating distribution network
49	# - one cooling distribution network
50	# - one heating and cooling ETS per load
51	# NOTE: loads can be of any type/combination
52	all_couplings = []	2✔
53
54	if sys_param_district_type == "fourth_generation":	2✔
55	# create the plants and networks
56	cooling_network = Network2Pipe(sys_params)	2✔
57	cooling_plant = CoolingPlant(sys_params)	2✔
58	heating_network = Network2Pipe(sys_params)	2✔
59	heating_plant = HeatingPlantWithOptionalCHP(sys_params)	2✔
60	all_couplings += [	2✔
61	Coupling(cooling_plant, cooling_network),
62	Coupling(heating_plant, heating_network),
63	]
64	elif sys_param_district_type == "fifth_generation":	2!
65	# create ambient water stub
66	ambient_water_stub = NetworkDistributionPump(sys_params)	2✔
67	# create district data
68	design_data = DesignDataSeries(sys_params)	2✔
69	# import loo order
70	loop_order = load_loop_order(sys_params.filename)	2✔
71
72	if sys_params.get_param("$.district_system.fifth_generation.ghe_parameters"):	2!
73	# create ground coupling
74	ground_coupling = GroundCoupling(sys_params)	2✔
75	for loop in loop_order:	2✔
76	ghe_id = loop["list_ghe_ids_in_group"][0]	2✔
77	for ghe in sys_params.get_param(	2✔
78	"$.district_system.fifth_generation.ghe_parameters.ghe_specific_params"
79	):
80	if ghe_id == ghe["ghe_id"]:	2!
81	borefield = Borefield(sys_params, ghe)	2✔
82	distribution = UnidirectionalSeries(sys_params)	2✔
83	for bldg_id in loop["list_bldg_ids_in_group"]:	2✔
84	for geojson_load in geojson.buildings:	2✔
85	if bldg_id == geojson_load.id:	2✔
86	# create the building time series load
87	time_series_load = TimeSeries(sys_params, geojson_load)	2✔
88	# couple each time series load to distribution
89	all_couplings.append(	2✔
90	Coupling(time_series_load, distribution, district_type="fifth_generation")
91	)
92	all_couplings.append(	2✔
93	Coupling(time_series_load, ambient_water_stub, district_type="fifth_generation")
94	)
95	all_couplings.append(	2✔
96	Coupling(time_series_load, design_data, district_type="fifth_generation")
97	)
98	# couple each borefield and distribution
99	all_couplings.append(Coupling(distribution, borefield, district_type="fifth_generation"))	2✔
100	# couple distribution and ground coupling
101	all_couplings.append(Coupling(distribution, ground_coupling, district_type="fifth_generation"))	2✔
102	# empty couple between borefield and ground
103	all_couplings.append(Coupling(ground_coupling, borefield, district_type="fifth_generation"))	2✔
104	all_couplings.append(Coupling(ambient_water_stub, ambient_water_stub, district_type="fifth_generation"))	2✔
105	else:
106	pass # Create waste heat components & couplings	×
107
108	# create the loads and their ETSes
109	for building in geojson.buildings:	2✔
110	load_model_type = sys_params.get_param_by_id(building.id, "load_model")	2✔
111	load_class = LOAD_MODEL_TO_CLASS[load_model_type]	2✔
112	load = load_class(sys_params, building)	2✔
113
114	if sys_param_district_type is None or sys_param_district_type == "fourth_generation":	2✔
115	cooling_indirect = CoolingIndirect(sys_params, building.id)	2✔
116	all_couplings.append(Coupling(load, cooling_indirect))	2✔
117	all_couplings.append(Coupling(cooling_indirect, cooling_network))	2✔
118
119	heating_indirect = HeatingIndirect(sys_params, building.id)	2✔
120	all_couplings.append(Coupling(load, heating_indirect))	2✔
121	all_couplings.append(Coupling(heating_indirect, heating_network))	2✔
122
123	return all_couplings	2✔
124
125
126	class ModelicaPackage:	2✔
127	"""Represents a modelica package which can be simulated"""
128
129	def __init__(self, project_path, project_name):	2✔
130	self._project_path = project_path	2✔
131	self._project_name = project_name	2✔
132
133	def simulate(self):	2✔
134	"""Simulate the package.
135
136	:return: tuple(bool, pathlib.Path), True or False depending on simulation success
137	followed by the path to the results directory
138	"""
NEW 139	_log.debug(f"Model name: {self._project_name}.Districts.DistrictEnergySystem")	×
NEW 140	_log.debug(f"file to load: {self._project_path / self._project_name / 'package.mo'}")	×
NEW 141	_log.debug(f"run path: {self._project_path / self._project_name}")	×
142
143	modelica_runner = ModelicaRunner()	×
144	return modelica_runner.run_in_docker(	×
145	action="compile_and_run",
146	model_name=f"{self._project_name}.Districts.DistrictEnergySystem",
147	file_to_load=self._project_path / self._project_name / "package.mo",
148	run_path=self._project_path / self._project_name,
149	)
150
151
152	class GeoJsonModelicaTranslator:	2✔
153	"""Main class for using the GeoJSON to Modelica Translator."""
154
155	def __init__(	2✔
156	self,
157	geojson_filepath,
158	sys_params_filepath,
159	root_dir,
160	project_name,
161	):
162	"""Create an instance of this class
163
164	:param geojson_filepath: str, path to GeoJSON file
165	:param sys_params_filepath: str, path to system parameters file
166	:param root_dir: str, where to create the package
167	:project_name: str, name of the package
168	"""
169	if not Path(geojson_filepath).exists():	2!
170	raise FileNotFoundError(f"GeoJSON file path does not exist: {geojson_filepath}")	×
171	if not Path(sys_params_filepath).exists():	2!
172	raise FileNotFoundError(f"System parameters file path does not exist: {sys_params_filepath}")	×
173
174	self._system_parameters = SystemParameters(sys_params_filepath)	2✔
175
176	geojson_ids = self._system_parameters.get_param("$.buildings.[*].geojson_id")	2✔
177	self._geojson = UrbanOptGeoJson(geojson_filepath, geojson_ids)	2✔
178
179	# Use different couplings for each district system type
180	# The first key of district_system is always the district system type
181	sys_param_district_type = next(iter(self._system_parameters.get_param("district_system")))	2✔
182	self._couplings = _parse_couplings(self._geojson, self._system_parameters, sys_param_district_type)	2✔
183
184	self._root_dir = root_dir	2✔
185	self._project_name = project_name	2✔
186	self._coupling_graph = CouplingGraph(self._couplings)	2✔
187	if sys_param_district_type == "fifth_generation":	2✔
188	self._district = District(	2✔
189	self._root_dir, self._project_name, self._system_parameters, self._coupling_graph, self._geojson
190	)
191	else:
192	self._district = District(self._root_dir, self._project_name, self._system_parameters, self._coupling_graph)	2✔
193	self._package_created = False	2✔
194
195	def to_modelica(self):	2✔
196	"""Generate the modelica package. Call `simulate` method on the result
197	to run the package
198
199	:return: ModelicaPackage
200	"""
201	self._district.to_modelica()	2✔
202
203	return ModelicaPackage(self._root_dir, self._project_name)	2✔

urbanopt / geojson-modelica-translator / 11859388015

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous