def test_init():
telescope = telescopes.Telescope()
assert telescope.name == 'NDG'
assert telescope.filter == 'I'
assert len(telescope.lightcurve_magnitude) == 0
assert telescope.location == 'Earth'
assert telescope.location == 'Earth'
assert len(telescope.lightcurve_flux) == 0
assert telescope.altitude == 0.0
assert telescope.longitude == 0.57
assert telescope.latitude == 49.49
assert telescope.gamma == 0.0
assert len(telescope.deltas_positions) == 0
telescope2 = telescopes.Telescope('Goleta', 'sdss_i',
light_curve_magnitude=np.array([[0, 1, 0.1], [3, 4, 0.1]]))
assert telescope2.name == 'Goleta'
assert telescope2.filter == 'sdss_i'
assert telescope2.lightcurve_magnitude.shape == (2, 3)
assert telescope2.lightcurve_flux.shape == (2, 3)
telescope2.location = 'Space'
telescope2.altitude = 1.0
telescope2.longitude = -150.0
telescope2.latitude = 35.0
telescope2.gamma = 0.6
assert telescope2.location == 'Space'
assert telescope2.altitude == 1.0
assert telescope2.longitude == -150.0
assert telescope2.latitude == 35.0
assert telescope2.gamma == 0.6
def main():
my_event = event.Event()
my_event.name = 'my_event'
#my_event.ra = 269.39166666666665
#my_event.dec = -29.22083333333333
data_K0 = np.loadtxt("./fits_files/lightcurve_gen_K0_text_2.txt")
data_V0 = np.loadtxt("./fits_files/lightcurve_gen_V0_text_2.txt")
telescope_K0 = telescopes.Telescope(name="LSST", camera_filter="K", light_curve_magnitude=data_K0)
telescope_V0 = telescopes.Telescope(name="LSST", camera_filter="V", light_curve_magnitude=data_V0)
my_event.telescopes.append(telescope_K0)
#my_event.telescopes.append(telescope_V0)
my_event.check_event()
model = microlmodels.create_model("PSPL", my_event)
my_event.fit(model, "LM")
my_event.fits[0].produce_outputs()
chi2_LM = my_event.fits[0].outputs.fit_parameters.chichi
print("Chi2_LM: {}".format(chi2_LM))
figure = my_event.fits[0].outputs.figure_lightcurve
#print "Other output:",figure.as_list()
plt.show()
def pyLIMAfit(filename):
ML_event = event.Event()
ML_event.name = str(filename).replace(".dat", "")
ML_event.ra = 269.39166666666665
ML_event.dec = -29.22083333333333
fileDirectoryR = lightcurve_path + 'Rfilter/' + str(filename)
fileDirectoryG = lightcurve_path + 'Gfilter/' + str(filename)
if ML_event.name.endswith('R'): #color == 'R':
data_1 = np.loadtxt(fileDirectoryR)
telescope_1 = telescopes.Telescope(name='LCOGT',
camera_filter='R',
light_curve_magnitude=data_1)
ML_event.telescopes.append(telescope_1)
if ML_event.name.endswith('G'): #color == 'G':
data_2 = np.loadtxt(fileDirectoryG)
telescope_2 = telescopes.Telescope(name='LCOGT',
camera_filter='G',
light_curve_magnitude=data_2)
ML_event.telescopes.append(telescope_2)
ML_event.find_survey('LCOGT')
ML_event.check_event()
PSPL_model = microlmodels.create_model('PSPL', ML_event)
ML_event.fit(PSPL_model, 'DE')
ML_event.fits[-1].produce_outputs()
try:
initial_parameters = [
getattr(ML_event.fits[-2].outputs.fit_parameters, key)
for key in ML_event.fits[-2].outputs.fit_parameters._fields[:4]
]
PSPL_model.parameters_guess = initial_parameters
ML_event.fit(PSPL_model, 'LM')
ML_event.fits[-1].produce_outputs()
except:
pass
output1 = plt.figure(1)
plt.savefig(lightcurve_path + 'pyLIMA_fits/' +
str(filename).replace(".dat", "") + '_pyLIMA_fit.png')
output2 = plt.figure(2)
plt.savefig(lightcurve_path + 'pyLIMA_fits/' +
str(filename).replace(".dat", "") + '_pyLIMA_parameters.png')
plt.close('all')
return 0
def read_dataset_to_telescope(self, model_type):
if 'p.t' in self.data_file:
lightcurve = np.loadtxt(self.data_file, dtype=str)
lightcurve = np.c_[lightcurve[:, 1], lightcurve[:, 6],
lightcurve[:, 7]].astype(float)
if 'cal.t' in self.data_file:
lightcurve = np.loadtxt(self.data_file, dtype=str)
lightcurve = np.c_[lightcurve[:, 1], lightcurve[:, 8],
lightcurve[:, 9]].astype(float)
if 'DK-1.54' in self.data_file:
lightcurve = np.loadtxt(self.data_file, dtype=str)
lightcurve = np.c_[lightcurve[:, 1], lightcurve[:, 6],
lightcurve[:, 7]].astype(float)
self.tel = telescopes.Telescope(name=self.name,
camera_filter=self.filter,
light_curve_magnitude=lightcurve,
light_curve_magnitude_dictionnary={
'time': 0,
'mag': 1,
'err_mag': 2
})
if 'FS' in model_type:
self.tel.gamma = self.gamma
print(self.tel.name, self.tel.gamma)
def test_clean_data_not_clean():
telescope = telescopes.Telescope(light_curve_magnitude=np.array(
[[0, 1, 0.1], [3, np.nan, 0.1], [5, 6, 0.1], [7, np.nan, np.nan],
[8, 1, 27.0], [9, 2, 0.03]]))
clean_lightcurve = telescope.clean_data_magnitude()
assert np.allclose(clean_lightcurve,
np.array([[0, 1, 0.1], [5, 6, 0.1], [9, 2, 0.03]]))
def test_clean_data_already_clean():
telescope = telescopes.Telescope(light_curve_magnitude=np.array(
[[0, 1, 0.1], [3, 4, 0.1], [5, 6, 0.1]]))
clean_lightcurve = telescope.clean_data_magnitude()
assert np.allclose(clean_lightcurve,
np.array([[0, 1, 0.1], [3, 4, 0.1], [5, 6, 0.1]]))
def test_n_data():
telescope = telescopes.Telescope(light_curve_magnitude=np.array(
[[0, 1, 0.1], [3, np.nan, 0.1], [5, 6, 0.1], [7, np.nan, np.nan],
[8, 1, 27.0], [9, 2, 0.03]]))
telescope.lightcurve_flux = telescope.lightcurve_in_flux()
assert telescope.n_data() == 3
assert telescope.n_data('flux') == 3
def test_arrange_the_lightcurve_columns_invert_time_magnitude():
telescope = telescopes.Telescope(light_curve_magnitude=np.array(
[[0, 1, 0.1], [3, 0.0, 0.1], [5, 6, 0.1], [7, 0.0, 0.0], [8, 1, 27.0], [9, 2, 0.03]]),
light_curve_magnitude_dictionnary={'time': 1, 'mag': 0,
'err_mag': 2}, clean_the_lightcurve='No')
assert np.allclose(telescope.lightcurve_magnitude, np.array(
[[1, 0, 0.1], [0.0, 3, 0.1], [6, 5, 0.1], [0.0, 7, 0.0], [1, 8, 27.0], [2, 9, 0.03]]))
def test_find_gamma():
telescope = telescopes.Telescope(camera_filter="z'")
full_path = os.path.abspath(__file__)
directory, filename = os.path.split(full_path)
telescope.find_gamma(32000.0, 4.5, os.path.join(directory, '../data/'))
EPSILON = 0.001
assert np.abs(telescope.gamma - 0.127056) <= EPSILON
def test_find_gamma():
telescope = telescopes.Telescope(camera_filter="z'")
star = stars.Star()
telescope.find_gamma(star)
EPSILON = 0.001
assert np.abs(telescope.gamma - 0.370885527486) <= EPSILON
def test_find_gamma():
telescope = telescopes.Telescope(camera_filter="z'")
full_path = os.path.abspath(__file__)
directory, filename = os.path.split(full_path)
star = stars.Star()
telescope.find_gamma(star)
EPSILON = 0.001
assert np.abs(telescope.gamma - 0.370885527486) <= EPSILON
def test_lightcurve_in_flux():
telescope = telescopes.Telescope(
light_curve_magnitude=np.array([[0, 1, 0.1], [3, 4, 0.1], [5, 6, 0.1]]))
telescope.lightcurve_flux = telescope.lightcurve_in_flux()
assert np.allclose(telescope.lightcurve_flux,
np.array([[0.00000000e+00, 3.63078055e+10, 3.34407247e+09],
[3.00000000e+00, 2.29086765e+09, 2.10996708e+08],
[5.00000000e+00, 3.63078055e+08, 3.34407247e+07]]))
def test_input_lightcurve_flux():
telescope = telescopes.Telescope(light_curve_flux=np.array(
[[0, 10.0, 0.1], [3, 5.0, 0.1], [5, 7.0, 0.1], [7, 5.0, 0.0], [8, 1.0, 27.0],
[9, 2.0, 0.03]]), light_curve_flux_dictionnary={'time': 1, 'flux': 0,
'err_flux': 2}, reference_flux=10000.0, clean_the_lightcurve='Yes')
assert np.allclose(telescope.lightcurve_magnitude,
np.array([[1.00000000e+01, 1.74000000e+01, 1.08573620e-05],
[5.00000000e+00, 1.73996743e+01, 1.08541058e-05],
[7.00000000e+00, 1.73994573e+01, 1.08519361e-05],
[5.00000000e+00, 1.73992403e+01, 0.00000000e+00],
[1.00000000e+00, 1.73991318e+01, 2.92914444e-03],
[2.00000000e+00, 1.73990233e+01, 3.25427976e-06]]))
def fit_PSPL(photometry, emag_limit=None, cores=None):
current_event = event.Event()
current_event.name = 'MOP_to_fit'
filters = np.unique(photometry[:, -1])
for ind, filt in enumerate(filters):
if emag_limit:
mask = (photometry[:, -1] == filt) & (np.abs(
photometry[:, -2].astype(float)) < emag_limit)
else:
mask = (photometry[:, -1] == filt)
lightcurve = photometry[mask, :-1].astype(float)
telescope = telescopes.Telescope(name='Tel_' + str(ind),
camera_filter=filt,
light_curve_magnitude=lightcurve,
light_curve_magnitude_dictionnary={
'time': 0,
'mag': 1,
'err_mag': 2
},
clean_the_lightcurve='Yes')
if len(lightcurve) > 5:
current_event.telescopes.append(telescope)
Model = microlmodels.create_model('PSPL',
current_event,
parallax=['None', 0])
Model.parameters_boundaries[0] = [
Model.parameters_boundaries[0][0],
Model.parameters_boundaries[0][-1] + 500
]
Model.parameters_boundaries[1] = [0, 2]
if cores != 0:
import multiprocessing
with multiprocessing.Pool(processes=cores) as pool:
current_event.fit(Model,
'DE',
DE_population_size=10,
flux_estimation_MCMC='polyfit',
computational_pool=pool)
else:
current_event.fit(Model,
'DE',
DE_population_size=10,
flux_estimation_MCMC='polyfit')
t0_fit = current_event.fits[-1].fit_results[0]
u0_fit = current_event.fits[-1].fit_results[1]
tE_fit = current_event.fits[-1].fit_results[2]
chi2_fit = current_event.fits[-1].fit_results[-1]
mag_source_fit = flux_to_mag(current_event.fits[-1].fit_results[3])
mag_blend_fit = flux_to_mag(current_event.fits[-1].fit_results[3] *
current_event.fits[-1].fit_results[4])
mag_baseline_fit = flux_to_mag(current_event.fits[-1].fit_results[3] *
(1 + current_event.fits[-1].fit_results[4]))
if np.isnan(mag_blend_fit):
mag_blend_fit = "null"
return [
t0_fit, u0_fit, tE_fit, mag_source_fit, mag_blend_fit,
mag_baseline_fit, chi2_fit
]
def simulate_ffp():
spring = True
fall = False
u0 = 0.01
tE = 1.0
if spring:
t0 = 2460394.400000
start_jd = 2460389.500000 # 2024 March 20
end_jd = 2460399.500000
if fall:
t0 = 2460389.500000
start_jd = 2460573.500000 # 2024 Aug 20
end_jd = 2460583.500000 # 2024 Aug 30
ra = 270.0
dec = -27.0
piEN = 0.01
piEE = 0.01
blend_ratio = 0.2
source_flux = mag_to_flux(22.0,1.0,24.0)
blend_flux = source_flux * blend_ratio
model_params = [ t0, u0, tE, piEN, piEE ]
lsst_aperture = 6.68
lsst_read_noise = 10.0
wfirst_aperture = 2.4
wfirst_read_noise = 10.0
if spring:
horizons_file = 'wfirst_observer_table_spring.txt'
if fall:
horizons_file = 'wfirst_observer_table_fall.txt'
ffp_lsst = event.Event()
ffp_lsst.name = 'FFP'
ffp_lsst.ra = ra
ffp_lsst.dec = dec
lsst_lc = simulate_lightcurve(start_jd, end_jd, 0.5/24.0, lsst_aperture,
spring, fall, day_gaps=True )
lsst = telescopes.Telescope(name='LSST', camera_filter='i',
location='Earth',
light_curve_magnitude=lsst_lc)
ffp_lsst.telescopes.append(lsst)
model_lsst = microlmodels.create_model('PSPL', ffp_lsst,
parallax=['Full', t0])
model_lsst.define_model_parameters()
fit_lsst = microlfits.MLFits(ffp_lsst)
fit_lsst.model = model_lsst
fit_lsst.fit_results = model_params
ffp_lsst.fits.append(fit_lsst)
print('Generated event lightcurve from LSST')
print('Model parameters:')
print_fit_params(model_params)
ffp_wfirst = event.Event()
ffp_wfirst.name = 'FFP'
ffp_wfirst.ra = ra
ffp_wfirst.dec = dec
horizons_table = jplhorizons_utils.parse_JPL_Horizons_table(horizons_file_path=horizons_file,
table_type='OBSERVER')
spacecraft_positions = jplhorizons_utils.extract_spacecraft_positions(horizons_table,t0)
wfirst_lc = simulate_lightcurve(start_jd, end_jd, 0.25/24.0, wfirst_aperture, spring, fall)
wfirst = telescopes.Telescope(name='WFIRST', camera_filter='W149',
spacecraft_name = 'WFIRST',
location='Space',
light_curve_magnitude=wfirst_lc)
wfirst.spacecraft_positions = spacecraft_positions
ffp_wfirst.telescopes.append(wfirst)
model_wfirst = microlmodels.create_model('PSPL', ffp_wfirst,
parallax=['Full', t0])
model_wfirst.define_model_parameters()
fit_wfirst = microlfits.MLFits(ffp_wfirst)
fit_wfirst.model = model_wfirst
fit_wfirst.fit_results = model_params
ffp_wfirst.fits.append(fit_wfirst)
print('Generated event lightcurve from WFIRST')
print('Model parameters:')
print_fit_params(fit_wfirst)
parameters = [ t0, u0, tE ]
lsst_pylima_params = extract_event_parameters(ffp_lsst, fit_lsst, parameters, source_flux, blend_ratio)
wfirst_pylima_params = extract_event_parameters(ffp_wfirst, fit_wfirst, parameters, source_flux, blend_ratio)
lsst_lc = add_lensing_event_to_lightcurve(lsst_pylima_params, ffp_lsst,
fit_lsst, lsst_read_noise)
wfirst_lc = add_lensing_event_to_lightcurve(wfirst_pylima_params, ffp_wfirst,
fit_wfirst, wfirst_read_noise)
plot_fitted_lightcurves(lsst_lc, wfirst_lc, ffp_lsst, ffp_wfirst,
'LSST', 'WFIRST', 'ffp_sim_lightcurve.png',
t0=t0,tE=tE)
def simulate_a_telescope(name,
event,
time_start,
time_end,
sampling,
location,
filter,
uniform_sampling=False,
altitude=0,
longitude=0,
latitude=0,
spacecraft_name=None,
bad_weather_percentage=0.0,
minimum_alt=20,
moon_windows_avoidance=20,
maximum_moon_illumination=100.0):
""" Simulate a telescope. More details in the telescopes module. The observations simulation are made for the
full time windows, then limitation are applied :
- Sun has to be below horizon : Sun< -18
- Moon has to be more than the moon_windows_avoidance distance from the target
- Observations altitude of the target have to be bigger than minimum_alt
:param str name: the name of the telescope.
:param object event: the microlensing event you look at
:param float time_start: the start of observations in JD
:param float time_end: the end of observations in JD
:param float sampling: the hour sampling.
:param str location: the location of the telescope.
:param str filter: the filter used for observations
:param boolean uniform_sampling: set it to True if you want no bad weather, no moon avoidance etc....
:param float altitude: the altitude in meters if the telescope
:param float longitude: the longitude in degree of the telescope location
:param float latitude: the latitude in degree of the telescope location
:param str spacecraft_name: the name of your satellite according to JPL horizons
:param float bad_weather_percentage: the percentage of bad nights
:param float minimum_alt: the minimum altitude ini degrees that your telescope can go to.
:param float moon_windows_avoidance: the minimum distance in degrees accepted between the target and the Moon
:param float maximum_moon_illumination: the maximum Moon brightness you allow in percentage
:return: a telescope object
:rtype: object
"""
#import pdb; pdb.set_trace()
# fake lightcurve
if (uniform_sampling == False) & (location != 'Space'):
earth_location = EarthLocation(lon=longitude * astropy.units.deg,
lat=latitude * astropy.units.deg,
height=altitude * astropy.units.m)
target = SkyCoord(event.ra, event.dec, unit='deg')
minimum_sampling = min(4.0, sampling)
ratio_sampling = np.round(sampling / minimum_sampling)
time_of_observations = time_simulation(time_start, time_end,
minimum_sampling,
bad_weather_percentage)
time_convertion = Time(time_of_observations, format='jd').isot
telescope_altaz = target.transform_to(
AltAz(obstime=time_convertion, location=earth_location))
altazframe = AltAz(obstime=time_convertion, location=earth_location)
Sun = get_sun(Time(time_of_observations,
format='jd')).transform_to(altazframe)
Moon = get_moon(Time(time_of_observations,
format='jd')).transform_to(altazframe)
Moon_illumination = moon_illumination(Sun, Moon)
Moon_separation = target.separation(Moon)
observing_windows = np.where(
(telescope_altaz.alt > minimum_alt * astropy.units.deg)
& (Sun.alt < -18 * astropy.units.deg)
& (Moon_separation > moon_windows_avoidance * astropy.units.deg)
& (Moon_illumination < maximum_moon_illumination))[0]
time_of_observations = time_of_observations[observing_windows]
else:
time_of_observations = np.arange(time_start, time_end,
sampling / (24.0))
lightcurveflux = np.ones((len(time_of_observations), 3)) * 42
lightcurveflux[:, 0] = time_of_observations
telescope = telescopes.Telescope(name=name,
camera_filter=filter,
light_curve_flux=lightcurveflux,
location=location,
spacecraft_name=spacecraft_name)
return telescope
def plot_mulens(n_clicks, object_data):
""" Fit for microlensing event
TODO: implement a fit using pyLIMA
"""
if n_clicks is not None:
pdf_ = pd.read_json(object_data)
cols = [
'i:jd', 'i:magpsf', 'i:sigmapsf', 'i:fid', 'i:ra', 'i:dec',
'i:magnr', 'i:sigmagnr', 'i:magzpsci', 'i:isdiffpos', 'i:objectId'
]
pdf = pdf_.loc[:, cols]
pdf['i:fid'] = pdf['i:fid'].astype(str)
pdf = pdf.sort_values('i:jd', ascending=False)
mag_dc, err_dc = np.transpose([
dc_mag(*args) for args in zip(
pdf['i:fid'].astype(int).values, pdf['i:magpsf'].astype(
float).values, pdf['i:sigmapsf'].astype(float).values,
pdf['i:magnr'].astype(float).values, pdf['i:sigmagnr'].astype(
float).values, pdf['i:magzpsci'].astype(
float).values, pdf['i:isdiffpos'].values)
])
current_event = event.Event()
current_event.name = pdf['i:objectId'].values[0]
current_event.ra = pdf['i:ra'].values[0]
current_event.dec = pdf['i:dec'].values[0]
filts = {'1': 'g', '2': 'r'}
for fid in np.unique(pdf['i:fid'].values):
mask = pdf['i:fid'].values == fid
telescope = telescopes.Telescope(
name='ztf_{}'.format(filts[fid]),
camera_filter=format(filts[fid]),
light_curve_magnitude=np.transpose([
pdf['i:jd'].values[mask], pdf['i:magpsf'].values[mask],
pdf['i:sigmapsf'].values[mask]
]),
light_curve_magnitude_dictionnary={
'time': 0,
'mag': 1,
'err_mag': 2
})
current_event.telescopes.append(telescope)
# Le modele le plus simple
mulens_model = microlmodels.create_model('PSPL', current_event)
current_event.fit(mulens_model, 'DE')
# 4 parameters
dof = len(pdf) - 4 - 1
results = current_event.fits[0]
normalised_lightcurves = microltoolbox.align_the_data_to_the_reference_telescope(
results, 0, results.fit_results)
# Model
create_the_fake_telescopes(results, results.fit_results)
telescope_ = results.event.fake_telescopes[0]
flux_model = mulens_model.compute_the_microlensing_model(
telescope_,
results.model.compute_pyLIMA_parameters(results.fit_results))[0]
time = telescope_.lightcurve_flux[:, 0]
magnitude = microltoolbox.flux_to_magnitude(flux_model)
if '1' in np.unique(pdf['i:fid'].values):
plot_filt1 = {
'x': [
convert_jd(t, to='iso')
for t in normalised_lightcurves[0][:, 0]
],
'y':
normalised_lightcurves[0][:, 1],
'error_y': {
'type': 'data',
'array': normalised_lightcurves[0][:, 2],
'visible': True,
'color': '#1f77b4'
},
'mode':
'markers',
'name':
'g band',
'text': [
convert_jd(t, to='iso')
for t in normalised_lightcurves[0][:, 0]
],
'marker': {
'size': 12,
'color': '#1f77b4',
'symbol': 'o'
}
}
else:
plot_filt1 = {}
if '2' in np.unique(pdf['i:fid'].values):
plot_filt2 = {
'x': [
convert_jd(t, to='iso')
for t in normalised_lightcurves[1][:, 0]
],
'y':
normalised_lightcurves[1][:, 1],
'error_y': {
'type': 'data',
'array': normalised_lightcurves[1][:, 2],
'visible': True,
'color': '#ff7f0e'
},
'mode':
'markers',
'name':
'r band',
'text': [
convert_jd(t, to='iso')
for t in normalised_lightcurves[1][:, 0]
],
'marker': {
'size': 12,
'color': '#ff7f0e',
'symbol': 'o'
}
}
else:
plot_filt2 = {}
fit_filt = {
'x': [convert_jd(float(t), to='iso') for t in time],
'y': magnitude,
'mode': 'lines',
'name': 'fit',
'showlegend': False,
'line': {
'color': '#7f7f7f',
}
}
figure = {
'data': [fit_filt, plot_filt1, plot_filt2],
"layout": layout_mulens
}
# fitted parameters
names = results.model.model_dictionnary
params = results.fit_results
err = np.diag(np.sqrt(results.fit_covariance))
mulens_params = """
```python
# Fitted parameters
t0: {} +/- {} (jd)
tE: {} +/- {} (days)
u0: {} +/- {}
chi2/dof: {}
```
---
""".format(params[names['to']], err[names['to']], params[names['tE']],
err[names['tE']], params[names['uo']], err[names['uo']],
params[-1] / dof)
return figure, mulens_params
mulens_params = """
```python
# Fitted parameters
t0: None
tE: None
u0: None
chi2: None
```
---
"""
return {'data': [], "layout": layout_mulens}, mulens_params
import os
import sys
import numpy as np
sys.path.append("/usr/custom/pyLIMA-1.0.0")
from pyLIMA import event, telescopes, microlmodels
from pyLIMA_functions import chi2_telescope
file_1 = "test_10000.txt"
data_1 = np.loadtxt(file_1)
telescope_1 = telescopes.Telescope(light_curve_magnitude=data_1)
your_event = event.Event()
your_event.telescopes.append(telescope_1)
model_1 = microlmodels.create_model('PSPL', your_event)
model_1.define_model_parameters()
t_0 = 2456900.
u_0 = 0.01
t_E = 20.
parameters_list = [t_0, u_0, t_E]
### Create an event object. You can choose the name and RA,DEC in degrees :
your_event = event.Event()
your_event.name = 'your choice'
#Here RA DEC matters !!
your_event.ra = 266.25624999999997
your_event.dec = -22.261972222222223
## Now we need some observations. That's good, we obtain some data on two
### telescopes. Both are in I band and magnitude units :
data_1 = np.loadtxt('./Survey_parallax.dat')
telescope_1 = telescopes.Telescope(name='OGLE',
camera_filter='I',
light_curve_magnitude=data_1)
### Add the telescopes to your event :
your_event.telescopes.append(telescope_1)
### Sanity check
your_event.check_event()
### Construct the model you want to fit. Let's go basic with a PSPL, without second_order effects :
model_1 = microlmodels.create_model('PSPL', your_event)
### Let's try with the simplest Levenvberg_Marquardt algorithm :
your_event.fit(model_1, 'LM')
### Let's see some plots.
your_event = event.Event()
your_event.name = 'The_secret_event'
### Now we need some observations. That's good, we obtain some data from somewhere....
directory = '/home/etienne/Work/HackSession/secret_event/'
event_telescopes = [i for i in os.listdir(directory)]
for i, name in enumerate(event_telescopes):
data_1 = np.loadtxt(directory + name)
telescope_1 = telescopes.Telescope(name=name[:-4],
camera_filter='I',
light_curve_magnitude=data_1)
plt.scatter(data_1[:, 0] - 2450000, data_1[:, 1])
your_event.telescopes.append(telescope_1)
plt.xlabel('HJD')
plt.ylabel('Mag')
plt.gca().invert_yaxis()
plt.show()
### Construct the model you want to fit. Let's go basic with a PSPL, without second_order effects :
model_1 = microlmodels.create_model('PSPL', your_event)
### Let's try with the simplest Levenvberg_Marquardt algorithm :
from pyLIMA import event
from pyLIMA import telescopes
from pyLIMA import microlmodels
### Create an event object. You can choose the name and RA,DEC in degrees :
your_event = event.Event()
your_event.name = 'your choice'
your_event.ra = 269.39166666666665
your_event.dec = -29.22083333333333
### Now we need some observations. That's good, we obtain some data on two
### telescopes. Both are in I band and magnitude units :
data_1 = np.loadtxt('./Survey_1.dat')
telescope_1 = telescopes.Telescope(name='OGLE', camera_filter='I', light_curve_magnitude=data_1)
data_2 = np.loadtxt('./Followup_1.dat')
telescope_2 = telescopes.Telescope(name='LCOGT', camera_filter='I', light_curve_magnitude=data_2)
### Add the telescopes to your event :
your_event.telescopes.append(telescope_1)
your_event.telescopes.append(telescope_2)
### Find the survey telescope :
your_event.find_survey('OGLE')
### Sanity check
your_event.check_event()
def fit_PSPL_parallax(ra, dec, photometry, emag_limit=None, cores=None):
# Filter orders
filters_order = ['I', 'ip', 'i_ZTF', 'r_ZTF', 'R', 'g_ZTF', 'gp', 'G']
filters = np.unique(photometry[:, -1])
order = []
for fil in filters_order:
mask = np.where(filters == fil)[0]
if len(mask) != 0:
order += mask.tolist()
for fil in filters:
if fil not in filters_order:
mask = np.where(filters == fil)[0]
if len(mask) != 0:
order += mask.tolist()
filters = filters[order]
t0_fit, u0_fit, tE_fit, mag_source_fit, mag_blend_fit, mag_baseline_fit, chi2_fit = fit_PSPL(
photometry, emag_limit=None, cores=cores)
current_event = event.Event()
current_event.name = 'MOP_to_fit'
current_event.ra = ra
current_event.dec = dec
for ind, filt in enumerate(filters):
if emag_limit:
mask = (photometry[:, -1] == filt) & (np.abs(
photometry[:, -2].astype(float)) < emag_limit)
else:
mask = (photometry[:, -1] == filt)
lightcurve = photometry[mask, :-1].astype(float)
telescope = telescopes.Telescope(name='Tel_' + str(ind),
camera_filter=filt,
light_curve_magnitude=lightcurve,
light_curve_magnitude_dictionnary={
'time': 0,
'mag': 1,
'err_mag': 2
},
clean_the_lightcurve='Yes')
if len(lightcurve) > 5:
current_event.telescopes.append(telescope)
t0_par = t0_fit
Model_parallax = microlmodels.create_model('PSPL',
current_event,
parallax=['Full', t0_par])
Model_parallax.parameters_boundaries[0] = [t0_fit - 100, t0_fit + 100]
Model_parallax.parameters_boundaries[1] = [-2, 2]
Model_parallax.parameters_boundaries[2] = [0.1, 500]
#Model_parallax.parameters_boundaries[3] = [-1,1]
#Model_parallax.parameters_boundaries[4] = [-1,1]
Model_parallax.parameters_guess = [t0_fit, u0_fit, tE_fit, 0, 0]
if cores != 0:
import multiprocessing
with multiprocessing.Pool(processes=cores) as pool:
current_event.fit(Model_parallax,
'DE',
DE_population_size=10,
flux_estimation_MCMC='polyfit',
computational_pool=pool)
else:
current_event.fit(Model_parallax,
'DE',
DE_population_size=10,
flux_estimation_MCMC='polyfit')
#if (chi2_fit-current_event.fits[-1].fit_results[-1])/current_event.fits[-1].fit_results[-1]<0.1:
#return [t0_fit,u0_fit,tE_fit,None,None,mag_source_fit,mag_blend_fit,mag_baseline_fit]
t0_fit = current_event.fits[-1].fit_results[0]
u0_fit = current_event.fits[-1].fit_results[1]
tE_fit = current_event.fits[-1].fit_results[2]
piEN_fit = current_event.fits[-1].fit_results[3]
piEE_fit = current_event.fits[-1].fit_results[4]
mag_source_fit = flux_to_mag(current_event.fits[-1].fit_results[5])
mag_blend_fit = flux_to_mag(current_event.fits[-1].fit_results[5] *
current_event.fits[-1].fit_results[6])
mag_baseline_fit = flux_to_mag(current_event.fits[-1].fit_results[5] *
(1 + current_event.fits[-1].fit_results[6]))
if np.isnan(mag_blend_fit):
mag_blend_fit = "null"
microloutputs.create_the_fake_telescopes(
current_event.fits[0], current_event.fits[0].fit_results[:-1])
model_telescope = current_event.fits[0].event.fake_telescopes[0]
pyLIMA_parameters = Model_parallax.compute_pyLIMA_parameters(
current_event.fits[0].fit_results[:-1])
flux_model = current_event.fits[0].model.compute_the_microlensing_model(
model_telescope, pyLIMA_parameters)[0]
magnitude = microltoolbox.flux_to_magnitude(flux_model)
model_telescope.lightcurve_magnitude[:, 1] = magnitude
mask = ~np.isnan(magnitude)
model_telescope.lightcurve_magnitude = model_telescope.lightcurve_magnitude[
mask]
try:
to_return = [
np.around(t0_fit, 3),
np.around(u0_fit, 5),
np.around(tE_fit, 3),
np.around(piEN_fit, 5),
np.around(piEE_fit, 5),
np.around(mag_source_fit, 3),
np.around(mag_blend_fit, 3),
np.around(mag_baseline_fit, 3),
current_event.fits[-1].fit_covariance, model_telescope
]
except:
to_return = [
np.around(t0_fit, 3),
np.around(u0_fit, 5),
np.around(tE_fit, 3),
np.around(piEN_fit, 5),
np.around(piEE_fit, 5),
np.around(mag_source_fit, 3), mag_blend_fit,
np.around(mag_baseline_fit, 3),
current_event.fits[-1].fit_covariance, model_telescope
]
return to_return
