11409200998

Committed 18 Oct 2024 06:40PM UTC coverage: 93.048%. Remained the same

Build # 11409200998

Build Type

Pull #33

github

Committed by

mdpiper

Commit Message

Merge branch 'master' into mdpiper/update-examples

Pull Request Pull Request #33: Update examples + check repository health

Run Details

174 of 187 relevant lines covered (93.05%)

0.93 hits per line

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

89.84

/heat/bmi_heat.py

#! /usr/bin/env python
"""Basic Model Interface implementation for the 2D heat model."""

import numpy as np
from bmipy import Bmi

from .heat import Heat


class BmiHeat(Bmi):
    """Solve the heat equation for a 2D plate."""

    _name = "The 2D Heat Equation"
    _input_var_names = ("plate_surface__temperature",)
    _output_var_names = ("plate_surface__temperature",)

    def __init__(self):
        """Create a BmiHeat model that is ready for initialization."""
        self._model = None
        self._values = {}
        self._var_units = {}
        self._var_loc = {}
        self._grids = {}
        self._grid_type = {}

        self._start_time = 0.0
        self._end_time = np.finfo("d").max
        self._time_units = "s"

    def initialize(self, filename=None):
        """Initialize the Heat model.

        Parameters
        ----------
        filename : str, optional
            Path to name of input file.
        """
        if filename is None:
            self._model = Heat()
        elif isinstance(filename, str):
            with open(filename) as file_obj:
                self._model = Heat.from_file_like(file_obj.read())
        else:
            self._model = Heat.from_file_like(filename)

        self._values = {"plate_surface__temperature": self._model.temperature}
        self._var_units = {"plate_surface__temperature": "K"}
        self._var_loc = {"plate_surface__temperature": "node"}
        self._grids = {0: ["plate_surface__temperature"]}
        self._grid_type = {0: "uniform_rectilinear"}

    def update(self):
        """Advance model by one time step."""
        self._model.advance_in_time()

    def update_frac(self, time_frac):
        """Update model by a fraction of a time step.

        Parameters
        ----------
        time_frac : float
            Fraction fo a time step.
        """
        time_step = self.get_time_step()
        self._model.time_step = time_frac * time_step
        self.update()
        self._model.time_step = time_step

    def update_until(self, then):
        """Update model until a particular time.

        Parameters
        ----------
        then : float
            Time to run model until.
        """
        n_steps = (then - self.get_current_time()) / self.get_time_step()

        for _ in range(int(n_steps)):
            self.update()
        self.update_frac(n_steps - int(n_steps))

    def finalize(self):
        """Finalize model."""
        self._model = None

    def get_var_type(self, var_name):
        """Data type of variable.

        Parameters
        ----------
        var_name : str
            Name of variable as CSDMS Standard Name.

        Returns
        -------
        str
            Data type.
        """
        return str(self.get_value_ptr(var_name).dtype)

    def get_var_units(self, var_name):
        """Get units of variable.

        Parameters
        ----------
        var_name : str
            Name of variable as CSDMS Standard Name.

        Returns
        -------
        str
            Variable units.
        """
        return self._var_units[var_name]

    def get_var_nbytes(self, var_name):
        """Get units of variable.

        Parameters
        ----------
        var_name : str
            Name of variable as CSDMS Standard Name.

        Returns
        -------
        int
            Size of data array in bytes.
        """
        return self.get_value_ptr(var_name).nbytes

    def get_var_itemsize(self, name):
        return np.dtype(self.get_var_type(name)).itemsize

    def get_var_location(self, name):
        return self._var_loc[name]

    def get_var_grid(self, var_name):
        """Grid id for a variable.

        Parameters
        ----------
        var_name : str
            Name of variable as CSDMS Standard Name.

        Returns
        -------
        int
            Grid id.
        """
        for grid_id, var_name_list in self._grids.items():
            if var_name in var_name_list:
                return grid_id

    def get_grid_rank(self, grid_id):
        """Rank of grid.

        Parameters
        ----------
        grid_id : int
            Identifier of a grid.

        Returns
        -------
        int
            Rank of grid.
        """
        return len(self._model.shape)

    def get_grid_size(self, grid_id):
        """Size of grid.

        Parameters
        ----------
        grid_id : int
            Identifier of a grid.

        Returns
        -------
        int
            Size of grid.
        """
        return int(np.prod(self._model.shape))

    def get_value_ptr(self, var_name):
        """Reference to values.

        Parameters
        ----------
        var_name : str
            Name of variable as CSDMS Standard Name.

        Returns
        -------
        array_like
            Value array.
        """
        return self._values[var_name]

    def get_value(self, var_name, dest):
        """Copy of values.

        Parameters
        ----------
        var_name : str
            Name of variable as CSDMS Standard Name.
        dest : ndarray
            A numpy array into which to place the values.

        Returns
        -------
        array_like
            Copy of values.
        """
        dest[:] = self.get_value_ptr(var_name).flatten()
        return dest

    def get_value_at_indices(self, var_name, dest, indices):
        """Get values at particular indices.

        Parameters
        ----------
        var_name : str
            Name of variable as CSDMS Standard Name.
        dest : ndarray
            A numpy array into which to place the values.
        indices : array_like
            Array of indices.

        Returns
        -------
        array_like
            Values at indices.
        """
        dest[:] = self.get_value_ptr(var_name).take(indices)
        return dest

    def set_value(self, var_name, src):
        """Set model values.

        Parameters
        ----------
        var_name : str
            Name of variable as CSDMS Standard Name.
        src : array_like
            Array of new values.
        """
        val = self.get_value_ptr(var_name)
        val[:] = src.reshape(val.shape)

    def set_value_at_indices(self, name, inds, src):
        """Set model values at particular indices.

        Parameters
        ----------
        var_name : str
            Name of variable as CSDMS Standard Name.
        src : array_like
            Array of new values.
        indices : array_like
            Array of indices.
        """
        val = self.get_value_ptr(name)
        val.flat[inds] = src

    def get_component_name(self):
        """Name of the component."""
        return self._name

    def get_input_item_count(self):
        """Get names of input variables."""
        return len(self._input_var_names)

    def get_output_item_count(self):
        """Get names of output variables."""
        return len(self._output_var_names)

    def get_input_var_names(self):
        """Get names of input variables."""
        return self._input_var_names

    def get_output_var_names(self):
        """Get names of output variables."""
        return self._output_var_names

    def get_grid_shape(self, grid_id, shape):
        """Number of rows and columns of uniform rectilinear grid."""
        var_name = self._grids[grid_id][0]
        shape[:] = self.get_value_ptr(var_name).shape
        return shape

    def get_grid_spacing(self, grid_id, spacing):
        """Spacing of rows and columns of uniform rectilinear grid."""
        spacing[:] = self._model.spacing
        return spacing

    def get_grid_origin(self, grid_id, origin):
        """Origin of uniform rectilinear grid."""
        origin[:] = self._model.origin
        return origin

    def get_grid_type(self, grid_id):
        """Type of grid."""
        return self._grid_type[grid_id]

    def get_start_time(self):
        """Start time of model."""
        return self._start_time

    def get_end_time(self):
        """End time of model."""
        return self._end_time

    def get_current_time(self):
        return self._model.time

    def get_time_step(self):
        return self._model.time_step

    def get_time_units(self):
        return self._time_units

    def get_grid_edge_count(self, grid):
        raise NotImplementedError("get_grid_edge_count")

    def get_grid_edge_nodes(self, grid, edge_nodes):
        raise NotImplementedError("get_grid_edge_nodes")

    def get_grid_face_count(self, grid):
        raise NotImplementedError("get_grid_face_count")

    def get_grid_face_nodes(self, grid, face_nodes):
        raise NotImplementedError("get_grid_face_nodes")

    def get_grid_node_count(self, grid):
        """Number of grid nodes.

        Parameters
        ----------
        grid : int
            Identifier of a grid.

        Returns
        -------
        int
            Size of grid.
        """
        return self.get_grid_size(grid)

    def get_grid_nodes_per_face(self, grid, nodes_per_face):
        raise NotImplementedError("get_grid_nodes_per_face")

    def get_grid_face_edges(self, grid, face_edges):
        raise NotImplementedError("get_grid_face_edges")

    def get_grid_x(self, grid, x):
        raise NotImplementedError("get_grid_x")

    def get_grid_y(self, grid, y):
        raise NotImplementedError("get_grid_y")

    def get_grid_z(self, grid, z):
        raise NotImplementedError("get_grid_z")

