pymcnp 0.1.2__py3-none-any.whl

demo/main.py

@@ -0,0 +1,24 @@
+import sys
+
+import docopt
+
+
+DEMO_DOCOPT = """
+Usage:
+    demo <inp>
+"""
+
+
+def main():
+    args = docopt.docopt(DEMO_DOCOPT)
+
+    try:
+        open(args['<inp>'])
+        print(f"[DEMO] Args: {' '.join(sys.argv)}")
+    except FileNotFoundError:
+        print('[DEMO] Input file not found.')
+        exit(1)
+
+    file = open('.' + ''.join(args['<inp>'].split('.')[:-1]) + '.outp', 'x')
+    file.write('MCNP Output! :)')
+    file.close()

mcnptools/geometryGUI.py

@@ -0,0 +1,56 @@
+"""
+GUI program to look at geometry
+"""
+
+import matplotlib.pyplot as plt
+from mcnptools import build_geometry as bg
+
+plt.rc('font', size=14)
+plt.style.use('seaborn-v0_8-darkgrid')
+fig = plt.figure(constrained_layout=True, figsize=(16, 8))
+gs = fig.add_gridspec(1, 2, width_ratios=[0.7, 0.3], height_ratios=[1])
+ax_3d = fig.add_subplot(gs[0, 0], projection='3d')
+ax_menu = fig.add_subplot(gs[0, 1])
+ax_menu.set_xticks([])
+ax_menu.set_yticks([])
+
+# MCNP file
+file_path = 'test_output_files/geom_gui.i'
+
+soil = bg.Geometry(
+    color='blue',
+    name='Soil',
+    h_menu=0,
+    fig=fig,
+    ax_3d=ax_3d,
+    ax_menu=ax_menu,
+    soil=True,
+)
+soil.make_object(x0=0, y0=0, z0=-200, height=150, radius=200, axis='z')
+
+png = bg.Geometry(
+    color='green', name='PNG (TR1)', h_menu=0.89, fig=fig, ax_3d=ax_3d, ax_menu=ax_menu
+)
+png.make_object(x0=0, y0=-30, z0=0, height=30, radius=10, axis='y')
+
+rover = bg.Geometry(
+    color='black',
+    name='Rover (TR2)',
+    h_menu=0.65,
+    fig=fig,
+    ax_3d=ax_3d,
+    ax_menu=ax_menu,
+)
+rover.make_object(x0=30, y0=-50, z0=0, height=100, radius=12, axis='y')
+
+detector = bg.Geometry(
+    color='red',
+    name='Detector (TR3)',
+    h_menu=0.42,
+    fig=fig,
+    ax_3d=ax_3d,
+    ax_menu=ax_menu,
+)
+detector.make_object(x0=60, y0=0, z0=0, height=-10, radius=5, axis='z')
+
+gui = bg.Transform(file_path, [soil, png, rover, detector])

mcnptools/mcnprun.py

