ChessAnalysisPipeline 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

CHAP/utils/fit.py

@@ -118,7 +118,9 @@ class Fit:
         self._result = None
         self._try_linear_fit = True
         self._param_constraint = None
+        self._fwhm_min = None
         self._fwhm_max = None
+        self._sigma_min = None
         self._sigma_max = None
         self._y = None
         self._y_norm = None
@@ -851,12 +853,20 @@ class Fit:
 
     def create_multipeak_model(
             self, centers=None, fit_type=None, peak_models=None,
-            center_exprs=None, background=None, param_constraint=False,
-            fwhm_max=None):
+            center_exprs=None, background=None, param_constraint=True,
+            fwhm_min=None, fwhm_max=None, centers_range=None):
         """Create a multipeak model."""
         # System modules
         from re import search as re_search
 
+        # Third party modules
+        from asteval import Interpreter
+
+        if centers_range is None:
+            centers_range = (self._x[0], self._x[-1])
+        elif not is_index_range(centers_range, ge=self._x[0], le=self._x[-1]):
+            raise ValueError(
+                f'Invalid parameter centers_range ({centers_range})')
         if self._model is not None:
             if self._fit_type == 'uniform' and fit_type != 'uniform':
                 logger.info('Use the existing multipeak model to refit a '
@@ -872,10 +882,12 @@ class Fit:
                         self._best_errors, scale_factor_index, 0)
                     for name, par in self._parameters.items():
                         if re_search('peak\d+_center', name) is not None:
-                            par.set(min=min_value, vary=True, expr=None)
+                            par.set(
+                                min=centers_range[0], max=centers_range[1],
+                                vary=True, expr=None)
                             self._parameter_bounds[name] = {
-                                'min': min_value,
-                                'max': np.inf,
+                                'min': centers_range[0],
+                                'max': centers_range[1],
                             }
                 else:
                     for name, par in self._parameters.items():
@@ -942,11 +954,15 @@ class Fit:
                 raise ValueError(
                     f'Invalid parameter fit_type ({fit_type})')
         self._fit_type = fit_type
+        self._fwhm_min = fwhm_min
         self._fwhm_max = fwhm_max
+        self._sigma_min = None
         self._sigma_max = None
         if param_constraint:
             self._param_constraint = True
             min_value = FLOAT_MIN
+            if self._fwhm_min is not None:
+                self._sigma_min = np.zeros(num_peaks)
             if self._fwhm_max is not None:
                 self._sigma_max = np.zeros(num_peaks)
         else:
@@ -1045,7 +1061,13 @@ class Fit:
                     f'Invalid parameter background ({background})')
 
         # Add peaks and set initial fit parameters
+        ast = Interpreter()
         if num_peaks == 1:
+            sig_min = None
+            if self._sigma_min is not None:
+                ast(f'fwhm = {self._fwhm_min}')
+                sig_min = ast(fwhm_factor[peak_models[0]])
+                self._sigma_min[0] = sig_min
             sig_max = None
             if self._sigma_max is not None:
                 ast(f'fwhm = {self._fwhm_max}')
@@ -1055,14 +1077,20 @@ class Fit:
                 peak_models[0],
                 parameters=(
                     {'name': 'amplitude', 'min': min_value},
-                    {'name': 'center', 'value': centers[0], 'min': min_value},
-                    {'name': 'sigma', 'min': min_value, 'max': sig_max},
+                    {'name': 'center', 'value': centers[0],
+                     'min': centers_range[0], 'max': centers_range[1]},
+                    {'name': 'sigma', 'min': sig_min, 'max': sig_max},
                 ))
         else:
             if fit_type == 'uniform':
                 self.add_parameter(
                     name='scale_factor', value=1.0, min=min_value)
             for i in range(num_peaks):
+                sig_min = None
+                if self._sigma_min is not None:
+                    ast(f'fwhm = {self._fwhm_min}')
+                    sig_min = ast(fwhm_factor[peak_models[i]])
+                    self._sigma_min[i] = sig_min
                 sig_max = None
                 if self._sigma_max is not None:
                     ast(f'fwhm = {self._fwhm_max}')
