def guess(self, data, x=None, negative=False, **kwargs): pars = guess_from_peak(self, data, x, negative, ampscale=0.5, amp_area=False) pname = "%s%s" % (self.prefix, 'res') pars[pname].value = .1 pname = "%s%s" % (self.prefix, 'kbT') pars[pname].value = .01 return update_param_vals(pars, self.prefix, **kwargs)
def rect_guess(self, data, x=None, **kwargs): if x is None: return ymin, ymax = min(data), max(data) xmin, xmax = min(x), max(x) ntest = min(2, len(data)/5) step_up = (data[:ntest].mean() > data[-ntest:].mean()) dydx = savitzky_golay(np.gradient(data)/np.gradient(x), 5, 2) cen1 = x[np.where(dydx==dydx.max())][0] cen2 = x[np.where(dydx==dydx.min())][0] if step_up: center1 = cen1 # + (xmax+xmin)/4.0)/2. center2 = cen2 # + 3*(xmax+xmin)/4.0)/2. else: center1 = cen2 # + (xmax+xmin)/4.0)/2.0 center2 = cen1 # + 3*(xmax+xmin)/4.0)/2.0 pars = self.make_params(amplitude=(ymax-ymin), center1=center1, center2=center2) pars['%ssigma1' % self.prefix].set(value=(xmax-xmin)/5.0, min=0.0) pars['%ssigma2' % self.prefix].set(value=(xmax-xmin)/5.0, min=0.0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): data = data.flatten() offset = np.mean(data) pars = self.make_params(offset_re=float(np.real(offset)), offset_im=float(np.imag(offset))) return update_param_vals(pars, self.prefix, **kwargs)[0]
def rect_guess(self, data, x=None, **kwargs): if x is None: return ymin, ymax = min(data), max(data) xmin, xmax = min(x), max(x) ntest = min(2, len(data) / 5) step_up = (data[:ntest].mean() > data[-ntest:].mean()) dydx = savitzky_golay(np.gradient(data) / np.gradient(x), 5, 2) cen1 = x[np.where(dydx == dydx.max())][0] cen2 = x[np.where(dydx == dydx.min())][0] if step_up: center1 = cen1 # + (xmax+xmin)/4.0)/2. center2 = cen2 # + 3*(xmax+xmin)/4.0)/2. else: center1 = cen2 # + (xmax+xmin)/4.0)/2.0 center2 = cen1 # + 3*(xmax+xmin)/4.0)/2.0 pars = self.make_params(amplitude=(ymax - ymin), center1=center1, center2=center2) pars['%ssigma1' % self.prefix].set(value=(xmax - xmin) / 5.0, min=0.0) pars['%ssigma2' % self.prefix].set(value=(xmax - xmin) / 5.0, min=0.0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, **kwargs): """Guess parameters as gamma=2, H_k=0, M_s~(pi.f)^2/(mu_0^2.H)-H""" x = kwargs.get("x", np.linspace(1, len(data), len(data) + 1)) v_offset_guess = np.mean(data) v = np.abs(data - v_offset_guess) x = np.abs(x) v_low = np.max(v) * 0.05 v_high = np.max(v) * 0.90 ic_index = v < v_low rn_index = v > v_high ic_guess = np.max( x[ic_index]) # Guess Ic from a 2% of max V threhsold creiteria rn_guess = np.mean(v[rn_index] / x[rn_index]) pars = self.make_params(Ic_p=ic_guess, Ic_n=-ic_guess, Rn=rn_guess, V_offset=v_offset_guess) pars["Ic_p"].min = 0 pars["Ic_n"].max = 0 return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x, **kwargs): """Guess starting values for the parameters of a model. Parameters ---------- data: :class:`~numpy:numpy.ndarray` data to be fitted x: :class:`~numpy:numpy.ndarray` energy domain where the interpolation required kwargs : dict additional optional arguments, passed to model function. Returns ------- :class:`~lmfit.parameter.Parameters` parameters with guessed values """ params = self.make_params() def pset(param, value): params["%s%s" % (self.prefix, param)].set(value=value) x_at_max = x[models.index_of(data, max(data))] ysim = self.eval(x=x_at_max, amplitude=1, center=x_at_max) amplitude = max(data) / ysim pset("amplitude", amplitude) pset("center", x_at_max) return models.update_param_vals(params, self.prefix, **kwargs)
def guess(self, data, x=None, negative=False, **kwargs): pars = self.make_params() pars['%samplitude' % self.prefix].set(value=data.max() - data.min()) try: pars['%scenter' % self.prefix].set(value=(x.min() + x.max() )/2) except AttributeError: pass return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): sxval, syval, oval = 0., 0., 0. if x is not None: not_nan_inds = ~np.isnan(data) sxval, oval = np.polyfit(x[0][not_nan_inds], data[not_nan_inds], 1) syval, oval = np.polyfit(x[1][not_nan_inds], data[not_nan_inds], 1) pars = self.make_params(intercept=oval, slope_x=sxval, slope_y=syval) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, negative=False, **kwargs): pars = guess_from_peak_2D(self, data, x, negative, ampscale=1., amp_area=False) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): _kb=consts.physical_constants['Boltzmann constant'][0]/consts.physical_constants['elementary charge'][0] d1,d2 = 1.,0.0 if x is not None: d1,d2=_np_.polyfit(-1.0/x,_np_.log(data),1) pars = self.make_params(A=_np_.exp(d2), dE=_kb*d1,n=1.0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): _kb = consts.physical_constants['Boltzmann constant'][ 0] / consts.physical_constants['elementary charge'][0] d1, d2 = 1., 0.0 if x is not None: d1, d2 = _np_.polyfit(-1.0 / x, _np_.log(data), 1) pars = self.make_params(A=_np_.exp(d2), dE=_kb * d1, n=1.0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, B=None, **kwargs): s0, DS, B1, B2 = 1.0, 1.0, 1.0, 1.0 if B is not None: zpos = _np_.argmin(_np_.abs(B)) s0 = data[zpos] B1 = _np_.max(B) / 2.0 B2 = B1 DS = 1.0 pars = self.make_params(s0=s0, DS=DS, B1=B1, B2=B2) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): data = data.flatten() slope = (data[-1]-data[0])/(x[-1] - x[0]) intercept = data[0] - slope*x[0] pars = self.make_params(intercept_re=float(np.real(intercept)), intercept_im=float(np.imag(intercept)), slope_re=float(np.real(slope)), slope_im=float(np.imag(slope))), return update_param_vals(pars, self.prefix, **kwargs)[0]
def guess(self, data, x=None, **kwargs): """Guess paramneters from a set of data.""" _kb = consts.physical_constants["Boltzmann constant"][ 0] / consts.physical_constants["elementary charge"][0] d1, d2 = 1.0, 0.0 if x is not None: d1, d2 = np.polyfit(-1.0 / x, np.log(data / x), 1) pars = self.make_params(A=np.exp(d2), DE=_kb * d1, n=1.0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, B=None, **kwargs): s0,DS,B1,B2=1.0,1.0,1.0,1.0 if B is not None: zpos=_np_.argmin(_np_.abs(B)) s0=data[zpos] B1=_np_.max(B)/2.0 B2=B1 DS=1.0 pars = self.make_params(s0=s0,DS=DS,B1=B1,B2=B2) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, B=None, **kwargs): """Guess parameters for weak localisation fit.""" s0, DS, B1, B2 = 1.0, 1.0, 1.0, 1.0 if B is not None: zpos = np.argmin(np.abs(B)) s0 = data[zpos] B1 = np.max(B) / 2.0 B2 = B1 DS = 1.0 pars = self.make_params(s0=s0, DS=DS, B1=B1, B2=B2) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): """Guess paramneters from a set of data.""" _kb = consts.physical_constants["Boltzmann constant"][ 0] / consts.physical_constants["elementary charge"][0] d1, d2, x0 = 1.0, 0.0, 1.0 if x is not None: x0 = x[np.argmin(np.abs(data))] d1, d2 = np.polyfit(-1.0 / (x - x0), np.log(data), 1) pars = self.make_params(A=np.exp(d2), dE=_kb * d1, x_0=x0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): """Guess some starting values.""" Ms = data.max() * 1.001 if x is not None: y = np.log(1 - data / Ms) X = np.log(x) d2 = np.polyfit(X, y, 1)[1] x0 = np.exp(d2 * 2 / 3) else: x0 = len(data) pars = self.make_params(Ms=Ms, Tc=x0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): """Guess parameters for weak localisation fit.""" s0, DS, B1, B2 = 1.0, 1.0, 1.0, 1.0 if x is not None: zpos = np.argmin(np.abs(x)) s0 = data[zpos] B1 = np.max(x) / 20.0 B2 = B1 * 10 DS = 1.0 pars = self.make_params(s0=s0, DS=DS, B1=B1, B2=B2) for p in pars: pars[p].min = 0.0 return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): """Guess parameters as gamma=2, H_k=0, M_s~(pi.f)^2/(mu_0^2.H)-H""" M_s = (_np_.pi * data / consts.mu0) / x - x M_s = _np_.mean(M_s[1:]) g = 2 pars = self.make_params(g=g, M_s=M_s, H_k=100.0) pars["M_s"].min = 0 pars["g"].min = g / 100 pars["H_k"].min = 0 pars["H_k"].max = M_s.max() return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): """Estimate initial model parameter values from data. Args: data (array_like): y data points x (array_like): x data points Returns: lmfit.parameter.Parameters: Guessed parameters """ pars = guess_voigt(self, data, x) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): """Guess parameters for the stretched exponential from data.""" A, beta, x0 = 1.0, 1.0, 1.0 if x is not None: A = data[np.argmin(np.abs(x))] x = np.log(x) y = np.log(-np.log(data / A)) d = np.column_stack((x, y)) d = d[~np.isnan(d).any(axis=1)] d = d[~np.isinf(d).any(axis=1)] d1, d2 = np.polyfit(d[:, 0], d[:, 1], 1) beta = d1 x0 = np.exp(d2 / beta) pars = self.make_params(A=A, beta=beta, x_0=x0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): """Guess parameters as gamma=2, H_k=0, M_s~(pi.f)^2/(mu_0^2.H)-H""" g = 2 H_k = 100 gamma = g * cnst.e / (2 * cnst.m_e) M_s = (4 * np.pi**2 * data**2 - gamma**2 * cnst.mu_0**2 * (x**2 + 2 * x * H_k + H_k**2)) / (gamma**2 * cnst.mu_0**2 * (x + H_k)) M_s = np.mean(M_s) pars = self.make_params(g=g, M_s=M_s, H_k=H_k) pars["M_s"].min = 0 pars["g"].min = g / 100 pars["H_k"].min = 0 pars["H_k"].max = M_s.max() return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): # pylint: disable=unused-argument """Guess some starting values - not very clever""" rho0 = data.min() if x is None: t = np.linspace(0, 1, len(data)) else: t = x / x.max() y = data - data.min() t = t[y > 0.05 * y.max()] y = y[y > 0.05 * y.max()] A = np.polyfit(t, y, 1)[0] pars = self.make_params(thetaD=500, rho0=rho0, A=A, n=5.0) pars["A"].min = 0 pars["n"].vary = False return update_param_vals(pars, self.prefix, **kwargs)
def step_guess(self, data, x=None, **kwargs): if x is None: return ymin, ymax = min(data), max(data) xmin, xmax = min(x), max(x) ntest = min(2, len(data)/5) step_up = (data[:ntest].mean() > data[-ntest:].mean()) dydx = savitzky_golay(np.gradient(data)/np.gradient(x), 5, 2) if step_up: cen = x[np.where(dydx==dydx.max())][0] else: cen = x[np.where(dydx==dydx.min())][0] pars = self.make_params(amplitude=(ymax-ymin), center=cen) pars['%ssigma' % self.prefix].set(value=(xmax-xmin)/5.0, min=0.0) return update_param_vals(pars, self.prefix, **kwargs)
def step_guess(self, data, x=None, **kwargs): if x is None: return ymin, ymax = min(data), max(data) xmin, xmax = min(x), max(x) ntest = min(2, len(data) / 5) step_up = (data[:ntest].mean() > data[-ntest:].mean()) dydx = savitzky_golay(np.gradient(data) / np.gradient(x), 5, 2) if step_up: cen = x[np.where(dydx == dydx.max())][0] else: cen = x[np.where(dydx == dydx.min())][0] pars = self.make_params(amplitude=(ymax - ymin), center=cen) pars['%ssigma' % self.prefix].set(value=(xmax - xmin) / 5.0, min=0.0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, **kwargs): """Guess parameters as max(data), x[argmax(data)] and from FWHM of peak""" x = kwargs.get("x", np.linspace(-len(data) / 2, len(data) / 2, len(data))) Ic0_guess = data.max() B_offset_guess = x[data.argmax()] tmp = np.abs(data - (data.max() / 2)) x0 = np.abs(x[tmp.argmin()] - B_offset_guess) A_guess = 2.2 * Phi_0 / (np.pi * x0) pars = self.make_params(Ic0=Ic0_guess, B_offset=B_offset_guess, A=A_guess) pars["Ic0"].min = 0 return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): """ Estimate initial anchor points through a dataset for the fitting of a cubic spline. Args: data (array_like): y data points x (array_like): x data points Returns: lmfit.parameter.Parameters: Guessed parameters """ pars = self.make_params() spacing = np.linspace(np.min(x), np.max(x), self.n_anchors) spacing_idx = [(np.abs(x - space)).argmin() for space in spacing] data = np.asarray(data) x_anchors = [x[i] for i in spacing_idx] for i, coef in enumerate(x_anchors[::1]): pars['%sx_%i' % (self.prefix, i)].set(value=coef, vary=False) y_anchors = [] for i in spacing_idx: if i == 0: ymin = i ymax = i + int(len(x) / self.n_anchors) y_anchors.append(np.median(data[ymin:ymax])) elif i == len(x) - 1: ymin = i - int(len(x) / self.n_anchors) ymax = i y_anchors.append(np.median(data[ymin:ymax])) else: ymin = i - int(len(x) / self.n_anchors) ymax = i + int(len(x) / self.n_anchors) y_anchors.append(np.median(data[ymin:ymax])) for i, coef in enumerate(y_anchors[::1]): pars['%sy_%i' % (self.prefix, i)].set(value=coef, min=0, max=2 * np.max(data)) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): """Guess paramneters from a set of data.""" _kb = consts.physical_constants["Boltzmann constant"][ 0] / consts.physical_constants["elementary charge"][0] d1, d2, x0 = 1.0, 0.0, 1.0 yy = np.log(data) if x is not None: # Getting a good x_0 is critical, so we first of all use poly fit to look x0 = x[np.argmin(np.abs(data))] * 0.95 def _find_x0(x, d1, d2, x0): X = np.where(np.isclose(x, x0), 1e-8, x - x0) y = d2 - (d1 / X) return y popt = curve_fit(_find_x0, x, yy, p0=[1.0 / _kb, 25, x0])[0] d1, d2, x0 = popt pars = self.make_params(A=np.exp(d2), DE=_kb * d1, x_0=x0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): r"""Guess some starting values. M_s is taken as half the difference of the range of thew M data, we can find m/T from the susceptibility :math:`chi= M_s \mu_o m / kT`,""" M_s = (np.max(data) - np.min(data)) / 2.0 if x is not None: d = np.sort(np.row_stack((x, data))) dd = savgol_filter(d, 7, 1) yd = dd[1] / dd[0] chi = np.interp(np.array([0]), d[0], yd)[0] mT = chi / M_s * (k / mu_0) # Assume T=150K for no good reason m = mT * 150 else: m = 1e6 * (e * hbar) / (2 * electron_mass ) # guess 1 million Bohr Magnetrons T = 150 pars = self.make_params(M_s=M_s, m=m, T=T) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, x, y, **kwargs): """Takes x and y data and generates initial guesses for fit parameters. """ ym = y.min() yM = y.max() a_guess = 0.5 * (yM - ym) * 1.2 b_guess = 0.5 * (yM + ym) t_guess = 0.25 * x[-1] d_guess = get_freq_from_fft(x, y, b_guess) x_guess = 0.0 pars = self.make_params(baseline=b_guess, amplitude=a_guess, T2=t_guess, detuning=d_guess, x0=x_guess) pars['amplitude'].value = kwargs.pop('amplitude_guess', a_guess) pars['baseline'].value = kwargs.pop('baseline_guess', b_guess) pars['T2'].value = kwargs.pop('T2_guess', t_guess) pars['detuning'].value = kwargs.pop('detuning_guess', d_guess) pars['x0'].value = kwargs.pop('x0_guess', x_guess) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): """Guess parameters as gamma=2, H_k=0, M_s~(pi.f)^2/(mu_0^2.H)-H""" if x is None: x = np.linspace(1, len(data), len(data) + 1) x1 = x[np.argmax(data)] x2 = x[np.argmin(data)] sigma = abs(x1 - x2) mu = (x1 + x2) / 2.0 y1 = np.max(data) y2 = np.min(data) dy = y1 - y2 A = dy * (4 * np.pi * sigma**2) / (3 * np.sqrt(3)) pars = self.make_params(A=A, sigma=sigma, mu=mu) pars["A"].min = 0 pars["sigma"].min = 0 pars["mu"].min = np.min(x) pars["mu"].max = np.max(x) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, h=None, **kwargs): """Guess some starting values. M_s is taken as half the difference of the range of thew M data, we can find m/T from the susceptibility chi= M_s \mu_o m / kT,""" from scipy.signal import savgol_filter from scipy.constants import k, mu_0, e, electron_mass, hbar M_s = (_np_.max(data) - _np_.min(data)) / 2.0 if h is not None: d = _np_.sort(_np_.row_stack((h, data))) dd = savgol_filter(d, 7, 1) yd = dd[1] / dd[0] chi = _np_.interp(_np_.array([0]), d[0], yd)[0] mT = chi / M_s * (k / mu_0) #Assume T=150K for no good reason m = mT * 150 else: m = 1E6 * (e * hbar) / (2 * electron_mass ) # guess 1 million Bohr Magnetrons T = 150 pars = self.make_params(M_s=M_s, m=m, T=T) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, x=None, **kwargs): r"""Guess parameters as :math:`\gamma=2, H_k=0, M_s~(\pi f)^2/\mu_0^2.H)-H`.""" if x is None: x = np.linspace(1, len(data), len(data) + 1) x1 = x[np.argmax(data)] x2 = x[np.argmin(data)] Delta_H = abs(x1 - x2) H_res = (x1 + x2) / 2.0 y1 = np.max(data) y2 = np.min(data) dy = y1 - y2 K_2 = dy * (4 * np.pi * Delta_H**2) / (3 * np.sqrt(3)) ay = (y1 + y2) / 2 K_1 = ay * np.pi / Delta_H pars = self.make_params(Delta_H=Delta_H, H_res=H_res, K_1=K_1, K_2=K_2) pars["K_1"].min = 0 pars["K_2"].min = 0 pars["Delta_H"].min = 0 pars["H_res"].min = np.min(x) pars["H_res"].max = np.max(x) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, V=None, **kwargs): """Just set the A, phi,dphi,d and mass values to typical answers for a small tunnel junction""" pars = self.make_params(A=1E-12,phi=3.0,d=10.0,dphi=1.0,mass=1.0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, V=None, **kwargs): """Just set the A, phi and d values to typical answers for a small tunnel junction""" pars = self.make_params(A=_np_.mean(data/V)) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, V=None, **kwargs): """Guess starting values for a good Nb contact to a ferromagnet at 4.2K""" pars = self.make_params(omega=0.36,delta=1.50,P=0.42,Z=0.15) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, t=None, **kwargs): """Guess some starting values - not very clever""" pars = self.make_params(l=10.0,p=0.5,sigma_0=10.0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, t=None, **kwargs): """Guess some starting values - not very clever""" pars = self.make_params(thetaD=900,rho0=0.01,A=0.2,n=5.0) return update_param_vals(pars, self.prefix, **kwargs)
def guess(self, data, **kwargs): pars = self.make_params() pars['%sc' % self.prefix].set(value=data.mean()) return update_param_vals(pars, self.prefix, **kwargs)