def lmfit_ngauss(x,y, *params):
  params = params[0]
  mods = []
  prefixes = []
  for i in range(0, len(params), 3):
    pref = "g%02i_" % (i/3)
    gauss_i = GaussianModel(prefix=pref)

    if i == 0:
      pars = gauss_i.guess(y, x=x)
    else:
      pars.update(gauss_i.make_params())

    A = params[i]
    l_cen = params[i+1]
    sigma = params[i+2]

    pars[pref+'amplitude'].set(A)
    pars[pref+'center'].set(l_cen)
    pars[pref+'sigma'].set(sigma)

    mods.append(gauss_i)
    prefixes.append(pref)

  mod = mods[0]

  if len(mods) > 1:
    for m in mods[1:]:
      mod += m

  print mod

  init = mod.eval(pars, x=x)
  out = mod.fit(y, pars, x=x)
  return mod, out, init
示例#2
0
def make_gaussian_model(self):
    """ This method creates a model of a gaussian with an offset.

    @return tuple: (object model, object params)

    Explanation of the objects:
        object lmfit.model.CompositeModel model:
            A model the lmfit module will use for that fit. Here a
            gaussian model. Returns an object of the class
            lmfit.model.CompositeModel.

        object lmfit.parameter.Parameters params:
            It is basically an OrderedDict, so a dictionary, with keys
            denoting the parameters as string names and values which are
            lmfit.parameter.Parameter (without s) objects, keeping the
            information about the current value.
            The used model has the Parameter with the meaning:
                'amplitude' : amplitude
                'center'    : center
                'sigm'      : sigma
                'fwhm'      : full width half maximum
                'c'         : offset

    For further information have a look in:
    http://cars9.uchicago.edu/software/python/lmfit/builtin_models.html#models.GaussianModel
    """

    model = GaussianModel() + ConstantModel()
    params = model.make_params()

    return model, params
示例#3
0
def init_dr_model(baseline=False, guess=None):
    """ Function to serialize a Model object for DR fits.
        Defaults to a Gaussian line shape, but the option to include
        a linear offset is available.

        Additionally, if a guess is provided in the
        lmfit convention then it will be incorporated.

        args:
        -----------------
        baseline - boolean indicating if linear offset is included
        guess - nested dict with keys corresponding to parameter name
                and values corresponding to dicts with key/value
                indicating the parameter value, range, and constraints
    """
    model = GaussianModel()
    if baseline:
        model += LinearModel()
    params = model.make_params()
    if guess:
        params.update(guess)
    # Constrain amplitude to always be negative
    # since we're measuring depletion.
    params["amplitude"].set(max=0.0)
    return model, params
def test_2gaussians():

  x = np.linspace(0.0, 10.0, num=1000)
  y = gaussian(x, -1, 3, 0.75) + gaussian(x, -0.5, 5, 0.8) + np.random.normal(0, 0.01, x.shape[0])

  gauss1  = GaussianModel(prefix='g1_')
  
  pars = gauss1.guess(y, x=x)
  pars['g1_amplitude'].set(-0.9)
  pars['g1_center'].set(2.5)
  pars['g1_sigma'].set(0.5)

  gauss2  = GaussianModel(prefix='g2_')
  pars.update(gauss2.make_params())
  pars['g2_amplitude'].set(-0.4)
  pars['g2_center'].set(5)
  pars['g2_sigma'].set(0.5)

  mod = gauss1 + gauss2

  init = mod.eval(pars, x=x)

  plt.plot(x, y)
  plt.plot(x, init, 'k--')

  out = mod.fit(y, pars, x=x)

  print(out.fit_report(min_correl=0.5))

  plt.plot(x, out.best_fit, 'r-')
  plt.show()
def fit_profile(profile, guess):
    "Fit a profile to a Gaussian + Contant"
    x = np.arange(len(profile))

    model = GaussianModel(missing='drop') + ConstantModel(missing='drop')
    result = model.fit(profile, x=x, verbose=False, **guess)
    return result
示例#6
0
def gaussian(x, y):

	# Gaussian fit to a curve

    x_shifted = x - x.min() # Shifting to 0    
    y_shifted = y - y.min() # Shifting to 0    
    mod = GaussianModel() # Setting model type
    pars = mod.guess(y_shifted, x=x_shifted) # Estimating fit
    out = mod.fit(y_shifted, pars, x=x_shifted) # Fitting fit
    print(out.fit_report(min_correl=0.25)) # Outputting best fit results
    #print("Gaussian FWHM = ", out.params['fwhm'].value) # Outputting only FWHM
    out.plot() # Plotting fit
    
    
    std = np.std(x_shifted)
    mux = np.mean(x_shifted)
    h_y = np.max(out.best_fit)
    #print(std, mux, h_y)
    
    y_x = h_y/2
    
    x_i = mux - np.sqrt(2*(std**2)*
                    np.log((np.sqrt(2*np.pi)*y_x*std)/
                          (h_y)))
    
    x_f = mux + np.sqrt(2*(std**2)*
                    np.log((np.sqrt(2*np.pi)*y_x*std)/
                          (h_y)))  
    
    fwhm = x_f-x_i
    print(x_i, x_f, fwhm)
def GaussConst(signal, guess):
    
    amp, centre, stdev, offset = guess
    
    data = np.array([range(len(signal)), signal]).T
    X = data[:,0]
    Y = data[:,1]

    gauss_mod = GaussianModel(prefix='gauss_')
    const_mod = ConstantModel(prefix='const_')
    
    pars = gauss_mod.make_params(center=centre, sigma=stdev, amplitude=amp)
    pars += const_mod.guess(Y, x=X)
    pars['gauss_center'].min = centre - 5.
    pars['gauss_center'].max = centre + 5.
    pars['gauss_sigma'].max = stdev + 5.
    
    mod = gauss_mod + const_mod
    result = mod.fit(Y, pars, x=X)
    
    fwhm = result.best_values['gauss_sigma'] #* 2.3548
    centr = result.best_values['gauss_center']
    
    # Values within two stdevs i.e. 95%
    pl.plot(np.repeat(centr - fwhm * 2, len(Y)),
            np.arange(len(Y)), 'b-')
    pl.plot(np.repeat(centr + fwhm * 2, len(Y)),
            np.arange(len(Y)), 'b-')
    
    return X, result.best_fit, result.best_values['gauss_sigma'] * 4
    def fit_and_plot_scan(self):
        #        self.ui.result_textBrowser.append("Starting Scan Fitting")
        print("Starting Scan Fitting")

        try:
            """Define starting and stopping wavelength values here"""
            start_nm = int(self.ui.start_nm_spinBox.value())
            stop_nm = int(self.ui.stop_nm_spinBox.value())

            ref = self.bck_file
            index = (ref[:, 0] > start_nm) & (ref[:, 0] < stop_nm)

            x = self.wavelengths
            x = x[index]

            data_array = self.intensities

            result_dict = {}

            for i in range(data_array.shape[0]):

                y = data_array[i, index]  # intensity
                yref = ref[index, 1]

                y = y - yref  # background correction
                y = y - np.mean(
                    y[(x > start_nm)
                      & (x < start_nm + 25)])  # removing any remaining bckgrnd

                gmodel = GaussianModel(prefix='g1_')  # calling gaussian model
                pars = gmodel.guess(y,
                                    x=x)  # parameters - center, width, height
                result = gmodel.fit(y, pars, x=x, nan_policy='propagate')
                result_dict["result_" + str(i)] = result

#            self.ui.result_textBrowser.append("Scan Fitting Complete!")
            print("Scan Fitting Complete!")

            filename = QtWidgets.QFileDialog.getSaveFileName(self)
            pickle.dump(result_dict,
                        open(filename[0] + "_fit_result_dict.pkl", "wb"))

            #            self.ui.result_textBrowser.append("Data Saved!")
            print("Data Saved!")

        except Exception as e:
            self.ui.result_textBrowser2.append(str(e))
            pass


#        self.ui.result_textBrowser.append("Loading Fit Data and Plotting")
        print("Loading Fit Data and Plotting")
        try:
            self.fit_scan_file = pickle.load(
                open(filename[0] + "_fit_result_dict.pkl", 'rb'))
            self.plot_fit_scan()

        except Exception as e:
            self.ui.result_textBrowser2.append(str(e))
            pass
    def gaussian_model(self):
        composite_model = None
        composite_pars = None

        x, y = self.background_correction()

        for i in range(self.num_of_gaussians):

            model = GaussianModel(prefix='g' + str(i + 1) + '_')

            if composite_pars is None:
                composite_pars = model.guess(y, x=x)
