def save_image_model_data(self, output_filename):
"""
:param output_filename:
:return:
"""
output_dict = self.model.to_dict()
file_io.dict_2_h5(output_filename, output_dict)
def check_finesse(folder, recover=False):
data = h5_2_dict(join(folder, 'input_finesse.h5'))
ix = data['fit_ix']
Lpost, dpost = read_Ld_results(data['Ld_folder'])
i = np.random.choice(len(Lpost))
L = Lpost[i]
d = dpost[i]
r = data['r']
sig = data['sig']
analyzer = pymultinest.Analyzer(5,
outputfiles_basename=join(
folder, "finesse_"))
modes = analyzer.get_mode_stats()
#F, A, Arel, Ti, offset = modes['modes'][0]['mean']
F, A, Arel, Ti = modes['modes'][0]['mean']
post = analyzer.get_equal_weighted_posterior()
w0 = [487.873302, 487.98634]
mu = [232.03806, 39.948]
Lpost = Lpost[::30]
dpost = dpost[::30]
Fpost = post[::30, 0]
Apost = post[::30, 1]
Arelpost = post[::30, 2]
Tipost = post[::30, 3]
#offsetpost = post[::30, 4]
#offset_mean = np.mean(post[:, 4])
#offset_sd = np.std(post[:, 4])
print('F: {0:f} +/- {1:f}'.format(np.mean(post[:, 0]), np.std(post[:, 0])))
print('A: {0:e} +/- {1:e}'.format(np.mean(post[:, 1]), np.std(post[:, 1])))
print('Arel: {0:f} +/- {1:f}'.format(np.mean(post[:, 2]), np.std(post[:,
2])))
print('Ti Ar: {0:f} +/- {1:f}'.format(np.mean(post[:, 3]),
np.std(post[:, 3])))
#print('offset: {0:e} +/- {1:e}'.format(offset_mean, offset_sd))
if recover:
try:
post_dict = h5_2_dict(join(folder, "finesse_solver_model_post.h5"))
sig_post = post_dict["signal post"]
new_r = post_dict['new_r']
except IOError, e:
print(
"Can't recover finesse solver q posterior. Calculating from scratch."
)
#sig_post = calculate_signal_post(r[ix], Lpost, dpost, Fpost, Apost, Arelpost, Tipost, offsetpost, w0, mu)
new_r = np.linspace(0, 900, 1000)
# sig_post = calculate_signal_post(r[ix], Lpost, dpost, Fpost, Apost, Arelpost, Tipost, w0, mu)
sig_post = calculate_signal_post(new_r, Lpost, dpost, Fpost, Apost,
Arelpost, Tipost, w0, mu)
dict_2_h5(join(folder, "finesse_solver_model_post.h5"), {
'signal post': sig_post,
'new_r': new_r
})
def check_solution(folder,
Ld_dir,
finesse_dir,
recover=False,
w0=487.98634,
mu=39.948):
print("I'm here!")
data = h5_2_dict(join(folder, 'input_plasma_data.h5'))
ix = data['fit_ix']
r = data['r']
sig = data['sig']
Lpost, dpost = read_Ld_results(Ld_dir)
Fpost, _, _, _ = read_finesse_results(finesse_dir)
nL = len(Lpost)
nF = len(Fpost)
i = np.random.choice(nL)
j = np.random.choice(nF)
L = Lpost[i]
d = dpost[i]
F = Fpost[j]
Lstep = 100
Fstep = 100
Tistep = 100
analyzer = pymultinest.Analyzer(3,
outputfiles_basename=join(folder, "Ti_"))
modes = analyzer.get_mode_stats()
Ti, V, A = modes['modes'][0]['mean']
print(modes['modes'][0]['sigma'])
print(Ti, V, A)
post = analyzer.get_equal_weighted_posterior()
Tipost = post[::, 0]
Vpost = post[::, 1]
Apost = post[::, 2]
if recover:
try:
post_dict = h5_2_dict(join(folder, "Ti_solver_model_post.h5"))
sig_post = post_dict["signal post"]
except:
print(
"Can't recover Ti solver q posterior. Calculating from scratch."
)
sig_post = calculate_signal_post(r[ix],
Lpost[::Lstep],
dpost[::Lstep],
Fpost[::Fstep],
Tipost[::Tistep],
Vpost[::Tistep],
Apost[::Tistep],
w0,
mu,
nprocs=32)
dict_2_h5(join(folder, "Ti_solver_model_post.h5"),
{"signal post": sig_post})
else:
sig_post = calculate_signal_post(r[ix],
Lpost[::Lstep],
dpost[::Lstep],
Fpost[::Fstep],
Tipost[::Tistep],
Vpost[::Tistep],
Apost[::Tistep],
w0,
mu,
nprocs=32)
dict_2_h5(join(folder, "Ti_solver_model_post.h5"),
{"signal post": sig_post})
sig_mean = np.mean(sig_post, axis=1)
percentiles = calculate_percentile_ranges(sig_post)
#vals = forward_model(r[ix], L, d, F, w0, mu, A, Ti, V, sm_ang=False, nlambda=1024)
fig, ax = plt.subplots(figsize=(3.5, 3.5 / 1.61))
# ax.plot(r[ix], sig[ix], 'C1', alpha=0.5, label='Data')
ax.plot(r[ix], (sig[ix] - 3000.0) / 100.0, 'C1', alpha=0.5, label='Data')
#ax.plot(r[ix], vals, 'r')
alphas = [0.8, 0.5, 0.2]
keys = [68, 95, 99]
for alpha, per in zip(alphas, keys):
if per == 99:
# ax.fill_between(r[ix], percentiles[per][0], percentiles[per][1], color='C3', alpha=alpha, label='Fit')
ax.fill_between(r[ix],
percentiles[per][0] / 100.0,
percentiles[per][1] / 100.0,
color='C3',
alpha=alpha,
label='Fit')
else:
# ax.fill_between(r[ix], percentiles[per][0], percentiles[per][1], color='C3', alpha=alpha)
ax.fill_between(r[ix],
percentiles[per][0] / 100.0,
percentiles[per][1] / 100.0,
color='C3',
alpha=alpha)
fig.legend(frameon=False,
fontsize=8,
loc='upper right',
bbox_to_anchor=(0.5, 0.5))
ax.set_xlabel("R (px)", fontsize=8, labelpad=-1)
ax.set_ylabel("Counts (Hundreds)", fontsize=8, labelpad=-1)
ax.tick_params(labelsize=8)
#fig.tight_layout()
fig.savefig(join(folder, "Ti_Ar_fit.png"), dpi=400)
plt.show(block=False)
axis_labels = ["Ti (eV)", "V (m/s)", "A (Counts)"]
ylabels = ["P(Ti)", "P(V)", "P(A)"]
# fig, ax = plt.subplots(3, figsize=(6, 15))
fig, ax = plt.subplots(2, figsize=(3.5, 2 * 3.5 / 1.61))
# for n in range(3):
for n in range(2):
my_hist(ax[n], post[:, n])
ax[n].set_xlabel(axis_labels[n], fontsize=8, labelpad=-1)
ax[n].set_ylabel(ylabels[n], fontsize=8, labelpad=-1)
ax[n].tick_params(labelsize=8)
#fig.tight_layout()
fig.savefig(join(folder, "Ti_solver_histograms.png"), dpi=400)
plt.show()
fname = abspath(join(args.folder, "input_plasma_data.h5"))
basename = abspath(join(args.folder, 'Ti_'))
org_fname = abspath(join(args.folder, 'ringsum.h5'))
if not isfile(fname) or args.overwrite:
if isfile(org_fname):
data = h5_2_dict(org_fname)
r = data['r']
sig = data['sig']
error = data['sig_sd']
fit_ix, _ = get_fitting_region(r, sig, error)
maxval = np.max(sig[fit_ix])
amp_lim = [0.5 * maxval, 5.0 * maxval]
dict_2_h5(fname, {
'r': r,
'sig': sig,
'fit_ix': fit_ix,
'error': error
})
else:
raise ValueError('{0} does not exist!'.format(org_fname))
else:
a = h5_2_dict(fname)
r = a['r']
sig = a['sig']
fit_ix = a['fit_ix']
error = a['error']
maxval = np.max(sig[fit_ix])
amp_lim = [0.5 * maxval, 5.0 * maxval]
inputs = {
'error_per': args.error,
#sig_post = calculate_signal_post(r[ix], Lpost, dpost, Fpost, Apost, Arelpost, Tipost, offsetpost, w0, mu)
new_r = np.linspace(0, 900, 1000)
# sig_post = calculate_signal_post(r[ix], Lpost, dpost, Fpost, Apost, Arelpost, Tipost, w0, mu)
sig_post = calculate_signal_post(new_r, Lpost, dpost, Fpost, Apost,
Arelpost, Tipost, w0, mu)
dict_2_h5(join(folder, "finesse_solver_model_post.h5"), {
'signal post': sig_post,
'new_r': new_r
})
else:
new_r = np.linspace(0, 900, 1000)
#sig_post = calculate_signal_post(r[ix], Lpost, dpost, Fpost, Apost, Arelpost, Tipost, w0, mu)
sig_post = calculate_signal_post(new_r, Lpost, dpost, Fpost, Apost,
Arelpost, Tipost, w0, mu)
dict_2_h5(join(folder, "finesse_solver_model_post.h5"), {
'signal post': sig_post,
'new_r': new_r
})
sig_mean = np.mean(sig_post, axis=1)
sig_std = np.std(sig_post, axis=1)
percentiles = calculate_percentile_ranges(sig_post)
fig, ax = plt.subplots()
ax.plot(r[ix], sig[ix], 'C0', alpha=0.7)
#ax.plot(r[ix], sig_mean, 'C3')
alphas = [0.8, 0.5, 0.2]
#alphas = [0.9, 0.7, 0.5]
keys = [68, 95, 99]
for alpha, per in zip(alphas, keys):
#ax.fill_between(r[ix], percentiles[per][0], percentiles[per][1], color='C3', alpha=alpha)
ax.fill_between(new_r,
#i1 = np.abs(r - r1).argmin()
#i2 = np.abs(r - r2).argmin()+1
#sl = slice(i1, i2)
#data['sig_sd'][sl] = np.sqrt(data['sig_sd'][sl]**2 - (0.01*data['sig'][sl])**2 + (0.02*data['sig'][sl])**2)
#min_loc = np.argmin(sig)
# data['sig'] -= sig.min()
# data['sig'] -= 0.8 * sig.min()
# data['sig_sd'] = np.sqrt(data['sig_sd']**2 + data['sig_sd'][min_loc]**2) # Adding in the offset error
ix = get_fitting_region(r, sig, data['sig_sd'], plot_fit_region=True)
data['fit_ix'] = ix
fig, ax = plt.subplots()
ax.plot(r**2, data['sig'])
ax.plot(r[ix['0']]**2, data['sig'][ix['0']])
ax.fill_between(r**2,
data['sig'] - data['sig_sd'],
data['sig'] + data['sig_sd'],
alpha=0.5)
plt.show()
fig, ax = plt.subplots()
ax.plot(r[ix['0']], data['sig_sd'][ix['0']] / data['sig'][ix['0']])
plt.show()
#dict_2_h5(join(folder, 'finesse_input.h5'), data)
# dict_2_h5(join(folder, 'test_finesse_input.h5'), data)
dict_2_h5(join(folder, args.filename), data)
if args.overwrite:
resume = False
else:
resume = True
resume = False
if not isfile(fname) or args.overwrite:
if isfile(org_fname):
data = h5_2_dict(org_fname)
r = data['r']
sig = data['sig']
sig_sd = data['sig_sd']
pk_dir = join(args.folder,'multinest_peaks/')
prep_folder(pk_dir)
peaks, peaks_sd, orders = get_pk_locations(r, sig, sig_sd, args.wavelengths, pk_dir, pkerr=args.pkerr, pkthresh=args.pkthresh)
image_name = data['fname']
dict_2_h5(fname, {'r':r, 'sig':sig, 'peaks':peaks, 'orders':orders, 'peaks_sd':peaks_sd})
else:
raise ValueError('{0} does not exist!'.format(org_fname))
else:
a = h5_2_dict(fname)
peaks = a['peaks']
orders = a['orders']
peaks_sd = a['peaks_sd']
inputs = {'L_lim':args.L_lim, 'd_lim':args.d_lim, 'livepoints':args.livepoints, 'pkerr':args.pkerr}
dict_2_h5(fname, inputs, append=True)
if args.no_solve:
solver_in = None
else:
solver_in = {'peaks':peaks, 'orders':orders, 'basename':basename, 'peaks_sd':peaks_sd,
def main(fname,
bgfname=None,
color='b',
binsize=0.1,
xguess=None,
yguess=None,
block_center=False,
click_center=True,
find_center=True,
sub_prof=False,
plotit=False,
write=None,
npix=1,
return_tiff_mean=True,
tiff_image_idx=None):
bgdata = None
data = images.get_data(fname,
color=color,
return_mean=return_tiff_mean,
image_index=tiff_image_idx)
if npix > 1:
data = ringsum.super_pixelate(data, npix=npix)
if find_center:
if click_center:
xguess, yguess = plotting.center_plot(data)
x0, y0 = ringsum.locate_center(data,
xguess=xguess,
yguess=yguess,
block_center=block_center,
binsize=0.1,
plotit=True,
printit=True)
if plotit:
fig, ax = plt.subplots(figsize=(10, 8))
plotting.ring_plot(data, fax=(fig, ax))
ax.axhline(y0, color='b')
ax.axvline(x0, color='r')
fig.savefig('/home/milhone/fp_shot_2332.png', transparent=True)
plt.show()
else:
if xguess is None:
x0 = data.shape[1] / 2.
else:
x0 = xguess
if yguess is None:
y0 = data.shape[0] / 2.
else:
y0 = yguess
print('Performing Annual Sum...')
r, sig0, sig0_sd = ringsum.ringsum(data,
x0,
y0,
use_weighted=False,
quadrants=False,
binsize=binsize,
remove_hot_pixels=True)
if bgfname is not None:
print('Removing background...')
if bgdata is None:
bgdata = images.get_data(bgfname,
color=color,
return_mean=return_tiff_mean,
image_index=tiff_image_idx)
if npix > 1:
bgdata = ringsum.super_pixelate(bgdata, npix=npix)
_, bg, bg_sd = ringsum.ringsum(bgdata,
x0,
y0,
use_weighted=False,
binsize=binsize,
remove_hot_pixels=True)
sig = sig0 - bg
sig_sd = np.sqrt(sig0_sd**2 + bg_sd**2)
else:
sig, sig_sd = sig0, sig0_sd
dic = {
'fname': abspath(fname),
'color': color,
'center': (x0, y0),
'binsize': binsize,
'r': r,
'sig': sig,
'sig_sd': sig_sd
}
if bgfname is not None:
dic['bg_fname'] = abspath(bgfname)
if sub_prof:
dic['pk_guess'] = pk_guess
print('done!')
if write is not None:
file_io.prep_folder(write)
file_io.dict_2_h5(join(write, 'ringsum.h5'), dic)
if write is not None or plotit:
fig, axs = plt.subplots(2, 1, figsize=(12, 8))
axs[0].errorbar(r,
sig,
yerr=sig_sd,
fmt='-',
errorevery=5,
color='r',
lw=2,
zorder=10,
ecolor='b')
axs[0].axhline(0, color='k', alpha=0.7)
axs[0].set_title('binsize={0}'.format(binsize))
axs[1].errorbar(r,
sig0,
yerr=sig0_sd,
fmt='-',
errorevery=5,
lw=2,
label='raw',
zorder=10,
color='C0',
ecolor='C1')
axs[1].axhline(0, color='k', alpha=0.7)
if bgfname is not None:
axs[1].errorbar(r,
bg,
yerr=bg_sd,
fmt='-',
errorevery=5,
lw=2,
label='background',
zorder=10,
color='C2',
ecolor='C3')
axs[1].set_xlabel('R (px)')
axs[1].legend()
if write:
file_io.prep_folder(join(write, 'plots'))
plt.savefig(join(write, 'plots', 'ringsum.png'),
bbox_inches='tight')
if plotit:
plt.show()
else:
plt.close()
fig, ax = plt.subplots()
#ax.plot(r**2, sig, 'C1')
ax.errorbar(r, sig / 1000, yerr=sig_sd / 1000, color='C1')
#ax.plot(r, sig/1000.0, color='C1')
#ax.ticklabel_format(style='sci', axis='both', scilimits=(0,0))
#ax.ticklabel_format(style='sci', axis='y', scilimits=(0,0))
#ax.set_xlabel(r"R${}^2$ (px${}^2$)", fontsize=18)
ax.set_xlabel("R (px)", fontsize=18)
ax.set_ylabel("Counts ($10^3$)", fontsize=18)
ax.tick_params(labelsize=18)
fig.tight_layout()
#fig.savefig('fp_ringsum_2332.pdf', transparent=True)
plt.show()
#
fig, ax = plt.subplots()
ax.plot(r, sig_sd / sig)
plt.show()
#check_fwhm(r, sig-sig.min())
return dic
def main(w,
mass,
temp,
v_outer,
r_outer,
impact_factor,
Lnu,
fname,
rmax=42.0):
warr, spectrum = plasma.calculate_pcx_chord_emission(impact_factor,
temp,
w,
mass,
Lnu,
v_outer,
rmax=rmax,
nr=500,
nlambda=2000,
Lne=4.0,
R_outer=r_outer)
L = 150.0 / 0.004
d = 0.88
F = 20.7
print('Impact Factor', impact_factor)
print('Ti: ', temp)
print('w0: ', w)
print('mu: ', mass)
print('Lnu: ', Lnu)
print('Vouter: ', v_outer)
print('Router: ', r_outer)
print('Rmax: ', rmax)
print('L: ', L)
print('d: ', d)
print('F: ', F)
r, theta, x = plasma.calculate_r_theta_x_from_impact_factor(impact_factor,
rmax=rmax,
npts=500)
vel = plasma.pcx_velocity_profile(r, Lnu, r_outer, v_outer)
plt.plot(r, vel)
plt.show()
raw_input('pausing...')
nx = 6000
ny = 4000
data = np.zeros((ny, nx))
x = np.arange(1, nx + 1, 1)
y = np.arange(1, ny + 1, 1)
x0 = 3000
y0 = 2000
XX, YY = np.meshgrid(x, y)
R = np.sqrt((XX - x0)**2 + (YY - y0)**2)
nprocs = 32
split_r = np.array_split(R.flatten(), nprocs)
results = [0.0 for _ in split_r]
t0 = time.time()
with concurrent.futures.ProcessPoolExecutor() as executor:
fut_to_spl = dict()
for idx, split in enumerate(split_r):
future = executor.submit(models.general_model, split, L, d, F,
warr, spectrum)
fut_to_spl[future] = idx
for future in concurrent.futures.as_completed(fut_to_spl):
current_idx = fut_to_spl[future]
output = future.result()
results[current_idx] = output
results = np.concatenate(results)
results.shape = (ny, nx)
results *= 1000.0 / results.max()
t1 = time.time()
print(t1 - t0, 'seconds')
fig, ax = plt.subplots()
im = ax.imshow(results)
plt.colorbar(im, ax=ax)
plt.show()
x0, y0 = ringsum.locate_center(results, xguess=3000, yguess=2000)
rr, ss, _ = ringsum.ringsum(results, x0, y0)
rrr = np.linspace(1, 1750, 5000)
actual = models.general_model(rrr, L, d, F, warr, spectrum)
fig, ax = plt.subplots()
ax.plot(rr, ss / ss.max(), 'C0', label='ringsum')
ax.plot(rrr, actual / actual.max(), 'C1', label='actual')
ax.legend()
plt.show()
#results = results.astype(int)
#results = np.asarray(results, dtype=np.int16)
image_data = {
'image': results,
'L': L,
'd': d,
'F': F,
'Vouter': v_outer,
'R_outer': r_outer,
'Ti': temp,
'w0': w,
'mu': mass,
'Lnu': Lnu,
'impact_factor': impact_factor
}
file_io.dict_2_h5(fname, image_data)
Ti = 0.5
Vouter = 1000.0
Router = 35.0
Rmax = 42.0
impact_fac = 35.0
ne = 2e17
nn = 8e17
# mom_dif_length = 20.0
mom_dif_length = 100.0 * plasma.Lnu(ne * nn, Ti, mu=40.0)
fname = 'pcx_vel_profile_{0:2.0f}.h5'.format(impact_fac)
print(fname)
main(w0,
mu,
Ti,
Vouter,
Router,
impact_fac,
mom_dif_length,
fname,
rmax=Rmax)
data = file_io.h5_2_dict(fname)
data['image'] = add_noise(data['image'])
file_io.dict_2_h5(fname, data)
# fig, ax = plt.subplots()
# im = ax.imshow(data['image'])
# plt.colorbar(im)
# plt.show()