@@ -0,0 +1,187 @@
+"""
+Run MCNP through Python using the package subprocess.
+Code modifed from https://gist.github.com/abnowack
+"""
+
+import numpy as np
+import subprocess
+import shutil
+import os
+from pathlib import Path
+
+
+def set_mcnp_environment(DATAPATH, ISCDATA, MCNPPATH, force=False):
+    if force or 'DATAPATH' not in os.environ:
+        os.environ['DATAPATH'] = DATAPATH
+
+    if force or 'ISCDATA' not in os.environ:
+        os.environ['ISCDATA'] = ISCDATA
+
+    if force or 'MCNPPATH' not in os.environ:
+        os.environ['MCNPPATH'] = MCNPPATH
+        os.environ['PATH'] += os.pathsep + str(os.environ['MCNPPATH'])
+
+
+def create_directory(directory):
+    """
+    If directory already exists, append 1 to the name and create a new one.
+    If directory does not exist, create it.
+
+    Parameters:
+    directory (Path object): Directory path to check/create.
+    """
+    if directory.exists():
+        print(f"Directory '{directory}' already exists.")
+        new_name = directory.name + f'-{np.random.randint(0, 999)}'
+        new_dir = directory.parent / new_name
+        new_dir.mkdir()
+        print(f"Directory '{new_dir}' created successfully.")
+    else:
+        new_dir = directory
+        new_dir.mkdir()
+        print(f"Directory '{new_dir}' created successfully.")
+    return new_dir
+
+
+def clean_directory(clean_dir):
+    shutil.rmtree(clean_dir)
+
+
+DATAPATH = r'C:\MCNP62\MCNP_DATA'
+ISCDATA = r'C:\MCNP62\MCNP_CODE\MCNP620\Utilities\ISC\data'
+MCNPPATH = r'C:\MCNP62\MCNP_CODE\bin'
+
+set_mcnp_environment(DATAPATH, ISCDATA, MCNPPATH)
+
+input_file = 'C:/Users/mayll/Documents/MCNP-tools/examples/Data/proton-dist.i'
+# test_dir = "C:/Users/mayll/Documents/MCNP-tools/test-delete"
+
+# args = f"i={input_file} o=testout.o"
+
+# run = subprocess.run("mcnp6.exe " + args, shell=True, cwd=test_dir, capture_output=True)
+# print(run)
+
+
+def run_mcnp(input_file, out_dir=None, out_name=None, cores=1, clean=False):
+    """
+    Python interface for running MCNP
+
+    Parameters
+    ----------
+    input_file : string
+        Input file full path.
+    out_dir : string, optional.
+        Directory where output files will be saved. The default is None
+        (will be saved to the same directory as the input file)
+    out_name : string, optional.
+        Output file name. The default is None
+        (will be saved with the same name as the input file)
+    cores : int, optional
+        Number of threads used (not available for all particle types). The default is 1.
+    clean : bool, optional
+        Delete secondary output files. The default is False.
+
+    Returns
+    -------
+    Dictionary with information about the run.
+    """
+    input_file = Path(input_file)
+    if out_dir is None:
+        out_dir = input_file.parent / 'test-folder'
+        new_out_dir = create_directory(out_dir)
+    else:
+        new_out_dir = Path(out_dir)
+    if out_name is None:
+        new_name = input_file.name
+    else:
+        new_name = out_name
+    if cores <= 2:
+        args = f'i={input_file} o={new_name}.o'
+    else:
+        args = f'i={input_file} o={new_name}.o tasks {cores}'
+
+    args = f'i={input_file} o={new_name}.o'
+    run = subprocess.run('mcnp6.exe ' + args, shell=True, cwd=new_out_dir, capture_output=True)
+    return run
+
+
+out_dir = 'C:/Users/mayll/Documents/MCNP-tools/examples/Data/test-folder'
+run = run_mcnp(input_file=input_file)
+
+# @contextmanager
+# def run_mcnp(card, extra_args=None, params=None, cores=1, clean=True):
+#     """ Python interface for running MCNP programs.
+#     Parameters
+#     ----------
+#     card : str
+#         MCNP input card, can contain variable expressions using str.format(params)
+#     extra_args: dict
+#         Dictionary of additional arguments for MCNP, eg `mcnp $KEY=$VALUE`
+#     params : dict, optional
+#         Values to apply on MCNP input card
+#     cores : int
+#         Number of CPU cores for MCNP to run on
+#     clean : bool
+#         Clean the temporary output directory
+#     Returns
+#     -------
+#     run : subprocess.CompletedProcess
+#         Contains successful run information
+#     output_dir : file directory
+#         Temporary output directory containing MCNP results
+#     """
+#     if params:
+#         card = card.format(**params)
+
+#     args = []
+#     if extra_args:
+#         for (arg, val) in extra_args:
+#                 args.append('{}={}'.format(arg, val))
+
+#     args.append('tasks {}'.format(cores))
+
+#     # create temp folder
+#     output_dir = tempfile.mkdtemp()
+#     with open(output_dir + '\\input.i', 'w') as f:
+#         f.write(card)
+
+#     args.append('i=input.i')
+
+#     # mcnp doesn't use errorcodes or stderr, so Popen doesnt add features
+#     # stick with simpler check_output and parse stdout
+#     run = subprocess.run(['mcnp6.exe'] + args, shell=True, cwd=output_dir, capture_output=True)
+
+#     # check for errors in stdout
+#     stdout_str = str(run.stdout)
+#     if 'bad trouble' in stdout_str or 'fatal error' in stdout_str:
+#         print('Error in MCNP outout')
+#         print(run.args)
+#         print(run.stdout)
+#         status = False
+#     else:
+#         status = True
+
+#     try:
+#         yield (run, output_dir)
+#     finally:
+#         if clean:
+#             print(output_dir)
+#             clean_directory(output_dir)
+
+# if __name__ == '__main__':
+#   DATAPATH=r'C:\MCNP62\MCNP_DATA'
+#   ISCDATA=r'C:\MCNP62\MCNP_CODE\MCNP620\Utilities\ISC\data'
+#   MCNPPATH=r'C:\MCNP62\MCNP_CODE\bin'
+
+#   set_mcnp_environment(DATAPATH, ISCDATA, MCNPPATH)
+
+
+#   input_card = \
+#   r"""PUT YOUR MCNP INPUT CARD HERE
+#   IT CAN HAVE {} for formatting the card with values filled in by params arg in run_mcnp
+#   """
+
+#   # use run_mcnp in the following way as a context manager
+#   with run_mcnp(input_card, cores=4, clean=False) as (run, out_dir):
+#   print(run.stdout)
+#   print(out_dir)

