Imaging

Setup

FunctionDescription
setup_dft(data, nx, pixsize)Build a DFT matrix for exact Fourier imaging
setup_dft_polychromatic(data, nx, pixsize)DFT setup for polychromatic data
setup_nfft(data, nx, pixsize)Build an NFFT plan for fast Fourier imaging
setup_nfft_multiepochs(data, nx, pixsize)NFFT setup for multi-epoch data
setup_nfft_polychromatic(data, nx, pixsize)NFFT setup for polychromatic data
gaussian2d(nx, ny, sigma)Generate a 2D Gaussian starting image

Forward model

FunctionDescription
image_to_vis(x, ft)Image to complex visibilities (DFT or NFFT)
image_to_v2(x, ft, data)Image to squared visibilities
image_to_t3phi(x, ft, data)Image to closure phases
image_to_t3amp(x, ft, data)Image to triple amplitudes
image_to_obs(x, ft, data)Image to all observables (V², T3phi, T3amp)
image_to_residuals(x, ft, data)Image to normalised residuals (model - data) / error
vis_to_v2(cvis, indx)Complex visibilities to squared visibilities
vis_to_t3(cvis, i1, i2, i3)Complex visibilities to triple product, T3amp, T3phi
observables(cvis, data)Complex visibilities to (V², T3phi, T3amp)

Chi-squared and criterion

FunctionDescription
image_to_chi2(x, ft, data)Image chi-squared (value only; alias: chi2_f)
image_to_chi2_fg(x, g, ft, data)Image chi-squared with gradient (alias: chi2_fg)
chi2_polychromatic_f(x, ft, data)Polychromatic chi-squared (value only)
crit_f(x, ft, data)Criterion = chi-squared + regularization (value only)
crit_fg(x, g, ft, data)Criterion + gradient (includes normalization correction)
crit_polychromatic_fg(x, g, ft, data)Polychromatic criterion + gradient
crit_multitemporal_fg(x, g, ft, data)Multi-temporal criterion + gradient
OITOOLS.image_to_residualsFunction
image_to_residuals(x, ft, data)

Compute normalised residuals (model - data) / error for each observable type. Returns a NamedTuple with fields v2, t3amp, t3phi, visamp, visphi. Phase residuals (t3phi, visphi) are wrapped to [-180, 180] before dividing by error.

source
OITOOLS.image_to_chi2Function
image_to_chi2(x, ft, data; weights=[1,1,1], verb=false, vonmises=false)

Alias for chi2_f. Compute the weighted chi-squared of an image against data, for consistency with the image_to_vis / image_to_obs family.

source
OITOOLS.image_to_chi2_fgFunction
image_to_chi2_fg(x, g, ft, data; weights=[1,1,1], verb=false, vonmises=false)

Alias for chi2_fg. Compute chi-squared and its gradient w.r.t. the image, for consistency with the image_to_vis / image_to_obs family.

source

Reconstruction

FunctionDescription
reconstruct(x0, data, ft)Monochromatic image reconstruction (VMLMB)
reconstruct_multitemporal(x0, data, ft)Multi-epoch reconstruction
reconstruct_polychromatic(x0, data, ft)Polychromatic reconstruction

SPARCO

FunctionDescription
reconstruct_sparco_gray(x0, params, data, ft)SPARCO grey image reconstruction
reconstruct_sparco_multi(x0, params, nsources, data, ft)Multi-source SPARCO reconstruction
reconstruct_sparco_flat(x0, params, model, data, ft)SPARCO reconstruction using flat model
chi2_sparco_multi_f(x, params, nsources, ft, data)Multi-source SPARCO chi-squared (forward only)
chi2_sparco_flat_f(x, params, model, ft, data)Flat-model SPARCO chi-squared (forward only)
optimize_sparco_multi_parameters(params, nsources, x, ft, data)Optimize multi-source SPARCO parameters (image fixed)
optimize_sparco_flat_parameters(params, model, x, ft, data)Optimize flat-model SPARCO parameters (image fixed)
OITOOLS.reconstruct_sparco_grayFunction
reconstruct_sparco_gray(x_start, params_start, data, ft; kwargs...)

SPARCO grey image reconstruction with a single chromatic point source. Jointly optimizes [params; image_pixels] via VMLMB. Returns (params_final, x_final).

source
OITOOLS.reconstruct_sparco_multiFunction
reconstruct_sparco_multi(x_start, params_start, nsources, data, ft; kwargs...)

Multi-source SPARCO image reconstruction with N chromatic point sources. Jointly optimizes [params; image_pixels] via VMLMB. Returns (params_final, x_final).

source
OITOOLS.reconstruct_sparco_flatFunction
reconstruct_sparco_flat(x_start, params_start, model, data, ft;
                        w_name="env,f", regularizers=[], weights=[1,1,1],
                        maxiter=100, verb=false, vonmises=false, ...)

