API

Public Step API

jwst.ami.ami_analyze_step Module

Classes

AmiAnalyzeStep([name, parent, config_file, ...])

Performs analysis of an AMI mode exposure by applying the LG algorithm.

Complete Developer API

(Some API here may also be used in AMI Normalize.)

jwst.ami.ami_analyze Module

Functions

apply_lg_plus(input_model, throughput_model, ...)

Apply the image plane algorithm (LG-PLUS) to an AMI exposure.

jwst.ami.analyticnrm2 Module

Functions

jinc(x, y, d, lam, pitch[, offx, offy])

Compute 2d Jinc for given coordinates.

ffc(kx, ky, ko, baseline, lam, pitch, affine2d)

Calculate cosine terms of analytic model.

ffs(kx, ky, ko, baseline, lam, pitch, affine2d)

Calculate sine terms of analytic model.

harmonicfringes(fov, pitch, baseline, lam, ...)

Calculate the sine and cosine fringes.

phasor(kx, ky, hx, hy, lam, phi_m, pitch, ...)

Calculate the wavefront for a single hole.

image_center(fov, oversample, psf_offset)

Calculate the Image center location in oversampled pixels.

interf(kx, ky, c, ctrs, phi, lam, pitch, ...)

Calculate the complex amplitudes for all holes.

model_array(ctrs, lam, oversample, pitch, fov, d)

Create a model using the specified wavelength.

asf(detpixel, fov, oversample, d, lam, ...)

Calculate the Amplitude Spread Function for a circular aperture.

asffringe(detpixel, fov, oversample, ctrs, ...)

Amplitude Spread Function (AKA image plane complex amplitude) for a fringe.

asf_hex(detpixel, fov, oversample, d, lam, ...)

Amplitude Spread Function (AKA image plane complex amplitude) for a hexagonal aperture.

psf(detpixel, fov, oversample, ctrs, d, lam, ...)

Calculate the PSF for the requested aperture shape.

jwst.ami.bp_fix Module

Pipeline implementation of Jens Kammerer’s bp_fix code based on Ireland 2013 algorithm.

Functions

create_wavelengths(filtername)

Extend filter support slightly past half power points.

calc_pupil_support(filtername, sqfov_npix, ...)

Calculate psf at low, center, and high wavelengths of filter.

transform_image(image)

Take Fourier transform of image.

calcpsf(wl, fovnpix, pxsc_rad, pupil_mask)

Calculate the PSF.

bad_pixels(data, median_size, median_tres)

Identify bad pixels by subtracting median-filtered data and searching for outliers.

fourier_corr(data, pxdq, fmas)

Compute and apply the bad pixel corrections based on Section 2.5 of Ireland 2013.

fix_bad_pixels(data, pxdq0, filt, pxsc, ...)

Apply the Fourier bad pixel correction to pixels flagged DO_NOT_USE or JUMP_DET.

jwst.ami.find_affine2d_parameters Module

Functions

create_afflist_rot(rotdegs)

Create a list of affine objects with various rotations.

find_rotation(imagedata, nrm_model, ...)

Create an affine2d object using the known rotation and scale.

jwst.ami.hextransformee Module

Functions

gfunction(xi, eta, c, pixel, d, lam, affine2d)

Fourier transform a half-hexagon.

hextransform(s, d, lam, pitch, affine2d[, c])

Calculate the complex array analytical transform of a (distorted if necessary) hexagon.

jwst.ami.instrument_data Module

Classes

NIRISS(filt, nrm_model, bandpass[, ...])

Module for defining NIRISS data format, wavelength info, and mask geometry.

jwst.ami.leastsqnrm Module

Functions

replacenan(array)

Replace singularities in analytical hexagon Fourier transform.

weighted_operations(img, model[, dqm])

Perform least squares matrix operations to solve A x = b weighting by Poisson variance.

matrix_operations(img, model[, linfit, dqm])

Use least squares matrix operations to solve A x = b.

multiplyenv(env, fringeterms)

Multiply the envelope by each fringe 'image'.

tan2visibilities(coeffs)

From the solution to the fit, calculate the fringe amplitude and phase.

populate_antisymmphasearray(deltaps[, n])

Populate the antisymmetric fringe phase array:.

populate_symmamparray(amps[, n])

Populate the symmetric fringe amplitude array.

t3_amplitudes(amps[, n])

Populate the triple-product amplitude array (NOT closure amplitudes).

redundant_cps(deltaps[, n])

Calculate closure phases for each set of 3 holes.

closure_amplitudes(amps[, n])

Calculate closure amplitudes.

