コード例 #1
0
def fit_gaussian(data, constrained=False):
    illusion_strength = compute_illusion_strength(data)
    noise_frequencies = np.unique(data.noise_freq)
    n_reps = illusion_strength.shape[1]
    # fit a horizontal line if the data do not have any real dip
    # approximate baseline as 3rd largest value
    baseline = np.sort(illusion_strength.mean(1))[-2]
    minimum = illusion_strength.mean(1).min()
    if baseline - minimum < illusion_strength.mean(1).max() - baseline:
        model = lmfit.Model(lambda x, baseline: baseline)
        params = lmfit.Parameters()
        params.add('baseline', value=baseline)
    else:
        params = lmfit.Parameters()
        #params.add('center', value=3)
        params.add('center',
                   value=noise_frequencies[np.argmin(
                       illusion_strength.mean(1))],
                   max=9,
                   min=.5)
        params.add('width', value=2)
        if constrained:
            params.add('baseline', value=baseline)
            params.add('minimum',
                       value=minimum,
                       min=minimum - 1,
                       max=baseline + 1)
        else:
            params.add('baseline', value=5)
            params.add('minimum', value=-2)
        model = lmfit.Model(inverted_gaussian)
    result = model.fit(illusion_strength.ravel(),
                       x=noise_frequencies.repeat(n_reps),
                       params=params)
    return result
コード例 #2
0
def fit_gaussian(data, constrained=False):
    illusion_strength = compute_illusion_strength(data)
    noise_frequencies = np.unique(data.noise_freq)
    n_reps = illusion_strength.shape[1]
    # fit a horizontal line if the data do not have any real dip
    if data.vp[0] in ['dbm', 'odog'] or (data.vp[0] == 'biwam'
                                         and data.grating_freq[0] == .2):
        model = lmfit.Model(lambda x, baseline: baseline)
        params = lmfit.Parameters()
        params.add('baseline', value=5)
    else:
        params = lmfit.Parameters()
        #params.add('center', value=3)
        params.add('center',
                   value=noise_frequencies[np.argmin(
                       illusion_strength.mean(1))],
                   max=9,
                   min=.01)
        params.add('width', value=3)
        if constrained:
            minimum = illusion_strength.mean(1).min()
            params.add('baseline', value=5, max=8.8)
            params.add('minimum', value=-minimum, min=-6, max=-minimum + 1)
        else:
            params.add('baseline', value=5)
            params.add('minimum', value=5)
        model = lmfit.Model(inverted_gaussian)
    result = model.fit(illusion_strength.ravel(),
                       x=noise_frequencies.repeat(n_reps),
                       params=params)
    return result
コード例 #3
0
    def __init__(self, amplitude, sigma, skew, baseline, floor, ceiling, null, peak_limit_frc=.2):

        # initialise null model
        null_model = lmfit.models.ConstantModel()
        null_params = lmfit.Parameters()
        null_params['c'] = null

        # initialise peak model
        peak_model = lmfit.Model(skewed_gaussian)
        peak_params = lmfit.Parameters()
        peak_params['center'] = lmfit.Parameter(value=0, vary=False)
        peak_params['amplitude'] = amplitude
        peak_params['sigma'] = sigma
        peak_params['skew'] = skew
        peak_params['baseline'] = baseline
        peak_params['ceiling'] = ceiling
        peak_params['floor'] = floor

        # initialise flank model
        half_peak_model = lmfit.Model(gaussian)

        super(SkewedGaussianPeakFitter, self).__init__(
            null_model=null_model, null_params=null_params, peak_model=peak_model,
            peak_params=peak_params, half_peak_model=half_peak_model, peak_limit_frc=peak_limit_frc
        )
コード例 #4
0
    def prepare_fitting(self):
        self.fit_dicts = OrderedDict()

        dac_vals = self.proc_data_dict['dac_values']
        freq_vals = self.proc_data_dict['fit_frequencies']
        if max(freq_vals) < 1e9:
            freq_vals *= 1e9

        guess = self.options_dict.get('fit_guess', {})
        f_q = guess.get(
            'f_max_qubit', self.options_dict.get('f_max_qubit', None))
        guess['f_max_qubit'] = f_q
        ext = f_q is not None
        if self.is_spectroscopy:
            fitmod = lmfit.Model(Qubit_dac_to_freq)
            fitmod.guess = Qubit_dac_arch_guess.__get__(
                fitmod, fitmod.__class__)
        else:
            if f_q is None and self.verbose:
                print('Specify f_max_qubit in the options_dict to obtain a better fit!')
                # Todo: provide alternative fit?
            fitmod = lmfit.Model(Resonator_dac_to_freq)
            fitmod.guess = Resonator_dac_arch_guess.__get__(
                fitmod, fitmod.__class__)

#        fit_result = fitmod.fit(freq_vals, dac_voltage=dac_vals)

        self.fit_dicts['dac_arc'] = {
            'model': fitmod,
            'fit_xvals': {'dac_voltage': dac_vals},
            'fit_yvals': {'data': freq_vals},
            'guessfn_pars': {'values': guess}
        }