@@ -1074,8 +1102,7 @@ class Fit:
                         parameters=(
                             {'name': 'amplitude', 'min': min_value},
                             {'name': 'center', 'expr': center_exprs[i]},
-                            {'name': 'sigma', 'min': min_value,
-                             'max': sig_max},
+                            {'name': 'sigma', 'min': sig_min, 'max': sig_max},
                         ))
                 else:
                     self.add_model(
@@ -1084,7 +1111,7 @@ class Fit:
                         parameters=(
                             {'name': 'amplitude', 'min': min_value},
                             {'name': 'center', 'value': centers[i],
-                             'min': min_value},
+                             'min': centers_range[0], 'max': centers_range[1]},
                             {'name': 'sigma', 'min': min_value,
                              'max': sig_max},
                         ))
@@ -1102,7 +1129,7 @@ class Fit:
         # Third party modules
         from asteval import Interpreter
 
-        # Check inputs
+        # Check input parameters
         if self._model is None:
             logger.error('Undefined fit model')
             return None
@@ -1121,6 +1148,11 @@ class Fit:
                     f'Invalid value of keyword argument guess ({guess})')
         else:
             guess = False
+        if self._result is not None:
+            if guess:
+                logger.warning(
+                    'Ignoring input parameter guess during refitting')
+                guess = False
         if 'try_linear_fit' in kwargs:
             try_linear_fit = kwargs.pop('try_linear_fit')
             if not isinstance(try_linear_fit, bool):
@@ -1133,16 +1165,6 @@ class Fit:
                     '(not yet supported for callable models)')
             else:
                 self._try_linear_fit = try_linear_fit
-        if self._result is not None:
-            if guess:
-                logger.warning(
-                    'Ignoring input parameter guess during refitting')
-                guess = False
-
-        # Check for circular expressions
-        # RV
-#        for name1, par1 in self._parameters.items():
-#            if par1.expr is not None:
 
         # Apply mask if supplied:
         if 'mask' in kwargs:
@@ -1171,14 +1193,17 @@ class Fit:
                 # Should work for other peak-like models,
                 #   but will need tests first
                 for component in self._model.components:
-                    if component._name == 'gaussian':
+                    if isinstance(component, GaussianModel):
                         center = self._parameters[
                             f"{component.prefix}center"].value
                         height_init, cen_init, fwhm_init = \
                             self.guess_init_peak(
                                 xx, yy, center_guess=center,
                                 use_max_for_center=False)
