def fit_data_exponential_curve(
covid19_data: pd.DataFrame,
parent_region: str,
region: str,
data_set: str = "confirmed",
) -> Dict[str, Union[lmfit.model.ModelResult, pd.DataFrame]]:
"""
Implementation of fit_data_model, with setting specific to
the exponential curve model
Parameters
----------
covid19_data : pd.DataFrame
Full covid19 data from a data_source
parent_region : str
parent_region of the data which should be fitted,
needs to be in covid19_region_data.parent_region
region : str
region which data should be fired, needs to be in covid19_region_data.region
data_set : str, optional
which subdata schold be fitted, need to be of value
["confirmed", "recovered", deaths], by default "confirmed"
Returns
-------
Dict[str, Union[lmfit.model.ModelResult, pd.DataFrame]]
Result dict with keys "model_result" and "plot_data".
model_result: lmfit.model.ModelResult
result of the fit, with optimized parameters
plot_data: pd.DataFrame
Same as covid19_region_data, but with an resetted index and
and added fir result
See Also
--------
fit_data_model
"""
def exp_func(x, amplitude=1, decay=1):
return amplitude * np.exp(-x / decay)
data_selector = (covid19_data.region
== region) & (covid19_data.parent_region == parent_region)
covid19_region_data = covid19_data.loc[data_selector, :].reset_index(
drop=True)
current_max = covid19_region_data[data_set].max()
init_params = {
"amplitude": current_max * 1e-3,
"decay": -covid19_region_data.shape[0] / 7,
}
exp_model = ExponentialModel()
exp_model.func = exp_func
fit_result = fit_data_model(
covid19_region_data,
exp_model,
data_set=data_set,
init_params=init_params,
)
return fit_result
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()
def get_model(self):
self.x = np.array([0, 1, 2, 6, 12, 24])
self.y = np.array(self.norm_vals)
# Compound model with Voigt curve.
self.background = ExponentialModel(prefix='b_')
self.pars = self.background.guess(self.y, x=self.x)
self.peak = VoigtModel(prefix='p_')
self.pars += self.peak.guess(self.y, x=self.x)
self.comp_mod = self.peak + self.background
self.init = self.comp_mod.eval(self.pars, x=self.x)
self.comp_out = self.comp_mod.fit(
self.y, x=self.x,
fit_kws={'nan_policy': 'propagate'
}) # instead of 'omit', it keeps up the zero vals.
self.comp_list = self.comp_out.fit_report().split('\n')
self.comp_chisq = float(self.comp_list[6][-5:])
self.out = self.comp_out
self.chisq = float(self.comp_list[6][-5:])
self.usedmod = self.comp_mod
self.model_flag = "composite (exponential+Voigt)"
return self.comp_out, self.comp_chisq, self.out, self.chisq, self.usedmod, self.model_flag
def predictive_model(data: pd.DataFrame,
interesting_rows,
day_zero_n_patients: int = 20,
days_in_future: int = 30,
aggregated: bool = False):
data = data[interesting_rows].iloc[:, :]
from lmfit.models import StepModel, ExponentialModel
fig = plt.figure(figsize=(10, 5))
for c in range(len(data.index)):
if aggregated:
values = data.values[c, 4:][data.iloc[c, 4:] > day_zero_n_patients]
else:
values = np.concatenate(
([0],
np.diff(
data.values[c,
4:][data.iloc[c, 4:] > day_zero_n_patients])))
n = values.shape[0]
x = np.asarray(range(values.shape[0]), dtype='float64')
y = np.asarray(values, dtype='float64')
if len(x) == 0:
continue
label = "{}-{}".format(data.values[c, 0], data.values[c, 1])
plt.plot(x, y, label=label)
if data.values[c, 1] in ["China", "US"]:
continue
try:
model_step = StepModel()
model_exp = ExponentialModel()
params_step = model_step.guess(y, x=x)
params_exp = model_exp.guess(y, x=x)
result_step = model_step.fit(y, params_step, x=x)
result_exp = model_exp.fit(y, params_exp, x=x)
except Exception:
continue
x_pred = np.asarray(range(days_in_future))
plt.plot(x_pred,
model_step.eval(result_step.params, x=x_pred),
':',
label='fit-{}'.format(label))
plt.plot(x_pred,
model_exp.eval(result_exp.params, x=x_pred),
'.',
label='fit-{}'.format(label))
# print(result.fit_report())
# result.plot_fit()
plt.legend(prop={"size": 7})
plt.yscale('log')
plt.xticks(rotation=45)
plt.grid(which='both')
now = datetime.now()
dt_string = now.strftime("%d%m%Y-%H%M%S")
def exponential_fit(x, y, errors=True):
from lmfit.models import ExponentialModel
mod = ExponentialModel()
par = mod.guess(data=y, x=x)
out = mod.fit(y, params=par, x=x)
a = out.params['amplitude']
d = out.params['decay']
return a, d
def exponential_fit(x, y, errors=True):
from lmfit.models import ExponentialModel
mod = ExponentialModel()
par = mod.guess(data=y, x=x)
out = mod.fit(y, params=par, x=x)
a = out.params["amplitude"]
d = out.params["decay"]
return a, d
def prepare_model(nexp):
emodel = ConstantModel() + ExponentialModel(prefix='a') + ExponentialModel(
prefix='b')
pars.add('e', value=0, min=0)
pars.add('cntrl', value=1, min=1 - 1e-5, max=1 + 1e-5)
pars['cntrl'].expr = 'c'
pars['cntrl'].vary = True
expr = '{}amplitude'
all_expr = ''
for i in range(1, 1):
pars['cntrl'].expr += ' + ' + expr.format(Prefixes[i])
return emodel, pars
def predict_detector_position(datatable=None, target=20500):
dt = array(datatable)
mod = ExponentialModel()
prediction = []
for i in range(1, 5):
signal = dt[:, i]
pars = mod.guess(signal, x=dt[:, 0])
out = mod.fit(signal, pars, x=dt[:, 0])
#out.plot()
#print(whisper(out.fit_report(min_correl=0)))
amp = out.params['amplitude']
tau = out.params['decay']
prediction.append(ceil(tau * log(amp / target)))
#print(go_msg(f'predictions are {prediction}'))
return prediction
def get_model(self):
self.x = np.array([0, 1, 2, 6, 12, 24])
self.y = np.array(self.norm_vals)
#x = np.array([0,1,2,6,12,24])
# Exponential model for reference
self.exp_mod = ExponentialModel(prefix='onlye_')
self.pars = self.exp_mod.guess(self.y, x=self.x)
self.init = self.exp_mod.eval(self.pars, x=self.x)
self.exp_out = self.exp_mod.fit(self.y, x=self.x, missing='drop')
self.exp_list = self.exp_out.fit_report().split('\n')
self.exp_chisq = float(self.exp_list[6][-5:])
return self.exp_out, self.exp_chisq
def test_numdifftools_no_bounds(fit_method):
pytest.importorskip("numdifftools")
np.random.seed(7)
x = np.linspace(0, 100, num=50)
noise = np.random.normal(scale=0.25, size=x.size)
y = exponential(x, amplitude=5, decay=15) + noise
mod = ExponentialModel()
params = mod.guess(y, x=x)
# do fit, here with leastsq model
result = mod.fit(y, params, x=x, method='leastsq')
result_ndt = mod.fit(y, params, x=x, method=fit_method)
# assert that fit converged to the same result
vals = [result.params[p].value for p in result.params.valuesdict()]
vals_ndt = [
result_ndt.params[p].value for p in result_ndt.params.valuesdict()
]
assert_allclose(vals_ndt, vals, rtol=0.1)
assert_allclose(result_ndt.chisqr, result.chisqr, rtol=1e-5)
# assert that parameter uncertaintes from leastsq and calculated from
# the covariance matrix using numdifftools are very similar
stderr = [result.params[p].stderr for p in result.params.valuesdict()]
stderr_ndt = [
result_ndt.params[p].stderr for p in result_ndt.params.valuesdict()
]
perr = np.array(stderr) / np.array(vals)
perr_ndt = np.array(stderr_ndt) / np.array(vals_ndt)
assert_almost_equal(perr_ndt, perr, decimal=3)
# assert that parameter correlatations from leastsq and calculated from
# the covariance matrix using numdifftools are very similar
for par1 in result.var_names:
cor = [
result.params[par1].correl[par2]
for par2 in result.params[par1].correl.keys()
]
cor_ndt = [
result_ndt.params[par1].correl[par2]
for par2 in result_ndt.params[par1].correl.keys()
]
assert_almost_equal(cor_ndt, cor, decimal=2)
def fit_exponential(x, y):
"""
Fits a data set to an exponential with a constant offset, returns best-fit
parameters: `amplitude`, `decay,` and `c`
Args:
x (numpy.ndarray): A one-dimensional real-valued numpy array, the independent variable
y (numpy.ndarray): A one-dimensional real-valued numpy array, the dependent variable.
Returns:
type: lmfit.model.ModelResult
"""
em = ExponentialModel()
exponential_fit_result = em.fit(
y,
x=x,
)
return exponential_fit_result
def create_model_params(x, y):
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(105, min=75, max=125)
params['g1_sigma'].set(15, min=3)
params['g1_amplitude'].set(2000, min=10)
params['g2_center'].set(155, min=125, max=175)
params['g2_sigma'].set(15, min=3)
params['g2_amplitude'].set(2000, min=10)
model = gauss1 + gauss2 + exp_mod
return model, params
def fit_peak(wl, np_x, np_y, with_plot=True, plot_components=False):
''' Fit one peak
wl wavelength
x axis values as a numpy array
y axis values as a numpy array
'''
i_min = len(np_x)-sum(np_x>wl) - 10
i_max = len(np_x)-sum(np_x>wl) + 10
x = np_x[i_min:i_max]
many_x = np.arange(x[0], x[-1], 0.01)
y = np_y[i_min:i_max]
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(wl, min=wl-5, max=wl+5)
pars['g1_sigma'].set(1, min=0.01)
pars['g1_amplitude'].set(50000, min=10)
mod = gauss1 + exp_mod
# init = mod.eval(pars, x=many_x)
out = mod.fit(y, pars, x=x)
comps = out.eval_components(x=many_x)
print(out.fit_report(min_correl=0.5))
print('Gaussian line model')
try:
print('Mean={:.2f}+/-{:.2f}\tFWHM={:.2f}+/-{:.2f}'.format(
out.params['g1_center'].value, out.params['g1_center'].stderr,
out.params['g1_fwhm'].value, out.params['g1_fwhm'].stderr))
except:
print('Fit did not converge')
if with_plot:
fig = plt.figure()
out.plot(fig=fig, numpoints=100)
plt.show()
return out
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 gaussPlusExp(self, g1):
result, modGauss1 = self.singleGauss(g1)
#update statements like this are used through each higher order function
#This keeps all minimised parameters updated at each interval
g1_sigma = result.best_values['g1_sigma']
modExpon = ExponentialModel(prefix='exp_')
model = modExpon + modGauss1
params = model.make_params(g1_amplitude=g1['amp'],
g1_center=g1['mu'],
g1_sigma=g1_sigma)
result = model.fit(self.yData, params, x=self.xData)
return result, modExpon, modGauss1
def test_numdifftools_no_bounds(fit_method):
pytest.importorskip("numdifftools")
np.random.seed(7)
x = np.linspace(0, 100, num=50)
noise = np.random.normal(scale=0.25, size=x.size)
y = exponential(x, amplitude=5, decay=15) + noise
mod = ExponentialModel()
params = mod.guess(y, x=x)
# do fit, here with leastsq model
result = mod.fit(y, params, x=x, method='leastsq')
result_ndt = mod.fit(y, params, x=x, method=fit_method)
# assert that fit converged to the same result
vals = [result.params[p].value for p in result.params.valuesdict()]
vals_ndt = [result_ndt.params[p].value for p in result_ndt.params.valuesdict()]
assert_allclose(vals_ndt, vals, rtol=0.1)
assert_allclose(result_ndt.chisqr, result.chisqr, rtol=1e-5)
# assert that parameter uncertaintes from leastsq and calculated from
# the covariance matrix using numdifftools are very similar
stderr = [result.params[p].stderr for p in result.params.valuesdict()]
stderr_ndt = [result_ndt.params[p].stderr for p in result_ndt.params.valuesdict()]
perr = np.array(stderr) / np.array(vals)
perr_ndt = np.array(stderr_ndt) / np.array(vals_ndt)
assert_almost_equal(perr_ndt, perr, decimal=3)
# assert that parameter correlatations from leastsq and calculated from
# the covariance matrix using numdifftools are very similar
for par1 in result.var_names:
cor = [result.params[par1].correl[par2] for par2 in
result.params[par1].correl.keys()]
cor_ndt = [result_ndt.params[par1].correl[par2] for par2 in
result_ndt.params[par1].correl.keys()]
assert_almost_equal(cor_ndt, cor, decimal=2)
def get_model(self):
self.x = np.array([0, 1, 2, 6, 12, 24])
self.y = np.array([self.norm_vals])
self.peak = GaussianModel(prefix='g_')
self.background = ExponentialModel(prefix='e_')
self.comp_mod = self.peak + self.background
#guess?pars?
#pars = exp_mod.guess(y, x=x)
#pars = gauss_mod.guess(y, x=x)
#pars += step_mod.guess()
#pars.update(gauss1.make_params())
#init = mod.eval(pars, x=x)
self.comp_out = self.comp_mod.fit(self.y,
x=self.x,
fit_kws={'nan_policy': 'omit'})
self.comp_list = self.comp_out.fit_report().split('\n')
self.comp_chisq = float(self.comp_list[6][-5:])
self.exp_mod = ExponentialModel(prefix='onlye_')
self.exp_out = self.exp_mod.fit(self.y, x=self.x, missing='drop')
self.exp_list = self.exp_out.fit_report().split('\n')
self.exp_chisq = float(self.exp_list[6][-5:])
if np.count_nonzero(np.isinf(self.comp_out.best_fit)) == 5:
self.out = self.exp_out
elif self.comp_chisq < self.exp_chisq:
self.out = self.comp_out
elif self.comp_chisq == self.exp_chisq:
self.out = self.comp_out
elif self.comp_chisq > self.exp_chisq:
self.out = self.exp_out
return self.comp_out, self.comp_chisq, self.exp_out, self.exp_chisq, self.out
def single_taufit(self, x, y, t0, t1):
"""
Perform single exponential fit to voltage traces
Parameters
----------
x : numpy array
time corresponding to data in y
y : numpy array
voltage trace (single trace)
t0 : float
start time for fit (ms)
t1 : float
end time for fit (ms)
Returns
-------
tuple of (best fit parameters as dict, x times, best fit y values)
If fit fails, return is (None, None, None)
"""
(cx, cy) = pu.clipdata(y, x, t0, t1, minFlag = False)
expmodel = ExponentialModel() #, prefix='', missing=None, name=None, **kwargs)
expmodel.set_param_hint('decay', min=0.1, max=50.0)
cye = np.mean(cy[-5:])
try:
result = expmodel.fit(cy-cye, x=cx-t0, amplitude=0., decay=10.)
if verbose:
print(result.fit_report()) # print the result
rbv = result.best_values
fitr = {'a': 0, 'tau': 5., 'dc': 0.}
fitr['a'] = rbv['amplitude']
fitr['tau'] = rbv['decay']
return fitr, cx, result.best_fit+cye
except:
return None, None, None
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()
def model_resetting(self):
if self.peak_flag != "Resetting":
#go for the previous method
pass
elif self.peak_flag == "Resetting":
# mostly for plotting, half-life needs new zeros
self.scnd_peak = np.sort(self.bestfit)[-2]
self.scnd_idx = np.argsort(self.bestfit)[-2]
self.newzero = self.x[self.scnd_idx]
# Cutting the new time scale, reset to 0.
self.x2 = np.array(
[i - self.newzero for i in self.x[self.scnd_idx:]])
#x2 = np.array([i for i in x[scnd_idx:]])
# Re-normalized and cutted array
self.y2 = np.array(
[i / self.y[self.scnd_idx] for i in self.y[self.scnd_idx:]])
#newarray = myarray[scnd_idx:]
self.exp_mod = ExponentialModel(prefix='e_')
self.pars = self.exp_mod.guess(self.y2, x=self.x2)
self.init = self.exp_mod.eval(self.pars, x=self.x2)
self.exp_out = self.exp_mod.fit(self.y2, x=self.x2, missing='drop')
self.exp_list = self.exp_out.fit_report().split('\n')
self.exp_chisq = float(self.exp_list[6][-5:])
self.out = self.exp_out
self.chisq = float(self.exp_list[6][-5:])
self.usedmod = self.exp_mod
self.bestfit = self.exp_out.best_fit
self.idx = np.argmin(np.abs(self.bestfit - 0.5))
self.mysort = np.argsort(np.abs(self.bestfit - 0.5))
self.peak_flag = None
if self.bestfit[self.idx] < 0.5:
self.min = self.x2[self.idx - 1]
self.max = self.x2[self.idx]
self.peak_flag = "Resetted exponential"
elif self.bestfit[self.idx] > 0.5:
self.min = self.x2[self.idx]
self.max = self.x2[self.idx + 1]
self.peak_flag = "Resetted exponential"
# For printing.
if len(self.bestfit) < 6:
l = [self.bestfit[-1]] * (6 - len(self.bestfit))
self.bestfit = np.append(self.bestfit, l)
self.x = self.x2
self.y = self.y2
self.model_flag = "exponential"
return self.min, self.max, self.peak_flag, self.bestfit, self.x, self.out, self.chisq, self.usedmod, self.model_flag
import matplotlib.pyplot as plt
import numpy as np
from lmfit.models import ExponentialModel, GaussianModel, Model
import lmfit
print(lmfit.__version__)
lmfit.models.ModelRe
dat = np.loadtxt('NIST_Gauss2.dat')
x = dat[:, 1]
y = dat[:, 0]
model = ExponentialModel(prefix='exp_')
model.set_param_hint('amplitude', value=10)
model.set_param_hint('decay', value=10)
model += GaussianModel(prefix='g1_')
model.set_param_hint('g1_center', value=105, min=75, max=125)
model.set_param_hint('g1_sigma', value=15, min=3)
model.set_param_hint('g1_amplitude', value=2000, min=10)
model += GaussianModel(prefix='g2_')
model.set_param_hint('g2_center', value=155, min=125, max=175)
model.set_param_hint('g2_delta_sigma', value=1.5, min=0.8)
model.set_param_hint('g2_sigma', expr='g2_delta_sigma*g1_sigma')
model.set_param_hint('g2_amplitude', value=2000, min=10)
pars = model.make_params()
init = model.eval(pars, x=x)
out = model.fit(y, pars, x=x)
print(out.fit_report(min_correl=0.5))
def expModel(self, stateCode):
from lmfit.models import ExponentialModel
model = ExponentialModel()
return self.guessAndFit(model, stateCode, lambda x: x.dropna())
def calculate_feature(image_path,
value=[1, 0, 0, 0, 1, 0],
return_image=False):
debug_image = []
image = cv2.imread(image_path)
from detector_borde_plastico import detector_borde_plastico
image_bp, images_dp_debug = detector_borde_plastico(image)
debug_image.extend(images_dp_debug)
#features = [mask_pasto == 1]
"""
image_kmeans = kmeans(image_bottom_lab, K=40)
image_kmeans_rgb = cv2.cvtColor(image_kmeans, cv2.COLOR_LAB2BGR)
debug_image.append(image_kmeans_rgb)
image_kmeans_rgb_cut = image_kmeans_rgb[0:image_kmeans_rgb.shape[0], int(image_kmeans_rgb.shape[1]*0.167):int(image_kmeans_rgb.shape[1]*0.905)]
debug_image.append(image_kmeans_rgb_cut)
image_kmeans2 = kmeans(image_kmeans_rgb_cut, K=5)
#image_kmeans2_rgb = cv2.cvtColor(image_kmeans2, cv2.COLOR_LAB2BGR)
debug_image.append(image_kmeans2)
lowerBound = np.array(value[0:3])*255.0
upperBound = np.array(value[3:6])*255.0
# this gives you the mask for those in the ranges you specified,
# but you want the inverse, so we'll add bitwise_not...
image_inrange = cv2.inRange(image_kmeans2, lowerBound, upperBound)
image_inrange_color = cv2.bitwise_not(image_kmeans_rgb_cut, mask=image_inrange)
debug_image.append(image_inrange_color)
"""
"""
cv2.kmeans(image_bottom_lab, 40, )
from sklearn.cluster import MiniBatchKMeans
image_bottom_lab_reshape = image_bottom_lab.reshape((image_bottom_lab.shape[0] * image_bottom_lab.shape[1], 3))
clt = MiniBatchKMeans(n_clusters=10)
labels = clt.fit_predict(image_bottom_lab_reshape)
quant = clt.cluster_centers_.astype("uint8")[labels]
quant = quant.reshape(image_bottom_lab.shape)
image_bottom_lab_res = image_bottom_lab_reshape.reshape(image_bottom_lab.shape)
# convert from L*a*b* to RGB
quant = cv2.cvtColor(quant, cv2.COLOR_LAB2BGR)
image_bottom_lab_res = cv2.cvtColor(image_bottom_lab_res, cv2.COLOR_LAB2BGR)
sobelx64f = cv2.Sobel(image_bottom, cv2.CV_64F, 1, 0, ksize=3)
abs_sobel64f = np.absolute(sobelx64f)
sobel_8u = np.uint8(abs_sobel64f)
lowerBound = np.array(value[0:3])*255.0
upperBound = np.array(value[3:6])*255.0
# this gives you the mask for those in the ranges you specified,
# but you want the inverse, so we'll add bitwise_not...
image_inrange = cv2.inRange(sobel_8u, lowerBound, upperBound)
image_inrange_color = cv2.bitwise_not(image_bottom, mask=image_inrange)
features = image.flatten()[:500]
debug_image.append(image_bottom)
debug_image.append(sobel_8u)
debug_image.append(image_inrange)
debug_image.append(image_inrange_color)
debug_image.append(quant)
debug_image.append(image_bottom_lab_res)
"""
x = []
y = []
for x_ in xrange(mask_pasto.shape[1]):
for y_ in xrange(10, mask_pasto.shape[0]):
if mask_pasto[y_, x_] == 255:
x.append(x_)
y.append(y_)
break
x = np.array(x)
y = np.array(y)
x1 = x[x < (mask_pasto.shape[1] / 2)]
y1 = y[x < (mask_pasto.shape[1] / 2)]
x1 = x1[y1 > (mask_pasto.shape[0] / 2)]
y1 = y1[y1 > (mask_pasto.shape[0] / 2)]
y1 = y1.max() - y1
x = x - x[0] # x offset
mask_pasto2 = np.zeros(thresh.shape, np.uint8)
for i in xrange(len(x1)):
mask_pasto2[y1[i], x1[i]] = 255
debug_image.append(mask_pasto2)
x2 = x[x > (mask_pasto.shape[1] / 2)]
y2 = y[x > (mask_pasto.shape[1] / 2)]
y2 = y2 - y2.max()
from lmfit.models import ExponentialModel
exp_mod = ExponentialModel(prefix='exp_')
pars = exp_mod.guess(y1, x=x1)
out = exp_mod.fit(y, pars, x=x)
print "error en amplitud:", out.params['exp_amplitude'].stderr,
print "error en decay:", out.params['exp_decay'].stderr,
features = np.array(
[out.best_values['exp_decay'], out.params['exp_decay'].stderr])
#print(out.fit_report(min_correl=0.5))
#print pars
if return_image:
return features, debug_image
return features
#!/usr/bin/env python
#<examples/doc_nistgauss2.py>
import numpy as np
from lmfit.models import GaussianModel, ExponentialModel
import matplotlib.pyplot as plt
dat = np.loadtxt('NIST_Gauss2.dat')
x = dat[:, 1]
y = dat[:, 0]
exp_mod = ExponentialModel(prefix='exp_')
gauss1 = GaussianModel(prefix='g1_')
gauss2 = GaussianModel(prefix='g2_')
def index_of(arrval, value):
"return index of array *at or below* value "
if value < min(arrval): return 0
return max(np.where(arrval<=value)[0])
ix1 = index_of(x, 75)
ix2 = index_of(x, 135)
ix3 = index_of(x, 175)
pars1 = exp_mod.guess(y[:ix1], x=x[:ix1])
pars2 = gauss1.guess(y[ix1:ix2], x=x[ix1:ix2])
pars3 = gauss2.guess(y[ix2:ix3], x=x[ix2:ix3])
pars = pars1 + pars2 + pars3
mod = gauss1 + gauss2 + exp_mod
def add_exp(self):
self.nexp += 1
self.model += ExponentialModel(prefix=Prefixes[self.nexp])
def calculateQ_2peaks(filename, time, taper, lambda0, slope,
modulation_coefficient, rg):
q = readlvm(filename)
q = q.ravel()
q = q / taper - 1
valley = q.min()
valley_index = np.argmin(q)
max_height = -1 * q[valley_index]
q_valley = q[valley_index - rg:valley_index + rg]
l_valley = time[valley_index - rg:valley_index + rg]
q_valley = q_valley * -1
peaks, peak_info = find_peaks(q_valley,
height=max_height * 0.6,
prominence=0.05,
distance=50)
#results_half = peak_widths(q_valley, peaks, rel_height=0.5)
if len(peaks) != 2:
print("Wrong peaks with num:", len(peaks))
return None, None, None, None, None, None
x = np.asarray(list(range(0, 2 * rg)))
y = q_valley
# One peak guess to get width
g_mod = LorentzianModel()
g_pars = g_mod.guess(y, x=x)
g_out = g_mod.fit(y, g_pars, x=x)
g_res = g_out.fit_report()
g_info = g_res.split("\n")
g_variables = parse_info(g_info, 1)
guessedWidth = float(g_variables['fwhm']) / 2
exp_mod = ExponentialModel(prefix='exp_')
pars = exp_mod.guess(y, x=x)
lorenz1 = LorentzianModel(prefix='l1_')
pars.update(lorenz1.make_params())
pars['l1_center'].set(peaks[0])
pars['l1_sigma'].set(guessedWidth)
pars['l1_amplitude'].set(np.pi * guessedWidth * q_valley[peaks[0]])
lorenz2 = LorentzianModel(prefix='l2_')
pars.update(lorenz2.make_params())
pars['l2_center'].set(peaks[1])
pars['l2_sigma'].set(guessedWidth)
pars['l2_amplitude'].set(np.pi * guessedWidth * q_valley[peaks[1]])
mod = lorenz1 + lorenz2 + exp_mod
init = mod.eval(pars, x=x)
out = mod.fit(y, pars, x=x)
res = out.fit_report()
info = res.split("\n")
variables = parse_info(info, 2)
l1_h_res, l1_w_res, l1_c_res = variables['l1_height'], variables[
'l1_fwhm'], variables['l1_center']
print(l1_h_res, l1_w_res, l1_c_res)
l1 = lambda0 + l_valley[int(
float(l1_c_res))] * slope * modulation_coefficient
d_lambda1 = (l_valley[1] - l_valley[0]
) * float(l1_w_res) * slope * modulation_coefficient
Q1 = l1 / d_lambda1
l2_h_res, l2_w_res, l2_c_res = variables['l2_height'], variables[
'l2_fwhm'], variables['l2_center']
print(l2_h_res, l2_w_res, l2_c_res)
l2 = lambda0 + l_valley[int(
float(l2_c_res))] * slope * modulation_coefficient
d_lambda2 = (l_valley[1] - l_valley[0]
) * float(l2_w_res) * slope * modulation_coefficient
Q2 = l2 / d_lambda2
return Q1, float(l1_h_res) * 100, l1, Q2, float(l2_h_res) * 100, l2
amps.append(np.array(amp))
amps_std.append(np.array(amp_err))
print(o_i.fit_report(min_correl=0.5))
amps = np.vstack(amps)
amps_std = np.vstack(amps_std)
#print(out.fit_report(min_correl=0.5))
##ax.plot_wireframe(X, Y, Z_noise.reshape(50,50),color="r")
#ax.plot_wireframe(X, Y, Z_conv.reshape(50,50),color="r")
ax.plot_wireframe(X, Y, test_data_noise.reshape(50, 50), color="r")
colors = ["r", "g", "b", "orange", "k", "c"]
#for i,c in zip(exp_test_data,colors):
# ax.plot_wireframe(X, Y, i.reshape(50,50),color=c)
ax.plot_wireframe(X, Y, out.best_fit.reshape(50, 50), color="b")
##ax.contour(X,Y,Z)
ax.set_ylabel("y")
ax.set_xlabel("x")
plt.show()
t = np.arange(6)
for i in range(len(exp_test_data)):
mod = ExponentialModel()
pars = mod.guess(amps[:, i], x=t)
fit = mod.fit(amps[:, i], pars, x=t)
plt.errorbar(t, amps[:, i], yerr=amps_std[:, i], fmt="ro")
plt.plot(t, fit.best_fit, "k--")
plt.show()
import matplotlib.pyplot as plt
import numpy as np
from lmfit.models import ExponentialModel, GaussianModel
N = 80
# dat = np.loadtxt('Gauss2.dat')
x = np.linspace(0, 40, N, endpoint=False)
y1 = np.exp(-x)
y2 = np.exp(-5 * x)
y = y1 + y2
# plt.plot(x, y1, 'b')
# plt.plot(x, y2, 'k--')
# plt.plot(x, y , 'r-')
# plt.show()
exp1 = ExponentialModel(prefix='e1_')
exp2 = ExponentialModel(prefix='e2_')
pars1 = exp1.guess(y, x=x)
pars2 = exp2.guess(y, x=x)
# pars1 = exp_mod.guess(y[:ix1], x=x[:ix1])
# pars2 = gauss1.guess(y[ix1:ix2], x=x[ix1:ix2])
# pars3 = gauss2.guess(y[ix2:ix3], x=x[ix2:ix3])
pars = pars1 + pars2
mod = exp1 + exp2
out = mod.fit(y, pars, x=x)
print(out.fit_report(min_correl=0.5))
def get_model(self):
self.x = np.array([0,1,2,6,12,24])
self.y = np.array(self.norm_vals)
self.model_flag = None
self.model_list = []
# First model with Gaussian curve.
self.background1 = ExponentialModel(prefix='e1_')
self.pars1 = self.background1.guess(self.y, x=self.x)
self.peak1 = GaussianModel(prefix='p1_')
self.pars1 += self.peak1.guess(self.y, x=self.x)
self.comp_mod1 = self.peak1 + self.background1
self.init1 = self.comp_mod1.eval(self.pars1, x=self.x)
self.comp_out1 = self.comp_mod1.fit(self.y, x=self.x, fit_kws={'nan_policy': 'omit'})
self.comp_list1 = self.comp_out1.fit_report().split('\n')
self.comp_chisq1 = float(self.comp_list1[6][-5:])
# Second model with Voigt curve.
self.background2 = ExponentialModel(prefix='e2_')
self.pars2 = self.background2.guess(self.y, x=self.x)
self.peak2 = VoigtModel(prefix='p2_')
self.pars2 += self.peak2.guess(self.y, x=self.x)
self.comp_mod2 = self.peak2 + self.background2
self.init2 = self.comp_mod2.eval(self.pars2, x=self.x)
self.comp_out2 = self.comp_mod2.fit(self.y, x=self.x, fit_kws={'nan_policy': 'omit'})
self.comp_list2 = self.comp_out2.fit_report().split('\n')
self.comp_chisq2 = float(self.comp_list2[6][-5:])
# Exponential model for reference
self.exp_mod = ExponentialModel(prefix='onlye_')
self.pars = self.exp_mod.guess(self.y, x=self.x)
self.init = self.exp_mod.eval(self.pars, x=self.x)
self.exp_out = self.exp_mod.fit(self.y, x=self.x, missing='drop')
self.exp_list = self.exp_out.fit_report().split('\n')
self.exp_chisq = float(self.exp_list[6][-5:])
self.model_list = [self.comp_chisq1, self.comp_chisq2, self.exp_chisq]
if np.count_nonzero(np.isinf(self.comp_out1.best_fit)) == 5 and np.count_nonzero(np.isinf(self.comp_out2.best_fit)):
model_flag = "exponential"
self.out = self.exp_out
elif len(self.model_list) == len(set(self.model_list)):
if min(self.model_list) == self.comp_chisq1:
self.model_flag = "Gaussian compound"
self.out = self.comp_out1
elif min(self.model_list) == self.comp_chisq2:
self.model_flag = "Voigt compound"
self.out = self.comp_out2
elif min(self.model_list) == self.exp_chisq:
self.model_flag = "exponential"
self.out = self.exp_out
elif len(self.model_list) != len(set(self.model_list)):
if min(self.model_list) == self.comp_chisq1:
self.model_flag = "Gaussian compound"
self.out = self.comp_out1
elif min(self.model_list) == self.comp_chisq2:
self.model_flag = "Voigt compound"
self.out = self.comp_out2
elif min(self.model_list) == self.exp_chisq:
self.model_flag = "exponential"
self.out = self.exp_out
if min(self.model_list) == self.comp_chisq1 and self.comp_chisq1 == self.comp_chisq2:
self.model_flag = "Both compounds"
self.out = self.comp_out2
if min(self.model_list) == self.comp_chisq2 and self.comp_chisq2 == self.exp_chisq:
self.model_flag = "Voigt compound and exponential"
self.out = self.comp_out2
if min(self.model_list) == self.exp_chisq and self.exp_chisq == self.comp_chisq1:
self.model_flag = "Gaussian compound and exponential"
self.out = self.comp_out1
return self.comp_out1, self.comp_chisq1, self.comp_out2, self.comp_chisq2, self.exp_out, self.exp_chisq, self.model_flag
def calculate_feature2(image_path, value=[1,0,0,0,1,0], return_image=False):
debug_image = []
image = cv2.imread(image_path)
from detector_borde_plastico import detector_borde_plastico
image_bp, images_dp_debug = detector_borde_plastico(image)
debug_image.extend(images_dp_debug)
image_bottom = image_bp[int(0.7*image_bp.shape[0]):image_bp.shape[0],:,:]
#image_sharr = cv2.Scharr(image_bottom, cv2.CV_32F, 2, 0)
image_bottom_lab = cv2.cvtColor(image_bottom, cv2.COLOR_BGR2LAB)
#features = image_bottom_lab.flatten()[:500]
#debug_image.append(image_bottom_lab[:,:,0])
#debug_image.append(image_bottom_lab[:,:,2])
image_lab_a = image_bottom_lab[:, :, 1]
image_lab_b = image_bottom_lab[:, :, 2]
debug_image.append(image_lab_a)
debug_image.append(image_lab_b)
thresh = cv2.threshold(image_lab_a, 0, 255,
cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
#debug_image.append(thresh)
_, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# bigest_area = amg
max_area = 0
for cnt in contours:
area = cv2.contourArea(cnt)
if max_area < area:
max_area = area
biggest_area = cnt
"""
# points = [(100,h1[1][1]-h1[0][1]-5), (200, h1[1][1]-h1[0][1]-5), (300, h1[1][1]-h1[0][1]-5)]
bad = 0
good = 0
for x in xrange(0, th2.shape[1], 10):
p = (x, th2.shape[0] - 5)
if cv2.pointPolygonTest(biggest_area, p, False) <= 0:
bad += 1
else:
good += 1
# print "good:", good, "bad:", bad
isgood = False
if bad < 25:
isgood = True
"""
mask_pasto = np.zeros(thresh.shape, np.uint8)
cv2.drawContours(mask_pasto, [biggest_area], 0, 255, 3)
debug_image.append(mask_pasto)
#features = [mask_pasto == 1]
"""
image_kmeans = kmeans(image_bottom_lab, K=40)
image_kmeans_rgb = cv2.cvtColor(image_kmeans, cv2.COLOR_LAB2BGR)
debug_image.append(image_kmeans_rgb)
image_kmeans_rgb_cut = image_kmeans_rgb[0:image_kmeans_rgb.shape[0], int(image_kmeans_rgb.shape[1]*0.167):int(image_kmeans_rgb.shape[1]*0.905)]
debug_image.append(image_kmeans_rgb_cut)
image_kmeans2 = kmeans(image_kmeans_rgb_cut, K=5)
#image_kmeans2_rgb = cv2.cvtColor(image_kmeans2, cv2.COLOR_LAB2BGR)
debug_image.append(image_kmeans2)
lowerBound = np.array(value[0:3])*255.0
upperBound = np.array(value[3:6])*255.0
# this gives you the mask for those in the ranges you specified,
# but you want the inverse, so we'll add bitwise_not...
image_inrange = cv2.inRange(image_kmeans2, lowerBound, upperBound)
image_inrange_color = cv2.bitwise_not(image_kmeans_rgb_cut, mask=image_inrange)
debug_image.append(image_inrange_color)
"""
"""
cv2.kmeans(image_bottom_lab, 40, )
from sklearn.cluster import MiniBatchKMeans
image_bottom_lab_reshape = image_bottom_lab.reshape((image_bottom_lab.shape[0] * image_bottom_lab.shape[1], 3))
clt = MiniBatchKMeans(n_clusters=10)
labels = clt.fit_predict(image_bottom_lab_reshape)
quant = clt.cluster_centers_.astype("uint8")[labels]
quant = quant.reshape(image_bottom_lab.shape)
image_bottom_lab_res = image_bottom_lab_reshape.reshape(image_bottom_lab.shape)
# convert from L*a*b* to RGB
quant = cv2.cvtColor(quant, cv2.COLOR_LAB2BGR)
image_bottom_lab_res = cv2.cvtColor(image_bottom_lab_res, cv2.COLOR_LAB2BGR)
sobelx64f = cv2.Sobel(image_bottom, cv2.CV_64F, 1, 0, ksize=3)
abs_sobel64f = np.absolute(sobelx64f)
sobel_8u = np.uint8(abs_sobel64f)
lowerBound = np.array(value[0:3])*255.0
upperBound = np.array(value[3:6])*255.0
# this gives you the mask for those in the ranges you specified,
# but you want the inverse, so we'll add bitwise_not...
image_inrange = cv2.inRange(sobel_8u, lowerBound, upperBound)
image_inrange_color = cv2.bitwise_not(image_bottom, mask=image_inrange)
features = image.flatten()[:500]
debug_image.append(image_bottom)
debug_image.append(sobel_8u)
debug_image.append(image_inrange)
debug_image.append(image_inrange_color)
debug_image.append(quant)
debug_image.append(image_bottom_lab_res)
"""
x = []
y = []
for x_ in xrange(mask_pasto.shape[1]):
for y_ in xrange(10, mask_pasto.shape[0]):
if mask_pasto[y_,x_] == 255:
x.append(x_)
y.append(y_)
break
x = np.array(x)
y = np.array(y)
x1 = x[x<(mask_pasto.shape[1]/2)]
y1 = y[x<(mask_pasto.shape[1]/2)]
x1 = x1[y1>(mask_pasto.shape[0]/2)]
y1 = y1[y1>(mask_pasto.shape[0]/2)]
y1 = y1.max() - y1
x = x-x[0] # x offset
mask_pasto2 = np.zeros(thresh.shape, np.uint8)
for i in xrange(len(x1)):
mask_pasto2[y1[i], x1[i]] = 255
debug_image.append(mask_pasto2)
x2 = x[x>(mask_pasto.shape[1]/2)]
y2 = y[x>(mask_pasto.shape[1]/2)]
y2 = y2 - y2.max()
from lmfit.models import ExponentialModel
exp_mod = ExponentialModel(prefix='exp_')
pars = exp_mod.guess(y1, x=x1)
out = exp_mod.fit(y, pars, x=x)
print "error en amplitud:", out.params['exp_amplitude'].stderr,
print "error en decay:", out.params['exp_decay'].stderr,
features = np.array([out.best_values['exp_decay'], out.params['exp_decay'].stderr])
#print(out.fit_report(min_correl=0.5))
#print pars
if return_image:
return features, debug_image
return features
import pandas as pd
from itertools import accumulate
import langevin
A,D = 1.0,1.0
delta_t=0.01
N=1000
M=10000
t_list=[]
tstd_list=[]
A_list=[]
Astd_list=[]
mean_list=[]
std_list=[]
mod = ExponentialModel()
acf_avg=np.zeros(int(N/2))
acf_var=np.zeros(int(N/2))
for i in range(M):
# random force
w=np.random.normal(0,1,N)
x = langevin.time_series(A=A,D=D,delta_t=delta_t,N=N)
# see http://docs.scipy.org/doc/scipy-0.15.1/reference/generated/scipy.signal.fftconvolve.html
# autocorr = signal.fftconvolve(x, x[::-1], mode='full')
f = np.fft.rfft(x)
acf = np.fft.irfft(f * np.conjugate(f))
acf = np.fft.fftshift(acf) / N
autocorr=acf[int(N/2):]
# n=len(autocorr)
# autocorr=autocorr[int((n-1)/2):]*2.0/(n+1)
class gene_set():
def __init__(self, gene_id, cluster):
self.cluster = cluster
self.gene_id = gene_id
self.norm_vals = [
float(y) for y in [x[1:] for x in reference if x[0] == gene_id][0]
] #TPM.
self.get_model()
self.def_peaks()
self.model_resetting()
self.half_life()
#self.printing()
self.saving()
def get_model(self):
self.x = np.array([0, 1, 2, 6, 12, 24])
self.y = np.array(self.norm_vals)
# Compound model with Voigt curve.
self.background = ExponentialModel(prefix='b_')
self.pars = self.background.guess(self.y, x=self.x)
self.peak = VoigtModel(prefix='p_')
self.pars += self.peak.guess(self.y, x=self.x)
self.comp_mod = self.peak + self.background
self.init = self.comp_mod.eval(self.pars, x=self.x)
self.comp_out = self.comp_mod.fit(
self.y, x=self.x,
fit_kws={'nan_policy': 'propagate'
}) # instead of 'omit', it keeps up the zero vals.
self.comp_list = self.comp_out.fit_report().split('\n')
self.comp_chisq = float(self.comp_list[6][-5:])
self.out = self.comp_out
self.chisq = float(self.comp_list[6][-5:])
self.usedmod = self.comp_mod
self.model_flag = "composite (exponential+Voigt)"
return self.comp_out, self.comp_chisq, self.out, self.chisq, self.usedmod, self.model_flag
def def_peaks(self):
self.bestfit = self.comp_out.best_fit
self.idx = np.argmin(np.abs(self.bestfit - 0.5))
self.mysort = np.argsort(np.abs(self.bestfit - 0.5))
self.peak_flag = None
if all(i > 0.5 for i in self.bestfit):
# Meaning that it is never reaching the half-life, and we don't do extrapolation (not enough data points).
self.min = 0
self.max = 0
self.peak_flag = "No predictable half-life"
else:
if self.bestfit[self.idx] == 0.5:
# If by accident one time point hits the half-life.
self.half_life_y = self.bestfit[self.idx]
self.half_life_x = self.idx
self.peak_flag = "Exact compound half-life"
elif self.bestfit[0] > 0.5 and self.bestfit[1] < 0.5:
self.min = self.x[0]
self.max = self.x[1]
self.peak_flag = "Compound"
elif self.idx == 5 and self.bestfit[self.idx - 1] < 0.5:
# Last value crosses only
self.max = self.x[self.idx]
self.min = self.x[self.idx - 1]
self.peak_flag = "Compound"
elif np.abs(self.idx - self.mysort[1]) == 1:
if self.bestfit[self.idx] < 0.5:
self.min = self.x[self.idx - 1]
self.max = self.x[self.idx]
self.peak_flag = "Compound"
elif self.bestfit[self.idx] > 0.5:
self.min = self.x[self.idx]
self.max = self.x[self.idx + 1]
self.peak_flag = "Compound"
elif np.abs(self.idx - self.mysort[1]) > 1:
# Meaning that the steps are not linear, there's a bump.
if self.bestfit[self.idx] < 0.5:
self.min = self.x[self.idx - 1]
self.max = self.x[self.idx]
self.peak_flag = "Compound"
elif self.bestfit[self.idx] > 0.5 and self.bestfit[
self.mysort[1]] < 0.5:
if self.bestfit[self.idx + 1] < 0.5:
self.min = self.x[self.idx]
self.max = self.x[self.idx + 1]
self.peak_flag = "Compound"
#resetting!!
else:
self.min = self.x[self.mysort[1] - 1]
self.max = self.x[self.mysort[1]]
self.peak_flag = "Resetting"
elif self.bestfit[self.idx] > 0.5 and self.bestfit[
self.mysort[1]] > 0.5:
if self.bestfit[self.idx + 1] < 0.5:
self.min = self.x[self.idx]
self.max = self.x[self.idx + 1]
self.peak_flag = "Compound"
#resetting!!
elif self.bestfit[self.idx + 1] > 0.5 and self.bestfit[
self.mysort[1] + 1] < 0.5:
self.min = self.x[self.mysort[1] - 1]
self.max = self.x[self.mysort[1]]
self.peak_flag = "Resetting"
return self.min, self.max, self.peak_flag, self.bestfit
def model_resetting(self):
if self.peak_flag != "Resetting":
#go for the previous method
pass
elif self.peak_flag == "Resetting":
# mostly for plotting, half-life needs new zeros
self.scnd_peak = np.sort(self.bestfit)[-2]
self.scnd_idx = np.argsort(self.bestfit)[-2]
self.newzero = self.x[self.scnd_idx]
# Cutting the new time scale, reset to 0.
self.x2 = np.array(
[i - self.newzero for i in self.x[self.scnd_idx:]])
#x2 = np.array([i for i in x[scnd_idx:]])
# Re-normalized and cutted array
self.y2 = np.array(
[i / self.y[self.scnd_idx] for i in self.y[self.scnd_idx:]])
#newarray = myarray[scnd_idx:]
self.exp_mod = ExponentialModel(prefix='e_')
self.pars = self.exp_mod.guess(self.y2, x=self.x2)
self.init = self.exp_mod.eval(self.pars, x=self.x2)
self.exp_out = self.exp_mod.fit(self.y2, x=self.x2, missing='drop')
self.exp_list = self.exp_out.fit_report().split('\n')
self.exp_chisq = float(self.exp_list[6][-5:])
self.out = self.exp_out
self.chisq = float(self.exp_list[6][-5:])
self.usedmod = self.exp_mod
self.bestfit = self.exp_out.best_fit
self.idx = np.argmin(np.abs(self.bestfit - 0.5))
self.mysort = np.argsort(np.abs(self.bestfit - 0.5))
self.peak_flag = None
if self.bestfit[self.idx] < 0.5:
self.min = self.x2[self.idx - 1]
self.max = self.x2[self.idx]
self.peak_flag = "Resetted exponential"
elif self.bestfit[self.idx] > 0.5:
self.min = self.x2[self.idx]
self.max = self.x2[self.idx + 1]
self.peak_flag = "Resetted exponential"
# For printing.
if len(self.bestfit) < 6:
l = [self.bestfit[-1]] * (6 - len(self.bestfit))
self.bestfit = np.append(self.bestfit, l)
self.x = self.x2
self.y = self.y2
self.model_flag = "exponential"
return self.min, self.max, self.peak_flag, self.bestfit, self.x, self.out, self.chisq, self.usedmod, self.model_flag
def half_life(self):
self.new_x = np.array([0])
self.hl_eval = np.array([0])
self.hl_array = np.array([0])
self.hl_coord = np.array([0])
self.step = None
if self.max == 0:
self.half_life_y = 0
self.half_life_x = 0
self.peak_flag = "No predictable half-life"
else:
self.half_life_y = 0
self.half_life_x = 0
self.step = 0.1
self.max_allowed = 3
self.attempt = 0
#while self.attempt < 3 or self.half_life_y == 0:
while self.half_life_y == 0 and self.attempt < 3:
self.attempt += 1
self.step = self.step / 100
self.ranging = np.arange(
self.min, self.max, self.step
) # normally it 0.001, but the slope is so radical, can't catxh half-life.
for j in np.nditer(self.ranging):
self.new_x = np.array([j])
#self.h = self.out.eval_components(self.out.params,x=self.new_x)
#self.hl_eval = list(self.h.values())[-1]
self.hl_eval = self.out.eval(self.out.params, x=self.new_x)
if self.hl_eval >= 0.50 and self.hl_eval <= 0.51:
self.hl_array = np.append(self.hl_array, self.hl_eval)
self.hl_coord = np.append(self.hl_coord, self.new_x)
self.half_life_id = np.argmin(np.abs(self.hl_array - 0.5))
self.half_life_y = self.hl_array[self.half_life_id]
self.half_life_x = self.hl_coord[self.half_life_id]
self.peak_flag = self.peak_flag
if self.half_life_y == 0:
self.peak_flag = "Above permitted interpolation iterations"
return self.half_life_y, self.half_life_x, self.peak_flag
def saving(self):
with open('model_fit_c5_average_filtering_compound.txt', 'a') as f:
f.write(
"%s\t%s\t%s\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%s\n"
% (self.gene_id, self.cluster, self.model_flag, self.chisq,
self.half_life_y, self.half_life_x, self.norm_vals[0],
self.norm_vals[1], self.norm_vals[2], self.norm_vals[3],
self.norm_vals[4], self.norm_vals[5], self.bestfit[0],
self.bestfit[1], self.bestfit[2], self.bestfit[3],
self.bestfit[4], self.bestfit[5], self.peak_flag))
amps.append(np.array(amp))
amps_std.append(np.array(amp_err))
print(o_i.fit_report(min_correl=0.5))
amps = np.vstack(amps)
amps_std = np.vstack(amps_std)
#print(out.fit_report(min_correl=0.5))
##ax.plot_wireframe(X, Y, Z_noise.reshape(50,50),color="r")
#ax.plot_wireframe(X, Y, Z_conv.reshape(50,50),color="r")
ax.plot_wireframe(X, Y, test_data_noise.reshape(50,50),color="r")
colors = ["r","g","b","orange","k","c"]
#for i,c in zip(exp_test_data,colors):
# ax.plot_wireframe(X, Y, i.reshape(50,50),color=c)
ax.plot_wireframe(X,Y,out.best_fit.reshape(50,50),color="b")
##ax.contour(X,Y,Z)
ax.set_ylabel("y")
ax.set_xlabel("x")
plt.show()
t = np.arange(6)
for i in range(len(exp_test_data)):
mod = ExponentialModel()
pars = mod.guess(amps[:,i],x=t)
fit = mod.fit(amps[:,i],pars,x=t)
plt.errorbar(t,amps[:,i],yerr=amps_std[:,i],fmt="ro")
plt.plot(t,fit.best_fit,"k--")
plt.show()
def produce_taufits(filepath,meth='iso',pulseperiod=None,snr_cut=None,
verbose=True, plotparams=False, plotflux=False, savefigure=False):
pulsar, nch, nbins,nsub, lm_rms, tsub = read_headerfull(filepath)
if verbose == True:
verboseTag = True
else:
verboseTag = False
print0 = "Pulsar name: %s" %pulsar
print1 = "Number of freq. channels: %d \nFreq channels will be labeled 0 - %d" %(nch, nch-1)
print2 = "Number of bins: %d" %nbins
print3 = "RMS: %.2f" %lm_rms
print4 = "Tsub: %.2f sec" %tsub
for k in range(5):
print eval('print{0}'.format(k))
print"--------------------------------------------------------"
if pulseperiod==None:
## Define time axis, and time/bins conversions
print ("Using Tsub in header to convert bins to time. Assumption is that tsub corresponds to 1.0 phase, corresponding to nbins. This should be adapted for search data.")
pulseperiod = tsub
else:
pulseperiod = pulseperiod #set to provided pulseperiod in seconds
profilexaxis = np.linspace(0,pulseperiod,nbins)
pbs = pulseperiod/nbins
tbs = tsub/nbins
"""Initialise vector outputs"""
obtainedtaus, lmfittausstds = [], []
"""freqmsMHz will correctly associate scattering time values
(tau) with frequency, taking into account frequency integration
across a sub-band. Whereas freqcsMHz is the centre freq. to the subband"""
freqmsMHz, freqcsMHz = [], []
noiselessmodels =[]
results, datas, comp_SNRs, comp_rmss = [], [], [], []
redchis, paramset, paramset_std, correls = [], [], [], []
halfway = nbins/2.
for i in range(nch):
print"--------------------------------------------------------"
print "Channel %d" %i
"""Read in (pdv) data"""
data, freqc, freqm = read_data(filepath,i,nbins)
freqmsMHz.append(freqm)
freqcsMHz.append(freqc)
# roll the data of lowest freq channel to middle of bins
if i ==0:
peakbin = np.argmax(data)
shift = int(halfway -int(peakbin))
if verboseTag:
print 'peak bin at lowest freq channel:%d' %peakbin
else:
peakbin = peakbin
shift = int(halfway - int(peakbin))
data = np.roll(data,shift)
if verboseTag:
print "Rolling data by -%d bins" %shift
comp_rms = find_rms(data,nbins)
if meth is None:
print "No fitting method was chosen. Will default to an isotropic fitting model. \n Use option -m with 'onedim' to change."
result, noiselessmodel, besttau, taustd, bestparams, bestparams_std, redchi, corsig = tau_fitter(data,nbins,verbose=verboseTag)
elif meth == 'iso':
result, noiselessmodel, besttau, taustd, bestparams, bestparams_std, redchi, corsig = tau_fitter(data,nbins,verbose=verboseTag)
elif meth == 'onedim':
result, noiselessmodel, besttau, taustd, bestparams, bestparams_std, redchi, corsig = tau_1D_fitter(data,nbins)
comp_SNR_model = find_peaksnr(noiselessmodel,comp_rms)
if verboseTag:
print 'Estimated SNR (from model peak and data rms): %.2f' % comp_SNR_model
comp_SNR = find_peaksnr_smooth(data,comp_rms)
print 'Estimated SNR (from data peak and rms): %.2f' % comp_SNR
print 'Channel Tau (ms): %.2f \pm %.2f ms' %(besttau,taustd)
obtainedtaus.append(besttau)
lmfittausstds.append(taustd)
noiselessmodels.append(noiselessmodel)
results.append(result)
datas.append(data)
comp_SNRs.append(comp_SNR)
#new:
comp_rmss.append(comp_rms)
redchis.append(redchi)
paramset.append(bestparams)
paramset_std.append(bestparams_std)
# if plotflux == True:
# correls.append(corsig)
#if plotflux == True:
# cor_sigA = np.zeros(len(correls))
# for i in range(len(correls)):
# cor_sigA[i] = correls[i]['A']
paramset = np.transpose(paramset)
paramset_std = np.transpose(paramset_std)
"""Next check if any of the subbands contain only zeros. This happens with high RFI excision in LOFAR bands"""
zero_ch = []
for i in range(nch):
all_zeros = not np.any(datas[i])
if all_zeros:
zero_ch.append(i)
print"--------------------------------------------------------"
if zero_ch:
print "\n"
print "%d channels have all zeroes (channels(s):" %len(zero_ch), zero_ch, ") and will be removed."
if verboseTag:
print "All zero channels are assigned SNR of 0"
if snr_cut:
print "Using SNR cutoff of %.2f" %snr_cut
comp_SNRs = np.nan_to_num(comp_SNRs)
(ind_lowSNR,) = np.where(np.array(comp_SNRs) < snr_cut)
print "SNR cutoff will exclude %d channels (channel(s): %s)" %(len(ind_lowSNR), ind_lowSNR)
data_highsnr = np.delete(np.array(datas),ind_lowSNR,0)
model_highsnr = np.delete(np.array(noiselessmodels),ind_lowSNR,0)
taus_highsnr = np.delete(np.array(obtainedtaus),ind_lowSNR)
lmfitstds_highsnr = np.delete(np.array(lmfittausstds),ind_lowSNR)
freqMHz_highsnr = np.delete(np.array(freqmsMHz),ind_lowSNR)
#New:
comp_rmss_highsnr = np.delete(np.array(comp_rmss),ind_lowSNR)
redchis_highsnr = np.delete(np.array(redchis),ind_lowSNR)
#corsigA_highsnr = np.delete(np.array(cor_sigA),ind_lowSNR)
paramset_highsnr = np.zeros([len(paramset),len(data_highsnr)])
paramsetstd_highsnr = np.zeros([len(paramset),len(data_highsnr)])
for i in range(len(paramset)):
paramset_highsnr[i]= np.delete(paramset[i],ind_lowSNR)
paramsetstd_highsnr[i]= np.delete(paramset_std[i],ind_lowSNR)
elif (snr_cut == None) and (zero_ch != []):
print "Used no SNR cutoff"
"""Rename array to be same as when cut-off is used"""
"""If no SNR cutoff is used, remove channels with all zeroes
-- these will automatically be removed by any snr_cut > 0"""
data_highsnr = np.delete(np.array(datas),zero_ch,0)
model_highsnr = np.delete(np.array(noiselessmodels),zero_ch,0)
taus_highsnr = np.delete(np.array(obtainedtaus),zero_ch)
lmfitstds_highsnr = np.delete(np.array(lmfittausstds),zero_ch)
freqMHz_highsnr = np.delete(np.array(freqmsMHz),zero_ch)
# New:
comp_rmss_highsnr = np.delete(np.array(comp_rmss),zero_ch)
redchis_highsnr = np.delete(np.array(redchis),zero_ch)
#corsigA_highsnr = np.delete(np.array(cor_sigA),zero_ch)
paramset_highsnr = np.zeros([len(paramset),len(data_highsnr)])
paramsetstd_highsnr = np.zeros([len(paramset),len(data_highsnr)])
for i in range(len(paramset)):
paramset_highsnr[i]= np.delete(paramset[i],zero_ch)
paramsetstd_highsnr[i]= np.delete(paramset_std[i],zero_ch)
else:
print "Used no SNR cutoff and there are no empty channels"
data_highsnr = np.array(datas)
model_highsnr = np.array(noiselessmodels)
taus_highsnr = np.array(obtainedtaus)
lmfitstds_highsnr = np.array(lmfittausstds)
freqMHz_highsnr = np.array(freqmsMHz)
# New:
comp_rmss_highsnr = np.array(comp_rmss)
redchis_highsnr = np.array(redchis)
paramset_highsnr = np.array(paramset)
paramsetstd_highsnr = np.array(paramset_std)
taussec_highsnr = taus_highsnr*pbs
lmfitstdssec_highsnr = lmfitstds_highsnr*pbs
number_of_plotted_channels = len(data_highsnr)
npch = number_of_plotted_channels
print "Will plot remaining %d/%d channels" %(npch, nch)
"""Plotting starts"""
#plot onedim in blue dashed
#else plot in red
if meth == 'onedim':
prof = 'b--'
lcol='b'
else:
prof = 'r-'
lcol ='r'
"""1. PLOT PROFILES"""
dimx, dimy = 3., 3.
numsubplots = dimx*dimy
numplots = int(np.ceil(npch/numsubplots))
print "Num profile plots:", numplots
"""Compute residuals"""
#"""Plot 1: Pulse profiles and fits"""
if npch > 0:
resdata = data_highsnr - model_highsnr
resnormed = (resdata-resdata.mean())/resdata.std()
if taussec_highsnr[0] > 1:
taulabel = taussec_highsnr
taulabelerr = lmfitstdssec_highsnr
taustring = 'sec'
else:
taulabel = taussec_highsnr*1000
taulabelerr = lmfitstdssec_highsnr*1000
taustring = 'ms'
for k in range(numplots):
j = int(numsubplots*k)
figg = plt.figure(k+1,figsize=(int(4*dimx),int(3*dimy)))
plots_remaining = int(npch - numsubplots*k)
#print "Plots remaining", plots_remaining
for i in range(np.min([int(numsubplots),int(plots_remaining)])):
figg.subplots_adjust(left = 0.08, right = 0.98, wspace=0.35,hspace=0.35,bottom=0.15)
#plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.subplot(dimx,dimy,i+1)
plt.plot(profilexaxis,data_highsnr[j+i],alpha = 0.20)
plt.plot(profilexaxis,model_highsnr[j+i],lw = 2.0, alpha = 0.85, label=r'$\tau: %.2f \pm%.2f$ %s' %(taulabel[j+i], taulabelerr[j+i], taustring))
plt.title('%s at %.1f MHz' %(pulsar, freqMHz_highsnr[j+i]))
plt.ylim(ymax=1.3*np.max(data_highsnr[j+i]))
plt.xlim(xmax=pulseperiod)
plt.xticks(fontsize=11)
plt.yticks(fontsize=11)
plt.xlabel('time (s)',fontsize=11)
plt.legend(fontsize=11,numpoints=1)
plt.ylabel('normalized intensity',fontsize=11)
plt.tight_layout()
if savefigure == True:
figname = '%s_%s_%s_%d.png' %(os.path.basename(filepath),'fitted_profiles', meth, k)
plt.savefig(figname, dpi=200)
print "Saved figure %s in ./" %figname
if noshow == False:
plt.show()
if verboseTag:
for i in range(npch):
print "Channel %d" %i
print'Tau (ms): %.2f' %(1000*taussec_highsnr[i])
tau1GHz = tauatfreq(freqMHz_highsnr[i]/1000.,taussec_highsnr[i],1.0,4)
print 'tau1GHz_alpha_4 (ms) ~ %.4f' %(tau1GHz*1000)
lmfitstdssec_highsnr = lmfitstdssec_highsnr[np.nonzero(lmfitstdssec_highsnr)]
taussec_highsnr = taussec_highsnr[np.nonzero(lmfitstdssec_highsnr)]
freqMHz_highsnr = freqMHz_highsnr[np.nonzero(lmfitstdssec_highsnr)]
"""Plot 2: Plot Gaussian fitting parameters and DM if selected"""
if plotparams==True:
print "\nPlotting Gaussian fit parameters w.r.t frequency\n"
"""Set plotting parameters"""
alfval = 0.6
markr= '*'
msize=12
plt.figure(numplots+1, figsize=(12,8))
plt.subplots_adjust(left = 0.055, right=0.98,wspace=0.35,hspace=0.4,bottom=0.08)
"""Fit models to sigma"""
powmod = PowerLawModel()
powpars = powmod.guess(paramset_highsnr[0], x=freqMHz_highsnr)
powout = powmod.fit(paramset_highsnr[0], powpars, x=freqMHz_highsnr, weights=1/((paramsetstd_highsnr[0])**2))
linmod = LinearModel()
if len(freqMHz_highsnr) < 3:
raise RuntimeError("plotparams == True: Less than three frequency channels. Cannot compute quadratic or exponential fit for width evolution. Consider lowering snr_cut.")
else:
quadmod = QuadraticModel()
quadpars = quadmod.guess(paramset_highsnr[0], x=freqMHz_highsnr)
quadout = quadmod.fit(paramset_highsnr[0], quadpars, x=freqMHz_highsnr, weights=1/((paramsetstd_highsnr[0])**2))
expmod = ExponentialModel()
exppars = expmod.guess(paramset_highsnr[0], x=freqMHz_highsnr)
expout = expmod.fit(paramset_highsnr[0], exppars, x=freqMHz_highsnr, weights=1/((paramsetstd_highsnr[0])**2))
"""Fit a DM model to delta mu"""
delnuarray = [-(1/freqMHz_highsnr[-1]**2-1/freqMHz_highsnr[i]**2) for i in range(npch)] ##in MHz
delmuarray = [(paramset_highsnr[1][-1] - paramset_highsnr[1][i])*pbs for i in range(npch)] ##in seconds
delmu_stdarray = [(paramsetstd_highsnr[1][-1] - paramsetstd_highsnr[1][i])*pbs for i in range(npch)]
DM_linpars = linmod.guess(delmuarray, x=delnuarray)
DM_linout = linmod.fit(delmuarray, DM_linpars, x=delnuarray)
DM_CCval = DM_linout.best_values['slope']
DM_CCvalstd = DM_linout.params['slope'].stderr
DMmodelfit = DM_linout.best_fit ##model gives deltime in seconds (used to shift data)
DMconstant = 4148.808
#uncertainty in the constant is 0.003 - only affects the Delta DM value in the 9th decimal
DMval = (DM_CCval/DMconstant)
DMvalstd = (DM_CCvalstd/DMconstant)
#DMcheck = psr.DM_checker(freqmsMHz,bestpT_highSNR[1]*pbs)
## Plot reduced chi square:
plt.subplot(2,3,1)
plt.plot(freqMHz_highsnr, redchis_highsnr/np.power(comp_rmss_highsnr,2), markr,alpha=alfval,markersize = msize)
plt.title(r'Reduced $\chi^2$ values', fontsize=12)
plt.yticks(fontsize=12)
plt.xticks(fontsize=12)
plt.xlabel(r'$\nu$ MHz',fontsize=12)
plt.ylabel(r'$\chi^2$',fontsize=12)
## Plot sigma:
plt.subplot(2,3,2)
#plt.errorbar(freqMHz_highsnr,paramset_highsnr[0]*pbs)
plt.errorbar(freqMHz_highsnr,paramset_highsnr[0]*pbs,yerr =paramsetstd_highsnr[0]*pbs, fmt = markr,markersize=msize,capthick=2,linewidth=1.5,alpha=alfval)
plt.plot(freqMHz_highsnr,powout.best_fit*pbs,'-', alpha=alfval,label='pow = %.2f' %powout.best_values['exponent'])
plt.plot(freqMHz_highsnr,quadout.best_fit*pbs,'-',alpha=alfval, label='quad: a,b = %.3f,%.3f' %(quadout.best_values['a'],quadout.best_values['b']))
plt.ylabel(r'$\sigma$ (sec)')
plt.title(r'Width evolution', fontsize=12)
plt.yticks(fontsize=12)
plt.xticks(fontsize=12)
plt.xlabel(r'$\nu$ MHz',fontsize=14)
plt.legend(fontsize = 10, loc='best')
## Plot mean:
plt.subplot(2,3,3)
#plt.errorbar(freqMHz_highsnr,paramset_highsnr[1]*pbs)
plt.errorbar(freqMHz_highsnr,paramset_highsnr[1]*pbs,yerr =paramsetstd_highsnr[1]*pbs, fmt = markr,markersize=msize,capthick=2,linewidth=1.5,alpha=alfval)
plt.ylabel(r'$\mu$ (sec)')
plt.title(r'Centroid evolution', fontsize=12)
plt.yticks(fontsize=12)
plt.xticks(fontsize=12)
plt.xlabel(r'$\nu$ MHz',fontsize=14)
#plt.legend(fontsize = 9, loc='best')
## Plot amplitude:
plt.subplot(2,3,4)
#plt.errorbar(freqMHz_highsnr,paramset_highsnr[2]*pbs)
plt.errorbar(freqMHz_highsnr,paramset_highsnr[2]*pbs,yerr =paramsetstd_highsnr[2]*pbs, fmt = markr,markersize=msize,capthick=2,linewidth=1.5,alpha=alfval)
plt.ylabel(r'$\mu$ (sec)')
plt.title(r'Amplitude evolution', fontsize=12)
plt.yticks(fontsize=12)
plt.xticks(fontsize=12)
plt.xlabel(r'$\nu$ MHz',fontsize=14)
#plt.legend(fontsize = 9, loc='best')
## Plot DC:
plt.subplot(2,3,5)
#plt.errorbar(freqMHz_highsnr,paramset_highsnr[2]*pbs)
plt.errorbar(freqMHz_highsnr,paramset_highsnr[3]*pbs,yerr =paramsetstd_highsnr[3]*pbs, fmt = markr,markersize=msize,capthick=2,linewidth=1.5,alpha=alfval)
plt.ylabel(r'$\mu$ (sec)')
plt.title(r'DC offset', fontsize=12)
plt.yticks(fontsize=12)
plt.xticks(fontsize=12)
plt.xlabel(r'$\nu$ MHz',fontsize=14)
#plt.legend(fontsize = 9, loc='best')
## Plot DM:
plt.subplot(2,3,6)
plt.errorbar(delmuarray,freqMHz_highsnr, fmt = markr, xerr=delmu_stdarray, alpha = alfval, markersize=msize)
plt.plot(DMmodelfit,freqMHz_highsnr, '-', label=r'DM: $%.3f \pm %.3f$ $\rm{pc.cm}^{-3}$' %(DMval,DMvalstd), alpha = alfval)
plt.xlabel(r'$\Delta \mu$ (sec)', fontsize =12)
plt.yticks(fontsize=12)
plt.xticks(fontsize=12)
plt.title('Delta DM', fontsize=12)
plt.ylabel(r'$\nu$ (MHz)',fontsize=14)
plt.ticklabel_format(style='sci', axis='x',scilimits=(0,0))
plt.legend(fontsize = 10, loc='best')
plt.tight_layout()
if savefigure == True:
figname2 = '%s_%s.png' %(os.path.basename(filepath),'fitting_parameters')
plt.savefig(figname2, dpi=200)
print "Saved figure %s in ./" %figname2
if noshow == False:
plt.show()
if plotflux == True: ##Flux section needs debugging
ls = 'solid'
"""Plot flux, and corrected flux spectrum"""
"""Create unscattered profiles, i.e. Guassians"""
bins, profiles = [],[makeprofile(nbins = nbins, ncomps = 1, amps = paramset_highsnr[2][j], means = paramset_highsnr[1][j], sigmas = paramset_highsnr[0][j]) for j in range(npch)]
unscatflux = []
for i in range(npch):
unscatfl = np.sum(profiles[j])/nbins
unscatflux.append(unscatfl)
#smootheddata = smooth(data_highsnr[j],int(0.05*nbins))
scatflux = [find_modelflux(model_highsnr[i],nbins) for i in range(npch)]
climbvals = []
for i in range(npch):
climb = returnclimb(np.linspace(1,nbins,nbins),paramset_highsnr[1][i],paramset_highsnr[0][i],paramset_highsnr[2][i],taussec_highsnr[i],paramset_highsnr[3][i],nbins)
climbvals.append(climb)
correctedflux = np.array([scatflux[i] + climbvals[i] for i in range(npch)])
print scatflux
print climbvals
#per bin
meancorflux = np.mean(correctedflux)
meancorfluxerr = np.sqrt(np.sum(correctedflux**2))/len(correctedflux)
"""Calculate error in Flux"""
sigmaWIDTH = paramsetstd_highsnr[0]*pbs #in seconds
sigmaAMP = paramsetstd_highsnr[2] #in mJy
WIDTHS =paramset_highsnr[0]*pbs #in seconds
AMPS =paramset_highsnr[2] #in mJy
Expr1 = np.sqrt(2*np.pi)*AMPS
Expr2 = np.sqrt(WIDTHS)
AreaExpression = Expr1*Expr2
sigmaEx1 = np.sqrt(2*np.pi)*sigmaAMP
sigmaEx2 = Expr2*0.5*sigmaWIDTH/WIDTHS
sigmaFlux =AreaExpression*np.sqrt(np.power(sigmaEx1/Expr1,2)+ np.power(sigmaEx2/Expr2,2))#+ 2*corsigA_highsnr*sigmaEx1*sigmaEx2/(Expr1*Expr2)
plt.figure(figsize=(10,6))
plt.plot(freqMHz_highsnr, correctedflux,'k-', linewidth=2.0)
plt.plot(freqMHz_highsnr, scatflux,'r--', linewidth=2.0)
plt.fill_between(freqMHz_highsnr,scatflux,correctedflux, alpha=alfval,facecolor='r')
eb = plt.errorbar(freqMHz_highsnr,correctedflux,yerr=sigmaFlux, fmt=markr,markersize=10.0, alpha=1.0,capthick=2,linewidth=1.5)
eb[-1][0].set_linestyle(ls)
#plt.errorbar(freqMHz_highsnr, unscatflux,yerr=sigmaFlux, fmt=markr,markersize=10.0, alpha=alfval)
plt.title('Flux Spectrum', fontsize=12)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.xlabel(r'$\nu$ (MHz)',fontsize=12)
plt.ylabel(r'Calibrated flux (mJy)',fontsize=12)
return freqMHz_highsnr, taussec_highsnr, lmfitstdssec_highsnr
#!/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
elif 'wid' in name:
wid_list.append(getSigma(getFWHM(param.value)))
for wid, cen in zip(wid_list, cen_list):
param_list.append([cen, wid])
mcd_comps = fitting_result.eval_components(x=x)
abs_x = abs_data['energy']
abs_y = abs_data['normalized_absorbance']
gauss1 = GaussianModel(prefix='g1_')
gauss2 = GaussianModel(prefix='g2_')
gauss3 = GaussianModel(prefix='g3_')
gauss4 = GaussianModel(prefix='g4_')
exp = ExponentialModel(prefix='exp_')
abs_model = gauss1 + gauss2 + gauss3 + gauss4
pars = abs_model.make_params()
pars['g1_center'].set(value=param_list[0][0], vary=False)
pars['g1_sigma'].set(value=param_list[0][1], vary=False)
pars['g1_amplitude'].set(value=.409, min=0, vary=True)
pars['g2_center'].set(value=param_list[1][0], vary=False)
pars['g2_sigma'].set(value=param_list[1][1], vary=False)
pars['g2_amplitude'].set(value=.3668, min=0, vary=True)
pars['g3_center'].set(value=param_list[2][0], vary=False)
pars['g3_sigma'].set(value=param_list[2][1], vary=False)
pars['g3_amplitude'].set(value=.2, min=0)
pars['g4_center'].set(value=4, min=2.5, max=6, vary=True)
pars['g4_sigma'].set(value=0.3, max=0.5, vary=True)
for i in range(M):
print("***** Iteration ",i," *****")
data = langevin.time_series(A=A, D=D, delta_t=delta_t, N=N)
data_results = [data[0]**2, data[-1]**2, np.sum(data[1:-2]**2), np.sum(data[:-1]*data[1:])]
# calculate autocorrelation function
f = np.fft.rfft(data)
acf = np.fft.irfft(f * np.conjugate(f))
acf = np.fft.fftshift(acf) / N
autocorr = acf[int(N / 2):]
y = autocorr[:min(int(N / 2), P)]
t = np.arange(min(int(N / 2), P))
mod = ExponentialModel()
pars = mod.guess(y, x=t)
try:
out = mod.fit(y, pars, x=t)
except:
fit_results = np.zeros(4)
print('fit did not work')
else:
fit_results = np.array([out.values['decay']*delta_t,
np.sqrt(out.covar[0,0])*delta_t,
out.values['amplitude'],
np.sqrt(out.covar[1,1])])
print(out.fit_report(min_correl=0.25))
trace = sm.run(x=data,
aB=alpha_B,
#!/usr/bin/env python
#<examples/doc_nistgauss2.py>
import numpy as np
from lmfit.models import GaussianModel, ExponentialModel
import matplotlib.pyplot as plt
dat = np.loadtxt('NIST_Gauss2.dat')
x = dat[:, 1]
y = dat[:, 0]
exp_mod = ExponentialModel(prefix='exp_')
gauss1 = GaussianModel(prefix='g1_')
gauss2 = GaussianModel(prefix='g2_')
def index_of(arrval, value):
"return index of array *at or below* value "
if value < min(arrval): return 0
return max(np.where(arrval <= value)[0])
ix1 = index_of(x, 75)
ix2 = index_of(x, 135)
ix3 = index_of(x, 175)
pars1 = exp_mod.guess(y[:ix1], x=x[:ix1])
pars2 = gauss1.guess(y[ix1:ix2], x=x[ix1:ix2])
pars3 = gauss2.guess(y[ix2:ix3], x=x[ix2:ix3])
pars = pars1 + pars2 + pars3
result_array = None
for i in range(M):
print("***** Iteration ", i, " *****")
data = langevin.time_series(A=A, D=D, delta_t=delta_t, N=N)
# calculate autocorrelation function
f = np.fft.rfft(data)
acf = np.fft.irfft(f * np.conjugate(f))
acf = np.fft.fftshift(acf) / N
autocorr = acf[int(N / 2):]
y = autocorr[:min(int(N / 2), P)]
t = np.arange(min(int(N / 2), P))
mod = ExponentialModel()
pars = mod.guess(y, x=t)
try:
out = mod.fit(y, pars, x=t)
except:
fit_results = np.zeros(4)
print('fit did not work')
else:
fit_results = np.array([
out.values['decay'] * delta_t,
np.sqrt(out.covar[0, 0]) * delta_t, out.values['amplitude'],
np.sqrt(out.covar[1, 1])
])
print(out.fit_report(min_correl=0.25))
trace = sm.run(x=data,
class gene_set():
def __init__(self, gene_id, cluster):
self.cluster = cluster
self.gene_id = gene_id
self.norm_vals = [
float(y) for y in [x[1:] for x in reference if x[0] == gene_id][0]
] #TPM.
self.get_model()
self.half_life()
self.printing()
self.saving()
def get_model(self):
self.x = np.array([0, 1, 2, 6, 12, 24])
self.y = np.array(self.norm_vals)
#x = np.array([0,1,2,6,12,24])
# Exponential model for reference
self.exp_mod = ExponentialModel(prefix='onlye_')
self.pars = self.exp_mod.guess(self.y, x=self.x)
self.init = self.exp_mod.eval(self.pars, x=self.x)
self.exp_out = self.exp_mod.fit(self.y, x=self.x, missing='drop')
self.exp_list = self.exp_out.fit_report().split('\n')
self.exp_chisq = float(self.exp_list[6][-5:])
return self.exp_out, self.exp_chisq
def half_life(self):
self.new_x = np.array([0])
self.hl_eval = np.array([0])
self.hl_array = np.array([0])
self.hl_coord = np.array([0])
self.bestfit = self.exp_out.best_fit
self.idx = np.argmin(np.abs(self.bestfit - 0.5))
if self.idx == 5 and self.bestfit[self.idx - 1] < 0.5:
self.bestfit = self.exp_out.best_fit[:-1]
self.idx = np.argmin(np.abs(self.bestfit - 0.5))
if self.bestfit[self.idx] == 0.5:
self.half_life_y = self.bestfit[self.idx]
self.half_life_x = self.idx
elif 0.5 > self.bestfit[self.idx] and self.bestfit[self.idx - 1] > 0.5:
self.max = self.x[self.idx]
self.min = self.x[self.idx - 1]
elif 0.5 < self.bestfit[self.idx] and self.bestfit[
self.idx] == self.bestfit[5]:
self.min = 0
self.max = 0
elif 0.5 < self.bestfit[self.idx] and self.bestfit[self.idx + 1] < 0.5:
self.min = self.x[self.idx]
self.max = self.x[self.idx + 1]
elif 0.5 < self.bestfit[self.idx] and self.bestfit[
self.idx + 1] > 0.5 and self.bestfit[self.idx + 2] < 0.5:
self.min = self.x[self.idx + 1]
self.max = self.x[self.idx + 2]
elif 0.5 > self.bestfit[self.idx] and self.bestfit[
self.idx + 1] < 0.5 and self.bestfit[self.idx - 2] > 0.5:
self.min = self.x[self.idx - 2]
self.max = self.x[self.idx]
self.ranging = np.arange(self.min, self.max, 0.001)
if self.max > 0:
# if self.min > 0 and self.max > 0:
for j in np.nditer(self.ranging):
self.new_x = np.array([j])
self.hl_eval = self.exp_out.eval(self.exp_out.params,
x=self.new_x)
if self.hl_eval >= 0.50 and self.hl_eval <= 0.51:
self.hl_array = np.append(self.hl_array, self.hl_eval)
self.hl_coord = np.append(self.hl_coord, self.new_x)
self.half_life_id = np.argmin(np.abs(self.hl_array - 0.5))
self.half_life_y = self.hl_array[self.half_life_id]
self.half_life_x = self.hl_coord[self.half_life_id]
self.bestfit = self.exp_out.best_fit
else:
self.half_life_y = 0
self.half_life_x = 0
self.bestfit = self.exp_out.best_fit
return self.half_life_y, self.half_life_x
def printing(self):
print(self.gene_id, self.cluster, "exponential", self.exp_chisq,
self.half_life_y, self.half_life_x, self.norm_vals[0],
self.norm_vals[1], self.norm_vals[2], self.norm_vals[3],
self.norm_vals[4], self.norm_vals[5], self.bestfit[0],
self.bestfit[1], self.bestfit[2], self.bestfit[3],
self.bestfit[4], self.bestfit[5])
def saving(self):
with open('model_fit_c5_average_filtering_newexp.txt', 'a') as f:
(f.write(
"%s\t%s\t%s\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\n"
% (self.gene_id, self.cluster, "exponential", self.exp_chisq,
self.half_life_y, self.half_life_x, self.norm_vals[0],
self.norm_vals[1], self.norm_vals[2], self.norm_vals[3],
self.norm_vals[4], self.norm_vals[5], self.bestfit[0],
self.bestfit[1], self.bestfit[2], self.bestfit[3],
self.bestfit[4], self.bestfit[5])))
