def generate_nircam_reffiles(tmpdir_factory):
gainfile = str(tmpdir_factory.mktemp("ndata").join("gain.fits"))
readnoisefile = str(tmpdir_factory.mktemp("ndata").join('readnoise.fits'))
ingain = 6
xsize = 20
ysize = 20
gain = np.ones(shape=(ysize, xsize), dtype=np.float64) * ingain
gain_model = GainModel(data=gain)
gain_model.meta.instrument.name = "NIRCAM"
gain_model.meta.subarray.name = "FULL"
gain_model.meta.subarray.xstart = 1
gain_model.meta.subarray.ystart = 1
gain_model.meta.subarray.xsize = xsize
gain_model.meta.subarray.ysize = ysize
gain_model.save(gainfile)
inreadnoise = 5
rnoise = np.ones(shape=(ysize, xsize), dtype=np.float64) * inreadnoise
readnoise_model = ReadnoiseModel(data=rnoise)
readnoise_model.meta.instrument.name = "NIRCAM"
readnoise_model.meta.subarray.xstart = 1
readnoise_model.meta.subarray.ystart = 1
readnoise_model.meta.subarray.xsize = xsize
readnoise_model.meta.subarray.ysize = ysize
readnoise_model.save(readnoisefile)
return gainfile, readnoisefile
def setup_subarray_inputs(nints=1,
ngroups=10,
nrows=1032,
ncols=1024,
subxstart=1,
subxsize=1024,
subystart=1,
subysize=1032,
nframes=1,
grouptime=1.0,
deltatime=1,
readnoise=10,
gain=1):
data = np.zeros(shape=(nints, ngroups, subysize, subxsize),
dtype=np.float32)
err = np.ones(shape=(nints, ngroups, nrows, ncols), dtype=np.float32)
pixdq = np.zeros(shape=(subysize, subxsize), dtype=np.uint32)
gdq = np.zeros(shape=(nints, ngroups, subysize, subxsize), dtype=np.uint8)
gain = np.ones(shape=(nrows, ncols), dtype=np.float64) * gain
read_noise = np.full((nrows, ncols), readnoise, dtype=np.float32)
times = np.array(list(range(ngroups)), dtype=np.float64) * deltatime
model1 = RampModel(data=data,
err=err,
pixeldq=pixdq,
groupdq=gdq,
times=times)
model1.meta.instrument.name = 'MIRI'
model1.meta.instrument.detector = 'MIRIMAGE'
model1.meta.instrument.filter = 'F480M'
model1.meta.observation.date = '2015-10-13'
model1.meta.exposure.type = 'MIR_IMAGE'
model1.meta.exposure.group_time = deltatime
model1.meta.subarray.name = 'FULL'
model1.meta.subarray.xstart = subxstart
model1.meta.subarray.ystart = subystart
model1.meta.subarray.xsize = subxsize
model1.meta.subarray.ysize = subysize
model1.meta.exposure.frame_time = deltatime
model1.meta.exposure.ngroups = ngroups
model1.meta.exposure.group_time = deltatime
model1.meta.exposure.nframes = 1
model1.meta.exposure.groupgap = 0
gain = GainModel(data=gain)
gain.meta.instrument.name = 'MIRI'
gain.meta.subarray.xstart = 1
gain.meta.subarray.ystart = 1
gain.meta.subarray.xsize = 1024
gain.meta.subarray.ysize = 1032
rnModel = ReadnoiseModel(data=read_noise)
rnModel.meta.instrument.name = 'MIRI'
rnModel.meta.subarray.xstart = 1
rnModel.meta.subarray.ystart = 1
rnModel.meta.subarray.xsize = 1024
rnModel.meta.subarray.ysize = 1032
return model1, gdq, rnModel, pixdq, err, gain
def create_mod_arrays(ngroups, nints, nrows, ncols, deltatime, gain,
readnoise):
"""
For an input datacube (arbitrarily chosen to be MIRI), create arrays having
the specified dimensions for the pixel DQ, the group DQ, and the
ERR extensions, and create datamodels for the ramp, readnoise, and gain.
"""
gain = np.ones(shape=(nrows, ncols), dtype=np.float32) * gain
err = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.float32)
data = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.float32)
pixdq = np.zeros(shape=(nrows, ncols), dtype=np.uint32)
read_noise = np.full((nrows, ncols), readnoise, dtype=np.float32)
gdq = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.uint8)
# Create and populate ramp model
ramp_model = RampModel(data=data, err=err, pixeldq=pixdq, groupdq=gdq)
ramp_model.meta.instrument.name = 'MIRI'
ramp_model.meta.instrument.detector = 'MIRIMAGE'
ramp_model.meta.instrument.filter = 'F480M'
ramp_model.meta.observation.date = '2015-10-13'
ramp_model.meta.exposure.type = 'MIR_IMAGE'
ramp_model.meta.exposure.group_time = deltatime
ramp_model.meta.subarray.name = 'FULL'
ramp_model.meta.subarray.xstart = 1
ramp_model.meta.subarray.ystart = 1
ramp_model.meta.subarray.xsize = ncols
ramp_model.meta.subarray.ysize = nrows
ramp_model.meta.exposure.frame_time = deltatime
ramp_model.meta.exposure.ngroups = ngroups
ramp_model.meta.exposure.group_time = deltatime
ramp_model.meta.exposure.nframes = 1
ramp_model.meta.exposure.groupgap = 0
ramp_model.meta.exposure.drop_frames1 = 0
return ramp_model, read_noise, gain, pixdq, gdq, err
# Create and populate gain model
gain_model = GainModel(data=gain)
gain_model.meta.instrument.name = 'MIRI'
gain_model.meta.subarray.xstart = 1
gain_model.meta.subarray.ystart = 1
gain_model.meta.subarray.xsize = ncols
gain_model.meta.subarray.ysize = nrows
# Create and populate readnoise model
rnoise_model = ReadnoiseModel(data=read_noise)
rnoise_model.meta.instrument.name = 'MIRI'
rnoise_model.meta.subarray.xstart = 1
rnoise_model.meta.subarray.ystart = 1
rnoise_model.meta.subarray.xsize = ncols
rnoise_model.meta.subarray.ysize = nrows
return ramp_model, rnoise_model, gain_model, pixdq, gdq, err
def _setup(ngroups=10,
readnoise=10,
nints=1,
nrows=1024,
ncols=1032,
nframes=1,
grouptime=1.0,
gain=1,
deltatime=1):
times = np.array(list(range(ngroups)), dtype=np.float64) * deltatime
gain = np.ones(shape=(nrows, ncols), dtype=np.float64) * gain
err = np.ones(shape=(nints, ngroups, nrows, ncols), dtype=np.float64)
data = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.float64)
pixdq = np.zeros(shape=(nrows, ncols), dtype=np.uint32)
read_noise = np.full((nrows, ncols), readnoise, dtype=np.float64)
gdq = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.uint32)
rampmodel = RampModel(data=data,
err=err,
pixeldq=pixdq,
groupdq=gdq,
times=times)
rampmodel.meta.instrument.name = 'MIRI'
rampmodel.meta.instrument.detector = 'MIRIMAGE'
rampmodel.meta.instrument.filter = 'F480M'
rampmodel.meta.observation.date = '2015-10-13'
rampmodel.meta.exposure.type = 'MIR_IMAGE'
rampmodel.meta.exposure.group_time = deltatime
rampmodel.meta.subarray.name = 'FULL'
rampmodel.meta.subarray.xstart = 1
rampmodel.meta.subarray.ystart = 1
rampmodel.meta.subarray.xsize = ncols
rampmodel.meta.subarray.ysize = nrows
rampmodel.meta.exposure.frame_time = deltatime
rampmodel.meta.exposure.ngroups = ngroups
rampmodel.meta.exposure.group_time = deltatime
rampmodel.meta.exposure.nframes = 1
rampmodel.meta.exposure.groupgap = 0
gain = GainModel(data=gain)
gain.meta.instrument.name = 'MIRI'
gain.meta.subarray.xstart = 1
gain.meta.subarray.ystart = 1
gain.meta.subarray.xsize = ncols
gain.meta.subarray.ysize = nrows
rnmodel = ReadnoiseModel(data=read_noise)
rnmodel.meta.instrument.name = 'MIRI'
rnmodel.meta.subarray.xstart = 1
rnmodel.meta.subarray.ystart = 1
rnmodel.meta.subarray.xsize = ncols
rnmodel.meta.subarray.ysize = nrows
return rampmodel, gdq, rnmodel, pixdq, err, gain
def setup_inputs(ngroups=10,
readnoise=10,
nints=1,
nrows=103,
ncols=102,
nframes=1,
grouptime=1.0,
gain=1,
deltatime=1):
gain = np.ones(shape=(nrows, ncols), dtype=np.float64) * gain
err = np.ones(shape=(nints, ngroups, nrows, ncols), dtype=np.float64)
data = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.uint32)
pixdq = np.zeros(shape=(nrows, ncols), dtype=np.float64)
read_noise = np.full((nrows, ncols), readnoise, dtype=np.float64)
gdq = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.int32)
int_times = np.zeros((nints, ))
model1 = RampModel(data=data,
err=err,
pixeldq=pixdq,
groupdq=gdq,
int_times=int_times)
model1.meta.instrument.name = 'MIRI'
model1.meta.instrument.detector = 'MIRIMAGE'
model1.meta.instrument.filter = 'F480M'
model1.meta.observation.date = '2015-10-13'
model1.meta.exposure.type = 'MIR_IMAGE'
model1.meta.exposure.group_time = deltatime
model1.meta.subarray.name = 'FULL'
model1.meta.subarray.xstart = 1
model1.meta.subarray.ystart = 1
model1.meta.subarray.xsize = ncols
model1.meta.subarray.ysize = nrows
model1.meta.exposure.frame_time = deltatime
model1.meta.exposure.ngroups = ngroups
model1.meta.exposure.group_time = deltatime
model1.meta.exposure.nframes = 1
model1.meta.exposure.groupgap = 0
model1.meta.exposure.drop_frames1 = 0
gain = GainModel(data=gain)
gain.meta.instrument.name = 'MIRI'
gain.meta.subarray.xstart = 1
gain.meta.subarray.ystart = 1
gain.meta.subarray.xsize = ncols
gain.meta.subarray.ysize = nrows
rnModel = ReadnoiseModel(data=read_noise)
rnModel.meta.instrument.name = 'MIRI'
rnModel.meta.subarray.xstart = 1
rnModel.meta.subarray.ystart = 1
rnModel.meta.subarray.xsize = ncols
rnModel.meta.subarray.ysize = nrows
return model1, gdq, rnModel, pixdq, err, gain
def setup_small_cube(ngroups=10,
nints=1,
nrows=2,
ncols=2,
deltatime=10.,
gain=1.,
readnoise=10.):
'''Create input MIRI datacube having the specified dimensions
'''
gain = np.ones(shape=(nrows, ncols), dtype=np.float64) * gain
err = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.float64)
data = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.float64)
pixdq = np.zeros(shape=(nrows, ncols), dtype=np.int32)
read_noise = np.full((nrows, ncols), readnoise, dtype=np.float64)
gdq = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.uint8)
model1 = RampModel(data=data, err=err, pixeldq=pixdq, groupdq=gdq)
model1.meta.instrument.name = 'MIRI'
model1.meta.instrument.detector = 'MIRIMAGE'
model1.meta.instrument.filter = 'F480M'
model1.meta.observation.date = '2015-10-13'
model1.meta.exposure.type = 'MIR_IMAGE'
model1.meta.exposure.group_time = deltatime
model1.meta.subarray.name = 'FULL'
model1.meta.subarray.xstart = 1
model1.meta.subarray.ystart = 1
model1.meta.subarray.xsize = ncols
model1.meta.subarray.ysize = nrows
model1.meta.exposure.drop_frames1 = 0
model1.meta.exposure.frame_time = deltatime
model1.meta.exposure.ngroups = ngroups
model1.meta.exposure.group_time = deltatime
model1.meta.exposure.nframes = 1
model1.meta.exposure.groupgap = 0
gain = GainModel(data=gain)
gain.meta.instrument.name = 'MIRI'
gain.meta.subarray.xstart = 1
gain.meta.subarray.ystart = 1
gain.meta.subarray.xsize = ncols
gain.meta.subarray.ysize = nrows
rnModel = ReadnoiseModel(data=read_noise)
rnModel.meta.instrument.name = 'MIRI'
rnModel.meta.subarray.xstart = 1
rnModel.meta.subarray.ystart = 1
rnModel.meta.subarray.xsize = ncols
rnModel.meta.subarray.ysize = nrows
return model1, gdq, rnModel, pixdq, err, gain
def _setup(ngroups=10,
readnoise=10,
nints=1,
nrows=102,
ncols=103,
nframes=1,
grouptime=1.0,
gain=1,
deltatime=1,
subarray=False):
if subarray:
shape = (nints, ngroups, 20, 20)
else:
shape = (nints, ngroups, nrows, ncols)
model = RampModel(shape)
model.meta.instrument.name = 'MIRI'
model.meta.instrument.detector = 'MIRIMAGE'
model.meta.instrument.filter = 'F480M'
model.meta.observation.date = '2015-10-13'
model.meta.exposure.type = 'MIR_IMAGE'
model.meta.exposure.group_time = deltatime
model.meta.subarray.name = 'FULL'
model.meta.subarray.xstart = 1
model.meta.subarray.ystart = 1
model.meta.subarray.xsize = shape[3]
model.meta.subarray.ysize = shape[2]
model.meta.exposure.frame_time = deltatime
model.meta.exposure.ngroups = ngroups
model.meta.exposure.group_time = deltatime
model.meta.exposure.nframes = nframes
model.meta.exposure.groupgap = 0
gain_model = GainModel((nrows, ncols))
gain_model.data += gain
gain_model.meta.instrument.name = 'MIRI'
gain_model.meta.subarray.xstart = 1
gain_model.meta.subarray.ystart = 1
gain_model.meta.subarray.xsize = ncols
gain_model.meta.subarray.ysize = nrows
read_noise_model = ReadnoiseModel((nrows, ncols))
read_noise_model.data += readnoise
read_noise_model.meta.instrument.name = 'MIRI'
read_noise_model.meta.subarray.xstart = 1
read_noise_model.meta.subarray.ystart = 1
read_noise_model.meta.subarray.xsize = ncols
read_noise_model.meta.subarray.ysize = nrows
return model, read_noise_model, gain_model
def save(self, array, error):
# Save using datamodel
mod = GainModel()
mod.data = array
#mod.err = error
mod.meta.telescope = 'JWST'
mod.meta.author = self.author
mod.meta.description = self.descrip
mod.meta.useafter = self.useafter
mod.meta.instrument.name = 'NIRCAM'
mod.meta.instrument.detector = self.detector
mod.meta.pedigree = self.pedigree
mod.meta.reftype = 'GAIN'
mod.meta.subarray.fastaxis = self.fastaxis
mod.meta.subarray.slowaxis = self.slowaxis
mod.meta.subarray.name = 'GENERIC'
mod.meta.subarray.xsize = 2048
mod.meta.subarray.ysize = 2048
mod.meta.subarray.xstart = 1
mod.meta.subarray.ystart = 1
#mod = self.add_history(mod,self.history)
mod.history.append(self.history)
mod.save(os.path.join(self.outdir, self.outfile))
def generate_miri_reffiles():
ingain = 6
xsize = 103
ysize = 102
gain = np.ones(shape=(ysize, xsize), dtype=np.float64) * ingain
gain_model = GainModel(data=gain)
gain_model.meta.instrument.name = "MIRI"
gain_model.meta.subarray.name = "FULL"
gain_model.meta.subarray.xstart = 1
gain_model.meta.subarray.ystart = 1
gain_model.meta.subarray.xsize = xsize
gain_model.meta.subarray.ysize = ysize
inreadnoise = 5
rnoise = np.ones(shape=(ysize, xsize), dtype=np.float64) * inreadnoise
readnoise_model = ReadnoiseModel(data=rnoise)
readnoise_model.meta.instrument.name = "MIRI"
readnoise_model.meta.subarray.xstart = 1
readnoise_model.meta.subarray.ystart = 1
readnoise_model.meta.subarray.xsize = xsize
readnoise_model.meta.subarray.ysize = ysize
return gain_model, readnoise_model
def setup_inputs(ngroups=4,
readnoise=10,
nints=1,
nrows=4096,
ncols=4096,
nframes=1,
grouptime=1.0,
gain=1,
deltatime=1):
arr = np.array([
np.zeros([4096, 4096]),
np.ones([4096, 4096]) * 4000,
np.ones([4096, 4096]) * 8000,
np.ones([4096, 4096]) * 12000
],
dtype=np.float64)
arr = np.array([arr])
times = np.array(list(range(ngroups)), dtype=np.float64) * deltatime
gain = np.ones(shape=(nrows, ncols), dtype=np.float64) * gain
err = np.ones(shape=(nints, ngroups, nrows, ncols), dtype=np.float64)
data = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.float64)
data = arr
pixdq = np.zeros(shape=(nrows, ncols), dtype=np.float64)
read_noise = np.full((nrows, ncols), readnoise, dtype=np.float64)
gdq = np.zeros(shape=(nints, ngroups, nrows, ncols), dtype=np.int32)
model1 = RampModel(data=data,
err=err,
pixeldq=pixdq,
groupdq=gdq,
times=times)
model1.meta.instrument.name = 'MIRI'
model1.meta.instrument.detector = 'MIRIMAGE'
model1.meta.instrument.filter = 'F480M'
model1.meta.observation.date = '2015-10-13'
model1.meta.exposure.type = 'MIR_IMAGE'
model1.meta.exposure.group_time = deltatime
model1.meta.subarray.name = 'FULL'
model1.meta.subarray.xstart = 1
model1.meta.subarray.ystart = 1
model1.meta.subarray.xsize = 10
model1.meta.subarray.ysize = 10
model1.meta.exposure.frame_time = deltatime
model1.meta.exposure.ngroups = ngroups
model1.meta.exposure.group_time = deltatime
model1.meta.exposure.nframes = 1
model1.meta.exposure.groupgap = 0
model1.times = times
gain = GainModel(data=gain)
gain.meta.instrument.name = 'MIRI'
gain.meta.subarray.xstart = 1
gain.meta.subarray.ystart = 1
gain.meta.subarray.xsize = 10
gain.meta.subarray.ysize = 10
rnModel = ReadnoiseModel(data=read_noise)
rnModel.meta.instrument.name = 'MIRI'
rnModel.meta.subarray.xstart = 1
rnModel.meta.subarray.ystart = 1
rnModel.meta.subarray.xsize = 10
rnModel.meta.subarray.ysize = 10
return model1, gdq, rnModel, pixdq, err, gain
def setup_inputs_ramp_model_new(dims, frame_data, timing, variance):
"""
dims : tuple
nints, ngroups, nrows, ncols
frame_data : tuple
nframes, groupgap
timing : tuple
tframe, tgroup, tgroup0
variance : tuple
rnoise, gain
"""
nints, ngroups, nrows, ncols = dims
nframes, groupgap = frame_data
tframe, tgroup, tgroup0 = timing
rnoise, gain = variance
frame_time = tframe
group_time = (groupgap + nframes) * tframe
# Setup the RampModel
int_times = np.zeros((nints,))
rampmodel = RampModel((nints, ngroups, nrows, ncols), int_times=int_times)
rampmodel.meta.instrument.name = 'MIRI'
rampmodel.meta.instrument.detector = 'MIRIMAGE'
rampmodel.meta.instrument.filter = 'F480M'
rampmodel.meta.observation.date = '2015-10-13'
rampmodel.meta.exposure.type = 'MIR_IMAGE'
rampmodel.meta.exposure.frame_time = frame_time
rampmodel.meta.exposure.group_time = group_time
rampmodel.meta.exposure.groupgap = groupgap
rampmodel.meta.exposure.ngroups = ngroups
rampmodel.meta.exposure.nframes = nframes
rampmodel.meta.subarray.name = 'FULL'
rampmodel.meta.subarray.xstart = 1
rampmodel.meta.subarray.ystart = 1
rampmodel.meta.subarray.xsize = ncols
rampmodel.meta.subarray.ysize = nrows
# Set up the gain model
garray = np.ones(shape=(nrows, ncols), dtype=np.float64) * gain
gmodel = GainModel(data=garray)
gmodel.meta.instrument.name = 'MIRI'
gmodel.meta.subarray.xstart = 1
gmodel.meta.subarray.ystart = 1
gmodel.meta.subarray.xsize = ncols
gmodel.meta.subarray.ysize = nrows
# Set up the read noise model
read_noise = np.full((nrows, ncols), rnoise, dtype=np.float64)
rnmodel = ReadnoiseModel(data=read_noise)
rnmodel.meta.instrument.name = 'MIRI'
rnmodel.meta.subarray.xstart = 1
rnmodel.meta.subarray.ystart = 1
rnmodel.meta.subarray.xsize = ncols
rnmodel.meta.subarray.ysize = nrows
return rampmodel, gmodel, rnmodel
def _setup(ngroups=10,
readnoise=10,
nints=1,
nrows=1024,
ncols=1032,
nframes=1,
grouptime=1.0,
gain=1,
deltatime=1,
gain_subarray=False,
readnoise_subarray=False,
subarray=False):
# Populate data arrays for gain and readnoise ref files
gain = np.ones(shape=(nrows, ncols), dtype=np.float64) * gain
read_noise = np.full((nrows, ncols), readnoise, dtype=np.float64)
# Create data array for science RampModel
if subarray:
data = np.zeros(shape=(nints, ngroups, 20, 20), dtype=np.float64)
else:
data = np.zeros(shape=(nints, ngroups, nrows, ncols),
dtype=np.float64)
# Create the science RampModel and populate meta data
model1 = RampModel(data=data)
model1.meta.instrument.name = 'MIRI'
model1.meta.instrument.detector = 'MIRIMAGE'
model1.meta.instrument.filter = 'F480M'
model1.meta.observation.date = '2015-10-13'
model1.meta.exposure.type = 'MIR_IMAGE'
model1.meta.exposure.group_time = deltatime
model1.meta.subarray.name = 'FULL'
model1.meta.subarray.xstart = 1
model1.meta.subarray.ystart = 1
if subarray:
model1.meta.subarray.xsize = 20
model1.meta.subarray.ysize = 20
else:
model1.meta.subarray.xsize = ncols
model1.meta.subarray.ysize = nrows
model1.meta.exposure.frame_time = deltatime
model1.meta.exposure.ngroups = ngroups
model1.meta.exposure.group_time = deltatime
model1.meta.exposure.nframes = 1
model1.meta.exposure.groupgap = 0
# Create gain datamodel and populate meta
gain = GainModel(data=gain)
gain.meta.instrument.name = 'MIRI'
gain.meta.subarray.xstart = 1
gain.meta.subarray.ystart = 1
gain.meta.subarray.xsize = ncols
gain.meta.subarray.ysize = nrows
# Create readnoise datamodel and populate meta
rnModel = ReadnoiseModel(data=read_noise)
rnModel.meta.instrument.name = 'MIRI'
rnModel.meta.subarray.xstart = 1
rnModel.meta.subarray.ystart = 1
rnModel.meta.subarray.xsize = ncols
rnModel.meta.subarray.ysize = nrows
return model1, rnModel, gain
