21550569496

Committed 31 Jan 2026 08:38PM UTC coverage: 81.504% (-0.5%) from 81.979%

Build # 21550569496

Build Type

Pull #3547

github

Committed by

web-flow

Commit Message

Merge a20d1123d into 7b4617aff

Pull Request Pull Request #3547: Tally spectrum of secondary particles

Run Details

17254 of 24050 branches covered (71.74%)

Branch coverage included in aggregate %.

69 of 71 new or added lines in 10 files covered. (97.18%)

1040 existing lines in 19 files now uncovered.

55434 of 65133 relevant lines covered (85.11%)

35659348.56 hits per line

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

78.26

/openmc/executor.py

from collections.abc import Iterable
from numbers import Integral
import os
import subprocess

import openmc
from .plots import _get_plot_image


def _process_CLI_arguments(volume=False, geometry_debug=False, particles=None,
                           plot=False, restart_file=None, threads=None,
                           tracks=False, event_based=None,
                           openmc_exec='openmc', mpi_args=None, path_input=None):
    """Converts user-readable flags in to command-line arguments to be run with
    the OpenMC executable via subprocess.

    Parameters
    ----------
    volume : bool, optional
        Run in stochastic volume calculation mode. Defaults to False.
    geometry_debug : bool, optional
        Turn on geometry debugging during simulation. Defaults to False.
    particles : int, optional
        Number of particles to simulate per generation.
    plot : bool, optional
        Run in plotting mode. Defaults to False.
    restart_file : str or PathLike
        Path to restart file to use
    threads : int, optional
        Number of OpenMP threads. If OpenMC is compiled with OpenMP threading
        enabled, the default is implementation-dependent but is usually equal
        to the number of hardware threads available (or a value set by the
        :envvar:`OMP_NUM_THREADS` environment variable).
    tracks : bool, optional
        Enables the writing of particles tracks. The number of particle
        tracks written to tracks.h5 is limited to 1000 unless
        Settings.max_tracks is set. Defaults to False.
    event_based : None or bool, optional
        Turns on event-based parallelism if True. If None, the value in
        the Settings will be used.
    openmc_exec : str, optional
        Path to OpenMC executable. Defaults to 'openmc'.
    mpi_args : list of str, optional
        MPI execute command and any additional MPI arguments to pass,
        e.g., ['mpiexec', '-n', '8'].
    path_input : str or PathLike
        Path to a single XML file or a directory containing XML files for the
        OpenMC executable to read.

    .. versionadded:: 0.13.0

    Returns
    -------
    args : Iterable of str
        The runtime flags converted to CLI arguments of the OpenMC executable

    """

    args = [openmc_exec]

    if volume:
        args.append('--volume')

    if isinstance(particles, Integral) and particles > 0:
        args += ['-n', str(particles)]

    if isinstance(threads, Integral) and threads > 0:
        args += ['-s', str(threads)]

    if geometry_debug:
        args.append('-g')

    if event_based is not None:
        if event_based:
            args.append('-e')

    if isinstance(restart_file, (str, os.PathLike)):
        args += ['-r', str(restart_file)]

    if tracks:
        args.append('-t')

    if plot:
        args.append('-p')

    if mpi_args is not None:
        args = mpi_args + args

    if path_input is not None:
        args += [path_input]

    return args


def _run(args, output, cwd):
    # Launch a subprocess
    p = subprocess.Popen(args, cwd=cwd, stdout=subprocess.PIPE,
                         stderr=subprocess.STDOUT, universal_newlines=True)

    # Capture and re-print OpenMC output in real-time
    lines = []
    while True:
        # If OpenMC is finished, break loop
        line = p.stdout.readline()
        if not line and p.poll() is not None:
            break

        lines.append(line)
        if output:
            # If user requested output, print to screen
            print(line, end='')

    # Raise an exception if return status is non-zero
    if p.returncode != 0:
        # Get error message from output and simplify whitespace
        output = ''.join(lines)
        if 'ERROR: ' in output:
            _, _, error_msg = output.partition('ERROR: ')
        elif 'what()' in output:
            _, _, error_msg = output.partition('what(): ')
        else:
            error_msg = 'OpenMC aborted unexpectedly.'
        error_msg = ' '.join(error_msg.split())

        raise RuntimeError(error_msg)