コード例 #5
0
def curv_fit(x=None, y=None, model=None):

    x = np.array(x)
    y = np.array(y)
    params = lmfit.Parameters()

    if model == 'gaussian':
        mod = lmfit.models.GaussianModel()
        params = mod.guess(y, x=x)
        out = mod.fit(y, params, x=x)
        r_sq = 1 - out.residual.var() / np.var(y)

    elif model == '4PL':
        mod = lmfit.Model(logistic_4p)
        params.add('la', value=1.0)
        params.add('gr', value=120.0, vary=False)
        params.add('ce', value=150.0)
        params.add('ua', value=3.0)
        out = mod.fit(y, params, x=x)
        r_sq = 1 - out.residual.var() / np.var(y)

    elif model == '5PL':
        mod = lmfit.Model(logistic_5p)
        params.add('la', value=1.0)
        params.add('gr', value=1.0)
        params.add('ce', value=1.0)
        params.add('ua', value=1.0)
        params.add('sy', value=1.0)
        out = mod.fit(y, params, x=x)
        r_sq = 1 - out.residual.var() / np.var(y)

    out.R_sq = r_sq
    return out
コード例 #6
0
def lmfit_voigt_fit(data, startparams, costrains):
    # startparams:XCEN,YCEN,
    model = lmfit.Model(func=constant_func,
                        independent_vars=['x', 'y'],
                        prefix='const_')
    for i in range(len(startparams)):
        mod = lmfit.Model(func=pseudo_voigt_2d,
                          independent_vars=['x', 'y'],
                          prefix='model' + str(i) + '_')
        model += mod

    params = model.make_params()
    params['const_c'].set(value=np.min(data[2]), vary=False)
    for i in range(len(startparams)):
        for j in values:
            ii = 'model' + str(i) + '_'
            params[ii + j].set(value=startparams.at[ii, j],
                               max=costrains.at[j, 'max'],
                               min=costrains.at[j, 'min'],
                               vary=costrains.at[j, 'vary'])
    output = model.fit(data=data[2].ravel(),
                       params=params,
                       x=data[0].ravel(),
                       y=data[1].ravel())
    return output
コード例 #7
0
        def Obtain_Initial_Phase(tpf, corrected_lc, frequency_list):

            flux = corrected_lc.flux.value
            times = corrected_lc.time.value - np.mean(corrected_lc.time.value)
            pg = corrected_lc.to_periodogram(frequency=np.append(
                [0.0001], frequency_list),
                                             ls_method='slow')
            initial_flux = np.asarray(pg.power[1:])

            initial_phase = np.zeros(len(frequency_list))

            def lc_model(time, amp, freq, phase):
                return amp * np.sin(2 * np.pi * freq * time + phase)

            def background_model(time, height):
                return np.ones(len(time)) * height

            for j in np.arange(len(frequency_list)):
                for i in np.arange(len(frequency_list)):

                    if (i == 0):
                        model = lm.Model(lc_model,
                                         independent_vars=['time'],
                                         prefix='f{0:d}'.format(i))
                        model += lm.Model(background_model,
                                          independent_vars=['time'])
                    else:
                        model += lm.Model(lc_model,
                                          independent_vars=['time'],
                                          prefix='f{0:d}'.format(i))

                    model.set_param_hint('f{0:d}phase'.format(i),
                                         min=-np.pi,
                                         max=np.pi,
                                         value=initial_phase[i],
                                         vary=False)
                    model.set_param_hint('f{0:d}amp'.format(i),
                                         value=initial_flux[i],
                                         vary=False)
                    model.set_param_hint('height',
                                         value=np.mean(flux),
                                         vary=False)
                    model.set_param_hint('f{0:d}freq'.format(i),
                                         value=frequency_list[i],
                                         vary=False)

                params = model.make_params()
                params['f{0:d}phase'.format(j)].set(vary=True)
                params['f{0:d}phase'.format(j)].set(value=initial_phase[j])
                params['f{0:d}phase'.format(j)].set(brute_step=np.pi / 10)
                result = model.fit(corrected_lc.flux.value,
                                   params,
                                   time=times,
                                   method='brute')
                initial_phase[j] = result.best_values['f{0:d}phase'.format(j)]

            return initial_phase
コード例 #8
0
    def __init__(self, amp, tau):
        self.amp_s = amp
        self.tau_s = tau
        self.amp_k = self.amp_s/(self.amp_s-1.)
        self.tau_k = (1.-self.amp_s)*self.tau_s

        self.step_func = lambda t: 1.-self.amp_s*np.exp(-t/self.tau_s)

        self.kernel_step_func = lambda t: 1.+self.amp_k*np.exp(-t/self.tau_k)
        self.step_model = lmfit.Model(self.step_func)
        self.kernel_step_model = lmfit.Model(self.kernel_step_func)
