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 get_bhm_model_pars(params: Dict[str, Union[int, float]], method: str = "close") -> List[
List[Union[int64, float64]]]:
method = method.lower()
host_params = [params["temp"], params["logg"], params["fe_h"]]
closest_host_model = closest_model_params(*host_params)
if method == "config":
model_pars = list(generate_bhm_config_params(closest_host_model))
elif method == "close":
# Model parameters to try iterate over.
model_pars = list(generate_close_params(closest_host_model, small=True))
else:
raise ValueError("The method '{0}' is not valid".format(method))
return model_pars
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 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 test_get_bh_model_pars_close_method_returns_close_params():
pars = get_bhm_model_pars({"temp": 5200, "logg": 4.5, "fe_h": 0.0}, method="close")
assert pars == list(generate_close_params(closest_model_params(5200, 4.5, 0.0)))