pymcnp/__init__.py

@@ -0,0 +1,22 @@
+from . import cli
+from .files import inp
+from .files import outp
+from .files import ptrac
+from .files import utils
+from .files.inp import Inp
+from .files.outp import ReadOutput
+from .files.ptrac import Ptrac
+
+from .version import __version__
+
+__all__ = [
+    "cli",
+    "inp",
+    "outp",
+    "ptrac",
+    "utils",
+    "Inp",
+    "ReadOutput",
+    "Ptrac",
+    "__version__",
+]

pymcnp/cli/__init__.py

@@ -0,0 +1,7 @@
+from .ls import Ls
+from .run import Run
+
+__all__ = [
+    'Ls',
+    'Run',
+]

pymcnp/cli/_io.py

@@ -0,0 +1,41 @@
+"""
+'_utils'
+"""
+
+import datetime
+
+
+ERROR_INSUFFICENT_ARGS = '\x1b[1mpymcnp: \x1b[31mERROR:\x1b[0m Insufficent Arguments.'
+ERROR_EXCESSIVE_ARGS = '\x1b[1mpymcnp: \x1b[31mERROR:\x1b[0m Excesive Arguments.'
+ERROR_UNRECOGNIZED_ARGS = '\x1b[1mpymcnp: \x1b[31mERROR:\x1b[0m Unrecognized Arguments.'
+ERROR_UNRECOGNIZED_OPTION = '\x1b[1mpymcnp: \x1b[31mERROR:\x1b[0m Unrecognized Option.'
+ERROR_ALIAS_NOT_FOUND = '\x1b[1mpymcnp: \x1b[31mERROR:\x1b[0m INP Alias Not Found.'
+ERROR_FILE_NOT_FOUND = '\x1b[1mpymcnp: \x1b[31mERROR:\x1b[0m File Not Found.'
+
+
+def ERROR_INP_VALUE(msg: str) -> str:
+    return '\x1b[1mpymcnp: \x1b[31mERROR:\x1b[0m INP Syntax Error: ' + msg
+
+
+def ERROR_INP_SYNTAX(msg: str) -> str:
+    return '\x1b[1mpymcnp: \x1b[31mERROR:\x1b[0m INP Value Error: ' + msg
+
+
+INFO_RUNNING_CQEDITOR = '\x1b[1mpymcnp: \x1b[31m\x1b[34mINFO:\x1b[0m Launching CQ-Editor.'
+INFO_RUNNING_MCNP = '\x1b[1mpymcnp: \x1b[31m\x1b[34mINFO:\x1b[0m Launching MCNP.'
+INFO_BUILD_INP = '\x1b[1mpymcnp: \x1b[31m\x1b[34mINFO:\x1b[0m Built INP.'
+INFO_BUILD_CELL = '\x1b[1mpymcnp: \x1b[31m\x1b[34mINFO:\x1b[0m Built Cell.'
+INFO_BUILD_SURFACE = '\x1b[1mpymcnp: \x1b[31m\x1b[34mINFO:\x1b[0m Built Surface.'
+INFO_BUILD_DATUM = '\x1b[1mpymcnp: \x1b[31m\x1b[34mINFO:\x1b[0m Built Datum.'
+INFO_BUILD_TITLE = '\x1b[1mpymcnp: \x1b[31m\x1b[34mINFO:\x1b[0m Built Title.'
+INFO_BUILD_MESSAGE = '\x1b[1mpymcnp: \x1b[31m\x1b[34mINFO:\x1b[0m Built Message.'
+INFO_BUILD_OTHER = '\x1b[1mpymcnp: \x1b[31m\x1b[34mINFO:\x1b[0m Built Other.'
+
+
+def get_timestamp() -> str:
+    return datetime.datetime.today().strftime('%Y-%m-%d--%H-%M-%S')
+
+
+def error(msg):
+    print(msg)
+    exit(1)

