def simulate_data(affine2d=None):
print(" simulate_data: ")
jw = NRM_Model(mask='jwst', holeshape="hex")
jw.simulate(fov=fov,
bandpass=bandpass,
over=oversample,
psf_offset=psf_offset_det)
fits.PrimaryHDU(data=jw.psf).writeto(fitsimdir + "all_effects_data.fits",
overwrite=True)
#**********Convert simulated data to mirage format.*******
utils.amisim2mirage(fitsimdir, ("all_effects_data", ), mirexample, filt)
def simulate_data(affine2d=None, psf_offset_det=None, pistons_w=None):
np.set_printoptions(precision=4, formatter={'float': lambda x: '{:+.1e}'.format(x)}, linewidth=80)
default_printoptions()
#***********ADD EFFECTS TO SIMULATE*******************
jw = NRM_Model(mask='jwst', holeshape="hex", affine2d=affine2d)
jw.set_pixelscale(pixelscale_as*arcsec2rad)
jw.simulate(fov=fov, bandpass=bandpass, over=oversample)
fits.PrimaryHDU(data=jw.psf).writeto(fitsimdir+"all_effects_data.fits",overwrite=True)
#**********Convert simulated data to mirage format.*******
utils.amisim2mirage(fitsimdir, ("all_effects_data",), mirexample, filt)
def simulate_data(affine2d=None, psf_offset_det=None, pistons_w=None):
print(" simulate_data: ", affine2d.name)
#************ADD PISTONS TO PERFECT DATA******************
pistons_w = pistons_w - pistons_w.mean()
pistons_m = pistons_w * lamc
pistons_r = pistons_w * 2.0 * np.pi
utils.show_pistons_w(pistons_w, str="simulate_data: input pistons")
np.set_printoptions(precision=4,
formatter={'float': lambda x: '{:+.1e}'.format(x)},
linewidth=80)
print(" simulate_data: pistons_um", pistons_m / 1e-6)
print(" simulate_data: pistons_r", pistons_r)
print(" simulate_data: pistons_w stdev/w", round(pistons_w.std(), 4))
print(" simulate_data: pistons_w stdev/r",
round(pistons_w.std() * 2 * np.pi, 4))
print(" simulate_data: pistons_w mean/r",
round(pistons_w.mean() * 2 * np.pi, 4))
default_printoptions()
#***********ADD EFFECTS TO SIMULATE*******************
jw = NRM_Model(mask='jwst', holeshape="hex", affine2d=affine2d)
jw.set_pixelscale(pixelscale_as * arcsec2rad)
jw.set_pistons(pistons_m)
print(" simulate: ", psf_offset_det, type(psf_offset_det))
jw.simulate(fov=fov,
bandpass=bandpass,
over=oversample,
psf_offset=psf_offset_det)
fits.PrimaryHDU(data=jw.psf).writeto(fitsimdir + "all_effects_data.fits",
overwrite=True)
#**********Convert simulated data to mirage format.*******
utils.amisim2mirage(fitsimdir, ("all_effects_data", ), mirexample, filt)
def rotsim_mir(rotdegs=0.0, ov=1):
""" This function sets up directory and file names, writes a 2D file,
and then mirage-izes it to disk.
Data is written to a hardcoded ddata directory at the momet:
~/data/niriss_verification/*"
A subdirectory labelled with oversampling is created for implaneia analysis output.
rotdegs: pupil rotation in degrees
"""
# Set up directories for :
# input fits miragelike files
# output optical Interferometry directory for implaneia text files & fits files
# where to find the mirage example to borrow its header
home = os.path.expanduser('~')
import getpass
username = getpass.getuser()
# Mirage header needed from:
mirext = "_mir"
if (username=="anand"):
mirexample = home + \
"/gitsrc/ImPlaneIA/example_data/example_niriss/"+\
"jw00793001001_01101_00001_nis_cal.fits"
else:
mirexample = home + \
"/ImplaneIA/notebooks/simulatedpsfs/" + \
"jw00793001001_01101_00001_nis_cal.fits"
# create simdata and output observables directories data
#
ov = 1 # oversampling for simulation of psf
fitsimdir = home+"/data/implaneia/niriss_verification/"
if not os.path.exists(fitsimdir):
os.makedirs(fitsimdir)
print("Created image simulation data directory:\n\t", fitsimdir)
oidir = fitsimdir + "ov{:d}".format(ov)
if not os.path.exists(oidir):
os.mkdir(oidir)
print("Created oi text output file directory:\n\t", oidir)
else:
print("Using existing oi text output file directory:\n\t", oidir)
if not os.path.exists(fitsimdir+'/rotdir/'):
os.mkdir(fitsimdir+'/rotdir/')
# Create psf with implaneia
#
simfn = create_data(fitsimdir, rotdegs, ov)
# get back miragefile.fits string (not full path)
mirfn = utils.amisim2mirage(fitsimdir, simfn.replace(".fits",""), mirexample, FILT)
if mirfn[0] == '/': mirfn=mirfn[1:]
print("mirage-like file", mirfn, 'written in', fitsimdir)
simdata = fits.getdata(fitsimdir+mirfn, 1)[0,:,:]
print("simdata.shape", simdata.shape)
# in real data:
# psfoffset = locatecenter(simdata, filt)
psf_offset = (0.5,0.5)
# Extract observables with implaneia
#
from nrm_analysis import find_affine2d_parameters as FAP
mx, my, sx,sy, xo,yo, = (1.0,1.0, 0.0,0.0, 0.0,0.0)
rotsearch_d = (8.0, 9.0, 10.0, 11.0, 12.0)
wave = np.array([(1.0, 4.3e-6),]) # SI - we won't know from the data what lam_c - comes from outside?
# real-life - use apprpriate bandpass array
aff_rot_measured = FAP.find_rotation(simdata, psf_offset,
rotsearch_d, mx, my, sx,sy, xo,yo,
PIXELSCALE_r, 80, wave, ov, 'hex', outdir=fitsimdir+"/rotdir/")
image2oi(fitsimdir+mirfn, oidir, oversample=ov, filt=FILT, bp=MONOF430M, prec=4, affine2d=aff_rot_measured)
# Helpful printout after implaneia bulk output
#
print(InstrumentData.__file__)
aff_rot_measured.show()
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)
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")
datafiles_byfilter[filt] = [
't_ABDor_{:s}__myPSF_{:s}_Obs1_00'.format(filt, filt),
't_ABDor_{:s}__myPSF_{:s}_Obs2_00'.format(filt, filt),
't_HD37093_{:s}__myPSF_{:s}_Obs4_00'.format(filt, filt),
't_HD36805_{:s}__myPSF_{:s}_Obs6_00'.format(filt, filt),
] # 12 oifits files
# These file names require the addition of Obs_nn to oifn so
# we don't overwrite first since there are two ABDor observations
# With MAST files we might not need this mnemonic
print(len(datafiles_byfilter[filt]), 'datafiles', len(filters), 'filters')
# convert to _mir files, add target name & prop from amisim filename t_targetname_...
for filt in filters:
fitsimdir = datasuperdir + filt + '/'
utils.amisim2mirage(fitsimdir, datafiles_byfilter[filt], mirexample,
filt)
# following target name loop only needs to occur once... but doesn't hurt
add_targetname = True
if add_targetname: # put in target name for oif to pick up, use in prefix
for fitsfile in datafiles_byfilter[filt]:
targname = fitsfile.split('_')[1].upper()
mirfitsfn = fitsfile + '_mir.fits'
fobj = fits.open(fitsimdir + mirfitsfn)
fobj[0].header['TARGNAME'] = (targname,
'parsed from file name')
fobj[0].header['TARGPROP'] = (targname,
'parsed from file name')
fobj.writeto(fitsimdir + mirfitsfn, overwrite=True)
print("mirage file targname", targname)
count = 0