16366577751

Committed 18 Jul 2025 08:59AM UTC coverage: 85.115% (-0.1%) from 85.251%

Build # 16366577751

Build Type

Pull #3420

github

Committed by

web-flow

Commit Message

Merge 486047f9a into 659e43af7

Pull Request Pull Request #3420: Adding material depletion function

Run Details

28 of 28 new or added lines in 1 file covered. (100.0%)

437 existing lines in 24 files now uncovered.

52652 of 61860 relevant lines covered (85.11%)

36277994.88 hits per line

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

75.59

/openmc/lib/plot.py

from ctypes import (c_bool, c_int, c_size_t, c_int32,
                    c_double, Structure, POINTER)

from . import _dll
from .error import _error_handler

import numpy as np


class _Position(Structure):
    """Definition of an xyz location in space with underlying c-types

    C-type Attributes
    -----------------
    x : c_double
        Position's x value (default: 0.0)
    y : c_double
        Position's y value (default: 0.0)
    z : c_double
        Position's z value (default: 0.0)
    """
    _fields_ = [('x', c_double),
                ('y', c_double),
                ('z', c_double)]

    def __getitem__(self, idx):
        if idx == 0:
            return self.x
        elif idx == 1:
            return self.y
        elif idx == 2:
            return self.z
        else:
            raise IndexError(f"{idx} index is invalid for _Position")

    def __setitem__(self, idx, val):
        if idx == 0:
            self.x = val
        elif idx == 1:
            self.y = val
        elif idx == 2:
            self.z = val
        else:
            raise IndexError(f"{idx} index is invalid for _Position")

    def __repr__(self):
        return f"({self.x}, {self.y}, {self.z})"


class _PlotBase(Structure):
    """A structure defining a 2-D geometry slice with underlying c-types

    C-Type Attributes
    -----------------
    origin : openmc.lib.plot._Position
        A position defining the origin of the plot.
    width_ : openmc.lib.plot._Position
        The width of the plot along the x, y, and z axes, respectively
    basis_ : c_int
        The axes basis of the plot view.
    pixels_ : c_size_t[3]
        The resolution of the plot in the horizontal and vertical dimensions
    level_ : c_int
        The universe level for the plot view

    Attributes
    ----------
    origin : tuple or list of ndarray
        Origin (center) of the plot
    width : float
        The horizontal dimension of the plot in geometry units (cm)
    height : float
        The vertical dimension of the plot in geometry units (cm)
    basis : string
        One of {'xy', 'xz', 'yz'} indicating the horizontal and vertical
        axes of the plot.
    h_res : int
        The horizontal resolution of the plot in pixels
    v_res : int
        The vertical resolution of the plot in pixels
    level : int
        The universe level for the plot (default: -1 -> all universes shown)
    """
    _fields_ = [('origin_', _Position),
                ('width_', _Position),
                ('basis_', c_int),
                ('pixels_', 3*c_size_t),
                ('color_overlaps_', c_bool),
                ('level_', c_int)]

    def __init__(self):
        self.level_ = -1
        self.basis_ = 1
        self.color_overlaps_ = False

    @property
    def origin(self):
        return self.origin_

    @origin.setter
    def origin(self, origin):
        self.origin_.x = origin[0]
        self.origin_.y = origin[1]
        self.origin_.z = origin[2]

    @property
    def width(self):
        return self.width_.x

    @width.setter
    def width(self, width):
        self.width_.x = width

    @property
    def height(self):
        return self.width_.y

    @height.setter
    def height(self, height):
        self.width_.y = height

    @property
    def basis(self):
        if self.basis_ == 1:
            return 'xy'
        elif self.basis_ == 2:
            return 'xz'
        elif self.basis_ == 3:
            return 'yz'

        raise ValueError(f"Plot basis {self.basis_} is invalid")

    @basis.setter
    def basis(self, basis):
        if isinstance(basis, str):
            valid_bases = ('xy', 'xz', 'yz')
            basis = basis.lower()
            if basis not in valid_bases:
                raise ValueError(f"{basis} is not a valid plot basis.")

            if basis == 'xy':
                self.basis_ = 1
            elif basis == 'xz':
                self.basis_ = 2
            elif basis == 'yz':
                self.basis_ = 3
            return

        if isinstance(basis, int):
            valid_bases = (1, 2, 3)
            if basis not in valid_bases:
                raise ValueError(f"{basis} is not a valid plot basis.")
            self.basis_ = basis
            return

        raise ValueError(f"{basis} of type {type(basis)} is an invalid plot basis")

    @property
    def h_res(self):
        return self.pixels_[0]

    @h_res.setter
    def h_res(self, h_res):
        self.pixels_[0] = h_res

    @property
    def v_res(self):
        return self.pixels_[1]

    @v_res.setter
    def v_res(self, v_res):
        self.pixels_[1] = v_res

    @property
    def level(self):
        return int(self.level_)

    @level.setter
    def level(self, level):
        self.level_ = level

    @property
    def color_overlaps(self):
        return self.color_overlaps_

    @color_overlaps.setter
    def color_overlaps(self, color_overlaps):
        self.color_overlaps_ = color_overlaps

    @property
    def color_overlaps(self):
        return self.color_overlaps_

    @color_overlaps.setter
    def color_overlaps(self, val):
        self.color_overlaps_ = val

    def __repr__(self):
        out_str = ["-----",
                   "Plot:",
                   "-----",
                   f"Origin: {self.origin}",
                   f"Width: {self.width}",
                   f"Height: {self.height}",
                   f"Basis: {self.basis}",
                   f"HRes: {self.h_res}",
                   f"VRes: {self.v_res}",
                   f"Color Overlaps: {self.color_overlaps}",
                   f"Level: {self.level}"]
        return '\n'.join(out_str)