#                 composite_pars = model.make_params()

            else:
                composite_pars.update(model.make_params())

            if composite_model is None:
                composite_model = model
            else:
                composite_model += model

        result = composite_model.fit(y,
                                     composite_pars,
                                     x=x,
                                     nan_policy='propagate')
        return result
示例#10
0
def test_default_inputs_gauss():
    area = 1
    cen = 0
    std = 0.2
    x = np.arange(-3, 3, 0.01)
    y = gaussian(x, area, cen, std)

    g = GaussianModel()

    fit_option1 = {'maxfev': 5000, 'xtol': 1e-2}
    result1 = g.fit(y,
                    x=x,
                    amplitude=1,
                    center=0,
                    sigma=0.5,
                    fit_kws=fit_option1)

    fit_option2 = {'maxfev': 5000, 'xtol': 1e-6}
    result2 = g.fit(y,
                    x=x,
                    amplitude=1,
                    center=0,
                    sigma=0.5,
                    fit_kws=fit_option2)

    assert result1.values != result2.values
def lmfit_ngauss(x, y, *params):
    params = params[0]
    mods = []
    prefixes = []
    for i in range(0, len(params), 3):
        pref = "g%02i_" % (i / 3)
        gauss_i = GaussianModel(prefix=pref)

        if i == 0:
            pars = gauss_i.guess(y, x=x)
        else:
            pars.update(gauss_i.make_params())

        A = params[i]
        l_cen = params[i + 1]
        sigma = params[i + 2]

        pars[pref + 'amplitude'].set(A)
        pars[pref + 'center'].set(l_cen)
        pars[pref + 'sigma'].set(sigma)

        mods.append(gauss_i)
        prefixes.append(pref)

    mod = mods[0]

    if len(mods) > 1:
        for m in mods[1:]:
            mod += m

    print mod

    init = mod.eval(pars, x=x)
    out = mod.fit(y, pars, x=x)
    return mod, out, init
def gaussFitFunction(fitOut,minimum,maximum,ptNumber=100,prefix=None):
	x = np.linspace(minimum,maximum,ptNumber)
	gaussian = GaussianModel()
	if prefix==None: params = fitOut.best_values
	else: params = getKeysWithoutPrefix(fitOut.best_values,prefix)
	gauss = gaussian.func(x=x,center=params["center"],sigma=params["sigma"],amplitude=params["amplitude"])
	return x, gauss
示例#13
0
def fit(les_x_init, les_y_init, remove):
    les_x = []
    les_y = []
    for i in range(len(les_x_init)):
        if les_x_init[i] not in remove:
            les_x.append(les_x_init[i])
            les_y.append(les_y_init[i])
    x = scipy.asarray(les_x)
    y = scipy.asarray(les_y)
    gmod = GaussianModel()
    param = gmod.guess(y, x=x)
    amplitude = param['amplitude'].value
    center = param['center'].value
    sigma = param['sigma'].value
    the_fit = gmod.fit(y, x=x, amplitude=amplitude, center=center, sigma=sigma)
    best_res = the_fit.chisqr
    amplitude = the_fit.params['amplitude'].value
    center = the_fit.params['center'].value
    sigma = the_fit.params['sigma'].value
    best_sol = [amplitude, center, sigma]
    y_fit = []
    for i in range(len(les_x_init)):
        y_fit.append(
            gmod.eval(x=les_x_init[i],
                      amplitude=amplitude,
                      center=center,
                      sigma=sigma))
    return [best_sol, best_res, y_fit]
示例#14
0
 def peakFit(self, x, y, model = 'gau', pi = None, di = None):
     ti = time.time()
     if pi:
         NumPeaks = len(pi)
         center = []
         fwhm = []
         amp = []
         numVal = len(x)
         for i in range(NumPeaks):
             pImin = pi[i]-di
             if pImin < 0:
                 pImin = 0
             pImax = pi[i] + di
             if pImax > (numVal-1):
                 pImax = numVal-1
             __y = y[pImin:pImax]
             __x = x[pImin:pImax]
             
             __y = np.power(10,__y/10) #np.array(y)- np.min(y)
             
             mod = GaussianModel()
             pars = mod.guess(__y, x=__x)
             out  = mod.fit(__y, pars, x=__x)
             center.append(out.best_values['center'])
             fwhm.append(out.best_values['sigma']*2.3548)
             amp.append(out.best_values['amplitude'])
         #print 'fit:', time.time()-ti
         return center, fwhm ,amp
示例#15
0
    def refine_energies(self,
                        frame_width: int = 20) -> List[Tuple[float, Any]]:
        """
        Refine energy locations using curve fitting. For every peak in `.energies`, a small slice of the data around it is curve fitted to a gaussian and the center used as the refined energy location.
        
        Will set the property `.refined_energies` equal to function output

        Note: The detector energy channel is a `float` here

        Parameters:
            frame_width (int): The width of the slice of data around the peak used for curve fitting

        Returns:
            (List[Tuple[float, Any]]): List of energy locations as tuple (detector energy channel, actual energy)
        """
        model = GaussianModel()
        refined = []
        for energy in self.energies:
            domain = (int(max(energy[0] - frame_width / 2, 0)),
                      int(
                          min(energy[0] + frame_width / 2,
                              self.data.shape[0] - 1)))
            frame = self.data[domain[0]:domain[1]]
            pars = model.guess(frame, x=np.arange(0, 20))
            out = model.fit(frame, pars, x=np.arange(0, 20))
            refined.append((out.params["center"].value + domain[0], energy[1]))

        self.refined_energies = refined
        self.polynomial_coefficients = None
        return refined
示例#16
0
def test_lmfit():
    """ load data """
    wave, flux, flux_err = np.loadtxt(
        '/hydrogen/projects/song/delCep_order20.dat').T
    flux_sine = 1 - flux
    flux_sine = flux_sine * sinebell_like(flux, 1.0)

    flux_obs = flux_sine + np.random.randn(*flux_sine.shape) * 0.1
    wave_mod = wave
    wave_obs = wave
    flux_mod = flux_sine
    rv_grid = np.linspace(-500, 500, 1000)
    # z_grid = rv_grid / constants.c.value * 1000

    ccfv = xcorr_rvgrid(wave_obs,
                        flux_obs,
                        wave_mod,
                        flux_mod,
                        mask_obs=None,
                        rv_grid=rv_grid,
                        sinebell_idx=1)

    # Gaussian fit using LMFIT
    from lmfit.models import GaussianModel

    mod = GaussianModel()
    x, y = ccfv[0], ccfv[1]
    # pars = mod.guess(y, x=x)
    out = mod.fit(y, None, x=x, method="least_squares")
    # out = mod.fit(y, pars, x=x, method="leastsq")

    plt.figure()
    plt.plot(x, y)
    plt.plot(x, out.best_fit)
    print(out.fit_report())
示例#17
0
def GaussConst(signal, guess):
    
    if guess == False:
        return [0, 0, 0]
    else:
        amp, centre, stdev, offset = guess
        
        data = np.array([range(len(signal)), signal]).T
        X = data[:,0]
        Y = data[:,1]

        gauss_mod = GaussianModel(prefix='gauss_')
        const_mod = ConstantModel(prefix='const_')
        
        #pars = lorentz_mod.make_params(amplitude=amp, center=centre, sigma=stdev / 3.)
        #lorentz_mod.set_param_hint('sigma', value = stdev / 3., min=0., max=stdev)
        
        pars = gauss_mod.guess(Y, x=X, center=centre, sigma=stdev / 3., amplitude=amp)
        #pars += step_mod.guess(Y, x=X, center=centre)
        pars += const_mod.guess(Y, x=X)
        
        pars['gauss_sigma'].vary = False
        mod = gauss_mod + const_mod
        result = mod.fit(Y, pars, x=X)
        # write error report
        #print result.fit_report()
        fwhm = result.best_values['gauss_sigma'] * 2.3548

        
    return X, result.best_fit, result.redchi, fwhm
示例#18
0
def find_fraunhofer_center(field: np.ndarray,
                           ic: np.ndarray,
                           debug: bool = False) -> float:
    """Extract the field at which the Fraunhofer is centered.

    Parameters
    ----------
    field : np.ndarray
        1D array of the magnetic field applied of the JJ.
    ic : np.ndarray
        1D array of the JJ critical current.

    Returns
    -------
    float
        Field at which the center of the pattern is located.

    """
    max_loc = np.argmax(ic)
    width, *_ = peak_widths(ic, [max_loc], rel_height=0.5)
    width_index = int(round(width[0] * 0.65))
    subset_field = field[max_loc - width_index:max_loc + width_index + 1]
    subset_ic = ic[max_loc - width_index:max_loc + width_index + 1]
    model = GaussianModel()
    params = model.guess(subset_ic, subset_field)
    out = model.fit(subset_ic, params, x=subset_field)

    if debug:
        plt.figure()
        plt.plot(field, ic)
        plt.plot(subset_field, out.best_fit)
        plt.show()

    return out.best_values["center"]
