def doubleBrokenPowerLaw(logX, *p):
'''
p1 = amplitude of break A
p2 = break A
p3 = break B
p4 = PL inde A
p5 = PL index A-B
p6 = PL indec B+
p7 = deltaA
p8 = deltaB
'''
p1, p2, p3, p4, p5, p6, p7, p8 = p
if (p7 < 0.001) | (p8 < 0.001) | (p1 < 0) | (p1 > 1.) | (p4 > 0) | (p6 <
0):
return np.zeros(len(logX)) + np.inf
x = 10**logX
f = models.SmoothlyBrokenPowerLaw1D(amplitude=p1, \
x_break=p2, alpha_1=p4, alpha_2=p5)
g = models.SmoothlyBrokenPowerLaw1D(amplitude=1., \
x_break=1., alpha_1=p5, alpha_2=p6)
f.delta = p7
g.delta = p8
y = f(x) * g(x)
return np.log10(y)
def calc_flux(t,nu,F_0t,nu_bt,alpha_1t,alpha_2t):
"""Flux as flux[t_i,nu_i] for given arrays of ts and nus. Give other paramters as arrays
i.e F_0t[ti]= amplitude for time t_i"""
flux=np.zeros((n,len(nu)))
f=models.SmoothlyBrokenPowerLaw1D()
for i in range(n):
f.amplitude=F_0t[i]
f.x_break=nu_bt[i]
f.alpha_1=alpha_1t[i]
f.alpha_2=alpha_2t[i]
flux[i]=f(nu)
return flux
def brokenPowerLaw(x, *p):
p1, p2, p3, p4, p5 = p
if (p4 < 0.001) | (p2 > 0) | (p3 < 0):
return np.zeros(len(x)) + np.inf
f = models.SmoothlyBrokenPowerLaw1D(amplitude=1.,
x_break=p1,
alpha_1=p2,
alpha_2=p3)
f.delta = p4
y = np.log10(f(10**x))
return y
astmodels.Plummer1D(mass=10.0, r_plum=5.0),
astmodels.BrokenPowerLaw1D(amplitude=10,
x_break=0.5,
alpha_1=2.0,
alpha_2=3.5),
astmodels.ExponentialCutoffPowerLaw1D(10, 0.5, 2.0, 7.),
astmodels.LogParabola1D(
amplitude=10,
x_0=0.5,
alpha=2.,
beta=3.,
),
astmodels.PowerLaw1D(amplitude=10., x_0=0.5, alpha=2.0),
astmodels.SmoothlyBrokenPowerLaw1D(amplitude=10.,
x_break=5.0,
alpha_1=2.0,
alpha_2=3.0,
delta=0.5),
custom_and_analytical_inverse(),
custom_inputs_outputs(),
]
if HAS_SCIPY:
test_models.append(
astmodels.Spline1D(
np.array([-3., -3., -3., -3., -1., 0., 1., 3., 3., 3., 3.]),
np.array([
0.10412331, 0.07013616, -0.18799552, 1.35953147, -0.15282581,
0.03923, -0.04297299, 0., 0., 0., 0.
]), 3))
dataset = 6
data = all_mi[dataset]
alpha_1 = 0.38215
alpha_2 = 0.003
p1 = plt.loglog(np.arange(1, len(data) + 1), data, label="WikiText2 (C)")
amplitude = all_mi[dataset][break_point + 12]
x = np.linspace(1, len(data), len(data))
f = models.BrokenPowerLaw1D(amplitude=amplitude,
x_break=break_point,
alpha_1=alpha_1,
alpha_2=alpha_2)
fit_sample = f(x)
p2 = plt.loglog(x, fit_sample, label="Broken Power-Law for WikiText2 (C)")
amplitude = all_mi[dataset][break_point - 1]
f = models.SmoothlyBrokenPowerLaw1D(amplitude=amplitude,
x_break=break_point,
alpha_1=alpha_1,
alpha_2=alpha_2)
f.delta = 0.25
fit_sample = f(x)
p3 = plt.loglog(x,
fit_sample,
label="Smoothly Broken Power-Law for WikiText2 (C)")
###################################################################################################################
# Wiki2 Raw
###################################################################################################################
# break_point = 4
# dataset = 7
# data = all_mi[dataset]
# alpha_1 = 0.421
# alpha_2 = 0.00281
return y
# return b*(freq**alpha)*np.exp((alpha/beta)*freq**(-beta))
'''
#plt.plot(np.linspace(250,450,1024),power_law(np.linspace(250,450),1,)
popt,pcov=curve_fit(power_law,combined_nonec_freq,combined_nonec,absolute_sigma=True)
print (popt,np.sqrt(np.diag(pcov)))
x=np.linspace(min(combined_nonec_freq),max(combined_nonec_freq))
y=power_law(x,popt[0],popt[1],popt[2],popt[3])
plt.plot(np.log10(x),np.log10(y))
plt.errorbar(np.log10(combined_nonec_freq),np.log10(combined_nonec),np.divide(np.array(combined_nonec_err),np.array(combined_nonec))/2.7182818,fmt='o',capsize=5)
plt.show()
'''
f = models.SmoothlyBrokenPowerLaw1D(amplitude=12, x_break=290,alpha_1=-1.5, alpha_2=2.6,delta=0.01)
fit= fitting.LevMarLSQFitter()
fitted_line = fit(f, combined_nonec_freq,combined_nonec)
plt.errorbar((combined_nonec_freq),(combined_nonec),(combined_nonec_err),fmt='o',capsize=5)
x=np.linspace(min(combined_nonec_freq),max(combined_nonec_freq))
alpha1=fitted_line.alpha_1.value
alpha2=fitted_line.alpha_2.value
error=(np.diag(fit.fit_info['param_cov']))
print(fitted_line,error)
alpha1_err=error[2]
alpha2_err=error[3]
plt.plot((x),(fitted_line(x)))
plt.ylim(bottom=0)
plt.xlabel('(Frequency)')
plt.ylabel('(Mean flux density)')
plt.text(250,50,r'$\alpha_1=$'+str(-1*alpha1)[:4]+r'$\pm$'+str(alpha1_err)[:4])