SPARCO image reconstruction using a flat-model parametric component.

Returns (params_final, x_final).

source
OITOOLS.chi2_sparco_multi_fFunction
chi2_sparco_multi_f(x, params, nsources, ftplan, data; kwargs...)

Compute chi-squared for the multi-source SPARCO model (forward only, no gradient). params layout: 5 per source [flux, dindex, ra, dec, diam] + 3 global [f_bg, d_env, λ₀].

source
OITOOLS.chi2_sparco_flat_fFunction
chi2_sparco_flat_f(x_img, params, model, ftplan, data;
                   w_name="env,f", weights=[1,1,1], verb=true, vonmises=false)

Evaluate chi2 for the SPARCO-flat model (no gradient).

source
OITOOLS.optimize_sparco_multi_parametersFunction
optimize_sparco_multi_parameters(params_start, nsources, x, ft, data; kwargs...)

Optimize multi-source SPARCO parameters with the image held fixed. Uses NelderMead (gradient-free). Returns (minchi2, params_opt, ret).

source
OITOOLS.optimize_sparco_flat_parametersFunction
optimize_sparco_flat_parameters(params_start, model, x_img, ft, data;
                                w_name="env,f", weights=[1,1,1], lb, ub)

Optimize SPARCO-flat model parameters with the image held fixed. Uses NelderMead (gradient-free). Returns (minchi2, params_opt, ret).

source

Maximum entropy (BSMEM)

FunctionDescription
reconstruct_bsmem(x0, data, ft)BSMEM image reconstruction
auto_pixsize(data)Estimate pixel size from data
gaussian_prior(nx, fwhm)Generate a Gaussian prior image
OITOOLS.reconstruct_bsmemFunction
reconstruct_bsmem(x_start, data, ft; kwargs...) → Matrix{Float64}

Maximum Entropy image reconstruction using power spectra (V²) and closure phases (T3φ), with the same calling convention as reconstruct.

This is the recommended high-level entry point. Pixel size and image size are inferred from the OITOOLS NFFT plan ft; you do not need to call maxent_setup or maxent_reconstruct! directly.

Arguments

  • x_start — starting image: an nx×nx matrix or length-nx² vector. Used as the initial iterate and, unless overridden via regularizers, as the entropy prior.
  • data::OIdata — interferometric data loaded by readoifits.
  • ft — NFFT plan produced by setup_nfft(data, nx, pixsize).

Keyword arguments

Reconstruction control

  • method — MaximENT stopping criterion. Either a 4-element Int vector passed directly as methd, or one of these shorthands:
    • 1[1,1,1,2] classic known noise
    • 4[4,1,1,2] χ² = N (default)
  • maxiter — maximum outer iterations. Default: 200.
  • verbose — print iteration diagnostics. Default: true.

Prior / entropy

  • regularizers — list of regularization entries. The first entry of the form ["mem", model] supplies the entropy prior image; all other entries are ignored by MaxEnt. If no "mem" entry is found, x_start is used as the prior.

Data-space options

  • flux_err — relative flux uncertainty for the zero-baseline constraint. Default: 1e-5.
  • biserrtype — bispectrum noise model: :full (Meimon 2005 elliptic, default) or :classic (first-order approximation).
  • force_extrapolate — always estimate triple amplitudes from V² rather than using measured values. Default: false.

MaximENT hyper-parameters

  • nrand — number of random probe vectors for evidence estimation. Default: 10.
  • aim, rate, utol, alpha — MaximENT convergence parameters.
  • mackay_alpha — use MacKay fixed-point α update. Default: false.
  • ritz_alpha — use Ritz-value bisection α update. Default: false.

Example

data   = readoifits("data/2004-data1.oifits")[1,1]
nx     = 128
pixsize = 0.05   # mas/pixel
ft      = setup_nfft(data, nx, pixsize)
prior   = gaussian_prior(nx, pixsize; fwhm_mas = nx * pixsize / 5)
x = reconstruct_bsmem(prior, data, ft;
                      regularizers = [["mem", prior]],
                      method       = [1, 1, 1, 2],
                      maxiter      = 100,
                      flux_err     = 1e-5)
imdisp(x; pixsize)

See also: maxent_setup, maxent_reconstruct!.

source
OITOOLS.auto_pixsizeFunction
auto_pixsize(data; oversampling=3.0) → Float64

Return a pixel size in mas giving oversampling pixels per fringe at the longest baseline.

source
OITOOLS.gaussian_priorFunction
gaussian_prior(nx, pixsize_mas; fwhm_mas, flux=1.0) → Vector{Float64}

Centred Gaussian prior matching bsmem.c modeltype=3. fwhm_mas defaults to 1/5 of the image FoV. Pixels are clipped at 1e-8 to avoid log(0) in the entropy.

source