コード例 #9
0
def fitBandy2(et, M, dM=None, mode="logM", start=None, lb=None, ub=None):
    def residual(pars, x, data=None, eps=None):
        # unpack parameters:
        #  extract .value attribute for each parameter
        parvals = pars.valuesdict()
        period = parvals["period"]
        shift = parvals["shift"]
        decay = parvals["decay"]

        if abs(shift) > pi / 2:
            shift = shift - sign(shift) * pi

        if abs(period) < 1.0e-10:
            period = sign(period) * 1.0e-10

        model = parvals["amp"] * sin(shift + x / period) * exp(
            -x * x * decay * decay)

        if data is None:
            return model
        if eps is None:
            return model - data
        return (model - data) / eps

    pars = lmfit.Parameters()
    pars.add("t", value=start[0], min=lb[0], max=ub[0], vary=1)
    pars.add("g", value=start[1], min=lb[1], max=ub[1], vary=1)
    if dM is not None:
        wgt = 1.0 / dM**2
    else:
        wgt = np.ones_like(M)
    if mode == "M":
        mod = lmfit.Model(bandy_M)
    elif mode == "logM":
        mod = lmfit.Model(bandy_logM)
    elif mode == "logMa" or mode == "logMa_off":
        mod = lmfit.Model(bandy_logMa)
        if "off" in mode:
            pars.add("a", value=0, min=0, vary=1)
        else:
            pars.add("a", value=0, vary=0)
        pars.add("b", value=start[2], min=lb[2], max=ub[2], vary=1)
    elif mode == "logV2a":
        mod = lmfit.Model(bandy_V2a)
        wgt = np.log10(wgt)
        pars.add("a", value=0, vary=0)
        pars.add("b", value=start[2], min=lb[2], max=ub[2], vary=1)
    if "log" in mode:
        M = np.log10(M)
        if dM is not None:
            wgt = 1.0 / np.log10(dM)**2
    return mod.fit(M, pars, x=et, weights=wgt)
コード例 #10
0
ファイル: fitBandy.orig.py プロジェクト: RobertRosca/Xana
def fitBandy2(et, M, dM=None, mode='logM', start=None, lb=None, ub=None):
    def residual(pars, x, data=None, eps=None):
        # unpack parameters:
        #  extract .value attribute for each parameter
        parvals = pars.valuesdict()
        period = parvals['period']
        shift = parvals['shift']
        decay = parvals['decay']

        if abs(shift) > pi / 2:
            shift = shift - sign(shift) * pi

        if abs(period) < 1.e-10:
            period = sign(period) * 1.e-10

        model = parvals['amp'] * sin(shift + x / period) * exp(
            -x * x * decay * decay)

        if data is None:
            return model
        if eps is None:
            return (model - data)
        return (model - data) / eps

    pars = lmfit.Parameters()
    pars.add('t', value=start[0], min=lb[0], max=ub[0], vary=1)
    pars.add('g', value=start[1], min=lb[1], max=ub[1], vary=1)
    if dM is not None:
        wgt = 1. / dM**2
    else:
        wgt = np.ones_like(M)
    if mode == 'M':
        mod = lmfit.Model(bandy_M)
    elif mode == 'logM':
        mod = lmfit.Model(bandy_logM)
    elif mode == 'logMa' or mode == 'logMa_off':
        mod = lmfit.Model(bandy_logMa)
        if 'off' in mode:
            pars.add('a', value=0, min=0, vary=1)
        else:
            pars.add('a', value=0, vary=0)
        pars.add('b', value=start[2], min=lb[2], max=ub[2], vary=1)
    elif mode == 'logV2a':
        mod = lmfit.Model(bandy_V2a)
        wgt = np.log10(wgt)
        pars.add('a', value=0, vary=0)
        pars.add('b', value=start[2], min=lb[2], max=ub[2], vary=1)
    if 'log' in mode:
        M = np.log10(M)
        if dM is not None:
            wgt = (1. / np.log10(dM)**2)
    return mod.fit(M, pars, x=et, weights=wgt)
コード例 #11
0
ファイル: cphase_calib.py プロジェクト: QudevETH/PycQED_py3
def get_optimal_amp(qbc, qbt, soft_sweep_points, timestamp=None,
                    classified_ro=False, tangent_fit=False,
                    parfit=False,
                    analysis_object=None, **kw):

    if analysis_object is None:
        if classified_ro:
            channel_map = {qb.name: [vn + ' ' +
                                     qb.instr_acq() for vn in
                                     qb.int_avg_classif_det.value_names]
                           for qb in [qbc, qbt]}
        else:
            channel_map = {qb.name: [vn + ' ' +
                                     qb.acq_instr() for vn in
                                     qb.int_avg_det.value_names]
                           for qb in [qbc, qbt]}
        tdma = tda.CPhaseLeakageAnalysis(
            t_start=timestamp,
            qb_names=[qbc.name, qbt.name],
            options_dict={'TwoD': True, 'plot_all_traces': False,
                          'plot_all_probs': False,
                          'delegate_plotting': False,
                          'channel_map': channel_map})
    else:
        tdma = analysis_object
    cphases = tdma.proc_data_dict[
        'analysis_params_dict'][f'cphase_{qbt.name}']['val']

    sweep_pts = list(soft_sweep_points.values())[0]['values']
    if tangent_fit:
        fit_res = lmfit.Model(lambda x, m, b: m*np.tan(x/2-np.pi/2) + b).fit(
            x=cphases, data=sweep_pts,
            m=(max(sweep_pts)-min(sweep_pts))/((max(cphases)-min(cphases))),
            b=np.min(sweep_pts))
    elif parfit:
        fit_res = lmfit.Model(lambda x, m, b, c: m*x + c*x**2 + b).fit(
            x=cphases, data=sweep_pts,
            m=(max(sweep_pts)-min(sweep_pts))/((max(cphases)-min(cphases))),
            c=0.001,
            b=np.min(sweep_pts))
    else:
        fit_res = lmfit.Model(lambda x, m, b: m*x + b).fit(
            x=cphases, data=sweep_pts,
            m=(max(sweep_pts)-min(sweep_pts))/((max(cphases)-min(cphases))),
            b=np.min(sweep_pts))
    plot_and_save_cz_amp_sweep(cphases=cphases, timestamp=timestamp,
                               soft_sweep_params_dict=soft_sweep_points,
                               fit_res=fit_res, save_fig=True, plot_guess=False,
                               qbc_name=qbc.name, qbt_name=qbt.name, **kw)
    return fit_res