def GaussConst(signal, guess):

    amp, centre, stdev, offset = guess

    data = np.array([range(len(signal)), signal]).T
    X = data[:, 0]
    Y = data[:, 1]

    gauss_mod = GaussianModel(prefix='gauss_')
    const_mod = ConstantModel(prefix='const_')

    pars = gauss_mod.make_params(center=centre, sigma=stdev, amplitude=amp)
    pars += const_mod.guess(Y, x=X)
    pars['gauss_center'].min = centre - 5.
    pars['gauss_center'].max = centre + 5.
    pars['gauss_sigma'].max = stdev + 5.

    mod = gauss_mod + const_mod
    result = mod.fit(Y, pars, x=X)

    fwhm = result.best_values['gauss_sigma']  #* 2.3548
    centr = result.best_values['gauss_center']

    # Values within two stdevs i.e. 95%
    pl.plot(np.repeat(centr - fwhm * 2, len(Y)), np.arange(len(Y)), 'b-')
    pl.plot(np.repeat(centr + fwhm * 2, len(Y)), np.arange(len(Y)), 'b-')

    return X, result.best_fit, result.best_values['gauss_sigma'] * 4
示例#20
0
    def _fit_gauss(xval, yval):

        model = GaussianModel()
        result = model.fit(yval, model.guess(yval, x=xval,
                           amplitude=np.max(yval)), x=xval)

        return result
示例#21
0
def fitgaussian_sample(sample, components, svg, verbose, center, cmin, cmax,
                       amp, amin, sigma, smin):
    '''Fits gaussian curve to dyad coverage for a single sample.'''
    print('Fits gaussian curve to dyad coverage of sample {}'.format(sample))
    input = sample + '-dyad.txt'
    dyads = pd.read_csv(input, sep='\t', index_col=0, comment='#')
    x = dyads.index.values
    y = dyads['Relative Frequency'].values
    if not amp:
        amp = dyads['Relative Frequency'].max() * 100
    if not center:
        center = 0.0
    if not sigma:
        sigma = dyads.index.max() / 2
    plt.figure()
    plt.title(sample)
    plt.xlabel('Position relative to dyad (bp)')
    plt.ylabel('Relative Frequency')
    plt.xlim(x[0], x[len(x) - 1])
    plt.xticks(list(range(x[0], x[len(x) - 1] + 1, 25)))
    plt.plot(dyads.index.values,
             dyads['Relative Frequency'].values,
             color='red')
    plot_output = sample + '-dyad-gaussian.png'
    try:
        constant = ConstantModel(prefix='c_')
        pars = constant.make_params()
        pars['c_c'].set(value=dyads['Relative Frequency'].min(),
                        min=0.0,
                        max=dyads['Relative Frequency'].max())
        gauss = GaussianModel(prefix='g_')
        pars.update(gauss.make_params())
        pars['g_center'].set(value=center, min=cmin, max=cmax)
        pars['g_sigma'].set(value=sigma, min=smin)
        pars['g_amplitude'].set(value=amp, min=amin)
        mod = constant + gauss
        init = mod.eval(pars, x=x)
        out = mod.fit(y, pars, x=x)
        if components:
            plt.plot(x, init, 'b--', label='Initial fit')
        if verbose:
            print(out.fit_report(min_correl=0.5))
        plt.plot(x, out.best_fit, 'b-', label='Best fit')
        if components:
            comps = out.eval_components(x=x)
            plt.plot(x,
                     np.repeat(comps['c_'], len(x)),
                     'g--',
                     label='Constant component')
            plt.plot(x, comps['g_'], 'm--', label='Gaussian component')
    except Exception as e:
        logging.warning(
            'could not fit gaussian curve to sample {}'.format(sample), e)
    if components:
        plt.legend(loc='lower right')
    plt.savefig(plot_output)
    if svg:
        plot_svg_output = sample + '-dyad-gaussian.svg'
        plt.savefig(plot_svg_output, transparent=True)
    plt.close()
示例#22
0
def gauss_peak_fit(energy_data, cnts_data, energy_spectrum, channel_width):
    '''
    spectrum_gauss_fit takes an input spectrum and finds the peaks of the
    spectrum and fits a gaussian curve to the photopeaks and returns the
    amplitude and sigma of the gaussian peak.
    Make sure the spectrum is calibrated first.

    sigma_list, amplitude_list = spectrum_gauss_fit(energy_data, cnts_data, energy_spectrum, channel_width)

    energy_data: .energies_kev that has been calibrated from becquerel
    cnts_data: .cps_vals from becquerel spectrum
    energy_spectrum: an array of gamma energies generated from gamma_energies
    channel_width: width of the peak for analysis purposes
    '''
    sigma_list = []
    amplitude_list = []
    for erg in energy_spectrum:
        x_loc = list(
            filter(lambda x: (erg - 3) < energy_data[x] < (erg + 3),
                   range(len(energy_data))))
        x_loc_pk = range(int(x_loc[0] - 5), int(x_loc[0] + 5))
        pk_cnt = np.argmax(cnts_data[x_loc_pk])
        ch_width = range(int(x_loc_pk[pk_cnt] - channel_width),
                         int(x_loc_pk[pk_cnt] + channel_width))

        calibration = energy_data[ch_width]
        real_y_gauss = cnts_data[ch_width]
        x = np.asarray(calibration)
        real_y = np.asarray(real_y_gauss)

        mod_gauss = GaussianModel(prefix='g1_')
        line_mod = LinearModel(prefix='line')
        pars = mod_gauss.guess(real_y, x=x)
        pars.update(line_mod.make_params(intercept=real_y.min(), slope=0))
        pars.update(mod_gauss.make_params())
        pars['g1_center'].set(x[np.argmax(real_y)], min=x[np.argmax(real_y)]\
        - 3)
        pars['g1_sigma'].set(3, min=0.25)
        pars['g1_amplitude'].set(max(real_y), min=max(real_y) - 10)
        mod = mod_gauss + line_mod
        out = mod.fit(real_y, pars, x=x)

        #print("The amplitude sum is %0.2f" % sum(real_y))
        gauss_x = []
        gauss_y = []
        parameter_list_1 = []
        real_y_gauss = []
        #print(out.fit_report(min_correl=10))
        sigma = out.params['g1_sigma'].value
        amplitude = out.params['g1_amplitude'].value
        sigma_list.append(sigma)
        amplitude_list.append(amplitude)
        fit_params = {}

        #gauss_fit_parameters = [out.params[key].value for k in out.params]
        #print(key, "=", out.params[key].value, "+/-", out.params[key].stderr)
        gauss_fit_parameters = []

    return sigma_list, amplitude_list
示例#23
0
def call_gauss(x, y, cen, count, pars):
	label='g'+str(count)+'_'
	gauss = GaussianModel(prefix=label)
	pars.update(gauss.make_params())
	pars[label+'center'].set(cen, min=cen-0.01, max=cen+0.01)
	pars[label+'amplitude'].set(-0.5, min=-10., max=0.0001)
	pars[label+'sigma'].set(0.1, min=0.005, max=0.25)
	return gauss
def fit_s21mag(x_val, y_val):
    peak = GaussianModel()
    offset = ConstantModel()
    model = peak + offset
    pars = offset.make_params(c=np.median(y_val))
    pars += peak.guess(y_val, x=x_val, amplitude=-0.5)
    result = model.fit(y_val, pars, x=x_val)
    return result
示例#25
0
def call_gauss(x, y, cen, count, pars):
	label='g'+str(count)+'_'
	gauss = GaussianModel(prefix=label)
	pars.update(gauss.make_params())
	pars[label+'center'].set(cen, min=cen-0.01, max=cen+0.01)
	pars[label+'amplitude'].set(0, min=-(max(y)-min(y))*1.5, max=0.0001)
	pars[label+'sigma'].set(fw_set/4, min=0.005, max=fw_set/2.3548)
	return gauss
def get_plume_gaussian_model(dat, img_width):
    '''returns a single gaussian fit for the pd series provided
    dat = horizontal row of plume time average df'''
    mod = GaussianModel()
    pars = mod.guess(dat, x=img_width)  # guesses starting value for gaussian
    out = mod.fit(dat, pars, x=img_width)  # finds best fit of gaussian

    return out
