ncrystal-python 4.2.12__py3-none-any.whl → 4.3.2__py3-none-any.whl

NCrystal/__init__.py

@@ -55,7 +55,7 @@ For detailed usage conditions and licensing of this open source project, see:
 
 #NB: Synchronize meta-data below with fields in setup.py+template_setup.py.in meta data:
 __license__ = "Apache 2.0, http://www.apache.org/licenses/LICENSE-2.0"
-__version__ = '4.2.12'
+__version__ = '4.3.2'
 __status__ = "Production"
 __author__ = "NCrystal developers (Thomas Kittelmann, Xiao Xiao Cai)"
 __copyright__ = "Copyright 2015-2024 %s"%__author__

NCrystal/_chooks.py

@@ -162,8 +162,9 @@ def _load(nclib_filename, ncrystal_namespace_protection ):
             def fct(*args):
                 return raw(*args)
         if error_check:
-            #NB: we should read about return types in the ctypes tutorial. Apparently one
-            #can just set an error checking function as the restype.
+            #NB: we should read about return types in the ctypes
+            #tutorial. Apparently one can just set an error checking function as
+            #the restype.
             raw_fct = fct
             def fcte(*aaa):
                 r = raw_fct(*aaa)
@@ -284,12 +285,15 @@ def _load(nclib_filename, ncrystal_namespace_protection ):
     functions['iter_hkllist']=iter_hkllist
 
     _raw_dealloc_dblptr = _wrap('ncrystal_dealloc_doubleptr',None,(_dblp,),hide=True)
-    def _cptr_to_nparray( cptr, n, free_after_with_ncrystal_dealloc = True ):
+
+    def _cptr_to_nparray( cptr, n, dealloc = True ):
         import numpy.ctypeslib as _np_ctypeslib
-        np_arr = _np_ctypeslib.as_array(cptr,shape=(int(n.value if hasattr(n,'value') else n),)).copy()
-        if free_after_with_ncrystal_dealloc:
+        s = (int( n.value if hasattr(n,'value') else n ),)
+        a = _np_ctypeslib.as_array( cptr, shape=s )
+        a = a.copy()
+        if dealloc:
             _raw_dealloc_dblptr(cptr)
-        return np_arr
+        return a
 
     _wrap('ncrystal_info_ndyninfo',_uint,(ncrystal_info_t,))
     _raw_di_base = _wrap('ncrystal_dyninfo_base',None,(ncrystal_info_t,_uint,_dblp,_uintp,_dblp,_uintp),hide=True)
@@ -820,49 +824,91 @@ def _load(nclib_filename, ncrystal_namespace_protection ):
         _raw_setmsghandler(keepalive[-1])
     functions['setmsghandler'] = ncrystal_setmsghandler
 
-    _raw_runmmcsim_stdengine    = _wrap('ncrystal_runmmcsim_stdengine',None,
-                                        (_uint,_uint,
-                                         _cstr,_cstr,_cstr,
-                                         _charptrptr,_uintp,_dblpp,_dblpp),
-                                        hide=True)
-    def nc_runmmcsim_stdengine( nthreads,
-                                tally_detail_lvl,
-                                mat_cfgstr,
-                                mmc_geomcfg,
-                                mmc_srccfg ):
-        nthreads_ = _uint(int(nthreads))
-        assert 0<=tally_detail_lvl<=2
-        tally_detail_lvl_ = _uint(int(tally_detail_lvl))
-        mat_cfgstr_ = _str2cstr(mat_cfgstr)
-        mmc_geomcfg_ = _str2cstr(mmc_geomcfg)
-        mmc_srccfg_ = _str2cstr(mmc_srccfg)
-        t_json = _charptr()
-        t_exitangle_nbins = _uint()
-        t_exitangle_ct = _dblp()
-        t_exitangle_errsq = _dblp()
-        _raw_runmmcsim_stdengine( nthreads_,
-                                  tally_detail_lvl_,
-                                  mat_cfgstr_,
-                                  mmc_geomcfg_,
-                                  mmc_srccfg_,
-                                  t_json,
-                                  t_exitangle_nbins,
-                                  ctypes.byref(t_exitangle_ct),
-                                  ctypes.byref(t_exitangle_errsq) )
-        if t_json is not None:
-            t_json_cstr = ctypes.cast(t_json,_cstr).value
-            if t_json_cstr is not None:
-                _ = _cstr2str(t_json_cstr)
-                _raw_deallocstr(t_json)
-                t_json = _
-            else:
-                t_json = None
+    _raw_jsonquery = _wrap('ncrystal_jsonquery',_charptr,(_cstr,), hide=True)
 
-        tally_exitangle_contents = _cptr_to_nparray( t_exitangle_ct, t_exitangle_nbins )
-        tally_exitangle_errsq = _cptr_to_nparray( t_exitangle_errsq, t_exitangle_nbins )
-        return tally_exitangle_contents,tally_exitangle_errsq,t_json
+    def prepare_query_cstr( query ):
+        if not query:
+            raise NCBadInput("Missing or empty query")
+        sc = '\x07'
+        str_query = sc.join(query)
+        if len(query) != str_query.count(sc)+1:
+            raise NCBadInput("Can not use character 0x07 (ASCII BEL) in"
+                             " JSON query strings" )
+        return _str2cstr(str_query)
 
-    functions['runmmcsim_stdengine']=nc_runmmcsim_stdengine
+    def decode_query_result( raw_str ):
+        assert raw_str is not None
+        res=_cstr2str(ctypes.cast(raw_str,_cstr).value)
+        _raw_deallocstr(raw_str)
+        return res
+
+    def jsonquery( query ):
+        cstr_query = prepare_query_cstr(query)
+        raw_str = _raw_jsonquery( cstr_query )
+        return decode_query_result(raw_str)
+    functions['jsonquery'] = jsonquery
 
