def main(chip=None, verbose=False, error_off=False, disable_wav_scale=False, renormalize=False, norm_method="scalar",
betasigma=False):
"""Main function."""
wav_scale = not disable_wav_scale
star = "HD211847"
obsnum = 2
star = star.upper()
setup_tcm_dirs(star)
if chip is None:
chip = 4
obs_name, params, output_prefix = tcm_helper_function(star, obsnum, chip)
logging.debug(__("The observation used is {} \n", obs_name))
host_params = [params["temp"], params["logg"], params["fe_h"]]
comp_params = [params["comp_temp"], params["logg"], params["fe_h"]]
closest_host_model = closest_model_params(*host_params) # unpack temp, logg, fe_h with *
closest_comp_model = closest_model_params(*comp_params)
# Function to find the good models I need from parameters
model1_pars = list(generate_close_params(closest_host_model, small=True))
model2_pars = list(generate_close_params(closest_comp_model, small=True))
# Load observation
obs_spec = load_spectrum(obs_name)
# Mask out bad portion of observed spectra
obs_spec = spectrum_masking(obs_spec, star, obsnum, chip)
# Barycentric correct spectrum
_obs_spec = barycorr_crires_spectrum(obs_spec, extra_offset=None)
# Determine Spectrum Errors
try:
if betasigma:
errors = betasigma_error(obs_spec)
logging.info(__("Beta-Sigma error value = {:6.5f}", errors))
else:
errors = spectrum_error(star, obsnum, chip, error_off=error_off)
logging.info(__("File obtained error value = {}", errors))
except KeyError as e:
errors = None
param_iter = len(alphas) * len(rvs) * len(gammas) * len(model2_pars) * len(model1_pars)
logging.info(__("STARTING tcm_analysis\nWith {0} parameter iterations", param_iter))
logging.debug(__("model1_pars = {}, model2_pars = {} ", len(model1_pars), len(model2_pars)))
tcm_analysis(obs_spec, model1_pars, model2_pars, alphas, rvs, gammas, errors=errors,
verbose=verbose, norm=renormalize, prefix=output_prefix, wav_scale=wav_scale, norm_method=norm_method)
return 0
def test_barycorr_crires_is_implemented_on_spectrum(host, extra):
host_copy = host.copy()
new_spec = barycorr_crires_spectrum(host, extra_offset=extra)
wlprime, new_flux = barycorr_crires(host.xaxis, host.flux, host.header, extra_offset=extra)
extra = 0.0 if extra is None else extra
assert isinstance(new_spec, Spectrum)
assert np.allclose(new_spec.xaxis, host.xaxis)
assert np.allclose(new_spec.flux[~np.isnan(new_spec.flux)], new_flux[~np.isnan(new_flux)])
assert np.allclose(new_flux[~np.isnan(new_flux)], np.interp(host.xaxis, wlprime, host.flux)[~np.isnan(new_flux)])
if extra is not None:
manual_shift = host_copy.xaxis * (1 + extra / c.value)
assert np.allclose(wlprime, manual_shift)
assert np.allclose(new_spec.flux, new_flux)
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 main():
"""Main function."""
star = "HD211847"
param_file = os.path.join(simulators.paths["parameters"], "{}_params.dat".format(star))
params = parse_paramfile(param_file, path=None)
host_params = [params["temp"], params["logg"], params["fe_h"]]
# comp_params = [params["comp_temp"], params["logg"], params["fe_h"]]
obsnum = 2
chip = 4
obs_name = os.path.join(
simulators.paths["spectra"], "{}-{}-mixavg-tellcorr_{}.fits".format(star, obsnum, chip))
logging.info("The observation used is ", obs_name, "\n")
closest_host_model = closest_model_params(*host_params) # unpack temp, logg, fe_h with *
# closest_comp_model = closest_model_params(*comp_params)
# original_model = "Z-0.0/lte05700-4.50-0.0.PHOENIX-ACES-AGSS-COND-2011-HiRes.fits"
# logging.debug(pv("closest_host_model"))
# logging.debug(pv("closest_comp_model"))
# logging.debug(pv("original_model"))
# Function to find the good models I need
# models = find_phoenix_model_names(model_base_dir, original_model)
# Function to find the good models I need from parameters
# model_par_gen = generate_close_params(closest_host_model)
model_pars = list(generate_close_params(closest_host_model)) # Turn to list
print("Model parameters", model_pars)
# Load observation
obs_spec = load_spectrum(obs_name)
_obs_spec = barycorr_crires_spectrum(obs_spec, extra_offset=None)
obs_spec.flux /= 1.02
# Mask out bad portion of observed spectra ## HACK
if chip == 4:
# Ignore first 40 pixels
obs_spec.wav_select(obs_spec.xaxis[40], obs_spec.xaxis[-1])
import simulators
gammas = np.arange(*simulators.sim_grid["gammas"])
####
chi2_grids = bhm_analysis(obs_spec, model_pars, gammas, verbose=True)
####
(model_chisqr_vals, model_xcorr_vals, model_xcorr_rv_vals,
broadcast_chisqr_vals, broadcast_gamma, broadcast_chisquare) = chi2_grids
TEFF = [par[0] for par in model_pars]
LOGG = [par[1] for par in model_pars]
FEH = [par[2] for par in model_pars]
plt.plot(TEFF, broadcast_chisqr_vals, "+", label="broadcast")
plt.plot(TEFF, model_chisqr_vals, ".", label="org")
plt.title("TEFF vs Broadcast chisqr_vals")
plt.legend()
plt.show()
plt.plot(TEFF, broadcast_gamma, "o")
plt.title("TEFF vs Broadcast gamma grid")
plt.show()
plt.plot(LOGG, broadcast_chisqr_vals, "+", label="broadcast")
plt.plot(LOGG, model_chisqr_vals, ".", label="org")
plt.title("LOGG verse Broadcast chisqr_vals")
plt.legend()
plt.show()
plt.plot(LOGG, broadcast_gamma, "o")
plt.title("LOGG verse Broadcast gamma grid")
plt.show()
plt.plot(FEH, broadcast_chisqr_vals, "+", label="broadcast")
plt.plot(FEH, model_chisqr_vals, ".", label="org")
plt.title("FEH vs Broadcast chisqr_vals")
plt.legend()
plt.show()
plt.plot(FEH, broadcast_gamma, "o")
plt.title("FEH vs Broadcast gamma grid")
plt.show()
TEFFS_unique = np.array(set(TEFF))
LOGG_unique = np.array(set(LOGG))
FEH_unique = np.array(set(FEH))
X, Y, Z = np.meshgrid(TEFFS_unique, LOGG_unique, FEH_unique) # set sparse=True for memory efficency
print("Teff grid", X)
print("Logg grid", Y)
print("FEH grid", Z)
assert len(TEFF) == sum(len(x) for x in (TEFFS_unique, LOGG_unique, FEH_unique))
chi_ND = np.empty_like(X.shape)
print("chi_ND.shape", chi_ND.shape)
print("len(TEFFS_unique)", len(TEFFS_unique))
print("len(LOGG_unique)", len(LOGG_unique))
print("len(FEH_unique)", len(FEH_unique))
for i, tf in enumerate(TEFFS_unique):
for j, lg in enumerate(LOGG_unique):
for k, fh in enumerate(FEH_unique):
print("i,j,k", (i, j, k))
print("num = t", np.sum(TEFF == tf))
print("num = lg", np.sum(LOGG == lg))
print("num = fh", np.sum(FEH == fh))
mask = (TEFF == tf) * (LOGG == lg) * (FEH == fh)
print("num = tf, lg, fh", np.sum(mask))
chi_ND[i, j, k] = broadcast_chisqr_vals[mask]
print("broadcast val", broadcast_chisqr_vals[mask],
"\norg val", model_chisqr_vals[mask])
# logging.debug(pv("model_chisqr_vals"))
# logging.debug(pv("model_xcorr_vals"))
chisqr_argmin_indx = np.argmin(model_chisqr_vals)
xcorr_argmax_indx = np.argmax(model_xcorr_vals)
print("Minimum Chisqr value =", model_chisqr_vals[chisqr_argmin_indx]) # , min(model_chisqr_vals)
print("Chisqr at max correlation value", model_chisqr_vals[chisqr_argmin_indx])
print("model_xcorr_vals = {}".format(model_xcorr_vals))
print("Maximum Xcorr value =", model_xcorr_vals[xcorr_argmax_indx]) # , max(model_xcorr_vals)
print("Xcorr at min Chiqsr", model_xcorr_vals[chisqr_argmin_indx])
# logging.debug(pv("model_xcorr_rv_vals"))
print("RV at max xcorr =", model_xcorr_rv_vals[xcorr_argmax_indx])
# print("Meadian RV val =", np.median(model_xcorr_rv_vals))
print(pv("model_xcorr_rv_vals[chisqr_argmin_indx]"))
print(pv("sp.stats.mode(np.around(model_xcorr_rv_vals))"))
# print("Max Correlation model = ", models[xcorr_argmax_indx].split("/")[-2:])
# print("Min Chisqr model = ", models[chisqr_argmin_indx].split("/")[-2:])
print("Max Correlation model = ", model_pars[xcorr_argmax_indx])
print("Min Chisqr model = ", model_pars[chisqr_argmin_indx])
limits = [2110, 2160]
best_model_params = model_pars[chisqr_argmin_indx]
best_model_spec = load_starfish_spectrum(best_model_params, limits=limits, normalize=True)
best_xcorr_model_params = model_pars[xcorr_argmax_indx]
best_xcorr_model_spec = load_starfish_spectrum(best_xcorr_model_params, limits=limits, normalize=True)
close_model_spec = load_starfish_spectrum(closest_model_params, limits=limits, normalize=True)
plt.plot(obs_spec.xaxis, obs_spec.flux, label="Observations")
plt.plot(best_model_spec.xaxis, best_model_spec.flux, label="Best Model")
plt.plot(best_xcorr_model_spec.xaxis, best_xcorr_model_spec.flux, label="Best xcorr Model")
plt.plot(close_model_spec.xaxis, close_model_spec.flux, label="Close Model")
plt.legend()
plt.xlim(*limits)
plt.show()
logging.debug("After plot")
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 main(star,
obsnum,
chip=None,
suffix=None,
error_off=False,
disable_wav_scale=False,
renormalize=False,
norm_method="scalar",
betasigma=False):
"""Best Host modelling main function."""
wav_scale = not disable_wav_scale
star = star.upper()
setup_bhm_dirs(star)
# Define the broadcasted gamma grid
gammas = np.arange(*simulators.sim_grid["gammas"])
# print("bhm gammas", gammas)
obs_name, params, output_prefix = bhm_helper_function(star, obsnum, chip)
if suffix is not None:
output_prefix = output_prefix + str(suffix)
print("The observation used is ", obs_name, "\n")
# Host Model parameters to iterate over
# model_pars = get_bhm_model_pars(params, method="close")
model_pars = get_bhm_model_pars(params, method="config") # Use config file
# Load observation
obs_spec = load_spectrum(obs_name)
from spectrum_overload import Spectrum
assert isinstance(obs_spec, Spectrum)
# Mask out bad portion of observed spectra
obs_spec = spectrum_masking(obs_spec, star, obsnum, chip)
# Barycentric correct spectrum
_obs_spec = barycorr_crires_spectrum(obs_spec, extra_offset=None)
# Determine Spectrum Errors
try:
if betasigma:
print("DOING BETASIGMA ERRORS")
N = simulators.betasigma.get("N", 5)
j = simulators.betasigma.get("j", 2)
errors, derrors = betasigma_error(obs_spec, N=N, j=j)
print("Beta-Sigma error value = {:6.5f}+/-{:6.5f}".format(
errors, derrors))
logging.info(
__("Beta-Sigma error value = {:6.5f}+/-{:6.5f}", errors,
derrors))
else:
print("NOT DOING BETASIGMA ERRORS")
errors = spectrum_error(star, obsnum, chip, error_off=error_off)
logging.info(__("File obtained error value = {0}", errors))
except KeyError as e:
print("ERRORS Failed so set to None")
errors = None
bhm_analysis(obs_spec,
model_pars,
gammas,
errors=errors,
verbose=False,
norm=renormalize,
wav_scale=wav_scale,
prefix=output_prefix,
norm_method=norm_method)
print("after bhm_analysis")
print("\nNow use bin/coadd_bhm_db.py")
return 0
def main():
"""Main function."""
star = "HD211847"
obsnum = 2
chip = 4
obs_name, params, output_prefix = tcm_helper_function(star, obsnum, chip)
print("The observation used is ", obs_name, "\n")
host_params = [params["temp"], params["logg"], params["fe_h"]]
comp_params = [params["comp_temp"], params["logg"], params["fe_h"]]
closest_host_model = closest_model_params(
*host_params) # unpack temp, logg, fe_h with *
closest_comp_model = closest_model_params(*comp_params)
# original_model = "Z-0.0/lte05700-4.50-0.0.PHOENIX-ACES-AGSS-COND-2011-HiRes.fits"
# Function to find the good models I need
# models = find_phoenix_model_names(model_base_dir, original_model)
# Function to find the good models I need from parameters
# model_par_gen = generate_close_params(closest_host_model)
model1_pars = list(
generate_close_params(closest_host_model)) # Turn to list
model2_pars = list(generate_close_params(closest_comp_model))
# print("Model parameters", model1_pars)
# print("Model parameters", model2_pars)
# Load observation
obs_spec = load_spectrum(obs_name)
# Mask out bad portion of observed spectra
obs_spec = spectrum_masking(spec, star, obsnum, chip)
# Barycentric correct spectrum
_obs_spec = barycorr_crires_spectrum(obs_spec, extra_offset=None)
# Determine Spectrum Errors
errors = spectrum_error(star, obs, chip, error_off=error_off)
if test:
model1_pars = model1_pars[:6]
model2_pars = model2_pars[:5]
print("Warning only small test feature set tried")
param_iter = len(alphas) * len(rvs) * len(gammas) * len(model2_pars) * len(
model1_pars)
print("STARTING tcm_analysis\nWith {} parameter iterations".format(
param_iter))
print("model1_pars", len(model1_pars), "model2_pars", len(model2_pars))
bcast_chisqr_vals = tcm_analysis(obs_spec,
model1_pars,
model2_pars,
alphas,
rvs,
gammas,
verbose=True,
norm=True,
chip=chip,
prefix=output_prefix)
print("tcm broadcast_chisquare shape", bcast_chisqr_vals.shape)
print("tcm broadcast_chisquare", bcast_chisqr_vals)
print("model1_pars len", len(model1_pars))
print("model2_pars len", len(model2_pars))
print("Done")
def main(star,
obsnum,
teff_1,
logg_1,
feh_1,
teff_2,
logg_2,
feh_2,
gamma,
rv,
plot_name=None):
fig, axis = plt.subplots(2, 2, figsize=(15, 8), squeeze=False)
for chip, ax in zip(range(1, 5), axis.flatten()):
# Get observation data
obs_name, params, output_prefix = iam_helper_function(
star, obsnum, chip)
# Load observed spectrum
obs_spec = load_spectrum(obs_name)
# Mask out bad portion of observed spectra
obs_spec = spectrum_masking(obs_spec, star, obsnum, chip)
# Barycentric correct spectrum
_obs_spec = barycorr_crires_spectrum(obs_spec, extra_offset=None)
# Determine Spectrum Errors
# error_off = False
# errors = spectrum_error(star, obsnum, chip, error_off=error_off)
# Create model with given parameters
host = load_starfish_spectrum([teff_1, logg_1, feh_1],
limits=[2110, 2165],
area_scale=True,
hdr=True)
if teff_2 is None:
assert (logg_2 is None) and (feh_2 is None) and (
rv == 0), "All must be None for bhm case."
companion = Spectrum(xaxis=host.xaxis,
flux=np.zeros_like(host.flux))
else:
companion = load_starfish_spectrum([teff_2, logg_2, feh_2],
limits=[2110, 2165],
area_scale=True,
hdr=True)
joint_model = inherent_alpha_model(host.xaxis,
host.flux,
companion.flux,
gammas=gamma,
rvs=rv)
model_spec = Spectrum(xaxis=host.xaxis,
flux=joint_model(host.xaxis).squeeze())
model_spec = model_spec.remove_nans()
model_spec = model_spec.normalize("exponential")
# plot
obs_spec.plot(axis=ax, label="{}-{}".format(star, obsnum))
model_spec.plot(axis=ax, linestyle="--", label="Chi-squared model")
ax.set_xlim([obs_spec.xmin() - 0.5, obs_spec.xmax() + 0.5])
ax.set_title("{} obs {} chip {}".format(star, obsnum, chip))
ax.legend()
plt.tight_layout()
if plot_name is None:
fig.show()
else:
if not (plot_name.endswith(".png") or plot_name.endswith(".pdf")):
raise ValueError("plot_name does not end with .pdf or .png")
fig.savefig(plot_name)
return 0
def main():
"""Main."""
star = "HD30501"
obsnum = "1"
chip = 1
obs_name = select_observation(star, obsnum, chip)
# Load observation
observed_spectra = load_spectrum(obs_name)
if chip == 4:
# Ignore first 40 pixels
observed_spectra.wav_select(observed_spectra.xaxis[40], observed_spectra.xaxis[-1])
# Load models
host_spectrum_model, companion_spectrum_model = load_PHOENIX_hd30501(limits=[2100, 2200], normalize=True)
obs_resolution = crires_resolution(observed_spectra.header)
# Convolve models to resolution of instrument
host_spectrum_model, companion_spectrum_model = convolve_models((host_spectrum_model, companion_spectrum_model),
obs_resolution, chip_limits=None)
plot_obs_with_model(observed_spectra, host_spectrum_model, companion_spectrum_model,
show=False, title="Before BERV Correction")
# Berv Correct
# Calculate the star RV relative to synthetic spectum
# [mean_val, K1, omega, e, Tau, Period, starmass (Msun), msini(Mjup), i]
parameters = {"HD30501": [23.710, 1703.1, 70.4, 0.741, 53851.5, 2073.6, 0.81, 90],
"HD211847": [6.689, 291.4, 159.2, 0.685, 62030.1, 7929.4, 0.94, 19.2, 7]}
try:
host_params = parameters[star]
except ValueError:
print("Parameters for {} are not in parameters list. Improve this.".format(star))
raise
host_params[1] = host_params[1] / 1000 # Convert K! to km/s
host_params[2] = np.deg2rad(host_params[2]) # Omega needs to be in radians for ajplanet
obs_time = observed_spectra.header["DATE-OBS"]
print(obs_time, isinstance(obs_time, str))
print(obs_time.replace("T", " ").split("."))
jd = ephem.julian_date(obs_time.replace("T", " ").split(".")[0])
host_rv = pl_rv_array(jd, *host_params[0:6])[0]
print("host_rv", host_rv, "km/s")
offset = -host_rv
# offset = 0
_berv_corrected_observed_spectra = barycorr_crires_spectrum(observed_spectra, offset) # Issue with air/vacuum
# This introduces nans into the observed spectrum
berv_corrected_observed_spectra.wav_select(*berv_corrected_observed_spectra.xaxis[
np.isfinite(berv_corrected_observed_spectra.flux)][[0, -1]])
# Shift to star RV
plot_obs_with_model(berv_corrected_observed_spectra, host_spectrum_model,
companion_spectrum_model, title="After BERV Correction")
# print("\nWarning!!!\n BERV is not good have added a offset to get rest working\n")
# Chisquared fitting
alphas = 10 ** np.linspace(-4, 0.1, 100)
rvs = np.arange(-50, 50, 0.05)
# chisqr_store = np.empty((len(alphas), len(rvs)))
observed_limits = [np.floor(berv_corrected_observed_spectra.xaxis[0]),
np.ceil(berv_corrected_observed_spectra.xaxis[-1])]
print("Observed_limits ", observed_limits)
n_jobs = 1
if n_jobs is None:
n_jobs = mprocess.cpu_count() - 1
start_time = dt.now()
if np.all(np.isnan(host_spectrum_model.flux)):
print("Host spectrum is all Nans")
if np.all(np.isnan(companion_spectrum_model.flux)):
print("Companion spectrum is all Nans")
print("Now performing the Chisqr grid analaysis")
obs_chisqr_parallel = parallel_chisqr(alphas, rvs, berv_corrected_observed_spectra, alpha_model2,
(host_spectrum_model, companion_spectrum_model,
observed_limits, berv_corrected_observed_spectra), n_jobs=n_jobs)
# chisqr_parallel = parallel_chisqr(alphas, rvs, simlulated_obs, alpha_model, (org_star_spec,
# org_bd_spec, new_limits), n_jobs=4)
end_time = dt.now()
print("Time to run parallel chisquared = {}".format(end_time - start_time))
# Plot memmap
# plt.subplot(2, 1, 1)
x, y = np.meshgrid(rvs, alphas)
fig = plt.figure(figsize=(7, 7))
cf = plt.contourf(x, y, np.log10(obs_chisqr_parallel.reshape(len(alphas), len(rvs))), 100)
fig.colorbar(cf)
plt.title("Sigma chisquared")
plt.ylabel("Flux ratio")
plt.xlabel("RV (km/s)")
plt.show()
# Locate minimum and plot resulting model next to observation
def find_min_chisquared(x, y, z):
"""Find minimum vlaue in chisqr grid."""
min_loc = np.argmin(z)
print("min location", min_loc)
x_sol = x.ravel()[min_loc]
y_sol = y.ravel()[min_loc]
z_sol = z.ravel()[min_loc]
return x_sol, y_sol, z_sol, min_loc
rv_solution, alpha_solution, min_chisqr, min_loc = find_min_chisquared(x, y, obs_chisqr_parallel)
print("Minium Chisqr value {2}\n RV sol = {0}\nAlpha Sol = {1}".format(rv_solution, alpha_solution, min_chisqr))
solution_model = alpha_model2(alpha_solution, rv_solution, host_spectrum_model, companion_spectrum_model,
observed_limits)
# alpha_model2(alpha, rv, host, companion, limits, new_x=None):
plt.plot(solution_model.xaxis, solution_model.flux, label="Min chisqr solution")
plt.plot(berv_corrected_observed_spectra.xaxis, berv_corrected_observed_spectra.flux, label="Observation")
plt.legend(loc=0)
plt.show()
# Dump the results into a pickle file
pickle_path = "/home/jneal/.chisqrpickles/"
pickle_name = "Chisqr_results_{0}_{1}_chip_{2}.pickle".format(star, obsnum, chip)
with open(os.path.join(pickle_path, pickle_name), "wb") as f:
# Pickle all the necessary parameters to store.
pickle.dump((rvs, alphas, berv_corrected_observed_spectra, host_spectrum_model, companion_spectrum_model,
rv_solution, alpha_solution, min_chisqr, min_loc, solution_model), f)
def main():
"""Main function."""
star = "HD30501"
host_parameters = load_param_file(star)
obsnum = 1
chip = 1
obs_name = select_observation(star, obsnum, chip)
# Load observation
# uncorrected_spectra = load_spectrum(obs_name)
observed_spectra = load_spectrum(obs_name)
_observed_spectra = barycorr_crires_spectrum(observed_spectra,
extra_offset=None)
observed_spectra.flux /= 1.02
obs_resolution = crires_resolution(observed_spectra.header)
wav_model = fits.getdata(
os.path.join(wav_dir, "WAVE_PHOENIX-ACES-AGSS-COND-2011.fits"))
wav_model /= 10 # turn into nm
logging.debug(__("Phoenix wav_model = {0}", wav_model))
closest_model = phoenix_name_from_params(model_base_dir, host_parameters)
original_model = "Z-0.0/lte05200-4.50-0.0.PHOENIX-ACES-AGSS-COND-2011-HiRes.fits"
logging.debug(__("closest_model {0}", closest_model))
logging.debug(__("original_model {0}", original_model))
# Function to find the good models I need
models = find_phoenix_model_names(model_base_dir, original_model)
if isinstance(models, list):
logging.debug(__("Number of close models returned {0}", len(models)))
model_chisqr_vals = np.empty_like(models)
model_xcorr_vals = np.empty_like(models)
model_xcorr_rv_vals = np.empty_like(models)
for ii, model_name in enumerate(models):
mod_flux = fits.getdata(model_name)
mod_header = fits.getheader(model_name)
mod_spectrum = Spectrum(xaxis=wav_model,
flux=mod_flux,
header=mod_header,
calibrated=True)
# Normalize Phoenix Spectrum
# mod_spectrum.wav_select(2080, 2200) # limits for simple normalization
mod_spectrum.wav_select(2105, 2165) # limits for simple normalization
# norm_mod_spectrum = simple_normalization(mod_spectrum)
norm_mod_spectrum = spec_local_norm(mod_spectrum, plot=False)
# Wav select
norm_mod_spectrum.wav_select(
np.min(observed_spectra.xaxis) - 5,
np.max(observed_spectra.xaxis) +
5) # +- 5nm of obs for convolution
# Convolve to resolution of instrument
conv_mod_spectrum = convolve_models([norm_mod_spectrum],
obs_resolution,
chip_limits=None)[0]
# Find crosscorrelation RV
# # Should run though all models and find best rv to apply uniformly
rvoffset, cc_max = xcorr_peak(observed_spectra,
conv_mod_spectrum,
plot=False)
# Interpolate to obs
conv_mod_spectrum.spline_interpolate_to(observed_spectra)
# conv_mod_spectrum.interpolate1d_to(observed_spectra)
model_chi_val = chi_squared(observed_spectra.flux,
conv_mod_spectrum.flux)
# argmax = np.argmax(cc_max)
model_chisqr_vals[ii] = model_chi_val
model_xcorr_vals[ii] = cc_max
model_xcorr_rv_vals[ii] = rvoffset
logging.debug(pv("model_chisqr_vals"))
logging.debug(pv("model_xcorr_vals"))
chisqr_argmin_indx = np.argmin(model_chisqr_vals)
xcorr_argmax_indx = np.argmax(model_xcorr_vals)
logging.debug(pv("chisqr_argmin_indx"))
logging.debug(pv("xcorr_argmax_indx"))
logging.debug(pv("model_chisqr_vals"))
print("Minimum Chisqr value =",
model_chisqr_vals[chisqr_argmin_indx]) # , min(model_chisqr_vals)
print("Chisqr at max correlation value",
model_chisqr_vals[chisqr_argmin_indx])
print("model_xcorr_vals = {}".format(model_xcorr_vals))
print("Maximum Xcorr value =",
model_xcorr_vals[xcorr_argmax_indx]) # , max(model_xcorr_vals)
print("Xcorr at min Chiqsr", model_xcorr_vals[chisqr_argmin_indx])
logging.debug(pv("model_xcorr_rv_vals"))
print("RV at max xcorr =", model_xcorr_rv_vals[xcorr_argmax_indx])
# print("Median RV val =", np.median(model_xcorr_rv_vals))
print(pv("model_xcorr_rv_vals[chisqr_argmin_indx]"))
# print(pv("sp.stats.mode(np.around(model_xcorr_rv_vals))"))
print("Max Correlation model = ",
models[xcorr_argmax_indx].split("/")[-2:])
print("Min Chisqr model = ", models[chisqr_argmin_indx].split("/")[-2:])
limits = [2110, 2160]
best_model = models[chisqr_argmin_indx]
best_model_spec = load_phoenix_spectrum(best_model,
limits=limits,
normalize=True)
best_model_spec = convolve_models([best_model_spec],
obs_resolution,
chip_limits=None)[0]
best_xcorr_model = models[xcorr_argmax_indx]
best_xcorr_model_spec = load_phoenix_spectrum(best_xcorr_model,
limits=limits,
normalize=True)
best_xcorr_model_spec = convolve_models([best_xcorr_model_spec],
obs_resolution,
chip_limits=None)[0]
close_model_spec = load_phoenix_spectrum(closest_model[0],
limits=limits,
normalize=True)
close_model_spec = convolve_models([close_model_spec],
obs_resolution,
chip_limits=None)[0]
plt.plot(observed_spectra.xaxis,
observed_spectra.flux,
label="Observations")
plt.plot(best_model_spec.xaxis, best_model_spec.flux, label="Best Model")
plt.plot(best_xcorr_model_spec.xaxis,
best_xcorr_model_spec.flux,
label="Best xcorr Model")
plt.plot(close_model_spec.xaxis,
close_model_spec.flux,
label="Close Model")
plt.legend()
plt.xlim(*limits)
plt.show()
print("After plot")
def test_barycorr_crires_spectrum_with_BARYDONE_no_offset_returns_same(host, extra):
host.header["BARYDONE"] = True
with pytest.warns(UserWarning):
new_spec = barycorr_crires_spectrum(host, extra_offset=extra)
assert np.allclose(new_spec.xaxis, host.xaxis)
assert np.allclose(new_spec.flux, host.flux)
def test_barycorr_crires_spectrum_with_invalid_header_no_offset_returns_same(host, extra):
new_spec = barycorr_crires_spectrum(host, extra_offset=extra)
assert np.allclose(new_spec.xaxis, host.xaxis)
assert np.allclose(new_spec.flux, host.flux)
def test_barycorr_crires_spectrum_with_obs_spec(host):
_new_spec = barycorr_crires_spectrum(host, extra_offset=None)
assert False
def test_barycorr_crires_spectrum(host):
barycorr_crires_spectrum(host, extra_offset=None)
assert False
# In[9]:
# Test with bayrrcorrection
for star in ["hdtest2", "hdtest3"]:
for chip in range(1, 5):
obs_name, obs_params, output_prefix = bhm_helper_function(
star.upper(), "001", chip)
obs_spec = load_spectrum(obs_name)
data = fits.getdata(
"/home/jneal/.handy_spectra/{}-001-mixavg-tellcorr_{}.fits".format(
star.upper(), chip))
plt.plot(data["wavelength"], data["flux"] + 0.01, label="fits")
obs_spec.plot(label="load spec")
obs_spec = barycorr_crires_spectrum(obs_spec, extra_offset=None)
obs_spec.plot(label="barycorr_")
plt.legend()
plt.show()
# In[10]:
# Test with bayrrcorrection with offset
for star in ["hdtest2", "hdtest3"]:
for chip in range(1, 5):
obs_name, obs_params, output_prefix = bhm_helper_function(
star.upper(), "001", chip)
obs_spec = load_spectrum(obs_name)
data = fits.getdata(
"/home/jneal/.handy_spectra/{}-001-mixavg-tellcorr_{}.fits".format(