コード例 #12
0
def test_live_fit_plot(fresh_RE):
    RE = fresh_RE
    try:
        import lmfit
    except ImportError:
        raise pytest.skip('requires lmfit')

    def gaussian(x, A, sigma, x0):
        return A * np.exp(-(x - x0)**2 / (2 * sigma**2))

    model = lmfit.Model(gaussian)
    init_guess = {
        'A': 2,
        'sigma': lmfit.Parameter('sigma', 3, min=0),
        'x0': -0.2
    }
    livefit = LiveFit(model,
                      'det', {'x': 'motor'},
                      init_guess,
                      update_every=50)
    lfplot = LiveFitPlot(livefit, color='r')
    lplot = LivePlot('det', 'motor', ax=plt.gca(), marker='o', ls='none')
    RE(scan([det], motor, -1, 1, 50), [lplot, lfplot])

    expected = {'A': 1, 'sigma': 1, 'x0': 0}
    for k, v in expected.items():
        assert np.allclose(livefit.result.values[k], v, atol=1e-6)
コード例 #13
0
def test_live_fit_multidim(fresh_RE):
    RE = fresh_RE

    try:
        import lmfit
    except ImportError:
        raise pytest.skip('requires lmfit')

    motor1._fake_sleep = 0
    motor2._fake_sleep = 0
    det4.exposure_time = 0

    def gaussian(x, y, A, sigma, x0, y0):
        return A * np.exp(-((x - x0)**2 + (y - y0)**2) / (2 * sigma**2))

    model = lmfit.Model(gaussian, ['x', 'y'])
    init_guess = {
        'A': 2,
        'sigma': lmfit.Parameter('sigma', 3, min=0),
        'x0': -0.2,
        'y0': 0.3
    }
    cb = LiveFit(model,
                 'det4', {
                     'x': 'motor1',
                     'y': 'motor2'
                 },
                 init_guess,
                 update_every=50)
    RE(outer_product_scan([det4], motor1, -1, 1, 10, motor2, -1, 1, 10, False),
       cb)

    expected = {'A': 1, 'sigma': 1, 'x0': 0, 'y0': 0}
    for k, v in expected.items():
        assert np.allclose(cb.result.values[k], v, atol=1e-6)
コード例 #14
0
def test_live_fit_plot(RE, hw):
    try:
        import lmfit
    except ImportError:
        raise pytest.skip("requires lmfit")

    def gaussian(x, A, sigma, x0):
        return A * np.exp(-(x - x0)**2 / (2 * sigma**2))

    model = lmfit.Model(gaussian)
    init_guess = {
        "A": 2,
        "sigma": lmfit.Parameter("sigma", 3, min=0),
        "x0": -0.2,
    }
    livefit = LiveFit(model,
                      "det", {"x": "motor"},
                      init_guess,
                      update_every=50)
    lfplot = LiveFitPlot(livefit, color="r")
    lplot = LivePlot("det", "motor", ax=plt.gca(), marker="o", ls="none")
    RE(scan([hw.det], hw.motor, -1, 1, 50), [lplot, lfplot])
    expected = {"A": 1, "sigma": 1, "x0": 0}
    for k, v in expected.items():
        assert np.allclose(livefit.result.values[k], v, atol=1e-6)
コード例 #15
0
ファイル: server0.py プロジェクト: sgounane/covid19
def train():
    body = request.json
    df=pd.DataFrame(body)
    N=body["init"].N
    #data=np.array([body["confirmed"],body["active"],body["recovered"],body["deaths"]])
    data=np.array([body["confirmed"],body["active"]])
    x =df.index
    # plt.plot(x,data[1])
    # plt.show()
    print(len(data.T),len(x))
    mod = lmfit.Model(mdl)
    mod.set_param_hint("beta",  value=body["init"].beta, vary=True,min=0, max=6)
    mod.set_param_hint("gamma", value=body["init"].gamma, vary=True,min=0, max=4,)
    mod.set_param_hint("sigma", value=body["init"].sigma, vary=True,min=0, max=4)
    mod.set_param_hint("N", value=N, vary=False)
    params = mod.make_params()

    result = mod.fit(data, params, method="leastsq", x=x) 
    #result.plot_fit(datafmt="-")
    #plt.show()
    print(result.fit_report())
 

    # a=requests.get(apiUrl+"dayone/country/"+body["country"])
    # print(a.content)
    return dict(result.params.valuesdict())