pymcnp/cli/_state.py

@@ -0,0 +1,131 @@
+import inspect
+from pathlib import Path
+import sys
+from typing import Callable
+
+
+class FileTable:
+    """Store information in a file, so that it can be used across multiple processes.
+
+    We use this mechanism to store information that is needed when, for example,
+    running MCNP simulations in parallel.
+    """
+
+    def __init__(self):
+        self.table = {}
+        self.path = Path.cwd() / '.pymcnp' / '_files.py'
+
+        self.path.parent.mkdir(exist_ok=True, parents=True)
+
+        if not self.path.is_file():
+            self.path.write_text('table = {}')
+
+    def append(self, alias, path):
+        self._sync_up()
+
+        if alias in self._table:
+            raise ValueError
+
+        self._table[alias] = path
+        self._sync_down()
+
+    def remove(self, alias):
+        self._sync_up()
+
+        if alias not in self._table:
+            raise ValueError
+
+        path = self._table.pop(alias)
+        self._sync_down()
+
+        return path
+
+    def access(self, alias):
+        self._sync_up()
+
+        if alias not in self._table:
+            raise ValueError
+
+        return self._table[alias]
+
+    def _sync_up(self):
+        """Read information from `_files.py`."""
+
+        path = sys.path
+        sys.path.append(str(self.path.parent.absolute()))
+        import _files
+
+        sys.path = path
+
+        self._table = _files.table
+
+        return self
+
+    def _sync_down(self):
+        """Write information to `_files.py`."""
+
+        self.path.write_text(f'table = {self._table.__repr__()}')
+
+    def __iter__(self):
+        self = self._sync_up()
+        return iter(self._table.items())
+
+
+class RunConfig:
+    """Store pre and posthooks as well as the run command for parallel runs."""
+
+    def __init__(self):
+        self.path = Path.cwd() / '.pymcnp' / '_run.py'
+        self.command = 'mcnp'
+
+        self.path.parent.mkdir(exist_ok=True, parents=True)
+
+        if not self.path.is_file():
+            self._sync_down()
+
+    def prehook(self):
+        pass
+
+    def posthook(self):
+        pass
+
+    def set_command(self, command: str):
+        self.command = command
+        self._sync_down()
+
+    def set_prehook(self, prehook: Callable):
+        self.prehook = prehook
+        self._sync_down()
+
+    def set_posthook(self, posthook: Callable):
+        self.posthook = posthook
+        self._sync_down()
+
+    def _sync_up(self):
+        """Read command, prehook, and posthook from `_run.py`."""
+
+        path = sys.path
+        sys.path.append(str(self.path.parent.absolute()))
+        import _run
+
+        sys.path = path
+
+        self.command = _run.command
+        self.prehook = _run.prehook
+        self.posthook = _run.posthook
+
+        return self
+
+    def _sync_down(self):
+        """Write command, prehook, and posthook to `_run.py`."""
+
+        prehook = 'def prehook():\n' + ''.join(inspect.getsourcelines(self.prehook)[0][1:])
+        posthook = 'def posthook():\n' + ''.join(inspect.getsourcelines(self.posthook)[0][1:])
+
+        self.path.write_text(
+            f"command = '{self.command}'\n" + '\n' + prehook + '\n' + posthook + '\n'
+        )
+
+
+table = FileTable()._sync_up()
+run = RunConfig()._sync_up()