def plot_geometry(output=True, openmc_exec='openmc', cwd='.', path_input=None):
    """Run OpenMC in plotting mode

    Parameters
    ----------
    output : bool, optional
        Capture OpenMC output from standard out
    openmc_exec : str, optional
        Path to OpenMC executable
    cwd : str, optional
        Path to working directory to run in
    path_input : str
        Path to a single XML file or a directory containing XML files for the
        OpenMC executable to read.

        .. versionadded:: 0.13.3

    Raises
    ------
    RuntimeError
        If the `openmc` executable returns a non-zero status

    """
    args = [openmc_exec, '-p']
    if path_input is not None:
        args += [path_input]
    _run(args, output, cwd)


def plot_inline(plots, openmc_exec='openmc', cwd='.', path_input=None):
    """Display plots inline in a Jupyter notebook.

    .. versionchanged:: 0.13.0
        The *convert_exec* argument was removed since OpenMC now produces
        .png images directly.


    Parameters
    ----------
    plots : Iterable of openmc.PlotBase
        Plots to display
    openmc_exec : str
        Path to OpenMC executable
    cwd : str, optional
        Path to working directory to run in
    path_input : str
        Path to a single XML file or a directory containing XML files for the
        OpenMC executable to read.

        .. versionadded:: 0.13.3

    Raises
    ------
    RuntimeError
        If the `openmc` executable returns a non-zero status

    """
    from IPython.display import display

    if not isinstance(plots, Iterable):
        plots = [plots]

    # Create plots.xml
    openmc.Plots(plots).export_to_xml(cwd)

    # Run OpenMC in geometry plotting mode
    plot_geometry(False, openmc_exec, cwd, path_input)

    if plots is not None:
        images = [_get_plot_image(p, cwd) for p in plots]
        display(*images)


def calculate_volumes(threads=None, output=True, cwd='.',
                      openmc_exec='openmc', mpi_args=None,
                      path_input=None):
    """Run stochastic volume calculations in OpenMC.

    This function runs OpenMC in stochastic volume calculation mode. To specify
    the parameters of a volume calculation, one must first create a
    :class:`openmc.VolumeCalculation` instance and assign it to
    :attr:`openmc.Settings.volume_calculations`. For example:

    >>> vol = openmc.VolumeCalculation(domains=[cell1, cell2], samples=100000)
    >>> settings = openmc.Settings()
    >>> settings.volume_calculations = [vol]
    >>> settings.export_to_xml()
    >>> openmc.calculate_volumes()

    Parameters
    ----------
    threads : int, optional
        Number of OpenMP threads. If OpenMC is compiled with OpenMP threading
        enabled, the default is implementation-dependent but is usually equal
        to the number of hardware threads available (or a value set by the
        :envvar:`OMP_NUM_THREADS` environment variable).
    output : bool, optional
        Capture OpenMC output from standard out
    openmc_exec : str, optional
        Path to OpenMC executable. Defaults to 'openmc'.
    mpi_args : list of str, optional
        MPI execute command and any additional MPI arguments to pass,
        e.g., ['mpiexec', '-n', '8'].
    cwd : str, optional
        Path to working directory to run in. Defaults to the current working
        directory.
    path_input : str or PathLike
        Path to a single XML file or a directory containing XML files for the
        OpenMC executable to read.


    Raises
    ------
    RuntimeError
        If the `openmc` executable returns a non-zero status

    See Also
    --------
    openmc.VolumeCalculation

    """

    args = _process_CLI_arguments(volume=True, threads=threads,
                                  openmc_exec=openmc_exec, mpi_args=mpi_args,
                                  path_input=path_input)

    _run(args, output, cwd)


