Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def test_composite_with_expression(self):
expression_model = models.ExpressionModel("exp(-x/x0)", name='exp')
amp_model = models.ConstantModel(prefix='amp_')
off_model = models.ConstantModel(prefix='off_', name="off")
comp_model = off_model + amp_model * expression_model
x = self.x
true_values = self.true_values()
data = comp_model.eval(x=x, **true_values) + self.noise
# data = 0.25 + 1 * np.exp(-x / 2.)
params = comp_model.make_params(**self.guess())
result = comp_model.fit(data, x=x, params=params)
assert_results_close(result.values, true_values, rtol=0.01, atol=0.01)
data_components = comp_model.eval_components(x=x)
self.assertIn('exp', data_components)
def test_user_defined_gaussian_plus_constant(self):
data = self.data + 5.0
model = self.model + models.ConstantModel()
guess = self.guess()
pars = model.make_params(c=10.1, **guess)
true_values = self.true_values()
true_values['c'] = 5.0
result = model.fit(data, pars, x=self.x)
assert_results_close(result.values, true_values, rtol=0.01, atol=0.01)
def test_eval_components(self):
model1 = models.GaussianModel(prefix='g1_')
model2 = models.GaussianModel(prefix='g2_')
model3 = models.ConstantModel(prefix='bkg_')
mod = model1 + model2 + model3
pars = mod.make_params()
values1 = dict(amplitude=7.10, center=1.1, sigma=2.40)
values2 = dict(amplitude=12.2, center=2.5, sigma=0.5)
data = (1.01 + gaussian(x=self.x, **values1) +
gaussian(x=self.x, **values2) + 0.05*self.noise)
pars['g1_sigma'].set(2)
pars['g1_center'].set(1, max=1.5)
pars['g1_amplitude'].set(3)
pars['g2_sigma'].set(1)
pars['g2_center'].set(2.6, min=2.0)
pars['g2_amplitude'].set(1)
pars['bkg_c'].set(1.88)
def test_guess_modelparams():
x = np.linspace(-10, 10, 501)
mod = models.ConstantModel()
y = 6.0 + x*0.005
pars = mod.guess(y)
assert_allclose(pars['c'].value, 6.0, rtol=0.01)
mod = models.ComplexConstantModel(prefix='f_')
y = 6.0 + x*0.005 + (4.0 - 0.02*x)*1j
pars = mod.guess(y)
assert_allclose(pars['f_re'].value, 6.0, rtol=0.01)
assert_allclose(pars['f_im'].value, 4.0, rtol=0.01)
mod = models.QuadraticModel(prefix='g_')
y = -0.2 + 3.0*x + 0.005*x**2
pars = mod.guess(y, x=x)
assert_allclose(pars['g_a'].value, 0.005, rtol=0.01)
assert_allclose(pars['g_b'].value, 3.0, rtol=0.01)
assert_allclose(pars['g_c'].value, -0.2, rtol=0.01)
def setUp(self):
self.true_values = lambda: dict(c=5)
self.guess = lambda: dict(c=2)
self.model_constructor = models.ConstantModel
super().setUp()
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)
DonaichModel, PowerLawModel, ExponentialModel,
StepModel, RectangleModel)
from .models import (GaussianModel, LorentzianModel, Lorentzian2Model,
ComptonModel, ElasticModel)
from lmfit.lineshapes import (pearson7, breit_wigner, damped_oscillator,
logistic, lognormal, students_t, expgaussian,
donaich, skewed_gaussian, skewed_voigt, step,
rectangle, exponential, powerlaw, linear,
parabolic)
from .lineshapes import (gaussian, lorentzian, lorentzian2, voigt, pvoigt,
gaussian_tail, gausssian_step, elastic, compton)
# valid models
model_list = [ConstantModel, LinearModel, QuadraticModel, ParabolicModel,
PolynomialModel, GaussianModel, LorentzianModel, VoigtModel,
PseudoVoigtModel, Pearson7Model, StudentsTModel, BreitWignerModel,
LognormalModel, DampedOscillatorModel, ExponentialGaussianModel,
SkewedGaussianModel, DonaichModel, PowerLawModel,
ExponentialModel, StepModel, RectangleModel, Lorentzian2Model,
ComptonModel, ElasticModel]
model_list.sort(key=lambda s: str(s).split('.')[-1])
lineshapes_list = [gaussian, lorentzian, voigt, pvoigt, pearson7,
breit_wigner, damped_oscillator, logistic,
lognormal, students_t, expgaussian, donaich,
skewed_gaussian, skewed_voigt, step, rectangle,
exponential, powerlaw, linear, parabolic,
lorentzian2, compton, elastic, gausssian_step,
if ln_sty is None:
ln_sty = dict()
ax.set_title(title)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
txt = ax.annotate('', (0, 0), xytext=(1, 1), xycoords='axes fraction')
ln_sty = 'bo-'
if fit:
ln_sty = 'bo'
ln, = ax.plot([], [], ln_sty)
if fit:
ln2, = ax.plot([], [], 'g-')
m = GaussianModel() + lmfit.models.ConstantModel()
param = m.make_params()
for k in param:
param[k].value = 1
param['area'].min = 1
param['area'].max = 150
param['sigma'].min = 1
param['sigma'].max = 150
param['center'].min = 0
param['center'].max = 150
time_tracker = {'old': time.time()}
def inner(y, x):
'''
Update line with this data. relim, autoscale, trigger redraw
def __init__(self, independent_vars=['x'], prefix='', nan_policy='raise',
**kwargs):
kwargs.update({'prefix': prefix, 'nan_policy': nan_policy,
'independent_vars': independent_vars})
def constant(x, c=0.0):
return c
super(ConstantModel, self).__init__(constant, **kwargs)