示例#27
0
文件: analysis.py 项目: sdss/astra
def label_diff_lmfit(label1,
                     label2,
                     bins='auto',
                     bin_std=3,
                     plot=False,
                     emcee=True):
    label1 = np.array(label1)
    label2 = np.array(label2)
    assert label1.shape == label2.shape

    n_obs, n_dim = label1.shape
    amp = np.zeros((n_dim, ), dtype=float)
    bias = np.zeros((n_dim, ), dtype=float)
    scatter = np.zeros((n_dim, ), dtype=float)
    frs = np.zeros((n_dim, ), dtype=object)

    for i_dim in range(n_dim):
        data = label2[:, i_dim] - label1[:, i_dim]
        theta, frs[i_dim] = \
            gfit_bin_lmfit(data, bins=bins, bin_std=bin_std, plot=False)
        amp[i_dim], bias[i_dim], scatter[i_dim] = theta
    params = [fr.params for fr in frs]

    if emcee:
        frs = Parallel(n_jobs=-1)(
            delayed(run_mcmc)(fr, steps=1000, nwalkers=50, burn=300, workers=1)
            for fr in frs)
        for i_dim in range(n_dim):
            bias[i_dim] = np.median(frs[i_dim].mcmc.flatchain["center"])
            scatter[i_dim] = np.median(frs[i_dim].mcmc.flatchain["sigma"])
        params = [fr.mcmc.params for fr in frs]

    histdata = []
    if plot:
        gm = GaussianModel()
        fig = plt.figure(figsize=(3 * n_dim, 4))
        for i_dim in range(n_dim):
            ax = fig.add_subplot(1, n_dim, i_dim + 1)
            data = label2[:, i_dim] - label1[:, i_dim]

            # binned statistics
            if bins == 'robust':
                bins = np.arange(np.min(data), np.max(data),
                                 np.std(data) / bin_std)
            hist, bin_edges = np.histogram(data, bins=bins)
            histdata.append((hist, bin_edges, data))
            # bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
            # bin_xx = np.linspace(bin_edges[0], bin_edges[-1], 100)
            ax.hist(data, bins=bin_edges, histtype='step')
            ax.plot(bin_edges, gm.eval(params[i_dim], x=bin_edges))
            ax.set_title("{:5f}+-{:5f}".format(bias[i_dim], scatter[i_dim]))
    else:
        for i_dim in range(n_dim):
            data = label2[:, i_dim] - label1[:, i_dim]
            hist, bin_edges = np.histogram(data, bins=bins)
            histdata.append((hist, bin_edges, data))

    return bias, scatter, frs, histdata
示例#28
0
def fitSimpleHist(array,
                  title='E5XX',
                  nbins=25,
                  xlabel='mytit',
                  verbose=False,
                  savedir=None,
                  fileappendix='',
                  ax=None):
    """ Simple Gaussian fit to an array of datapoints. Output can be saved to file if wanted 
    Input Argument:
        array        -- np.array of input points
        title        -- title of graph. Will also be the filename
        nbins        -- number of histogram bins
        xlabel       -- label on x-axis
        verbose      -- T/F print the fit report
        savedir      -- Directory to save output to, if not specified nothing will be saved. Suggest os.getcwd() or '.'
        fileappendix -- will add "_fileappendix" to the filename specified by title.
    """
    gausfit = GaussianModel()
    if (ax == None):
        fig, ax = plt.subplots(figsize=(15, 3), nrows=1, ncols=1)
    redarray = array[array >= (array.mean() - 5 * array.std()
                               )]  # and array<= (array.mean()+ 5*array.std())]
    n, bins, patches = ax.hist(
        redarray[redarray <= array.mean() + 5 * array.std()], nbins)
    cbins = np.zeros(len(bins) - 1)
    for k in (range(0, len(bins) - 1)):
        cbins[k] = (bins[k] + bins[k + 1]) / 2
    pars = gausfit.guess(n, x=cbins)
    fitresult = gausfit.fit(n, pars, x=cbins)
    if (verbose):
        print(fitresult.fit_report())
    ax.plot(cbins, fitresult.best_fit, 'r-', linewidth=2)
    mean = fitresult.best_values['center']
    fwhm = 2.35 * fitresult.best_values['sigma']
    textstring = ' Mean : ' + '{:4.3f}'.format(mean) + '\n'
    textstring += ' FWHM : ' + '{:4.3f}'.format(fwhm)
    props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
    ax.text(0.05,
            0.95,
            textstring,
            transform=ax.transAxes,
            fontsize=14,
            verticalalignment='top',
            bbox=props)
    ax.set_xlabel(xlabel)
    ax.set_ylabel('Frequency')
    ax.set_title(title)
    if savedir != None:
        filename = os.path.join(savedir, title)
        if (fileappendix != ''):
            filename += '_' + fileappendix
        filename += '.png'
        plt.savefig(filename, dpi=200, bbox_inches='tight')

#   plt.show()
#   return
    return fitresult
 def fit_gaussian(self, array_x, array_y, figure_number):
     mod = GaussianModel()
     pars = mod.guess(array_y, x=array_x)
     out = mod.fit(array_y, pars, x=array_x)
     self.sigma_temp = out.params['sigma'].value
     self.amplitude_temp = out.params['amplitude'].value
     self.center_temp = out.params['center'].value
     self.plot_fit_function(array_x, figure_number)
     return self.sigma_temp, self.amplitude_temp, self.center_temp
示例#30
0
def test_guess_requires_x():
    """Regression test for GH #747."""
    x = np.arange(100)
    y = np.exp(-(x - 50)**2 / (2 * 10**2))

    mod = GaussianModel()
    msg = r"guess\(\) missing 1 required positional argument: 'x'"
    with pytest.raises(TypeError, match=msg):
        mod.guess(y)
示例#31
0
def xrf_calib_init_roi(mca, roiname):
    """initial calibration step for MCA:
    find energy locations for one ROI
    """
    if not isLarchMCAGroup(mca):
        print('Not a valid MCA')
        return
    energy = 1.0 * mca.energy
    chans = 1.0 * np.arange(len(energy))
    counts = mca.counts
    bgr = getattr(mca, 'bgr', None)
    if bgr is not None:
        counts = counts - bgr
    if not hasattr(mca, 'init_calib'):
        mca.init_calib = OrderedDict()

    roi = None
    for xroi in mca.rois:
        if xroi.name == roiname:
            roi = xroi
            break
    if roi is None:
        return
    words = roiname.split()
    elem = words[0].title()
    family = 'Ka'
    if len(words) > 1:
        family = words[1].title()
    if family == 'Lb':
        family = 'Lb1'
    try:
        eknown = xray_line(elem, family).energy / 1000.0
    except:
        eknown = 0.001
    llim = max(0, roi.left - roi.bgr_width)
    hlim = min(len(chans) - 1, roi.right + roi.bgr_width)
    segcounts = counts[llim:hlim]
    maxcounts = max(segcounts)
    ccen = llim + np.where(segcounts == maxcounts)[0][0]
    ecen = ccen * mca.slope + mca.offset
    bkgcounts = counts[llim] + counts[hlim]
    if maxcounts < 2 * bkgcounts:
        mca.init_calib[roiname] = (eknown, ecen, 0.0, ccen, None)
    else:
        model = GaussianModel() + ConstantModel()
        params = model.make_params(amplitude=maxcounts,
                                   sigma=(chans[hlim] - chans[llim]) / 2.0,
                                   center=ccen - llim,
                                   c=0.00)
        params['center'].min = -10
        params['center'].max = hlim - llim + 10
        params['c'].min = -10
        out = model.fit(counts[llim:hlim], params, x=chans[llim:hlim])
        ccen = llim + out.params['center'].value
        ecen = ccen * mca.slope + mca.offset
        fwhm = out.params['fwhm'].value * mca.slope
        mca.init_calib[roiname] = (eknown, ecen, fwhm, ccen, out)
示例#32
0
def test_report_modelpars(fitresult):
    """Verify that model_values are shown when modelpars are given."""
    model = GaussianModel()
    params = model.make_params(amplitude=35, center=7, sigma=0.9)
    report_split = fitresult.fit_report(modelpars=params).split('\n')
    indices = [i for i, val in enumerate(report_split) if
               ('sigma:' in val or 'center:' in val or 'amplitude:' in val)]
    for indx in indices:
        assert 'model_value' in report_split[indx]
 def gaussian_model_w_lims(self, peak_pos, sigma, min_max_range):
     x, y = self.background_correction()
     gmodel = GaussianModel(prefix='g1_')  # calling gaussian model
     pars = gmodel.guess(y, x=x)  # parameters - center, width, height
     pars['g1_center'].set(peak_pos,
                           min=min_max_range[0],
                           max=min_max_range[1])
     pars['g1_sigma'].set(sigma)
     result = gmodel.fit(y, pars, x=x, nan_policy='propagate')
     return result  #770 760 780   sigma 15