pymcnp/cli/file.py

@@ -0,0 +1,49 @@
+"""
+``file`` provides utilities for aliasing PyMCNP file objects.
+
+``file`` contains the procedures for executing the ``pymcnp file`` command.
+This module underpins the CLI by simplifying commands.
+"""
+
+import sys
+
+import docopt
+
+from . import _state
+
+
+PYMCNP_INP_DOC = """
+Usage:
+    pymcnp file <alias> ( --read=<file> | --delete )
+
+Options:
+    -r --read=<file>    Read INP file and create alias.
+    -d --delete         Delete alias.
+"""
+
+
+def main(argv: list[str] = sys.argv[1:]) -> None:
+    """
+    ``main`` executes the ``pymcnp file`` command.
+
+    ``main`` processes the given command line arguments, and creates or deletes
+    PyMCNP aliased INP objects.
+
+    Parameters:
+        argv: Tokenized list of CLI arguments.
+    """
+
+    args = docopt.docopt(PYMCNP_INP_DOC, argv=argv)
+
+    if args['--read']:
+        # Adding alias to save.
+        try:
+            _state.table.append(args['<alias>'], args['--read'])
+        except ValueError:
+            print('ALREADY!')
+    elif args['--delete']:
+        # Removing alias from save.
+        try:
+            _state.table.remove(args['<alias>'])
+        except ValueError:
+            print('NOT THERE!')

pymcnp/cli/ls.py