コード例 #16
0
def test_coercion_of_input_data(peakdata, input_dtype, expected_dtype):
    """Test for coercion of 'data' and 'independent_vars'.

    - 'data' should become 'float64' or 'complex128'
    - dtype for 'indepdendent_vars' is only changed when the input is a list,
        tuple, numpy.ndarray, or pandas.Series

    """
    x, y = peakdata
    model = lmfit.Model(gaussian)
    pars = model.make_params()

    if (not lmfit.minimizer.HAS_PANDAS and input_dtype in ['pandas-real',
                                                           'pandas-complex']):
        return

    elif input_dtype == 'pandas-real':
        result = model.fit(lmfit.model.Series(y, dtype=np.float32), pars,
                           x=lmfit.model.Series(x, dtype=np.float32))
    elif input_dtype == 'pandas-complex':
        result = model.fit(lmfit.model.Series(y, dtype=np.complex64), pars,
                           x=lmfit.model.Series(x, dtype=np.complex64))
    elif input_dtype == 'list':
        result = model.fit(y.tolist(), pars, x=x.tolist())
    elif input_dtype == 'tuple':
        result = model.fit(tuple(y), pars, x=tuple(x))
    else:
        result = model.fit(np.asarray(y, dtype=input_dtype), pars,
                           x=np.asarray(x, dtype=input_dtype))

    assert result.__dict__['userkws']['x'].dtype == expected_dtype
    assert result.__dict__['userargs'][0].dtype == expected_dtype
コード例 #17
0
    def fit(self):
        mod = lmfit.Model(self.fitter)
        
        self.kabko.apply_params(mod)
        
        outbreak_shift = self.kabko.outbreak_shift(
            self.kabko.params["incubation_period"].init
        )
        
        days = self.kabko.data_days(outbreak_shift)
        
        mod.set_param_hint("days", value=days, vary=False)

        params = mod.make_params()
        
        x_data = np.linspace(0, days - 1, days, dtype=int)
        
        y_data = util.shift_array(
            self.kabko.dead, 
            outbreak_shift
        )

        result = mod.fit(y_data, params, method="least_squares", x=x_data)
        

        #result.plot_fit(datafmt="-");
        
        return result
コード例 #18
0
def tip_line_fit(point1, point2, image, length_spacing, line_thickness, width_spacing):
    """Fit the tip of a line to a complementary error function, 1 - erf(x).

    Args:
      point1: 1D array or float.
      point2: 1D array or float.
      image: 2D array.
      length_spacing: float, `get_thick_line()`.
      line_thickness: float, `get_thick_line()`.
      width_spacing: float, `get_thick_line()`.
    """

    profile_parameters = {}
    profile_parameters["length_spacing"] = length_spacing  # pixel
    profile_parameters["line_thickness"] = line_thickness  # pixel
    profile_parameters["width_spacing"] = width_spacing  # pixel
    profile_parameters["normalized_intensities"] = True

    x_profile, y_profile = line_profile(image, point1, point2, **profile_parameters)

    def errorfunction(x, mu, sigma, mt, bg):
        # pylint: disable=no-member
        return bg + (0.5 * mt * special.erfc((x - mu) / (np.sqrt(2) * sigma)))

    model = lmfit.Model(errorfunction)

    fit_params = {}
    fit_params["mu"] = lmfit.Parameter("mu", value=x_profile[-1] / 2, min=0, max=x_profile[-1])
    fit_params["sigma"] = lmfit.Parameter("sigma", value=1, vary=True, min=0, max=x_profile[-1])
    fit_params["mt"] = lmfit.Parameter("mt", value=1, vary=True, min=0)
    fit_params["bg"] = lmfit.Parameter("bg", value=1, vary=True, min=0)
    fit_result = model.fit(y_profile.copy(), x=x_profile.copy(), **fit_params)

    return x_profile, y_profile, fit_result, errorfunction
コード例 #19
0
        def setup():
            fig, ax = plt.subplots()
            self.ax = ax
            fig.canvas.set_window_title('Peakup')
            self.ax.clear()
            # Setup LiveCallbacks
            self.live_plot = LivePlot(scaler,
                                      dcm_c2_pitch_name,
                                      linestyle='',
                                      marker='*',
                                      color='C0',
                                      label='raw',
                                      ax=self.ax,
                                      use_teleporter=False)

            # Setup LiveFit
            # f_gauss(x, A, sigma, x0, y0, m)
            model = lmfit.Model(f_gauss, ['x'])
            init_guess = {
                'A': lmfit.Parameter('A', 100000, min=0),
                'sigma': lmfit.Parameter('sigma', 0.001, min=0),
                'x0': lmfit.Parameter('x0', pitch_guess),
                'y0': lmfit.Parameter('y0', 0, min=0),
                'm': lmfit.Parameter('m', 0, vary=False)
            }
            self.lf = LiveFit(model, scaler, {'x': dcm_c2_pitch_name},
                              init_guess)
            self.lpf = LiveFitPlot(self.lf,
                                   ax=self.ax,
                                   color='r',
                                   use_teleporter=False,
                                   label='Gaussian fit')