def run(particles=None, threads=None, geometry_debug=False,
        restart_file=None, tracks=False, output=True, cwd='.',
        openmc_exec='openmc', mpi_args=None, event_based=False,
        path_input=None):
    """Run an OpenMC simulation.

    Parameters
    ----------
    particles : int, optional
        Number of particles to simulate per generation.
    threads : int, optional
        Number of OpenMP threads. If OpenMC is compiled with OpenMP threading
        enabled, the default is implementation-dependent but is usually equal to
        the number of hardware threads available (or a value set by the
        :envvar:`OMP_NUM_THREADS` environment variable).
    geometry_debug : bool, optional
        Turn on geometry debugging during simulation. Defaults to False.
    restart_file : str or PathLike
        Path to restart file to use
    tracks : bool, optional
        Enables the writing of particles tracks. The number of particle tracks
        written to tracks.h5 is limited to 1000 unless Settings.max_tracks is
        set. Defaults to False.
    output : bool
        Capture OpenMC output from standard out
    cwd : str, optional
        Path to working directory to run in. Defaults to the current working
        directory.
    openmc_exec : str, optional
        Path to OpenMC executable. Defaults to 'openmc'.
    mpi_args : list of str, optional
        MPI execute command and any additional MPI arguments to pass, e.g.,
        ['mpiexec', '-n', '8'].
    event_based : bool, optional
        Turns on event-based parallelism, instead of default history-based

        .. versionadded:: 0.12

    path_input : str or PathLike
        Path to a single XML file or a directory containing XML files for the
        OpenMC executable to read.

        .. versionadded:: 0.13.3

    Raises
    ------
    RuntimeError
        If the `openmc` executable returns a non-zero status

    """

    args = _process_CLI_arguments(
        volume=False, geometry_debug=geometry_debug, particles=particles,
        restart_file=restart_file, threads=threads, tracks=tracks,
        event_based=event_based, openmc_exec=openmc_exec, mpi_args=mpi_args,
        path_input=path_input)

    _run(args, output, cwd)

