def plot_components(params1, params2, rvs, gammas, plot=True, snr=500):
# Load phoenix models and scale by area and wavelength limit
mod1_spec, mod2_spec = prepare_iam_model_spectra(params1,
params2,
limits=[2110, 2130],
area_scale=True,
wav_scale=True)
inherent_alpha = continuum_alpha(mod1_spec, mod2_spec, chip)
# Combine model spectra with iam model
if plot:
plt_spec = mod1_spec.copy()
plt_spec2 = mod2_spec.copy()
max_host = np.median(plt_spec.flux)
ax = plt.plot()
plt_spec /= max_host
plt_spec2 /= max_host
plt_spec.plot(label=params1)
plt_spec2.plot(label=params2)
std_noise = np.random.normal(0.5, np.ones_like(plt_spec.xaxis) / snr)
plt.plot(plt_spec.xaxis,
std_noise,
label="Noise with std=1/{} (offset)".format(snr))
plt.title("Spectra before combination\n (Scaled by emited area)")
plt.ylabel("Normalzied flux (peak host)")
plt.xlim([2110, 2120])
plt.legend(loc=5)
#plt.ylim([0,1.3])
plt.show()
def test_prepare_iam_model_spectra_with_warnings(limits):
"""Assert spectra with correct parameters are returned."""
params1 = [5200, 4.5, 0.0]
params2 = [2300, 5, 0.0]
with pytest.warns(UserWarning) as record:
x, y = prepare_iam_model_spectra(params1, params2, limits=limits,
area_scale=False, wav_scale=False)
assert len(record) == 2
# Check that the message matches
assert record[0].message.args[0] == "Not using area_scale. This is incorrect for paper."
assert record[1].message.args[0] == "Not using wav_scale. This is incorrect for paper."
assert isinstance(x, Spectrum)
assert isinstance(y, Spectrum)
# Check correct models are loaded
assert x.header["PHXTEFF"] == params1[0]
assert x.header["PHXLOGG"] == params1[1]
assert x.header["PHXM_H"] == params1[2]
assert y.header["PHXTEFF"] == params2[0]
assert y.header["PHXLOGG"] == params2[1]
assert y.header["PHXM_H"] == params2[2]
assert x.xaxis[0] >= limits[0]
assert y.xaxis[0] >= limits[0]
assert x.xaxis[-1] <= limits[1]
assert y.xaxis[-1] <= limits[1]
def test_prepare_iam_model_spectra(limits):
"""Assert spectra with correct parameters returned."""
params1 = [5200, 4.5, 0.0]
params2 = [2300, 5, 0.0]
x, y = prepare_iam_model_spectra(params1, params2, limits=limits)
assert isinstance(x, Spectrum)
assert isinstance(y, Spectrum)
# Check correct models are loaded
assert x.header["PHXTEFF"] == params1[0]
assert x.header["PHXLOGG"] == params1[1]
assert x.header["PHXM_H"] == params1[2]
assert y.header["PHXTEFF"] == params2[0]
assert y.header["PHXLOGG"] == params2[1]
assert y.header["PHXM_H"] == params2[2]
assert x.xaxis[0] >= limits[0]
assert y.xaxis[0] >= limits[0]
assert x.xaxis[-1] <= limits[1]
assert y.xaxis[-1] <= limits[1]
def fake_iam_simulation(wav,
params1,
params2,
gamma,
rv,
limits=(2070, 2180),
noise=None,
header=False,
fudge=None,
area_scale=True):
"""Make a fake spectrum with binary params and radial velocities."""
mod1_spec, mod2_spec = prepare_iam_model_spectra(params1,
params2,
limits,
area_scale=area_scale)
if fudge is not None:
mod2_spec.flux = mod2_spec.flux * fudge
warnings.warn("Fudging fake companion by '*{0}'".format(fudge))
# Combine model spectra with iam model
iam_grid_func = inherent_alpha_model(mod1_spec.xaxis,
mod1_spec.flux,
mod2_spec.flux,
rvs=rv,
gammas=gamma)
if wav is None:
delta = spec_max_delta(mod1_spec, rv, gamma)
assert np.all(np.isfinite(mod1_spec.xaxis))
mask = (mod1_spec.xaxis > mod1_spec.xaxis[0] + 2 * delta) * (
mod1_spec.xaxis < mod1_spec.xaxis[-1] - 2 * delta)
wav = mod1_spec.xaxis[mask]
iam_grid_models = iam_grid_func(wav).squeeze()
logging.debug(__("iam_grid_func(wav).squeeze() = {}", iam_grid_models))
logging.debug(
__("number of nans {}", np.sum(~np.isfinite(iam_grid_models))))
logging.debug(__("iam_grid_models = {}", iam_grid_models))
logging.debug("Continuum normalizing")
# Continuum normalize all iam_gird_models
def axis_continuum(flux):
"""Continuum to apply along axis with predefined variables parameters."""
return continuum(wav, flux, splits=20, method="exponential", top=20)
iam_grid_continuum = np.apply_along_axis(axis_continuum, 0,
iam_grid_models)
iam_grid_models = iam_grid_models / iam_grid_continuum
# This noise is added after continuum normalization.
if noise is not None or noise is not 0:
# Add 1 / snr noise to continuum normalized spectra
iam_grid_models = add_noise(iam_grid_models, noise, use_mu=False)
else:
logging.warning(
"\n!!!\n\nNot adding any noise to fake simulation!!\n\n!!!!!\n")
print("\n!!!\n\nNot adding any noise to fake simulation!!\n\n!!!!!\n")
if header:
return wav, iam_grid_models.squeeze(), mod1_spec.header
else:
return wav, iam_grid_models.squeeze()
def combine_spectrum(params1, params2, rvs, gammas, plot=True):
# Load phoenix models and scale by area and wavelength limit
mod1_spec, mod2_spec = prepare_iam_model_spectra(params1,
params2,
limits=[2110, 2130],
area_scale=True,
wav_scale=True)
inherent_alpha = continuum_alpha(mod1_spec, mod2_spec, chip)
# Combine model spectra with iam model
if plot:
plt_spec = mod1_spec.copy()
plt_spec2 = mod2_spec.copy()
max_host = np.max(plt_spec.flux)
ax = plt.plot()
plt_spec /= max_host
plt_spec2 /= max_host
plt_spec.plot(label=params1)
plt_spec2.plot(label=params2)
SNR = 500
std_noise = np.random.normal(0, np.ones_like(plt_spec.xaxis) / SNR)
plt.plot(plt_spec.xaxis,
std_noise,
label="Noise with std=1/{}".format(SNR))
plt.title("Spectra before combination\n (Scaled by area already)")
plt.ylabel("Normalzied flux (peak host)")
plt.legend()
plt.show()
if fudge or (fudge is not None):
fudge_factor = float(fudge)
mod2_spec.flux *= fudge_factor # fudge factor multiplication
mod2_spec.plot(label="fudged {0}".format(params2))
plt.title("fudges models")
plt.legend()
warnings.warn("Using a fudge factor = {0}".format(fudge_factor))
iam_grid_func = inherent_alpha_model(mod1_spec.xaxis,
mod1_spec.flux,
mod2_spec.flux,
rvs=rvs,
gammas=gammas)
iam_grid_models = iam_grid_func(obs_spec.xaxis)
iam_grid_models = iam_grid_func(obs_spec.xaxis)
# Continuum normalize all iam_gird_models
def axis_continuum(flux):
"""Continuum to apply along axis with predefined variables parameters."""
return continuum(obs_spec.xaxis,
flux,
splits=20,
method="exponential",
top=5)
iam_grid_continuum = np.apply_along_axis(axis_continuum, 0,
iam_grid_models)
iam_grid_models = iam_grid_models / iam_grid_continuum
return iam_grid_models
plt.ylabel("Normalzied flux (peak host)")
plt.xlim([2110, 2120])
plt.legend(loc=5)
#plt.ylim([0,1.3])
plt.show()
# In[6]:
plot_components(host3, comp3, rvs, gammas, snr=500)
plot_components(comp3, comp3, rvs, gammas, snr=500)
# Standard devition of median normalized spectrum of companion
mod1_spec, mod2_spec = prepare_iam_model_spectra(host3,
comp3,
limits=[2110, 2130],
area_scale=True,
wav_scale=True)
print("std of companion spectrum",
np.std(mod2_spec.flux / np.median(mod2_spec.flux) - 1))
print("std of companion spectrum",
(np.max(mod2_spec.flux) - np.min(mod2_spec.flux)) /
np.median(mod2_spec.flux))
# In[7]:
print("Very little difference")
plt.plot(model11, label="11")
plt.plot(model12, ":", label="12")
plt.plot(model21, label="21")
def fake_simulation(wav,
params1,
params2,
gamma,
rv,
chip=None,
limits=(2070, 2180),
noise=None):
"""Make a fake spectrum with binary params and radial velocities."""
mod1_spec, mod2_spec = prepare_iam_model_spectra(params1, params2, limits)
mod1_spec.plot()
mod2_spec.plot()
plt.show()
# Estimated flux ratio from models
if chip is not None:
inherent_alpha = continuum_alpha(mod1_spec, mod2_spec, chip)
print("inherent flux ratio = {}, chip={}".format(inherent_alpha, chip))
# Combine model spectra with iam model
iam_grid_func = inherent_alpha_model(mod1_spec.xaxis,
mod1_spec.flux,
mod2_spec.flux,
rvs=rv,
gammas=gamma)
if wav is None:
delta = spec_max_delta(mod1_spec, rv, gamma)
assert np.all(np.isfinite(mod1_spec.xaxis))
mask = (mod1_spec.xaxis > mod1_spec.xaxis[0] + delta) * (
mod1_spec.xaxis < mod1_spec.xaxis[-1] - delta)
wav = mod1_spec.xaxis[mask]
print("wav masked", wav)
iam_grid_models = iam_grid_func(wav).squeeze()
print(iam_grid_models)
assert np.all(np.isfinite(iam_grid_models))
if isinstance(noise, (int, float)):
snr = noise
else:
snr = None
# Continuum normalize all iam_gird_models
def axis_continuum(flux):
"""Continuum to apply along axis with predefined variables parameters."""
return continuum(wav, flux, splits=50, method="exponential", top=5)
iam_grid_continuum = np.apply_along_axis(axis_continuum, 0,
iam_grid_models)
iam_grid_models = iam_grid_models / iam_grid_continuum
# grid_spectrum = Spectrum(xaxis=wav, flux=iam_grid_models)
# iam_grid_models = grid_spectrum.normalize("exponential")
# Add the noise
from mingle.utilities.simulation_utilities import add_noise
if snr is not None:
iam_grid_models = add_noise(iam_grid_models, snr)
if np.any(np.isnan(iam_grid_models)):
print("there was some nans")
pass
return wav, iam_grid_models