コード例 #20
0
    def __init__(self, n_peaks, verbose=False, model='Lorentz'):

        self.mkey = model
        _func = {
            'Lorentz': makefunc_Lorentz_cmplx,
            'Voigt': makefunc_Voigt
        }[model]

        self.n = n_peaks
        self.model = lmfit.Model(_func(n_peaks))
        self.params = self.model.make_params(verbose=False)

        # This loop initializes all parameters by 1 and sets standard boundaries depending on the respective parameterset
        for k in self.params.keys():
            self.set_initial_values(k, 1)
            if k[0] == 'a':
                self.set_boundaries(k, 0, np.inf)
                self.set_initial_values(k, 1e6)
            elif k[0] == 'l':
                self.set_boundaries(k, 0, np.inf)
                self.set_initial_values(k, 1e-2)
            elif k[0] == 'p':
                self.set_boundaries(k, -180, 180)
            elif k[0] == 's':
                self.set_boundaries(k, 0, np.inf)
                self.set_initial_values(k, 1e-2)
            else:
                pass

        if verbose:
            self.params.pretty_print()
コード例 #21
0
def simplefit(t, G, err, kappa = 5, triplet = 1):
    #0 = triplet off, 1 = triplet on
    # 1-comp diffusion, triplet considered only if selected
    A0_guess = np.mean(G[:5])
    arg = abs(G - A0_guess/2)
    ind = np.argmin(arg)
    tau_guess = t[ind]    
    print('Guessing tau = %f ms' %(tau_guess))
    
    model = lmfit.Model(ff.triplet_diff3d)
    params = model.make_params(A0=A0_guess, tau_diff=tau_guess)
    if triplet == 1:
        params['T'].set(min=0, max=1, value=0.1)
        params['tau_trip'].set(min=1E-9, max=0.05, value=10e-4)
    else:
        params['T'].set(value=0, vary=False)
        params['tau_trip'].set(value=1e-4, vary=False)
    params['A0'].set(min=0.00001, value=A0_guess)
    params['tau_diff'].set(min=1e-4, value=tau_guess)
    params['Ginf'].set(value=0, vary = True)
    params['kappa'].set(value=kappa, vary=False)  # 3D model only
    
    weights = 1/err
    t_max = 1e7
    fitres = model.fit(G[t < t_max], timelag=t[t<t_max], params=params, method='least_squares',
                       weights=weights[t<t_max])
    print('\nList of fitted parameters for %s: \n' % model.name)
    fitres.params.pretty_print(colwidth=10, columns=['value', 'stderr', 'min', 'max'])
    
    print(fitres.fit_report())
    
    return fitres
コード例 #22
0
def simplefit2(t, G, err, kappa = 5, tau_diff2_fix_value = 0.050):
    
    # tau_diff2_fix_value = 0.036
    # kappa = 5.9
    
    # two component diffusion
    model = lmfit.Model(ff.twocomp_diff3d)
    
    A0_guess = np.mean(G[:5])
    arg = abs(G - A0_guess/2)
    ind = np.argmin(arg)
    tau_guess = t[ind]
    print('Guessing tau = %f ms' %(tau_guess))
    
    params = model.make_params(A0=A0_guess)
    params['A0'].set(min=0.00001, value = A0_guess)
    # params['tau_diff1'].set(min=2*tau_diff2_fix_value, value = tau_guess) #slow component
    params['tau_diff1'].set(min=1e-6, value = tau_guess) #slow component
    params['tau_diff2'].set(min=1e-6, value = tau_diff2_fix_value, vary = False) #fast component, usually fixed
    params['p1'].set(min = 0, max = 1, value = 0.5) #fraction slow
    
    params['Ginf'].set(value=0, vary = True)
    params['kappa'].set(value=kappa, vary=False)  # 3D model only
    
    # weights = np.ones_like(avg_G)
    weights = 1/err
    t_max = 1e7
    fitres = model.fit(G[t < t_max], timelag=t[t<t_max], params=params, method='least_squares',
                       weights=weights[t<t_max])
    print('\nList of fitted parameters for %s: \n' % model.name)
    fitres.params.pretty_print(colwidth=10, columns=['value', 'stderr', 'min', 'max'])
    print(fitres.fit_report())
    return fitres
コード例 #23
0
def constrained_fitter(minicube, xax, input_parameters, par_minima=None,
                       par_maxima=None, **model_kwargs):
    """
    input_parameters should be a dict
    """

    model = lmfit.Model(multicomp_minicube_model_generator(**model_kwargs),
                        independent_vars=['xax'])

    params = model.make_params()

    for par in params:
        params[par].value = input_parameters[par]
        if 'amp' in par and par[3] != 'd':
            params[par].min = 0
        elif 'sigma' in par and par[5] != 'd':
            params[par].min = 0
        if par_minima is not None:
            for mpar in par_minima:
                if mpar not in params:
                    raise ValueError("Parameter {0} is not in params".format(mpar))
                params[mpar].min = par_minima[mpar]
        if par_maxima is not None:
            for mpar in par_maxima:
                if mpar not in params:
                    raise ValueError("Parameter {0} is not in params".format(mpar))
                params[mpar].max = par_maxima[mpar]


    result = model.fit(minicube, xax=xax,
                       params=params)

    return result
