ncrystal-python 4.1.6__py3-none-any.whl → 4.2.0__py3-none-any.whl

NCrystal/__init__.py

@@ -48,14 +48,14 @@ additionally also use the following reference in your work:
 
 For detailed usage conditions and licensing of this open source project, see:
 
-   https://github.com/mctools/ncrystal/blob/master/NOTICE
-   https://github.com/mctools/ncrystal/blob/master/LICENSE
+   https://github.com/mctools/ncrystal/blob/HEAD/NOTICE
+   https://github.com/mctools/ncrystal/blob/HEAD/LICENSE
 
 """
 
 #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.1.6'
+__version__ = '4.2.0'
 __status__ = "Production"
 __author__ = "NCrystal developers (Thomas Kittelmann, Xiao Xiao Cai)"
 __copyright__ = "Copyright 2015-2024 %s"%__author__

NCrystal/_chooks.py

@@ -319,12 +319,24 @@ def _load(nclib_filename, ncrystal_namespace_protection ):
     functions['raw_vdos2gn'] = raw_vdos2gn
 
     _ORDERWEIGHTFCTTYPE = ctypes.CFUNCTYPE( _dbl, _uint )
-    _raw_vdos2knl = _wrap('ncrystal_raw_vdos2knl',None,(_dblp,_dblp,_uint,_uint,_dbl,_dbl,_dbl,_uint,_ORDERWEIGHTFCTTYPE,_uintp,_uintp,_dblpp,_dblpp,_dblpp),hide=True)
-    def raw_vdos2knl( egrid, density, scatxs, mass_amu, temperature, vdoslux, order_weight_fct ):
+    _raw_vdos2knl = _wrap('ncrystal_raw_vdos2kernel',None,
+                          (_dblp,_dblp,_uint,_uint,_dbl,_dbl,_dbl,_uint,
+                           _ORDERWEIGHTFCTTYPE,_uintp,_uintp,_dblpp,_dblpp,
+                           _dblpp,_dbl,_dblp),
+                          hide=True)
+    def raw_vdos2knl( egrid, density, scatxs, mass_amu, temperature,
+                      vdoslux, order_weight_fct, target_emax ):
         _ensure_numpy()
-        _egrid,_density = _np.asarray(egrid,dtype=float),_np.asarray(density,dtype=float)
-        _s,_m,_t,_vdl = _dbl(float(scatxs)),_dbl(float(mass_amu)),_dbl(float(temperature)),_uint(int(vdoslux))
-        nalpha, nbeta,agrid, bgrid, sab = _uint(), _uint(),_dblp(), _dblp(), _dblp()
+        _egrid = _np.asarray(egrid,dtype=float)
+        _density = _np.asarray(density,dtype=float)
+        _s = _dbl(float(scatxs))
+        _m = _dbl(float(mass_amu))
+        _t = _dbl(float(temperature))
+        _vdl = _uint(int(vdoslux))
+        _tgtemax = target_emax or 0.0
+        _tgtemax = _dbl( float(_tgtemax if _tgtemax>0.0 else 0.0 ) )
+        nalpha, nbeta, suggest_emax = _uint(), _uint(), _dbl()
+        agrid, bgrid, sab = _dblp(), _dblp(), _dblp()
         if order_weight_fct:
             def owf(order):
                 return float(order_weight_fct( int(order.value
@@ -336,11 +348,13 @@ def _load(nclib_filename, ncrystal_namespace_protection ):
             _owf = ctypes.cast(None, _ORDERWEIGHTFCTTYPE)
         _raw_vdos2knl( ndarray_to_dblp(_egrid), ndarray_to_dblp(_density),
                        _uint(len(_egrid)),_uint(len(_density)),
-                       _s,_m,_t,_vdl,_owf,nalpha, nbeta,
-                       ctypes.byref(agrid), ctypes.byref(bgrid), ctypes.byref(sab) )
+                       _s,_m,_t,_vdl,_owf, nalpha, nbeta,
+                       ctypes.byref(agrid), ctypes.byref(bgrid), ctypes.byref(sab),
+                       _tgtemax, suggest_emax )
         return ( _cptr_to_nparray( agrid, nalpha ),
                  _cptr_to_nparray( bgrid, nbeta ),
-                 _cptr_to_nparray( sab, nalpha.value * nbeta.value ) )
+                 _cptr_to_nparray( sab, nalpha.value * nbeta.value ),
+                 float( suggest_emax.value ) or None )
     functions['raw_vdos2knl'] = raw_vdos2knl
 
     def ncrystal_dyninfo_base(key):

NCrystal/_cli_ncmat2endf.py

@@ -0,0 +1,337 @@
+
+################################################################################
+##                                                                            ##
+##  This file is part of NCrystal (see https://mctools.github.io/ncrystal/)   ##
+##                                                                            ##
+##  Copyright 2015-2025 NCrystal developers                                   ##
+##                                                                            ##
+##  Licensed under the Apache License, Version 2.0 (the "License");           ##
+##  you may not use this file except in compliance with the License.          ##
+##  You may obtain a copy of the License at                                   ##
+##                                                                            ##
+##      http://www.apache.org/licenses/LICENSE-2.0                            ##
+##                                                                            ##
+##  Unless required by applicable law or agreed to in writing, software       ##
+##  distributed under the License is distributed on an "AS IS" BASIS,         ##
+##  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  ##
+##  See the License for the specific language governing permissions and       ##
+##  limitations under the License.                                            ##
+##                                                                            ##
+################################################################################
+
+from ._cliimpl import ( create_ArgumentParser,
+                        cli_entry_point )
+
+longopt_metadata = '--mdata'
+metavar_elastic = 'MODE'
+metavar_matname = 'NAME'
+metavar_metadata = 'DATA'
+longopt_elastic = '--elas'
+longopt_matname = '--name'
+longopt_datenow = '--now'
+longopt_othertemps = '--othertemps'
+
+#Examples here so they can be unit tested:
+examples = [
+    ['Al_sg225.ncmat;temp=350K'],
+    ['Si_sg227.ncmat;temp=293.6K','-m','MATNUM:Si:99',longopt_datenow],
+    ['ZnO_sg186_ZincOxide.ncmat;temp=293.15K','-n','ZnO',
+     '-e','scaled','-m','MATNUM:Zn:101,O:102'],
+    ['Bi_sg166.ncmat;comp=inelas;temp=77K','-m','AUTH:J. Doe']
+]
+
+def _parseArgs( progname, arglist, return_parser=False ):
+    from .ncmat2endf import ( available_elastic_modes,
+                              default_smin_value,
+                              default_emax_value )
+    from ._common import print
+    from argparse import RawTextHelpFormatter
+    import textwrap
+    import json
+    import shlex
+
+    helpw = 60
+    descrw = helpw + 22
+    descr_sections = [
+        """Script for creating a set of ENDF-6 thermal scattering files for the
+        material described by a particular NCrystal cfg-string.
+        """,
+        """
+        The script uses the endf-parserpy package from IAEA to format and check
+        the syntax of the ENDF-6 file:
+        """,
+        """
+        G. Schnabel, D. L. Aldama, R. Capote,
+        https://doi.org/10.48550/arXiv.2312.08249
+        """,
+        f"""
+        Note that while the handling of multiple temperatures in one ENDF-6
+        file is supported via the {longopt_othertemps} keyword, it is not
+        recommended. This is because NCrystal computes an optimal (alpha, beta)
+        grid for each material and temperature, while the ENDF format imposes
+        the same grid on all temperatures.
+        """,
+        ]
+
+    # NOTICE ^^^^^^^^^^^
+    #
+    # When updating ncmat2endf there are 2 main doc texts that have to be
+    # checked for updates:
+    #
+    #  1) The ncmat2endf function doc-string in ncmat2endf.py
+    #  2) The ncmat2endf CLI --help text in _cli_ncmat2endf.py
+    #
+
+    descr = '\n\n'.join(textwrap.fill(' '.join(e.strip().split()),descrw)
+                        for e in descr_sections)
+
+    def exquote(e):
+        #prefer " for quoting (for Windows compatibility)
+        e = shlex.quote(e)
+        if '"' not in e and "'" in e:
+            e = e.replace("'",'"')
+        if '"' not in e and ',' in e:
+            #Add some quotes that shlex did not think necessary:
+            e = '"%s"'%e
+        return e
+
+    descr += "\n\nExample invocations:\n\n"
+    exw = descrw - len(progname) - 7
+    expre=f'    $> {progname} '
+    for example in examples:
+        s=['']
+        for e in example:
+            e = exquote(e)
+            if len(s[-1]+e) > exw:
+                s[-1] += ' \\'
+                s.append('')
+            s[-1] += ' %s'%e
+        descr += '%s%s\n'%(expre,s[0])
+        for e in s[1:]:
+            descr += '%s%s\n'%(' '*len(expre),e)
+        descr += '\n'
+
+    usagestr = (
+        f'{progname} CFGSTR [{longopt_elastic} {metavar_elastic}]'
+        + f' [{longopt_matname} {metavar_matname}]'
+        + f' [{longopt_metadata} {metavar_metadata}]\n'
+        + (' '*(len(progname)+8))
+        + '[<<additional options described below>>]'
+    )
+
+    parser = create_ArgumentParser( prog = progname,
+                                    description=descr.strip()+'\n',
+                                    usage=usagestr,
+                                    formatter_class=RawTextHelpFormatter )
+    def wrap(t):
+        return textwrap.fill(t,width=helpw)
+
+    required_args = parser.add_argument_group('required arguments')
+    required_args.add_argument('CFGSTR',
+                               help=wrap('NCrystal cfg-string defining the'
+                                         ' material.'))
+
+    ba = parser.add_argument_group('Commonly used arguments')
+    ba.add_argument( '-n', longopt_matname, metavar=metavar_matname,
+                     help=wrap('Name of the material to be processed.'
+                               'If set ENDF files will be named '
+                               f'tsl_element_in_<{metavar_matname}>.endf.'))
+    elasmode_default = 'scaled'
+    assert elasmode_default in available_elastic_modes
+    elasmode_other = list(e for e in available_elastic_modes
+                          if e != elasmode_default )
+    assert len(elasmode_other)==2
+    ba.add_argument('-e', longopt_elastic,metavar=metavar_elastic,
+                    help=wrap('Approximation used for the elastic component'
+                              f' (default "{elasmode_default}, other options'
+                              f' are "{elasmode_other[0]}" and'
+                              f' "{elasmode_other[1]}").'
+                              ' See DOI:10.1016/j.nima.2021.166227 for'
+                              ' meaning of modes.'),
+                    type=str, choices=available_elastic_modes,
+                    default=elasmode_default)
+    ba.add_argument(longopt_metadata,default={},
+                    help=wrap('JSON dictionary containing ENDF-6'
+                              f' metadata. Run with {longopt_metadata}=help '
+                              'for more information.'))
+    ba.add_argument('-m',metavar='KEY:VAL', dest='mdata_kvlist',
+                    action='append', nargs='+',
+                    help=wrap('Add metadata entries. Run with '
+                              f'{longopt_metadata}=help for more info.'))
+    ba.add_argument(longopt_datenow,action='store_true',
+                    help=wrap('Set metadata fields EDATE, DDATE and RDATE'
+                              ' to current date.'))
+
+    parser.add_argument('-v','--verbose', action='count',default=0,
+                        help=wrap('Increase verbosity. Specify twice'
+                                  ' for additional verbosity.'))
+    parser.add_argument('--quiet','-q',default=False,action='store_true',
+                        help=wrap('Silence non-error output.'))
+    ba.add_argument('-d', '--dir', default = '.', metavar='PATH', dest='outdir',
+                    help=wrap('Directory for output files (default: current).'))
+    ba.add_argument('-i','--index', default = '',
+                    metavar='FILE', dest='jsonindex',
+                    help=wrap('Story summary of output in FILE (JSON format).'))
+    ba.add_argument('-f', '--force',action='store_true',
+                    help=wrap('Overwrite output files if'
+                              ' they already exist (danger!)'))
+
+    expert_args = parser.add_argument_group('Advanced expert-only arguments')
+    expert_args.add_argument(longopt_othertemps,metavar='TVALS',
+                             nargs='+',
+                             type=float,
+                             help=wrap('Additional temperatures to process. As'
+                                       ' noted above this is not normally'
+                                       ' recommended, and it is preferred'
+                                       ' to invoke the script for each'
+                                       ' temperature independently using the'
+                                       ' "temp" keyword in the cfg-string.') )
+    expert_args.add_argument('--smin',metavar='VALUE',
+                             type=float, default=default_smin_value,
+                             help=wrap('Minimum value of S(alpha, beta) stored'
+                                       f' (default: {default_smin_value})'))
+    expert_args.add_argument('--emax',
+                             type=float, default=default_emax_value,
+                             help=wrap('Maximum neutron energy covered by'
+                                       ' the kernels'
+                                       f' (default: {default_emax_value:g}eV)')
+                             )
+    expert_args.add_argument('--asymsab',action='store_true',
+                             help=wrap('Store S(a,b) in asymmetric form.'))
+    expert_args.add_argument('--totsab',action='store_true',
+                             help=wrap('Store S(a,b) branches for positive'
+                                       ' and negative beta'))
+
+    if return_parser:
+        return parser
+
+    #Avoid annoying CFGSTR-missing error when ppl use --mdata=help:
+    is_mdata_help = False
+    if f'{longopt_metadata}=help' in arglist:
+        is_mdata_help = True
+    elif longopt_metadata in arglist and 'help' in arglist:
+        if arglist.index(longopt_metadata)+1==arglist.index('help'):
+            is_mdata_help=True
+    if is_mdata_help:
+        arglist = [f'{longopt_metadata}=help','dummy']
+
+    args=parser.parse_args(arglist)
+    if args.mdata:
+        if args.mdata == 'help':
+            print(gen_metadata_doc())
+            raise SystemExit(0)
+        try:
+            args.mdata = json.loads(args.mdata)
+        except json.JSONDecodeError:
+            parser.error(f'Argument to {longopt_metadata} must be a JSON'
+                         ' dictionary of key, value pairs')
+        else:
+            if not isinstance(args.mdata,dict):
+                parser.error(f'Argument to {longopt_metadata} must be a JSON'
+                             ' dictionary of key, value pairs')
+    assert isinstance(args.mdata,dict)
+    for ee in args.mdata_kvlist or []:
+        for e in ee:
+            kv = list(_.strip() for _ in e.split(':',1))
+            if not len(kv)==2 or not kv[0]:
+                parser.error(f'Invalid parameter for -m: {repr(e)}')
+            args.mdata[kv[0]] = kv[1]
+    args.m = None
+
+    #map verbosity to 0...3 needed for Python API:
+    if args.quiet:
+        if args.verbose:
+            parser.error('Inconsistent usage of --quiet and --verbose flags')
+    else:
+        args.verbose = min( 3, args.verbose+1 )
+
+    if args.jsonindex:
+        import pathlib
+        args.jsonindex = pathlib.Path(args.jsonindex)
+        if args.jsonindex.is_file():
+            if not args.force:
+                parser.error('File already exists (run with --force to'
+                             f' overwrite): {args.jsonindex}')
+            args.jsonindex.unlink()
+            assert not args.jsonindex.is_file()
+        if not args.jsonindex.parent.is_dir():
+            parser.error('Directory does not exist: {args.jsonindex.parent}')
+        args.jsonindex = args.jsonindex.absolute()
+
+    return args
+
+def create_argparser_for_sphinx( progname ):
+    return _parseArgs(progname,[],return_parser=True)
+
+@cli_entry_point
+def main( progname, arglist ):
+    args = _parseArgs( progname, arglist )
+    if args.quiet:
+        from ._common import ( modify_ncrystal_print_fct_ctxmgr,
+                               WarningSpy )
+        with modify_ncrystal_print_fct_ctxmgr('block'):
+            with WarningSpy( block = True ):
+                _main_impl(args)
+    else:
+        _main_impl(args)
+
+def _main_impl( args ):
+    from .ncmat2endf import EndfMetaData, ncmat2endf
+    metadata = EndfMetaData()
+    if args.mdata:
+        metadata.update_from_dict(args.mdata)
+    if args.now:
+        metadata.set_all_dates_as_now()
+    lasym = 0
+    if args.totsab:
+        lasym = 1
+    if args.asymsab:
+        lasym += 2
+    r = ncmat2endf( args.CFGSTR,
+                    material_name = args.name,
+                    endf_metadata = metadata,
+                    othertemps = args.othertemps,
+                    elastic_mode = args.elas,
+                    force = args.force,
+                    smin = args.smin,
+                    emax = args.emax,
+                    lasym = lasym,
+                    verbosity = args.verbose,
+                    outdir = args.outdir )
+    if args.jsonindex:
+        import json
+        r_json = json.dumps( r, indent = 4 ).rstrip() + '\n'
+        print(f'Writing index file: {args.jsonindex.name}')
+        args.jsonindex.write_text( r_json )
+
+def gen_metadata_doc():
+    from ._ncmat2endf_impl import _impl_get_metadata_params_and_docs
+    import textwrap
+
+    d = _impl_get_metadata_params_and_docs()
+    assert 'LIBNAME' in d
+    assert 'ALAB' in d
+    txt = ''
+    w = 80
+    def section( x ):
+        return textwrap.fill(' '.join(x.strip().split()),w)
+
+    txt += section(
+        f"""Meta-data for ENDF can be provided by the {longopt_metadata}
+        option, by specifying a JSON dictionary like:"""
+    )
+    txt+=('''\n\n  %s='{ "LIBNAME" : "MySuperLib"'''%longopt_metadata
+          +''', "ALAB" : "MySuperLab" }'\n\n''')
+    txt += section(
+        """Or by adding individual items with the -m option like:"""
+    )
+    txt+=('''\n\n  -m LIBNAME:MySuperLib -m AUTH:"J. Chadwick"\n\n''')
+    txt += section('The list of supported meta-data'
+                   ' keys and their meaning is:')
+    txt += '\n\n'
+    kmax = max(len(k) for k in d)
+    for k, v in d.items():
+        s = f'   {k.rjust(kmax)} : '
+        for i,e in enumerate(textwrap.fill( v, width=w-len(s) ).splitlines()):
+            txt += (' '*len(s) if i else s) + e + '\n'
+    return txt

NCrystal/_common.py

@@ -130,7 +130,15 @@ def warn(msg):
     """Emit NCrystalUserWarning via standard warnings.warn function"""
     from .exceptions import NCrystalUserWarning
     import warnings
-    warnings.warn( NCrystalUserWarning(str(msg)), stacklevel = 2 )
+    m = str(msg)
+    if _add_warn_counts_to_msgs[0]:
+        _add_warn_counts_to_msgs[1] += 1
+        m = '%s [warn#%i]'%(m,_add_warn_counts_to_msgs[1])
+    warnings.warn( NCrystalUserWarning(m), stacklevel = 2 )
+
+#Hook to avoid repeated warnings to be silenced during unit tests, by appending
+#a warning number to them:
+_add_warn_counts_to_msgs = [False,0]
 
 class WarningSpy:
     """Context manager which spies on any warnings emitted via warnings