_dll.openmc_id_map.argtypes = [POINTER(_PlotBase), POINTER(c_int32)]
_dll.openmc_id_map.restype = c_int
_dll.openmc_id_map.errcheck = _error_handler


def id_map(plot):
    """
    Generate a 2-D map of cell and material IDs. Used for in-memory image
    generation.

    Parameters
    ----------
    plot : openmc.lib.plot._PlotBase
        Object describing the slice of the model to be generated

    Returns
    -------
    id_map : numpy.ndarray
        A NumPy array with shape (vertical pixels, horizontal pixels, 3) of
        OpenMC property ids with dtype int32. The last dimension of the array
        contains, in order, cell IDs, cell instances, and material IDs.

    """
    img_data = np.zeros((plot.v_res, plot.h_res, 3),
                        dtype=np.dtype('int32'))
    _dll.openmc_id_map(plot, img_data.ctypes.data_as(POINTER(c_int32)))
    return img_data


_dll.openmc_property_map.argtypes = [POINTER(_PlotBase), POINTER(c_double)]
_dll.openmc_property_map.restype = c_int
_dll.openmc_property_map.errcheck = _error_handler


def property_map(plot):
    """
    Generate a 2-D map of cell temperatures and material densities. Used for
    in-memory image generation.

    Parameters
    ----------
    plot : openmc.lib.plot._PlotBase
        Object describing the slice of the model to be generated

    Returns
    -------
    property_map : numpy.ndarray
        A NumPy array with shape (vertical pixels, horizontal pixels, 2) of
        OpenMC property ids with dtype float

    """
    prop_data = np.zeros((plot.v_res, plot.h_res, 2))
    _dll.openmc_property_map(plot, prop_data.ctypes.data_as(POINTER(c_double)))
    return prop_data

