def test_lin_subarray():
"""Test that the pipeline properly extracts the subarray from the reference file.
put dq flags in specific pixels and make sure they match in the output subarray file"""
# create input data
# create model of data with 0 value array
ngroups = 50
ysize = 224
xsize = 288
# create a JWST datamodel for MIRI data
im = RampModel((1, ngroups, ysize, xsize))
im.data += 1
im.meta.instrument.name = 'MIRI'
im.meta.instrument.detector = 'MIRIMAGE'
im.meta.instrument.filter = 'F1500W'
im.meta.instrument.band = 'N/A'
im.meta.observation.date = '2016-06-01'
im.meta.observation.time = '00:00:00'
im.meta.exposure.type = 'MIR_IMAGE'
im.meta.subarray.name = 'MASK1550'
im.meta.subarray.xstart = 1
im.meta.subarray.xsize = xsize
im.meta.subarray.ystart = 467
im.meta.subarray.ysize = ysize
# Read in reference file
dq = np.zeros((1024, 1032), dtype=int)
numcoeffs = 3
# place dq flags in dq array that would be in subarray
# MASK1550 file has colstart=1, rowstart=467
dq[542, 100:105] = 1
ref_model = LinearityModel((numcoeffs, 1024, 1032))
ref_model.dq = dq
ref_model.meta.instrument.name = 'MIRI'
ref_model.meta.instrument.detector = 'MIRIMAGE'
ref_model.meta.description = "MIRI LINEARITY Correction"
ref_model.meta.reftype = "LINEARITY"
ref_model.meta.author = "Monty Pytest"
ref_model.meta.pedigree = "GROUND"
ref_model.meta.useafter = '2015-08-01T00:00:00'
ref_model.meta.subarray.xstart = 1
ref_model.meta.subarray.xsize = 1032
ref_model.meta.subarray.ystart = 1
ref_model.meta.subarray.ysize = 1024
# run through pipeline
outfile = lincorr(im, ref_model)
# read dq array
outpixdq = outfile.pixeldq
# check for dq flag in pixeldq of subarray image
assert (outpixdq[76, 100] == 1)
assert (outpixdq[76, 104] == 1)
def test_lin_subarray():
"""Test that the pipeline properly extracts the subarray from the reference file.
put dq flags in specific pixels and make sure they match in the output subarray file"""
# create input data
# create model of data with 0 value array
ngroups = 50
ysize = 224
xsize = 288
# create a JWST datamodel for MIRI data
im = MIRIRampModel((1, ngroups, ysize, xsize))
im.data += 1
im.meta.instrument.name = 'MIRI'
im.meta.instrument.detector = 'MIRIMAGE'
im.meta.instrument.filter = 'F1500W'
im.meta.instrument.band = 'N/A'
im.meta.observation.date = '2016-06-01'
im.meta.observation.time = '00:00:00'
im.meta.exposure.type = 'MIR_IMAGE'
im.meta.subarray.name = 'MASK1550'
im.meta.subarray.xstart = 1
im.meta.subarray.xsize = xsize
im.meta.subarray.ystart = 467
im.meta.subarray.ysize = ysize
# Read in reference file
dq = np.zeros((1024, 1032), dtype=int)
numcoeffs = 3
# place dq flags in dq array that would be in subarray
# MASK1550 file has colstart=1, rowstart=467
dq[542, 100:105] = 1
ref_model = LinearityModel((numcoeffs, 1024, 1032))
ref_model.dq = dq
ref_model.meta.instrument.name = 'MIRI'
ref_model.meta.instrument.detector = 'MIRIMAGE'
ref_model.meta.subarray.xstart = 1
ref_model.meta.subarray.xsize = 1032
ref_model.meta.subarray.ystart = 1
ref_model.meta.subarray.ysize = 1024
# run through pipeline
outfile = lincorr(im, ref_model)
# read dq array
outpixdq = outfile.pixeldq
# check for dq flag in pixeldq of subarray image
assert(outpixdq[76, 100] == 1)
assert(outpixdq[76, 104] == 1)
def test_pixeldqprop():
"""Check that linearity reference file DQ values are populated into the PIXELDQ array of the data
This does not fully test mapping, as we have not provided a dq_def to define the
mapping of dq flags in the reference file. it's a straightforward mapping (1-1)"""
# size of integration
nints = 1
ngroups = 10
xsize = 1032
ysize = 1024
# create a JWST datamodel for MIRI data
im = make_rampmodel(nints, ngroups, ysize, xsize)
im.meta.instrument.detector = 'MIRIMAGE'
# Create reference file
dq = np.zeros((ysize, xsize), dtype=int)
numcoeffs = 3
# set PIXELDQ to 'NO_LIN_CORR'
dq[500, 500] = dqflags.pixel['NO_LIN_CORR']
dq[550, 550] = dqflags.pixel['DO_NOT_USE']
dq[560, 550] = dqflags.pixel['HOT']
dq[550, 560] = dqflags.pixel['DEAD']
dq[500, 300] = np.bitwise_or(dqflags.pixel['HOT'],
dqflags.pixel['DO_NOT_USE'])
ref_model = LinearityModel((numcoeffs, ysize, xsize))
ref_model.dq = dq
ref_model.meta.instrument.name = 'MIRI'
ref_model.meta.instrument.detector = 'MIRIMAGE'
ref_model.meta.subarray.xstart = 1
ref_model.meta.subarray.xsize = xsize
ref_model.meta.subarray.ystart = 1
ref_model.meta.subarray.ysize = ysize
# run through linearity correction
outfile = lincorr(im, ref_model)
assert (outfile.pixeldq[500, 500] == dqflags.pixel['NO_LIN_CORR'])
assert (outfile.pixeldq[550, 550] == dqflags.pixel['DO_NOT_USE'])
assert (outfile.pixeldq[560, 550] == dqflags.pixel['HOT'])
assert (outfile.pixeldq[550, 560] == dqflags.pixel['DEAD'])
assert (outfile.pixeldq[500,
300] == np.bitwise_or(dqflags.pixel['HOT'],
dqflags.pixel['DO_NOT_USE']))
def test_pixeldqprop():
"""Check that linearity reference file DQ values are populated into the PIXELDQ array of the data
This does not fully test mapping, as we have not provided a dq_def to define the
mapping of dq flags in the reference file. it's a straightforward mapping (1-1)"""
# size of integration
nints = 1
ngroups = 10
xsize = 1032
ysize = 1024
# create a JWST datamodel for MIRI data
im = make_rampmodel(nints, ngroups, ysize, xsize)
im.meta.instrument.detector = 'MIRIMAGE'
# Create reference file
dq = np.zeros((1024, 1032), dtype=int)
numcoeffs = 3
# set PIXELDQ to 'NO_LIN_CORR'
dq[500, 500] = dqflags.pixel['NO_LIN_CORR']
dq[550, 550] = dqflags.pixel['DO_NOT_USE']
dq[560, 550] = dqflags.pixel['HOT']
dq[550, 560] = dqflags.pixel['DEAD']
dq[500, 300] = np.bitwise_or(dqflags.pixel['HOT'], dqflags.pixel['DO_NOT_USE'])
ref_model = LinearityModel()
ref_model.data = np.zeros(shape=(numcoeffs, 1024, 1032), dtype=np.float32)
ref_model.dq = dq
ref_model.meta.instrument.name = 'MIRI'
ref_model.meta.instrument.detector = 'MIRIMAGE'
ref_model.meta.subarray.xstart = 1
ref_model.meta.subarray.xsize = 1032
ref_model.meta.subarray.ystart = 1
ref_model.meta.subarray.ysize = 1024
# run through linearity correction
outfile = lincorr(im, ref_model)
assert(outfile.pixeldq[500, 500] == dqflags.pixel['NO_LIN_CORR'])
assert(outfile.pixeldq[550, 550] == dqflags.pixel['DO_NOT_USE'])
assert(outfile.pixeldq[560, 550] == dqflags.pixel['HOT'])
assert(outfile.pixeldq[550, 560] == dqflags.pixel['DEAD'])
assert(outfile.pixeldq[500, 300] == np.bitwise_or(dqflags.pixel['HOT'], dqflags.pixel['DO_NOT_USE']))
def test_nolincorr():
"""Check that correction is not applied for pixels flagged NO_LIN_CORR in the DQ array
of the reference file."""
# size of integration
nints = 1
ngroups = 10
xsize = 1032
ysize = 1024
# create a JWST datamodel for MIRI data
im = make_rampmodel(nints, ngroups, ysize, xsize)
im.meta.instrument.detector = 'MIRIMAGE'
# set data value
im.data[0, 5, 500, 500] = 35
# Create reference file
dq = np.zeros((ysize, xsize), dtype=int)
numcoeffs = 3
# set reference file DQ to 'NO_LIN_CORR'
dq[500, 500] = dqflags.pixel['NO_LIN_CORR']
ref_model = LinearityModel((numcoeffs, 1024, 1032))
ref_model.dq = dq
ref_model.meta.instrument.name = 'MIRI'
ref_model.meta.instrument.detector = 'MIRIMAGE'
ref_model.meta.subarray.xstart = 1
ref_model.meta.subarray.xsize = xsize
ref_model.meta.subarray.ystart = 1
ref_model.meta.subarray.ysize = ysize
# run through pipeline (saturation and linearity steps)
outfile = lincorr(im, ref_model)
assert (outfile.pixeldq[500, 500] == dqflags.pixel['NO_LIN_CORR'])
assert (outfile.data[0, 5, 500, 500] == 35
) # NO_LIN_CORR, sci value should not change
def test_nolincorr():
"""Check that correction is not applied for pixels flagged NO_LIN_CORR in the DQ array
of the reference file."""
# size of integration
nints = 1
ngroups = 10
xsize = 1032
ysize = 1024
# create a JWST datamodel for MIRI data
im = make_rampmodel(nints, ngroups, ysize, xsize)
im.meta.instrument.detector = 'MIRIMAGE'
# set data value
im.data[0, 5, 500, 500] = 35
# Create reference file
dq = np.zeros((1024, 1032), dtype=int)
numcoeffs = 3
# set reference file DQ to 'NO_LIN_CORR'
dq[500, 500] = dqflags.pixel['NO_LIN_CORR']
ref_model = LinearityModel()
ref_model.data = np.zeros(shape=(numcoeffs, 1024, 1032), dtype=np.float32)
ref_model.dq = dq
ref_model.meta.instrument.name = 'MIRI'
ref_model.meta.instrument.detector = 'MIRIMAGE'
ref_model.meta.subarray.xstart = 1
ref_model.meta.subarray.xsize = 1032
ref_model.meta.subarray.ystart = 1
ref_model.meta.subarray.ysize = 1024
# run through pipeline (saturation and linearity steps)
outfile = lincorr(im, ref_model)
assert(outfile.pixeldq[500, 500] == dqflags.pixel['NO_LIN_CORR'])
assert(outfile.data[0, 5, 500, 500] == 35) # NO_LIN_CORR, sci value should not change
def get_lin_coeffs(self, file):
"""Read in non-linearity coefficients, and check
for bad pixels
"""
lin_model = LinearityModel(file)
data = lin_model.coeffs
#set pixels with bad linearity coeffs
#so that no correction is applied
numcof, ys, xs = data.shape
bad = np.where(np.isnan(data))
for y, x in zip(bad[1], bad[2]):
data[0, y, x] = 0.
data[1, y, x] = 1.
data[2:, y, x] = 0.
return data
def save_reffile(self, lin, err, passedmap, files, output):
'''Save the reference file using JWST data models.'''
# Use jwst.datamodels LinearityModel to put data in correct FITS format.
finallinearity = LinearityModel()
finallinearity.coeffs = lin
# Need to add errors but LinearityModel doesn't have ERR extension yet.
finallinearity.err = err
# Create DQ flag definition table.
dqdef = []
dqssb_lin = {
'DO_NOT_USE': np.uint8(1),
'NONLINEAR': np.uint8(2),
'NO_LIN_CORR': np.uint8(4)
}
dqssb_desc = {
'Bad pixel, do not use.', 'Highly nonlinear pixel.',
'No linearity correction available.'
}
for bitname, bitdescription in zip(dqssb_lin, dqssb_desc):
bitvalue = dqssb_lin[bitname]
bitnumber = int(np.log(bitvalue) / np.log(2))
newrow = (bitnumber, bitvalue, bitname, bitdescription)
dqdef.append(newrow)
dqmap = passedmap
# Insert dq array into linearity reffile.
finallinearity.dq = dqmap
finallinearity.dq_def = dqdef
# Create the proper headers.
finallinearity = make_proper_header(finallinearity, files)
# Save the reference file.
outfile = output
finallinearity.save(outfile)
return outfile
def test_coeff_dq():
"""Test linearity algorithm with random data ramp (does algorithm match expected algorithm)
also test a variety of dq flags and expected output """
# size of integration
nints = 1
ngroups = 160
xsize = 103
ysize = 102
# create the data and groupdq arrays
# create a JWST datamodel for MIRI data
im = make_rampmodel(nints, ngroups, ysize, xsize)
im.meta.instrument.detector = 'MIRIMAGE'
# Create reference file
numcoeffs = 5
ref_model = LinearityModel((numcoeffs, ysize, xsize))
ref_model.dq = np.zeros((ysize, xsize), dtype=int)
ref_model.meta.instrument.name = 'MIRI'
ref_model.meta.instrument.detector = 'MIRIMAGE'
ref_model.meta.subarray.xstart = 1
ref_model.meta.subarray.ystart = 1
ref_model.meta.subarray.xsize = xsize
ref_model.meta.subarray.ysize = ysize
# Set coefficient values in reference file to check the algorithm
# Equation is DNcorr = L0 + L1*DN(i) + L2*DN(i)^2 + L3*DN(i)^3 + L4*DN(i)^4
# DN(i) = signal in pixel, Ln = coefficient from ref file
# L0 = 0 for all pixels for CDP6
L0 = 0
L1 = 0.85
L2 = 4.62E-6
L3 = -6.16E-11
L4 = 7.23E-16
coeffs = np.asfarray([0.0e+00, 0.85, 4.62e-06, -6.16e-11, 7.23e-16])
ref_model.data[:, 30, 50] = coeffs
# check behavior with NaN coefficients: should not alter pixel values
coeffs2 = np.asfarray([L0, np.nan, L2, L3, L4])
ref_model.data[:, 20, 50] = coeffs2
im.data[0, 50, 20, 50] = 500.0
tgroup = 2.775
# set pixel values (DN) for specific pixels up the ramp
im.data[0, :, 30, 50] = np.arange(ngroups) * 100 * tgroup
scival = 40000.0
im.data[0, 45, 30,
50] = scival # to check linearity multiplication is done correctly
im.data[
0, 30, 35,
36] = 35 # pixel to check that dq=2 meant no correction was applied
# check if dq flags in pixeldq are correctly populated in output
im.pixeldq[50, 40] = dqflags.pixel['DO_NOT_USE']
im.pixeldq[50, 41] = dqflags.pixel['SATURATED']
im.pixeldq[50, 42] = dqflags.pixel['DEAD']
im.pixeldq[50, 43] = dqflags.pixel['HOT']
# set dq flags in DQ of reference file
ref_model.dq[35, 35] = dqflags.pixel['DO_NOT_USE']
ref_model.dq[35, 36] = dqflags.pixel['NO_LIN_CORR']
ref_model.dq[30, 50] = dqflags.pixel['GOOD']
# run through Linearity pipeline
outfile = lincorr(im, ref_model)
# check that multiplication of polynomial was done correctly for specified pixel
outval = L0 + (L1 * scival) + (L2 * scival**2) + (L3 * scival**3) + (
L4 * scival**4)
assert (np.isclose(outfile.data[0, 45, 30, 50], outval, rtol=0.00001))
# check that dq value was handled correctly
assert outfile.pixeldq[35, 35] == dqflags.pixel['DO_NOT_USE']
assert outfile.pixeldq[35, 36] == dqflags.pixel['NO_LIN_CORR']
# NO_LIN_CORR, sci value should not change
assert outfile.data[0, 30, 35, 36] == 35
# NaN coefficient should not change data value
assert outfile.data[0, 50, 20, 50] == 500.0
def test_coeff_dq():
"""Test linearity algorithm with random data ramp (does algorithm match expected algorithm)
also test a variety of dq flags and expected output """
# size of integration
nints = 1
ngroups = 160
xsize = 1032
ysize = 1024
# create the data and groupdq arrays
# create a JWST datamodel for MIRI data
im = make_rampmodel(nints, ngroups, ysize, xsize)
im.meta.instrument.detector = 'MIRIMAGE'
# Create reference file
numcoeffs = 5
ref_model = LinearityModel((numcoeffs, ysize, xsize))
ref_model.dq = np.zeros((ysize, xsize), dtype=int)
ref_model.meta.instrument.name = 'MIRI'
ref_model.meta.instrument.detector = 'MIRIMAGE'
ref_model.meta.subarray.xstart = 1
ref_model.meta.subarray.ystart = 1
ref_model.meta.subarray.xsize = xsize
ref_model.meta.subarray.ysize = ysize
# Set coefficient values in reference file to check the algorithm
# Equation is DNcorr = L0 + L1*DN(i) + L2*DN(i)^2 + L3*DN(i)^3 + L4*DN(i)^4
# DN(i) = signal in pixel, Ln = coefficient from ref file
# L0 = 0 for all pixels for CDP6
L0 = 0
L1 = 0.85
L2 = 4.62E-6
L3 = -6.16E-11
L4 = 7.23E-16
coeffs = np.asfarray([0.0e+00, 0.85, 4.62e-06, -6.16e-11, 7.23e-16])
ref_model.data[:, 300, 500] = coeffs
# check behavior with NaN coefficients: should not alter pixel values
coeffs2 = np.asfarray([L0, np.nan, L2, L3, L4])
ref_model.data[:, 200, 500] = coeffs2
im.data[0, 50, 200, 500] = 500.0
tgroup = 2.775
# set pixel values (DN) for specific pixels up the ramp
im.data[0, :, 300, 500] = np.arange(ngroups) * 100 * tgroup
scival = 40000.0
im.data[0, 45, 300, 500] = scival # to check linearity multiplication is done correctly
im.data[0, 30, 350, 360] = 35 # pixel to check that dq=2 meant no correction was applied
# check if dq flags in pixeldq are correctly populated in output
im.pixeldq[50, 40] = 1
im.pixeldq[50, 41] = 2
im.pixeldq[50, 42] = 1024
im.pixeldq[50, 43] = 2048
# set dq flags in DQ of reference file
ref_model.dq[350, 350] = dqflags.pixel['DO_NOT_USE']
ref_model.dq[350, 360] = dqflags.pixel['NO_LIN_CORR']
ref_model.dq[300, 500] = dqflags.pixel['GOOD']
# run through Linearity pipeline
outfile = lincorr(im, ref_model)
# check that multiplication of polynomial was done correctly for specified pixel
outval = L0+(L1*scival)+(L2*scival**2)+(L3*scival**3)+(L4*scival**4)
assert(np.isclose(outfile.data[0, 45, 300, 500], outval, rtol=0.00001))
# check that dq value was handled correctly
assert(outfile.pixeldq[350, 350] == 1)
assert(outfile.pixeldq[350, 360] == dqflags.pixel['NO_LIN_CORR']) # NO_LIN_CORR flag
assert(outfile.data[0, 30, 350, 360] == 35) # NO_LIN_CORR, sci value should not change
assert(outfile.data[0, 50, 200, 500] == 500.0) # NaN coefficient should not change data value
def test_lin_subarray():
"""Test that the pipeline properly extracts the subarray from the reference file.
put dq flags in specific pixels and make sure they match in the output subarray file"""
# create input data
# create model of data with 0 value array
ngroups = 50
ysize = 224
xsize = 288
# create the data and groupdq arrays
csize = (1, ngroups, ysize, xsize)
data = np.full(csize, 1.0)
pixeldq = np.zeros((ysize, xsize), dtype=int)
groupdq = np.zeros(csize, dtype=int)
# create a JWST datamodel for MIRI data
im = MIRIRampModel(data=data, pixeldq=pixeldq, groupdq=groupdq)
im.meta.instrument.name = 'MIRI'
im.meta.instrument.detector = 'MIRIMAGE'
im.meta.instrument.filter = 'F1500W'
im.meta.instrument.band = 'N/A'
im.meta.observation.date = '2016-06-01'
im.meta.observation.time = '00:00:00'
im.meta.exposure.type = 'MIR_IMAGE'
im.meta.subarray.name = 'MASK1550'
im.meta.subarray.xstart = 1
im.meta.subarray.xsize = xsize
im.meta.subarray.ystart = 467
im.meta.subarray.ysize = ysize
# Read in reference file
dq = np.zeros((1024, 1032), dtype=int)
numcoeffs = 3
# place dq flags in dq array that would be in subarray
# MASK1550 file has colstart=1, rowstart=467
dq[542, 100:105] = 1
ref_model = LinearityModel()
ref_model.data = np.zeros(shape=(numcoeffs, 1024, 1032), dtype=np.float32)
ref_model.dq = dq
ref_model.meta.instrument.name = 'MIRI'
ref_model.meta.instrument.detector = 'MIRIMAGE'
ref_model.meta.subarray.xstart = 1
ref_model.meta.subarray.xsize = 1032
ref_model.meta.subarray.ystart = 1
ref_model.meta.subarray.ysize = 1024
# run through pipeline
outfile = lincorr(im, ref_model)
# read dq array
outpixdq = outfile.pixeldq
# check for dq flag in pixeldq of subarray image
assert(outpixdq[76, 100] == 1)
assert(outpixdq[76, 104] == 1)
def make_files(self):
#loop over detector
for det in self.detectors:
satfile = [s for s in self.satfiles if det in s][0]
sat_model = SaturationModel(satfile)
sat = sat_model.data
#pixels with saturation level of 0.
#set sat level to 65535
bad = sat == 0
sat[bad] = 65535
linfile = [s for s in self.linfiles if det in s][0]
lin_model = LinearityModel(linfile)
lin = lin_model.coeffs
#pixels with bad linearity coeffs
#set so no correction is applied
nans = np.isnan(lin[1, :, :])
tmp = lin[1, :, :]
tmp[nans] = 1.
lin[1, :, :] = tmp
for i in range(2, 7):
tmp = lin[i, :, :]
nans = np.isnan(tmp)
tmp[nans] = 0.
lin[i, :, :] = tmp
#superbias file
sbfile = [s for s in self.sbfiles if det in s][0]
sb_model = SuperBiasModel(sbfile)
superbias = sb_model.data
#linearize the saturation values
sat_lin = self.linearize(sat - superbias, lin)
#loop over readout patterns
for readpat in self.readpatts:
nframe, nskip = self.readpatts[readpat]
#optional output plot
if self.plot:
xx = 400
yy = 400
fsize = 12
f = plt.figure()
a = f.add_subplot(111)
a2 = a.twiny()
f.subplots_adjust(bottom=0.2)
xs = np.arange(self.maxgroups * (nframe + nskip))
a.plot(xs,
np.repeat(sat[yy, xx], len(xs)),
linestyle=':',
color='blue',
linewidth=2,
label='Original Saturation')
a.plot(xs,
np.repeat(sat_lin[yy, xx] + superbias[yy, xx],
len(xs)),
linestyle=':',
color='red',
linewidth=2,
label='Linearized Saturation')
a.plot(xs,
np.repeat(superbias[yy, xx], len(xs)),
linestyle=':',
color='black',
linewidth=2,
label='Superbias Level')
#loop over groups
satramp = np.zeros((self.maxgroups, 2048, 2048))
linsatramp = np.zeros((self.maxgroups, 2048, 2048))
xfmeans = []
for i in range(self.maxgroups):
#exposure time to the final frame in the group
exptime = self.frametime * (nframe + nskip) * (i + 1)
satslope = sat_lin / exptime
#now calculate signals for each frame within the
#group, by reducing exposure time by one frametime
#for each
fsigs = np.zeros((nframe, 2048, 2048))
fsigs[0, :, :] = sat_lin
for frame in range(1, nframe):
fsigs[frame, :, :] = satslope * (
exptime - (self.frametime * frame))
linsatramp[i, :, :] = np.mean(fsigs,
axis=0) + superbias
#non-linearize fsigs
fsigs_nl = self.unlinearize(fsigs, lin, sat - superbias)
#add superbias back in
fsigs_nl += superbias
satramp[i, :, :] = np.mean(fsigs_nl, axis=0)
#print("Group: {}".format(i))
#print("Exptime: {}".format(exptime))
#print("Sat: {}, Lin Sat: {}".format(sat[yy,xx],sat_lin[yy,xx]))
#print("Satslope: {}".format(satslope[yy,xx]))
#print("Frame exps: {}".format(exptime-(self.frametime*np.arange(1,nframe))))
#print("signals: {}".format(fsigs[:,yy,xx]))
#print("mean signal: {}".format(satramp[i,yy,xx]))
#if i == 1:
# stop
if self.plot:
xf = np.array([-1])
xf = np.append(
xf,
np.arange((i + 1) * (nframe + nskip) - nframe,
(i + 1) * (nframe + nskip)))
yf = np.array([superbias[yy, xx]])
yf = np.append(
yf, fsigs[:, yy, xx][::-1] + superbias[yy, xx])
yfnl = np.array([superbias[yy, xx]])
yfnl = np.append(yfnl, fsigs_nl[:, yy, xx][::-1])
if i == 9:
a.plot(xf,
yf,
mfc='red',
mec='red',
color='black',
marker='o',
linestyle='-',
label='Linearized Frames',
alpha=0.5)
#a.plot(np.mean(xf[1:]),linsatramp[i,yy,xx],color='red',marker='8',mfc='none',mec='red',markersize=10,label='Linearized Frames Mean')
a.plot(xf,
yfnl,
mfc='black',
mec='black',
color='black',
marker='o',
linestyle='-',
label='Non-Linearized Frames',
alpha=0.5)
#a.plot(np.mean(xf[1:]),linsatramp[i,yy,xx],color='red',marker='8',mfc='none',mec='red',markersize=10,label='Linearized Frames Mean')
else:
a.plot(xf,
yf,
mfc='red',
mec='red',
color='black',
marker='o',
linestyle='-',
alpha=0.5)
#a.plot(np.mean(xf[1:]),linsatramp[i,yy,xx],color='red',mfc='none',mec='red',marker='8',markersize=10)
a.plot(xf,
yfnl,
mfc='black',
mec='black',
color='black',
marker='o',
linestyle='-',
alpha=0.5)
xfmeans.append(np.mean(xf[1:]))
#optional plot
if self.plot:
new_tick_locations = np.array(xfmeans)
a.plot(xfmeans,
satramp[:, yy, xx],
color='blue',
marker='8',
markersize=10,
label='Non-Linear Frames Mean')
a.legend(loc='lower right', numpoints=1, fontsize=fsize)
a.set_xlabel('Frame Number')
a.set_ylabel('Signal (DN)')
a.set_title('NRC{}, Readpattern: {}, Pixel ({},{})'.format(
det, readpat, xx, yy))
a.set_xlim(-1, np.max(xf) + 1)
a.set_ylim(0, 60000)
# Move twinned axis ticks and label from top to bottom
a2.xaxis.set_ticks_position("bottom")
a2.xaxis.set_label_position("bottom")
# Offset the twin axis below the host
a2.spines["bottom"].set_position(("axes", -0.15))
# Turn on the frame for the twin axis, but then hide all
# but the bottom spine
a2.set_frame_on(True)
a2.patch.set_visible(False)
for sp in a2.spines.itervalues():
sp.set_visible(False)
a2.spines["bottom"].set_visible(True)
a2.set_xticks(new_tick_locations)
a2.set_xticklabels(np.arange(len(new_tick_locations)))
a2.set_xlabel("Group Number")
f.savefig(
'GroupSatPlot_forTR_{}_{}_C_filledcircs.png'.format(
det, readpat))
#save output file
self.savefile(satramp, det, readpat)