-                        if (self._fwhm_max is not None
+                        if (self._fwhm_min is not None
+                                and fwhm_init < self._fwhm_min):
+                            fwhm_init = self._fwhm_min
+                        elif (self._fwhm_max is not None
                                 and fwhm_init > self._fwhm_max):
                             fwhm_init = self._fwhm_max
                         ast(f'fwhm = {fwhm_init}')
@@ -1292,9 +1317,7 @@ class Fit:
             self._parameter_bounds = {
                 name:{'min': par.min, 'max': par.max}
                 for name, par in self._parameters.items() if par.vary}
-            for par in self._parameters.values():
-                if par.vary:
-                    par.set(value=self._reset_par_at_boundary(par, par.value))
+            self._reset_par_at_boundary()
 
             # Perform the fit
             fit_kws = None
@@ -1842,39 +1865,39 @@ class Fit:
         if self._result.residual is not None:
             self._result.residual *= self._norm[1]
 
-    def _reset_par_at_boundary(self, par, value):
-        assert par.vary
-        name = par.name
-        _min = self._parameter_bounds[name]['min']
-        _max = self._parameter_bounds[name]['max']
-        if np.isinf(_min):
-            if not np.isinf(_max):
-                if self._parameter_norms.get(name, False):
-                    upp = _max-0.1*self._y_range
-                elif _max == 0.0:
-                    upp = _max-0.1
-                else:
-                    upp = _max-0.1*abs(_max)
-                if value >= upp:
-                    return upp
-        else:
-            if np.isinf(_max):
-                if self._parameter_norms.get(name, False):
-                    low = _min + 0.1*self._y_range
-                elif _min == 0.0:
-                    low = _min+0.1
+    def _reset_par_at_boundary(self):
+        for name, par in self._parameters.items():
+            if par.vary:
+                value = par.value
+                _min = self._parameter_bounds[name]['min']
+                _max = self._parameter_bounds[name]['max']
+                if np.isinf(_min):
+                    if not np.isinf(_max):
+                        if self._parameter_norms.get(name, False):
+                            upp = _max-0.1*self._y_range
+                        elif _max == 0.0:
+                            upp = _max-0.1
+                        else:
+                            upp = _max-0.1*abs(_max)
+                        if value >= upp:
+                            par.set(value=upp)
                 else:
-                    low = _min + 0.1*abs(_min)
-                if value <= low:
-                    return low
-            else:
-                low = 0.9*_min + 0.1*_max
-                upp = 0.1*_min + 0.9*_max
-                if value <= low:
-                    return low
-                if value >= upp:
-                    return upp
-        return value
+                    if np.isinf(_max):
+                        if self._parameter_norms.get(name, False):
+                            low = _min + 0.1*self._y_range
+                        elif _min == 0.0:
+                            low = _min+0.1
+                        else:
+                            low = _min + 0.1*abs(_min)
+                        if value <= low:
+                            par.set(value=low)
+                    else:
+                        low = 0.9*_min + 0.1*_max
+                        upp = 0.1*_min + 0.9*_max
+                        if value <= low:
+                            par.set(value=low)
+                        if value >= upp:
+                            par.set(value=upp)
 
 
 class FitMap(Fit):
@@ -1917,7 +1940,7 @@ class FitMap(Fit):
             raise ValueError('Invalid parameter ymap ({ymap})')
         self._ymap = ymap
 
-        # Verify the input parameters
+        # Check input parameters
         if self._x.ndim != 1:
             raise ValueError(f'Invalid dimension for input x {self._x.ndim}')
         if self._ymap.ndim < 2:
@@ -2314,7 +2337,7 @@ class FitMap(Fit):
             logger.warning(
                 f'The requested number of processors ({num_proc}) exceeds the '
                 'maximum number of processors, num_proc reduced to '
-                f'({cpu_count()})')
+                f'{cpu_count()}')
             num_proc = cpu_count()
         if 'try_no_bounds' in kwargs:
             self._try_no_bounds = kwargs.pop('try_no_bounds')
@@ -2469,9 +2492,7 @@ class FitMap(Fit):
         self._parameter_bounds = {
             name:{'min': par.min, 'max': par.max}
             for name, par in self._parameters.items() if par.vary}
-        for name, par in self._parameters.items():
-            if par.vary:
-                par.set(value=self._reset_par_at_boundary(par, par.value))
+        self._reset_par_at_boundary()
 
         # Set parameter bounds to unbound
         #     (only use bounds when fit fails)
@@ -2587,7 +2608,7 @@ class FitMap(Fit):
             if num_proc > num_fit:
                 logger.warning(
                     f'The requested number of processors ({num_proc}) exceeds '
-                    f'the number of fits, num_proc reduced to ({num_fit})')
+                    f'the number of fits, num_proc reduced to {num_fit}')
                 num_proc = num_fit
                 num_fit_per_proc = 1
             else:
@@ -2684,23 +2705,112 @@ class FitMap(Fit):
             self._fit(n_start+n, current_best_values, **kwargs)
 
     def _fit(self, n, current_best_values, return_result=False, **kwargs):
