ncrystal-python 4.2.6__py3-none-any.whl → 4.2.10__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.6'
+__version__ = '4.2.10'
 __status__ = "Production"
 __author__ = "NCrystal developers (Thomas Kittelmann, Xiao Xiao Cai)"
 __copyright__ = "Copyright 2015-2024 %s"%__author__

NCrystal/_hist.py

@@ -0,0 +1,297 @@
+
+################################################################################
+##                                                                            ##
+##  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.                                            ##
+##                                                                            ##
+################################################################################
+
+# In this internal file we provide a histogram class which can be used to load
+# the JSON data representing the (likewise internal) histograms from
+# "NCrystal/internal/utils/NCHists.hh".
+
+__all__ = ['Hist1D']
+
+from ._numpy import _np, _ensure_numpy, _np_linspace
+
+class Hist1D:
+
+    def __init__( self, data ):
+        if data=='_no_init_':
+            return
+        _ensure_numpy()
+        self.__stats = data.get('stats')
+        self.__title = data['title']
+        hb = data['bindata']
+        self.__xmin = hb['xmin']
+        self.__xmax = hb['xmax']
+        self.__nbins = hb['nbins']
+        self.__y = _np.asarray(hb['content'],dtype=float)
+        esq = hb.get('errorsq')
+        self.__yerrsq = ( _np.asarray(esq,dtype=float)
+                          if esq is not None
+                          else None )
+        self.__yerr = None
+        assert self.__nbins == len(self.__y)
+        assert self.__yerrsq is None or self.__nbins == len(self.__yerrsq)
+
+    def clone( self, rebin_factor = 1 ):
+        c = Hist1D('_no_init_')
+        c.__stats = self.__stats
+        c.__title = self.__title
+        c.__xmin = self.__xmin
+        c.__xmax = self.__xmax
+        c.__nbins = self.__nbins
+        c.__y = self.__y.copy()
+        c.__yerrsq = self.__yerrsq.copy() if self.__yerrsq is not None else None
+        c.__yerr = self.__yerr.copy() if self.__yerr is not None else None
+        if rebin_factor > 1:
+            c.rebin( rebin_factor )
+        return c
+
+    def integrate( self, xlow, xhigh, tolerance = 1e-5 ):
+        """
+        Returns integrated contents of the histogram over the area
+        [xlow,xhigh] along with the error of that value in a tuple
+        (content,error).
+
+        This is done translating xlow and xhigh to exact bin edges and then
+        calling integrate_bins. If that is not possible within the
+        tolerance, an exception is raised.
+
+        """
+        if not ( xhigh >= xlow ):
+            from .exceptions import NCBadInput
+            raise NCBadInput('Invalid integration range requested.')
+
+        bw = self.binwidth
+        def _findedge(x):
+            if x <= self.__xmin:
+                return 0
+            if x >= self.__xmax:
+                return self.nbins
+            r = ( x - self.__xmin ) / bw
+            ir = int(r+0.5)
+            if abs(r-ir) > tolerance:
+                from .exceptions import NCBadInput
+                raise NCBadInput(f'Value {x} does not correspond exactly'
+                                 ' to a bin edge within the tolerance.')
+            return ir
+        e_low = _findedge(xlow)
+        e_high = _findedge(xhigh)
+        if e_low == e_high:
+            return ( 0.0, 0.0 )
+        assert e_low >= 0
+        assert e_low < e_high < self.nbins
+        return self.integrate_bins( e_low, e_high - 1 )
+
+    def integrate_bins( self, bin_low = None, bin_up = None ):
+        """
+        Returns integrated contents of the bins [bin_low,bin_up[ along with
+        the error of that value in a tuple (content,error).
+
+        If bin_low is None the integration will start at the first bin and
+        include the underflow bin.
+
+        If bin_up is None the integration will end at the last bin and
+        include the overflow bin.
+        """
+
+        add_overflow, add_underflow = False, False
+        if bin_low is None:
+            add_underflow = True
+            bin_low = 0
+            underflow_c = self.stats.get('underflow')
+            underflow_e2 = self.stats.get('underflow_errorsq')
+            if bool(underflow_c is None) != bool(underflow_e2 is None):
+                from .exceptions import NCBadInput
+                raise NCBadInput('Inconsistent underflow info')
+            if underflow_c is None:
+                add_underflow = False
+
+        if bin_up is None:
+            add_overflow = True
+            bin_up = self.__nbins
+            overflow_c = self.stats.get('overflow')
+            overflow_e2 = self.stats.get('overflow_errorsq')
+            if bool(overflow_c is None) != bool(overflow_e2 is None):
+                from .exceptions import NCBadInput
+                raise NCBadInput('Inconsistent overflow info')
+            if overflow_c is None:
+                add_overflow = False
+
+        bin_low, bin_up = int(bin_low), int(bin_up)
+        if bin_up < bin_low or bin_low<0 or bin_up > self.__nbins:
+            from .exceptions import NCBadInput
+            raise NCBadInput('Invalid bin range requested')
+        content_integral = self.__y[bin_low:bin_up].sum()
+        if add_underflow:
+            content_integral += underflow_c
+        if add_overflow:
+            content_integral += overflow_c
+        if self.__yerrsq is None:
+            #unweighted, just base erros on contents:
+            return ( content_integral, _np.sqrt(content_integral) )
+        errorsq_integral = self.__yerrsq[bin_low:bin_up].sum()
+        if add_underflow:
+            errorsq_integral += underflow_e2
+        if add_overflow:
+            errorsq_integral += overflow_e2
+        return ( content_integral, _np.sqrt(errorsq_integral) )
+
+    def add_contents( self, other_hist ):
+        o = other_hist
+        assert self.__xmin == o.__xmin
+        assert self.__xmax == o.__xmax
+        assert self.__nbins == o.__nbins
+        self.__stats = {}
+        self.__title = '<edited>'
+        self.__y += o.__y
+        self.__yerr = None
+        if self.__yerrsq is None:
+            if o.__yerrsq is None:
+                pass#done
+            else:
+                self.__yerrsq = self.__y + o.__yerrsq
+        else:
+            if o.__yerrsq is None:
+                self.__yerrsq += o.__y
+            else:
+                self.__yerrsq += o.__yerrsq
+
+    def rebin( self, rebin_factor ):
+        assert self.__nbins % rebin_factor == 0
+        def _dorebin(x):
+            return _np.sum( x.reshape( len(x)//rebin_factor, rebin_factor ),
+                                       axis=1)
+        self.__y = _dorebin(self.__y)
+        self.__yerr = None
+        if self.__yerrsq is not None:
+            self.__yerrsq = _dorebin(self.__yerrsq)
+        self.__nbins = self.__nbins // rebin_factor
+        assert self.__yerrsq is None or len(self.__yerrsq)==len(self.__y)
+        assert self.__nbins==len(self.__y)
+
+    @property
+    def stats( self ):
+        return self.__stats or {}
+
+    @property
+    def errors( self ):
+        if self.__yerr is None:
+            self.__yerr = _np.sqrt( self.errors_squared )
+        return self.__yerr
+
+    @property
+    def errors_squared( self ):
+        return ( self.__yerrsq
+                 if self.__yerrsq is not None
+                 else self.__y )
+
+    @property
+    def content( self ):
+        return self.__y
+
+    @property
+    def title( self ):
+        return self.__title
+
+    @property
+    def xmin( self ):
+        return self.__xmin
+
+    @property
+    def xmax( self ):
+        return self.__xmax
+
+    @property
+    def binwidth( self ):
+        return (self.__xmax-self.__xmin)/self.__nbins
+
+    @property
+    def nbins( self ):
+        return self.__nbins
+
+    @property
+    def bincenters( self ):
+        halfbw = 0.5*self.binwidth
+        return _np_linspace(self.__xmin+halfbw,
+                            self.__xmax-halfbw,
+                            self.__nbins)
+
+    @property
+    def binedges( self ):
+        return _np_linspace(self.__xmin,
+                            self.__xmax,
+                            self.__nbins+1)
+
+
+    def _hist_curve( self, error_offset = 0.0 ):
+        be = self.binedges
+        y = self.content
+        if error_offset:
+            y += self.errors * error_offset
+        cx = _np.empty(self.__nbins*2)
+        cy = _np.empty(self.__nbins*2)
+        i = 0
+        for ibin in range(self.__nbins):
+            cx[i] = be[ibin]
+            cy[i] = y[ibin]
+            i+=1
+            cx[i] = be[ibin+1]
+            cy[i] = y[ibin]
+            i+=1
+        return cx,cy
+
+    def errorbar_args( self, style = True, **kwargs ):
+        d = {'x':self.bincenters,
+             'y':self.content,'xerr':0.5*self.binwidth,
+             'yerr':self.errors }
+        if style:
+            d.update({'fmt':'.',#dont connect with line
+                      'mec':'black','mfc':'black',
+                      #'ms':4,'mew':1,
+                      'ecolor':'black','elinewidth':1.0 })
+        d.update(kwargs)
+        return d
+
+    def bar_args( self, style = True, **kwargs ):
+        d = {'x' : self.binedges[:-1],
+             'height': self.content,
+             'width': self.binwidth,
+             'align':'edge'
+             }
+        d.update(kwargs)
+        return d
+
+    def plot_hist( self, plt=None, axis=None, style=True, label=None,
+                   show_errors=True, do_show = True, set_xlim = True ):
+        if not plt and not axis:
+            from .plot import _import_matplotlib_plt
+            plt = _import_matplotlib_plt()
+        if not axis:
+            axis = plt.gca()
+        axis.bar(**self.bar_args(label=label))
+        if show_errors:
+            ( error_markers,
+              ecaplines,
+              ebarlinecols ) = axis.errorbar(**self.errorbar_args())
+
+        xmin,xmax,binwidth = self.xmin, self.xmax, self.binwidth
+        if set_xlim:
+            axis.set_xlim(xmin-1e-6*binwidth,xmax+1e-6*binwidth)
+        if do_show and plt:
+            plt.show()

NCrystal/_mmc.py

@@ -74,274 +74,6 @@ def runsim_diffraction_pattern( cfgstr, *,
                               mmc_geomcfg = str(geomcfg),
                               mmc_srccfg = str(srccfg) )
 
-    class Hist1D:
-
-        def __init__( self, data ):
-            if data=='_no_init_':
-                return
-            self.__stats = data.get('stats')
-            self.__title = data['title']
-            hb = data['bindata']
-            self.__xmin = hb['xmin']
-            self.__xmax = hb['xmax']
-            self.__nbins = hb['nbins']
-            self.__y = _np.asarray(hb['content'],dtype=float)
-            esq = hb.get('errorsq')
-            self.__yerrsq = ( _np.asarray(esq,dtype=float)
-                              if esq is not None
-                              else None )
-            self.__yerr = None
-            assert self.__nbins == len(self.__y)
-            assert self.__yerrsq is None or self.__nbins == len(self.__yerrsq)
-
-        def clone( self, rebin_factor = 1 ):
-            c = Hist1D('_no_init_')
-            c.__stats = self.__stats
-            c.__title = self.__title
-            c.__xmin = self.__xmin
-            c.__xmax = self.__xmax
-            c.__nbins = self.__nbins
-            c.__y = self.__y.copy()
-            c.__yerrsq = self.__yerrsq.copy() if self.__yerrsq is not None else None
-            c.__yerr = self.__yerr.copy() if self.__yerr is not None else None
-            if rebin_factor > 1:
-                c.rebin( rebin_factor )
-            return c
-
-        def integrate( self, xlow, xhigh, tolerance = 1e-5 ):
-            """
-            Returns integrated contents of the histogram over the area
-            [xlow,xhigh] along with the error of that value in a tuple
-            (content,error).
-
-            This is done translating xlow and xhigh to exact bin edges and then
-            calling integrate_bins. If that is not possible within the
-            tolerance, an exception is raised.
-
-            """
-            if not ( xhigh >= xlow ):
-                from .exceptions import NCBadInput
-                raise NCBadInput('Invalid integration range requested.')
-
-            bw = self.binwidth
-            def _findedge(x):
-                if x <= self.__xmin:
-                    return 0
-                if x >= self.__xmax:
-                    return self.nbins
-                r = ( x - self.__xmin ) / bw
-                ir = int(r+0.5)
-                if abs(r-ir) > tolerance:
-                    from .exceptions import NCBadInput
-                    raise NCBadInput(f'Value {x} does not correspond exactly'
-                                     ' to a bin edge within the tolerance.')
-                return ir
-            e_low = _findedge(xlow)
-            e_high = _findedge(xhigh)
-            if e_low == e_high:
-                return ( 0.0, 0.0 )
-            assert e_low >= 0
-            assert e_low < e_high < self.nbins
-            return self.integrate_bins( e_low, e_high - 1 )
-
-        def integrate_bins( self, bin_low = None, bin_up = None ):
-            """
-            Returns integrated contents of the bins [bin_low,bin_up[ along with
-            the error of that value in a tuple (content,error).
-
-            If bin_low is None the integration will start at the first bin and
-            include the underflow bin.
-
-            If bin_up is None the integration will end at the last bin and
-            include the overflow bin.
-            """
-
-            add_overflow, add_underflow = False, False
-            if bin_low is None:
-                add_underflow = True
-                bin_low = 0
-                underflow_c = self.stats.get('underflow')
-                underflow_e2 = self.stats.get('underflow_errorsq')
-                if bool(underflow_c is None) != bool(underflow_e2 is None):
-                    from .exceptions import NCBadInput
-                    raise NCBadInput('Inconsistent underflow info')
-                if underflow_c is None:
-                    add_underflow = False
-
-            if bin_up is None:
-                add_overflow = True
-                bin_up = self.__nbins
-                overflow_c = self.stats.get('overflow')
-                overflow_e2 = self.stats.get('overflow_errorsq')
-                if bool(overflow_c is None) != bool(overflow_e2 is None):
-                    from .exceptions import NCBadInput
-                    raise NCBadInput('Inconsistent overflow info')
-                if overflow_c is None:
-                    add_overflow = False
-
-            bin_low, bin_up = int(bin_low), int(bin_up)
-            if bin_up < bin_low or bin_low<0 or bin_up > self.__nbins:
-                from .exceptions import NCBadInput
-                raise NCBadInput('Invalid bin range requested')
-            content_integral = self.__y[bin_low:bin_up].sum()
-            if add_underflow:
-                content_integral += underflow_c
-            if add_overflow:
-                content_integral += overflow_c
-            if self.__yerrsq is None:
-                #unweighted, just base erros on contents:
-                return ( content_integral, _np.sqrt(content_integral) )
-            errorsq_integral = self.__yerrsq[bin_low:bin_up].sum()
-            if add_underflow:
-                errorsq_integral += underflow_e2
-            if add_overflow:
-                errorsq_integral += overflow_e2
-            return ( content_integral, _np.sqrt(errorsq_integral) )
-
-        def add_contents( self, other_hist ):
-            o = other_hist
-            assert self.__xmin == o.__xmin
-            assert self.__xmax == o.__xmax
-            assert self.__nbins == o.__nbins
-            self.__stats = {}
-            self.__title = '<edited>'
-            self.__y += o.__y
-            self.__yerr = None
-            if self.__yerrsq is None:
-                if o.__yerrsq is None:
-                    pass#done
-                else:
-                    self.__yerrsq = self.__y + o.__yerrsq
-            else:
-                if o.__yerrsq is None:
-                    self.__yerrsq += o.__y
-                else:
-                    self.__yerrsq += o.__yerrsq
-
-        def rebin( self, rebin_factor ):
-            assert self.__nbins % rebin_factor == 0
-            def _dorebin(x):
-                return _np.sum( x.reshape( len(x)//rebin_factor, rebin_factor ),
-                                           axis=1)
-            self.__y = _dorebin(self.__y)
-            self.__yerr = None
-            if self.__yerrsq is not None:
-                self.__yerrsq = _dorebin(self.__yerrsq)
-            self.__nbins = self.__nbins // rebin_factor
-            assert self.__yerrsq is None or len(self.__yerrsq)==len(self.__y)
-            assert self.__nbins==len(self.__y)
-
-        @property
-        def stats( self ):
-            return self.__stats or {}
-
-        @property
-        def errors( self ):
-            if self.__yerr is None:
-                self.__yerr = _np.sqrt( self.errors_squared )
-            return self.__yerr
-
-        @property
-        def errors_squared( self ):
-            return ( self.__yerrsq
-                     if self.__yerrsq is not None
-                     else self.__y )
-
-        @property
-        def content( self ):
-            return self.__y
-
-        @property
-        def title( self ):
-            return self.__title
-
-        @property
-        def xmin( self ):
-            return self.__xmin
-
-        @property
-        def xmax( self ):
-            return self.__xmax
-
-        @property
-        def binwidth( self ):
-            return (self.__xmax-self.__xmin)/self.__nbins
-
-        @property
-        def nbins( self ):
-            return self.__nbins
-
-        @property
-        def bincenters( self ):
-            halfbw = 0.5*self.binwidth
-            return _np_linspace(self.__xmin+halfbw,
-                                self.__xmax-halfbw,
-                                self.__nbins)
-
-        @property
-        def binedges( self ):
-            return _np_linspace(self.__xmin,
-                                self.__xmax,
-                                self.__nbins+1)
-
-
-        def _hist_curve( self, error_offset = 0.0 ):
-            be = self.binedges
-            y = self.content
-            if error_offset:
-                y += self.errors * error_offset
-            cx = _np.empty(self.__nbins*2)
-            cy = _np.empty(self.__nbins*2)
-            i = 0
-            for ibin in range(self.__nbins):
-                cx[i] = be[ibin]
-                cy[i] = y[ibin]
-                i+=1
-                cx[i] = be[ibin+1]
-                cy[i] = y[ibin]
-                i+=1
-            return cx,cy
-
-        def errorbar_args( self, style = True, **kwargs ):
-            d = {'x':self.bincenters,
-                 'y':self.content,'xerr':0.5*self.binwidth,
-                 'yerr':self.errors }
-            if style:
-                d.update({'fmt':'.',#dont connect with line
-                          'mec':'black','mfc':'black',
-                          #'ms':4,'mew':1,
-                          'ecolor':'black','elinewidth':1.0 })
-            d.update(kwargs)
-            return d
-
-        def bar_args( self, style = True, **kwargs ):
-            d = {'x' : self.binedges[:-1],
-                 'height': self.content,
-                 'width': self.binwidth,
-                 'align':'edge'
-                 }
-            d.update(kwargs)
-            return d
-
-        def plot_hist( self, plt=None, axis=None, style=True, label=None,
-                       show_errors=True, do_show = True, set_xlim = True ):
-            if not plt and not axis:
-                from .plot import _import_matplotlib_plt
-                plt = _import_matplotlib_plt()
-            if not axis:
-                axis = plt.gca()
-            axis.bar(**self.bar_args(label=label))
-            if show_errors:
-                ( error_markers,
-                  ecaplines,
-                  ebarlinecols ) = axis.errorbar(**self.errorbar_args())
-
-            xmin,xmax,binwidth = self.xmin, self.xmax, self.binwidth
-            if set_xlim:
-                axis.set_xlim(xmin-1e-6*binwidth,xmax+1e-6*binwidth)
-            if do_show and plt:
-                plt.show()
-
     class Results:
 
         def __init__( self,
@@ -367,6 +99,7 @@ def runsim_diffraction_pattern( cfgstr, *,
                 datadict = json.loads(json_details)
                 mainhist_dict['stats'] = datadict.get('main_stats')
 
+            from ._hist import Hist1D
             hists = [ Hist1D( mainhist_dict ) ]
             hists += [ Hist1D( h )
                        for h in (datadict.get('breakdown_hists',[])) ]
@@ -433,6 +166,7 @@ def runsim_diffraction_pattern( cfgstr, *,
             if breakdown_mode:
                 hist = None
             else:
+                from ._hist import Hist1D
                 if hist is None:
                     hist = self.__hists[0]
                     assert isinstance(hist,Hist1D)

NCrystal/_ncmatimpl.py

@@ -912,9 +912,17 @@ class NCMATComposerImpl:
                                self.create_ncmat( cfg_params = cfg_params ) )
         return p
 
-    def load(self,cfg_params,force ):
-        if force or self.__loadcache is None or self.__loadcache[0] != cfg_params:
-            self.__loadcache = ( cfg_params, _nc_core.directLoad( self.create_ncmat(), cfg_params ) )
+    def load( self, cfg_params, force,
+              doInfo = True, doScatter = True, doAbsorption = True ):
+        key = ( cfg_params, doInfo, doScatter, doAbsorption )
+        if force or self.__loadcache is None or self.__loadcache[0] != key:
+            self.__loadcache = ( key,
+                                 _nc_core.directLoad( self.create_ncmat(),
+                                                      cfg_params = cfg_params,
+                                                      dtype = 'ncmat',
+                                                      doInfo = doInfo,
+                                                      doScatter = doScatter,
+                                                      doAbsorption = doAbsorption) )
         return self.__loadcache[1]
 
     def plot_xsect( self, composer, cfg_params, kwargs_plot_xsect ):

NCrystal/core.py

@@ -1763,7 +1763,12 @@ def directLoad( data, cfg_params='', *, dtype='',
         if len(p)>=2 and p[-1] and p[-1].isalpha() and p[-1] not in ('gz','tgz','bz2','zip','tar'):
             dtype = dtype
 
-    rawi,raws,rawa = _rawfct['multicreate_direct'](content,dtype,cfg_params,doInfo,doScatter,doAbsorption)
+    rawi,raws,rawa = _rawfct['multicreate_direct']( content,
+                                                    dtype,
+                                                    cfg_params,
+                                                    doInfo,
+                                                    doScatter,
+                                                    doAbsorption )
     info = Info( ('_rawobj_',rawi) ) if rawi else None
     scatter = Scatter( ('_rawobj_',raws) ) if raws else None
     absorption = Absorption( ('_rawobj_',rawa) ) if rawa else None

NCrystal/ncmat.py

@@ -662,15 +662,21 @@ class NCMATComposer:
         return self.__impl.register_as( virtual_filename = virtual_filename,
                                         cfg_params = cfg_params )
 
-    def load(self, cfg_params = None, *, force = False ):
+    def load( self, cfg_params = None, *, force = False,
+              doInfo = True, doScatter = True, doAbsorption = True ):
         """Will create NCMAT and load it with the directLoad(..) function of the
         NCrystal.core module. The cfg_params parameter can be used to apply cfg
         parameters (e.g. cfg_params="temp=200K;dcutoff=0.1")., while force=True
         will prevent the NCMATComposer from simply returning a previously loaded
         material (usually one should just leave the default force=False value
-        untouched).
-        """
-        return self.__impl.load( cfg_params = cfg_params, force = force )
+        untouched). The doInfo / doScatter / doAbsorption flags can be used to
+        only load selected objects for a potential speedup.
+        """
+        return self.__impl.load( cfg_params = cfg_params,
+                                 force = force,
+                                 doInfo = doInfo,
+                                 doScatter = doScatter,
+                                 doAbsorption = doAbsorption )
 
     def plot_xsect( self, cfg_params = None, **kwargs_plot_xsect ):
         """

{ncrystal_python-4.2.6.dist-info → ncrystal_python-4.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ncrystal-python
-Version: 4.2.6
+Version: 4.2.10
 Summary: Library for thermal neutron transport in crystals and other materials.
 Author: NCrystal developers (Thomas Kittelmann, Xiao Xiao Cai)
 License: 

{ncrystal_python-4.2.6.dist-info → ncrystal_python-4.2.10.dist-info}/RECORD

@@ -1,4 +1,4 @@
-NCrystal/__init__.py,sha256=YEDgJIjLopRbDNFMibofc8kFZq0mxx14z7bTo1NI3P0,4151
+NCrystal/__init__.py,sha256=pxbgi15N65ft2i8Le4XgyWBcR4ZqZeW1uk3C7DDMDyc,4152
 NCrystal/__main__.py,sha256=tYOeVhY6joHahgtnBwNgcBDd-WXYQoHFmpslk2TAlTY,3624
 NCrystal/_chooks.py,sha256=blZZ4IWjZDYAS7YLhmqxjYKl2IArcE4dotZXoziDE48,43713
 NCrystal/_cli_cif2ncmat.py,sha256=Hmp8MWV7d3Bzu_5Ekiik9Pdv43yNyZygun8HtqShn78,14626
@@ -16,15 +16,16 @@ NCrystal/_cliwrap_config.py,sha256=RPawApLbRrZRTkWdAP3JK_eTtU_nfPrARYcnfF1-7sE,2
 NCrystal/_common.py,sha256=YNQ9xm6lqtc_E75RRvCSGVTunJkr-T6BMOmGRa1kj0k,19860
 NCrystal/_coreimpl.py,sha256=dWBPwbdb8l8Bi3wfDaaQVyqSqTQzwDfs1oEIJR9KTiQ,5727
 NCrystal/_hfgdata.py,sha256=uYTB_xHTHVN8Vw91wr7_kXi18ileHJGNyVjnSi-Ss7g,62828
+NCrystal/_hist.py,sha256=8JBLsfjdopzDyrpqoOaKCMGRL6W0R2UKPjiknxR7Zac,10866
 NCrystal/_hklobjects.py,sha256=wQAUe3tD6UncSW-qfuyAh5jSGnA_2kzvE5-HZ43s3xQ,4974
 NCrystal/_is_std.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 NCrystal/_locatelib.py,sha256=VCzJQEyOZfOonzah3wTyLndaO8XZRYZmA5oES9xptpI,9504
 NCrystal/_miscimpl.py,sha256=SF1RriTZXgF4uINON6UZqY4vtroJZJ_HuoGaV0tMuK0,17380
-NCrystal/_mmc.py,sha256=FiavyAkRDb3MZ222AHXbmQpBQLwqBdzxtDCMunnKfRI,29349
+NCrystal/_mmc.py,sha256=hVXrrJxN6s2a0uxNF2EgqO2xVq2OLU7P0emIG9g1JCQ,19448
 NCrystal/_msg.py,sha256=wBJk0kGHusm0xXSt8KNYq6iIO_cubnznvnJ5Erl87EU,2624
 NCrystal/_ncmat2cpp_impl.py,sha256=D_knqsv92EnaPJlufE3fJe2fnETnyQ8k9TbMwpXmxZs,18383
 NCrystal/_ncmat2endf_impl.py,sha256=rcKHdvIsrsl9SPRoWcmgXk4TR-NRwY79E1JydtW-J4Q,62918
-NCrystal/_ncmatimpl.py,sha256=fsIHG77q27tZT9R7ZDMrSr3yunT2W5dE9FH6uA0gvYk,95041
+NCrystal/_ncmatimpl.py,sha256=-vPYyBUDc0SCXTqPwm2pB-xbsqM6DCwQe5R34avcUAo,95561
 NCrystal/_numpy.py,sha256=SwFcvrNBDqP647guedRdFeISsC8b4VvGm9McFyF1gJQ,2924
 NCrystal/_sabutils.py,sha256=vZD2wB42r48_0EZKPTS6q5sKN1RGgjWi2zVuVvtbdGk,4798
 NCrystal/_testimpl.py,sha256=UPP2b4aaOTPxdUpfqPWgWIwg-BFZbeaivFxnrE7sO_M,21418
@@ -34,14 +35,14 @@ NCrystal/cfgstr.py,sha256=IVrMagRTD0TkAhuJkWkGKsJCX4ezG8Tf9uyfkhRjMgY,3741
 NCrystal/cifutils.py,sha256=zdYKqxVmzIahj9AKPZl-ISOi-SSWOMaJ_4iJ-v0ImdE,78824
 NCrystal/cli.py,sha256=OMUi3NZEwKwvx1fRzNDwWG9Yb-Vm49kkyiMu9NHHTlM,4395
 NCrystal/constants.py,sha256=ldOyJAAhW0tBNDVexqTw1rxvcmwCnGJOueurXS44Plw,5919
-NCrystal/core.py,sha256=wH7o2JKzvEGyTNsnMtEdMWxI3Nkh3bBlWP3HMwjRWyk,83339
+NCrystal/core.py,sha256=D7wOKLciHpNu5EZI0_vtpcRkf-XAkQQErLbxu4VdmzI,83606
 NCrystal/datasrc.py,sha256=wAmpYjLMB5w8_0J4qRFtKMZ-RoFvyu8DMOouQDB6xac,9978
 NCrystal/exceptions.py,sha256=7L61coTf_Sy8gjrsn7BNCu1cvOyAx0dWrihlV7AqgLM,2679
 NCrystal/hfg2ncmat.py,sha256=10FbQNxYzdSjTMG2F1DCq7LiQ7xvd1gjFkrZFjj-GKg,10189
 NCrystal/mcstasutils.py,sha256=7IRfwefvaXQORBV1Qibn88vb9OKMvIn_qfQoEt8-G3U,18540
 NCrystal/misc.py,sha256=KmbmW2PB2roQReqLtn-RWse30f6w7gOmJPb7cId_-ME,14083
 NCrystal/mmc.py,sha256=LQ0IXMgJexpSPrGYwZZm6bAh5Bo6y2z5CjezFAFy1UE,1948
-NCrystal/ncmat.py,sha256=iOBbe7KmmgAeMDnFpBDqzinUYjn9QpH8YRhaklt4dzs,42577
+NCrystal/ncmat.py,sha256=Gwrf1u2P4UeWQNvSXKhWHHCOibbMFmTlx0fyfE0DgOY,42966
 NCrystal/ncmat2cpp.py,sha256=_gXxXgbPcCmn0XnLx0h_dS_N3s4d18RORDSgSeVTgG4,4398
 NCrystal/ncmat2endf.py,sha256=1T1I08mWRG_yBhdb20dzEaVJMC0OeF2BYm2qY-L9BHg,12504
 NCrystal/obsolete.py,sha256=v2HzQFqdrLaGm6bWNqioGwMdQMAhuWYSbTEF2He_HbY,3451
@@ -49,9 +50,9 @@ NCrystal/plot.py,sha256=oymblLRKTfE2xCsX4W7H6cXIKxDNV7rr6Z4dZnCJjt0,19975
 NCrystal/plugins.py,sha256=U4EF25DlYE8aO6uoG5Ptyia5Nj08LCrVl7973BCIkDI,2440
 NCrystal/test.py,sha256=fH6OfjvQ2KJRYaooYVGFsp4QJGj_WC4QRq1bPd36vwg,2731
 NCrystal/vdos.py,sha256=DL3UtaCMLaY-bBB6ztT1qZKYfO44INeEpgra_9JAyMo,47607
-ncrystal_python-4.2.6.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-ncrystal_python-4.2.6.dist-info/METADATA,sha256=Fbhmjqmu6_905uRoh3Wo4h54t1VFgLZdTKCYkEIlRMM,16274
-ncrystal_python-4.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ncrystal_python-4.2.6.dist-info/entry_points.txt,sha256=I9Nz-pdriq2xHbYRAw-yUaI33jQwVbNRy8-3mCVe_jE,521
-ncrystal_python-4.2.6.dist-info/top_level.txt,sha256=VIJdIQMfLIbKpFXA8xm0fKY5okz8s5IHrZTYDSH18y0,9
-ncrystal_python-4.2.6.dist-info/RECORD,,
+ncrystal_python-4.2.10.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+ncrystal_python-4.2.10.dist-info/METADATA,sha256=bCyoH_AFcozyS7XF9HG1vdaiEIsgApsN50Bx99RHuBY,16275
+ncrystal_python-4.2.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ncrystal_python-4.2.10.dist-info/entry_points.txt,sha256=I9Nz-pdriq2xHbYRAw-yUaI33jQwVbNRy8-3mCVe_jE,521
+ncrystal_python-4.2.10.dist-info/top_level.txt,sha256=VIJdIQMfLIbKpFXA8xm0fKY5okz8s5IHrZTYDSH18y0,9
+ncrystal_python-4.2.10.dist-info/RECORD,,