def analyze_data(fitsfn, observables_dir="", affine2d=None,
psf_offset_find_rotation = (0.0,0.0),
psf_offset_ff = None,
rotsearch_d=None,
set_pistons=None):
"""
returns: affine2d (measured or input),
psf_offset_find_rotation (input),
psf_offset_ff (input or found),
fringe pistons/r (found)
"""
print("analyze_data: input file", fitsfn)
data = fits.getdata(fitsfn)
dim = data.shape[1]
mx, my, sx,sy, xo,yo, = (1.0,1.0, 0.0,0.0, 0.0,0.0)
niriss = InstrumentData.NIRISS(filt, bandpass=bandpass, affine2d=affine2d)
ff_t = nrm_core.FringeFitter(niriss, psf_offset_ff=psf_offset_ff, datadir=fitsimdir, savedir=fitsimdir+observables_dir,
oversample=oversample, interactive=False)
ff_t.fit_fringes(fitsfn)
examine_residuals(ff_t)
np.set_printoptions(formatter={'float': lambda x: '{:+.2e}'.format(x)}, linewidth=80)
print("analyze_data: fringepistons/rad", ff_t.nrm.fringepistons)
default_printoptions()
return affine2d, psf_offset_find_rotation, ff_t.nrm.psf_offset, ff_t.nrm.fringepistons
def analyze_data(fitsfn=None,
fitsimdir=None,
oitdir=None,
oifdir=None,
affine2d=None,
psf_offset_find_rotation=(0.0, 0.0),
psf_offset_ff=None,
rotsearch_d=None,
set_pistons=None,
oversample=3,
firstfew=None,
verbose=False):
"""
returns: affine2d (measured or input),
psf_offset_find_rotation (input),
psf_offset_ff (input or found),
fringe pistons/r (found)
"""
if verbose: print("analyze_data: input", fitsimdir + fitsfn)
if verbose: print("analyze_data: oversample", oversample)
fobj = fits.open(fitsimdir + fitsfn)
if verbose: print(fobj[0].header['FILTER'])
niriss = InstrumentData.NIRISS(
fobj[0].header['FILTER'],
bpexist=False,
firstfew=
firstfew, # read_data truncation to only read first few slices...
)
ff = nrm_core.FringeFitter(
niriss,
oitdir=
oitdir, # write OI text files here, and diagnostic images if desired
oifdir=oifdir, # write OI fits files here
oversample=oversample,
interactive=False,
save_txt_only=False)
ff.fit_fringes(fitsimdir + fitsfn)
examine_residuals(ff)
np.set_printoptions(formatter={'float': lambda x: '{:+.2e}'.format(x)},
linewidth=80)
if verbose: print("analyze_data: fringepistons/rad", ff.nrm.fringepistons)
utils.default_printoptions()
return affine2d, psf_offset_find_rotation, ff.nrm.psf_offset, ff.nrm.fringepistons
def image2oi(mirfile, oitxtdir, oversample=3,
filt="F430M", bp=None, affine2d=None,
prec=4, debug=True, verbose=False):
"""
function to extract text observables from a fits data file
in mirage format (with expected keywords, and a second HDU that is a
datacube of slices (eg number of exposures) that come out of second
stage STScI pipeline processing).
input:
mirfile (str): full path(s) of input image fits file to be analyzed
oitxtdir (str) : directory where text observables are to be written,
a sub_dir_str of the object rootname is created for the
output txt oi observables, one per input data slice
oversample (int): pixel oversampling for implaneia fringe fitting
prec (int) optional precision for float numpy printout
bp, affine2d args passed ImPlaneIA
"""
np.set_printoptions(precision=prec)
# Create InstrumentData instantiation for NIRISS...
# convenient BANDPASS variables are defined here: use what you need.
#f debug:
# bp = np.array([(1.0, 4.3e-6),]) # for speedy development, exact simulations
niriss = InstrumentData.NIRISS(filt, bandpass=bp, affine2d=affine2d)
# * FringeFitter(..., save_txt_only=True, ...) switch off fits file writing
# * set interactive=False unless you are a beginner
ff_t = nrm_core.FringeFitter(niriss, datadir="nonsense", savedir=oitxtdir,
oversample=oversample, interactive=False)
# To use the parallelization option, set threads=n_threads in fit_fringes()
# fit_fringes calls InstrumentData.read_data() which assigns the sub_dir_string used
# to write out the per slice observables' text files under the object name (without
# ".fits") sub directory.
# fit_fringes works for fn or [fns]
ff_t.fit_fringes(mirfile)
print("oversample {:d} used in modelling the data".format(oversample))
print("observables text files in ", oitxtdir)
print("observables text files by image file root/* under ", oitxtdir)
###print("cal observables in subdir", csavedir)
if debug:
print("Current working directory is ", os.getcwd())
print("InstrumentData is file: ", InstrumentData.__file__)
def test_fringe_fitting(self):
image_file_name = self.simulated_image
print(('testing on %s' % image_file_name))
header = fits.getheader(image_file_name)
file_name = os.path.basename(image_file_name)
data_dir = os.path.dirname(image_file_name)
save_dir = data_dir + '/'
if 'Monochromatic' in self.filter_name:
nirissdata = InstrumentData.NIRISS(filt=self.filter)
nirissdata.wls = [self.monochromatic_wavelength_m]
print((nirissdata.wls))
nirissdata.pscale_mas = header['PIXELSCL'] * 1000
print(('measure_fringes: pixelscale %f' % header['PIXELSCL']))
nirissdata.pscale_rad = nirissdata.pscale_mas / 1000. * arcsec2rad
ff = nrm_core.FringeFitter(nirissdata, oversample=oversample, \
savedir=save_dir, datadir=data_dir, \
npix=n_image, interactive=False)
print(('FringeFitter oversampling: %d' % ff.oversample))
threads = 1
ff.fit_fringes([file_name])
CP_file = sorted(
glob.glob(
os.path.join(data_dir, '%s/%s*.txt' %
(file_name.split('.')[0], 'CPs_'))))
CP = Table.read(CP_file[0],
format='ascii.no_header',
names=({'closure_phase'}))
# perform the actual test
print("Closure phases standard deviation (radians)",
(np.array(CP['closure_phase'])).std())
print("Closure phases standard deviation (degrees)",
(np.array(CP['closure_phase'])).std() * 180.0 / np.pi)
self.assertTrue(
np.mean(np.array(CP['closure_phase'])) < 1e-7,
'Simulated closure phases of point source are non-zero'
) # Avoiding hex singularity in hextransformEE.py causes this sort of noise in exactly-XYaligned PSF 2018 AS
def test_fringe_fitting(self, verbose=0):
'''
Run fringe fitting algorithm on the point source image and test that closure phases are zero
'''
image_file_name = self.simulated_image
if verbose:
print('testing on %s' % image_file_name)
header = fits.getheader(image_file_name)
file_name = os.path.basename(image_file_name)
data_dir = os.path.dirname(image_file_name)
save_dir = data_dir + '/'
if 'Monochromatic' in self.filter_name:
nirissdata = InstrumentData.NIRISS(filt=self.filter)
nirissdata.wls = [self.monochromatic_wavelength_m]
print(nirissdata.wls)
nirissdata.pscale_mas = header['PIXELSCL'] * 1000
print('measure_fringes: pixelscale %f' % header['PIXELSCL'])
nirissdata.pscale_rad = nirissdata.pscale_mas / 1000. * arcsec2rad
ff = nrm_core.FringeFitter(nirissdata, oversample=oversample, \
savedir=save_dir, datadir=data_dir, \
npix=n_image, interactive=False, flip=flip)
print('FringeFitter oversampling: %d' % ff.oversample)
threads = 0
ff.fit_fringes([file_name], threads=threads)
CP_file = sorted(
glob.glob(
os.path.join(data_dir, '%s/%s*.txt' %
(file_name.split('.')[0], 'CPs_'))))
CP = Table.read(CP_file[0],
format='ascii.no_header',
names=({'closure_phase'}))
# perform the actual test
self.assertTrue(
np.mean(np.array(CP['closure_phase'])) < 1e-15,
'Simulated closure phases of point source are non-zero')
def analyze_data(fitsfn=None, fitsimdir=None, affine2d=None,
psf_offset_find_rotation = (0.0,0.0),
psf_offset_ff = None,
rotsearch_d=None,
set_pistons=None,
oversample=3,
mnem='',
firstfew=None,
verbose=False):
"""
returns: affine2d (measured or input),
psf_offset_find_rotation (input),
psf_offset_ff (input or found),
fringe pistons/r (found)
"""
if verbose: print("analyze_data: input", fitsimdir+fitsfn)
if verbose: print("analyze_data: oversample", oversample)
fobj = fits.open(fitsimdir+fitsfn)
if verbose: print(fobj[0].header['FILTER'])
niriss = InstrumentData.NIRISS(fobj[0].header['FILTER'],
usebp=False,
firstfew=firstfew,# read_data truncation to only read first few slices...
)
ff = nrm_core.FringeFitter(niriss,
datadir=fitsimdir,
savedir=fitsimdir,
oifdir='/Users/anand/data/oifdir/',
oversample=oversample,
oifprefix="ov{:d}_".format(oversample)+mnem,
interactive=False,
save_txt_only=False)
ff.fit_fringes(fitsimdir+fitsfn)
examine_residuals(ff)
np.set_printoptions(formatter={'float': lambda x: '{:+.2e}'.format(x)}, linewidth=80)
if verbose: print("analyze_data: fringepistons/rad", ff.nrm.fringepistons)
utils.default_printoptions()
return affine2d, psf_offset_find_rotation, ff.nrm.psf_offset, ff.nrm.fringepistons
def analyze_data(fitsfn=None,
fitsimdir=None,
affine2d=None,
psf_offset_find_rotation=(0.0, 0.0),
psf_offset_ff=None,
rotsearch_d=None,
set_pistons=None,
oversample=3):
"""
returns: affine2d (measured or input),
psf_offset_find_rotation (input),
psf_offset_ff (input or found),
fringe pistons/r (found)
"""
print("analyze_data: input file", fitsfn)
print("analyze_data: oversample", oversample)
data = fits.getdata(fitsfn)
fobj = fits.open(fitsfn)
print(fobj[0].header['FILTER'])
niriss = InstrumentData.NIRISS(fobj[0].header['FILTER'], bpexist=False)
ff_t = nrm_core.FringeFitter(niriss,
datadir=fitsimdir,
savedir=fitsimdir,
oversample=oversample,
oifprefix="ov{:d}_".format(oversample),
interactive=False)
ff_t.fit_fringes(fitsfn)
print(fitsfn)
sys.exit()
examine_residuals(ff_t)
np.set_printoptions(formatter={'float': lambda x: '{:+.2e}'.format(x)},
linewidth=80)
print("analyze_data: fringepistons/rad", ff_t.nrm.fringepistons)
utils.default_printoptions()
return affine2d, psf_offset_find_rotation, ff_t.nrm.psf_offset, ff_t.nrm.fringepistons
def raw_observables( fitsfn=None, fitsimdir=None, oitdir=None, oifdir=None, affine2d=None,
psf_offset_find_rotation=(0.0, 0.0), psf_offset_ff=None,
rotsearch_d=None, set_pistons=None, oversample=3, mnem="", firstfew=None,
usebp=False, verbose=False,):
"""
Reduce calibrated image data to raw fringe observables
returns: affine2d (measured or input),
psf_offset_find_rotation (input),
psf_offset_ff (input or found),
fringe pistons/r (found)
"""
if verbose: print("raw_observables: input", os.path.join(fitsimdir, fitsfn))
if verbose: print("raw_observables: oversample", oversample)
fobj = fits.open(os.path.join(fitsimdir, fitsfn))
if verbose: print(fobj[0].header["FILTER"])
print("InstrumentData file:", InstrumentData.__file__)
niriss = InstrumentData.NIRISS( fobj[0].header["FILTER"], usebp=usebp, # bpexist=False,
firstfew=firstfew, # read_data truncation to only read first few slices...
noise=1.0e-6,
)
ff = nrm_core.FringeFitter( niriss, oitdir=oitdir, # write OI text files here, and diagnostic images if desired
oifdir=oifdir, # write OI fits files here
weighted=True, oversample=oversample,
interactive=False, save_txt_only=False,)
ff.fit_fringes(os.path.join(fitsimdir, fitsfn))
examine_observables(ff)
np.set_printoptions( formatter={"float": lambda x: "{:+.2e}".format(x)}, linewidth=80)
if verbose: print("raw_observables: fringepistons/rad", *ff.nrm.fringepistons)
utils.default_printoptions()
fobj.close()
return affine2d, psf_offset_find_rotation, ff.nrm.psf_offset, ff.nrm.fringepistons
def test_find_pass_affine_scl(self):
header = fits.getheader(self.imagefn)
filename = os.path.basename(self.imagefn)
datadir = os.path.dirname(self.imagefn)
print('\n')
print(' >> >> >> >> testing self.imagefn %s' % self.imagefn)
print(' >> >> >> >> testing self.datadir %s' % self.datadir)
print(' >> >> >> >> testing self.savedir %s' % self.savedir)
fn = filename.replace('.fits', '')
print(' >> >> >> >> fn %s' % fn)
#mx, my, sx,sy, xo,yo, = (1.0,1.0, 0.0,0.0, 0.0,0.0)
# FIND SCALE FROM IMAGE DATA CREATED USING KNOWN ROTATION AND SCALE
# we use the known rotation for the affine2d
aff_best_scl = FAP.find_scale(
self.simulated_image,
self.affine, # contains how the test image data was created
scale_search,
header['PIXELSCL'] * arcsec2rad,
n_image,
self.monochromatic_wavelength_m,
oversample,
holeshape,
outdir=None)
# you have to re-initialize an InstrumentData.NIRISS object with the
# best pscale_mas & pscale_rad parameter now in order to use it in further data reduction
aff_best_scl.show(label="aff_best_scl")
if 'Monochromatic' in self.filter_name:
nirissdata = InstrumentData.NIRISS(filt=self.filter,
affine2d=aff_best_scl)
nirissdata.wls = [self.monochromatic_wavelength_m]
print((nirissdata.wls))
# naughty coding - adjust attributes to suit quick coding. Just for testing...
nirissdata.pscale_mas = header['PIXELSCL'] * 1000 # set
nirissdata.pscale_rad = nirissdata.pscale_mas / 1000. * arcsec2rad # propagate to convenience attribute
ff = nrm_core.FringeFitter(nirissdata,
oversample=oversample,
savedir=self.savedir,
datadir=datadir,
npix=n_image,
interactive=False,
hold_centering=True)
print(('FringeFitter oversampling: %d' % ff.oversample))
threads = 1
ff.fit_fringes([filename])
CP_file = sorted(
glob.glob(
os.path.join(datadir,
'%s/%s*.txt' % (filename.split('.')[0], 'CPs_'))))
print("CP_file: ", type(CP_file), len(CP_file))
CP = Table.read(CP_file[0],
format='ascii.no_header',
names=({'closure_phase'}))
# perform the actual test
self.assertTrue(
np.mean(np.array(CP['closure_phase'])) < 1e-7,
'Simulated closure phases of point source are non-zero'
) # Avoiding hex singularity in hextransformEE.py causes this sort of noise in exactly-XYaligned PSF 2018 AS
def test_find_pass_affine_rot(self):
header = fits.getheader(self.imagefn)
filename = os.path.basename(self.imagefn)
datadir = os.path.dirname(self.imagefn)
print('\n')
print(' >> >> >> >> testing self.imagefn %s' % self.imagefn)
print(' >> >> >> >> testing self.datadir %s' % self.datadir)
print(' >> >> >> >> testing self.savedir %s' % self.savedir)
fn = filename.replace('.fits', '')
print(' >> >> >> >> fn %s' % fn)
print("driver rotd_search:", rotd_search)
print("driver rotd_true:", rotd_true)
mx, my, sx, sy, xo, yo, = (1.0, 1.0, 0.0, 0.0, 0.0, 0.0)
psf_offset = (0.0, 0.0)
# FIND ROTATION FROM IMAGE DATA CREATED USING KNOWN ROTATION AND SCALE
aff_best_rot = FAP.find_rotation(self.simulated_image,
psf_offset,
rotd_search,
mx,
my,
sx,
sy,
xo,
yo,
header['PIXELSCL'] * arcsec2rad,
n_image,
self.monochromatic_wavelength_m,
oversample,
holeshape,
outdir=None)
print("rotd_measured:", aff_best_rot)
aff_best_rot.show(label="Measured ")
# you have to re-initialize an InstrumentData.NIRISS object with the
# best rotation affine parameter now in order to use it in further data reduction
if 'Monochromatic' in self.filter_name:
nirissdata = InstrumentData.NIRISS(filt=self.filter,
affine2d=aff_best_rot)
nirissdata.wls = [self.monochromatic_wavelength_m]
print((nirissdata.wls))
ff = nrm_core.FringeFitter(nirissdata,
oversample=oversample,
savedir=self.savedir,
datadir=datadir,
npix=n_image,
interactive=False,
hold_centering=True)
print(('FringeFitter oversampling: %d' % ff.oversample))
threads = 1
ff.fit_fringes([filename])
CP_file = sorted(
glob.glob(
os.path.join(datadir,
'%s/%s*.txt' % (filename.split('.')[0], 'CPs_'))))
print("CP_file: ", type(CP_file), len(CP_file))
CP = Table.read(CP_file[0],
format='ascii.no_header',
names=({'closure_phase'}))
# perform the actual test
self.assertTrue(
np.mean(np.array(CP['closure_phase'])) < 1e-7,
'Simulated closure phases of point source are non-zero'
) # Avoiding hex singularity in hextransformEE.py causes this sort of noise in exactly-XYaligned PSF 2018 AS
def test_offset_residuals_with_offset_measured():
"""
Simulate data with known offsets, analyze data using fringefitter.
"""
pixelscale_as = 0.0656
arcsec2rad = u.arcsec.to(u.rad)
PIXELSCALE_r = pixelscale_as * arcsec2rad
jw0 = NRM_Model(mask='jwst', holeshape="hex")
jw0.set_pixelscale(pixelscale_as * arcsec2rad)
jw0.simulate(fov=35,
bandpass=bandpass,
over=oversample,
psf_offset=(0.0, 0.0))
fits.PrimaryHDU(data=jw0.psf).writeto(fitsimdir + "no_offset_data.fits",
overwrite=True)
jw = NRM_Model(mask='jwst', holeshape="hex")
jw.set_pixelscale(pixelscale_as * arcsec2rad)
jw.simulate(fov=35,
bandpass=bandpass,
over=oversample,
psf_offset=psf_offsets)
fits.PrimaryHDU(data=jw.psf).writeto(fitsimdir + "offset_data.fits",
overwrite=True)
fits.PrimaryHDU(data=(jw.psf - jw0.psf) / jw0.psf.max()).writeto(
fitsimdir + "diff_from_center.fits", overwrite=True)
amisim2mirage(fitsimdir, ("offset_data", ), mirexample, filt)
niriss = InstrumentData.NIRISS(filt, bandpass=bandpass)
ff_t = nrm_core.FringeFitter(niriss,
datadir=fitsimdir,
savedir=fitsimdir,
oversample=oversample,
interactive=False)
print(test_tar)
ff_t.fit_fringes(test_tar)
jw_m = NRM_Model(mask='jwst', holeshape="hex")
jw_m.set_pixelscale(pixelscale_as * arcsec2rad)
#Look at measured offsets in the screen output and feed them to simulate to compare with simulated data created with input offsets.
#nrm.bestcenter (0.4799802988666451, 6.984734412937637e-05) nrm.xpos 0.4799802988666451 nrm.ypos 6.984734412937637e-05
jw_m.simulate(fov=35,
bandpass=bandpass,
over=oversample,
psf_offset=(ff_t.nrm.xpos, ff_t.nrm.ypos))
fits.PrimaryHDU(data=jw_m.psf).writeto(fitsimdir + "m_offset_data.fits",
overwrite=True)
fits.PrimaryHDU(data=(jw.psf - jw_m.psf) / jw0.psf.max()).writeto(
fitsimdir + "m_diff_of_offsets.fits", overwrite=True)
print("Residual:")
#print(ff_t.nrm.residual)
print("Residual/psfpeak array center:", ff_t.nrm.reference.shape)
pos = np.get_printoptions()
np.set_printoptions(precision=3,
formatter={'float': lambda x: '{:+.3e}'.format(x)},
linewidth=80)
print((ff_t.nrm.residual / jw.psf.max())[36:-36, 36:-36])
np.set_printoptions(pos)
fits.PrimaryHDU(data=ff_t.nrm.residual).writeto(fitsimdir+\
"residual_offsets_with_ff.fits",overwrite=True)
bp3 = np.array([(0.1, 4.2e-6), (0.8, 4.3e-6),
(0.1, 4.4e-6)]) # for speedy development
bpmono = np.array([
(1.0, 4.3e-6),
]) # for speedy development
niriss = InstrumentData.NIRISS(filt, bandpass=bpmono)
# ### Next: Extract fringe observables using image plane fringe-fitting
# * Need to pass the InstrumentData object, some keywords.
# * Observables are (over)written to a new savedir/input_datafile_root (eg cr or tr here)
# * Initialize FringeFitter with save_txt_only=True to switch off diagnostic fits file writing
# *files written out to these directories.
ff_t = nrm_core.FringeFitter(niriss,
datadir=datadir,
savedir=tsavedir,
oversample=oversample,
interactive=False)
ff_c = nrm_core.FringeFitter(niriss,
datadir=datadir,
savedir=csavedir,
oversample=oversample,
interactive=False)
# set interactive to False unless you don't know what you are doing
# This can take a little while -- there is a parallelization option, set threads=n_threads
# output of this is long -- may also want to do this scripted instead of in notebook,
# leaving off the output in this example.
ff_t.fit_fringes(test_tar)
ff_c.fit_fringes(test_cal)
def verify_pistons(arg):
"""
Create simulated data with pistons,
1. analyze the data by calling fit_image
Do not use fringefitter since the data is perfecrly centered (the if loop).
Check if input and output pistons match.
2. analyze the data by calling fit_image via fringefitter
Fringefitter finds the bestcenter and makes model with bestcenter.
Since the data is perfecrly centered fringefitter should not affect output pistons.
Check if input and output pistons match.
"""
jw = NRM_Model(mask='jwst', holeshape="hex")
pixelscale_as = 0.0656
arcsec2rad = u.arcsec.to(u.rad)
jw.set_pixelscale(pixelscale_as * arcsec2rad)
np.random.seed(100)
#lambda/14 ~ 80% strehl ratio
phi = np.random.normal(0, 1.0, 7) / 14.0 # waves
print("phi", phi, "varphi", phi.var(), "waves")
phi = phi - phi.mean()
print("phi_nb stdev/w", phi.std())
print("phi_nb stdev/r", phi.std() * 2 * np.pi)
print("phi_nb mean/r", phi.mean() * 2 * np.pi)
pistons = phi * 4.3e-6 #OR
print("/=====input pistons/m=======/\n", pistons)
print("/=====input pistons/r=======/\n", pistons * (2 * np.pi) / 4.3e-6)
jw.set_pistons(pistons)
jw.simulate(fov=81, bandpass=4.3e-6, over=oversample)
fits.PrimaryHDU(data=jw.psf).writeto(
"implaneia_tests/perfect_wpistons.fits", overwrite=True)
if arg == ("no_fringefitter"):
jw.make_model(fov=81, bandpass=4.3e-6, over=oversample)
jw.fit_image(jw.psf, modelin=jw.model)
pos = np.get_printoptions()
np.set_printoptions(precision=4,
formatter={'float': lambda x: '{:+.4e}'.format(x)},
linewidth=80)
print("Residual/psfpeak array center:", jw.psf.shape)
print((jw.residual / jw.psf.max())[36:-36, 36:-36])
np.set_printoptions(pos)
fits.PrimaryHDU(data=jw.residual).writeto(
"residual_pistons_no_ff.fits", overwrite=True)
#return jw
#print("output pistons/r",jw.fringepistons)
#print("output pistons/w",jw.fringepistons/(2*np.pi))
#print("output pistons/m",jw.fringepistons*4.3e-6/(2*np.pi))
#print("input pistons/m ",jw.phi)
elif arg == ("use_fringefitter"):
fits.PrimaryHDU(data=jw.psf).writeto(datadir +
"/perfect_wpistons.fits",
overwrite=True)
amisim2mirage(datadir, ("perfect_wpistons", ), mirexample, filt)
niriss = InstrumentData.NIRISS(filt)
ff_t = nrm_core.FringeFitter(niriss,
datadir=datadir,
savedir=datadir,
oversample=oversample,
interactive=False)
print(test_tar)
ff_t.fit_fringes(test_tar)
print("Residual:")
#print(ff_t.nrm.residual)
print("Residual/psfpeak array center:", ff_t.nrm.reference.shape)
pos = np.get_printoptions()
np.set_printoptions(precision=3,
formatter={'float': lambda x: '{:+.3e}'.format(x)},
linewidth=80)
print((ff_t.nrm.residual / jw.psf.max())[36:-36, 36:-36])
np.set_printoptions(pos)
fits.PrimaryHDU(data=ff_t.nrm.residual).writeto(datadir+\
"/residual_pistons_with_ff.fits",overwrite=True)
utils.compare_pistons(jw.phi * 2 * np.pi / 4.3e-6,
ff_t.nrm.fringepistons,
str="ff_t")