+        # Check input parameters
+        if 'rel_amplitude_cutoff' in kwargs:
+            rel_amplitude_cutoff = kwargs.pop('rel_amplitude_cutoff')
+            if (rel_amplitude_cutoff is not None
+                    and not is_num(rel_amplitude_cutoff, gt=0.0, lt=1.0)):
+                logger.warning(
+                    'Ignoring invalid parameter rel_amplitude_cutoff '
+                    f'in FitMap._fit() ({rel_amplitude_cutoff})')
+                rel_amplitude_cutoff = None
+        else:
+            rel_amplitude_cutoff = None
+
+        # Regular full fit
+        result = self._fit_with_bounds_check(n, current_best_values, **kwargs)
+
+        if rel_amplitude_cutoff is not None:
+            # Third party modules
+            from lmfit.models import (
+                GaussianModel,
+                LorentzianModel,
+            )
+
+            # Check for low amplitude peaks and refit without them
+            amplitudes = []
+            names = []
+            for component in result.components:
+                if isinstance(component, (GaussianModel, LorentzianModel)):
+                   for name in component.param_names:
+                       if 'amplitude' in name:
+                           amplitudes.append(result.params[name].value)
+                           names.append(name)
+            if amplitudes:
+                refit = False
+                amplitudes = np.asarray(amplitudes)/sum(amplitudes)
+                parameters_save = deepcopy(self._parameters)
+                for i, (name, amp) in enumerate(zip(names, amplitudes)):
+                    if abs(amp) < rel_amplitude_cutoff:
+                        self._parameters[name].set(
+                            value=0.0, min=0.0, vary=False)
+                        self._parameters[
+                            name.replace('amplitude', 'center')].set(
+                               vary=False)
+                        self._parameters[
+                            name.replace('amplitude', 'sigma')].set(
+                               value=0.0, min=0.0, vary=False)
+                        refit = True
+                if refit:
+                    result = self._fit_with_bounds_check(
+                        n, current_best_values, **kwargs)
+#                    for name in names:
+#                        result.params[name].error = 0.0
+                    # Reset fixed amplitudes back to default
+                    self._parameters = deepcopy(parameters_save)
+
+        if result.redchi >= self._redchi_cutoff:
+            result.success = False
+        if result.nfev == result.max_nfev:
+            if result.redchi < self._redchi_cutoff:
+                result.success = True
+            self._max_nfev_flat[n] = True
+        if result.success:
+            assert all(
+                True for par in current_best_values
+                if par in result.params.values())
+            for par in result.params.values():
+                if par.vary:
+                    current_best_values[par.name] = par.value
+        else:
+            logger.warning(f'Fit for n = {n} failed: {result.lmdif_message}')
+        # Renormalize the data and results
+        self._renormalize(n, result)
+        if self._print_report:
+            print(result.fit_report(show_correl=False))
+        if self._plot:
+            dims = np.unravel_index(n, self._map_shape)
+            if self._inv_transpose is not None:
+                dims = tuple(
+                    dims[self._inv_transpose[i]] for i in range(len(dims)))
+            super().plot(
+                result=result, y=np.asarray(self._ymap[dims]),
+                plot_comp_legends=True, skip_init=self._skip_init,
+                title=str(dims))
+        if return_result:
+            return result
+        return None
+
+    def _fit_with_bounds_check(self, n, current_best_values, **kwargs):
         # Set parameters to current best values, but prevent them from
         #     sitting at boundaries
         if self._new_parameters is None:
             # Initial fit
             for name, value in current_best_values.items():
                 par = self._parameters[name]
-                par.set(value=self._reset_par_at_boundary(par, value))
+                if par.vary:
+                    par.set(value=value)
         else:
             # Refit
             for i, name in enumerate(self._best_parameters):
                 par = self._parameters[name]
-                if name in self._new_parameters:
-                    if name in current_best_values:
-                        par.set(value=self._reset_par_at_boundary(
-                            par, current_best_values[name]))
-                elif par.expr is None:
-                    par.set(value=self._best_values[i][n])
+                if par.vary:
+                    if name in self._new_parameters:
+                        if name in current_best_values:
+                            par.set(value=current_best_values[name])
+                    elif par.expr is None:
+                        par.set(value=self._best_values[i][n])
+        self._reset_par_at_boundary()
         if self._mask is None:
             result = self._model.fit(
                 self._ymap_norm[n], self._parameters, x=self._x, **kwargs)
@@ -2710,35 +2820,39 @@ class FitMap(Fit):
                 x=self._x[~self._mask], **kwargs)
         out_of_bounds = False
         for name, par in self._parameter_bounds.items():