示例#34
0
 def fit_gaussian(self):
     mod = GaussianModel()
     pars = mod.guess(self.result[:, 1], x=self.result[:, 0])
     out = mod.fit(self.result[:, 1], pars, x=self.result[:, 0])
     self.sigma = out.params['sigma'].value
     self.amp = out.params['amplitude'].value
     self.center = out.params['center'].value
     print('sigma:' + str(self.sigma), 'amp:' + str(self.amp), 'center' + str(self.center))
     self.plot_fit_function(1)
     return self.sigma, self.amp, self.center
示例#35
0
    def gauss_shoulder(self, fitv, par_g: list, bounds_g: list, Ng: int = 1):
        gauss2 = GaussianModel(prefix='g' + str(Ng) + '_')
        pars = fitv.params
        pars.update(gauss2.make_params())

        for k, p, b in zip(gauss2.param_names, par_g, bounds_g):
            pars[k].set(value=p, min=b[0], max=b[1])
        mod = fitv.model + gauss2

        return self.finish_fit(self, mod, pars)
示例#36
0
文件: models.py 项目: rhroberts/kfit
def gauss_mod(N):
    '''
        Returns a model consisting of N gaussian curves
    '''
    # initialize model
    model = GaussianModel(prefix='gau1_')
    # Add N-1 gaussians
    for i in range(N - 1):
        model += GaussianModel(prefix='gau' + str(i + 2) + '_')
    return model
示例#37
0
def SPErough(data, n_channel_s):
    fit_input, bins, check = SPE_input(data)
    amplitude  = get_amp(data)
    gauss = GaussianModel(prefix='g_')
    s, bins = np.histogram(amplitude,  bins=bins)
    topnoise  = fit_input[0]
    valley    = fit_input[1]
    endvalley = fit_input[2]
    spebump   = fit_input[3]
    endbin    = fit_input[4]
    idx_1 = endvalley
    idx_2 = spebump + (spebump-endvalley)
    if idx_1 < endvalley:
        idx_1 = endvalley
    if idx_2 > endbin:
        idx_2 = endbin 
    if check == 1:      
        gauss.set_param_hint('g_height', value=s[spebump], min=s[spebump]-30, max=s[spebump]+30)
        gauss.set_param_hint('g_center', value=bins[spebump], min=bins[spebump]-30, max=bins[spebump]+30)
        gauss.set_param_hint('g_sigma', value=idx_2-idx_1, max=(idx_2-idx_1)+30)
        
        result = gauss.fit(s[idx_1:idx_2], x=bins[idx_1:idx_2], weights=1.0/np.sqrt(s[idx_1:idx_2]))
    else:
        gauss  = 0
        result = 0

    return gauss, result
def gaussian_fit(x, y, title_name):
	mod = GaussianModel()
	pars = mod.guess(y, x=x)
	out = mod.fit(y, pars, x=x)
	plt.figure()
	plt.plot(x, y)
	plt.plot(x, out.best_fit, 'r-')
	plt.title(title_name)
	print(out.fit_report(min_correl = 0.25))
	print('Center at ' + str(out.best_values['center']) + ' Angstrom')
	plt.show()
def get_gaussianmodel(amplitude=1.0, center=5.0, sigma=1.0, noise=0.1):
    # create data to be fitted
    np.random.seed(7392)
    x = np.linspace(-20, 20, 201)
    y = gaussian(x, amplitude, center=center, sigma=sigma)
    y = y + np.random.normal(size=len(x), scale=noise)

    model = GaussianModel()
    params = model.make_params(amplitude=amplitude/5.0,
                               center=center-1.0,
                               sigma=sigma*2.0)
    return x, y, model, params
示例#40
0
def xrf_calib_init_roi(mca, roiname):
    """initial calibration step for MCA:
    find energy locations for one ROI
    """
    if not isLarchMCAGroup(mca):
        print( 'Not a valid MCA')
        return
    energy = 1.0*mca.energy
    chans = 1.0*np.arange(len(energy))
    counts = mca.counts
    bgr = getattr(mca, 'bgr', None)
    if bgr is not None:
        counts = counts - bgr
    if not hasattr(mca, 'init_calib'):
        mca.init_calib = OrderedDict()

    roi = None
    for xroi in mca.rois:
        if xroi.name == roiname:
            roi = xroi
            break
    if roi is None:
        return
    words = roiname.split()
    elem = words[0].title()
    family = 'Ka'
    if len(words) > 1:
        family = words[1].title()
    if family == 'Lb':
        family = 'Lb1'
    eknown = xray_line(elem, family)[0]/1000.0
    llim = max(0, roi.left - roi.bgr_width)
    hlim = min(len(chans)-1, roi.right + roi.bgr_width)
    segcounts = counts[llim:hlim]
    maxcounts = max(segcounts)
    ccen = llim + np.where(segcounts==maxcounts)[0]
    ecen = ccen * mca.slope + mca.offset
    bkgcounts = counts[llim] + counts[hlim]
    if maxcounts < 2*bkgcounts:
        mca.init_calib[roiname] = (eknown, ecen, 0.0, ccen, None)
    else:
        model = GaussianModel() + ConstantModel()
        params = model.make_params(amplitude=maxcounts,
                                   sigma=(chans[hlim]-chans[llim])/2.0,
                                   center=ccen-llim, c=0.00)
        params['center'].min = -10
        params['center'].max = hlim - llim + 10
        params['c'].min = -10
        out = model.fit(counts[llim:hlim], params, x=chans[llim:hlim])
        ccen = llim + out.params['center'].value
        ecen = ccen * mca.slope + mca.offset
        fwhm = out.params['fwhm'].value * mca.slope
        mca.init_calib[roiname] = (eknown, ecen, fwhm, ccen, out)
def gaussian_fit(x, y, title_name):
	mod = GaussianModel()
	pars = mod.guess(y, x=x)
	#pars = mod.make_params(amplitude = -2000, sigma = 1, center = 6562.801)
	out = mod.fit(y, pars, x=x)
	plt.figure()
	plt.plot(x, y)
	plt.plot(x, out.best_fit, 'r-')
	plt.title(title_name)
	print(out.fit_report(min_correl = 0.25))
	print('Center at ' + str(out.best_values['center']) + ' Angstrom')
	plt.show()
示例#42
0
def fluxError(counts, wavelength, error, continuum):
	flux_vector = []
	E_W_vector = []
	cont_avg = np.mean(continuum)
	#plt.close('all')

	for i in range(100):
		#plt.errorbar(wavelength, counts, yerr=error)
		new_counts=[]
		j = 0
		for point in counts:
			new_counts.append(np.random.normal(point, error[j]))
			j = j + 1
		new_counts = np.array(new_counts)
		#So for each N in 1000 a new counts vector is generated randomly
		#Take this data against the wavelength values and fit a gaussian 
		#each time to compute the flux. Append this to a vector and then 
		#find the standard deviation to get the flux error for that emission line
		#Note this is to be encorporated in the fitLines module so that each of the emission 
		#lines is fit in turn. Next step here is to construct the model with lmfit, 
		#guess the initial parameters and then fit the gaussian and take 
		#out.best_values('amplitude') as the flux and store in flux_vector	

		#Now use the lmfit package to perform gaussian fits to the data	
		#Construct the gaussian model
		mod = GaussianModel()

	#Take an initial guess at what the model parameters are 
	#In this case the gaussian model has three parameters, 
	#Which are amplitude, center and sigma
		pars = mod.guess(new_counts, x=wavelength)

	#We know from the redshift what the center of the gaussian is, set this
	#And choose the option not to vary this parameter 
	#Leave the guessed values of the other parameters
		pars['center'].set(value = np.mean(wavelength))


	#Now perform the fit to the data using the set and guessed parameters 
	#And the inverse variance weights form the fits file 
		out  = mod.fit(new_counts, pars, x=wavelength)
		flux = out.best_values['amplitude']
		E_W = out.best_values['amplitude'] / cont_avg
		flux_vector.append(flux)
		E_W_vector.append(E_W)
		#plt.scatter(wavelength, new_counts)
		#plt.plot(wavelength, out.best_fit)
		

	print 'Hello', flux_vector
	#Now return the standard deviation of the flux_vector as the flux error 
	return {'flux_error' : np.std(flux_vector), 'E_W_error' : np.std(E_W_vector)}	
def fit_gaussian(y,x):    
    x=array(x)
    y=array(y)
    mod=GaussianModel()
    pars=mod.guess(y,x=x)
    result=mod.fit(y,pars,x=x)
    a=result.params['amplitude'].value
    b=result.params['center'].value
    c=result.params['sigma'].value
    best=result.best_fit
    chsqred=result.redchi
    chisq=result.chisqr
    fwhm=result.params['fwhm'].value
    
    return a,b,c,best,fwhm,chisq,chsqred
