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 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 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 = 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 / 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 create_afflist_rot(rotdegs, mx, my, sx, sy, xo, yo):
""" create a list of affine objects with various rotations to use
in order to go through and find which fits some image plane data best """
alist = []
for nrot, rotd in enumerate(rotdegs):
rotd_ = utils.avoidhexsingularity(rotd)
alist.append(
utils.Affine2d(rotradccw=np.pi * rotd_ / 180.0,
name="affrot_{0:+.3f}".format(rotd_)))
return alist
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 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
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)
if __name__ == "__main__":
identity = utils.Affine2d(rotradccw=utils.avoidhexsingularity(0.0),
name="affrot_{0:+.3f}deg".format(0.0))
no_pistons = np.zeros((7, )) * 1.0
_psf_offset_det = (0.48, 0.0)
no_psf_offset = (0.0, 0.0)
rot = 2.0
rot = utils.avoidhexsingularity(rot)
aff = utils.Affine2d(rotradccw=np.pi * rot / 180.0,
name="affrot_{0:+.3f}d".format(rot))
_rotsearch_d = np.arange(-3, 3.1, 1)
#std dev 1, 7 holes, diffraction-limited @ 2um we're at 4um
_pistons_w = 0.5 * np.random.normal(0, 1.0, 7) / 14.0
simulate_data(affine2d=aff,
