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 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 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 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 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 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 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()
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(
[par, chi2_val],
limit=3,
fixed={par: float(unique_val)},
order_by=chi2_val)
min_chi2.append(df_chi2[chi2_val].values[0])
min_chi2 = reduced_chi_squared(min_chi2, params["npix"][npix_val],
params["npars"])
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"$\Delta \chi^2_{red}$")
plt.legend()
filename = "red_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 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 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 test_reduced_chi_squared_without_erros_equals_scipy(chi2, n, p, expected):
if isinstance(chi2, list):
chi2 = np.asarray(chi2)
expected = np.asarray(expected)
assert np.all(reduced_chi_squared(chi2, n, p) == expected)