示例#44
0
文件: MainWindow.py 项目: RFlehr/AccQ
 def peakFit(self, x, y):
     if len(x) == 0:
         y = self.getdBmSpec()
         y = y[self.__scalePos]
         x = self.__scaledWavelength
     y = np.power(10,y/10)
     mod = GaussianModel()
     pars = mod.guess(y, x=x)
     out  = mod.fit(y, pars, x=x)
     
     print(out.fit_report(min_correl=0.25))
     center = out.best_values['center']
     fwhm = out.best_values['sigma']*2.3548
     
     return center, fwhm#, amp
def lmfit_ngauss_constrains(x,y, params, constrains):
  """
  INPUT:
  x - is the wavelength array
  y - is the normalized flux
  params - is a list/array of initial guess values for the parameters
  		   (this controls the number of gaussians to be fitted
  		   	number of gaussians: len(params)/3 - 3 parameters per Gaussian)
  contrains - the limits of the constrains for the fit of the parameters
  OUTPUT:
  mod - the lmfit model object used for the fit
  out - the lmfit fit object that contains all the results of the fit
  init- array with the initial guess model (usefull to see the initial guess when plotting)
  """

  mods = []
  prefixes = []
  for i in range(0, len(params), 3):
    pref = "g%02i_" % (i/3)
    gauss_i = GaussianModel(prefix=pref)

    if i == 0:
      pars = gauss_i.guess(y, x=x)
    else:
      pars.update(gauss_i.make_params())
    A = params[i]
    limA = constrains[i]
    l_cen = params[i+1]
    limL = constrains[i+1]
    sigma = params[i+2]
    limS = constrains[i+2]

    pars[pref+'amplitude'].set(A, min=limA[0], max=limA[1])
    pars[pref+'center'].set(l_cen, min=limL[0], max=limL[1])
    pars[pref+'sigma'].set(sigma, min=limS[0], max=limS[1])

    mods.append(gauss_i)
    prefixes.append(pref)

  mod = mods[0]

  if len(mods) > 1:
    for m in mods[1:]:
      mod += m
  init = mod.eval(pars, x=x)
  out = mod.fit(y, pars, x=x)

  return mod, out, init
def test_default_inputs_gauss():

    area = 1
    cen = 0
    std = 0.2
    x = np.arange(-3, 3, 0.01)
    y = gaussian(x, area, cen, std)

    g = GaussianModel()

    fit_option1 = {'maxfev': 5000, 'xtol': 1e-2}
    result1 = g.fit(y, x=x, amplitude=1, center=0, sigma=0.5, fit_kws=fit_option1)

    fit_option2 = {'maxfev': 5000, 'xtol': 1e-6}
    result2 = g.fit(y, x=x, amplitude=1, center=0, sigma=0.5, fit_kws=fit_option2)

    assert_true(result1.values!=result2.values)
    return
示例#47
0
def test_itercb():
    x = np.linspace(0, 20, 401)
    y = gaussian(x, amplitude=24.56, center=7.6543, sigma=1.23)
    y = y  - .20*x + 3.333 + np.random.normal(scale=0.23,  size=len(x))
    mod = GaussianModel(prefix='peak_') + LinearModel(prefix='bkg_')

    pars = mod.make_params(peak_amplitude=21.0,
                           peak_center=7.0,
                           peak_sigma=2.0,
                           bkg_intercept=2,
                           bkg_slope=0.0)

    out = mod.fit(y, pars, x=x, iter_cb=per_iteration)

    assert(out.nfev == 23)
    assert(out.aborted)
    assert(not out.errorbars)
    assert(not out.success)
示例#48
0
def create_model_params(x, y):
    """Create the model and parameters."""
    exp_mod = ExponentialModel(prefix='exp_')
    params = exp_mod.guess(y, x=x)

    gauss1 = GaussianModel(prefix='g1_')
    params.update(gauss1.make_params())

    gauss2 = GaussianModel(prefix='g2_')
    params.update(gauss2.make_params())

    params['g1_center'].set(value=105, min=75, max=125)
    params['g1_sigma'].set(value=15, min=3)
    params['g1_amplitude'].set(value=2000, min=10)

    params['g2_center'].set(value=155, min=125, max=175)
    params['g2_sigma'].set(value=15, min=3)
    params['g2_amplitude'].set(value=2000, min=10)

    model = gauss1 + gauss2 + exp_mod
    return model, params
def fitTwoGaussians(x,y):
	background  = PolynomialModel(2)
	pars = background.make_params()
	peak1 = GaussianModel(prefix='p1_')
	pars.update( peak1.make_params())
	peak2 = GaussianModel(prefix='p2_')
	pars.update( peak2.make_params())
	# Guess some parameters from data to help the fitting
	span = max(x)-min(x)
	c1Guess = (y[-1]-y[0])/(x[-1]-x[0])
	c0Guess = y[0]-c1Guess*x[0]
	bgGuess = background.func(x=x,c0=c0Guess,c1=c1Guess,c2=0.)
	signalGuess=min(y-bgGuess)
	sigmaGuess = span/30.
	amplitudeGuess = signalGuess*(sigmaGuess*np.sqrt(2.0*np.pi))
	# Fit variables initialization
	
	# pars.add('splitting',0.0001,max=span)
	
	pars['c2'].set(0.,min=-0.000001,max=0.001)
	pars['c1'].set(c1Guess)
	pars['c0'].set(c0Guess)
	pars['p1_center'].set(min(x)+span*0.35,min=min(x),max=max(x))
	pars['p2_center'].set(min(x)+span*0.55,min=min(x),max=max(x))
	# pars['p2_center'].set(min(x)+span*0.65,expr='p1_center+splitting')
	pars['p1_amplitude'].set(amplitudeGuess,max=amplitudeGuess/10000.)
	pars['p2_amplitude'].set(amplitudeGuess,max=amplitudeGuess/10000.)
	pars['p1_sigma'].set(sigmaGuess, min=sigmaGuess/100.,max=sigmaGuess*10000.)
	pars['p2_sigma'].set(sigmaGuess, min=sigmaGuess/100.,max=sigmaGuess*10000.)
	#Add some useful parameters to evaluate
	pars.add('p1_signal', expr='p1_amplitude/(p1_sigma*sqrt(2.0*pi))')
	pars.add('p2_signal', expr='p2_amplitude/(p2_sigma*sqrt(2.0*pi))')
	pars.add('p1_contrast', expr='-p1_amplitude/(p1_sigma*sqrt(2.0*pi)*(c0+c1*p1_center+c2*p1_center**2))')
	pars.add('p2_contrast', expr='-p2_amplitude/(p2_sigma*sqrt(2.0*pi)*(c0+c1*p2_center+c2*p2_center**2))')
	pars.add('splitting',pars['p2_center']-pars['p1_center'],expr='p2_center-p1_center',min=0.00001)
	model = peak1 + peak2 + background
	init = model.eval(pars, x=x)
	out = model.fit(y, pars, x=x)
	# print out.fit_report()
	return init,out
示例#50
0
def gaussian_fit(x, y, bounds=None):
    """Fit a gaussian background to `field` in `scan`

    Parameters
    ----------
    x : array
        independent variable
    y : array
        dependent variable
    bounds : iterable
        The +/- range to fit the data to

    Returns
    -------
    fit : lmfit.model.ModelFit
        The results of fitting the data to a gaussian peak

    Examples
    --------
    >>> fit = fit_gaussian(scan.scan_data)
    >>> fit.plot()
    """
    gaussian = GaussianModel()
    center = x[np.argmax(y)]
    if bounds is None:
        lower, upper = 0, len(x)
    else:
        lower = center - bounds
        upper = center + bounds
        if lower < 0:
            lower = 0
        if upper > len(x):
            upper = len(x)
    bounds = slice(lower, upper)
    y = y[bounds]
    x = x[bounds]
    gaussian_params = gaussian.guess(y, x=x, center=center)
    model = gaussian
    return model.fit(y, x=x, params=gaussian_params)