コード例 #24
0
    def fit_to_exp(self, rem = 0, plot_rem = False):
        model = lmf.Model(self.decay_exp)
        params = model.make_params(amp = 1.0, delta = 0.5)
        params.add('c', value = 0, vary = False)

#         res_exp = model.fit(self.Fs, params, x = self.Ls)
        
        mod = lmf.models.LinearModel()
        pars = mod.guess(np.log(self.Fs[:self.Len-rem]), x=self.Ls[:self.Len-rem])
        scaling_fit = mod.fit(np.log(self.Fs)[:self.Len-rem] ,pars, x=self.Ls[:self.Len-rem])
        
        fig, ax = plt.subplots(figsize = (6, 3.6))

        ax.plot(self.Ls, self.Fs, "o")
        ax.plot(self.Ls, np.exp(scaling_fit.values["intercept"])*np.exp(scaling_fit.values["slope"]*self.Ls),"C1-")
        ax.annotate("$\propto exp({:.2f}{})$".format(scaling_fit.values["slope"], self.L_label), (self.Ls[0]*0.1+self.Ls[1]*0.9, self.Fs[0]*0.1 + self.Fs[1]*0.9))
        ax.set_xlabel("{}".format(self.L_label))
        ax.set_ylabel("{}".format(self.F_label))
        ax.tick_params(axis = "y")
        ax.yaxis.set_major_formatter(mpl.ticker.FormatStrFormatter('%.1e'))
        ax.locator_params(nbins=5)
        
        axin = ax.inset_axes([0.35,0.35,0.6,0.6])
        scaling_fit.plot_fit(ax = axin, xlabel = "{}".format(self.L_label), ylabel = "log({})".format(self.F_label))
        if plot_rem:
            axin.plot(self.Ls[-3:],np.log(np.abs(self.Fs[-rem:])),"C0o")
        axin.set_title("")
        axin.set_xticklabels([])
        axin.set_yticklabels([])
        axin.tick_params(axis='both', which='both', length=0)
        axin.get_legend().remove()
        
        plt.show()
コード例 #25
0
    def read_mu_x(self):
        self.debug_stream("Calculating the center of the peak in the x axis")

        def gaussian_paula(x, mu, A, sigma, c):
            return A * np.exp(-(x - mu)**2 / (2 * sigma**2)) + c

        mod = lm.Model(gaussian_paula)
        self.parsx = lm.Parameters()
        real_data = np.array(self.image_proxy.read().value)
        self.x_axis = np.mean(real_data, axis=0)
        #self.x_axis = np.mean(real_data[self.__xposi:self.__xposi+self.__xwind,:], axis = 0)
        self.x_max = np.max(self.x_axis)
        self.x_min = np.min(self.x_axis)
        self.mu = self.x_axis.argmax()

        self.parsx.add('mu', value=self.mu)
        self.parsx.add('A', value=self.x_max - self.x_min)
        self.parsx.add('c', value=self.x_min)
        self.parsx.add('sigma', value=self.sigma_try)

        self.debug_stream('parameters fitting x axis data')
        self.out_gaussx = mod.fit(self.x_axis, self.parsx, x=self.x2)
        self.debug_stream('fitting x axis done succesfully')

        self.a = self.out_gaussx.best_values['sigma']
        return self.out_gaussx.best_values['mu']
コード例 #26
0
ファイル: autonode_app.py プロジェクト: neildick/plottr
def sinefit(self, dataIn: DataDictBase = None):
    if dataIn is None:
        return None

    # this is just a ghetto example: only support very simple datasets
    naxes = len(dataIn.axes())
    ndeps = len(dataIn.dependents())
    if not (naxes == 1 and ndeps == 1):
        return dict(dataOut=dataIn)

    # getting the data
    axname = dataIn.axes()[0]
    x = dataIn.data_vals(axname)
    y = dataIn.data_vals(dataIn.dependents()[0])

    # try to fit
    sinemodel = lmfit.Model(sinefunc)
    p0 = sinemodel.make_params(amp=1, freq=self.frequencyGuess, phase=0)
    result = sinemodel.fit(y, p0, x=x)

    # if the fit works, add the fit result to the output
    dataOut = dataIn.copy()
    if result.success:
        dataOut['fit'] = dict(values=result.best_fit, axes=[
            axname,
        ])
        dataOut.add_meta('info', result.fit_report())
    else:
        dataOut.add_meta('info', 'Could not fit sine.')

    return dict(dataOut=dataOut)
