def parabola_plots(table, params):
extractor = DBExtractor(table)
parabola_list = ["teff_2", "gamma", "rv"]
for par in parabola_list:
df = extractor.simple_extraction(columns=[par])
unique_par = list(set(df[par].values))
unique_par.sort()
print("Unique ", par, " values =", unique_par)
for chi2_val, npix_val in zip(chi2_names, npix_names):
min_chi2 = []
for unique_val in unique_par:
df_chi2 = extractor.fixed_ordered_extraction(columns=[par, chi2_val], order_by=chi2_val,
fixed={par: float(unique_val)}, limit=3, asc=True)
min_chi2.append(df_chi2[chi2_val].values[0])
plt.plot(unique_par, min_chi2, ".-", label=chi2_val)
# popt, _ = curve_fit(parabola, unique_par, min_chi2)
popt, _ = fit_chi2_parabola(unique_par, min_chi2)
x = np.linspace(unique_par[0], unique_par[-1], 40)
plt.plot(x, parabola(x, *popt), "--")
plt.xlabel(r"${0}$".format(par))
plt.ylabel(r"$\chi^2$")
plt.legend()
filename = "Parabola_fit_{0}-{1}_{2}_param_{3}_{4}.png".format(
params["star"], params["obsnum"], params["chip"], par, params["suffix"])
plt.savefig(os.path.join(params["path"], "plots", filename))
plt.close()
print("saved parabolas for ", par)
plt.close()
def smallest_chi2_values(table, params, num=10):
"""Find smallest chi2 in table."""
chi2_val = "chi2_1" # "coadd_chi2"
df = DBExtractor(table).ordered_extraction(order_by=chi2_val,
limit=num,
asc=True)
df[chi2_val] = reduced_chi_squared(df[chi2_val],
params["npix"]["coadd_npix"],
params["npars"])
df_min = df[:1]
print("Smallest Co-add reduced Chi2 values in the database.")
print(df.head(n=num))
# name = "{0}-{1}_{2}_test_smallest_chi2_{3}.pdf".format(
# params["star"], params["obsnum"], params["chip"], params["suffix"])
name = "minimum_coadd_chi2_db_output_{0}_{1}_{2}.csv".format(
params["star"], params["obsnum"], params["suffix"])
from bin.check_result import main as visual_inspection
df.to_csv(os.path.join(params["path"], name))
plot_name = os.path.join(
params["path"], "plots",
"visual_inspection_min_chi2_coadd_{0}_{1}_{2}.png".format(
params["star"], params["obsnum"], params["suffix"]))
visual_inspection(params["star"],
params["obsnum"],
float(df_min.teff_1),
float(df_min.logg_1),
float(df_min.feh_1),
None,
None,
None,
gamma=float(df_min.gamma),
rv=0.0,
plot_name=plot_name)
def get_column_limits(table, params):
extractor = DBExtractor(table)
print("Database Column Value Ranges")
for col in extractor.cols.keys():
min_df = extractor.ordered_extraction(order_by=col, columns=[col], limit=1, asc=True)
max_df = extractor.ordered_extraction(order_by=col, columns=[col], limit=1, asc=False)
print("{0:10}\t\t{1:5.3} - {2:5.3}".format(col, float(min_df[col].values[0]), float(max_df[col].values[0])))
def contrast_iam_results(table, params):
extractor = DBExtractor(table)
star_name = params["star"]
obsnum = params["obsnum"]
___, host_params, ___ = iam_helper_function(star_name, obsnum, 1)
h_temp, h_logg, h_feh = host_params['temp'], host_params['logg'], host_params["fe_h"]
c_temp = host_params.get("comp_temp")
print(
"Observation {4} - {5}\n"
"Expected Parameters\n---------------------\n"
"teff={0:5.0f} logg={1:3.02f} feh={2:4.01f} \tcompanion_temp={3:5.0f} ".format(h_temp, h_logg, h_feh, c_temp,
star_name, obsnum))
print("IAM SOLUTIONS\n---------------------")
for ii, chi2_val in enumerate(chi2_names):
df = extractor.minimum_value_of(chi2_val)
print(
"{0:10} solution:\nCompanion: teff_2={1:5.0f} logg2={2:4.02f} ".format(chi2_val, df.teff_2.values[0],
df.logg_2.values[0]) +
"feh2={0:4.01f} gamma={1:4.01f} rv={2:4.01f} ".format(df.feh_2.values[0], float(df.gamma.values[0]),
float(df.rv.values[0])) +
"Host: teff={0:5.0f} logg={1:4.02f} feh={2:4.01f} chi2={3:8.02f} median alpha={4:5.03f}".format(
df.teff_1.values[0],
df.logg_1.values[0],
df.feh_1.values[0],
df[chi2_val].values[0],
np.median([df["alpha_1"].values[0],
df["alpha_2"].values[0],
df["alpha_3"].values[0],
df["alpha_4"].values[0]])))
def host_parameters_reduced_gamma_individual(table, params):
print("Fixed host analysis with reduced gamma individual plots.")
extractor = DBExtractor(table)
d_gamma = 5
nrows, ncols = 1, 1
for jj, (chi2_val, npix_val) in enumerate(zip(chi2_names, npix_names)):
red_chi2 = "red_{0}".format(chi2_val)
if jj == 4:
chi2legend = "coadd"
else:
chi2legend = "det {0}".format(jj + 1)
# Select lowest chi square gamma values.
df = extractor.ordered_extraction(order_by=chi2_val,
columns=["gamma", chi2_val],
limit=1)
min_chi2_gamma = df.loc[0, "gamma"]
upper_lim = min_chi2_gamma + d_gamma
lower_lim = min_chi2_gamma - d_gamma
columns = ["teff_1", "logg_1", "feh_1", "gamma"]
for ii, col in enumerate(columns):
df = extractor.simple_extraction(
columns={col, chi2_val, "gamma", "teff_1"})
df = df[[
(df.gamma > float(lower_lim)) & (df.gamma < float(upper_lim))
]]
df[red_chi2] = reduced_chi_squared(df[chi2_val],
params["npix"][npix_val],
params["npars"])
fig, axes = plt.subplots(nrows, ncols)
fig.tight_layout()
df.plot(x=col,
y=red_chi2,
kind="scatter",
ax=axes,
label=chi2legend)
plt.suptitle("Coadd {2}-reduced Chi**2 Results: {0}-{1}".format(
params["star"], params["obsnum"], col))
name = "{0}-{1}_coadd_fixed_host_params_{2}_{3}_individual_{4}.png".format(
params["star"], params["obsnum"], params["suffix"], chi2_val,
col)
fig.savefig(os.path.join(params["path"], "plots", name))
fig.savefig(
os.path.join(params["path"], "plots",
name.replace(".pdf", ".png")))
plt.close()
plt.close()
def display_bhm_xcorr_values(table, params):
extractor = DBExtractor(table)
fig, axarr = plt.subplots(3)
for ii, xcorr in enumerate(
[r"xcorr_1", r"xcorr_2", r"xcorr_3", r"xcorr_4"]):
df = extractor.simple_extraction(["gamma", xcorr, "teff_1"])
c = axarr[0].scatter(xshift(df["gamma"], ii),
df[xcorr],
c=df[r"teff_1"].values,
alpha=0.9,
label=xcorr)
axarr[0].set_xlabel(r'host rv offset', fontsize=12)
axarr[0].set_ylabel(r'Arbitrary norm', fontsize=12)
axarr[0].set_title(r'Arbitrary normalization.')
d = axarr[1].scatter(xshift(df[r"gamma"], ii),
df[xcorr],
c=df[r"teff_1"].values,
alpha=0.9,
label=xcorr)
axarr[1].set_xlabel(r'$\gamma$ offset', fontsize=12)
axarr[1].set_ylabel(r'Arbitrary norm', fontsize=12)
axarr[1].set_title(r'$\gamma$.')
e = axarr[2].scatter(xshift(df[r"teff_1"], ii),
df[xcorr],
c=df[r"gamma"].values,
alpha=0.9,
label=xcorr)
axarr[2].set_xlabel(r'Companion temperature', fontsize=15)
axarr[2].set_ylabel(r'Arbitrary norm ', fontsize=15)
axarr[2].set_title(r'Companion Temperature')
axarr[0].grid(True)
axarr[1].grid(True)
axarr[2].grid(True)
cbar0 = plt.colorbar(c)
cbar0.ax.set_ylabel(r" teff_1")
cbar1 = plt.colorbar(d)
cbar1.ax.set_ylabel(r" teff_1")
cbar2 = plt.colorbar(e)
cbar1.ax.set_ylabel(r"$\gamma$")
fig.tight_layout()
fig.suptitle("Arbitrary normalization used, \n slight shift with detetor")
name = "{0}-{1}_{2}_plot_xcorr_value_{3}.pdf".format(
params["star"], params["obsnum"], params["chip"], params["suffix"])
plt.savefig(os.path.join(params["path"], "plots", name))
plt.savefig(
os.path.join(params["path"], "plots", name.replace(".pdf", ".png")))
plt.close()
def fix_host_parameters_individual(table, params):
nrows, ncols = 1, 1
columns = ["teff_2", "logg_2", "feh_2", "gamma", "rv"]
extractor = DBExtractor(table)
for ii, col in enumerate(columns):
for jj, (chi2_val, npix_val) in enumerate(zip(chi2_names, npix_names)):
if jj == 4:
chi2legend = "coadd chi2"
else:
chi2legend = "det {0}".format(jj + 1)
red_chi2 = "red_{0}".format(chi2_val)
fig, axes = plt.subplots(nrows, ncols)
fig.tight_layout()
fixed_params = {"teff_1": params["teff"], "logg_1": params["logg"], "feh_1": params["fe_h"]}
df = extractor(columns=[col, chi2_val], fixed=fixed_params)
df[red_chi2] = reduced_chi_squared(df[chi2_val], params["npix"][npix_val], params["npars"])
df.plot(x=col, y=chi2_val, kind="scatter",
ax=axes, label=chi2legend)
name = "{0}-{1}_coadd_fixed_host_params_full_gamma_{2}_{3}_individual_{4}.png".format(
params["star"], params["obsnum"], params["suffix"], chi2_val, col)
plt.suptitle("Co-add {2}-Chi**2 Results (Fixed host): {0}-{1}: {3}".format(
params["star"], params["obsnum"], chi2_val, col))
fig.savefig(os.path.join(params["path"], "plots", name))
fig.savefig(os.path.join(params["path"], "plots", name.replace(".pdf", ".png")))
plt.close()
plt.close()
def rv_plot(table, params):
for chi2_val, npix_val in zip(chi2_names, npix_names):
red_chi2 = "red_{0}".format(chi2_val)
df = DBExtractor(table).simple_extraction(columns=["rv", chi2_val, "teff_2"])
df[red_chi2] = reduced_chi_squared(df[chi2_val], params["npix"][npix_val], params["npars"])
fig, ax = plt.subplots()
c = ax.scatter(df["rv"], df[chi2_val], c=df["teff_2"], alpha=0.8)
cbar = plt.colorbar(c)
cbar.ax.set_ylabel(r"teff_2")
ax.set_xlabel(r'RV offset', fontsize=12)
ax.set_ylabel(r"${0}$".format(chi2_val), fontsize=12)
ax.set_title(r'$teff_2$ (color) and companion temperature.')
ax.grid(True)
fig.tight_layout()
name = "{0}-{1}_{2}_scatter_rv_{3}_{4}.pdf".format(
params["star"], params["obsnum"], params["chip"], chi2_val, params["suffix"])
plt.savefig(os.path.join(params["path"], "plots", name))
plt.savefig(os.path.join(params["path"], "plots", name.replace(".pdf", ".png")))
plt.close()
fig, ax = plt.subplots()
c = ax.scatter(df["rv"], df[red_chi2], c=df["teff_2"], alpha=0.8)
cbar = plt.colorbar(c)
cbar.ax.set_ylabel(r"teff_2")
ax.set_xlabel(r'RV offset', fontsize=12)
ax.set_ylabel(r"${0}$".format(red_chi2), fontsize=12)
ax.set_title(r'$teff_2$ (color) and companion temperature.')
ax.grid(True)
fig.tight_layout()
name = "{0}-{1}_{2}_scatter_rv_reduced_{3}_{4}.pdf".format(
params["star"], params["obsnum"], params["chip"], chi2_val, params["suffix"])
plt.savefig(os.path.join(params["path"], "plots", name))
plt.savefig(os.path.join(params["path"], "plots", name.replace(".pdf", ".png")))
plt.close()
def get_npix_values(table):
npix_values = {}
df_npix = DBExtractor(table).simple_extraction(columns=npix_names)
for col in npix_names:
assert len(set(df_npix[col].values)) == 1
npix_values[col] = df_npix[col].values[0]
return npix_values
def contours(table, params):
extractor = DBExtractor(table)
for par_limit, contour_param in zip(["gamma", "rv"], ["rv", "gamma"]):
fixed_params = {"teff_1": params["teff"], "logg_1": params["logg"], "feh_1": params["fe_h"],
"logg_2": params["logg"], "feh_2": params["fe_h"]}
for chi2_val, npix_val in zip(chi2_names, npix_names):
df_min_chi2 = extractor.minimum_value_of(chi2_val)
fixed_params.update({par_limit: float(df_min_chi2[par_limit][0])})
df = extractor.fixed_extraction(columns=["teff_2", "rv", "gamma", chi2_val],
fixed=fixed_params)
params["this_npix"] = params["npix"][npix_val]
params["par_limit"] = par_limit
pars = [contour_param, "teff_2", chi2_val]
dataframe_contour(df, xcol=pars[0], ycol=pars[1], zcol=pars[2], params=params)
# Using Reduced chi2 value
for par_limit, contour_param in zip(["gamma", "rv"], ["rv", "gamma"]):
fixed_params = {"teff_1": params["teff"], "logg_1": params["logg"], "feh_1": params["fe_h"],
"logg_2": params["logg"], "feh_2": params["fe_h"]}
for chi2_val, npix_val in zip(chi2_names, npix_names):
red_chi2 = "red_{0}".format(chi2_val)
df_min_chi2 = extractor.minimum_value_of(chi2_val)
fixed_params.update({par_limit: float(df_min_chi2[par_limit][0])})
df = extractor.fixed_extraction(columns=["teff_2", "rv", "gamma", chi2_val],
fixed=fixed_params)
df[red_chi2] = reduced_chi_squared(df[chi2_val], params["npix"][npix_val], params["npars"])
params["this_npix"] = params["npix"][npix_val]
params["par_limit"] = par_limit
pars = [contour_param, "teff_2", red_chi2]
dataframe_contour(df, xcol=pars[0], ycol=pars[1], zcol=pars[2], params=params)
# Using teff_1 contour
for par_limit, contour_param in zip(["gamma", "rv"], ["rv", "gamma"]):
fixed_params = {"logg_1": params["logg"], "feh_1": params["fe_h"],
"logg_2": params["logg"], "feh_2": params["fe_h"]}
for chi2_val, npix_val in zip(chi2_names, npix_names):
df_min_chi2 = extractor.minimum_value_of(chi2_val)
fixed_params.update({par_limit: df_min_chi2[par_limit].values[0],
"teff_2": df_min_chi2["teff_2"].values[0]})
df = extractor.fixed_extraction(columns=["teff_1", "rv", "gamma", chi2_val],
fixed=fixed_params)
params["this_npix"] = params["npix"][npix_val]
params["par_limit"] = par_limit
pars = [contour_param, "teff_1", chi2_val]
dataframe_contour(df, xcol=pars[0], ycol=pars[1], zcol=pars[2], params=params)
def contrast_bhm_results(table, params):
extractor = DBExtractor(table)
star_name = params["star"]
obsnum = params["obsnum"]
___, host_params, ___ = bhm_helper_function(star_name, obsnum, 1)
h_temp, h_logg, h_feh = host_params['temp'], host_params[
'logg'], host_params["fe_h"]
print(
"Expected Parameters\n---------------------\nteff={0}\tlogg={1}\tfeh={2}"
.format(h_temp, h_logg, h_feh))
print("BHM SOLUTIONS\n---------------------")
for ii, chi2_val in enumerate(chi2_names):
df = extractor.minimum_value_of(chi2_val)
print("{0}: teff={1:5}\tlogg={2:3.02}\t".format(
chi2_val, df.teff_1.values[0], df.logg_1.values[0]) +
"feh={0:4.1}\tgamma={1:3.2},\txcorr={2:3.2},\tchi2={3:8.03}".
format(df.feh_1.values[0], float(df.gamma.values[0]),
df.xcorr_1.values[0], df[chi2_val].values[0]))
def test_figure(table, params):
chi2_val = "coadd_chi2"
df = DBExtractor(table).simple_extraction(columns=["gamma", chi2_val], limit=10000)
fig, ax = plt.subplots()
red_chi2 = reduced_chi_squared(df[chi2_val], params["npix"]["coadd_npix"], params["npars"])
ax.scatter(df["gamma"], red_chi2, s=3, alpha=0.5)
ax.set_xlabel(r'$\gamma$', fontsize=15)
ax.set_ylabel(r"$ Reduced {0}$".format(chi2_val), fontsize=15)
ax.set_title(r'$\gamma$ and $\chi^2$.')
ax.grid(True)
fig.tight_layout()
name = "{0}-{1}_{2}_red_test_figure_{3}_{4}.pdf".format(
params["star"], params["obsnum"], params["chip"], chi2_val, params["suffix"])
plt.savefig(os.path.join(params["path"], "plots", name))
plt.close()
def contours(table, params):
extractor = DBExtractor(table)
for chi2_val, npix_val in zip(chi2_names, npix_names):
df_min_chi2 = extractor.minimum_value_of(chi2_val)
fixed_params = {
"logg_1": float(df_min_chi2["logg_1"].values[0]),
"feh_1": float(df_min_chi2["feh_1"].values[0])
}
df = extractor.fixed_extraction(
columns=["teff_1", "feh_1", "logg_1", "gamma", chi2_val],
fixed=fixed_params)
params["this_npix"] = params["npix"][npix_val]
params["chi2_value"] = chi2_val
pars = ["gamma", "teff_1", chi2_val]
dataframe_contour(df,
xcol=pars[0],
ycol=pars[1],
zcol=pars[2],
params=params)
# Reduced chi2
for chi2_val, npix_val in zip(chi2_names, npix_names):
red_chi2 = "red_{0}".format(chi2_val)
df_min_chi2 = extractor.minimum_value_of(chi2_val)
fixed_params = {
"logg_1": float(df_min_chi2["logg_1"].values[0]),
"feh_1": float(df_min_chi2["feh_1"].values[0])
}
df = extractor.fixed_extraction(
columns=["teff_1", "feh_1", "logg_1", "gamma", chi2_val],
fixed=fixed_params)
df[red_chi2] = reduced_chi_squared(df[chi2_val],
params["npix"][npix_val],
params["npars"])
params["this_npix"] = params["npix"][npix_val]
params["chi2_value"] = chi2_val
pars = ["gamma", "teff_1", red_chi2]
dataframe_contour(df,
xcol=pars[0],
ycol=pars[1],
zcol=pars[2],
params=params)
def fix_host_parameters_reduced_gamma(table, params):
print("Fixed host analysis with reduced gamma.")
extractor = DBExtractor(table)
d_gamma = 5
nrows, ncols = 3, 2
columns = ["teff_2", "logg_2", "feh_2", "gamma", "rv"]
assert len(columns) <= (nrows * ncols)
fig, axes = plt.subplots(nrows, ncols)
fig.tight_layout()
indices = np.arange(nrows * ncols).reshape(nrows, ncols)
for jj, (chi2_val, npix_val) in enumerate(zip(chi2_names, npix_names)):
if jj == 4:
chi2legend = "coadd"
else:
chi2legend = "det {0}".format(jj + 1)
# Select lowest chi square gamma values.
df = extractor.ordered_extraction(order_by=chi2_val, columns=["gamma", chi2_val], limit=1)
min_chi2_gamma = df.loc[0, "gamma"]
upper_lim = min_chi2_gamma + d_gamma
lower_lim = min_chi2_gamma - d_gamma
for ii, col in enumerate(columns):
fixed_values = {"teff_1": int(params["teff"]), "logg_1": float(params["logg"]),
"feh_1": float(params["fe_h"])}
df = extractor.fixed_extraction(columns={col, chi2_val, "gamma", "teff_1"},
fixed=fixed_values)
df = df[[(df.gamma > float(lower_lim)) & (df.gamma < float(upper_lim))]]
axis_pos = [int(x) for x in np.where(indices == ii)]
df.plot(x=col, y=chi2_val, kind="scatter",
ax=axes[axis_pos[0], axis_pos[1]], label=chi2legend)
plt.suptitle("Coadd Chi**2 Results: {0}-{1}".format(params["star"], params["obsnum"]))
name = "{0}-{1}_coadd_fixed_host_params_{2}.png".format(
params["star"], params["obsnum"], params["suffix"])
fig.savefig(os.path.join(params["path"], "plots", name))
fig.savefig(os.path.join(params["path"], "plots", name.replace(".pdf", ".png")))
plt.close()
for jj, (chi2_val, npix_val) in enumerate(zip(chi2_names, npix_names)):
red_chi2 = "red_{0}".format(chi2_val)
if jj == 4:
chi2legend = "coadd"
else:
chi2legend = "det {0}".format(jj + 1)
# Select lowest chi square gamma values.
df = extractor.ordered_extraction(order_by=chi2_val, columns=["gamma", chi2_val], limit=1)
min_chi2_gamma = df.loc[0, "gamma"]
upper_lim = min_chi2_gamma + d_gamma
lower_lim = min_chi2_gamma - d_gamma
for ii, col in enumerate(columns):
fixed_values = {"teff_1": int(params["teff"]), "logg_1": float(params["logg"]),
"feh_1": float(params["fe_h"])}
df = extractor.fixed_extraction(columns={col, chi2_val, "gamma", "teff_1"},
fixed=fixed_values)
df = df[[(df.gamma > float(lower_lim)) & (df.gamma < float(upper_lim))]]
df[red_chi2] = reduced_chi_squared(df[chi2_val], params["npix"][npix_val], params["npars"])
axis_pos = [int(x) for x in np.where(indices == ii)]
df.plot(x=col, y=red_chi2, kind="scatter",
ax=axes[axis_pos[0], axis_pos[1]], label=chi2legend)
plt.suptitle("Coadd reduced Chi**2 Results: {0}-{1}".format(params["star"], params["obsnum"]))
name = "{0}-{1}_coadd_fixed_host_params_{2}.png".format(
params["star"], params["obsnum"], params["suffix"])
fig.savefig(os.path.join(params["path"], "plots", name))
fig.savefig(os.path.join(params["path"], "plots", name.replace(".pdf", ".png")))
plt.close()
fix_host_parameters_reduced_gamma_individual(table, params)
def compare_spectra(table, params):
"""Plot the min chi2 result against the observations."""
extractor = DBExtractor(table)
gamma_df = extractor.simple_extraction(columns=["gamma"])
extreme_gammas = [min(gamma_df.gamma.values), max(gamma_df.gamma.values)]
for ii, chi2_val in enumerate(chi2_names[0:-2]):
df = extractor.ordered_extraction(
columns=["teff_1", "logg_1", "feh_1", "gamma", chi2_val],
order_by=chi2_val,
limit=1,
asc=True)
params1 = [
df["teff_1"].values[0], df["logg_1"].values[0],
df["feh_1"].values[0]
]
params1 = [float(param1) for param1 in params1]
gamma = df["gamma"].values
obs_name, obs_params, output_prefix = bhm_helper_function(
params["star"], params["obsnum"], ii + 1)
print(obs_name)
obs_spec = load_spectrum(obs_name)
# Mask out bad portion of observed spectra
# obs_spec = spectrum_masking(obs_spec, params["star"], params["obsnum"], ii + 1)
# Barycentric correct spectrum
_obs_spec = barycorr_crires_spectrum(obs_spec, extra_offset=None)
normalization_limits = [obs_spec.xaxis[0] - 5, obs_spec.xaxis[-1] + 5]
# models
# print("params for models", params1)
mod1 = load_starfish_spectrum(params1,
limits=normalization_limits,
hdr=True,
normalize=False,
area_scale=True,
flux_rescale=True)
bhm_grid_func = one_comp_model(mod1.xaxis, mod1.flux, gammas=gamma)
bhm_upper_gamma = one_comp_model(mod1.xaxis,
mod1.flux,
gammas=extreme_gammas[1])
bhm_lower_gamma = one_comp_model(mod1.xaxis,
mod1.flux,
gammas=extreme_gammas[0])
bhm_grid_model = bhm_grid_func(obs_spec.xaxis).squeeze()
bhm_grid_model_full = bhm_grid_func(mod1.xaxis).squeeze()
bhm_upper_gamma = bhm_upper_gamma(obs_spec.xaxis).squeeze()
bhm_lower_gamma = bhm_lower_gamma(obs_spec.xaxis).squeeze()
model_spec_full = Spectrum(flux=bhm_grid_model_full, xaxis=mod1.xaxis)
model_spec = Spectrum(flux=bhm_grid_model, xaxis=obs_spec.xaxis)
bhm_upper_gamma = Spectrum(flux=bhm_upper_gamma, xaxis=obs_spec.xaxis)
bhm_lower_gamma = Spectrum(flux=bhm_lower_gamma, xaxis=obs_spec.xaxis)
model_spec = model_spec.remove_nans()
model_spec = model_spec.normalize(method="exponential")
model_spec_full = model_spec_full.remove_nans()
model_spec_full = model_spec_full.normalize(method="exponential")
bhm_lower_gamma = bhm_lower_gamma.remove_nans()
bhm_lower_gamma = bhm_lower_gamma.normalize(method="exponential")
bhm_upper_gamma = bhm_upper_gamma.remove_nans()
bhm_upper_gamma = bhm_upper_gamma.normalize(method="exponential")
from mingle.utilities.chisqr import chi_squared
chisqr = chi_squared(obs_spec.flux, model_spec.flux)
print("Recomputed chi^2 = {0}".format(chisqr))
print("Database chi^2 = {0}".format(df[chi2_val]))
fig, ax = plt.subplots(1, 1, figsize=(15, 8))
plt.plot(obs_spec.xaxis,
obs_spec.flux + 0.01,
label="0.05 + Observation, {}".format(obs_name))
plt.plot(model_spec.xaxis,
model_spec.flux,
label="Minimum \chi^2 model")
plt.plot(model_spec_full.xaxis,
model_spec_full.flux,
"--",
label="Model_full_res")
plt.plot(bhm_lower_gamma.xaxis,
bhm_lower_gamma.flux,
"-.",
label="gamma={}".format(extreme_gammas[0]))
plt.plot(bhm_upper_gamma.xaxis,
bhm_upper_gamma.flux,
":",
label="gamma={}".format(extreme_gammas[1]))
plt.title("bhm spectrum")
plt.legend()
fig.tight_layout()
name = "{0}-{1}_{2}_{3}_bhm_min_chi2_spectrum_comparison_{4}.png".format(
params["star"], params["obsnum"], params["chip"], chi2_val,
params["suffix"])
plt.savefig(os.path.join(params["path"], "plots", name))
plt.close()
plt.plot(obs_spec.xaxis, obs_spec.flux, label="Observation")
plt.show()
def chi2_individual_parabola_plots(table, params):
extractor = DBExtractor(table)
parabola_list = ["teff_1", "logg_1", "feh_1", "gamma"]
for par in parabola_list:
df = extractor.simple_extraction(columns=[par])
unique_par = list(set(df[par].values))
unique_par.sort()
for chi2_val, npix_val in zip(chi2_names, npix_names):
min_chi2 = []
for unique_val in unique_par:
df_chi2 = extractor.fixed_ordered_extraction(
columns=[par, chi2_val],
order_by=chi2_val,
limit=3,
fixed={par: float(unique_val)},
asc=True)
min_chi2.append(df_chi2[chi2_val].values[0])
# min_chi2 = reduced_chi_squared(min_chi2, params["npix"][npix_val], params["npars"])
min_chi2 = min_chi2 - min(min_chi2)
plt.plot(unique_par, min_chi2, ".-", label=chi2_val)
# popt, _ = curve_fit(parabola, unique_par, min_chi2)
popt, _ = fit_chi2_parabola(unique_par, min_chi2)
# print("params", popt)
x = np.linspace(unique_par[0], unique_par[-1], 40)
plt.plot(x, parabola(x, *popt)) # , label="parabola")
plt.xlabel(r"${0}$".format(par))
plt.ylabel(r"$\Delta \chi^2$ from mimimum")
plt.ylim([-0.05 * np.max(min_chi2), np.max(min_chi2)])
# Find roots
try:
residual = lambda x: parabola(x, *popt) - chi2_at_sigma(
1, params["npars"])
min_chi2_par = unique_par[np.argmin(min_chi2)]
min_chi2_par.astype(np.float64)
try:
lower_bound = newton(
residual,
(min_chi2_par + unique_par[0]) / 2) - min_chi2_par
except RuntimeError as e:
print(e)
lower_bound = np.nan
try:
upper_bound = newton(
residual,
(min_chi2_par + unique_par[-1]) / 2) - min_chi2_par
except RuntimeError as e:
print(e)
upper_bound = np.nan
print("min_chi2_par", min_chi2_par,
type(min_chi2_par), "\nlower_bound", lower_bound,
type(lower_bound), "\nupper_bound", upper_bound,
type(upper_bound))
print("{0} solution {1: 5.3} {2:+5.3} {3:+5.3}".format(
chi2_val, float(min_chi2_par), float(lower_bound),
float(upper_bound)))
plt.annotate("{0: 5.3f} {1:+5.3f} {2:+5.3f}".format(
float(min_chi2_par), (lower_bound), (upper_bound)),
xy=(float(min_chi2_par), 0),
xytext=(0.4, 0.5),
textcoords="figure fraction",
arrowprops={"arrowstyle": "->"})
except Exception as e:
print(e)
logging.warning("Could not Annotate the contour plot")
plt.axhline(y=chi2_at_sigma(1, params["npars"]), label="1 sigma")
plt.axhline(y=chi2_at_sigma(2, params["npars"]), label="2 sigma")
plt.axhline(y=chi2_at_sigma(3, params["npars"]), label="3 sigma")
plt.legend()
filename = "Chi2_Parabola_fit_{0}-{1}_{2}_param_{3}_{4}_individual_{5}.png".format(
params["star"], params["obsnum"], params["chip"], par,
params["suffix"], chi2_val)
plt.savefig(os.path.join(params["path"], "plots", filename))
plt.close()
print("saved individual chi2 parabolas for ", par)
plt.close()
def host_parameters(table, params):
extractor = DBExtractor(table)
print("Fixed host analysis.")
nrows, ncols = 3, 2
columns = ["teff_1", "logg_1", "feh_1", "gamma"]
assert len(columns) <= (nrows * ncols)
for jj, (chi2_val, npix_val) in enumerate(zip(chi2_names, npix_names)):
if jj == 4:
chi2legend = "coadd chi2"
else:
chi2legend = "det {0}".format(jj + 1)
fig, axes = plt.subplots(nrows, ncols)
fig.tight_layout()
indices = np.arange(nrows * ncols).reshape(nrows, ncols)
for ii, col in enumerate(columns):
df = extractor.fixed_extraction([col, chi2_val],
fixed={
"logg_1": params["logg"],
"feh_1": params["fe_h"]
})
axis_pos = [int(x) for x in np.where(indices == ii)]
df.plot(x=col,
y=chi2_val,
kind="scatter",
ax=axes[axis_pos[0], axis_pos[1]],
label=chi2legend) # , c="gamma", colorbar=True)
plt.suptitle("Co-add Chi**2 Results (fixed_logg_feh): {0}-{1}".format(
params["star"], params["obsnum"]))
name = "{0}-{1}_coadd_fixed_logg_feh_params_full_gamma_{2}_{3}.png".format(
params["star"], params["obsnum"], params["suffix"], chi2_val)
fig.savefig(os.path.join(params["path"], "plots", name))
fig.savefig(
os.path.join(params["path"], "plots", name.replace(".pdf",
".png")))
plt.close()
for jj, (chi2_val, npix_val) in enumerate(zip(chi2_names, npix_names)):
if jj == 4:
chi2legend = "coadd chi2"
else:
chi2legend = "det {0}".format(jj + 1)
red_chi2 = "red_{0}".format(chi2_val)
fig, axes = plt.subplots(nrows, ncols)
fig.tight_layout()
indices = np.arange(nrows * ncols).reshape(nrows, ncols)
for ii, col in enumerate(columns):
df = extractor.fixed_extraction([col, chi2_val],
fixed={
"logg_1": params["logg"],
"feh_1": params["fe_h"]
})
df[red_chi2] = reduced_chi_squared(df[chi2_val],
params["npix"][npix_val],
params["npars"])
axis_pos = [int(x) for x in np.where(indices == ii)]
df.plot(x=col,
y=red_chi2,
kind="scatter",
ax=axes[axis_pos[0], axis_pos[1]],
label=chi2legend) # , c="gamma", colorbar=True)
plt.suptitle(
"Co-add reduced Chi**2 Results (fixed_logg_feh): {0}-{1}".format(
params["star"], params["obsnum"]))
name = "{0}-{1}_coadd_fixed_logg_feh_params_full_gamma_{2}_{3}.png".format(
params["star"], params["obsnum"], params["suffix"], red_chi2)
fig.savefig(os.path.join(params["path"], "plots", name))
fig.savefig(
os.path.join(params["path"], "plots", name.replace(".pdf",
".png")))
plt.close()
host_parameters_individual(table, params)
def compare_spectra(table, params):
"""Plot the min chi2 result against the observations."""
extractor = DBExtractor(table)
for ii, chi2_val in enumerate(chi2_names[0:-2]):
df = extractor.minimum_value_of(chi2_val)
df = df[["teff_1", "logg_1", "feh_1", "gamma",
"teff_2", "logg_2", "feh_2", "rv", chi2_val]]
params1 = [df["teff_1"].values[0], df["logg_1"].values[0], df["feh_1"].values[0]]
params2 = [df["teff_2"].values[0], df["logg_2"].values[0], df["feh_2"].values[0]]
params1 = [float(param1) for param1 in params1]
params2 = [float(param2) for param2 in params2]
gamma = df["gamma"].values
rv = df["rv"].values
from simulators.iam_module import iam_helper_function
obs_name, obs_params, output_prefix = iam_helper_function(params["star"], params["obsnum"], ii + 1)
obs_spec = load_spectrum(obs_name)
# Mask out bad portion of observed spectra
# obs_spec = spectrum_masking(obs_spec, params["star"], params["obsnum"], ii + 1)
# Barycentric correct spectrum
_obs_spec = barycorr_crires_spectrum(obs_spec, extra_offset=None)
normalization_limits = [obs_spec.xaxis[0] - 5, obs_spec.xaxis[-1] + 5]
# models
# print("params for models", params1, params2)
mod1 = load_starfish_spectrum(params1, limits=normalization_limits,
hdr=True, normalize=False, area_scale=True,
flux_rescale=True)
mod2 = load_starfish_spectrum(params2, limits=normalization_limits,
hdr=True, normalize=False, area_scale=True,
flux_rescale=True)
iam_grid_func = inherent_alpha_model(mod1.xaxis, mod1.flux, mod2.flux,
rvs=rv, gammas=gamma)
iam_grid_model = iam_grid_func(obs_spec.xaxis).squeeze()
iam_grid_model_full = iam_grid_func(mod1.xaxis).squeeze()
model_spec_full = Spectrum(flux=iam_grid_model_full, xaxis=mod1.xaxis)
model_spec = Spectrum(flux=iam_grid_model, xaxis=obs_spec.xaxis)
model_spec = model_spec.remove_nans()
model_spec = model_spec.normalize(method="exponential")
model_spec_full = model_spec_full.remove_nans()
model_spec_full = model_spec_full.normalize(method="exponential")
fig, ax = plt.subplots(1, 1)
plt.plot(obs_spec.xaxis, obs_spec.flux, label="Observation")
plt.plot(model_spec.xaxis, model_spec.flux, label="Minimum \chi^2 model")
plt.plot(model_spec_full.xaxis, model_spec_full.flux, "--", label="Model_full_res")
plt.legend()
fig.tight_layout()
name = "{0}-{1}_{2}_{3}_min_chi2_spectrum_comparison_{4}.png".format(
params["star"], params["obsnum"], params["chip"], chi2_val, params["suffix"])
plt.savefig(os.path.join(params["path"], "plots", name))
plt.close()
plt.plot(obs_spec.xaxis, obs_spec.flux, label="Observation")
plt.show()
def test_BDExtractor_initalized(self, test_table):
x = DBExtractor(table=test_table)
assert isinstance(x, DBExtractor)
assert x.table == test_table
assert x.cols == test_table.c