def GaussConst(signal, guess):
    """
    Fits a Gaussian function
    Plots fwhm and 2*sigma gap widths for comparison
    with the analytically calculated one
    """
    amp, centre, stdev, offset = guess
    
    data = np.array([range(len(signal)), signal]).T
    X = data[:,0]
    Y = data[:,1]

    gauss_mod = GaussianModel(prefix='gauss_')
    const_mod = ConstantModel(prefix='const_')
    
    pars = gauss_mod.make_params(center=centre, sigma=stdev, amplitude=amp)
    pars += const_mod.guess(Y, x=X)
    pars['gauss_center'].min = centre - 5.
    pars['gauss_center'].max = centre + 5.
    pars['gauss_sigma'].max = stdev + 5.
    
    mod = gauss_mod + const_mod
    result = mod.fit(Y, pars, x=X)
    
    fwhm = result.best_values['gauss_sigma'] #* 2.3548
    centr = result.best_values['gauss_center']
    
    # Values within two stdevs i.e. 95%
    pl.plot(np.repeat(centr - fwhm * 2, len(Y)),
            np.arange(len(Y)), 'b-')
    pl.plot(np.repeat(centr + fwhm * 2, len(Y)),
            np.arange(len(Y)), 'b-', label="Sigma * 2")
    
    pl.plot(np.repeat(centr - fwhm * 2.3548 / 2., len(Y)),
            np.arange(len(Y)), 'y--')
    pl.plot(np.repeat(centr + fwhm * 2.3548 / 2., len(Y)),
            np.arange(len(Y)), 'y--', label="FWHM")
    
    return X, result.best_fit, result.best_values['gauss_sigma'] * 4, centr
示例#52
0
def measure_line_index_recover_spectrum(wave, params, norm=False):
    """ recover the fitted line profile from params

    Parameters
    ----------
    wave: array-like
        the wavelength to which the recovered flux correspond

    params: 5-element tuple
        the 1 to 5 elements are:
        mod_linear_slope
        mod_linear_intercept
        mod_gauss_amplitude
        mod_gauss_center
        mod_gauss_sigma

    norm: bool
        if True, linear model (continuum) is deprecated
        else linear + Gaussian model is used

    """
    from lmfit.models import LinearModel, GaussianModel
    mod_linear = LinearModel(prefix='mod_linear_')
    mod_gauss = GaussianModel(prefix='mod_gauss_')
    par_linear = mod_linear.make_params()
    par_gauss = mod_gauss.make_params()
    par_linear['mod_linear_slope'].value = params[0]
    par_linear['mod_linear_intercept'].value = params[1]
    par_gauss['mod_gauss_amplitude'].value = params[2]
    par_gauss['mod_gauss_center'].value = params[3]
    par_gauss['mod_gauss_sigma'].value = params[4]
    if not norm:
        flux = 1 - mod_gauss.eval(params=par_gauss, x=wave)
    else:
        flux = \
            (1 - mod_gauss.eval(params=par_gauss, x=wave)) * \
            mod_linear.eval(params=par_linear, x=wave)
    return flux
示例#53
0
def lmfit_ngauss_constrains(x,y, params, constrains):
  #params = params[0]
  #constrains = constrains[0]
  mods = []
  prefixes = []
  for i in range(0, len(params), 3):
    pref = "g%02i_" % (i/3)
    gauss_i = GaussianModel(prefix=pref)

    if i == 0:
      pars = gauss_i.guess(y, x=x)
    else:
      pars.update(gauss_i.make_params())

    A = params[i]
    limA = constrains[i]
    l_cen = params[i+1]
    limL = constrains[i+1]
    sigma = params[i+2]
    limS = constrains[i+2]

    pars[pref+'amplitude'].set(A, min=limA[0], max=limA[1])
    pars[pref+'center'].set(l_cen, min=limL[0], max=limL[1])
    pars[pref+'sigma'].set(sigma, min=limS[0], max=limS[1])

    mods.append(gauss_i)
    prefixes.append(pref)

  mod = mods[0]

  if len(mods) > 1:
    for m in mods[1:]:
      mod += m

  init = mod.eval(pars, x=x)
  out = mod.fit(y, pars, x=x)
  return mod, out, init
示例#54
0
def test_reports_created():
    """do a simple Model fit but with all the bells-and-whistles
    and verify that the reports are created
    """
    x = np.linspace(0, 12, 601)
    data = gaussian(x, amplitude=36.4, center=6.70, sigma=0.88)
    data = data + np.random.normal(size=len(x), scale=3.2)
    model = GaussianModel()
    params = model.make_params(amplitude=50, center=5, sigma=2)

    params['amplitude'].min = 0
    params['sigma'].min = 0
    params['sigma'].brute_step = 0.001

    result = model.fit(data, params, x=x)

    report = result.fit_report()
    assert(len(report) > 500)

    html_params = result.params._repr_html_()
    assert(len(html_params) > 500)

    html_report = result._repr_html_()
    assert(len(html_report) > 1000)
def test_example_2_Gaussians_1_exp():
  dat = np.loadtxt('NIST_Gauss2.dat')
  x = dat[:, 1]
  y = dat[:, 0]

  exp_mod = ExponentialModel(prefix='exp_')
  pars = exp_mod.guess(y, x=x)

  gauss1  = GaussianModel(prefix='g1_')
  pars.update(gauss1.make_params())

  pars['g1_center'].set(105, min=75, max=125)
  pars['g1_sigma'].set(15, min=3)
  pars['g1_amplitude'].set(2000, min=10)

  gauss2  = GaussianModel(prefix='g2_')

  pars.update(gauss2.make_params())

  pars['g2_center'].set(155, min=125, max=175)
  pars['g2_sigma'].set(15, min=3)
  pars['g2_amplitude'].set(2000, min=10)

  mod = gauss1 + gauss2 + exp_mod


  init = mod.eval(pars, x=x)
  plt.plot(x, y)
  plt.plot(x, init, 'k--')

  out = mod.fit(y, pars, x=x)

  print(out.fit_report(min_correl=0.5))

  plt.plot(x, out.best_fit, 'r-')
  plt.show()
#!/usr/bin/env python

# <examples/doc_builtinmodels_nistgauss.py>
import matplotlib.pyplot as plt
import numpy as np

from lmfit.models import ExponentialModel, GaussianModel

dat = np.loadtxt('NIST_Gauss2.dat')
x = dat[:, 1]
y = dat[:, 0]

exp_mod = ExponentialModel(prefix='exp_')
pars = exp_mod.guess(y, x=x)

gauss1 = GaussianModel(prefix='g1_')
pars.update(gauss1.make_params())

pars['g1_center'].set(105, min=75, max=125)
pars['g1_sigma'].set(15, min=3)
pars['g1_amplitude'].set(2000, min=10)

gauss2 = GaussianModel(prefix='g2_')

pars.update(gauss2.make_params())

pars['g2_center'].set(155, min=125, max=175)
pars['g2_sigma'].set(15, min=3)
pars['g2_amplitude'].set(2000, min=10)

