11407919893

Committed 18 Oct 2024 05:05PM UTC coverage: 93.048%. First build

Build # 11407919893

Build Type

push

github

Committed by

mcflugen

Commit Message

rename tests with _test suffix

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

csdms / bmi-example-python / 11407919893

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