1	from ctypes import (c_bool, c_int, c_size_t, c_int32,	11✔
2	c_double, Structure, POINTER)
3
4	from . import _dll	11✔
5	from .error import _error_handler	11✔
6
7	import numpy as np	11✔
8
9
10	class _Position(Structure):	11✔
11	"""Definition of an xyz location in space with underlying c-types
12
13	C-type Attributes
14	-----------------
15	x : c_double
16	Position's x value (default: 0.0)
17	y : c_double
18	Position's y value (default: 0.0)
19	z : c_double
20	Position's z value (default: 0.0)
21	"""
22	_fields_ = [('x', c_double),	11✔
23	('y', c_double),
24	('z', c_double)]
25
26	def __getitem__(self, idx):	11✔
27	if idx == 0:	11✔
28	return self.x	11✔
29	elif idx == 1:	11✔
30	return self.y	11✔
31	elif idx == 2:	11✔
32	return self.z	11✔
33	else:
34	raise IndexError(f"{idx} index is invalid for _Position")	11✔
35
36	def __setitem__(self, idx, val):	11✔
37	if idx == 0:	11✔
38	self.x = val	11✔
39	elif idx == 1:	11✔
40	self.y = val	11✔
41	elif idx == 2:	11✔
42	self.z = val	11✔
43	else:
44	raise IndexError(f"{idx} index is invalid for _Position")	×
45
46	def __repr__(self):	11✔
47	return f"({self.x}, {self.y}, {self.z})"	×
48
49
50	class _PlotBase(Structure):	11✔
51	"""A structure defining a 2-D geometry slice with underlying c-types
52
53	C-Type Attributes
54	-----------------
55	origin : openmc.lib.plot._Position
56	A position defining the origin of the plot.
57	width_ : openmc.lib.plot._Position
58	The width of the plot along the x, y, and z axes, respectively
59	basis_ : c_int
60	The axes basis of the plot view.
61	pixels_ : c_size_t[3]
62	The resolution of the plot in the horizontal and vertical dimensions
63	level_ : c_int
64	The universe level for the plot view
65
66	Attributes
67	----------
68	origin : tuple or list of ndarray
69	Origin (center) of the plot
70	width : float
71	The horizontal dimension of the plot in geometry units (cm)
72	height : float
73	The vertical dimension of the plot in geometry units (cm)
74	basis : string
75	One of {'xy', 'xz', 'yz'} indicating the horizontal and vertical
76	axes of the plot.
77	h_res : int
78	The horizontal resolution of the plot in pixels
79	v_res : int
80	The vertical resolution of the plot in pixels
81	level : int
82	The universe level for the plot (default: -1 -> all universes shown)
83	"""
84	_fields_ = [('origin_', _Position),	11✔
85	('width_', _Position),
86	('basis_', c_int),
87	('pixels_', 3*c_size_t),
88	('color_overlaps_', c_bool),
89	('level_', c_int)]
90
91	def __init__(self):	11✔
92	self.level_ = -1	11✔
93	self.basis_ = 1	11✔
94	self.color_overlaps_ = False	11✔
95
96	@property	11✔
97	def origin(self):	11✔
UNCOV 98	return self.origin_	×
99
100	@origin.setter	11✔
101	def origin(self, origin):	11✔
102	self.origin_.x = origin[0]	11✔
103	self.origin_.y = origin[1]	11✔
104	self.origin_.z = origin[2]	11✔
105
106	@property	11✔
107	def width(self):	11✔
UNCOV 108	return self.width_.x	×
109
110	@width.setter	11✔
111	def width(self, width):	11✔
112	self.width_.x = width	11✔
113
114	@property	11✔
115	def height(self):	11✔
UNCOV 116	return self.width_.y	×
117
118	@height.setter	11✔
119	def height(self, height):	11✔
120	self.width_.y = height	11✔
121
122	@property	11✔
123	def basis(self):	11✔
124	if self.basis_ == 1:	×
125	return 'xy'	×
126	elif self.basis_ == 2:	×
127	return 'xz'	×
128	elif self.basis_ == 3:	×
UNCOV 129	return 'yz'	×
130
UNCOV 131	raise ValueError(f"Plot basis {self.basis_} is invalid")	×
132
133	@basis.setter	11✔
134	def basis(self, basis):	11✔
135	if isinstance(basis, str):	11✔
136	valid_bases = ('xy', 'xz', 'yz')	11✔
137	basis = basis.lower()	11✔
138	if basis not in valid_bases:	11✔
UNCOV 139	raise ValueError(f"{basis} is not a valid plot basis.")	×
140
141	if basis == 'xy':	11✔
142	self.basis_ = 1	11✔
143	elif basis == 'xz':	×
144	self.basis_ = 2	×
145	elif basis == 'yz':	×
UNCOV 146	self.basis_ = 3	×
147	return	11✔
148
149	if isinstance(basis, int):	×
150	valid_bases = (1, 2, 3)	×
151	if basis not in valid_bases:	×
152	raise ValueError(f"{basis} is not a valid plot basis.")	×
153	self.basis_ = basis	×
UNCOV 154	return	×
155
UNCOV 156	raise ValueError(f"{basis} of type {type(basis)} is an invalid plot basis")	×
157
158	@property	11✔
159	def h_res(self):	11✔
160	return self.pixels_[0]	11✔
161
162	@h_res.setter	11✔
163	def h_res(self, h_res):	11✔
164	self.pixels_[0] = h_res	11✔
165
166	@property	11✔
167	def v_res(self):	11✔
168	return self.pixels_[1]	11✔
169
170	@v_res.setter	11✔
171	def v_res(self, v_res):	11✔
172	self.pixels_[1] = v_res	11✔
173
174	@property	11✔
175	def level(self):	11✔
UNCOV 176	return int(self.level_)	×
177
178	@level.setter	11✔
179	def level(self, level):	11✔
180	self.level_ = level	11✔
181
182	@property	11✔
183	def color_overlaps(self):	11✔
UNCOV 184	return self.color_overlaps_	×
185
186	@color_overlaps.setter	11✔
187	def color_overlaps(self, color_overlaps):	11✔
UNCOV 188	self.color_overlaps_ = color_overlaps	×
189
190	@property	11✔
191	def color_overlaps(self):	11✔
UNCOV 192	return self.color_overlaps_	×
193
194	@color_overlaps.setter	11✔
195	def color_overlaps(self, val):	11✔
UNCOV 196	self.color_overlaps_ = val	×
197
198	def __repr__(self):	11✔
UNCOV 199	out_str = ["-----",	×
200	"Plot:",
201	"-----",
202	f"Origin: {self.origin}",
203	f"Width: {self.width}",
204	f"Height: {self.height}",
205	f"Basis: {self.basis}",
206	f"HRes: {self.h_res}",
207	f"VRes: {self.v_res}",
208	f"Color Overlaps: {self.color_overlaps}",
209	f"Level: {self.level}"]
UNCOV 210	return '\n'.join(out_str)	×
211
212
213	_dll.openmc_id_map.argtypes = [POINTER(_PlotBase), POINTER(c_int32)]	11✔
214	_dll.openmc_id_map.restype = c_int	11✔
215	_dll.openmc_id_map.errcheck = _error_handler	11✔
216
217
218	def id_map(plot):	11✔
219	"""
220	Generate a 2-D map of cell and material IDs. Used for in-memory image
221	generation.
222
223	Parameters
224	----------
225	plot : openmc.lib.plot._PlotBase
226	Object describing the slice of the model to be generated
227
228	Returns
229	-------
230	id_map : numpy.ndarray
231	A NumPy array with shape (vertical pixels, horizontal pixels, 3) of
232	OpenMC property ids with dtype int32. The last dimension of the array
233	contains, in order, cell IDs, cell instances, and material IDs.
234
235	"""
236	img_data = np.zeros((plot.v_res, plot.h_res, 3),	11✔
237	dtype=np.dtype('int32'))
238	_dll.openmc_id_map(plot, img_data.ctypes.data_as(POINTER(c_int32)))	11✔
239	return img_data	11✔
240
241
242	_dll.openmc_property_map.argtypes = [POINTER(_PlotBase), POINTER(c_double)]	11✔
243	_dll.openmc_property_map.restype = c_int	11✔
244	_dll.openmc_property_map.errcheck = _error_handler	11✔
245
246
247	def property_map(plot):	11✔
248	"""
249	Generate a 2-D map of cell temperatures and material densities. Used for
250	in-memory image generation.
251
252	Parameters
253	----------
254	plot : openmc.lib.plot._PlotBase
255	Object describing the slice of the model to be generated
256
257	Returns
258	-------
259	property_map : numpy.ndarray
260	A NumPy array with shape (vertical pixels, horizontal pixels, 2) of
261	OpenMC property ids with dtype float
262
263	"""
264	prop_data = np.zeros((plot.v_res, plot.h_res, 2))	11✔
265	_dll.openmc_property_map(plot, prop_data.ctypes.data_as(POINTER(c_double)))	11✔
266	return prop_data	11✔

openmc-dev / openmc / 16366577751

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