mod = gauss1 + gauss2 + exp_mod
示例#57
0
def measure_line_index(wave,
                       flux,
                       flux_err=None,
                       mask=None,
                       z=None,
                       line_info=None,
                       num_refit=(100, None),
                       filepath=None,
                       return_type='dict',
                       verbose=False):
    """ Measure line index / EW and have it plotted

    Parameters
    ----------
    wave: array-like
        wavelength vector

    flux: array-like
        flux vector

    flux_err: array-like
        flux error vector (optional)
        If un-specified, auto-generate an np.ones array

    mask: array-like
        andmask or ormask (optional)
        If un-specified, auto-generate an np.ones array (evenly weighted)

    line_info: dict
        information about spectral line, eg:
        line_info_dib5780 = {'line_center':         5780,
                             'line_range':          (5775, 5785),
                             'line_shoulder_left':  (5755, 5775),
                             'line_shoulder_right': (5805, 5825)}

    num_refit: non-negative integer
        number of refitting.
        If 0, no refit will be performed
        If positive, refits will be performed after adding normal random noise

    z: float
        redshift (only specify when z is large)

    filepath: string
        path of the diagnostic figure
        if None, do nothing, else print diagnostic figure

    return_type: string
        'dict' or 'array'
        if 'array', np.array(return dict.values())

    verbose: bool
        if True, print details

    Returns
    -------
    line_indx: dict
        A dictionary type result of line index.
        If any problem encountered, return the default result (filled with nan).

    """
    try:
        # 0. do some input check
        # 0.1> check line_info
        line_info_keys = line_info.keys()
        assert 'line_range' in line_info_keys
        assert 'line_shoulder_left' in line_info_keys
        assert 'line_shoulder_right' in line_info_keys
        # 0.2> check line range/shoulder in spectral range
        assert np.min(wave) <= line_info['line_shoulder_left'][0]
        assert np.max(wave) >= line_info['line_shoulder_right'][0]

        # 1. get line information
        # line_center = line_info['line_center']  # not used
        line_range = line_info['line_range']
        line_shoulder_left = line_info['line_shoulder_left']
        line_shoulder_right = line_info['line_shoulder_right']

        # 2. shift spectra to rest-frame
        wave = np.array(wave)
        flux = np.array(flux)
        if z is not None:
            wave /= 1. + z

        # 3. estimate the local continuum
        # 3.1> shoulder wavelength range
        ind_shoulder = np.any([
            np.all([wave > line_shoulder_left[0],
                    wave < line_shoulder_left[1]], axis=0),
            np.all([wave > line_shoulder_right[0],
                    wave < line_shoulder_right[1]], axis=0)], axis=0)
        wave_shoulder = wave[ind_shoulder]
        flux_shoulder = flux[ind_shoulder]

        # 3.2> integrated/fitted wavelength range
        ind_range = np.logical_and(wave > line_range[0], wave < line_range[1])
        wave_range = wave[ind_range]
        flux_range = flux[ind_range]
        # flux_err_range = flux_err[ind_range]  # not used
        mask_range = mask[ind_range]
        flux_err_shoulder = flux_err[ind_shoulder]
        # mask_shoulder = mask[ind_shoulder]    # not used

        # 4. linear model
        mod_linear = LinearModel(prefix='mod_linear_')
        par_linear = mod_linear.guess(flux_shoulder, x=wave_shoulder)
        # ############################################# #
        # to see the parameter names:                   #
        # model_linear.param_names                      #
        # {'linear_fun_intercept', 'linear_fun_slope'}  #
        # ############################################# #
        out_linear = mod_linear.fit(flux_shoulder,
                                    par_linear,
                                    x=wave_shoulder,
                                    method='leastsq')

        # 5. estimate continuum
        cont_shoulder = out_linear.best_fit
        noise_std = np.std(flux_shoulder / cont_shoulder)
        cont_range = mod_linear.eval(out_linear.params, x=wave_range)
        resi_range = 1 - flux_range / cont_range

        # 6.1 Integrated EW (
        # estimate EW_int
        wave_diff = np.diff(wave_range)
        wave_step = np.mean(np.vstack([np.hstack([wave_diff[0], wave_diff]),
                                       np.hstack([wave_diff, wave_diff[-1]])]),
                            axis=0)
        EW_int = np.dot(resi_range, wave_step)

        # estimate EW_int_err
        num_refit_ = num_refit[0]
        if num_refit_ is not None and num_refit_>0:
            EW_int_err = np.std(np.dot(
                (resi_range.reshape(1, -1).repeat(num_refit_, axis=0) +
                 np.random.randn(num_refit_, resi_range.size) * noise_std),
                wave_step))

        # 6.2 Gaussian model
        # estimate EW_fit
        mod_gauss = GaussianModel(prefix='mod_gauss_')
        par_gauss = mod_gauss.guess(resi_range, x=wave_range)
        out_gauss = mod_gauss.fit(resi_range, par_gauss, x=wave_range)
        line_indx = collections.OrderedDict([
            ('SN_local_flux_err',        np.median(flux_shoulder / flux_err_shoulder)),
            ('SN_local_flux_std',        1. / noise_std),
            ('num_bad_pixel',            np.sum(mask_range != 0)),
            ('EW_int',                   EW_int),
            ('EW_int_err',               EW_int_err),
            ('mod_linear_slope',         out_linear.params[mod_linear.prefix + 'slope'].value),
            ('mod_linear_slope_err',     out_linear.params[mod_linear.prefix + 'slope'].stderr),
            ('mod_linear_intercept',     out_linear.params[mod_linear.prefix + 'intercept'].value),
            ('mod_linear_intercept_err', out_linear.params[mod_linear.prefix + 'intercept'].stderr),
            ('mod_gauss_amplitude',      out_gauss.params[mod_gauss.prefix + 'amplitude'].value),
            ('mod_gauss_amplitude_err',  out_gauss.params[mod_gauss.prefix + 'amplitude'].stderr),
            ('mod_gauss_center',         out_gauss.params[mod_gauss.prefix + 'center'].value),
            ('mod_gauss_center_err',     out_gauss.params[mod_gauss.prefix + 'center'].stderr),
            ('mod_gauss_sigma',          out_gauss.params[mod_gauss.prefix + 'sigma'].value),
            ('mod_gauss_sigma_err',      out_gauss.params[mod_gauss.prefix + 'sigma'].stderr),
            ('mod_gauss_amplitude_std',  np.nan),
            ('mod_gauss_center_std',     np.nan),
            ('mod_gauss_sigma_std',      np.nan)])

        # estimate EW_fit_err
        num_refit_ = num_refit[1]
        if num_refit_ is not None and num_refit_ > 2:
            # {'mod_gauss_amplitude',
            #  'mod_gauss_center',
            #  'mod_gauss_fwhm',
            #  'mod_gauss_sigma'}
            out_gauss_refit_amplitude = np.zeros(num_refit_)
            out_gauss_refit_center = np.zeros(num_refit_)
            out_gauss_refit_sigma = np.zeros(num_refit_)
            # noise_fit = np.random.randn(num_refit,resi_range.size)*noise_std
            for i in range(int(num_refit_)):
                # resi_range_with_noise = resi_range + noise_fit[i,:]
                resi_range_with_noise = resi_range + \
                                        np.random.randn(resi_range.size) * noise_std
                out_gauss_refit = mod_gauss.fit(resi_range_with_noise,
                                                par_gauss,
                                                x=wave_range)
                out_gauss_refit_amplitude[i],\
                out_gauss_refit_center[i],\
                out_gauss_refit_sigma[i] =\
                    out_gauss_refit.params[mod_gauss.prefix + 'amplitude'].value,\
                    out_gauss_refit.params[mod_gauss.prefix + 'center'].value,\
                    out_gauss_refit.params[mod_gauss.prefix + 'sigma'].value
                print(out_gauss_refit_amplitude[i], out_gauss_refit_center[i], out_gauss_refit_sigma[i])
            line_indx.update({'mod_gauss_amplitude_std': np.nanstd(out_gauss_refit_amplitude),
                              'mod_gauss_center_std':    np.nanstd(out_gauss_refit_center),
                              'mod_gauss_sigma_std':     np.nanstd(out_gauss_refit_sigma)})

        # 7. plot and save image
        if filepath is not None and os.path.exists(os.path.dirname(filepath)):
            save_image_line_indice(filepath, wave, flux, ind_range, cont_range,
                                   ind_shoulder, line_info)

        # if necessary, convert to array
        # NOTE: for a non-ordered dict the order of keys and values may change!
        if return_type == 'array':
            return np.array(line_indx.values())
        return line_indx
    except Exception:
        return measure_line_index_null_result(return_type)
示例#58
0
    # ax_res_y2.set_yticks((ax_res.get_yticks() / 100) * yNorm)
    for xticklabel in ax.get_xticklabels():
        xticklabel.set_visible(False)
    for xticklabel in axy2.get_xticklabels():
        xticklabel.set_visible(False)
    ax.get_yticklabels()[0].set_visible(False)
    axy2.get_yticklabels()[0].set_visible(False)
    ax_res.get_yticklabels()[-1].set_visible(False)
    ax_res_y2.get_yticklabels()[-1].set_visible(False)
    if legend:
        ax.legend(loc='best')
    ax_res.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)
    return fig, [ax, axy2, ax_res, ax_res_y2]

if __name__ == '__main__':
    from functions import gaussian
    from lmfit.models import GaussianModel
    x = np.linspace(-3, 3, 200)
    y = gaussian(x, sigma=0.5) * (1 + np.random.normal(0, 0.1, len(x)))
    gmod = GaussianModel()
    para = gmod.guess(y, x=x)
    gfit = gmod.fit(y, para, x=x)
    models = [gfit.init_fit, gfit.best_fit]
    plt.close('all')
    fig, axes = plotResidual(x, y, models, yNorm=1.0, yThresh=0.1)
    axes[0].set_ylabel('relative [%]')
    axes[1].set_ylabel('absolute')
    axes[2].set_xlabel('xxx')
    plt.show()
from lmfit.models import GaussianModel, LorentzianModel, VoigtModel

data = loadtxt('test_peak.dat')
x = data[:, 0]
y = data[:, 1]

gamma_free = False

MODEL = 'gauss'
# MODEL = 'loren'
# MODEL = 'voigt'
# gamma_free = True

if MODEL.lower().startswith('g'):
    mod = GaussianModel()
    gamma_free = False
    figname = '../doc/_images/models_peak1.png'
elif MODEL.lower().startswith('l'):
    mod = LorentzianModel()
    gamma_free = False
    figname = '../doc/_images/models_peak2.png'
elif MODEL.lower().startswith('v'):
    mod = VoigtModel()
    figname = '../doc/_images/models_peak3.png'

pars = mod.guess(y, x=x)

if gamma_free:
    pars['gamma'].set(value=0.7, vary=True, expr='')
    figname = '../doc/_images/models_peak4.png'