def alpha_beta2XanYan(input_model, reference_files):
"""
Create the transform from detector to Xan, Yan frame.
forward transform:
RegionsSelector
label_mapper is LabelMapperDict()
{channel_wave_range (): channel_number}
selector is {channel_number: ab2Xan & ab2Yan}
bacward_transform
RegionsSelector
label_mapper is LabelMapperDict()
{channel_wave_range (): channel_number}
selector is {channel_number: Xan2ab & Yan2ab}
"""
band = input_model.meta.instrument.band
channel = input_model.meta.instrument.channel
# used to read the wavelength range
channels = [c + band for c in channel]
f = AsdfFile.open(reference_files['v2v3'])
v23 = f.tree['model']
f.close()
f = AsdfFile.open(reference_files['wavelengthrange'])
# the following should go in the asdf reader
wave_range = f.tree['wavelengthrange'].copy()
wave_channels = f.tree['channels']
wr = {}
for ch, r in zip(wave_channels, wave_range):
wr[ch] = r
f.close()
dict_mapper = {}
sel = {}
for c in channels:
ch = int(c[0])
dict_mapper[tuple(wr[c])] = models.Mapping((2,), name="mapping_lam") | \
models.Const1D(ch, name="channel #")
map1 = models.Mapping((1, 0, 1, 0), name='map2poly')
map1._outputs = ('alpha', 'beta', 'alpha', 'beta')
map1._inputs = ('alpha', 'beta')
map1.inverse = models.Mapping((0, 1))
ident1 = models.Identity(1, name='identity_lam')
ident1._inputs = ('lam',)
chan_v23 = v23[c]
v23chan_backward = chan_v23.inverse
del chan_v23.inverse
v23_spatial = map1 | chan_v23
v23_spatial.inverse = map1 | v23chan_backward
v23c = v23_spatial & ident1
sel[ch] = v23c
wave_range_mapper = selector.LabelMapperRange(('alpha', 'beta', 'lam'), dict_mapper,
inputs_mapping=models.Mapping([2, ]))
wave_range_mapper.inverse = wave_range_mapper.copy()
ab2xyan = selector.RegionsSelector(('alpha', 'beta', 'lam'), ('v2', 'v3', 'lam'),
label_mapper=wave_range_mapper,
selector=sel)
return ab2xyan
def abl_to_v2v3l(input_model, reference_files):
"""
Create the transform from "alpha_beta" to "v2v3" frame.
Transform description:
forward transform
RegionsSelector
label_mapper is LabelMapperDict()
{channel_wave_range (): channel_number}
selector is {channel_number: ab2v2 & ab2v3}
bacward_transform
RegionsSelector
label_mapper is LabelMapperDict()
{channel_wave_range (): channel_number}
selector is {channel_number: v22ab & v32ab}
"""
band = input_model.meta.instrument.band
channel = input_model.meta.instrument.channel
# used to read the wavelength range
channels = [c + band for c in channel]
with DistortionMRSModel(reference_files['distortion']) as dist:
v23 = dict(zip(dist.abv2v3_model.channel_band,
dist.abv2v3_model.model))
with WavelengthrangeModel(reference_files['wavelengthrange']) as f:
wr = dict(zip(f.waverange_selector, f.wavelengthrange))
dict_mapper = {}
sel = {}
# Since there are two channels in each reference file we need to loop over them
for c in channels:
ch = int(c[0])
dict_mapper[tuple(wr[c])] = (models.Mapping(
(2, ), name="mapping_lam") | models.Const1D(ch, name="channel #"))
ident1 = models.Identity(1, name='identity_lam')
ident1._inputs = ('lam', )
chan_v23 = v23[c]
v23chan_backward = chan_v23.inverse
del chan_v23.inverse
v23_spatial = chan_v23
v23_spatial.inverse = v23chan_backward
# Tack on passing the third wavelength component
v23c = v23_spatial & ident1
sel[ch] = v23c
wave_range_mapper = selector.LabelMapperRange(
('alpha', 'beta', 'lam'),
dict_mapper,
inputs_mapping=models.Mapping([
2,
]))
wave_range_mapper.inverse = wave_range_mapper.copy()
abl2v2v3l = selector.RegionsSelector(('alpha', 'beta', 'lam'),
('v2', 'v3', 'lam'),
label_mapper=wave_range_mapper,
selector=sel)
return abl2v2v3l
def detector_to_abl(input_model, reference_files):
"""
Create the transform from "detector" to "alpha_beta" frame.
Transform description:
forward transform
RegionsSelector
label_mapper is the regions array
selector is {slice_number: alpha_model & beta_model & lambda_model}
backward transform
RegionsSelector
label_mapper is LabelMapperDict
{channel_wave_range (): LabelMapperDict}
{beta: slice_number}
selector is {slice_number: x_transform & y_transform}
"""
band = input_model.meta.instrument.band
channel = input_model.meta.instrument.channel
# used to read the wavelength range
with DistortionMRSModel(reference_files['distortion']) as dist:
alpha_model = dist.alpha_model
beta_model = dist.beta_model
x_model = dist.x_model
y_model = dist.y_model
bzero = dict(zip(dist.bzero.channel_band, dist.bzero.beta_zero))
bdel = dict(zip(dist.bdel.channel_band, dist.bdel.delta_beta))
slices = dist.slices
with SpecwcsModel(reference_files['specwcs']) as f:
lambda_model = f.model
try:
velosys = input_model.meta.wcsinfo.velosys
except AttributeError:
pass
else:
if velosys is not None:
velocity_corr = velocity_correction(
input_model.meta.wcsinfo.velosys)
lambda_model = [m | velocity_corr for m in lambda_model]
log.info("Applied Barycentric velocity correction : {}".format(
velocity_corr[1].amplitude.value))
with RegionsModel(reference_files['regions']) as f:
allregions = f.regions.copy()
# Use the 50% throughput slice mask
regions = allregions[4, :, :]
label_mapper = selector.LabelMapperArray(regions)
transforms = {}
for i, sl in enumerate(slices):
forward = models.Mapping([1, 0, 0, 1, 0]) | \
alpha_model[i] & beta_model[i] & lambda_model[i]
inv = models.Mapping([2, 0, 2, 0]) | x_model[i] & y_model[i]
forward.inverse = inv
transforms[sl] = forward
with WavelengthrangeModel(reference_files['wavelengthrange']) as f:
wr = dict(zip(f.waverange_selector, f.wavelengthrange))
ch_dict = {}
for c in channel:
cb = c + band
mapper = jwmodels.MIRI_AB2Slice(bzero[cb], bdel[cb], c)
lm = selector.LabelMapper(inputs=('alpha', 'beta', 'lam'),
mapper=mapper,
inputs_mapping=models.Mapping((1, ),
n_inputs=3))
ch_dict[tuple(wr[cb])] = lm
alpha_beta_mapper = selector.LabelMapperRange(
('alpha', 'beta', 'lam'), ch_dict, models.Mapping((2, )))
label_mapper.inverse = alpha_beta_mapper
det2alpha_beta = selector.RegionsSelector(('x', 'y'),
('alpha', 'beta', 'lam'),
label_mapper=label_mapper,
selector=transforms)
return det2alpha_beta
def detector_to_abl(input_model, reference_files):
"""
Create the transform from "detector" to "alpha_beta" frame.
Transform description:
forward transform
RegionsSelector
label_mapper is the regions array
selector is {slice_number: alpha_model & beta_model & lambda_model}
backward transform
RegionsSelector
label_mapper is LabelMapperDict
{channel_wave_range (): LabelMapperDict}
{beta: slice_number}
selector is {slice_number: x_transform & y_transform}
"""
band = input_model.meta.instrument.band
channel = input_model.meta.instrument.channel
# used to read the wavelength range
with DistortionMRSModel(reference_files['distortion']) as dist:
alpha_model = dist.alpha_model
beta_model = dist.beta_model
x_model = dist.x_model
y_model = dist.y_model
bzero = dict(zip(dist.bzero.channel_band, dist.bzero.beta_zero))
bdel = dict(zip(dist.bdel.channel_band, dist.bdel.delta_beta))
slices = dist.slices
with SpecwcsModel(reference_files['specwcs']) as f:
lambda_model = f.model
with RegionsModel(reference_files['regions']) as f:
regions = f.regions.copy()
label_mapper = selector.LabelMapperArray(regions)
transforms = {}
for i, sl in enumerate(slices):
forward = models.Mapping([1, 0, 0, 1, 0]) | \
alpha_model[i] & beta_model[i] & lambda_model[i]
inv = models.Mapping([2, 0, 2, 0]) | x_model[i] & y_model[i]
forward.inverse = inv
transforms[sl] = forward
with WavelengthrangeModel(reference_files['wavelengthrange']) as f:
wr = dict(zip(f.waverange_selector, f.wavelengthrange))
ch_dict = {}
for c in channel:
cb = c + band
mapper = jwmodels.MIRI_AB2Slice(bzero[cb], bdel[cb], c)
lm = selector.LabelMapper(inputs=('alpha', 'beta', 'lam'),
mapper=mapper,
inputs_mapping=models.Mapping((1, ),
n_inputs=3))
ch_dict[tuple(wr[cb])] = lm
alpha_beta_mapper = selector.LabelMapperRange(
('alpha', 'beta', 'lam'), ch_dict, models.Mapping((2, )))
label_mapper.inverse = alpha_beta_mapper
det2alpha_beta = selector.RegionsSelector(('x', 'y'),
('alpha', 'beta', 'lam'),
label_mapper=label_mapper,
selector=transforms)
return det2alpha_beta
def detector_to_alpha_beta(input_model, reference_files):
"""
Create the transform from detector to alpha, beta frame.
forward transform:
RegionsSelector
label_mapper is the regions array
selector is {slice_number: alphs_model & beta_model & lambda_model}
backward transform:
RegionsSelector
label_mapper is LabelMapperDict
{channel_wave_range (): LabelMapperDict}
{beta: slice_number}
selector is {slice_number: x_transform & y_transform}
"""
band = input_model.meta.instrument.band
channel = input_model.meta.instrument.channel
# used to read the wavelength range
channels = [c + band for c in channel]
f = AsdfFile.open(reference_files['distortion'])
# The name of the model indicates the output coordinate
alpha_model = f.tree['alpha_model']
beta_model = f.tree['beta_model']
x_model = f.tree['x_model']
y_model = f.tree['y_model']
slice_model = f.tree['slice_model']
f.close()
f = AsdfFile.open(reference_files['specwcs'])
lambda_model = f.tree['model']
f.close()
f = AsdfFile.open(reference_files['regions'])
regions = f.tree['regions'].copy()
f.close()
label_mapper = selector.LabelMapperArray(regions)
transforms = {}
for sl in alpha_model:
#chan = str(sl // 100) + band
forward = models.Mapping([1, 0, 0, 1, 0]) | \
alpha_model[sl] & beta_model[sl] & lambda_model[sl]
inv = models.Mapping([2, 0, 2, 0]) | x_model[sl] & y_model[sl]
forward.inverse = inv
transforms[sl] = forward
f = AsdfFile.open(reference_files['wavelengthrange'])
# the following should go in the asdf reader
wave_range = f.tree['wavelengthrange'].copy()
wave_channels = f.tree['channels']
wr = {}
for ch, r in zip(wave_channels, wave_range):
wr[ch] = r
f.close()
ch_dict = {}
for c in channels:
ch_dict.update({tuple(wr[c]): selector.LabelMapperDict(('alpha', 'beta', 'lam'), slice_model[c],
models.Mapping([1, ], n_inputs=3))})
alpha_beta_mapper = selector.LabelMapperRange(('alpha', 'beta', 'lam'), ch_dict,
models.Mapping((2,)))
label_mapper.inverse = alpha_beta_mapper
det2alpha_beta = selector.RegionsSelector(('x', 'y'), ('alpha', 'beta', 'lam'),
label_mapper=label_mapper, selector=transforms)
return det2alpha_beta
def abl_to_v2v3l(input_model, reference_files):
"""
Create the transform from (alpha,beta,lambda) to (V2,V3,lambda) frame.
Parameters
----------
input_model : `jwst.datamodels.ImagingModel`
Data model.
reference_files : dict
Dictionary {reftype: reference file name}.
forward transform:
RegionsSelector
label_mapper is LabelMapperDict()
{channel_wave_range (): channel_number}
selector is {channel_number: ab2v2 & ab2v3}
bacward_transform
RegionsSelector
label_mapper is LabelMapperDict()
{channel_wave_range (): channel_number}
selector is {channel_number: v22ab & v32ab}
"""
band = input_model.meta.instrument.band
channel = input_model.meta.instrument.channel
# used to read the wavelength range
channels = [c + band for c in channel]
with DistortionMRSModel(reference_files['distortion']) as dist:
v23 = dict(zip(dist.abv2v3_model.channel_band,
dist.abv2v3_model.model))
with WavelengthrangeModel(reference_files['wavelengthrange']) as f:
wr = dict(zip(f.waverange_selector, f.wavelengthrange))
dict_mapper = {}
sel = {}
# Since there are two channels in each reference file we need to loop over them
for c in channels:
ch = int(c[0])
dict_mapper[tuple(wr[c])] = models.Mapping((2,), name="mapping_lam") | \
models.Const1D(ch, name="channel #")
ident1 = models.Identity(1, name='identity_lam')
ident1._inputs = ('lam', )
chan_v23 = v23[c]
v23chan_backward = chan_v23.inverse
del chan_v23.inverse
# This is the spatial part of the transform; tack on additional conversion to degrees
# Remove this degrees conversion once pipeline can handle v2,v3 in arcsec
v23_spatial = chan_v23 | models.Scale(1 / 3600) & models.Scale(
1 / 3600)
v23_spatial.inverse = models.Scale(3600) & models.Scale(
3600) | v23chan_backward
# Tack on passing the third wavelength component
v23c = v23_spatial & ident1
sel[ch] = v23c
wave_range_mapper = selector.LabelMapperRange(
('alpha', 'beta', 'lam'),
dict_mapper,
inputs_mapping=models.Mapping([
2,
]))
wave_range_mapper.inverse = wave_range_mapper.copy()
abl2v2v3l = selector.RegionsSelector(('alpha', 'beta', 'lam'),
('v2', 'v3', 'lam'),
label_mapper=wave_range_mapper,
selector=sel)
return abl2v2v3l