-            value = result.params[name].value
-            if not np.isinf(par['min']) and value < par['min']:
-                out_of_bounds = True
-                break
-            if not np.isinf(par['max']) and value > par['max']:
-                out_of_bounds = True
-                break
+            if self._parameters[name].vary:
+                value = result.params[name].value
+                if not np.isinf(par['min']) and value < par['min']:
+                    out_of_bounds = True
+                    break
+                if not np.isinf(par['max']) and value > par['max']:
+                    out_of_bounds = True
+                    break
         self._out_of_bounds_flat[n] = out_of_bounds
         if self._try_no_bounds and out_of_bounds:
             # Rerun fit with parameter bounds in place
             for name, par in self._parameter_bounds.items():
-                self._parameters[name].set(min=par['min'], max=par['max'])
+                if self._parameters[name].vary:
+                    self._parameters[name].set(min=par['min'], max=par['max'])
             # Set parameters to current best values, but prevent them
             #     from sitting at boundaries
             if self._new_parameters is None:
                 # Initial fit
                 for name, value in current_best_values.items():
                     par = self._parameters[name]
-                    par.set(value=self._reset_par_at_boundary(par, value))
+                    if par.vary:
+                        par.set(value=value)
             else:
                 # Refit
                 for i, name in enumerate(self._best_parameters):
                     par = self._parameters[name]
-                    if name in self._new_parameters:
-                        if name in current_best_values:
-                            par.set(value=self._reset_par_at_boundary(par,
-                                    current_best_values[name]))
-                    elif par.expr is None:
-                        par.set(value=self._best_values[i][n])
+                    if par.vary:
+                        if name in self._new_parameters:
+                            if name in current_best_values:
+                                par.set(value=current_best_values[name])
+                        elif par.expr is None:
+                            par.set(value=self._best_values[i][n])
+            self._reset_par_at_boundary()
             if self._mask is None:
                 result = self._model.fit(
                     self._ymap_norm[n], self._parameters, x=self._x, **kwargs)
@@ -2748,48 +2862,18 @@ class FitMap(Fit):
                     x=self._x[~self._mask], **kwargs)
             out_of_bounds = False
             for name, par in self._parameter_bounds.items():
-                value = result.params[name].value
-                if not np.isinf(par['min']) and value < par['min']:
-                    out_of_bounds = True
-                    break
-                if not np.isinf(par['max']) and value > par['max']:
-                    out_of_bounds = True
-                    break
-            # Reset parameters back to unbound
-            for name in self._parameter_bounds.keys():
-                self._parameters[name].set(min=-np.inf, max=np.inf)
+                if self._parameters[name].vary:
+                    value = result.params[name].value
+                    if not np.isinf(par['min']) and value < par['min']:
+                        out_of_bounds = True
+                        break
+                    if not np.isinf(par['max']) and value > par['max']:
+                        out_of_bounds = True
+                        break
+                    # Reset parameters back to unbound
+                    self._parameters[name].set(min=-np.inf, max=np.inf)
         assert not out_of_bounds
-        if result.redchi >= self._redchi_cutoff:
-            result.success = False
-        if result.nfev == result.max_nfev:
-            if result.redchi < self._redchi_cutoff:
-                result.success = True
-            self._max_nfev_flat[n] = True
-        if result.success:
-            assert all(
-                True for par in current_best_values
-                if par in result.params.values())
-            for par in result.params.values():
-                if par.vary:
-                    current_best_values[par.name] = par.value
-        else:
-            logger.warning(f'Fit for n = {n} failed: {result.lmdif_message}')
-        # Renormalize the data and results
-        self._renormalize(n, result)
-        if self._print_report:
-            print(result.fit_report(show_correl=False))
-        if self._plot:
-            dims = np.unravel_index(n, self._map_shape)
-            if self._inv_transpose is not None:
-                dims = tuple(
-                    dims[self._inv_transpose[i]] for i in range(len(dims)))
-            super().plot(
-                result=result, y=np.asarray(self._ymap[dims]),
-                plot_comp_legends=True, skip_init=self._skip_init,
-                title=str(dims))
-        if return_result:
-            return result
-        return None
+        return result
 
     def _renormalize(self, n, result):
         self._redchi_flat[n] = np.float64(result.redchi)