def setUp(self): self.holeshape = "hex" # directory containing the test data data_dir = os.path.join(os.path.dirname(__file__), 'test_data/find_affine2d_parameters') self.data_dir = data_dir print(data_dir) if not os.path.exists(data_dir): os.makedirs(data_dir) pixel = 0.0656 * u.arcsec.to(u.rad) npix = 87 wave = np.array([ (1.0, 4.3e-6), ]) # m over = 3 holeshape = 'hex' rotd_true = 9.25 rotdegs = (8.0, 9.0, 10.0, 11.0, 12.0 ) # search in this range of rotation (degrees) # store the real affine to be uased to create test data self.affine = utils.Affine2d( rotradccw=np.pi * utils.avoidhexsingularity(rotd_true) / 180.0, name="{0:.4}".format(float(rotd_true))) self.affine.show(label="Creating affine2d for PSF data") # create image data to find its rotation, as a sample test... imagefn = data_dir + "/imagedata.fits" jw = NRM_Model(mask='jwst', holeshape="hex", affine2d=self.affine) jw.set_pixelscale(pixel) jw.simulate(fov=npix, bandpass=wave, over=over) fits.writeto(imagefn, jw.psf, overwrite=True) imagedata = jw.psf.copy() del jw fits.getdata(imagefn) psf_offset = (0.0, 0.0) print("driver:", rotdegs) mx, my, sx, sy, xo, yo, = (1.0, 1.0, 0.0, 0.0, 0.0, 0.0) aff_best_rot = FAP.find_rotation(imagedata, psf_offset, rotdegs, mx, my, sx, sy, xo, yo, pixel, npix, wave, over, holeshape, outdir=data_dir) print(aff_best_rot) self.aff_best_rot = aff_best_rot
def test_offset_residuals(): """ Use same affine object for simulation and analysis """ pixelscale_as = 0.0656 arcsec2rad = u.arcsec.to(u.rad) #psf_offsets = ((0,0), (1.0,0), ) #psf_offsets = ((0,0), (1.0,0), (0, 1.0), (1.0,1.0)) bandpass = np.array([ (1.0, 4.3e-6), ]) # Loop over psf_offsets 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.writeto(fitsimdir + "offset_data.fits", jw.psf, overwrite=True) jw.make_model(fov=35, bandpass=bandpass, over=oversample, psf_offset=psf_offsets) jw.fit_image(jw.psf, modelin=jw.model) fits.writeto(fitsimdir + "residual_offset.fits", jw.residual, overwrite=True)
def create_data(imdir, rot, ov): """ imdir: directory for simulated fits image data rot: pupil rotation in degrees ov: oversample for simulation Writes sim data to fitsimdir """ npix = 81 wave = 4.3e-6 # SI fnfmt = '/psf_nrm_{2:.1f}_{0}_{1}_rot{3:.3f}d.fits' # expects strings of %(npix, holeshape, wave/um, rot_d) rot = utils.avoidhexsingularity(rot) # in utils affine_rot = utils.Affine2d(rotradccw=np.pi*rot/180.0, name="rot{0:.3f}d".format(rot)) # in utils jw = NRM_Model(mask='jwst', holeshape='hex', affine2d=affine_rot) jw.set_pixelscale(PIXELSCALE_r) jw.simulate(fov=81, bandpass=MONOF430M, over=ov) psffn = fnfmt.format(npix, 'hex', wave/um, rot) fits.writeto(imdir+psffn, jw.psf, overwrite=True) header = fits.getheader(imdir+psffn) header = utils.affinepars2header(header, affine_rot) fits.update(imdir+psffn, jw.psf, header=header) del jw return psffn # filename only, not full path
def find_rotation( imagedata, rotdegs, mx, my, sx, sy, xo, yo, # for Affine2d pixel, npix, bandpass, over, holeshape, outdir=None): # for nrm_model """ AS AZG 2018 08 Ann Arbor Develop the rotation loop first """ vprint("Before Loop: ", rotdegs) #Extend this name to include multi-paramater searches? psffmt = 'psf_nrm_{0:d}_{1:s}_{2:.3f}um_r{3:.3f}deg.fits' # expect (npix, holeshape, bandpass/um, scl) if hasattr(rotdegs, '__iter__') is False: rotdegs = (rotdegs, ) affine2d_list = create_afflist_rot(rotdegs, mx, my, sx, sy, xo, yo) crosscorr_rots = [] for (rot, aff) in zip(rotdegs, affine2d_list): vprint(aff.name + "...") jw = NRM_Model(mask='jwst', holeshape=holeshape, over=over, affine2d=aff) jw.set_pixelscale(pixel) jw.simulate(fov=npix, bandpass=bandpass, over=over) psffn = psffmt.format(npix, holeshape, bandpass / um, rot) if outdir: fits.PrimaryHDU(data=jw.psf).writeto(outdir + "/" + psffn, overwrite=True) fits.writeto(psffn, jw.psf, overwrite=True) header = fits.getheader(psffn) utils.affinepars2header(header, aff) fits.update(psffn, jw.psf, header=header) crosscorr_rots.append(utils.rcrosscorrelate(imagedata, jw.psf).max()) del jw vprint("Debug: ", crosscorr_rots, rotdegs) rot_measured_d, max_cor = utils.findpeak_1d(crosscorr_rots, rotdegs) vprint("Rotation measured: max correlation {1:.3e}", rot_measured_d, max_cor) # return convenient affine2d return utils.Affine2d(rotradccw=np.pi * rot_measured_d / 180.0, name="{0:.4f}".format(rot_measured_d))
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)
class Affine2dMakeModelRotTestCase(unittest.TestCase): def setUp(self): allholes = ('b4', 'c2', 'b5', 'b2', 'c1', 'b6', 'c6') b4, c2, b5, b2, c1, b6, c6 = allholes self.hc = (b2, b6, b5) # holechoices self.hstr = holes2string(self.hc) self.holeshape = "hex" # directory containing the test data data_dir = os.path.join(os.path.dirname(__file__), 'test_data/affine2d_makemodel_rot') self.data_dir = data_dir print(data_dir) if not os.path.exists(data_dir): os.makedirs(data_dir) # expects strings of % (self.npix, self.holeshape, self.wave/um, rot, self.hstr) self.fnfmt = data_dir + '/psf_nrm_{2:.1f}_{0}_{1}_{3:.0f}_{4:s}.fits' self.fmt = " ({0:+.3f}, {1:+.3f}) -> ({2:+.3f}, {3:+.3f})" self.pixel = 0.0656 self.npix = 87 self.wave = 4.3e-6 # m self.over = 11 mx, my = 1.0, 1.0 sx, sy = 0.0, 0.0 xo, yo = 0.0, 0.0 affine_ideal = Affine2d(mx=mx, my=my, sx=sx, sy=sy, xo=xo, yo=yo, name="Ideal") rots = (0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95) rots = ( 0.000, 10.000, ) for rot in rots: rot = avoidhexsingularity(rot) # in utils affine_rot = Affine2d(rotradccw=np.pi * rot / 180.0, name="{0:.0f}".format(rot)) # in utils aff = affine_rot # holeshape is hex or circ g7s6 jwst # because model_array requires # a primary beam for one slice of the model self.jw = NRM_Model( mask='jwst', holeshape=self.holeshape, #chooseholes=self.hc, affine2d=aff) self.jw.set_pixelscale(self.pixel * arcsec2rad) self.jw.simulate(fov=self.npix, bandpass=self.wave, over=self.over) # write psf psffn = self.fnfmt.format(self.npix, self.holeshape, self.wave / um, rot, self.hstr) fits.writeto(psffn, self.jw.psf, overwrite=True) header = fits.getheader(psffn) header = affinepars2header(header, aff) fits.update(psffn, self.jw.psf, header=header) print("test: psf shape", self.jw.psf.shape) modelslices = self.jw.make_model(fov=self.npix, bandpass=self.wave, over=self.over) print("test: modelslices type", type(modelslices)) print("test: modelslices shape", modelslices.shape) modelfn = psffn.replace("psf_nrm", "model") # write model model_for_fitsfile = np.zeros( (modelslices.shape[2], modelslices.shape[0], modelslices.shape[1])) for sl in range(modelslices.shape[2]): model_for_fitsfile[sl, :, :] = modelslices[:, :, sl] print("test: model_for_fitsfile type", type(model_for_fitsfile)) print("test: model_for_fitsfile shape", model_for_fitsfile.shape) fits.writeto(modelfn, model_for_fitsfile[6, :, :], overwrite=True) header = fits.getheader(modelfn) header = affinepars2header(header, aff) fits.update(modelfn, model_for_fitsfile[6, :, :], header=header) del self.jw del aff del affine_rot def test_psf(self): """ sanity check and code development tool than a routine test. """ self.assertTrue(0.0 < 1e-15, 'error: test_affine2d failed')
def setUp(self): # setup parameters for simulation verbose = 1 overwrite = 1 monochromatic_wavelength_m = np.array([ (1.0, 4.3e-6), ]) mask = 'MASK_NRM' filter = 'F430M' pixel = 0.0656 # arcsec filter_name = 'Monochromatic ' + np.str(monochromatic_wavelength_m) self.filter = filter self.filter_name = filter_name self.monochromatic_wavelength_m = monochromatic_wavelength_m # directory containing the test data datadir = os.path.join(os.path.dirname(__file__), 'test_data/find_pass_affine') if not os.path.exists(datadir): os.makedirs(datadir) self.datadir = datadir # file containing the test data imagefn = datadir + "/simulated_image.fits" # use millidegrees and integers imagefn = imagefn.replace( ".fits", "_truerotmd{0:+05d}.fits".format(int(1000.0 * float(rotd_true)))) self.imagefn = imagefn # savedir for reduced quantities self.savedir = imagefn.replace( ".fits", "_truerotmd{0:+05d}.fits".format(int(1000.0 * float(rotd_true)))) self.savedir = self.datadir + '/' print('\n') print(' >> >> >> >> set-up self.imagefn %s' % self.imagefn) print(' >> >> >> >> set-up self.datadir %s' % self.datadir) print(' >> >> >> >> set-up self.savedir %s' % self.savedir) # Create test data on disk print("avoidhexsingularity: ", utils.avoidhexsingularity(rotd_true)) affine = utils.Affine2d(rotradccw=np.pi * utils.avoidhexsingularity(rotd_true) / 180.0, name="{0:.3}".format(float(rotd_true))) affine.show(label="Creating PSF data with Affine2d") # from nrm_analysis.fringefitting.LG_Model import NRM_Model jw = NRM_Model(mask='jwst', holeshape="hex", affine2d=affine) jw.set_pixelscale(pixel * arcsec2rad) jw.simulate(fov=n_image, bandpass=monochromatic_wavelength_m, over=oversample) # PSF without oversampling fits.writeto(imagefn, jw.psf, overwrite=True) header = fits.getheader(imagefn) header['PIXELSCL'] = (pixel, "arcseconds") header['FILTER'] = filter_name header['PUPIL'] = mask header = utils.affinepars2header(header, affine) fits.update(imagefn, jw.psf, header=header) self.simulated_image = jw.psf.copy() self.affine = affine # Affine2d parameters used to create test simulated_image ("true" value) del jw del affine
def psf(filt, fbp, cw, ew, beta, data_dir, oversample = 11, n_image = 81, pixelscale_as=0.0656, f2f = 0.82, saveover=False): arcsec2rad = u.arcsec.to(u.rad) WGHT = fbp[:,0] WAVE = fbp[:,1] # setup parameters for simulation verbose = 1 overwrite = 1 mask = 'MASK_NRM' # directory containing the test data if not os.path.exists(data_dir): os.makedirs(data_dir) name_seed = 'PSF_%s_%s_x%d_%.2f'%(mask,filt,oversample,f2f) # original # only det sampling needed here... name_seed = '%s_%d_%s_det.fits'%(filt, n_image, "A0V") # for ami_sim input photometry in NIRISSami_apt_calcPSF name_seed = '%s_%d_%s_x%d.fits'%(filt, n_image, "flat", oversample) # for ami_sim PSF to give to driver_scene name_seed_det = '%s_%d_%s_det.fits'%(filt, n_image, "flat") # for ami_sim PSF for examining by eye print(name_seed) psf_image = os.path.join(data_dir,name_seed) psf_image_without_oversampling = os.path.join(data_dir, name_seed_det) from nrm_analysis.fringefitting.LG_Model import NRM_Model jw = NRM_Model(mask='jwst',holeshape="hex") jw.set_pixelscale(pixelscale_as*arcsec2rad) jw.simulate(fov=n_image, bandpass=fbp, over=oversample) print("simulateG7S6psf: simulation oversampling is", oversample) (year, month, day, hour, minute, second, weekday, DOY, DST) = time.gmtime() # oversampled psf is used as the fine psf to create jitter and dither errors. # ami_sim driver scene expects ODD numbers of pixels to a side. # We oversize to 81 x 81 pixels here. # When adding mirage headers to ami_sim 'data' we should trim to 80x80. # oversampled psf is used as the fine psf to create jitter and dither errors. if saveover: # oversampled psf is used as the fine psf to createjitter and dither errors. # PSF on oversampled pixels psf_over_n = filt_psftot[filt] * jw.psf_over/jw.psf_over.sum() # wp psf total ~15% fits.writeto(psf_image, psf_over_n, overwrite=True) header = fits.getheader(psf_image) header['PIXELSCL'] = pixelscale_as/oversample, "arcsec per pixel" header['FILTER'] = filt header['PUPIL'] = mask header["OVER"] = ( oversample, "oversample") header["SPTYPE"] = "FLAT", "source spectral type unspecified" header["NWAVES"] = fbp.shape[0] header["WAVELEN"] = cw, "Weighted mean wavelength in meters " header["FILT_EW"] = ew, "Filter equiv width" header["FILT_BP"] = beta, "Fractional bandpass = WL/EqW" for i in range(len(WAVE)): header["WAVE%d"%i] = WAVE[i], "Wavelength %d"%i header["WGHT%d"%i] = WGHT[i], "Wavelength weight %d"%i header["FT"] = ( "analytical", "hexee * fringes") header['NRM_GEOM'] = 'G7S6', 'Beaulieu, PGT, AS, active ctrs' header['F2F'] = jw.d, "flat2flat hole size m" header['NRM_X_A1'] = jw.ctrs[0,0], 'X coordinate (m) of NRM sub-aperture 0' header['NRM_Y_A1'] = jw.ctrs[0,1], 'Y coordinate (m) of NRM sub-aperture 0' header['NRM_X_A2'] = jw.ctrs[1,0], 'X coordinate (m) of NRM sub-aperture 1' header['NRM_Y_A2'] = jw.ctrs[1,1], 'Y coordinate (m) of NRM sub-aperture 1' header['NRM_X_A3'] = jw.ctrs[2,0], 'X coordinate (m) of NRM sub-aperture 2' header['NRM_Y_A3'] = jw.ctrs[2,1], 'Y coordinate (m) of NRM sub-aperture 2' header['NRM_X_A4'] = jw.ctrs[3,0], 'X coordinate (m) of NRM sub-aperture 3' header['NRM_Y_A4'] = jw.ctrs[3,1], 'Y coordinate (m) of NRM sub-aperture 3' header['NRM_X_A5'] = jw.ctrs[4,0], 'X coordinate (m) of NRM sub-aperture 4' header['NRM_Y_A5'] = jw.ctrs[4,1], 'Y coordinate (m) of NRM sub-aperture 4' header['NRM_X_A6'] = jw.ctrs[5,0], 'X coordinate (m) of NRM sub-aperture 5' header['NRM_Y_A6'] = jw.ctrs[5,1], 'Y coordinate (m) of NRM sub-aperture 5' header['NRM_X_A7'] = jw.ctrs[6,0], 'X coordinate (m) of NRM sub-aperture 6' header['NRM_Y_A7'] = jw.ctrs[6,1], 'Y coordinate (m) of NRM sub-aperture 6' header['NORMALIZ'] = 'first', 'PM psf.sum=1, this.sum = mask throughput' header['PSFTOT'] = filt_psftot[filt], "sum of webbpsf sim done at 11x over" header['PSFPEAK'] = psf_over_n.max() header["SRC"] = ( "simulateG7S6psf.py", "ImplaneIA/notebooks/") header['AUTHOR'] = '%s@%s' % (os.getenv('USER'), os.getenv('HOST')), 'username@host for calculation' header['DATE'] = '%4d-%02d-%02dT%02d:%02d:%02d' % (year, month, day, hour, minute, second), 'Date of calculation' header['F2F'] = (0.82, "flat2flat hole size m") fits.update(psf_image, psf_over_n, header=header) # PSF on detector pixels psf_det_n = filt_psftot[filt] * jw.psf/jw.psf.sum() fits.writeto(psf_image_without_oversampling, psf_det_n, overwrite=True) header = fits.getheader(psf_image_without_oversampling) header['PIXELSCL'] = pixelscale_as, "arcsec per pixel" header['FILTER'] = filt header['PUPIL'] = mask header["OVER"] = ( oversample, "oversample pre-rebin") header["SPTYPE"] = "FLAT", "source spectral type" header["NWAVES"] = fbp.shape[0] header["WAVELEN"] = cw, "Weighted mean wavelength in meters " header["FILT_EW"] = ew, "Filter equiv width" header["FILT_BP"] = beta, "Fractional bandpass = WL/EqW" for i in range(len(WAVE)): header["WAVE%d"%i] = WAVE[i], "Wavelength %d"%i header["WGHT%d"%i] = WGHT[i], "Wavelength weight %d"%i header["FT"] = ( "analytical", "hexee * fringes") header['NRM_GEOM'] = 'G7S6', 'Beaulieu, PGT, AS active ctrs' header['F2F'] = jw.d, "flat2flat hole size m" header['NRM_X_A1'] = jw.ctrs[0,0], 'X coordinate (m) of NRM sub-aperture 0' header['NRM_Y_A1'] = jw.ctrs[0,1], 'Y coordinate (m) of NRM sub-aperture 0' header['NRM_X_A2'] = jw.ctrs[1,0], 'X coordinate (m) of NRM sub-aperture 1' header['NRM_Y_A2'] = jw.ctrs[1,1], 'Y coordinate (m) of NRM sub-aperture 1' header['NRM_X_A3'] = jw.ctrs[2,0], 'X coordinate (m) of NRM sub-aperture 2' header['NRM_Y_A3'] = jw.ctrs[2,1], 'Y coordinate (m) of NRM sub-aperture 2' header['NRM_X_A4'] = jw.ctrs[3,0], 'X coordinate (m) of NRM sub-aperture 3' header['NRM_Y_A4'] = jw.ctrs[3,1], 'Y coordinate (m) of NRM sub-aperture 3' header['NRM_X_A5'] = jw.ctrs[4,0], 'X coordinate (m) of NRM sub-aperture 4' header['NRM_Y_A5'] = jw.ctrs[4,1], 'Y coordinate (m) of NRM sub-aperture 4' header['NRM_X_A6'] = jw.ctrs[5,0], 'X coordinate (m) of NRM sub-aperture 5' header['NRM_Y_A6'] = jw.ctrs[5,1], 'Y coordinate (m) of NRM sub-aperture 5' header['NRM_X_A7'] = jw.ctrs[6,0], 'X coordinate (m) of NRM sub-aperture 6' header['NRM_Y_A7'] = jw.ctrs[6,1], 'Y coordinate (m) of NRM sub-aperture 6' header['NORMALIZ'] = 'first', 'PM psf.sum=1, this.sum = mask throughput' header['PSFTOT'] = psf_det_n.sum() header['PSFPEAK'] = psf_det_n.max() header['CPF'] = psf_det_n.max() / psf_det_n.sum(), 'Central pixel fraction' header["SRC"] = ( "simulateG7S6psf_for_ami_sim.py", "ImplaneIA/notebooks/") header['AUTHOR'] = '%s@%s' % (os.getenv('USER'), os.getenv('HOST')), 'username@host for calculation' header['DATE'] = '%4d-%02d-%02dT%02d:%02d:%02d' % (year, month, day, hour, minute, second), 'Date of calculation' fits.update(psf_image_without_oversampling, psf_det_n, header=header)
def psf(filt, fbp, cw, ew, beta, data_dir, oversample = 11, n_image = 81, pixelscale_as=0.0656, f2f = 0.82, saveover = True): arcsec2rad = u.arcsec.to(u.rad) WGHT = fbp[:,0] WAVE = fbp[:,1] # setup parameters for simulation verbose = 1 overwrite = 1 mask = 'MASK_NRM' # directory containing the test data if not os.path.exists(data_dir): os.makedirs(data_dir) name_seed = 'PSF_%s_%s_x%d_%.2f'%(mask,filt,oversample,f2f) psf_image_name = name_seed + '_ref.fits' psf_image = os.path.join(data_dir,psf_image_name) psf_image_without_oversampling = os.path.join(data_dir,psf_image_name.replace('.fits','_det.fits')) if (not os.path.isfile(psf_image_without_oversampling)) | (overwrite): from nrm_analysis.fringefitting.LG_Model import NRM_Model jw = NRM_Model(mask='jwst',holeshape="hex") jw.set_pixelscale(pixelscale_as*arcsec2rad) jw.simulate(fov=n_image, bandpass=fbp, over=oversample) print("simulateG7S6psf: simulation oversampling is", oversample) (year, month, day, hour, minute, second, weekday, DOY, DST) = time.gmtime() # optional writing of oversampled image if saveover: psf_over_n = jw.psf_over[:80*oversample,:80*oversample]/jw.psf_over[:80*oversample,:80*oversample].sum() psf_over_n = psf_over_n * filt_psftot[filt] # "sum of webbpsf sim done at 11x over" fits.writeto(psf_image, psf_over_n, overwrite=True) header = fits.getheader(psf_image) header['PIXELSCL'] = pixelscale_as/oversample, "arcsec per pixel" header['FILTER'] = filt header['PUPIL'] = mask header["OVER"] = ( oversample, "oversample") header["SPTYPE"] = "FLAT", "source spectral type unspecified" header["NWAVES"] = fbp.shape[0] header["WAVELEN"] = cw, "Weighted mean wavelength in meters " header["FILT_EW"] = ew, "Filter equiv width" header["FILT_BP"] = beta, "Fractional bandpass = WL/EqW" for i in range(len(WAVE)): header["WAVE%d"%i] = WAVE[i], "Wavelength %d"%i header["WGHT%d"%i] = WGHT[i], "Wavelength weight %d"%i header["FT"] = ( "analytical", "hexee * fringes") header['NRM_GEOM'] = 'G7S6', 'Beaulieu, PGT, AS, active ctrs' header['F2F'] = jw.d, "flat2flat hole size m" header['NRM_X_A1'] = jw.ctrs[0,0], 'X coordinate (m) of NRM sub-aperture 0' header['NRM_Y_A1'] = jw.ctrs[0,1], 'Y coordinate (m) of NRM sub-aperture 0' header['NRM_X_A2'] = jw.ctrs[1,0], 'X coordinate (m) of NRM sub-aperture 1' header['NRM_Y_A2'] = jw.ctrs[1,1], 'Y coordinate (m) of NRM sub-aperture 1' header['NRM_X_A3'] = jw.ctrs[2,0], 'X coordinate (m) of NRM sub-aperture 2' header['NRM_Y_A3'] = jw.ctrs[2,1], 'Y coordinate (m) of NRM sub-aperture 2' header['NRM_X_A4'] = jw.ctrs[3,0], 'X coordinate (m) of NRM sub-aperture 3' header['NRM_Y_A4'] = jw.ctrs[3,1], 'Y coordinate (m) of NRM sub-aperture 3' header['NRM_X_A5'] = jw.ctrs[4,0], 'X coordinate (m) of NRM sub-aperture 4' header['NRM_Y_A5'] = jw.ctrs[4,1], 'Y coordinate (m) of NRM sub-aperture 4' header['NRM_X_A6'] = jw.ctrs[5,0], 'X coordinate (m) of NRM sub-aperture 5' header['NRM_Y_A6'] = jw.ctrs[5,1], 'Y coordinate (m) of NRM sub-aperture 5' header['NRM_X_A7'] = jw.ctrs[6,0], 'X coordinate (m) of NRM sub-aperture 6' header['NRM_Y_A7'] = jw.ctrs[6,1], 'Y coordinate (m) of NRM sub-aperture 6' header['PSFTOT'] = filt_psftot[filt], "sum of webbpsf sim done at 11x over" header['PSFPEAK'] = psf_over_n.max() header["SRC"] = ( "simulateG7S6psf.py", "ImplaneIA/notebooks/") header['AUTHOR'] = '%s@%s' % (os.getenv('USER'), os.getenv('HOST')), 'username@host for calculation' header['DATE'] = '%4d-%02d-%02dT%02d:%02d:%02d' % (year, month, day, hour, minute, second), 'Date of calculation' header['F2F'] = (0.82, "flat2flat hole size m") fits.update(psf_image, psf_over_n, header=header) # PSF without oversampling psf_det_n = jw.psf[:80,:80]/jw.psf[:80,:80].sum() # we can delete this line but I'm in a hurry... webbpsfnorm = filt_cpf[filt] / psf_det_n.max() psf_det_n = psf_det_n * webbpsfnorm # forces central pixel values to agree ^see above fits.writeto(psf_image_without_oversampling, psf_det_n, overwrite=True) header = fits.getheader(psf_image_without_oversampling) header['PIXELSCL'] = pixelscale_as, "arcsec per pixel" header['FILTER'] = filt header['PUPIL'] = mask header["OVER"] = ( oversample, "oversample pre-rebin") header["SPTYPE"] = "FLAT", "source spectral type unspecified" header["NWAVES"] = fbp.shape[0] header["WAVELEN"] = cw, "Weighted mean wavelength in meters " header["FILT_EW"] = ew, "Filter equiv width" header["FILT_BP"] = beta, "Fractional bandpass = WL/EqW" for i in range(len(WAVE)): header["WAVE%d"%i] = WAVE[i], "Wavelength %d"%i header["WGHT%d"%i] = WGHT[i], "Wavelength weight %d"%i header["FT"] = ( "analytical", "hexee * fringes") header['NRM_GEOM'] = 'G7S6', 'Beaulieu, PGT, AS active ctrs' header['F2F'] = jw.d, "flat2flat hole size m" header['NRM_X_A1'] = jw.ctrs[0,0], 'X coordinate (m) of NRM sub-aperture 0' header['NRM_Y_A1'] = jw.ctrs[0,1], 'Y coordinate (m) of NRM sub-aperture 0' header['NRM_X_A2'] = jw.ctrs[1,0], 'X coordinate (m) of NRM sub-aperture 1' header['NRM_Y_A2'] = jw.ctrs[1,1], 'Y coordinate (m) of NRM sub-aperture 1' header['NRM_X_A3'] = jw.ctrs[2,0], 'X coordinate (m) of NRM sub-aperture 2' header['NRM_Y_A3'] = jw.ctrs[2,1], 'Y coordinate (m) of NRM sub-aperture 2' header['NRM_X_A4'] = jw.ctrs[3,0], 'X coordinate (m) of NRM sub-aperture 3' header['NRM_Y_A4'] = jw.ctrs[3,1], 'Y coordinate (m) of NRM sub-aperture 3' header['NRM_X_A5'] = jw.ctrs[4,0], 'X coordinate (m) of NRM sub-aperture 4' header['NRM_Y_A5'] = jw.ctrs[4,1], 'Y coordinate (m) of NRM sub-aperture 4' header['NRM_X_A6'] = jw.ctrs[5,0], 'X coordinate (m) of NRM sub-aperture 5' header['NRM_Y_A6'] = jw.ctrs[5,1], 'Y coordinate (m) of NRM sub-aperture 5' header['NRM_X_A7'] = jw.ctrs[6,0], 'X coordinate (m) of NRM sub-aperture 6' header['NRM_Y_A7'] = jw.ctrs[6,1], 'Y coordinate (m) of NRM sub-aperture 6' header['PSFTOT'] = psf_det_n.sum() header['PSFPEAK'] = psf_det_n.max() header['CPF'] = filt_cpf[filt] header["SRC"] = ( "simulateG7S6psf.py", "ImplaneIA/notebooks/") header['AUTHOR'] = '%s@%s' % (os.getenv('USER'), os.getenv('HOST')), 'username@host for calculation' header['DATE'] = '%4d-%02d-%02dT%02d:%02d:%02d' % (year, month, day, hour, minute, second), 'Date of calculation' fits.update(psf_image_without_oversampling, psf_det_n, header=header)
class Affine2dTestCase(unittest.TestCase): def setUp(self): # directory containing the test data data_dir = os.path.join(os.path.dirname(__file__), 'test_data/affine2d_xyscale_psf') self.data_dir = data_dir print(data_dir) if not os.path.exists(data_dir): os.makedirs(data_dir) self.fnfmt = data_dir + '/psf_nrm_{0:d}_{1:s}_{2:.3f}um_{3:s}.fits' # expects e.g. self.fnfmt.format(self.npix, 'hex', self.wave/um, aff.name) self.pixel = 0.0656 * u.arcsec.to(u.rad) self.npix = 87 self.wave = np.array([ (1.0, 4.3e-6), ]) # m self.over = 1 ################ self.pointsfmt = " ({0:+.3f}, {1:+.3f}) -> ({2:+.3f}, {3:+.3f})" self.numtestfmt = " min: {0:+.1e}, max: {1:+.1e}, avg: {2:+.1e}, sig: {3:+.1e}" # min max avg stddev self.testpoints = (np.array((0, 0)), np.array((1, 0)), np.array( (0, 1)), np.array((1, 1))) xo, yo = 0.0, 0.0 # always set these for PSFs... mx, my = 1.0, 1.0 sx, sy = 0.0, 0.0 self.affine_ideal = Affine2d(mx=mx, my=my, sx=sx, sy=sy, xo=xo, yo=yo, name="Ideal") mx, my = -1.0, 1.0 sx, sy = 0.0, 0.0 self.affine_xrev = Affine2d(mx=mx, my=my, sx=sx, sy=sy, xo=xo, yo=yo, name="Xreverse") mx, my = 2.0, 1.0 sx, sy = 0.0, 0.0 self.affine_xmag = Affine2d(mx=mx, my=my, sx=sx, sy=sy, xo=xo, yo=yo, name="Xmag") mx, my = 1.0, 1.0 sx, sy = 0.5, 0.0 self.affine_sigx = Affine2d(mx=mx, my=my, sx=sx, sy=sy, xo=xo, yo=yo, name="Xshear") for aff in (self.affine_ideal, self.affine_xrev, self.affine_xmag, self.affine_sigx): # circ g7s6 jwst created for info only self.jw = NRM_Model(mask='jwst', holeshape="circ", affine2d=aff) self.jw.set_pixelscale(self.pixel) self.jw.simulate(fov=self.npix, bandpass=self.wave, over=self.over) psffn = self.fnfmt.format(self.npix, 'circ', self.wave[:, 1][0] / um, aff.name) fits.writeto(psffn, self.jw.psf, overwrite=True) header = fits.getheader(psffn) header = affinepars2header(header, aff) fits.update(psffn, self.jw.psf, header=header) del self.jw # circonly g7s6 jwst created for info only self.jw = NRM_Model(mask='jwst', holeshape="circonly", affine2d=aff) self.jw.set_pixelscale(self.pixel) self.jw.simulate(fov=self.npix, bandpass=self.wave, over=self.over) psffn = self.fnfmt.format(self.npix, 'circonly', self.wave[:, 1][0] / um, aff.name) fits.writeto(psffn, self.jw.psf, overwrite=True) header = fits.getheader(psffn) header = affinepars2header(header, aff) fits.update(psffn, self.jw.psf, header=header) del self.jw # hex g7s6 jwst self.jw = NRM_Model(mask='jwst', holeshape="hex", affine2d=aff) self.jw.set_pixelscale(self.pixel) self.jw.simulate(fov=self.npix, bandpass=self.wave, over=self.over) psffn = self.fnfmt.format(self.npix, 'hex', self.wave[:, 1][0] / um, aff.name) fits.writeto(psffn, self.jw.psf, overwrite=True) header = fits.getheader(psffn) header = affinepars2header(header, aff) fits.update(psffn, self.jw.psf, header=header) del self.jw # hexonly g7s6 jwst self.jw = NRM_Model(mask='jwst', holeshape="hexonly", affine2d=aff) self.jw.set_pixelscale(self.pixel) self.jw.simulate(fov=self.npix, bandpass=self.wave, over=self.over) psffn = self.fnfmt.format(self.npix, 'hexonly', self.wave[:, 1][0] / um, aff.name) fits.writeto(psffn, self.jw.psf, overwrite=True) header = fits.getheader(psffn) header = affinepars2header(header, aff) fits.update(psffn, self.jw.psf, header=header) del self.jw # fringeonly g7s6 jwst self.jw = NRM_Model(mask='jwst', holeshape="fringeonly", affine2d=aff) self.jw.set_pixelscale(self.pixel) self.jw.simulate(fov=self.npix, bandpass=self.wave, over=self.over) psffn = self.fnfmt.format(self.npix, 'fringeonly', self.wave[:, 1][0] / um, aff.name) fits.writeto(psffn, self.jw.psf, overwrite=True) header = fits.getheader(psffn) header = affinepars2header(header, aff) fits.update(psffn, self.jw.psf, header=header) del self.jw del aff self.hextest = self.eval_psf_hex() self.fringeonlytest = self.eval_psf_fringeonly() self.hexonlytest = self.eval_psf_hexonly() self.evals = [self.hextest, self.fringeonlytest, self.hexonlytest] self.sigsum = self.hextest + self.fringeonlytest + self.hexonlytest """ Ideal and Xreverse_xflipped should be machine zero or close """ def eval_psf_hex(self): psfIdeal = fits.getdata( self.fnfmt.format(self.npix, 'hex', self.wave[:, 1][0] / um, "Ideal")) psfXrev = fits.getdata( self.fnfmt.format(self.npix, 'hex', self.wave[:, 1][0] / um, "Xreverse")) psfdiff = psfIdeal - psfXrev[::-1, :] print(" Numerical Summary: hex psf: " +\ self.numtestfmt.format(psfIdeal.min(), psfIdeal.max(), psfIdeal.mean(), psfIdeal.std())) print(" Numerical Summary: hex test: " +\ self.numtestfmt.format(psfdiff.min(), psfdiff.max(), psfdiff.mean(), psfdiff.std())) fits.PrimaryHDU(data=psfdiff).writeto(self.data_dir + "/diff_hex.fits", overwrite=True) return psfdiff.std() def eval_psf_fringeonly(self): psfIdeal = fits.getdata( self.fnfmt.format(self.npix, 'fringeonly', self.wave[:, 1][0] / um, "Ideal")) psfXrev = fits.getdata( self.fnfmt.format(self.npix, 'fringeonly', self.wave[:, 1][0] / um, "Xreverse")) psfdiff = psfIdeal - psfXrev[::-1, :] print(" Numerical Summary: fringeonly psf: " +\ self.numtestfmt.format(psfIdeal.min(), psfIdeal.max(), psfIdeal.mean(), psfIdeal.std())) print(" Numerical Summary: fringeonly test: " +\ self.numtestfmt.format(psfdiff.min(), psfdiff.max(), psfdiff.mean(), psfdiff.std())) fits.PrimaryHDU(data=psfdiff).writeto(self.data_dir + "/diff_fringeonly.fits", overwrite=True) return psfdiff.std() def eval_psf_hexonly(self): psfIdeal = fits.getdata( self.fnfmt.format(self.npix, 'hexonly', self.wave[:, 1][0] / um, "Ideal")) psfXrev = fits.getdata( self.fnfmt.format(self.npix, 'hexonly', self.wave[:, 1][0] / um, "Xreverse")) psfdiff = psfIdeal - psfXrev[::-1, :] print(" Numerical Summary: hexonly psf: " +\ self.numtestfmt.format(psfIdeal.min(), psfIdeal.max(), psfIdeal.mean(), psfIdeal.std())) print(" Numerical Summary: hexonly test: " +\ self.numtestfmt.format(psfdiff.min(), psfdiff.max(), psfdiff.mean(), psfdiff.std())) fits.PrimaryHDU(data=psfdiff).writeto(self.data_dir + "/diff_hexonly.fits", overwrite=True) return psfdiff.std() def test_psfs(self): print("Standard deviations of all three tests:", self.evals) self.assertTrue(self.sigsum < 1e-7, 'error: test_affine2d_xyscale_psf failed')
def find_scale( imagedata, affine_best, # best current guess at data geometry cf analytical ideal scales, # scales are near-unity pixel, npix, bandpass, over, holeshape, outdir=None): # for nrm_model """ Preserve incoming "pixel" value, put the scale correction into the Affine2d object Is that kosher??? Should we change the pixel scale and leave affine2d the same? Affine2d can also incorporate unequal x and y scales, shears... For now place scale corrections into the Affine2d object Note - placing isotropic scale change into Affine2d is equivalent to changing the effective image distance in the optical train while insisting that the mask physical geometry does not change, and the wavelength is perfectly knowm AS 2018 10 """ affine_best.show("\tfind_scale") vprint("\tBefore Loop: ", scales) #Extend this name to include multi-paramater searches? psffmt = 'psf_nrm_{0:d}_{1:s}_{2:.3f}um_scl{3:.3f}.fits' # expect (npix, holeshape, bandpass/um, scl) if hasattr(scales, '__iter__') is False: scales = (scales, ) affine2d_list = create_afflist_scales(scales, affine_best.mx, affine_best.my, affine_best.sx, affine_best.sy, affine_best.xo, affine_best.yo) crosscorrs = [] for (scl, aff) in zip(scales, affine2d_list): vprint(aff.name + "...") jw = NRM_Model(mask='jwst', holeshape=holeshape, over=over, affine2d=aff) jw.set_pixelscale(pixel) jw.simulate(fov=npix, bandpass=bandpass, over=over) psffn = psffmt.format(npix, holeshape, bandpass[:, 1][0] / um, scl) if outdir: fits.PrimaryHDU(data=jw.psf).writeto(outdir + "/" + psffn, overwrite=True) fits.writeto(psffn, jw.psf, overwrite=True) header = fits.getheader(psffn) utils.affinepars2header(header, aff) fits.update(psffn, jw.psf, header=header) crosscorrs.append(utils.rcrosscorrelate(imagedata, jw.psf).max()) del jw vprint("\tfind_affine2d_parameters: crosscorrelations", crosscorrs) vprint("\tfind_affine2d_parameters: scales", scales) scl_measured, max_cor = utils.findpeak_1d(crosscorrs, scales) vprint( "\tfind_affine2d_parameters factor measured {0:.5f} Max correlation {1:.3e}" .format(scl_measured, max_cor)) vprint("\tfind_affine2d_parameters pitch from header {0:.3f} mas".format( pixel * rad2mas)) vprint( "\tfind_affine2d_parameters pitch {0:.3f} mas (implemented using affine2d)" .format(scl_measured * pixel * rad2mas)) # return convenient affine2d return utils.Affine2d(affine_best.mx * scl_measured, affine_best.my * scl_measured, affine_best.sx * scl_measured, affine_best.sy * scl_measured, affine_best.xo * scl_measured, affine_best.yo * scl_measured, name="scale_{0:.4f}".format(scl))
def setUp(self): # setup parameters for simulation verbose = 1 overwrite = 1 monochromatic_wavelength_m = np.array([(1.0, 4.3e-6),]) mask = 'MASK_NRM' filter = 'F430M' pixelscale_arcsec = 0.0656 filter_name = 'Monochromatic '+np.str(monochromatic_wavelength_m) self.filter = filter self.filter_name = filter_name self.monochromatic_wavelength_m = monochromatic_wavelength_m # directory containing the test data data_dir = os.path.join(os.path.dirname(__file__),'test_data/fringe_fitting') if not os.path.exists(data_dir): os.makedirs(data_dir) out_dir = data_dir name_seed = 'PSF_NIRISS_%s_%s'%(mask,filter) psf_image_name = name_seed + '_reference.fits' psf_image = os.path.join(data_dir,psf_image_name) psf_image_without_oversampling = os.path.join(data_dir,psf_image_name.replace('.fits','_without_oversampling.fits')) if (not os.path.isfile(psf_image_without_oversampling)) | (overwrite): from nrm_analysis.fringefitting.LG_Model import NRM_Model jw = NRM_Model(mask='jwst',holeshape="hex") jw.set_pixelscale(pixelscale_arcsec*arcsec2rad) jw.simulate(fov=n_image, bandpass=monochromatic_wavelength_m, over=oversample) print("FringeFittingTestCase.SetUp: simulation oversampling is", oversample) # optional writing of oversampled image if 0: fits.writeto(psf_image,jw.psf_over, clobber=True) header = fits.getheader(psf_image) header['PIXELSCL'] = pixelscale_arcsec/oversample header['FILTER'] = filter_name header['PUPIL'] = mask fits.update(psf_image,jw.psf_over/10000./28., header=header) # PSF without oversampling fits.writeto(psf_image_without_oversampling,jw.psf, clobber=True) header = fits.getheader(psf_image_without_oversampling) header['PIXELSCL'] = pixelscale_arcsec header['FILTER'] = filter_name header['PUPIL'] = mask fits.update(psf_image_without_oversampling,jw.psf, header=header) # list of files produced for target file_list = glob.glob(os.path.join(data_dir,'*%s*.fits' % 'without_oversampling' )); self.simulated_image = file_list[0] self.psf_image_without_oversampling = psf_image_without_oversampling
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")
class Affine2dTestCase(unittest.TestCase): def setUp(self): # directory containing the test data data_dir = os.path.join(os.path.dirname(__file__),'test_data/affine2d_rot_psf') self.data_dir = data_dir print(data_dir) if not os.path.exists(data_dir): os.makedirs(data_dir) self.fnfmt = data_dir+'/psf_nrm_{2:.1f}_{0}_{1}_{3:.0f}.fits' # expects strings of %(imsize,hole) self.fmt = " ({0:+.3f}, {1:+.3f}) -> ({2:+.3f}, {3:+.3f})" self.pixel = 0.0656 * u.arcsec.to(u.rad) self.npix = 87 self.wave = np.array([(1.0, 4.3e-6),]) # m self.over = 1 mx, my = 1.0, 1.0 sx, sy= 0.0, 0.0 xo, yo= 0.0, 0.0 affine_ideal = Affine2d(mx=mx,my=my, sx=sx,sy=sy, xo=xo,yo=yo, name="Ideal") for rot in (0,5,10,15,20,25,30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95): """ print(" rot degrees pre", rot, end='') diagnostic = rot/15.0 - int(rot/15.0) print(" diagnostic", diagnostic, end='') rot = avoidhexsingularity(rot) # in utils print(" rot degrees post", rot) """ rot = avoidhexsingularity(rot) # in utils affine_rot = Affine2d(rotradccw=np.pi*rot/180.0, name="{0:.0f}".format(rot)) # in utils aff = affine_rot # hexonly g7s6 jwst self.jw = NRM_Model(mask='jwst', holeshape="hexonly", affine2d=aff) self.jw.set_pixelscale(self.pixel*arcsec2rad) self.jw.simulate(fov=self.npix, bandpass=self.wave, over=self.over) psffn = self.fnfmt.format(self.npix, 'hexonly', self.wave[:,1][0]/um, rot) fits.writeto(psffn, self.jw.psf, overwrite=True) header = fits.getheader(psffn) header = affinepars2header(header, aff) fits.update(psffn, self.jw.psf, header=header) del self.jw del aff del affine_rot def test_psf(self): """ Read in PSFs with 0, 90 degree affines, 5 and 95 degree affines, Rotate one set and subtract from the smaller rot PSF - should be zero if everything is correctly calculated. If we nudge the PSF centers to avoid the line singularity that hextransformEE will encounter if the psf is centrally placed in a pixel. The file names are hand-edited to reflect the oversampling and rotations, so this is more a sanity check and code development tool than a routine test. """ psf0 = fits.getdata(self.fnfmt.format(self.npix, 'hexonly', self.wave[:,1][0]/um, 0)) psf90 = fits.getdata(self.fnfmt.format(self.npix, 'hexonly', self.wave[:,1][0]/um, 90)) psf90r0 = np.rot90(psf90) psfdiff = psf0 - psf90r0 fits.PrimaryHDU(data=psfdiff).writeto(self.data_dir+"/diff_90_0_off08_ov1.fits", overwrite=True) psf0 = fits.getdata(self.fnfmt.format(self.npix, 'hexonly', self.wave[:,1][0]/um, 5)) psf90 = fits.getdata(self.fnfmt.format(self.npix, 'hexonly', self.wave[:,1][0]/um, 95)) psf90r0 = np.rot90(psf90) psfdiff = psf0 - psf90r0 fits.PrimaryHDU(data=psfdiff).writeto(self.data_dir+"/diff_95_5_off08_ov1.fits", overwrite=True) self.assertTrue(0.0 < 1e-15, 'error: test_affine2d failed')
def setUp(self): # directory containing the test data data_dir = os.path.join(os.path.dirname(__file__), 'test_data/psf_offset') self.data_dir = data_dir print(data_dir) if not os.path.exists(data_dir): os.makedirs(data_dir) self.pixel = 0.0656 * u.arcsec.to(u.rad) self.npix = 87 self.wave = 4.3e-6 # m self.over = 1 """ mx, my = 1.0, 1.0 sx, sy= 0.0, 0.0 xo, yo= 0.0, 0.0 affine_ideal = Affine2d(mx=mx,my=my, sx=sx,sy=sy, xo=xo,yo=yo, name="Ideal") """ invert = False # greyscale inversion (true/false) holeshape = "hex" pixel_as = 0.0656 / 1.3 # slightly finer-than-actual-detector sampling, for clearer images print( "\n\t*** Watch out *** if comparing to real data: slightly finer-than-actual-detector sampling used for clearer images\n" ) fov = 101 # 'detpix' but at finer sampling than actual over = 1 wav_m = 4.3e-6 filt = 'F430M' band = 'Monochromatic ' + np.str(wav_m) psf_offsets = ( (0, 0), (1.0, 0), ) psf_offsets = ((0, 0), ) psf_offsets = ((0, 0), (1.0, 0), (0, 1.0), (1.0, 1.0)) print((enumerate(psf_offsets))) psfs = np.zeros( (len(psf_offsets), fov, fov)) # for easy to understand movie print(('psfs.shape', psfs.shape)) fncube3 = data_dir + "/cube.fits" # Loop over psf_offsets for noff, psfo in enumerate(psf_offsets): jw3 = NRM_Model(mask='jwst', holeshape=holeshape, pixscale=arcsec2rad * pixel_as, datapath="", refdir="./refdir") #chooseholes=None) jw3.simulate(fov=fov, bandpass=wav_m, over=over, psf_offset=psfo) mnem = "imctr_%.1f_%.1f" % psfo fn3 = data_dir + "/" + mnem + '.fits' name_seed = mnem # PSF fits.writeto(fn3, jw3.psf, overwrite=True) header = fits.getheader(fn3) header['SEGNAMES'] = "asbuilt" header['PIXELSCL'] = pixel_as header['over'] = over header['FILTER'] = wav_m header['hole'] = holeshape header['PUPIL'] = 'asbuilt' header['psfoff0'] = (psfo[0], "ds9X / detector pixels") header['psfoff1'] = (psfo[1], "ds9Y / detector pixels") header['SRC'] = ("test_psf_offset.py", "generating code") header['author'] = ("*****@*****.**", "responsible person?") fits.update(fn3, jw3.psf, header=header) psfs[noff, :, :] = jw3.psf """ calls tkinter, needs $DISPLAY environment variable, breaks travis testing figname = UC.make_standard_image( fn3, image_title=name_seed, save_plot=1, plot_dir=data_dir, name_seed=name_seed, stretch='linear', x_axis_label=None, y_axis_label=None, invert=invert, add_grid=True) print(figname + " written to " + data_dir) """ del jw3 fits.PrimaryHDU(data=psfs).writeto(fncube3, overwrite=True) # good for movie """
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 setUp(self): # setup parameters for simulation, most are passed on to driver_scene verbose = 0 overwrite = 1 apply_dither = 0 apply_jitter = 0 include_detection_noise = 0 uniform_flatfield = 1 OVERSAMPLE = 11 monochromatic_wavelength_m = 4.3e-6 create_calibrator = 0 random_seed = 124 flip = False mask = 'MASK_NRM' filter = 'F430M' n_image = 77 filter_name = 'Monochromatic ' + np.str(monochromatic_wavelength_m) # directory containing the static test data data_dir = os.path.join(os.path.dirname(__file__), 'test_data') # define output directory for dynamically generated data out_dir = os.path.join(os.path.dirname(__file__), 'tmp_data') if not os.path.exists(out_dir): os.makedirs(out_dir) name_seed = 'PSF_NIRISS_%s_%s' % (mask, filter) point_source_image_name = 'point_source_image.fits' point_source_image = os.path.join(out_dir, point_source_image_name) psf_image_name = name_seed + '_reference.fits' psf_image = os.path.join(data_dir, psf_image_name) psf_image_without_oversampling = os.path.join( data_dir, psf_image_name.replace('.fits', '_without_oversampling.fits')) # generate delta-function like image to feed as point-source into scene_sim n_image2 = n_image * OVERSAMPLE data = np.zeros((n_image2, n_image2)) bright_pixel_index = (np.int(np.floor(n_image2 / 2.)), np.int(np.floor(n_image2 / 2.))) data[bright_pixel_index] = 1. fits.writeto(point_source_image, data, clobber=True) # following code can be used to regenerate reference PSF file, but it depends on nrm_analysis if 0: from nrm_analysis.fringefitting.LG_Model import NRM_Model jw = NRM_Model(mask='jwst', holeshape="hex", flip=flip) jw.simulate(fov=n_image, bandpass=monochromatic_wavelength_m, over=OVERSAMPLE, pixel=mas2rad(PIXELSCL_arcsec * 1000)) fits.writeto(psf_image, jw.psf_over, clobber=True) header = fits.getheader(psf_image) header['PIXELSCL'] = PIXELSCL_arcsec / OVERSAMPLE header['FILTER'] = filter_name header['PUPIL'] = mask fits.update(psf_image, jw.psf_over / 10000. / 28., header=header) # PSF without oversampling fits.writeto(psf_image_without_oversampling, jw.psf, clobber=True) header = fits.getheader(psf_image_without_oversampling) header['PIXELSCL'] = PIXELSCL_arcsec header['FILTER'] = filter_name header['PUPIL'] = mask fits.update(psf_image_without_oversampling, jw.psf, header=header) NGROUP = 1 NINT = 1 COUNTRATE = 5e8 # run driver_scene to generate target and calibrator images driver_scene.main(['--output_absolute_path','%s'%out_dir,\ '--overwrite','%d'%overwrite,'-utr','0', '-f','%s'%filter,'-v','%d'%verbose,'--apply_dither','%d'%apply_dither,'--apply_jitter','%d'%apply_jitter,\ '-p',psf_image,'-s','%s'%point_source_image,'-os','%d'%OVERSAMPLE,'-cr','%e'%COUNTRATE,'--include_detection_noise','%d'%include_detection_noise,\ '-tag',('%3.2e_NGROUP%d'%(COUNTRATE,NGROUP)).replace('.','p'),'--uniform_flatfield','%d'%uniform_flatfield,'--random_seed','%d'%random_seed,\ '--create_calibrator','%d'%create_calibrator,'--nint','%d'%NINT,'--ngroups','%d'%NGROUP]) # directory where simulated data was written filter_dir = os.path.join(out_dir, filter) self.filter_dir = filter_dir # list of files produced for target file_list = glob.glob(os.path.join(filter_dir, '%s*.fits' % 't_')) self.simulated_image = file_list[0] self.psf_image_without_oversampling = psf_image_without_oversampling