1	#! /usr/bin/env python
2	"""Basic Model Interface implementation for the 2D heat model."""	1✔
3
4	import numpy as np	1✔
5	from bmipy import Bmi	1✔
6
7	from .heat import Heat	1✔
8
9
10	class BmiHeat(Bmi):	1✔
11	"""Solve the heat equation for a 2D plate."""
12
13	_name = "The 2D Heat Equation"	1✔
14	_input_var_names = ("plate_surface__temperature",)	1✔
15	_output_var_names = ("plate_surface__temperature",)	1✔
16
17	def __init__(self):	1✔
18	"""Create a BmiHeat model that is ready for initialization."""
19	self._model = None	1✔
20	self._values = {}	1✔
21	self._var_units = {}	1✔
22	self._var_loc = {}	1✔
23	self._grids = {}	1✔
24	self._grid_type = {}	1✔
25
26	self._start_time = 0.0	1✔
27	self._end_time = np.finfo("d").max	1✔
28	self._time_units = "s"	1✔
29
30	def initialize(self, filename=None):	1✔
31	"""Initialize the Heat model.
32
33	Parameters
34	----------
35	filename : str, optional
36	Path to name of input file.
37	"""
38	if filename is None:	1✔
39	self._model = Heat()	1✔
40	elif isinstance(filename, str):	1✔
41	with open(filename) as file_obj:	1✔
42	self._model = Heat.from_file_like(file_obj.read())	1✔
43	else:
44	self._model = Heat.from_file_like(filename)	1✔
45
46	self._values = {"plate_surface__temperature": self._model.temperature}	1✔
47	self._var_units = {"plate_surface__temperature": "K"}	1✔
48	self._var_loc = {"plate_surface__temperature": "node"}	1✔
49	self._grids = {0: ["plate_surface__temperature"]}	1✔
50	self._grid_type = {0: "uniform_rectilinear"}	1✔
51
52	def update(self):	1✔
53	"""Advance model by one time step."""
54	self._model.advance_in_time()	1✔
55
56	def update_frac(self, time_frac):	1✔
57	"""Update model by a fraction of a time step.
58
59	Parameters
60	----------
61	time_frac : float
62	Fraction fo a time step.
63	"""
64	time_step = self.get_time_step()	1✔
65	self._model.time_step = time_frac * time_step	1✔
66	self.update()	1✔
67	self._model.time_step = time_step	1✔
68
69	def update_until(self, then):	1✔
70	"""Update model until a particular time.
71
72	Parameters
73	----------
74	then : float
75	Time to run model until.
76	"""
77	n_steps = (then - self.get_current_time()) / self.get_time_step()	1✔
78
79	for _ in range(int(n_steps)):	1✔
80	self.update()	1✔
81	self.update_frac(n_steps - int(n_steps))	1✔
82
83	def finalize(self):	1✔
84	"""Finalize model."""
85	self._model = None	1✔
86
87	def get_var_type(self, var_name):	1✔
88	"""Data type of variable.
89
90	Parameters
91	----------
92	var_name : str
93	Name of variable as CSDMS Standard Name.
94
95	Returns
96	-------
97	str
98	Data type.
99	"""
100	return str(self.get_value_ptr(var_name).dtype)	1✔
101
102	def get_var_units(self, var_name):	1✔
103	"""Get units of variable.
104
105	Parameters
106	----------
107	var_name : str
108	Name of variable as CSDMS Standard Name.
109
110	Returns
111	-------
112	str
113	Variable units.
114	"""
115	return self._var_units[var_name]	1✔
116
117	def get_var_nbytes(self, var_name):	1✔
118	"""Get units of variable.
119
120	Parameters
121	----------
122	var_name : str
123	Name of variable as CSDMS Standard Name.
124
125	Returns
126	-------
127	int
128	Size of data array in bytes.
129	"""
130	return self.get_value_ptr(var_name).nbytes	1✔
131
132	def get_var_itemsize(self, name):	1✔
133	return np.dtype(self.get_var_type(name)).itemsize	×
134
135	def get_var_location(self, name):	1✔
136	return self._var_loc[name]	×
137
138	def get_var_grid(self, var_name):	1✔
139	"""Grid id for a variable.
140
141	Parameters
142	----------
143	var_name : str
144	Name of variable as CSDMS Standard Name.
145
146	Returns
147	-------
148	int
149	Grid id.
150	"""
151	for grid_id, var_name_list in self._grids.items():	1✔
152	if var_name in var_name_list:	1✔
153	return grid_id	1✔
154
155	def get_grid_rank(self, grid_id):	1✔
156	"""Rank of grid.
157
158	Parameters
159	----------
160	grid_id : int
161	Identifier of a grid.
162
163	Returns
164	-------
165	int
166	Rank of grid.
167	"""
168	return len(self._model.shape)	1✔
169
170	def get_grid_size(self, grid_id):	1✔
171	"""Size of grid.
172
173	Parameters
174	----------
175	grid_id : int
176	Identifier of a grid.
177
178	Returns
179	-------
180	int
181	Size of grid.
182	"""
183	return int(np.prod(self._model.shape))	1✔
184
185	def get_value_ptr(self, var_name):	1✔
186	"""Reference to values.
187
188	Parameters
189	----------
190	var_name : str
191	Name of variable as CSDMS Standard Name.
192
193	Returns
194	-------
195	array_like
196	Value array.
197	"""
198	return self._values[var_name]	1✔
199
200	def get_value(self, var_name, dest):	1✔
201	"""Copy of values.
202
203	Parameters
204	----------
205	var_name : str
206	Name of variable as CSDMS Standard Name.
207	dest : ndarray
208	A numpy array into which to place the values.
209
210	Returns
211	-------
212	array_like
213	Copy of values.
214	"""
215	dest[:] = self.get_value_ptr(var_name).flatten()	1✔
216	return dest	1✔
217
218	def get_value_at_indices(self, var_name, dest, indices):	1✔
219	"""Get values at particular indices.
220
221	Parameters
222	----------
223	var_name : str
224	Name of variable as CSDMS Standard Name.
225	dest : ndarray
226	A numpy array into which to place the values.
227	indices : array_like
228	Array of indices.
229
230	Returns
231	-------
232	array_like
233	Values at indices.
234	"""
235	dest[:] = self.get_value_ptr(var_name).take(indices)	1✔
236	return dest	1✔
237
238	def set_value(self, var_name, src):	1✔
239	"""Set model values.
240
241	Parameters
242	----------
243	var_name : str
244	Name of variable as CSDMS Standard Name.
245	src : array_like
246	Array of new values.
247	"""
248	val = self.get_value_ptr(var_name)	1✔
249	val[:] = src.reshape(val.shape)	1✔
250
251	def set_value_at_indices(self, name, inds, src):	1✔
252	"""Set model values at particular indices.
253
254	Parameters
255	----------
256	var_name : str
257	Name of variable as CSDMS Standard Name.
258	src : array_like
259	Array of new values.
260	indices : array_like
261	Array of indices.
262	"""
263	val = self.get_value_ptr(name)	1✔
264	val.flat[inds] = src	1✔
265
266	def get_component_name(self):	1✔
267	"""Name of the component."""
268	return self._name	1✔
269
270	def get_input_item_count(self):	1✔
271	"""Get names of input variables."""
272	return len(self._input_var_names)	1✔
273
274	def get_output_item_count(self):	1✔
275	"""Get names of output variables."""
276	return len(self._output_var_names)	1✔
277
278	def get_input_var_names(self):	1✔
279	"""Get names of input variables."""
280	return self._input_var_names	1✔
281
282	def get_output_var_names(self):	1✔
283	"""Get names of output variables."""
284	return self._output_var_names	1✔
285
286	def get_grid_shape(self, grid_id, shape):	1✔
287	"""Number of rows and columns of uniform rectilinear grid."""
288	var_name = self._grids[grid_id][0]	1✔
289	shape[:] = self.get_value_ptr(var_name).shape	1✔
290	return shape	1✔
291
292	def get_grid_spacing(self, grid_id, spacing):	1✔
293	"""Spacing of rows and columns of uniform rectilinear grid."""
294	spacing[:] = self._model.spacing	1✔
295	return spacing	1✔
296
297	def get_grid_origin(self, grid_id, origin):	1✔
298	"""Origin of uniform rectilinear grid."""
299	origin[:] = self._model.origin	1✔
300	return origin	1✔
301
302	def get_grid_type(self, grid_id):	1✔
303	"""Type of grid."""
304	return self._grid_type[grid_id]	1✔
305
306	def get_start_time(self):	1✔
307	"""Start time of model."""
308	return self._start_time	1✔
309
310	def get_end_time(self):	1✔
311	"""End time of model."""
312	return self._end_time	1✔
313
314	def get_current_time(self):	1✔
315	return self._model.time	1✔
316
317	def get_time_step(self):	1✔
318	return self._model.time_step	1✔
319
320	def get_time_units(self):	1✔
321	return self._time_units	×
322
323	def get_grid_edge_count(self, grid):	1✔
324	raise NotImplementedError("get_grid_edge_count")	×
325
326	def get_grid_edge_nodes(self, grid, edge_nodes):	1✔
327	raise NotImplementedError("get_grid_edge_nodes")	×
328
329	def get_grid_face_count(self, grid):	1✔
330	raise NotImplementedError("get_grid_face_count")	×
331
332	def get_grid_face_nodes(self, grid, face_nodes):	1✔
333	raise NotImplementedError("get_grid_face_nodes")	×
334
335	def get_grid_node_count(self, grid):	1✔
336	"""Number of grid nodes.
337
338	Parameters
339	----------
340	grid : int
341	Identifier of a grid.
342
343	Returns
344	-------
345	int
346	Size of grid.
347	"""
348	return self.get_grid_size(grid)	×
349
350	def get_grid_nodes_per_face(self, grid, nodes_per_face):	1✔
351	raise NotImplementedError("get_grid_nodes_per_face")	×
352
353	def get_grid_face_edges(self, grid, face_edges):	1✔
354	raise NotImplementedError("get_grid_face_edges")	×
355
356	def get_grid_x(self, grid, x):	1✔
357	raise NotImplementedError("get_grid_x")	×
358
359	def get_grid_y(self, grid, y):	1✔
360	raise NotImplementedError("get_grid_y")	×
361
362	def get_grid_z(self, grid, z):	1✔
363	raise NotImplementedError("get_grid_z")	×

csdms / bmi-example-python / 11409200998

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