def test_sinc(p):
"""Tests from figure 1 of
*"Computation of quasi-discrete Hankel transforms of the integer
order for propagating optical wave fields"*
Manuel Guizar-Sicairos and Julio C. Guitierrez-Vega
J. Opt. Soc. Am. A **21** (1) 53-58 (2004)
"""
transformer = HankelTransform(p, max_radius=3, n_points=256)
v = transformer.v
gamma = 5
func = sinc(2 * np.pi * gamma * transformer.r)
expected_ht = np.zeros_like(func)
expected_ht[v < gamma] = (v[v < gamma]**p * np.cos(p * np.pi / 2)
/ (2*np.pi*gamma * np.sqrt(gamma**2 - v[v < gamma]**2)
* (gamma + np.sqrt(gamma**2 - v[v < gamma]**2))**p))
expected_ht[v >= gamma] = (np.sin(p * np.arcsin(gamma/v[v >= gamma]))
/ (2*np.pi*gamma * np.sqrt(v[v >= gamma]**2 - gamma**2)))
ht = transformer.qdht(func)
# use the same error measure as the paper
dynamical_error = 20 * np.log10(np.abs(expected_ht-ht) / np.max(ht))
not_near_gamma = np.logical_or(v > gamma*1.25,
v < gamma*0.75)
assert np.all(dynamical_error < -10)
assert np.all(dynamical_error[not_near_gamma] < -35)
def qdht(r: np.ndarray, f: np.ndarray, order: int = 0) -> Tuple[np.ndarray, np.ndarray]:
"""Perform a quasi-discrete Hankel transform of the function ``f`` (sampled at points
``r``) and return the transformed function and its sample points in :math:`k`-space.
If you requires the transform on a frequency axis (as opposed to the :math:`k`-axis), the
frequency axis :math:`v` can be calculated using :math:`v = \\frac{k}{2\\pi}`.
.. warning::
This method is a convenience wrapper for :meth:`.HankelTransform.qdht`, but incurs a
significant overhead in calculating the :class:`.HankelTransform` object. If you
are performing multiple transforms on the same grid, it will be much quicker to
construct a single :class:`.HankelTransform` object and call
:meth:`.HankelTransform.qdht` multiple times.
:param r: The radial coordinates at which the function is sampled
:type r: :class:`numpy.ndarray`
:param f: The value of the function to be transformed.
:type f: :class:`numpy.ndarray`
:param order: The order of the Hankel Transform to perform. Defaults to 0.
:return: A tuple containing the k coordinates of the transformed function and its values
:rtype: (:class:`numpy.ndarray`, :class:`numpy.ndarray`)
"""
transformer = HankelTransform(order=order, radial_grid=r)
f_transform = transformer.to_transform_r(f)
ht = transformer.qdht(f_transform)
return transformer.kr, ht
def test_top_hat_equivalence(a: float, order: int, radius: np.ndarray):
transformer = HankelTransform(order=order, radial_grid=radius)
f = generalised_top_hat(radius, a, order)
kr, one_shot_ht = qdht(radius, f, order=order)
f_t = generalised_top_hat(transformer.r, a, transformer.order)
standard_ht = transformer.qdht(f_t)
assert np.allclose(one_shot_ht, standard_ht)
def test_round_trip_3d(two_d_size: int, axis: int, radius: np.ndarray,
transformer: HankelTransform):
dims = np.ones(3, np.int) * two_d_size
dims[axis] = radius.size
func = np.random.random(dims)
ht = transformer.qdht(func, axis=axis)
reconstructed = transformer.iqdht(ht, axis=axis)
assert np.allclose(func, reconstructed)
def test_gaussian(a: float, radius: np.ndarray):
# Note the definition in Guizar-Sicairos varies by 2*pi in
# both scaling of the argument (so use kr rather than v) and
# scaling of the magnitude.
transformer = HankelTransform(order=0, radial_grid=radius)
f = np.exp(-a ** 2 * transformer.r ** 2)
expected_ht = 2*np.pi*(1 / (2 * a**2)) * np.exp(-transformer.kr**2 / (4 * a**2))
actual_ht = transformer.qdht(f)
assert np.allclose(expected_ht, actual_ht)
def test_round_trip_with_interpolation(shape: Callable, radius: np.ndarray,
transformer: HankelTransform):
# the function must be smoothish for interpolation
# to work. Random every point doesn't work
func = shape(radius)
func_hr = transformer.to_transform_r(func)
ht = transformer.qdht(func_hr)
reconstructed_hr = transformer.iqdht(ht)
reconstructed = transformer.to_original_r(reconstructed_hr)
assert np.allclose(func, reconstructed, rtol=2e-4)
def test_gaussian_equivalence(a: float, radius: np.ndarray):
# Note the definition in Guizar-Sicairos varies by 2*pi in
# both scaling of the argument (so use kr rather than v) and
# scaling of the magnitude.
transformer = HankelTransform(order=0, radial_grid=radius)
f = np.exp(-a ** 2 * radius ** 2)
kr, one_shot_ht = qdht(radius, f)
f_t = np.exp(-a ** 2 * transformer.r ** 2)
standard_ht = transformer.qdht(f_t)
assert np.allclose(one_shot_ht, standard_ht, rtol=1e-3, atol=1e-4)
def test_1_over_r2_plus_z2_equivalence(a: float):
r = np.linspace(0, 50, 1024)
f = 1 / (r ** 2 + a ** 2)
transformer = HankelTransform(order=0, radial_grid=r)
f_transformer = 1 / (transformer.r**2 + a**2)
assert np.allclose(transformer.to_transform_r(f), f_transformer, rtol=1e-2, atol=1e-6)
kr, one_shot_ht = qdht(r, f)
assert np.allclose(kr, transformer.kr)
standard_ht = transformer.qdht(f_transformer)
assert np.allclose(one_shot_ht, standard_ht, rtol=1e-3, atol=1e-2)
def test_energy_conservation(shape: Callable, transformer: HankelTransform):
transformer = HankelTransform(transformer.order, 10, transformer.n_points)
func = shape(transformer.r, 0.5, transformer.order)
intensity_before = np.abs(func)**2
energy_before = np.trapz(y=intensity_before * 2 * np.pi * transformer.r,
x=transformer.r)
ht = transformer.qdht(func)
intensity_after = np.abs(ht)**2
energy_after = np.trapz(y=intensity_after * 2 * np.pi * transformer.v,
x=transformer.v)
assert np.isclose(energy_before, energy_after, rtol=0.01)
def test_1_over_r2_plus_z2(a: float):
# Note the definition in Guizar-Sicairos varies by 2*pi in
# both scaling of the argument (so use kr rather than v) and
# scaling of the magnitude.
transformer = HankelTransform(order=0, n_points=1024, max_radius=50)
f = 1 / (transformer.r**2 + a**2)
# kn cannot handle complex arguments, so a must be real
expected_ht = 2 * np.pi * scipy_bessel.kn(0, a * transformer.kr)
actual_ht = transformer.qdht(f)
# These tolerances are pretty loose, but there seems to be large
# error here
assert np.allclose(expected_ht, actual_ht, rtol=0.1, atol=0.01)
error = np.mean(np.abs(expected_ht - actual_ht))
assert error < 4e-3
def test_qdht(engine):
r_max = 5e-3
nr = 512
h = HankelTransform(0, r_max, nr)
hm = engine.hankel_matrix(0., r_max, float(nr), nargout=1)
dr = r_max / (nr - 1) # Radial spacing
nr = np.arange(0, nr) # Radial pixels
r = nr * dr # Radial positions
er = r < 1e-3
# noinspection PyUnresolvedReferences
er_m = matlab.double(er[np.newaxis, :].transpose().tolist())
matlab_value = engine.qdht(er_m, hm, float(3), nargout=1)
python_value = h.qdht(er)
assert matlab_python_allclose(python_value, matlab_value)
def propagate_using_object(r: np.ndarray, field: np.ndarray) -> np.ndarray:
transformer = HankelTransform(order=0, radial_grid=r)
field_for_transform = transformer.to_transform_r(field) # Resampled field
hankel_transform = transformer.qdht(field_for_transform)
propagated_field = np.zeros((nr, Nz), dtype=complex)
kz = np.sqrt(k0**2 - transformer.kr**2)
for n, z_loop in enumerate(z):
phi_z = kz * z_loop # Propagation phase
hankel_transform_at_z = hankel_transform * np.exp(
1j * phi_z) # Apply propagation
field_at_z_transform_grid = transformer.iqdht(
hankel_transform_at_z) # iQDHT
propagated_field[:, n] = transformer.to_original_r(
field_at_z_transform_grid) # Interpolate output
intensity = np.abs(propagated_field)**2
return intensity
def test_gaussian_2d(axis: int, radius: np.ndarray):
# Note the definition in Guizar-Sicairos varies by 2*pi in
# both scaling of the argument (so use kr rather than v) and
# scaling of the magnitude.
transformer = HankelTransform(order=0, radial_grid=radius)
a = np.linspace(2, 10)
dims_a = np.ones(2, np.int)
dims_a[1 - axis] = len(a)
dims_r = np.ones(2, np.int)
dims_r[axis] = len(transformer.r)
a_reshaped = np.reshape(a, dims_a)
r_reshaped = np.reshape(transformer.r, dims_r)
kr_reshaped = np.reshape(transformer.kr, dims_r)
f = np.exp(-a_reshaped**2 * r_reshaped**2)
expected_ht = 2 * np.pi * (1 / (2 * a_reshaped**2)) * np.exp(
-kr_reshaped**2 / (4 * a_reshaped**2))
actual_ht = transformer.qdht(f, axis=axis)
assert np.allclose(expected_ht, actual_ht)
def example():
# Gaussian function
def gauss1d(x, x0, fwhm):
return np.exp(-2 * np.log(2) * ((x - x0) / fwhm) ** 2)
nr = 1024 # Number of sample points
r_max = .05 # Maximum radius (5cm)
dr = r_max / (nr - 1) # Radial spacing
ri = np.arange(0, nr) # Radial pixels
r = ri * dr # Radial positions
beam_radius = 5e-3 # 5mm
propagation_direction = 5000
Nz = 200 # Number of z positions
z_max = .25 # Maximum propagation distance
dz = z_max / (Nz - 1)
z = np.arange(0, Nz) * dz # Propagation axis
ht = HankelTransform(0, radial_grid=r)
k_max = 2 * np.pi * ht.v_max # Maximum K vector
field = gauss1d(r, 0, beam_radius) * np.exp(1j * propagation_direction * r) # Initial field
ht_field = ht.to_transform_r(field) # Resampled field
transform = ht.qdht(ht_field) # Convert from physical field to physical wavevector
propagated_intensity = np.zeros((nr, Nz + 1))
propagated_intensity[:, 0] = np.abs(field) ** 2
for n in range(1, Nz):
z_loop = z[n]
propagation_phase = (np.sqrt(k_max ** 2 - ht.kr ** 2) - k_max) * z_loop # Propagation phase
propagated_transform = transform * np.exp(1j * propagation_phase) # Apply propagation
propagated_ht_field = ht.iqdht(propagated_transform) # iQDHT
propagated_field = _spline(ht.r, propagated_ht_field, r) # Interpolate output
propagated_intensity[:, n] = np.abs(propagated_field) ** 2
return transform, propagated_intensity
# Set up a :class:`.HankelTransform` object, telling it the order (``0``) and
# the radial grid.
H = HankelTransform(order=0, radial_grid=r)
# %%
# Set up the electric field profile at :math:`z = 0`, and resample onto the correct radial grid
# (``transformer.r``) as required for the QDHT.
Er = gauss1d(r, 0, Dr) # Initial field
ErH = H.to_transform_r(Er) # Resampled field
# %%
# Perform Hankel Transform
# ------------------------
# Convert from physical field to physical wavevector
EkrH = H.qdht(ErH)
# %%
# Propagate the beam - loop
# -------------------------
# Do the propagation in a loop over :math:`z`
# Pre-allocate an array for field as a function of r and z
Erz = np.zeros((nr, Nz), dtype=complex)
kz = np.sqrt(k0**2 - H.kr**2)
for i, z_loop in enumerate(z):
phi_z = kz * z_loop # Propagation phase
EkrHz = EkrH * np.exp(1j * phi_z) # Apply propagation
ErHz = H.iqdht(EkrHz) # iQDHT
Erz[:, i] = H.to_original_r(ErHz) # Interpolate output
Irz = np.abs(Erz)**2
# %%
# First import the :class:`.HankelTransform` class and other packages
from pyhank import HankelTransform
import scipy.special
import matplotlib.pyplot as plt
# %%
# Create a :class:`.HankelTransform` object which holds the grid for :math:`r` and
# :math:`k_r` points and calculate the jinc function.
#
# Note that although the calculation fails at :math:`r = 0`, ``transformer.r`` does
# not include :math:`r=0`.
transformer = HankelTransform(order=0, max_radius=100, n_points=1024)
f = scipy.special.jv(1, transformer.r) / transformer.r
plt.figure()
plt.plot(transformer.r, f)
plt.xlabel('Radius /m')
# %%
# Now take the Hankel transform using :meth:`.HankelTransform.qdht`
ht = transformer.qdht(f)
plt.figure()
plt.plot(transformer.kr, ht)
plt.xlim([0, 5])
plt.xlabel('Radial wavevector /m$^{-1}$')
# %%
# As expected, this is a top-hat function bandlimited to :math:`k<1`, except for numerical error.
def test_round_trip_2d(two_d_size: int, radius: np.ndarray, transformer: HankelTransform):
func = np.random.random((radius.size, two_d_size))
ht = transformer.qdht(func)
reconstructed = transformer.iqdht(ht)
assert np.allclose(func, reconstructed)
def test_round_trip(radius: np.ndarray, transformer: HankelTransform):
func = np.random.random(radius.shape)
ht = transformer.qdht(func)
reconstructed = transformer.iqdht(ht)
assert np.allclose(func, reconstructed)
plt.xlabel('Frequency /$v$')
plt.xlim([0, 1.5])
plt.legend()
plt.tight_layout()
error = np.mean(np.abs(expected_ht-actual_ht))
assert error < 1e-3
# %%
# Now we repeat but the other way round: the Hankel transform of the top-hat
# function should be the jinc function.
radius = np.linspace(0, 2, 1024)
for order in [0, 1, 4]:
transformer = HankelTransform(order=order, radial_grid=radius)
f = generalised_top_hat(transformer.r, a, order)
actual_ht = transformer.qdht(f)
expected_ht = generalised_jinc(transformer.v, a, order)
plt.figure()
plt.subplot(2, 1, 1)
plt.title(f'Generalised top-hat function, order = {order}')
plt.plot(radius, f)
plt.xlabel('Radius /$r$')
plt.subplot(2, 1, 2)
plt.plot(v, expected_ht, label='Analytical')
plt.plot(v, actual_ht, marker='x', linestyle='None', label='QDHT')
plt.title(f'Hankel transform - generalised jinc, order = {order}')
plt.xlabel('Frequency /$v$')
plt.xlim([0, 1.5])
plt.legend()
plt.tight_layout()
def test_top_hat(transformer: HankelTransform, a: float):
f = generalised_top_hat(transformer.r, a, transformer.order)
expected_ht = generalised_jinc(transformer.v, a, transformer.order)
actual_ht = transformer.qdht(f)
error = np.mean(np.abs(expected_ht-actual_ht))
assert error < 1e-3
(gamma + np.sqrt(gamma**2 - v[v < gamma]**2))**p))
ht[v >= gamma] = (
np.sin(p * np.arcsin(gamma / v[v >= gamma])) /
(2 * np.pi * gamma * np.sqrt(v[v >= gamma]**2 - gamma**2)))
return ht
# %%
# Now plot the values of the hankel transform and the dynamical error as in figure 1 of |Guizar| `Guizar`_
# for order 1 and 4
for p in [1, 4]:
transformer = HankelTransform(p, max_radius=3, n_points=256)
gamma = 5
func = sinc(2 * np.pi * gamma * transformer.r)
expected_ht = hankel_transform_of_sinc(transformer.v)
ht = transformer.qdht(func)
dynamical_error = 20 * np.log10(np.abs(expected_ht - ht) / np.max(ht))
not_near_gamma = np.logical_or(transformer.v > gamma * 1.25,
transformer.v < gamma * 0.75)
plt.figure()
plt.subplot(2, 1, 1)
plt.plot(transformer.v, expected_ht, label='Analytical')
plt.plot(transformer.v, ht, marker='+', linestyle='None', label='QDHT')
plt.title(f'Hankel Transform, p={p}')
plt.legend()
plt.subplot(2, 1, 2)
plt.plot(transformer.v, dynamical_error)
plt.title('Dynamical error')
plt.tight_layout()
