def test_multislit_copy():
with MultiSlitModel() as input:
for i in range(4):
input.slits.append(
input.slits.item(data=np.empty((50, 50), dtype=np.float32)))
i = 0
for slit in input.slits:
i += 1
assert i == 4
input.save(TMP_FITS)
output = input.copy()
assert len(output.slits) == 4
i = 0
for slit in output.slits:
i += 1
assert i == 4
from astropy.io import fits
with fits.open(TMP_FITS, memmap=False) as hdulist:
assert len(hdulist) == 6
with MultiSlitModel(TMP_FITS) as input:
i = 0
for slit in input.slits:
i += 1
assert i == 4
output = input.copy()
assert len(output.slits) == 4
def test_multislit():
with MultiSlitModel() as dm:
dm.slits.append(dm.slits.item())
slit = dm.slits[-1]
slit.data = np.random.rand(5, 5)
slit.dm = np.random.rand(5, 5)
slit.err = np.random.rand(5, 5)
def test_container_structure():
"""Test for container usage."""
# Setup input
inputs = [MultiSlitModel(f) for f in helpers.INPUT_FILES]
container = ModelContainer(inputs)
# Make the source-based containers
outputs = multislit_to_container(container)
# See what we got.
assert len(container) == 3
assert len(outputs) == 5
for i, model in enumerate(container):
for slit in model.slits:
exposure = outputs[str(slit.source_id)][i]
assert (exposure.data == slit.data).all()
assert np.array_equal(exposure.data, slit.data)
assert exposure.meta.filename == model.meta.filename
assert exposure.meta.wcs.pipeline == slit.meta.wcs.pipeline
# Closeout
container.close()
for model in inputs:
model.close()
def test_multislit_metadata():
with MultiSlitModel() as ms:
with ImageModel((64, 64)) as im:
ms.slits.append(ms.slits.item())
ms.slits[-1].data = im.data
im = ms.slits[0]
im.name = "FOO"
assert ms.slits[0].name == "FOO"
def test_get_center_attr_err():
"""if no center provided for modes that are not IFU,
center is assigned to (0.0, 0.0)"""
datmod = MultiSlitModel()
x_pos, y_pos = get_center("NRS_MSASPEC", datmod)
assert(x_pos==y_pos==0.0)
def test_multislit_move_from_fits(tmp_path):
path = tmp_path / "multislit_move.fits"
hdulist = fits.HDUList()
hdulist.append(fits.PrimaryHDU())
for i in range(5):
hdu = fits.ImageHDU(data=np.zeros((64, 64)), name='SCI')
hdu.ver = i + 1
hdulist.append(hdu)
hdulist.writeto(path)
n = MultiSlitModel()
with MultiSlitModel(path) as m:
n.slits.append(m.slits[2])
assert len(n.slits) == 1
def test_do_correction_nis_soss_tso():
"""If observation is tso, skip correction"""
datmod = MultiSlitModel()
pathlossmod = PathlossModel()
datmod.meta.exposure.type = 'NIS_SOSS'
datmod.meta.visit.tsovisit = True
result, _ = do_correction(datmod, pathlossmod)
assert(result.meta.cal_step.pathloss == 'SKIPPED')
def test_do_correction_msa_slit_size_eq_0():
"""If slits have size 0, quit calibration."""
datmod = MultiSlitModel()
datmod.slits.append({'data':np.array([])})
pathlossmod = PathlossModel()
datmod.meta.exposure.type = 'NRS_MSASPEC'
result, _ = do_correction(datmod, pathlossmod)
assert(result.meta.cal_step.pathloss == 'COMPLETE')
def test_get_app_from_model_null():
"""If exp_type isn't the NRS or NIS specific mode,
routine returns None"""
datmod = MultiSlitModel()
datmod.meta.exposure.type = 'NRC_IMAGE'
result = get_aperture_from_model(datmod, None)
assert(result is None)
def test_multislit():
with MultiSlitModel() as dm:
dm.slits.append(dm.slits.item())
slit = dm.slits[-1]
slit.data = np.random.rand(5, 5)
slit.dm = np.random.rand(5, 5)
slit.err = np.random.rand(5, 5)
assert slit.wavelength.shape == (0, 0)
assert slit.pathloss_point.shape == (0, 0)
assert slit.pathloss_uniform.shape == (0, 0)
assert slit.barshadow.shape == (0, 0)
def test_do_correction_nis_soss_pupil_position_is_none():
"""If pupil_position is None, skip correction"""
datmod = MultiSlitModel()
pathlossmod = PathlossModel()
datmod.meta.exposure.type = 'NIS_SOSS'
datmod.meta.visit.tsovisit = False
datmod.meta.instrument.pupil_position = None
result, _ = do_correction(datmod, pathlossmod)
assert(result.meta.cal_step.pathloss == 'SKIPPED')
def test_get_center_exptype():
""" If exptype is "NRS_MSASPEC" | "NRS_FIXEDSLIT" | "NRS_BRIGHTOBJ" and
source_xpos and source_ypos exist in datamod.slits, make sure it's returned"""
datmod = MultiSlitModel()
datmod.slits.append({'source_xpos':1, 'source_ypos':2})
for exptype in ["NRS_MSASPEC", "NRS_FIXEDSLIT", "NRS_BRIGHTOBJ"]:
x_pos, y_pos = get_center(exptype, datmod.slits[0])
assert(x_pos==1)
assert(y_pos==2)
def test_image_with_extra_keyword_to_multislit():
with ImageModel((32, 32)) as im:
im.save(TMP_FITS, overwrite=True)
from astropy.io import fits
with fits.open(TMP_FITS, mode="update", memmap=False) as hdulist:
hdulist[1].header['BUNIT'] = 'x'
with ImageModel(TMP_FITS) as im:
with MultiSlitModel() as ms:
ms.update(im)
for i in range(3):
ms.slits.append(ImageModel((4, 4)))
assert len(ms.slits) == 3
ms.save(TMP_FITS2, overwrite=True)
with MultiSlitModel(TMP_FITS2) as ms:
assert len(ms.slits) == 3
for slit in ms.slits:
assert slit.data.shape == (4, 4)
def test_do_correction_fixed_slit_exception():
"""If no matching aperture name found, exit."""
datmod = MultiSlitModel()
# Give input_model aperture name
datmod.slits.append({'data':np.array([]), 'name':'S200A1'})
# Do assign pathloss model aperture with similar name.
pathlossmod = PathlossModel()
datmod.meta.exposure.type = 'NRS_FIXEDSLIT'
result, _ = do_correction(datmod, pathlossmod)
assert(result.meta.cal_step.pathloss == 'COMPLETE')
def test_multislit_copy(tmp_path):
path = tmp_path / "multislit.fits"
with MultiSlitModel() as input:
for i in range(4):
input.slits.append(input.slits.item(data=np.empty((50, 50))))
assert len(input.slits) == 4
input.save(path)
output = input.copy()
assert len(output.slits) == 4
with fits.open(path, memmap=False) as hdulist:
assert len(hdulist) == 6
with MultiSlitModel(path) as model:
for i, slit in enumerate(model.slits):
pass
assert i + 1 == 4
output = model.copy()
assert len(output.slits) == 4
def test_copy_multislit():
model1 = MultiSlitModel()
model2 = MultiSlitModel()
model1.slits.append(ImageModel(np.ones((1024, 1024))))
model2.slits.append(ImageModel(np.ones((1024, 1024)) * 2))
# Create the output model as a copy of the first input
output = model1.copy()
assert len(model1.slits) == 1
assert len(model2.slits) == 1
assert len(output.slits) == 1
assert model1.slits[0].data[330, 330] == 1
assert output.slits[0].data[330, 330] == 1
assert id(model1.slits[0].data) != id(output.slits[0].data)
output.slits[0].data = model1.slits[0].data - model2.slits[0].data
assert model1.slits[0].data[330, 330] == 1
assert output.slits[0].data[330, 330] == -1
def test_image_with_extra_keyword_to_multislit(tmp_path):
path = tmp_path / "extra_keyword_image.fits"
path2 = tmp_path / "extra_keyword_multislit.fits"
with ImageModel((32, 32)) as im:
im.save(path)
from astropy.io import fits
with fits.open(path, mode="update", memmap=False) as hdulist:
hdulist[1].header['BUNIT'] = 'x'
with ImageModel(path) as im:
with MultiSlitModel() as ms:
ms.update(im)
for i in range(3):
ms.slits.append(ImageModel((4, 4)))
assert len(ms.slits) == 3
ms.save(path2)
with MultiSlitModel(path2) as ms:
assert len(ms.slits) == 3
for slit in ms.slits:
assert slit.data.shape == (4, 4)
def test_multislit_from_fits_image():
with ImageModel((64, 64)) as im:
im.save(TMP_FITS, overwrite=True)
with MultiSlitModel(TMP_FITS) as ms:
assert len(ms.slits) == 1
assert ms.slits[0].data.shape == (64, 64)
for i, slit in enumerate(ms.slits):
assert slit.data is ms.slits[i].data
ms2 = ms.copy()
ms2.slits = ms.slits
assert len(ms2.slits) == 1
def test_multislit_from_saved_imagemodel(tmp_path):
path = tmp_path / "multislit_from_image.fits"
with ImageModel((64, 64)) as im:
im.save(path)
with MultiSlitModel(path) as ms:
assert len(ms.slits) == 1
assert ms.slits[0].data.shape == (64, 64)
for i, slit in enumerate(ms.slits):
assert slit.data is ms.slits[i].data
ms2 = ms.copy()
ms2.slits = ms.slits
assert len(ms2.slits) == 1
def test_do_correction_nis_soss_aperture_is_none():
"""If no matching aperture is found, skip correction."""
datmod = MultiSlitModel()
# Is FULL an option for NIRISS?
# The test doesn't care but something to remember.
datmod.slits.append({'data':np.array([]), 'name':'FULL'})
# Don't assign pathloss model aperture with similar name
pathlossmod = PathlossModel()
datmod.meta.exposure.type = 'NIS_SOSS'
datmod.meta.visit.tsovisit = False
datmod.meta.instrument.pupil_position = 1
result, _ = do_correction(datmod, pathlossmod)
assert(result.meta.cal_step.pathloss == 'SKIPPED')
def test_multislit_model():
array1 = np.asarray(np.random.rand(2, 2), dtype='float32')
array2 = np.asarray(np.random.rand(2, 2), dtype='float32')
with MultiSlitModel() as ms:
assert len(ms.slits) == 0
ms.slits.append(ms.slits.item())
ms.slits[-1].data = array1
assert len(ms.slits) == 1
ms.slits.append(ms.slits.item())
ms.slits[-1].data = array2
assert len(ms.slits) == 2
for i, slit in enumerate(ms.slits):
assert slit == ms.slits[i]
ms2 = ms.copy()
assert len(ms2.slits) == 2
assert_array_equal(ms.slits[-1].data, array2)
del ms.slits[0]
assert len(ms.slits) == 1
assert_array_equal(ms.slits[0].data, array2)
def s2d_single(generate_wcs_transform):
pytest.importorskip("jwst")
from jwst.datamodels import MultiSlitModel, SlitModel
from jwst.assign_wcs.util import wcs_bbox_from_shape
shape = (10, 100)
dispaxis = 1
model = MultiSlitModel()
sm = SlitModel(shape)
sm.data
model.slits.append(sm)
for slit in model.slits:
slit.meta.wcs = generate_wcs_transform(dispaxis)
slit.meta.wcs.bounding_box = wcs_bbox_from_shape(shape)
slit.meta.wcsinfo.dispersion_direction = dispaxis
model.meta.telescope = "JWST"
return model
def test_multislit_model():
data = np.arange(24, dtype=np.float32).reshape((6, 4))
err = np.arange(24, dtype=np.float32).reshape((6, 4)) + 2
wav = np.arange(24, dtype=np.float32).reshape((6, 4)) + 3
dq = np.arange(24, dtype=np.uint32).reshape((6, 4)) + 1
s0 = SlitDataModel(data=data, err=err, dq=dq, wavelength=wav)
s1 = SlitDataModel(data=data + 1,
err=err + 1,
dq=dq + 1,
wavelength=wav + 1)
ms = MultiSlitModel()
ms.slits.append(s0)
ms.slits.append(s1)
ms.meta.instrument.name = 'NIRSPEC'
ms.meta.exposure.type = 'NRS_IMAGE'
slit1 = ms[1]
assert isinstance(slit1, SlitModel)
assert slit1.meta.instrument.name == 'NIRSPEC'
assert slit1.meta.exposure.type == 'NRS_IMAGE'
assert_allclose(slit1.data, data + 1)
def __init__(self, args=None):
if args is None:
args = sys.argv[1:]
if isinstance(args, str):
args = args.split(' ')
parser = argparse.ArgumentParser(
description='Convert exposure-based data to source-based data',
usage='python -m jwst.exp_to_source.main files')
parser.add_argument('files',
type=str,
nargs='+',
help='Files to convert')
parser.add_argument(
'-o',
'--output-path',
type=str,
default='.',
help='Folder to save results in. Default: "%(default)s"')
parser.add_argument('--dry-run',
action='store_true',
dest='dry_run',
help='Execute but do not save results.')
try:
parsed = parser.parse_args(args=args)
except SystemExit:
return
exposures = [MultiSlitModel(f) for f in parsed.files]
self.sources = exp_to_source(exposures)
if not parsed.dry_run:
for source in self.sources:
out_path = '.'.join([source, 'fits'])
out_path = os.path.join(parsed.output_path, out_path)
self.sources[source].save(out_path)
def s2d_multi(generate_wcs_transform, request):
pytest.importorskip("jwst")
from jwst.datamodels import SlitModel, MultiSlitModel
from jwst.assign_wcs.util import wcs_bbox_from_shape
shape = request.param
if shape[0] < shape[1]:
dispaxis = 1
else:
dispaxis = 2
model = MultiSlitModel()
sm = SlitModel(shape)
sm.data
model.slits.append(sm)
model.slits.append(sm)
for slit in model.slits:
slit.meta.wcs = generate_wcs_transform(dispaxis)
slit.meta.wcs.bounding_box = wcs_bbox_from_shape(shape)
slit.meta.wcsinfo.dispersion_direction = dispaxis
slit.meta.bunit_data = "Jy"
slit.meta.bunit_err = "Jy"
return model
def run_multislit_to_container():
inputs = ModelContainer([MultiSlitModel(f) for f in helpers.INPUT_FILES])
outputs = multislit_to_container(inputs)
return inputs, outputs
def test_multislit_append_string():
with pytest.raises(jsonschema.ValidationError):
m = MultiSlitModel(strict_validation=True)
m.slits.append('junk')
def test_multislit_metadata2():
with MultiSlitModel() as ms:
ms.slits.append(ms.slits.item())
for key, val in ms.iteritems():
assert isinstance(val, (bytes, str, int, float, bool, Time))
def test_get_center_exp_type():
"""if exp_type is not in NRS, center is returned (0.0,0.0)"""
datmod = MultiSlitModel()
x_pos, y_pos = get_center("NRC_IMAGE", datmod)
assert(x_pos==y_pos==0.0)
def test_multislit_from_image():
with ImageModel((64, 64)) as im:
with MultiSlitModel(im) as ms:
assert len(ms.slits) == 1
assert ms.slits[0].data.shape == (64, 64)