@@ -0,0 +1,161 @@
+"""
+``ls`` provides utilities for listing MCNP information.
+
+``ls`` contains the procedures for executing the ``pymcnp ls`` command and
+utilities for listing MCNP information.
+"""
+
+import sys
+from typing import Final
+
+import docopt
+
+from ..files import inp
+from . import _state
+
+
+class Ls:
+    """
+    ``Ls``
+    """
+
+    def __init__(self, inpt: inp.Inp):
+        """
+        ``__init__`` initializes ``Ls``.
+        """
+
+        if inpt is None:
+            raise ValueError
+
+        self.inpt: Final[inp.Inp] = inpt
+
+    def list_cells(self) -> str:
+        """
+        ``list_cells`` tabulates INP object cell card information.
+
+        Returns:
+            String of INP object cell information.
+        """
+
+        out = (
+            '\x1b[4m{:^12.12}\x1b[24m ' * 3 + '\x1b[4m{:^25.25}\x1b[24m \x1b[4m{:^25.25}\x1b[24m\n'
+        )
+        out = out.format('NUMBER', 'MATERIAL', 'DENSITY', 'GEOMETRY', 'OPTIONS')
+
+        for cell in self.inpt.cells._cards.values():
+            out += (
+                f"{cell.number.to_mcnp():<12} "
+                f"{cell.material.to_mcnp():<12} "
+                f"{cell.density.to_mcnp() if cell.density.to_mcnp() else '':<12} "
+                f"{cell.geometry.to_mcnp():<25} {'':<25}\n"
+            )
+
+        return out
+
+    def list_surfaces(self) -> str:
+        """
+        ``list_surfaces`` tabulates INP object surface card information.
+
+        Returns:
+            String of INP object surface information.
+        """
+
+        out = '\x1b[4m{:^12.12}\x1b[24m \x1b[4m{:^12.12}\x1b[24m \x1b[4m{:^12.12}\x1b[24m \x1b[4m{:^51.51}\x1b[24m\n'
+        out = out.format('NUMBER', 'MNEMONIC', 'TRANSFORM', 'PARAMETERS')
+
+        for surface in self.inpt.surfaces._cards.values():
+            out += (
+                f"{surface.number.to_mcnp():<12} "
+                f"{surface.mnemonic.to_mcnp():<12} "
+                f"{surface.transfrom.to_mcnp() if surface.transform else '':<12} "
+                f"{'':<51}\n"
+            )
+
+        return out
+
+    def list_data(self) -> str:
+        """
+        ``list_data`` tabulates INP object data card information.
+
+        Returns:
+            String of INP object data information.
+        """
+
+        out = '\x1b[4m{:^12.12}\x1b[24m \x1b[4m{:^12.12}\x1b[24m \x1b[4m{:^12.12}\x1b[24m \x1b[4m{:^51.51}\x1b[24m\n'
+        out = out.format('NUMBER', 'SUFFIX', 'DESIGNATOR', 'PARAMETERS')
+
+        for datum in self.inpt.data._cards.values():
+            out += (
+                f"{datum.mnemonic:<12.12} "
+                f"{datum.suffix.to_mcnp() if hasattr(datum, 'suffix') else '':<12} "
+                f"{datum.designator.to_mcnp() if hasattr(datum, 'designator') else '':<12} "
+                f"{'':<51.51}\n"
+            )
+
+        return out
+
+    @staticmethod
+    def list_inpts(inpts: tuple[str, inp.Inp]) -> str:
+        """
+        ``list_inpts`` tabulates INP objects.
+
+        Returns:
+            String of INP object inpt information.
+        """
+
+        out = '\x1b[4m{:^25.25}\x1b[24m \x1b[4m{:^51.51}\x1b[24m \x1b[4m{:^51.51}\x1b[24m\n'.format(
+            'NAME', 'TITLE', 'OTHER'
+        )
+        for alias, inpt in list(inpts):
+            out += f'{alias:<25.25} {inpt.title:<51.51} {repr(inpt.other):<51.51}\n'
+
+        return out
+
+
+PYMCNP_LS_DOC = """
+Usage:
+    pymcnp ls [(<alias> (--cells|--surfaces|--data)...)]
+
+Options:
+    -f --file      List from INP file.
+    -c --cells     List aliased INP cell cards.
+    -s --surfaces  List aliased INP surface cards.
+    -d --data      List aliased INP data cards.
+"""
+
+
+def main(argv: list[str] = sys.argv[1:]) -> None:
+    """
+    ``main`` executes the ``pymcnp ls`` command.
+
+    ``main`` processes the given command line arguments, and it lists, prints,
+    and tabulates PyMCNP object contents.
+
+    Parameters:
+        argv: Tokenized list of CLI arguments.
+    """
+
+    args = docopt.docopt(PYMCNP_LS_DOC, argv=argv)
+
+    if args['<alias>']:
+        # Listing aliased PyMCNP object content.
+
+        try:
+            filename = _state.table.access(args['<alias>'])
+        except ValueError:
+            print('NOPE!')
+            exit(1)
+
+        ls = Ls(inp.Inp.from_mcnp_file(filename))
+
+        if args['--cells']:
+            print(ls.list_cells())
+        if args['--surfaces']:
+            print(ls.list_surfaces())
+        if args['--data']:
+            print(ls.list_data())
+    else:
+        # Listing all aliased PyMCNP objects.
+        print(
+            Ls.list_inpts([(alias, inp.Inp.from_mcnp_file(path)) for alias, path in _state.table])
+        )