NCrystal/_miscimpl.py

@@ -342,13 +342,34 @@ def _anyvdos_init( class_AnyVDOS, anyvdos_extract_d, data, fmt, label ):
     return MappingProxyType( d )
 
 def detect_scatcomps( standard_comp_types, matsrc ):
+    from .exceptions import NCBadInput, NCCalcError
     if matsrc.is_preloaded:
         from .exceptions import NCBadInput
         raise NCBadInput('detect_scattering_components can not be used'
                          ' with preloaded material sources')
     res=[]
     for ct in standard_comp_types:
-        _ = matsrc.load( extra_cfg_params = f'vdoslux=0;comp={ct}', doInfo = False, doAbsorption = False )
-        if not _.scatter.isNull():
+        def load(extra = None):
+            p = f'comp={ct}'
+            if extra is not None:
+                p += f';{extra}'
+            return matsrc.load( extra_cfg_params = p,
+                                doInfo = False,
+                                doAbsorption = False )
+        m = None
+        if ct == 'inelas':
+            #For inelas component first we try to see if we can get away with
+            #using a potentially smaller vdoslux than is actually used. This is
+            #not a great solution, but in the absence of deeper changes to
+            #NCrystal processes, this seems a reasonable compromise.
+            try:
+                m = load('vdoslux=0')
+            except NCCalcError as e:
+                if not str(e).startswith('VDOS expansion too slow'):
+                    raise e
+                m = None
+        if not m:
+            m = load()
+        if not m.scatter.isNull():
             res.append(ct)
     return res