kdsource 0.2.0__py3-none-win_amd64.whl

kdsource/__init__.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Python module for creating and optimizing KDSource objects.
+
+KDSource's are particle sources for Monte Carlo radiation transport
+simulations. The full distribution and documentation can be found in the
+project GitHub page:
+
+    https://github.com/KDSource/KDSource
+
+A KDSource object is based on a particle list in MCPL format (see
+https://mctools.github.io/mcpl/), on which a Kernel Density Estimation
+(KDE) is applied, using KDEpy library (see
+https://github.com/tommyod/KDEpy).
+
+With kdsource Python library you can create, optimize, and export
+KDSource objects as XML files. These files can be later used as
+distributional sources in other Monte Carlo simulations, using the tools
+available in the full distribution.
+
+If you use KDSource tools in your work, please add the following
+reference:
+
+    Abbate, O. I., Schmidt, N. S., Prieto, Z. M., Robledo, J. I.,
+    Dawidowski, J., Márquez, A. A., & Márquez Damián, J. I. KDSource,
+    a tool for the generation of Monte Carlo particle sources using
+    kernel density estimation [Computer software].
+    https://github.com/KDSource/KDSource
+
+"""
+
+__version__ = "0.2.0"
+versionint = int('2000')
+version = ( int('0'),
+            int('2'),
+            int('0') )
+__author__ = "KDSource"
+
+#NOTE: Keep __init__.py essentially empty. In particular, no import statements
+#here.

kdsource/_chooks.py

@@ -0,0 +1,101 @@
+def _str2cstr(s):
+    #converts any string (str,bytes,unicode,path) to bytes
+    if hasattr(s,'__fspath__'):
+        s = str(s)
+    try:
+        return s if isinstance(s,bytes) else s.encode('utf8')
+    except UnicodeEncodeError as e:
+        from .exceptions import NCBadInput
+        raise NCBadInput("Only unicode strings are supported") from e
+
+def _cstr2str(s):
+    #converts bytes object to str
+    try:
+        return s if isinstance(s,str) else s.decode('utf8')
+    except UnicodeDecodeError as e:
+        from .exceptions import NCBadInput
+        raise NCBadInput("Only UTF8-encoded C-strings are supported") from e
+
+__cache_fcts=[None]
+def _load_fcts():
+    if __cache_fcts[0] is not None:
+        return __cache_fcts[0]
+    from ._chooks_loadlib import _loadlib_kdsource
+    import ctypes
+    allfcts = {}
+    lib = _loadlib_kdsource()
+
+    ###### resample_to_mcpl
+    kds_rng_fct_t = ctypes.CFUNCTYPE( ctypes.c_double )
+    rawfct_rs = lib.kdsource_resample_to_mcpl
+    rawfct_rs.restype=None
+    rawfct_rs.argtypes=( kds_rng_fct_t,
+                         ctypes.c_char_p,
+                         ctypes.c_char_p,
+                         ctypes.c_uint64 )
+    def fct_rs( rng_fct, kds_sourcefile, destination_mcpl, nout ):
+        rawfct_rs( kds_rng_fct_t(rng_fct),
+                   _str2cstr(kds_sourcefile),
+                   _str2cstr(destination_mcpl),
+                   ctypes.c_uint64(nout) )
+    allfcts['resample_to_mcpl'] = fct_rs
+
+    ###### write_mcpl
+    dblptr = ctypes.POINTER(ctypes.c_double)
+    int32ptr = ctypes.POINTER(ctypes.c_int32)
+    uint32ptr = ctypes.POINTER(ctypes.c_uint32)
+    rawfct_wm = lib.kdsource_write_mcpl
+    rawfct_wm.restype = None
+    rawfct_wm.argtypes=( ctypes.c_char_p,ctypes.c_uint64,ctypes.c_uint,
+                         dblptr,dblptr,dblptr,
+                         dblptr,dblptr,dblptr,dblptr,dblptr,dblptr,int32ptr,
+                         dblptr,dblptr,dblptr, uint32ptr)
+    def get_ndarray_to_cptr():
+        import numpy as np
+        def ndarray_fix_type(arr, dtypename):
+            a = np.asarray(arr)
+            dt = np.dtype(dtypename)
+            if a.dtype == dt and a.flags['C_CONTIGUOUS']:
+                return a
+            return a.astype(dt, copy=True)
+        def ndarray_to_cptr(keepalive,a,dtypename='float64',cptr=dblptr):
+            keepalive.append( ndarray_fix_type(a,dtypename) )
+            return keepalive[-1].ctypes.data_as(cptr)
+        return ndarray_to_cptr
+    def fct_wm( filename, nparticles,
+                ekin, x, y, z, ux, uy, uz, time, weight, pdgcode,
+                polx, poly, polz, userflags, double_prec ):
+        import numbers
+        flags = 1 if double_prec else 0
+        keepalive=[]
+        a2c = get_ndarray_to_cptr()
+        if isinstance(pdgcode, numbers.Integral):
+            flags += 2
+            pdgcode_array =  (ctypes.c_int32 * 1)(int(pdgcode))
+            pdgcode_arg = ctypes.cast(pdgcode_array, int32ptr)
+        else:
+            pdgcode_arg = a2c(keepalive,pdgcode,'int32',int32ptr)
+        if isinstance(weight, numbers.Number):
+            flags += 4
+            weight_array =  (ctypes.c_double * 1)(float(weight))
+            weight_arg = ctypes.cast(weight_array, dblptr)
+        else:
+            weight_arg = a2c(keepalive,weight)
+
+        c_polx = a2c(keepalive,polx) if polx is not None else None
+        c_poly = a2c(keepalive,poly) if poly is not None else None
+        c_polz = a2c(keepalive,polz) if polz is not None else None
+        c_userflags = ( a2c(keepalive,pdgcode,'uint32',uint32ptr)
+                        if userflags is not None else None )
+        rawfct_wm( _str2cstr(filename),
+                   ctypes.c_uint64(nparticles),
+                   ctypes.c_uint(flags),
+                   a2c(keepalive,ekin),
+                   a2c(keepalive,x), a2c(keepalive,y), a2c(keepalive,z),
+                   a2c(keepalive,ux), a2c(keepalive,uy), a2c(keepalive,uz),
+                   a2c(keepalive,time), weight_arg, pdgcode_arg,
+                   c_polx, c_poly, c_polz, c_userflags )
+    allfcts['write_mcpl'] = fct_wm
+
+    __cache_fcts[0]=allfcts
+    return __cache_fcts[0]

kdsource/_chooks_loadlib.py

@@ -0,0 +1,34 @@
+_loadlib_cache = [None,None]
+def _loadlib_kdsource():
+    if _loadlib_cache[1]:
+        return _loadlib_cache[1]
+    from .config import config
+    _loadlib_cache[0] = _loadlib_frompath(_get_mcpl_shlibpath())
+    _loadlib_cache[1] = _loadlib_frompath(config('shlibpath'))
+    return _loadlib_cache[1]
+
+def _loadlib_mcpl():
+    if _loadlib_cache[0] is None:
+        _loadlib_kdsource()
+    return _loadlib_cache[0]
+
+def _get_mcpl_shlibpath():
+    import subprocess
+    rv = subprocess.run( ['mcpl-config','--show','shlibpath'],
+                         check = True, capture_output = True )
+    if rv.returncode or rv.stderr:
+        raise RuntimeError('Problems invoking mcpl-config for shlibpath')
+    import pathlib
+    return pathlib.Path(rv.stdout.decode().strip()).absolute().resolve()
+
+def _loadlib_frompath(libpath):
+    import ctypes
+    try:
+        lib = ctypes.CDLL(libpath)
+    except TypeError:
+        lib = None
+    if lib is None:
+        #On Windows, providing a Path rather than str can yield TypeError:
+        lib = ctypes.CDLL(str(libpath))
+    return lib
+

kdsource/_cli_config.py

@@ -0,0 +1,55 @@
+
+def parse_args(argv=None):
+    from argparse import ArgumentParser
+    from .config import config_items
+    import textwrap
+    def wrap(t,w=59):
+        return textwrap.fill( ' '.join(t.split()), width=w )
+
+    parser = ArgumentParser(
+        description
+        ='Provide basic information about KDSource installation'
+    )
+    parser.add_argument('-v','--version',action='store_true',
+                        help=wrap("""Show the KDSource version number and
+                        exit."""))
+    parser.add_argument('-i','--intversion',action='store_true',
+                        help=wrap("""Show KDSource version encoded into
+                        single integral number (e.g. v1.2.3 is 1002003) and
+                        exit."""))
+    parser.add_argument('-s','--summary',action='store_true',
+                        help=wrap("""Print summary information about
+                        installation and exit.  This displays all the
+                        information that is otherwise available via the --show
+                        flag."""))
+    parser.add_argument("--show",metavar="ITEM", choices=['list']+config_items,
+                        help=wrap("""Print value of the requested information
+                        ITEM for the current NCrystal installation and exit. Run
+                        with "--show list" to get a list of available ITEM
+                        values."""))
+    return parser.parse_args(argv)
+
+
+def main(argv=None):
+    from .config import summary, config, config_items
+    args = parse_args(argv)
+    if args.version:
+        print(config('version'))
+    elif args.intversion:
+        print(config('intversion'))
+    elif args.summary:
+        summary()
+    elif args.show:
+        if args.show == 'list':
+            for c in sorted(config_items):
+                print(c)
+        elif args.show not in config_items:
+            raise SystemExit('ERROR: Unknown configuration item "%s"'%args.show)
+        else:
+            print(config(args.show))
+    else:
+        summary()
+
+
+if __name__ == '__main__':
+    main()

kdsource/_cli_resample.py

@@ -0,0 +1,38 @@
+
+def parse_args(argv=None):
+    from argparse import ArgumentParser
+    import textwrap
+    def wrap(t,w=59):
+        return textwrap.fill( ' '.join(t.split()), width=w )
+
+    parser = ArgumentParser(
+        description=wrap("""Generate new MCPL files based upon an existing
+                            kernel density estimate XML file.""",
+                         79 )
+    )
+    parser.add_argument('kdefile',metavar='KDEFILE',
+                        help=wrap("""Kernel Density Estimate .xml file generated
+                        via KDSource python interface."""))
+    parser.add_argument('outmcpl',metavar='OUTMCPL',
+                        help=wrap("""Name of MCPL file which will be created."""))
+    parser.add_argument('nparticles',metavar='NPARTICLES',type=int,
+                        help=wrap("""Number of particles to sample and place in
+                        OUTMCPL."""))
+    parser.add_argument('-s','--seed',metavar='SEED',type=int,
+                        help=wrap("""Seed value of Number of particles to sample
+                        and place in OUTMCPL. If not set, a random seed is
+                        generated (based on bytes from os.urandom)."""))
+    parser.add_argument('-f','--force',action='store_true',
+                        help=wrap("""Will overwrite existing file if it already
+                        exists."""))
+
+    return parser.parse_args(argv)
+
+def main(argv=None):
+    from .resample import resample_to_mcpl
+    args = parse_args(argv)
+    resample_to_mcpl( args.kdefile, args.outmcpl, args.nparticles,
+                      force=args.force, rng = args.seed )
+
+if __name__ == '__main__':
+    main()

kdsource/_fact_dos_data.py

@@ -0,0 +1,194 @@
+_cache = {}
+def load(datakey):
+    if datakey in _cache:
+        return _cache[datakey]
+    import numpy
+    _cache[datakey] = numpy.fromstring(_data[datakey], unpack=True, sep=None)
+    return _cache[datakey]
+
+_data = {
+    'ARN_neutron' :
+"""0.          0.0
+2.53E-02 1.06E+01
+2.00E+03 7.70E+00
+2.50E+04 1.93E+01
+1.44E+05 1.27E+02
+2.50E+05 2.03E+02
+5.65E+05 3.43E+02
+1.20E+06 4.25E+02
+2.50E+06 4.16E+02
+2.80E+06 4.13E+02
+3.20E+06 4.11E+02
+5.00E+06 4.05E+02
+1.48E+07 5.36E+02
+1.90E+07 5.84E+02
+5.00E+07 5.84E+02
+""",
+    'ARN_photon' :
+"""0.0         0.0
+1.00E+04 6.10E-02
+1.50E+04 8.30E-01
+2.00E+04 1.05E+00
+3.00E+04 8.10E-01
+4.00E+04 6.40E-01
+5.00E+04 5.50E-01
+6.00E+04 5.10E-01
+8.00E+04 5.30E-01
+1.00E+05 6.10E-01
+1.50E+05 8.90E-01
+2.00E+05 1.20E+00
+3.00E+05 1.80E+00
+4.00E+05 2.38E+00
+5.00E+05 2.93E+00
+6.00E+05 3.44E+00
+8.00E+05 4.38E+00
+1.00E+06 5.20E+00
+1.50E+06 6.90E+00
+2.00E+06 8.60E+00
+3.00E+06 1.11E+01
+4.00E+06 1.34E+01
+5.00E+06 1.55E+01
+6.00E+06 1.76E+01
+8.00E+06 2.16E+01
+1.00E+07 2.56E+01
+5.00E+07 2.56E+01
+""",
+    'ICRP_neutron':
+    """0.00        0.00
+1.00E-03 3.09E+00
+1.00E-02 3.55E+00
+2.50E-02 4.00E+00
+1.00E-01 5.20E+00
+2.00E-01 5.87E+00
+5.00E-01 6.59E+00
+1.00E+00 7.03E+00
+2.00E+00 7.39E+00
+5.00E+00 7.71E+00
+1.00E+01 7.82E+00
+2.00E+01 7.84E+00
+5.00E+01 7.82E+00
+1.00E+02 7.79E+00
+2.00E+02 7.73E+00
+5.00E+02 7.54E+00
+1.00E+03 7.54E+00
+2.00E+03 7.61E+00
+5.00E+03 7.97E+00
+1.00E+04 9.11E+00
+2.00E+04 1.22E+01
+3.00E+04 1.57E+01
+5.00E+04 2.30E+01
+7.00E+04 3.06E+01
+1.00E+05 4.19E+01
+1.50E+05 6.06E+01
+2.00E+05 7.88E+01
+3.00E+05 1.14E+02
+5.00E+05 1.77E+02
+7.00E+05 2.32E+02
+9.00E+05 2.79E+02
+1.00E+06 3.01E+02
+1.20E+06 3.30E+02
+1.50E+06 3.65E+02
+2.00E+06 4.07E+02
+3.00E+06 4.58E+02
+4.00E+06 4.83E+02
+5.00E+06 4.94E+02
+6.00E+06 4.98E+02
+7.00E+06 4.99E+02
+8.00E+06 4.99E+02
+9.00E+06 5.00E+02
+1.00E+07 5.00E+02
+1.20E+07 4.99E+02
+1.40E+07 4.95E+02
+1.50E+07 4.93E+02
+1.60E+07 4.90E+02
+1.80E+07 4.84E+02
+2.00E+07 4.77E+02
+2.10E+07 4.74E+02
+3.00E+07 4.53E+02
+5.00E+07 4.33E+02
+7.50E+07 4.39E+02
+1.00E+08 4.44E+02
+1.30E+08 4.46E+02
+1.50E+08 4.46E+02
+1.80E+08 4.47E+02
+2.00E+08 4.48E+02
+3.00E+08 4.73E+02
+4.00E+08 5.15E+02
+5.00E+08 5.33E+02
+6.00E+08 5.69E+02
+7.00E+08 6.25E+02
+8.00E+08 6.38E+02
+9.00E+08 6.45E+02
+1.00E+09 6.63E+02
+2.00E+09 7.69E+02
+5.00E+09 1.04E+03
+1.00E+10 1.39E+03
+""",
+    'ICRP_photon':
+    """0.00        0.00
+5.00E+03 1.34E-02
+6.00E+03 1.66E-02
+7.00E+03 2.25E-02
+8.00E+03 3.35E-02
+9.00E+03 4.90E-02
+1.00E+04 6.85E-02
+1.20E+04 1.05E-01
+1.30E+04 1.22E-01
+1.50E+04 1.56E-01
+1.70E+04 1.81E-01
+2.00E+04 2.25E-01
+2.50E+04 2.75E-01
+3.00E+04 3.12E-01
+4.00E+04 3.50E-01
+5.00E+04 3.69E-01
+6.00E+04 3.89E-01
+7.00E+04 4.11E-01
+8.00E+04 4.43E-01
+1.00E+05 5.18E-01
+1.50E+05 7.47E-01
+2.00E+05 1.00E+00
+3.00E+05 1.51E+00
+4.00E+05 2.00E+00
+5.00E+05 2.47E+00
+5.11E+05 2.52E+00
+6.00E+05 2.91E+00
+6.62E+05 3.17E+00
+8.00E+05 3.73E+00
+1.00E+06 4.49E+00
+1.12E+06 4.90E+00
+1.33E+06 5.60E+00
+1.50E+06 6.12E+00
+2.00E+06 7.48E+00
+3.00E+06 9.75E+00
+4.00E+06 1.17E+01
+5.00E+06 1.34E+01
+6.00E+06 1.50E+01
+6.13E+06 1.52E+01
+8.00E+06 1.86E+01
+1.00E+07 2.21E+01
+1.50E+07 3.04E+01
+2.00E+07 3.82E+01
+3.00E+07 5.13E+01
+4.00E+07 6.18E+01
+5.00E+07 7.23E+01
+6.00E+07 8.21E+01
+8.00E+07 9.81E+01
+1.00E+08 1.10E+02
+1.50E+08 1.30E+02
+2.00E+08 1.44E+02
+3.00E+08 1.61E+02
+4.00E+08 1.73E+02
+5.00E+08 1.81E+02
+6.00E+08 1.87E+02
+8.00E+08 1.96E+02
+1.00E+09 2.06E+02
+1.50E+09 2.13E+02
+2.00E+09 2.36E+02
+3.00E+09 2.53E+02
+4.00E+09 2.67E+02
+5.00E+09 2.77E+02
+6.00E+09 2.85E+02
+8.00E+09 2.99E+02
+1.00E+10 3.07E+02
+"""
+}

kdsource/api.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Python module for creating and optimizing KDSource objects.
+
+KDSource's are particle sources for Monte Carlo radiation transport
+simulations. The full distribution and documentation can be found in the
+project GitHub page:
+
+    https://github.com/KDSource/KDSource
+
+A KDSource object is based on a particle list in MCPL format (see
+https://mctools.github.io/mcpl/), on which a Kernel Density Estimation
+(KDE) is applied, using KDEpy library (see
+https://github.com/tommyod/KDEpy).
+
+With kdsource Python library you can create, optimize, and export
+KDSource objects as XML files. These files can be later used as
+distributional sources in other Monte Carlo simulations, using the tools
+available in the full distribution.
+
+If you use KDSource tools in your work, please add the following
+reference:
+
+    Abbate, O. I., Schmidt, N. S., Prieto, Z. M., Robledo, J. I.,
+    Dawidowski, J., Márquez, A. A., & Márquez Damián, J. I. KDSource,
+    a tool for the generation of Monte Carlo particle sources using
+    kernel density estimation [Computer software].
+    https://github.com/KDSource/KDSource
+
+"""
+
+__version__ = "0.2.0"
+versionint = int('2000')
+version = ( int('0'),
+            int('2'),
+            int('0') )
+__author__ = "KDSource"
+
+#Convenience module with ~all imports (leaving __init__.py empty as per
+#best-practice, and to not make e.g. CLI scripts fail due to missing un-needed
+#dependency)
+from . import geom  #noqa F401
+from . import kde  #noqa F401
+from . import plist  #noqa F401
+from .geom import Geometry, Metric  #noqa F401
+from .kde import bw_silv  #noqa F401
+from .kdsource import KDSource, load  #noqa F401
+from .plist import PList, appendssv, convert2mcpl, join2mcpl, savessv  #noqa F401
+from .writemcpl import write_mcpl #noqa F401
+from .resample import resample_to_mcpl #noqa F401

kdsource/config.py

@@ -0,0 +1,121 @@
+import pathlib as _p
+_datadir = _p.Path(__file__).parent.joinpath('data').absolute()
+config_items = [
+    'version',
+    'intversion',
+    'includedir',
+    'libdir',
+    'libpath',
+    'libname',
+    'shlibdir',
+    'shlibpath',
+    'shlibname',
+    'buildflags',
+]
+
+def summary():
+    """Print summary of all config items"""
+    print("KDSource v%s with configuration:"%config('version'))
+    print()
+    maxlen = max(len(item) for item in config_items)
+    for item in config_items:
+        print('  %s : %s'%(item.rjust(maxlen),config(item)))
+
+_config_cache={}
+def config(item):
+    """Return configuration item (available are those in the config_item list).
+    """
+    c = _config_cache.get(item)
+    if c is not None:
+        return c
+    c = _config_deduce(item)
+    _config_cache[item] = c
+    return c
+
+def _config_deduce(item):
+    if item not in config_items:
+        raise RuntimeError(f"unknown config item: {item}")
+    if 'lib' not in item:
+        if item=='includedir':
+            return _datadir.joinpath('include')
+        if item=='buildflags':
+            import platform
+            if platform.system()=='Windows':
+                return '"/I%s" "%s"'%(config('includedir'),config('libpath'))
+            import shlex
+            return shlex.join(
+                shlex.quote(e)
+                for e in [ "-Wl,-rpath,%s"%config('libdir'),
+                           "-Wl,%s"%config('libpath'),
+                           "-I%s"%config('includedir') ]
+            )
+        if item=='intversion':
+            return "2000"
+        if item=='version':
+            return "0.2.0"
+
+    winsuffix = '.lib'
+    look_in_scripts_for_dll = False
+    if item.startswith('sh'):
+        winsuffix = '.dll'
+        item = item[2:]
+        #The next is only True on Windows in python installations:
+        look_in_scripts_for_dll = bool('1')
+
+    if look_in_scripts_for_dll:
+        p = _win_find_dll()
+        if item=='libdir':
+            return p.parent
+        return p.name if item=='libname' else p
+
+    libdir = _datadir.joinpath('lib')
+
+    if item=='libdir':
+        return libdir
+
+    libs = list( e for e in libdir.glob('*') if 'kdsource' in e.name.lower() )
+    libs_win = [ e for e in libs if e.name.lower().endswith(winsuffix) ]
+    libs_other = [ e for e in libs if not e.name.lower().endswith(winsuffix) ]
+    libs = libs_win or libs_other
+
+    if not libs:
+        raise RuntimeError('Inconsistent installation of KDSource'
+                           ' (could not find shared lib)')
+    if len(libs)!=1:
+        s = ' '.join(e.name for e in libs)
+        raise RuntimeError('Inconsistent installation of KDSource (multiple'
+                           f' libs: {s})')
+    assert len(libs)==1
+    return libs[0].name if item=='libname' else libs[0]
+
+__cache_windll = [None]
+def _win_find_dll():
+    #Windows. The DLL is in the scripts directory (to be in %PATH%). To be safe
+    #we look not only in the default scheme, but also in a few other preferred
+    #schemes. The sysconfig usage below assumes python 3.10 or later:
+    if __cache_windll[0] is not None:
+        return __cache_windll[0]
+
+    import sysconfig
+    import pathlib
+    schemes = [ sysconfig.get_default_scheme() ]
+    for scheme_key in ['prefix','home','user']:
+        scheme = sysconfig.get_preferred_scheme(scheme_key)
+        if scheme not in schemes:
+            schemes.append(scheme)
+    ln, ln2, res = 'kdsource.dll', 'kdsource.DLL', None
+    for scheme in schemes:
+        p = pathlib.Path( sysconfig.get_path('scripts',scheme) )
+        p1 = p.joinpath(ln)
+        if p1.is_file():
+            res = p1
+            break
+        p2 = p.joinpath(ln2)
+        if p2.is_file():
+            res = p2
+            break
+    if res is None:
+        raise RuntimeError('Unable to locate shared library (expected '
+                           f'{ln} in Python site scripts directory)')
+    __cache_windll[0] = res.absolute().resolve()
+    return __cache_windll[0]