+    _FLEXMMCRUNCBTYPE = ctypes.CFUNCTYPE( _uint, _dblpp, _ulong, _ulong )
+    _raw_flexmmcrun = _wrap( 'ncrystal_flexmmcrun',_charptr,
+                             (_cstr,_cstr,_FLEXMMCRUNCBTYPE ), hide=True )
+    def flexmmcrun( query, user_callback, callback_options ):
+        _ensure_numpy()
+        cstr_query = prepare_query_cstr(query)
+        cb_errors = []
+        def cb_wrapper( data, cbtype, data_len ):
+            if cb_errors:
+                return 2
+            rv = 0
+            try:
+                cbtype = int(cbtype)
+                assert cbtype in (1,2)
+
+                n = int(data_len)
+                assert 0 < n <= 1000000000
+                def load( i ):
+                    return _cptr_to_nparray( data[i], n, dealloc=False)
+
+                pydata = dict( x = load(0), y = load(1), z = load(2),
+                               ux = load(3), uy = load(4), uz = load(5),
+                               ekin = load(6), w = load(7), nscat = load(8),
+                               nscat_inelas = load(9) )
+                if cbtype==2:
+                    pydata.update(
+                        dict( x0 = load(10), y0 = load(11), z0 = load(12),
+                              ux0 = load(13),uy0 = load(14), uz0 = load(15),
+                              ekin0 = load(16), w0 = load(17) )
+                    )
+
+                user_rv = user_callback( pydata )
+                #TODO: Currently not aborting a long simjob on ctrl-C if
+                #      nthreads>2. Tricky to fix.
+                if not bool(user_rv):
+                    rv = 0 # STD (usual case)
+                else:
+                    #HALTERR or HALTSRC:
+                    rv = ( 2 if ( isinstance(user_rv,str)
+                                  and user_rv=='error' ) else 1 )
+                    if rv == 2 and not cb_errors:
+                        cb_errors.append(None)
+            except BaseException as exc:
+                rv = 2
+                cb_errors.append(exc)
+                del exc #maybe not needed, but exc.__traceback__ references the
+                        #function frame, so the function frame best not
+                        #reference exc.
+            return rv
+
+        cb_c = _FLEXMMCRUNCBTYPE(cb_wrapper)
+        cbopt_c = None
+        if callback_options is not None and callback_options.strip():
+            cbopt_c = _str2cstr(callback_options)
+        raw_str = _raw_flexmmcrun( cstr_query, cbopt_c, cb_c )
+        if cb_errors:
+            #Rethrow exception from callback function
+            user_callback_exception = cb_errors[0]
+            raise user_callback_exception
+        return decode_query_result(raw_str)
+
+    functions['flexmmcrun'] = flexmmcrun
 
     return functions

NCrystal/_cli_cif2ncmat.py

@@ -23,6 +23,13 @@ from ._cliimpl import ( create_ArgumentParser,
                         cli_entry_point,
                         print )
 
+def climod_metadata():
+    return dict(
+        displaygroup = 'conv',
+        displayorder = 10,
+        descr = "Create NCMAT data based on CIF input."
+    )
+
 def parseArgs( progname, arglist, return_parser=False ):
     import textwrap
     helpw = 60

NCrystal/_cli_endf2ncmat.py

@@ -30,6 +30,13 @@ from . import core as nccore
 import warnings
 import pathlib
 
+def climod_metadata():
+    return dict(
+        displaygroup = 'conv',
+        displayorder = 999,
+        descr = "Import ENDF data to NCMAT format (based on PyNE)."
+    )
+
 __pynecache=[None]
 def import_pyne():
     global __pynecache
@@ -38,10 +45,12 @@ def import_pyne():
 
     try:
         with warnings.catch_warnings():
-            warnings.simplefilter("ignore")#silence annoying pyne.endf QAWarning's.
+            #silence annoying pyne.endf QAWarning's:
+            warnings.simplefilter("ignore")
             import pyne.endf
     except ImportError:
-        raise RuntimeError('Could not "import pyne.endf". You probably need to install PyNE (see http://pyne.io/)')
+        raise RuntimeError('Could not "import pyne.endf". You probably need'
+                           ' to install PyNE (see http://pyne.io/)')
 
     #Monkey-patch pyne.endf reader, which was ignoring optional sections with teff
     #curves of non-principal atoms (see

NCrystal/_cli_hfg2ncmat.py

@@ -23,6 +23,13 @@ from ._cliimpl import ( create_ArgumentParser,
                         cli_entry_point,
                         print )
 
+def climod_metadata():
+    return dict(
+        displaygroup = 'conv',
+        displayorder = 20,
+        descr = "Create NCMAT data for amorphous hydrogen-rich materials."
+    )
+
 def _parseArgs( default_debye_temp, progname, arglist, return_parser=False ):
     from argparse import RawTextHelpFormatter
 

NCrystal/_cli_mcstasunion.py

@@ -23,6 +23,13 @@ from ._cliimpl import ( create_ArgumentParser,
                         cli_entry_point,
                         print )
 
+def climod_metadata():
+    return dict(
+        displaygroup = 'misc',
+        displayorder = 999,
+        descr = "Generate McStas-Union code for using NCrystal materials."
+    )
+
 def parseArgs( progname, args, return_parser=False ):
 
     descr="""Output McStas-Union code in McStas instrument (.instr) format to