Method _compute_intensity

pyxrf/model/lineplot.py:1137–1201

(self, elist)

        return energy, marker_visible

    def _compute_intensity(self, elist):
        # Some default value
        intensity = 1000.0

        if (
            self.io_model.data is not None
            and self.param_model.param_new is not None
            and self.param_model.prefit_x is not None
            and self.param_model.total_y is not None
            and len(self.io_model.data) > 1
            and len(self.param_model.prefit_x) > 1
        ):
            # Range of energies in fitting results
            e_fit_min = self.param_model.prefit_x[0]
            e_fit_max = self.param_model.prefit_x[-1]
            de_fit = (e_fit_max - e_fit_min) / (len(self.param_model.prefit_x) - 1)

            e_raw_min = self.param_model.param_new["e_offset"]["value"]
            e_raw_max = (
                self.param_model.param_new["e_offset"]["value"]
                + (len(self.io_model.data) - 1) * self.param_model.param_new["e_linear"]["value"]
                + (len(self.io_model.data) - 1) ** 2 * self.param_model.param_new["e_quadratic"]["value"]
            )

            de_raw = (e_raw_max - e_raw_min) / (len(self.io_model.data) - 1)

            # Note: the above algorithm for finding 'de_raw' is far from perfect but will
            #    work for now. As a result 'de_fit' and
            #    'de_raw' == sself.param_model.param_new['e_linear']['value'].
            #    So the quadratic coefficent is ignored. This is OK, since currently
            #    quadratic coefficient is always ZERO. When the program is rewritten,
            #    the complete algorithm should be revised.

            # Find the line with maximum energy. It must come first in the list,
            #    but let's check just to make sure
            max_line_energy, max_line_intensity = 0, 0
            if elist:
                for e, i in elist:
                    # e - line peak energy
                    # i - peak intensity relative to maximum peak
                    if e >= e_fit_min and e <= e_fit_max and e > e_raw_min and e < e_raw_max:
                        if max_line_intensity < i:
                            max_line_energy, max_line_intensity = e, i

            # Find the index of peak maximum in the 'fitted' data array
            n = (max_line_energy - e_fit_min) / de_fit
            n = np.clip(n, 0, len(self.param_model.total_y) - 1)
            n_fit = int(round(n))
            # Find the index of peak maximum in the 'raw' data array
            n = (max_line_energy - e_raw_min) / de_raw
            n = np.clip(n, 0, len(self.io_model.data) - 1)
            n_raw = int(round(n))
            # Intensity of the fitted data at the peak
            in_fit = self.param_model.total_y[n_fit]
            # Intensity of the raw data at the peak
            in_raw = self.io_model.data[n_raw]
            # The estimated peak intensity is the difference:
            intensity = in_raw - in_fit