def dflux_for_mlt(chunk, filter_obs, mjd_obs, variability_cache, dflux_out):
valid_obj = np.where(chunk['var_type'] == 2)
n_mlt = len(valid_obj[0])
if n_mlt == 0:
return
lc_id_map = {}
for ii in range(4):
lc_id_map[10 + ii] = 'early_inactive_%d' % ii
lc_id_map[20 + ii] = 'early_active_%d' % ii
lc_id_map[30 + ii] = 'mid_inactive_%d' % ii
lc_id_map[40 + ii] = 'mid_active_%d' % ii
lc_id_map[50 + ii] = 'late_active_%d' % ii
mlt_model = MLTflaringMixin()
mlt_model.photParams = PhotometricParameters(nexp=1, exptime=30.0)
mlt_model.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
mlt_model._actually_calculated_columns = []
for bp in 'ugrizy':
mlt_model._actually_calculated_columns.append('lsst_%s' % bp)
params = {}
params['lc'] = np.array(
[lc_id_map[ii] for ii in chunk['lc_id'][valid_obj]])
params['t0'] = chunk['t0'][valid_obj]
q_mags = {}
for bp in 'ugrizy':
q_mags[bp] = chunk['%smag' % bp][valid_obj]
for i_bp, bp in enumerate('ugrizy'):
valid_bp = np.where(filter_obs == i_bp)
if len(valid_bp[0]) == 0:
continue
results = mlt_model.applyMLTflaring(
np.array([True] * n_mlt),
params,
mjd_obs[valid_bp],
parallax=chunk['parallax'][valid_obj],
ebv=chunk['ebv'][valid_obj],
quiescent_mags=q_mags,
variability_cache=variability_cache,
do_mags=False,
mag_name_tuple=(bp, ))
for i_local, i_global in enumerate(valid_obj[0]):
dflux_out[i_global][valid_bp] = results[0][i_local]
def test_MLT_many_mjd_some_invalid(self):
"""
This test will verify that applyMLTflaring responds properly when given
an array/vector of MJD values in the case where some stars are not
marked as valid MLT stars.
"""
db = MLT_test_DB(database=self.db_name, driver='sqlite')
rng = np.random.RandomState(16)
mjd_arr = rng.random_sample(17)*3653.3+59580.0
objid = []
parallax = []
ebv = []
quiescent_u = []
quiescent_g = []
delta_u = []
delta_g = []
varparams = []
for mjd in mjd_arr:
obs = ObservationMetaData(mjd=mjd)
cat = FlaringCatalog(db, obs_metadata=obs,
column_outputs=['parallax', 'ebv',
'quiescent_lsst_u',
'quiescent_lsst_g',
'varParamStr',
'delta_lsst_u',
'delta_lsst_g'])
cat._mlt_lc_file = self.mlt_lc_name
n_obj = 0
for line in cat.iter_catalog():
n_obj += 1
objid.append(line[0])
parallax.append(line[3])
ebv.append(line[4])
quiescent_u.append(line[5])
quiescent_g.append(line[6])
varparams.append(line[7])
delta_u.append(line[8])
delta_g.append(line[9])
objid = np.array(objid)
parallax = np.array(parallax)
ebv = np.array(ebv)
quiescent_u = np.array(quiescent_u)
quiescent_g = np.array(quiescent_g)
delta_u = np.array(delta_u)
delta_g = np.array(delta_g)
self.assertEqual(len(parallax), n_obj*len(mjd_arr))
np.testing.assert_array_equal(objid, np.array([0,1,2,3]*len(mjd_arr)))
quiescent_mags = {}
quiescent_mags['u'] = quiescent_u
quiescent_mags['g'] = quiescent_g
params = {}
params['lc'] = []
params['t0'] = []
for ix in range(n_obj):
local_dict = json.loads(varparams[ix])
params['lc'].append(local_dict['p']['lc'])
params['t0'].append(local_dict['p']['t0'])
params['lc'] = np.array(params['lc'])
params['t0'] = np.array(params['t0'])
mlt_obj = MLTflaringMixin()
mlt_obj.photParams = PhotometricParameters()
mlt_obj.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
mlt_obj._mlt_lc_file = cat._mlt_lc_file
mlt_obj._actually_calculated_columns = ['delta_lsst_u', 'delta_lsst_g']
valid_dex = [] # applyMLT does not actually use valid_dex; it looks for non-None params['lc']
for ix in range(n_obj):
if ix not in (1,2):
params['lc'][ix] = None
delta_mag_vector = mlt_obj.applyMLTflaring(valid_dex, params, mjd_arr,
parallax=parallax,
ebv=ebv,
quiescent_mags=quiescent_mags)
n_time = len(mjd_arr)
self.assertEqual(delta_mag_vector.shape, (6, n_obj, n_time))
for i_time, mjd in enumerate(mjd_arr):
for i_obj in range(n_obj):
if i_obj not in (1,2):
for i_band in range(6):
self.assertEqual(delta_mag_vector[i_band][i_obj][i_time], 0.0)
continue
for i_band in range(6):
if i_band==0:
self.assertEqual(delta_mag_vector[i_band][i_obj][i_time],
delta_u[i_time*n_obj + i_obj])
elif i_band==1:
self.assertEqual(delta_mag_vector[i_band][i_obj][i_time],
delta_g[i_time*n_obj + i_obj])
else:
self.assertEqual(delta_mag_vector[i_band][i_obj][i_time], 0.0)
def test_selective_MLT_magnitudes(self):
"""
This test will verify that applyMLTflaring responds correctly
when mag_name_tuple is set to simulate only a subset of bandpasses
"""
rng =np.random.RandomState(87124)
n_stars = 1000
n_time = 5
quiescent_mags = {}
quiescent_mags['u'] = rng.random_sample(n_stars)*5.0+17.0
quiescent_mags['g'] = rng.random_sample(n_stars)*5.0+17.0
ebv = rng.random_sample(n_stars)*4.0
parallax = rng.random_sample(n_stars)*np.radians(0.001/3600.0)
available_lc = np.array(['lc_1', 'lc_2'])
params = {}
params['lc'] = rng.choice(available_lc, size=n_stars)
params['t0'] = rng.random_sample(n_stars)*1000.0
mjd_arr = rng.random_sample(n_time)*500.0*59580.0
mlt_obj = MLTflaringMixin()
mlt_obj.photParams = PhotometricParameters()
mlt_obj.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
mlt_obj._mlt_lc_file = self.mlt_lc_name
mlt_obj._actually_calculated_columns = ['delta_lsst_u', 'delta_lsst_g']
valid_dex = [] # applyMLT does not actually use valid_dex; it looks for non-None params['lc']
valid_obj = rng.choice(np.arange(n_stars, dtype=int), size=50)
for ix in range(n_stars):
if ix not in valid_obj:
params['lc'][ix] = None
delta_mag_vector = mlt_obj.applyMLTflaring(valid_dex, params, mjd_arr,
parallax=parallax,
ebv=ebv,
quiescent_mags=quiescent_mags)
n_time = len(mjd_arr)
self.assertEqual(delta_mag_vector.shape, (6, n_stars, n_time))
# test that delta_flux is correctly calculated
delta_flux_vector = mlt_obj.applyMLTflaring(valid_dex, params, mjd_arr,
parallax=parallax,
ebv=ebv,
quiescent_mags=quiescent_mags,
do_mags=False)
self.assertEqual(delta_flux_vector.shape, delta_mag_vector.shape)
dummy_sed = Sed()
for i_band in range(6):
if i_band>=2:
# because we only implemented models of variability for u, g
np.testing.assert_array_equal(delta_flux_vector[i_band],
np.zeros(delta_flux_vector[i_band].shape, dtype=float))
continue
for i_obj in range(n_stars):
mag0 = quiescent_mags['ug'[i_band]][i_obj]
flux0 = dummy_sed.fluxFromMag(mag0)
delta_flux_control = dummy_sed.fluxFromMag(mag0 + delta_mag_vector[i_band][i_obj])-flux0
denom = np.abs(delta_flux_control)
denom = np.where(denom>0.0, denom, 1.0e-20)
err = np.abs(delta_flux_vector[i_band][i_obj]-delta_flux_control)/denom
self.assertLess(err.max(), 1.0e-6)
# see that we get the same results as before when we request a subset
# of magnitudes
test_mag_vector = mlt_obj.applyMLTflaring(valid_dex, params, mjd_arr,
parallax=parallax,
ebv=ebv,
quiescent_mags=quiescent_mags,
mag_name_tuple=('g','i'))
non_zero = np.where(test_mag_vector[0]<0.0)
self.assertGreater(len(non_zero[0]), 0)
np.testing.assert_array_equal(test_mag_vector[0],
delta_mag_vector[1])
np.testing.assert_array_equal(test_mag_vector[1],
delta_mag_vector[3])
test_flux_vector = mlt_obj.applyMLTflaring(valid_dex, params, mjd_arr,
parallax=parallax,
ebv=ebv,
quiescent_mags=quiescent_mags,
do_mags=False,
mag_name_tuple=('u','z','g'))
non_zero = np.where(test_flux_vector[2]>0.0)
self.assertGreater(len(non_zero[0]), 0)
np.testing.assert_array_equal(test_flux_vector[0],
delta_flux_vector[0])
np.testing.assert_array_equal(test_flux_vector[1],
delta_flux_vector[4])
np.testing.assert_array_equal(test_flux_vector[2],
delta_flux_vector[1])
def test_MLT_many_mjd_some_invalid(self):
"""
This test will verify that applyMLTflaring responds properly when given
an array/vector of MJD values in the case where some stars are not
marked as valid MLT stars.
"""
db = MLT_test_DB(database=self.db_name, driver='sqlite')
rng = np.random.RandomState(16)
mjd_arr = rng.random_sample(17)*3653.3+59580.0
objid = []
parallax = []
ebv = []
quiescent_u = []
quiescent_g = []
delta_u = []
delta_g = []
varparams = []
for mjd in mjd_arr:
obs = ObservationMetaData(mjd=mjd)
cat = FlaringCatalog(db, obs_metadata=obs,
column_outputs=['parallax', 'ebv',
'quiescent_lsst_u',
'quiescent_lsst_g',
'varParamStr',
'delta_lsst_u',
'delta_lsst_g'])
cat._mlt_lc_file = self.mlt_lc_name
n_obj = 0
for line in cat.iter_catalog():
n_obj += 1
objid.append(line[0])
parallax.append(line[3])
ebv.append(line[4])
quiescent_u.append(line[5])
quiescent_g.append(line[6])
varparams.append(line[7])
delta_u.append(line[8])
delta_g.append(line[9])
objid = np.array(objid)
parallax = np.array(parallax)
ebv = np.array(ebv)
quiescent_u = np.array(quiescent_u)
quiescent_g = np.array(quiescent_g)
delta_u = np.array(delta_u)
delta_g = np.array(delta_g)
self.assertEqual(len(parallax), n_obj*len(mjd_arr))
np.testing.assert_array_equal(objid, np.array([0,1,2,3]*len(mjd_arr)))
quiescent_mags = {}
quiescent_mags['u'] = quiescent_u
quiescent_mags['g'] = quiescent_g
params = {}
params['lc'] = []
params['t0'] = []
for ix in range(n_obj):
local_dict = json.loads(varparams[ix])
params['lc'].append(local_dict['p']['lc'])
params['t0'].append(local_dict['p']['t0'])
params['lc'] = np.array(params['lc'])
params['t0'] = np.array(params['t0'])
mlt_obj = MLTflaringMixin()
mlt_obj.photParams = PhotometricParameters()
mlt_obj.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
mlt_obj._mlt_lc_file = cat._mlt_lc_file
mlt_obj._actually_calculated_columns = ['delta_lsst_u', 'delta_lsst_g']
valid_dex = [] # applyMLT does not actually use valid_dex; it looks for non-None params['lc']
for ix in range(n_obj):
if ix not in (1,2):
params['lc'][ix] = None
delta_mag_vector = mlt_obj.applyMLTflaring(valid_dex, params, mjd_arr,
parallax=parallax,
ebv=ebv,
quiescent_mags=quiescent_mags)
n_time = len(mjd_arr)
self.assertEqual(delta_mag_vector.shape, (6, n_obj, n_time))
for i_time, mjd in enumerate(mjd_arr):
for i_obj in range(n_obj):
if i_obj not in (1,2):
for i_band in range(6):
self.assertEqual(delta_mag_vector[i_band][i_obj][i_time], 0.0)
continue
for i_band in range(6):
if i_band==0:
self.assertEqual(delta_mag_vector[i_band][i_obj][i_time],
delta_u[i_time*n_obj + i_obj])
elif i_band==1:
self.assertEqual(delta_mag_vector[i_band][i_obj][i_time],
delta_g[i_time*n_obj + i_obj])
else:
self.assertEqual(delta_mag_vector[i_band][i_obj][i_time], 0.0)
# test that delta_flux is correctly calculated
delta_flux_vector = mlt_obj.applyMLTflaring(valid_dex, params, mjd_arr,
parallax=parallax,
ebv=ebv,
quiescent_mags=quiescent_mags,
do_mags=False)
self.assertEqual(delta_flux_vector.shape, delta_mag_vector.shape)
dummy_sed = Sed()
for i_band in range(6):
if i_band>=2:
# because we only implemented models of variability for u, g
np.testing.assert_array_equal(delta_flux_vector[i_band],
np.zeros(delta_flux_vector[i_band].shape, dtype=float))
continue
for i_obj in range(n_obj):
mag0 = quiescent_mags['ug'[i_band]][i_obj]
flux0 = dummy_sed.fluxFromMag(mag0)
delta_flux_control = dummy_sed.fluxFromMag(mag0 + delta_mag_vector[i_band][i_obj])-flux0
denom = np.abs(delta_flux_control)
denom = np.where(denom>0.0, denom, 1.0e-20)
err = np.abs(delta_flux_vector[i_band][i_obj]-delta_flux_control)/denom
self.assertLess(err.max(), 1.0e-10)
import numpy as np
import h5py
import os
from lsst.sims.utils import radiansFromArcsec
from lsst.sims.catUtils.mixins import MLTflaringMixin
from lsst.sims.photUtils import PhotometricParameters
from lsst.sims.photUtils import BandpassDict
from lsst.sims.photUtils import Sed
quiet_mag = 17.0
dummy_sed = Sed()
phot_params = PhotometricParameters(nexp=1, exptime=30)
mlt_model = MLTflaringMixin()
mlt_model.photParams = phot_params
mlt_model.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
mlt_model._actually_calculated_columns = list(
['lsst_%s' % bp for bp in 'ugrizy'])
fname = os.path.join(os.environ['SIMS_DATA_DIR'], 'catUtilsData',
'mlt_shortened_lc_171012.npz')
assert os.path.isfile(fname)
lc_curve_time = {}
t_max_dex_dict = {}
with np.load(fname) as lc_file:
for name in lc_file.keys():
if 'time' in name:
def test_MLT_many_mjd(self):
"""
This test will verify that applyMLTflaring responds properly when given
an array/vector of MJD values.
"""
db = MLT_test_DB(database=self.db_name, driver='sqlite')
rng = np.random.RandomState(16)
mjd_arr = rng.random_sample(17) * 3653.3 + 59580.0
objid = []
parallax = []
ebv = []
quiescent_u = []
quiescent_g = []
delta_u = []
delta_g = []
varparams = []
for mjd in mjd_arr:
obs = ObservationMetaData(mjd=mjd)
cat = FlaringCatalog(db,
obs_metadata=obs,
column_outputs=[
'parallax', 'ebv', 'quiescent_lsst_u',
'quiescent_lsst_g', 'varParamStr',
'delta_lsst_u', 'delta_lsst_g'
])
cat._mlt_lc_file = self.mlt_lc_name
n_obj = 0
for line in cat.iter_catalog():
n_obj += 1
objid.append(line[0])
parallax.append(line[3])
ebv.append(line[4])
quiescent_u.append(line[5])
quiescent_g.append(line[6])
varparams.append(line[7])
delta_u.append(line[8])
delta_g.append(line[9])
objid = np.array(objid)
parallax = np.array(parallax)
ebv = np.array(ebv)
quiescent_u = np.array(quiescent_u)
quiescent_g = np.array(quiescent_g)
delta_u = np.array(delta_u)
delta_g = np.array(delta_g)
self.assertEqual(len(parallax), n_obj * len(mjd_arr))
np.testing.assert_array_equal(objid,
np.array([0, 1, 2, 3] * len(mjd_arr)))
quiescent_mags = {}
quiescent_mags['u'] = quiescent_u
quiescent_mags['g'] = quiescent_g
params = {}
params['lc'] = []
params['t0'] = []
for ix in range(4):
local_dict = json.loads(varparams[ix])
params['lc'].append(local_dict['p']['lc'])
params['t0'].append(local_dict['p']['t0'])
params['lc'] = np.array(params['lc'])
params['t0'] = np.array(params['t0'])
mlt_obj = MLTflaringMixin()
mlt_obj.photParams = PhotometricParameters()
mlt_obj.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
mlt_obj._mlt_lc_file = cat._mlt_lc_file
mlt_obj._actually_calculated_columns = ['delta_lsst_u', 'delta_lsst_g']
valid_dex = [np.arange(4, dtype=int)]
delta_mag_vector = mlt_obj.applyMLTflaring(
valid_dex,
params,
mjd_arr,
parallax=parallax,
ebv=ebv,
quiescent_mags=quiescent_mags)
n_time = len(mjd_arr)
n_obj = 4
self.assertEqual(delta_mag_vector.shape, (6, n_obj, n_time))
for i_time, mjd in enumerate(mjd_arr):
for i_obj in range(n_obj):
for i_band in range(6):
if i_band == 0:
self.assertEqual(
delta_mag_vector[i_band][i_obj][i_time],
delta_u[i_time * n_obj + i_obj])
elif i_band == 1:
self.assertEqual(
delta_mag_vector[i_band][i_obj][i_time],
delta_g[i_time * n_obj + i_obj])
else:
self.assertEqual(
delta_mag_vector[i_band][i_obj][i_time], 0.0)