コード例 #27
0
    def fit_to_pow(self):
        model = lmf.Model(self.decay_pow)
        params = model.make_params(amp = 1.0, delta = 0.5)
        params.add('c', value = 0, vary = False)

        res_pow = model.fit(self.Fs, params, x = self.Ls)
        
        mod = lmf.models.LinearModel()
        pars = mod.guess(np.log(self.Fs), x=np.log(self.Ls))
        scaling_fit = mod.fit(np.log(self.Fs),pars, x=np.log(self.Ls))
        
        fig, ax = plt.subplots(figsize = (6, 3.6))


        ax.plot(self.Ls, self.Fs, "o")
        ax.plot(self.Ls, np.exp(scaling_fit.values["intercept"])*self.Ls**scaling_fit.values["slope"],"C1-")
        ax.annotate("$\propto {}^{{{:.2f}}}$".format(self.L_label,scaling_fit.values["slope"]), (self.Ls[2]/2+self.Ls[3]/2, self.Fs[2]/2 + self.Fs[3]/2))
        ax.set_xlabel("{}".format(self.L_label))
        ax.set_ylabel("{}".format(self.F_label))
        ax.locator_params(nbins=5)
        ax.tick_params(axis = "y", labelleft = False)
        
        axin = ax.inset_axes([0.4,0.4,0.6,0.6])
        scaling_fit.plot_fit(ax = axin, xlabel = "log({})".format(self.L_label), ylabel = "log({})".format(self.F_label))
        axin.set_title("")
        axin.set_xticklabels([])
        axin.set_yticklabels([])
        axin.tick_params(axis='both', which='both', length=0)
        axin.get_legend().remove()
        
        plt.show()
コード例 #28
0
    def test_OptimizerCallback(self):
        def rosen(params, a=1, b=100, noise=0):
            """ Rosenbrock function """
            v = (a - params[0])**2 + b * (params[1] - params[0]**2)**2
            v += noise * (np.random.rand() - .5)
            return v

        def objective(x):
            return rosen(x, 0.01, 1)

        oc = OptimizerCallback(show_progress=False)

        result = scipy.optimize.minimize(objective, [.5, .9],
                                         callback=oc.scipy_callback)
        self.assertEqual(result.success, True)
        self.assertEqual(oc.number_of_evaluations(), result.nit)
        self.assertIsInstance(oc.data, pandas.DataFrame)

        oc.clear()

        lmfit_model = lmfit.Model(linear_function, independent_vars=['x'])
        xdata = np.linspace(0, 10, 40)
        data = 10 + 5 * xdata
        lmfit_model.fit(data, x=xdata, a=1, b=1, iter_cb=oc.lmfit_callback)
        plt.figure(100)
        plt.clf()
        oc.plot(logy=True)
        plt.close(100)
コード例 #29
0
    def fit_to_expstr(self):
        model = lmf.Model(self.decay_expstr)
        params = model.make_params(amp = 1.0)
        params.add('c', value = 0, vary = False)
        params.add('delta', value = 0.5, min = 0.1)

        res_expstr = model.fit(self.Fs, params, x = self.Ls)
        
        mod = lmf.models.LinearModel()
        pars = mod.guess(np.log(self.Fs), x=np.sqrt(self.Ls))
        scaling_fit = mod.fit(np.log(self.Fs)[:] ,pars, x=np.sqrt(self.Ls[:]))
        
        fig, ax = plt.subplots(figsize = (6, 3.6))

        ax.plot(self.Ls, self.Fs, "o")
        ax.plot(self.Ls, np.exp(scaling_fit.values["intercept"])*np.exp(scaling_fit.values["slope"]*np.sqrt(self.Ls)),"C1-")
        ax.annotate("$\propto exp({:.2f}\sqrt{{{}}})$".format(scaling_fit.values["slope"], self.L_label), (self.Ls[2]*0.1+self.Ls[3]*0.9, self.Fs[2]*0.1 + self.Fs[3]*0.9))
        ax.set_xlabel("{}".format(self.L_label))
        ax.set_ylabel("{}".format(self.F_label))
        ax.locator_params(nbins=5)
        
        axin = ax.inset_axes([0.35,0.35,0.6,0.6])
        scaling_fit.plot_fit(ax = axin, xlabel = "$\sqrt{{{}}}$".format(self.L_label), ylabel = "log({})".format(self.F_label))
#         axin.plot(self.Ls[-3:],np.log(self.Fs[-3:]),"C0o")
        axin.set_title("")
        axin.set_xticklabels([])
        axin.set_yticklabels([])
        axin.tick_params(axis='both', which='both', length=0)
        axin.get_legend().remove()
        
        plt.show()
コード例 #30
0
    def prepare_fitting(self):
        self.fit_dicts = OrderedDict()
        states = ['0', '1', '+']
        for i, state in enumerate(states):
            yvals = self.proc_data_dict['yvals_{}'.format(state)]
            xvals = self.proc_data_dict['xvals']

            mod = lmfit.Model(fit_mods.idle_error_rate_exp_decay)
            mod.guess = fit_mods.idle_err_rate_guess.__get__(
                mod, mod.__class__)

            # Done here explicitly so that I can overwrite a specific guess
            guess_pars = mod.guess(N=xvals, data=yvals)
            vary_N2 = self.options_dict.get('vary_N2', True)

            if not vary_N2:
                guess_pars['N2'].value = 1e21
                guess_pars['N2'].vary = False
            # print(guess_pars)
            self.fit_dicts['fit {}'.format(states[i])] = {
                'model': mod,
                'fit_xvals': {
                    'N': xvals
                },
                'fit_yvals': {
                    'data': yvals
                },
                'guess_pars': guess_pars
            }