q4_phases(deltaps[, n])

Calculate phases for each set of 4 holes.

Classes

LinearFit(dependent_variable, ...)

Perform a general least-squares fit of a linear model using numpy matrix inversion.

jwst.ami.lg_model Module

Functions

goodness_of_fit(data, bestfit[, disk_r])

Calculate goodness of fit between the data and the fit.

run_data_correlate(data, model)

Calculate correlation between data and model.

Classes

LgModel(nrm_model, pixscale, bandpass[, ...])

A class for conveniently dealing with an NRM object.

jwst.ami.mask_definition_ami Module

Classes

NRMDefinition(nrm_model[, maskname, chooseholes])

Defines the geometry of the NRM mask.

jwst.ami.matrix_dft Module

Matrix-based discrete Fourier transforms for computing PSFs.

MatrixDFT: Matrix-based discrete Fourier transforms for computing PSFs. Internally this will call one of several subfunctions depending on the specified centering type. These have to do with where the (0, 0) element of the Fourier transform is located, i.e., where the PSF center ends up:

  • ‘FFTSTYLE’ centered on one pixel

  • ‘SYMMETRIC’ centered on crosshairs between middle pixel

  • ‘ADJUSTABLE’, always centered in output array depending on whether it is even or odd

‘ADJUSTABLE’ is the default. This module was originally called “Slow Fourier Transform”, and this terminology still appears in some places in the code. Note that this is ‘slow’ only in the sense that if you perform the exact same calculation as an FFT, the FFT algorithm is much faster. However this algorithm gives you much more flexibility in choosing array sizes and sampling, and often lets you replace “fast calculations on very large arrays” with “relatively slow calculations on much smaller ones”.

Notes

Code originally by A. Sivaramakrishnan, M. Perrin, and J. Long, in accordance with Soummer et al. 2007. [1]

References

[1]

Soummer et al. 2007, Opt. Express 15, 15935-15951 (2007) https://doi.org/10.1364/OE.15.015935

Examples

result = matrix_dft.matrix_dft(pupilArray, focalplane_size, focalplane_npix)

Functions

matrix_dft(plane, nlam_d, npix[, offset, ...])

Perform a matrix discrete Fourier transform with selectable output sampling and centering.

matrix_idft(*args, **kwargs)

Perform an inverse matrix discrete Fourier transform.

jwst.ami.nrm_core Module

Classes

FringeFitter(instrument_data[, oversample, ...])

Fit fringes to get interferometric observables for the data.

jwst.ami.oifits Module

Classes

RawOifits(instrument_data[, method])

Store AMI data in the format required to write out to OIFITS files.

CalibOifits(targoimodel, caloimodel)

Produce a final calibrated AmiOIModel.

jwst.ami.utils Module

Functions

makedisk(n, r)

Calculate a 'disk'.

avoidhexsingularity(rotation)

Avoid rotation of exact multiples of 15 degrees to avoid NaNs in hextransformee().

centerpoint(s)

Calculate center of image, accounting for odd/even pixel size.

min_distance_to_edge(img)

Calculate distance from the brightest pixel in img to the nearest edge of img.

find_centroid(a)

Calculate the centroid of the image.

quadratic_extremum(p)

Calculate extremum of the quadratic.

findpeak_1d(xvec, yvec)

Calculate the fit function extreme for a given input vector.

findslope(a)

Find slopes of an array.

make_a(nh)

Write the 'NRM matrix'.

fringes2pistons(fringephases, nholes)

Extract pistons out of fringes.

rebin([a, rc])

Perform simple flux-conserving binning using specified binning kernel.

krebin(a, shape)

Rebin, applying Klaus P's fastrebin from web.

rcrosscorrelate([a, b])

Calculate cross correlation of two identically-shaped real arrays.

crosscorrelate([a, b])

Calculate cross correlation of two identically-shaped real or complex arrays.

rotate2dccw(vectors, thetarad)

Apply a CCW rotation to the given vectors.

get_filt_spec(throughput_model)

Load filter throughput data into synphot spectrum object.

get_flat_spec()

Produce a synphot spectrum object with constant (unity) flux.

combine_src_filt(bandpass, srcspec[, trim, ...])

Get the observed spectrum through a filter.

get_cw_beta(bandpass)

Convert input bandpass array into format expected by code.

handle_bandpass(bandpass, throughput_model)

Determine what to do with the input bandpass.

degrees_per_pixel(datamodel)

Get pixel scale info from data model.

Classes

Affine2d([mx, my, sx, sy, xo, yo, ...])

Implement the Bracewell Fourier 2D affine transformation theorem.