def plot_lcurve(self, ax=None, guides=True):
"""
Make a plot of the data-misfit x regularization values.
The estimated corner value is shown as a blue triangle.
Parameters:
* ax : matplotlib Axes
If not ``None``, will plot the curve on this Axes instance.
* guides : True or False
Plot vertical and horizontal lines across the corner value.
"""
if ax is None:
ax = mpl.gca()
else:
mpl.sca(ax)
x, y = self.dnorm, self.mnorm
if self.loglog:
mpl.loglog(x, y, '.-k')
else:
mpl.plot(x, y, '.-k')
if guides:
vmin, vmax = ax.get_ybound()
mpl.vlines(x[self.corner_], vmin, vmax)
vmin, vmax = ax.get_xbound()
mpl.hlines(y[self.corner_], vmin, vmax)
mpl.plot(x[self.corner_], y[self.corner_], '^b', markersize=10)
mpl.xlabel('Data misfit')
mpl.ylabel('Regularization')
writer = csv.DictWriter(csvfile,
fieldnames=results[0].keys(),
delimiter=',',
quotechar='|',
quoting=csv.QUOTE_MINIMAL)
writer.writeheader()
for result in results:
writer.writerow(result)
csvfile.close()
title = '%s, %.3f GHz, %d times: surface %g \n%s %s %s' % \
(context, frequency[0] * 1e-9, ntimes, se, socket.gethostname(), epoch, basename)
plt.clf()
colors = ['b', 'r', 'g', 'y']
for ifield, field in enumerate(
['onsource_maxabs', 'onsource_rms', 'onsource_medianabs']):
plt.loglog(ses, [1e6 * result[field] for result in results],
'-',
label=field,
color=colors[ifield])
plt.xlabel('Surface error multiplier')
plt.ylabel('Error (uJy)')
plt.title(title)
plt.legend(fontsize='x-small')
print('Saving plot to %s' % plotfile)
plt.savefig(plotfile)
plt.show(block=False)
def prompt_MDP(dataname):
# ---------------数据读取
dat = []
bat = []
xrt = []
path_png = '../GRB_prompt_MDP(3)_300s/'
num = 0
with open(dataname, 'r') as f:
bat_start = bat_end = xrt_start = xrt_end = 0
for line in f.readlines():
num += 1
if 'batSNR5flux' in line:
bat_start = num
if 'batSNR5gamma' in line:
bat_end = num - 2
if 'xrtwtflux' in line:
xrt_start = num
if 'xrtwtgamma' in line:
xrt_end = num - 2
with open(dataname, 'r') as f:
for line in f.readlines()[bat_start:bat_end]:
bat.append(re.split(r'\s+', line))
bat = np.array(bat)
if len(bat) == 0:
pass
else:
bat = bat[:, :-1]
bat = bat.astype(np.float)
with open(dataname, 'r') as f:
for line in f.readlines()[xrt_start:xrt_end]:
xrt.append(re.split(r'\s+', line))
xrt = np.array(xrt)
xrt = xrt[:, :-1]
xrt = xrt.astype(np.float)
#---------------------- 转换光子数
def N_count(flux, index=xrt_photon_index):
N = flux * integrate.quad(lambda E: E ** (-index), 2, 10.0)[0] / \
integrate.quad(lambda E: E * E ** (-index), 0.3, 10)[0] / 1.6e-9
return N
#print('%3.3f count/cm2/s'%N_count(2.4e-8))
if len(bat) == 0:
pass
else:
flux = np.array(bat[:, 3])
flux_err = np.array(bat[:, 4])
bat_count = [
N_count(flux[i], index=bat_photon_index) for i in range(len(flux))
]
bat_count_err = [
N_count(flux_err[i], index=bat_photon_index)
for i in range(len(flux_err))
]
bat = np.column_stack((bat, bat_count, bat_count_err))
xrt_flux = np.array(xrt[:, 3])
xrt_flux_err = np.array(xrt[:, 4])
xrt_count = [N_count(xrt_flux[i]) for i in range(len(xrt_flux))]
xrt_count_err = [
N_count(xrt_flux_err[i]) for i in range(len(xrt_flux_err))
]
xrt = np.column_stack((xrt, xrt_count, xrt_count_err))
#print(bat_count)
# ---------------------------画图
fig, ax = plt.subplots()
if len(bat) == 0:
pass
else:
x = bat[:, 0]
xerr = bat[:, 1]
xerr_ = bat[:, 2]
y = bat[:, -2]
yerr = bat[:, -1]
plt.errorbar(x,
y,
yerr=yerr,
xerr=xerr,
fmt='o',
label='BAT(flux to count)')
xrt_x = xrt[:, 0]
xrt_xerr = xrt[:, 1]
xrt_xerr_ = xrt[:, 2]
xrt_y = xrt[:, -2]
xrt_yerr = xrt[:, -1]
plt.errorbar(xrt_x,
xrt_y,
yerr=xrt_yerr,
xerr=xrt_xerr,
fmt='o',
color='red',
label='XRT(flux to count)')
plt.xlabel('Time since BAT trigger (s)')
plt.ylabel(r'2-10 keV (Count/cm$^2$/s)')
plt.title('Swift BAT-XRT data of %s' % dataname)
plt.loglog()
#-----------------------------------合并BAT与XRT反推光子的数据
xrt_x0 = xrt[0, 0]
print(xrt_x0)
if len(bat) == 0:
bat = xrt
else:
bat = bat[bat[:, 0] < xrt_x0, :]
bat = np.row_stack((bat, xrt))
x = bat[:, 0]
xerr = bat[:, 1]
xerr_ = bat[:, 2]
y = bat[:, -2]
yerr = bat[:, -1]
# plt.errorbar(x, y, yerr=yerr, xerr=xerr, fmt='o',label='BAT')
# -----------------------------------计算总MPD
t = xerr - xerr_
N_cm = sum(y * t)
N_total = N_cm * eff * area
# print(N_cm, N_total)
MDP = 4.29 / (miu * np.sqrt(N_total)) * 100
# print(MDP)
# ----------------------------t_start 之后观测到的数据点及画图
bat2 = bat[bat[:, 0] > t_start, :]
bat2 = bat2[bat2[:, 0] < t_end, :]
#print(bat2)
x2 = bat2[:, 0]
xerr2 = bat2[:, 1]
xerr2_ = bat2[:, 2]
y2 = bat2[:, 6]
yerr2 = bat2[:, 7]
# plt.errorbar(x2, y2, yerr=yerr2, xerr=xerr2, fmt='*')
plt.axvline(t_start, label='t=%s s' % t_start, color='green')
plt.axvline(t_end, label='t=%s s' % t_end, color='green')
# ----------------------------t_start 之后观测到的MDP
t2 = xerr2 - xerr2_
N_cm2 = sum(y2 * t2)
N_total2 = N_cm2 * eff * area
# print(N_cm2, N_total2)
MDP2 = 4.29 / (miu * np.sqrt(N_total2)) * 100
# print(MDP2)
fig.text(0.2,
0.2,
'MDP = %2.2f %%' % MDP2,
color='red',
fontsize=12,
fontweight='bold')
plt.legend(loc='upper left')
#plt.legend()
plt.savefig(path_png + dataname + ' %2.2f%%' % MDP2 + '.png')
plt.show()
return MDP2
from numpy import *
import matplotlib as plt
data = loadtxt("data.txt")
plt.figure()
plt.loglog(data[:, 0], abs(data[:, 1] - exp(-4.096)))
plt.axis('equal')
plt.xlabel('dt')
plt.ylabel('error')
c2 = 'r'
xr05,Nr05 = ida.Nch_logscale("../Nch/rgh/rgh05.dat")
xr10,Nr10 = ida.Nch_logscale("../Nch/rgh/rgh10.dat")
xr20,Nr20 = ida.Nch_logscale("../Nch/rgh/rgh20.dat")
xr25,Nr25 = ida.Nch_logscale("../Nch/rgh/rgh25.dat")
xr30,Nr30 = ida.Nch_logscale("../Nch/rgh/rgh30.dat")
xr40,Nr40 = ida.Nch_logscale("../Nch/rgh/rgh40.dat")
xr50,Nr50 = ida.Nch_logscale("../Nch/rgh/rgh50.dat")
xg2,Ng2 = ida.Nch_logscale("../Nch/gamma/gam2-2000.dat")
xg4,Ng4 = ida.Nch_logscale("../Nch/gamma/gam4-2000.dat")
xg10,Ng10 = ida.Nch_logscale("../Nch/gamma/gam10-2000.dat")
xg20,Ng20 = ida.Nch_logscale("../Nch/gamma/gam20.dat")
xg40,Ng40 = ida.Nch_logscale("../Nch/gamma/gam40.dat")
xg100,Ng100 = ida.Nch_logscale("../Nch/gamma/gam100.dat")
xg1000,Ng1000 = ida.Nch_logscale("../Nch/gamma/gam1000.dat")
plt.loglog(xr05/10,Nr05,'d',markersize=8,color=c1,label=r'$\sigma=0.05h_0$')
plt.loglog(xr10/10,Nr10,'o',markersize=8,color=c1,label=r'$\sigma=0.10h_0$')
plt.loglog(xr20/10,Nr20,'s',markersize=8,color=c1,label=r'$\sigma=0.20h_0$')
plt.loglog(xr25/10,Nr25,'^',markersize=8,color=c1,label=r'$\sigma=0.25h_0$')
plt.loglog(xr30/10,Nr30,'v',markersize=8,color=c1,label=r'$\sigma=0.30h_0$')
plt.loglog(xr40/10,Nr40,'<',markersize=8,color=c1,label=r'$\sigma=0.40h_0$')
plt.loglog(xr50/10,Nr50,'>',markersize=8,color=c1,label=r'$\sigma=0.50h_0$')
plt.loglog(xg2/10,Ng2,'d',markersize=8,color=c2,label=r'$\gamma=0.2l_p$')
plt.loglog(xg4/10,Ng4,'o',markersize=8,color=c2,label=r'$\gamma=0.4l_p$')
plt.loglog(xg10/10,Ng10,'s',markersize=8,color=c2,label=r'$\gamma=l_p$')
plt.loglog(xg20/10,Ng20,'^',markersize=8,color=c2,label=r'$\gamma=2l_p$')
plt.loglog(xg40/10,Ng40,'v',markersize=8,color=c2,label=r'$\gamma=4l_p$')
plt.loglog(xg100/10,Ng100,'<',markersize=8,color=c2,label=r'$\gamma=10l_p$')
plt.loglog(xg1000/10,Ng1000,'>',markersize=8,color=c2,label=r'$\gamma=100l_p$')
plt.legend(loc='upper right',prop={'size':17})
plt.xticks((10**0, 10**1, 10**2), (r'$10^{0}$', r'$10^{1}$', r'$10^{2}$'), fontsize=24)
