def generate_binary_model():
"""
returns a binary source model, time array, and the magnification of
both sources
"""
# retrieve model 1
(model_1, t, A_1) = generate_model()
t_0_1 = model_1.parameters.t_0
u_0_1 = model_1.parameters.u_0
# create second model
t_0_2 = 3570.
u_0_2 = 0.25
t_E = model_1.parameters.t_E
model_2 = mm.Model({'t_0': t_0_2, 'u_0': u_0_2, 't_E': t_E})
A_2 = model_2.get_magnification(t)
# create separate binary model
params = {
't_0_1': t_0_1,
'u_0_1': u_0_1,
't_0_2': t_0_2,
'u_0_2': u_0_2,
't_E': t_E
}
binary_model = mm.Model(params)
return (binary_model, t, A_1, A_2)
def test_magnifications_for_orbital_motion():
"""
make sure that orbital motion parameters are properly passed to
magnification methods calculations
"""
dict_static = {
't_0': 100.,
'u_0': 0.1,
't_E': 100.,
'q': 0.99,
's': 1.1,
'alpha': 10.
}
dict_motion = dict_static.copy()
dict_motion.update({'ds_dt': -2, 'dalpha_dt': -300.})
static = mm.Model(dict_static)
motion = mm.Model(dict_motion)
t_1 = 100.
almost(static.magnification(t_1), motion.magnification(t_1))
t_2 = 130.
static.parameters.s = 0.93572895
static.parameters.alpha = 345.359342916
almost(static.magnification(t_2), motion.magnification(t_2))
def test_model_parallax_definition():
"""Update parameters in an existing model"""
model_2 = mm.Model({
't_0': 2450000.,
'u_0': 0.1,
't_E': 100.,
'pi_E_N': 0.1,
'pi_E_E': 0.2
})
model_2.parameters.pi_E_N = 0.3
model_2.parameters.pi_E_E = 0.4
assert model_2.parameters.pi_E_N == 0.3
assert model_2.parameters.pi_E_E == 0.4
model_3 = mm.Model({
't_0': 2450000.,
'u_0': 0.1,
't_E': 100.,
'pi_E': (0.5, 0.6)
})
assert model_3.parameters.pi_E_N == 0.5
assert model_3.parameters.pi_E_E == 0.6
model_4 = mm.Model({
't_0': 2450000.,
'u_0': 0.1,
't_E': 100.,
'pi_E_N': 0.7,
'pi_E_E': 0.8
})
assert model_4.parameters.pi_E_N == 0.7
assert model_4.parameters.pi_E_E == 0.8
def test_satellite_parallax_magnification():
"""
On a given date, the magnification should be different from the
ground and from Spitzer. Use OB140939 as a test case and t0 as the
test time.
"""
t_0 = 2456836.22
u_0 = 0.922
t_E = 22.87
pi_E_N = -0.248
pi_E_E = 0.234
ground_model = mm.Model(
{
't_0': t_0,
'u_0': u_0,
't_E': t_E,
'pi_E': [pi_E_N, pi_E_E]
},
coords='17:47:12.25 -21:22:58.2')
space_model = mm.Model(
{
't_0': t_0,
'u_0': u_0,
't_E': t_E,
'pi_E': [pi_E_N, pi_E_E]
},
ra='17:47:12.25',
dec='-21:22:58.2',
ephemerides_file=SAMPLE_FILE_03_EPH)
delta = ground_model.magnification(t_0) - space_model.magnification(t_0)
assert np.abs(delta) > 0.01
def test_event_chi2_binary_source():
"""simple test if chi2 calculation for binary source works fine"""
model = mm.Model({
't_0_1': 5000.,
'u_0_1': 0.05,
't_0_2': 5100.,
'u_0_2': 0.15,
't_E': 25.
})
model_1 = mm.Model(model.parameters.source_1_parameters)
model_2 = mm.Model(model.parameters.source_2_parameters)
# prepare fake data:
time = np.linspace(4900., 5200., 600)
mag_1 = model_1.magnification(time)
mag_2 = model_2.magnification(time)
flux = 100. * mag_1 + 300. * mag_2 + 50.
data = mm.MulensData(data_list=[time, flux, 1. + 0. * time],
phot_fmt='flux')
# Calculate chi^2:
event = mm.Event([data], model)
np.testing.assert_almost_equal(event.get_chi2(), 0.)
# Make sure Model.set_source_flux_ratio() is taken into account.
model.set_source_flux_ratio(1.)
np.testing.assert_almost_equal(model.magnification(time),
(mag_1 + mag_2) / 2.)
assert event.get_chi2() > 1.
model.set_source_flux_ratio(3.)
np.testing.assert_almost_equal(event.get_chi2(), 0.)
def generate_binary_source_models():
model = mm.Model({
't_0_1': 5000.,
'u_0_1': 0.05,
't_0_2': 5100.,
'u_0_2': 0.15,
't_E': 25.
})
model_1 = mm.Model(model.parameters.source_1_parameters)
model_2 = mm.Model(model.parameters.source_2_parameters)
return (model, model_1, model_2)
def test_t_E():
"""make sure t_E can be accessed properly"""
t_0 = 2460000.
u_0 = 0.1
t_E = 12.3456
t_star = 0.01234
params = dict(t_0=t_0, u_0=u_0, t_E=t_E)
model_1 = mm.Model(params)
params['t_star'] = t_star
model_2 = mm.Model(params)
almost(model_1.parameters.t_E, t_E)
almost(model_2.parameters.t_E, t_E)
def test_n_lenses():
"""check n_lenses property"""
model_1 = mm.Model({"t_0": 2456789., "u_0": 1., "t_E": 30.})
model_2 = mm.Model({
"t_0": 2456789.,
"u_0": 1.,
"t_E": 30.,
"s": 1.1234,
"q": 0.123,
'alpha': 12.34
})
assert model_1.n_lenses == 1
assert model_2.n_lenses == 2
def do_annual_parallax_test(filename):
"""testing functions called by a few unit tests"""
with open(filename) as data_file:
lines = data_file.readlines()
ulens_params = lines[3].split()
event_params = lines[4].split()
data = np.loadtxt(filename, dtype=None)
model = mm.Model(
{
't_0': float(ulens_params[1]) + 2450000.,
'u_0': float(ulens_params[3]),
't_E': float(ulens_params[4]),
'pi_E_N': float(ulens_params[5]),
'pi_E_E': float(ulens_params[6])
},
coords=SkyCoord(event_params[1] + ' ' + event_params[2],
unit=(u.deg, u.deg)))
model.parameters.t_0_par = float(ulens_params[2]) + 2450000.
time = data[:, 0]
dataset = mm.MulensData([time, 20. + time * 0., 0.1 + time * 0.],
add_2450000=True)
model.set_datasets([dataset])
model.parallax(satellite=False, earth_orbital=True, topocentric=False)
return np.testing.assert_almost_equal(model.data_magnification[0] /
data[:, 1],
1.0,
decimal=4)
def test_binary_source_and_fluxes_for_bands():
"""
Test if setting different flux ratios for different bands in binary
source models works properly. The argument flux_ratio_constraint
is set as string.
"""
model = mm.Model({
't_0_1': 5000.,
'u_0_1': 0.05,
't_0_2': 5100.,
'u_0_2': 0.003,
't_E': 30.
})
times_I = np.linspace(4900., 5200., 3000)
times_V = np.linspace(4800., 5300., 250)
(f_s_1_I, f_s_2_I, f_b_I) = (10., 20., 3.)
(f_s_1_V, f_s_2_V, f_b_V) = (15., 5., 30.)
q_f_I = f_s_2_I / f_s_1_I
q_f_V = f_s_2_V / f_s_1_V
(mag_1_I, mag_2_I) = model.get_magnification(times_I, separate=True)
(mag_1_V, mag_2_V) = model.get_magnification(times_V, separate=True)
effective_mag_I = (mag_1_I + mag_2_I * q_f_I) / (1. + q_f_I)
effective_mag_V = (mag_1_V + mag_2_V * q_f_V) / (1. + q_f_V)
flux_I = mag_1_I * f_s_1_I + mag_2_I * f_s_2_I + f_b_I
flux_V = mag_1_V * f_s_1_V + mag_2_V * f_s_2_V + f_b_V
# model.set_source_flux_ratio_for_band('I', q_f_I)
# model.set_source_flux_ratio_for_band('V', q_f_V)
# Test Model.get_magnification()
result_I = model.get_magnification(times_I, source_flux_ratio=q_f_I)
result_V = model.get_magnification(times_V, source_flux_ratio=q_f_V)
almost(result_I, effective_mag_I)
almost(result_V, effective_mag_V)
def setUp(self):
# Flux ratios
self.q_I = 0.01
self.q_V = 0.002
self.gamma = {'I': 0.44, 'V': 0.72}
# Model based on binary source
self.model = mm.Model({
't_0_1': 8000.,
'u_0_1': 0.3,
't_0_2': 8001.,
'u_0_2': 0.001,
't_E': 25.,
'rho_2': 0.002
})
n_tstar = 3
t_1 = self.model.parameters.t_0_2 - 3 * self.model.parameters.t_star_2
t_2 = self.model.parameters.t_0_2 + 3 * self.model.parameters.t_star_2
self.model.set_magnification_methods(
[t_1, 'finite_source_LD_Yoo04', t_2], source=2)
self.model.set_limb_coeff_gamma('I', self.gamma['I'])
self.model.set_limb_coeff_gamma('V', self.gamma['V'])
self.generate_fake_datasets()
def test_chi2_gradient():
"""
test that fit_fluxes/update must be run in order to update the gradient
"""
data = mm.MulensData(file_name=SAMPLE_FILE_02)
event = mm.Event(datasets=[data],
model=mm.Model(chi2_gradient_test_1.parameters),
fix_blend_flux={data: 0.})
result = event.get_chi2_gradient(chi2_gradient_test_1.grad_params)
reference = np.array([
chi2_gradient_test_1.gradient[key]
for key in chi2_gradient_test_1.grad_params
])
np.testing.assert_almost_equal(reference / result, 1., decimal=4)
# changing something w/o updating: gives old values
event.model.parameters.t_0 += 0.1
result_1 = event.chi2_gradient
np.testing.assert_almost_equal(result_1 / result, 1.)
# run fit_fluxes: gives new values
event.fit_fluxes()
result_2 = event.calculate_chi2_gradient(chi2_gradient_test_1.grad_params)
assert all(result != result_2)
# Go back to previous results and test that calculate_chi2_gradient gives
# results that don't match anything.
event.model.parameters.t_0 -= 0.1
result_3 = event.calculate_chi2_gradient(chi2_gradient_test_1.grad_params)
assert all(result != result_3)
assert all(result_2 != result_3)
result_4 = event.get_chi2_gradient(chi2_gradient_test_1.grad_params)
np.testing.assert_almost_equal(result_4 / result, 1.)
def test_chi2_gradient_2():
"""
Double-up on the gradient test, i.e. duplicate the dataset and check that
the gradient values double.
"""
reference = np.array([
chi2_gradient_test_1.gradient[key]
for key in chi2_gradient_test_1.grad_params
])
data = mm.MulensData(file_name=SAMPLE_FILE_02)
event = mm.Event(datasets=[data, data],
model=mm.Model(chi2_gradient_test_1.parameters),
fix_blend_flux={data: 0.})
result_0 = event.get_chi2_gradient(chi2_gradient_test_1.grad_params)
result_1 = event.fits[1].chi2_gradient
np.testing.assert_almost_equal(2. * reference / result_0, 1., decimal=4)
np.testing.assert_almost_equal(2. * result_1 / result_0, 1.)
np.testing.assert_almost_equal(reference / result_1, 1., decimal=4)
# Change something and test fit.get_chi2_gradient
event.model.parameters.t_0 += 0.1
result_2 = event.fits[1].get_chi2_gradient(
chi2_gradient_test_1.grad_params)
assert result_2[0] != result_1[0]
event.model.parameters.t_0 -= 0.1
result_3 = event.fits[1].get_chi2_gradient(
chi2_gradient_test_1.grad_params)
np.testing.assert_almost_equal(result_3 / reference, 1., decimal=4)
def test_chi2_vs_get_chi2():
"""get_chi2 always updates after something changes in the model, chi2 does
not."""
t_0 = 5379.57091
u_0 = 0.52298
t_E = 17.94002
data = mm.MulensData(file_name=SAMPLE_FILE_01)
ev = mm.Event()
mod = mm.Model({'t_0': t_0, 'u_0': u_0, 't_E': t_E})
ev.model = mod
ev.datasets = [data]
# New (v2.0) method of fixing the blending
ev.fix_blend_flux = {}
np.testing.assert_almost_equal(ev.get_chi2(), 427.20382, decimal=4)
np.testing.assert_almost_equal(ev.chi2, 427.20382, decimal=4)
fix_blend_flux = {}
for dataset in ev.datasets:
fix_blend_flux[dataset] = 0.
ev.fix_blend_flux = fix_blend_flux
np.testing.assert_almost_equal(ev.chi2, 427.20382, decimal=4)
np.testing.assert_almost_equal(ev.get_chi2(), 459.09826, decimal=4)
np.testing.assert_almost_equal(ev.chi2, 459.09826, decimal=4)
def test_caustic_for_orbital_motion():
"""
check if caustics calculated for different epochs in orbital motion model
are as expected
"""
q = 0.1
s = 1.3
params = {
't_0': 100.,
'u_0': 0.1,
't_E': 10.,
'q': q,
's': s,
'ds_dt': 0.5,
'alpha': 0.,
'dalpha_dt': 0.
}
model = mm.Model(parameters=params)
model.update_caustics()
almost(model.caustics.get_caustics(), mm.Caustics(q=q, s=s).get_caustics())
model.update_caustics(100. + 365.25 / 2)
almost(model.caustics.get_caustics(),
mm.Caustics(q=q, s=1.55).get_caustics())
def test_satellite_and_annual_parallax_calculation():
"""
test that data magnifications are correctly retrieved for Spitzer data.
"""
# Create Model
model_parameters = {
't_0': 2456836.22,
'u_0': 0.922,
't_E': 22.87,
'pi_E_N': -0.248,
'pi_E_E': 0.234,
't_0_par': 2456836.2
}
coords = "17:47:12.25 -21:22:58.2"
model_with_par = mm.Model(model_parameters, coords=coords)
model_with_par.parallax(satellite=True,
earth_orbital=True,
topocentric=False)
# Load Spitzer data and answers
data_Spitzer = mm.MulensData(file_name=SAMPLE_FILE_03,
ephemerides_file=SAMPLE_FILE_03_EPH)
ref_Spitzer = np.loadtxt(SAMPLE_FILE_03_REF, unpack=True, usecols=[5])
# Test FitData.data_magnification()
my_fit = mm.FitData(dataset=data_Spitzer, model=model_with_par)
ratio = my_fit.get_data_magnification() / ref_Spitzer
np.testing.assert_almost_equal(ratio, [1.] * len(ratio), decimal=4)
def test_satellite_and_annual_parallax_calculation():
"""test parallax calculation with Spitzer data"""
model_with_par = mm.Model(
{
't_0': 2456836.22,
'u_0': 0.922,
't_E': 22.87,
'pi_E_N': -0.248,
'pi_E_E': 0.234
},
coords="17:47:12.25 -21:22:58.2")
model_with_par.parallax(satellite=True,
earth_orbital=True,
topocentric=False)
model_with_par.parameters.t_0_par = 2456836.2
data_OGLE = mm.MulensData(file_name=SAMPLE_FILE_02)
data_Spitzer = mm.MulensData(file_name=SAMPLE_FILE_03,
ephemerides_file=SAMPLE_FILE_03_EPH)
model_with_par.set_datasets([data_OGLE, data_Spitzer])
ref_OGLE = np.loadtxt(SAMPLE_FILE_02_REF, unpack=True, usecols=[5])
ref_Spitzer = np.loadtxt(SAMPLE_FILE_03_REF, unpack=True, usecols=[5])
np.testing.assert_almost_equal(model_with_par.data_magnification[0],
ref_OGLE,
decimal=2)
ratio = model_with_par.data_magnification[1] / ref_Spitzer
np.testing.assert_almost_equal(ratio, [1.] * len(ratio), decimal=4)
def test_separate_method_for_each_source():
"""
Checks if setting separate magnification method for each source in
binary source models works properly.
"""
model = mm.Model({
't_0_1': 5000.,
'u_0_1': 0.01,
'rho_1': 0.005,
't_0_2': 5100.,
'u_0_2': 0.001,
'rho_2': 0.005,
't_E': 1000.
})
model.set_magnification_methods(
[4999., 'finite_source_uniform_Gould94', 5101.], source=1)
# In order not to get "no FS method" warning:
model.set_magnification_methods([0., 'finite_source_uniform_Gould94', 1.],
source=2)
out = model.magnification(5000., separate=True)
almost([out[0][0], out[1][0]], [103.46704167, 10.03696291])
model.set_magnification_methods(
[4999., 'finite_source_uniform_Gould94', 5001.], source=1)
model.set_magnification_methods(
[5099., 'finite_source_uniform_Gould94', 5101.], source=2)
out = model.magnification(5100., separate=True)
almost([out[0][0], out[1][0]], [9.98801936, 395.96963727])
def _set_event_PSPL(self):
"""
Sets internal variable to MulensModel.Event instance
that uses PSPL model.
"""
datasets = []
for band in self.bands:
mask = (self._filter == band)
if not np.any(mask):
continue
times = self._JD[mask]
flux = self._simulated_flux[band]
sigma_flux = self._sigma_flux[band]
plot = {}
data = MM.MulensData([times, flux, sigma_flux],
phot_fmt='flux',
bandpass=band,
plot_properties={'label': 'LSST ' + band})
datasets.append(data)
if self._follow_up_Chilean is not None:
if self._follow_up_Chilean.n_epochs > 0:
datasets.append(self._follow_up_Chilean)
if self._follow_up_nonChilean is not None:
if self._follow_up_nonChilean.n_epochs > 0:
datasets.append(self._follow_up_nonChilean)
model = MM.Model(
{p: self._parameters[p]
for p in ['t_0', 'u_0', 't_E']})
self._event_PSPL = MM.Event(datasets, model)
def test_event_get_chi2_4():
"""test if best chi2 is remembered correctly"""
t_0 = 5379.57091
u_0 = 0.52298
t_E = 17.94002
data = mm.MulensData(file_name=SAMPLE_FILE_01)
ev = mm.Event()
params = {'t_0': t_0, 'u_0': u_0, 't_E': t_E * u.day}
mod = mm.Model(params)
mod.set_datasets([data])
ev.model = mod
ev.datasets = [data]
chi2_1 = ev.get_chi2() # This is the best model.
ev.model.parameters.parameters['t_0'] += 1.
ev.model.parameters.parameters['u_0'] += 0.1
ev.model.parameters.parameters['t_E'] += 1. * u.day
chi2_2 = ev.get_chi2()
assert chi2_2 > chi2_1
assert ev.best_chi2 == chi2_1
assert ev.best_chi2_parameters == params
def test_event_get_chi2_5():
"""
De facto checks how information is passed between Event, Fit, and Model.
Also checks simple relations between different Event.get_chi2().
"""
kwargs = {'comments': ["\\", "|"]}
data_1 = mm.MulensData(file_name=SAMPLE_FILE_03, **kwargs)
data_2 = mm.MulensData(file_name=SAMPLE_FILE_04, phot_fmt='flux', **kwargs)
params = {'t_0': 2452848.06, 'u_0': 0.1317, 't_E': 61.5}
model = mm.Model(params)
event_1 = mm.Event(data_1, model)
event_2 = mm.Event(data_2, model)
event_1_2 = mm.Event([data_1, data_2], model)
event_2_1 = mm.Event([data_2, data_1], model)
chi2_1 = event_1.get_chi2()
chi2_2 = event_2.get_chi2()
# The line below was failing when the test was written:
chi2_1_2 = event_1_2.get_chi2()
chi2_2_1 = event_2_1.get_chi2()
np.testing.assert_almost_equal(chi2_1_2, chi2_1 + chi2_2)
np.testing.assert_almost_equal(chi2_1_2, chi2_2_1)
def test_event_get_chi2_3():
"""
Test: If I change the model parameters, the chi2 should change.
"""
t_0 = 5380.
u_0 = 0.5
t_E = 18.
model = mm.Model({'t_0': t_0, 'u_0': u_0, 't_E': t_E})
# Generate fake data
times = np.arange(5320, 5420.)
f_source = 0.1
f_blend = 0.5
mod_fluxes = f_source * model.magnification(times) + f_blend
I_mag = mm.Utils.get_mag_from_flux(mod_fluxes)
errors = 0.01 * np.ones(times.shape)
data = mm.MulensData(data_list=[times, I_mag, errors])
# Generate event and fit
event = mm.Event(datasets=data, model=model)
orig_chi2 = event.get_chi2()
# Change the model
event.model.parameters.t_0 = 5000.
assert event.get_chi2() != orig_chi2
def test_event_get_chi2_double_source_simple():
"""
basic test on ob08092 OGLE-IV data
"""
t_0 = 5379.57091
u_0 = 0.52298
t_E = 17.94002
data = mm.MulensData(file_name=SAMPLE_FILE_01)
ev = mm.Event()
mod = mm.Model({'t_0': t_0, 'u_0': u_0, 't_E': t_E})
mod.set_datasets([data, data])
ev.model = mod
ev.datasets = [data, data]
chi2 = ev.get_chi2()
assert isinstance(chi2, float), 'wrong type of chi2'
message = 'problem in resulting chi2 for 2 exactly the same datasets'
np.testing.assert_almost_equal(chi2,
854.407644,
decimal=4,
err_msg=message)
def test_event_get_chi2_3():
"""test on ob08092 OGLE-IV data - MulensData.good & MulensData.bad"""
t_0 = 5379.57091
u_0 = 0.52298
t_E = 17.94002
bad = np.zeros(383, dtype='bool')
bad[300:350] = True
data_1 = mm.MulensData(file_name=SAMPLE_FILE_01, bad=bad)
data_2 = mm.MulensData(file_name=SAMPLE_FILE_01, good=~bad)
ev = mm.Event()
mod = mm.Model({'t_0': t_0, 'u_0': u_0, 't_E': t_E})
mod.set_datasets([data_1])
ev.model = mod
ev.datasets = [data_1]
chi2 = ev.get_chi2()
np.testing.assert_almost_equal(float(chi2),
343.46567,
decimal=4,
err_msg='problem in resulting chi2')
mod.set_datasets([data_2])
ev.model = mod
ev.datasets = [data_2]
chi2 = ev.get_chi2()
np.testing.assert_almost_equal(float(chi2),
343.46567,
decimal=4,
err_msg='problem in resulting chi2')
def test_model_coords():
coords = SkyCoord('18:00:00 -30:00:00', unit=(u.hourangle, u.deg))
model_1 = mm.Model({
't_0': 2450000,
'u_0': 0.1,
't_E': 100
},
coords='18:00:00 -30:00:00')
assert isinstance(model_1.coords, SkyCoord)
assert model_1.coords.ra == coords.ra
assert model_1.coords.dec == coords.dec
assert model_1.coords.dec.deg == -30.00
model_3 = mm.Model({'t_0': 2450000, 'u_0': 0.1, 't_E': 100})
model_3.coords = '17:00:00 -27:32:14'
assert model_3.coords.to_string('hmsdms') == '17h00m00s -27d32m14s'
def test_annual_parallax_calculation():
"""
This is a high-level unit test for parallax. The "true" values were
calculated from the sfit routine assuming fs=1.0, fb=0.0.
"""
t_0 = 2457479.5 # April 1 2016, a time when parallax is large
times = np.array([t_0 - 1., t_0, t_0 + 1., t_0 + 1.])
true_with_par = [
np.array([7.12376832, 10.0386009, 7.13323363, 7.13323363])
]
model_with_par = mm.Model(
{
't_0': t_0,
'u_0': 0.1,
't_E': 10.,
'pi_E': (0.3, 0.5)
},
coords='17:57:05 -30:22:59')
model_with_par.parallax(satellite=False,
earth_orbital=True,
topocentric=False)
ones = np.ones(len(times))
data = mm.MulensData(data_list=[times, ones, ones])
model_with_par.set_datasets([data])
model_with_par.parameters.t_0_par = 2457479.
np.testing.assert_almost_equal(model_with_par.data_magnification,
true_with_par,
decimal=4)
def test_model_binary_and_finite_sources():
"""
test if model magnification calculation for binary source works with
finite sources (both rho and t_star given)
"""
model = mm.Model({
't_0_1': 5000.,
'u_0_1': 0.005,
'rho_1': 0.001,
't_0_2': 5100.,
'u_0_2': 0.0003,
't_star_2': 0.03,
't_E': 25.
})
model_1 = mm.Model(model.parameters.source_1_parameters)
model_2 = mm.Model(model.parameters.source_2_parameters)
(t1, t2) = (4999.95, 5000.05)
(t3, t4) = (5099.95, 5100.05)
finite = 'finite_source_uniform_Gould94'
model.set_magnification_methods(
[t1, finite, t2, 'point_source', t3, finite, t4])
model_1.set_magnification_methods([t1, finite, t2])
model_2.set_magnification_methods([t3, finite, t4])
# prepare fake data:
(f_s_1, f_s_2, f_b) = (100., 300., 50.)
time = np.linspace(4900., 5200., 4200)
mag_1 = model_1.magnification(time)
mag_2 = model_2.magnification(time)
flux = f_s_1 * mag_1 + f_s_2 * mag_2 + f_b
data = mm.MulensData(data_list=[time, flux, 1. + 0. * time],
phot_fmt='flux')
model.set_datasets([data])
model_1.set_datasets([data])
model_2.set_datasets([data])
# test:
fitted = model.get_data_magnification(data)
expected = (mag_1 * f_s_1 + mag_2 * f_s_2) / (f_s_1 + f_s_2)
almost(fitted, expected)
# test separate=True option:
(mag_1_, mag_2_) = model.magnification(time, separate=True)
almost(mag_1, mag_1_)
almost(mag_2, mag_2_)
def test_event_chi2_binary_source_2datasets():
"""
simple test if chi2 calculation for binary source
works fine for 2 datasets
"""
model = mm.Model({
't_0_1': 5000.,
'u_0_1': 0.05,
't_0_2': 5100.,
'u_0_2': 0.15,
't_E': 25.
})
model_1 = mm.Model(model.parameters.source_1_parameters)
model_2 = mm.Model(model.parameters.source_2_parameters)
# prepare fake data:
time = np.linspace(4900., 5200., 600)
mag_1 = model_1.magnification(time)
mag_2 = model_2.magnification(time)
flux = 100. * mag_1 + 300. * mag_2 + 50.
data_1 = mm.MulensData(data_list=[time, flux, 1. + 0. * time],
phot_fmt='flux')
flux = 20. * mag_1 + 30. * mag_2 + 50.
data_2 = mm.MulensData(data_list=[time, flux, 1. + 0. * time],
phot_fmt='flux')
# Calculate chi^2:
event = mm.Event([data_1, data_2], model)
np.testing.assert_almost_equal(event.get_chi2(), 0.)
np.testing.assert_almost_equal(event.get_chi2_for_dataset(0), 0.)
np.testing.assert_almost_equal(event.get_chi2_for_dataset(1), 0.)
# Make sure that changing parameters changes chi2:
model.parameters.t_E = 100.
assert event.get_chi2() > 1., 'wrong chi2'
model.parameters.t_E = 25.
np.testing.assert_almost_equal(event.get_chi2(), 0.)
model.parameters.t_0_1 = 5010.
assert event.get_chi2() > 1., 'wrong chi2'
model.parameters.t_0_1 = 5000.
# Test combination of Model.set_source_flux_ratio_for_band() and
# Event.get_chi2_for_dataset().
data_1.bandpass = '******'
event.model.set_source_flux_ratio_for_band('some', 3.)
np.testing.assert_almost_equal(event.get_chi2_for_dataset(0), 0.)
def test_model_event_coords():
"""
Check if coordinates are properly passed from Model to Event.
"""
coords = "18:12:34.56 -23:45:55.55"
model = mm.Model({'t_0': 0, 'u_0': .5, 't_E': 10.}, coords=coords)
event = mm.Event(model=model)
np.testing.assert_almost_equal(event.coords.ra.value, 273.144)
np.testing.assert_almost_equal(event.coords.dec.value, -23.765430555555554)
def generate_model(finite_source=True):
if finite_source:
model = mm.Model({'t_0_1': 5000., 'u_0_1': 0.05,
't_0_2': 5005., 'u_0_2': 0.003, 'rho_2': 0.005,
't_E': 30.})
model.set_limb_coeff_gamma('I', 0.5)
model.set_limb_coeff_gamma('V', 0.7)
model.set_magnification_methods(
[5004., 'finite_source_LD_Yoo04', 5006.])
else:
model = mm.Model({'t_0_1': 5000., 'u_0_1': 0.05,
't_0_2': 5005., 'u_0_2': 0.003,
't_E': 30.})
# model.set_source_flux_ratio_for_band('I', 0.01)
# model.set_source_flux_ratio_for_band('V', 0.005)
return model