1	from collections.abc import Iterable	6✔
2	from numbers import Integral	6✔
3	import os	6✔
4	import subprocess	6✔
5
6	import openmc	6✔
7	from .plots import _get_plot_image	6✔
8
9
10	def _process_CLI_arguments(volume=False, geometry_debug=False, particles=None,	6✔
11	plot=False, restart_file=None, threads=None,
12	tracks=False, event_based=None,
13	openmc_exec='openmc', mpi_args=None, path_input=None):
14	"""Converts user-readable flags in to command-line arguments to be run with
15	the OpenMC executable via subprocess.
16
17	Parameters
18	----------
19	volume : bool, optional
20	Run in stochastic volume calculation mode. Defaults to False.
21	geometry_debug : bool, optional
22	Turn on geometry debugging during simulation. Defaults to False.
23	particles : int, optional
24	Number of particles to simulate per generation.
25	plot : bool, optional
26	Run in plotting mode. Defaults to False.
27	restart_file : str or PathLike
28	Path to restart file to use
29	threads : int, optional
30	Number of OpenMP threads. If OpenMC is compiled with OpenMP threading
31	enabled, the default is implementation-dependent but is usually equal
32	to the number of hardware threads available (or a value set by the
33	:envvar:`OMP_NUM_THREADS` environment variable).
34	tracks : bool, optional
35	Enables the writing of particles tracks. The number of particle
36	tracks written to tracks.h5 is limited to 1000 unless
37	Settings.max_tracks is set. Defaults to False.
38	event_based : None or bool, optional
39	Turns on event-based parallelism if True. If None, the value in
40	the Settings will be used.
41	openmc_exec : str, optional
42	Path to OpenMC executable. Defaults to 'openmc'.
43	mpi_args : list of str, optional
44	MPI execute command and any additional MPI arguments to pass,
45	e.g., ['mpiexec', '-n', '8'].
46	path_input : str or PathLike
47	Path to a single XML file or a directory containing XML files for the
48	OpenMC executable to read.
49
50	.. versionadded:: 0.13.0
51
52	Returns
53	-------
54	args : Iterable of str
55	The runtime flags converted to CLI arguments of the OpenMC executable
56
57	"""
58
59	args = [openmc_exec]	6✔
60
61	if volume:	6✔
62	args.append('--volume')	6✔
63
64	if isinstance(particles, Integral) and particles > 0:	6✔
65	args += ['-n', str(particles)]	×
66
67	if isinstance(threads, Integral) and threads > 0:	6✔
68	args += ['-s', str(threads)]	6✔
69
70	if geometry_debug:	6✔
71	args.append('-g')	×
72
73	if event_based is not None:	6✔
74	if event_based:	6✔
UNCOV 75	args.append('-e')	×
76
77	if isinstance(restart_file, (str, os.PathLike)):	6✔
78	args += ['-r', str(restart_file)]	6✔
79
80	if tracks:	6✔
81	args.append('-t')	6✔
82
83	if plot:	6✔
84	args.append('-p')	×
85
86	if mpi_args is not None:	6✔
87	args = mpi_args + args	2✔
88
89	if path_input is not None:	6✔
90	args += [path_input]	6✔
91
92	return args	6✔
93
94
95	def _run(args, output, cwd):	6✔
96	# Launch a subprocess
97	p = subprocess.Popen(args, cwd=cwd, stdout=subprocess.PIPE,	6✔
98	stderr=subprocess.STDOUT, universal_newlines=True)
99
100	# Capture and re-print OpenMC output in real-time
101	lines = []	6✔
102	while True:	6✔
103	# If OpenMC is finished, break loop
104	line = p.stdout.readline()	6✔
105	if not line and p.poll() is not None:	6✔
106	break	6✔
107
108	lines.append(line)	6✔
109	if output:	6✔
110	# If user requested output, print to screen
111	print(line, end='')	6✔
112
113	# Raise an exception if return status is non-zero
114	if p.returncode != 0:	6✔
115	# Get error message from output and simplify whitespace
116	output = ''.join(lines)	6✔
117	if 'ERROR: ' in output:	6✔
118	_, _, error_msg = output.partition('ERROR: ')	6✔
119	elif 'what()' in output:	×
120	_, _, error_msg = output.partition('what(): ')	×
121	else:
122	error_msg = 'OpenMC aborted unexpectedly.'	×
123	error_msg = ' '.join(error_msg.split())	6✔
124
125	raise RuntimeError(error_msg)	6✔
126
127
128	def plot_geometry(output=True, openmc_exec='openmc', cwd='.', path_input=None):	6✔
129	"""Run OpenMC in plotting mode
130
131	Parameters
132	----------
133	output : bool, optional
134	Capture OpenMC output from standard out
135	openmc_exec : str, optional
136	Path to OpenMC executable
137	cwd : str, optional
138	Path to working directory to run in
139	path_input : str
140	Path to a single XML file or a directory containing XML files for the
141	OpenMC executable to read.
142
143	.. versionadded:: 0.13.3
144
145	Raises
146	------
147	RuntimeError
148	If the `openmc` executable returns a non-zero status
149
150	"""
151	args = [openmc_exec, '-p']	6✔
152	if path_input is not None:	6✔
153	args += [path_input]	6✔
154	_run(args, output, cwd)	6✔
155
156
157	def plot_inline(plots, openmc_exec='openmc', cwd='.', path_input=None):	6✔
158	"""Display plots inline in a Jupyter notebook.
159
160	.. versionchanged:: 0.13.0
161	The convert_exec argument was removed since OpenMC now produces
162	.png images directly.
163
164
165	Parameters
166	----------
167	plots : Iterable of openmc.PlotBase
168	Plots to display
169	openmc_exec : str
170	Path to OpenMC executable
171	cwd : str, optional
172	Path to working directory to run in
173	path_input : str
174	Path to a single XML file or a directory containing XML files for the
175	OpenMC executable to read.
176
177	.. versionadded:: 0.13.3
178
179	Raises
180	------
181	RuntimeError
182	If the `openmc` executable returns a non-zero status
183
184	"""
185	from IPython.display import display	×
186
187	if not isinstance(plots, Iterable):	×
188	plots = [plots]	×
189
190	# Create plots.xml
191	openmc.Plots(plots).export_to_xml(cwd)	×
192
193	# Run OpenMC in geometry plotting mode
194	plot_geometry(False, openmc_exec, cwd, path_input)	×
195
196	if plots is not None:	×
197	images = [_get_plot_image(p, cwd) for p in plots]	×
198	display(*images)	×
199
200
201	def calculate_volumes(threads=None, output=True, cwd='.',	6✔
202	openmc_exec='openmc', mpi_args=None,
203	path_input=None):
204	"""Run stochastic volume calculations in OpenMC.
205
206	This function runs OpenMC in stochastic volume calculation mode. To specify
207	the parameters of a volume calculation, one must first create a
208	:class:`openmc.VolumeCalculation` instance and assign it to
209	:attr:`openmc.Settings.volume_calculations`. For example:
210
211	>>> vol = openmc.VolumeCalculation(domains=[cell1, cell2], samples=100000)
212	>>> settings = openmc.Settings()
213	>>> settings.volume_calculations = [vol]
214	>>> settings.export_to_xml()
215	>>> openmc.calculate_volumes()
216
217	Parameters
218	----------
219	threads : int, optional
220	Number of OpenMP threads. If OpenMC is compiled with OpenMP threading
221	enabled, the default is implementation-dependent but is usually equal
222	to the number of hardware threads available (or a value set by the
223	:envvar:`OMP_NUM_THREADS` environment variable).
224	output : bool, optional
225	Capture OpenMC output from standard out
226	openmc_exec : str, optional
227	Path to OpenMC executable. Defaults to 'openmc'.
228	mpi_args : list of str, optional
229	MPI execute command and any additional MPI arguments to pass,
230	e.g., ['mpiexec', '-n', '8'].
231	cwd : str, optional
232	Path to working directory to run in. Defaults to the current working
233	directory.
234	path_input : str or PathLike
235	Path to a single XML file or a directory containing XML files for the
236	OpenMC executable to read.
237
238
239	Raises
240	------
241	RuntimeError
242	If the `openmc` executable returns a non-zero status
243
244	See Also
245	--------
246	openmc.VolumeCalculation
247
248	"""
249
250	args = _process_CLI_arguments(volume=True, threads=threads,	6✔
251	openmc_exec=openmc_exec, mpi_args=mpi_args,
252	path_input=path_input)
253
254	_run(args, output, cwd)	6✔
255
256
257	def run(particles=None, threads=None, geometry_debug=False,	6✔
258	restart_file=None, tracks=False, output=True, cwd='.',
259	openmc_exec='openmc', mpi_args=None, event_based=False,
260	path_input=None):
261	"""Run an OpenMC simulation.
262
263	Parameters
264	----------
265	particles : int, optional
266	Number of particles to simulate per generation.
267	threads : int, optional
268	Number of OpenMP threads. If OpenMC is compiled with OpenMP threading
269	enabled, the default is implementation-dependent but is usually equal to
270	the number of hardware threads available (or a value set by the
271	:envvar:`OMP_NUM_THREADS` environment variable).
272	geometry_debug : bool, optional
273	Turn on geometry debugging during simulation. Defaults to False.
274	restart_file : str or PathLike
275	Path to restart file to use
276	tracks : bool, optional
277	Enables the writing of particles tracks. The number of particle tracks
278	written to tracks.h5 is limited to 1000 unless Settings.max_tracks is
279	set. Defaults to False.
280	output : bool
281	Capture OpenMC output from standard out
282	cwd : str, optional
283	Path to working directory to run in. Defaults to the current working
284	directory.
285	openmc_exec : str, optional
286	Path to OpenMC executable. Defaults to 'openmc'.
287	mpi_args : list of str, optional
288	MPI execute command and any additional MPI arguments to pass, e.g.,
289	['mpiexec', '-n', '8'].
290	event_based : bool, optional
291	Turns on event-based parallelism, instead of default history-based
292
293	.. versionadded:: 0.12
294
295	path_input : str or PathLike
296	Path to a single XML file or a directory containing XML files for the
297	OpenMC executable to read.
298
299	.. versionadded:: 0.13.3
300
301	Raises
302	------
303	RuntimeError
304	If the `openmc` executable returns a non-zero status
305
306	"""
307
308	args = _process_CLI_arguments(	6✔
309	volume=False, geometry_debug=geometry_debug, particles=particles,
310	restart_file=restart_file, threads=threads, tracks=tracks,
311	event_based=event_based, openmc_exec=openmc_exec, mpi_args=mpi_args,
312	path_input=path_input)
313
314	_run(args, output, cwd)	6✔

openmc-dev / openmc / 21550569496

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