From 54661ee478ed3305482edc868d7fb645ef246c18 Mon Sep 17 00:00:00 2001 From: LukasK13 Date: Thu, 1 Oct 2020 16:35:24 +0200 Subject: [PATCH] Minor improvements --- esbo_etc/classes/psf/Airy.py | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/esbo_etc/classes/psf/Airy.py b/esbo_etc/classes/psf/Airy.py index 137de4f..1458f75 100644 --- a/esbo_etc/classes/psf/Airy.py +++ b/esbo_etc/classes/psf/Airy.py @@ -95,26 +95,27 @@ class Airy(IPSF): # Convert jitter to reduced observation angle in lambda / d_ap jitter_sigma = jitter_sigma.to(u.rad).value * self.__d_aperture / self.__wl.to(u.m) # Calculate necessary grid length to accommodate the psf and 3-sigma of the gaussian - grid_width = (reduced_observation_angle / 2 + 3 * jitter_sigma) + grid_width = (reduced_observation_angle / 2 + 3 * jitter_sigma.value) # Calculate the reduced observation angle of a single detector pixel reduced_observation_angle_pixel = (self.__pixel_size / ( self.__f_number * self.__d_aperture) * self.__d_aperture / self.__wl).decompose() # Calculate the width of each grid element dx = reduced_observation_angle_pixel.value / self.__osf # Calculate the necessary number of points on the grid - n_points = np.ceil(grid_width / dx).value + n_points = np.ceil(grid_width / dx) # Calculate the corresponding x-coordinates of each grid element x = np.arange(1, n_points + 1) * dx # Calculate the psf from an airy disk for each element on the grid psf = self.__airy(np.pi * x, np.sqrt(obstruction)) # Calculate the integral of the undisturbed airy disk in order to scale the result of the convolution + # This corresponds to an integration in polar coordinates: I(r)*r dr dphi total = np.sum(psf * x) * dx * 2 * np.pi # Mirror the PSF to the negative x-domain psf = np.concatenate((np.flip(psf), np.array([1]), psf)) # Calculate a gaussian kernel - kernel = 1 / (2 * np.pi * jitter_sigma ** 2) * np.exp(- x ** 2 / (2 * jitter_sigma ** 2)) + kernel = 1 / (2 * np.pi * jitter_sigma.value ** 2) * np.exp(- x ** 2 / (2 * jitter_sigma.value ** 2)) # Mirror the kernel to the negative x-domain - kernel = np.concatenate((np.flip(kernel), np.array([1 / (2 * np.pi * jitter_sigma ** 2)]), kernel)) + kernel = np.concatenate((np.flip(kernel), np.array([1 / (2 * np.pi * jitter_sigma.value ** 2)]), kernel)) # Normalize the kernel kernel = kernel / np.sum(kernel) # Convolve the PSF with gaussian kernel @@ -122,6 +123,7 @@ class Airy(IPSF): # Reduce the PSF to the positive x-domain psf = psf[int((psf.shape[0] - 1) / 2):] # Scale the integral of the disturbed PSF equal to the undisturbed PSF + # This corresponds to an integration in polar coordinates: I(r)*r dr dphi psf = psf / (np.sum(psf * np.arange(psf.shape[0]) * dx) * dx * 2 * np.pi) * total self.__psf_jitter = psf @@ -130,12 +132,13 @@ class Airy(IPSF): self.__osf * 2 else: # Calculate the rolling integral of the PSF + # This corresponds to an integration in polar coordinates: I(r)*r dr dphi psf_int = np.cumsum(psf * np.arange(psf.shape[0]) * dx) * dx * 2 * np.pi - # Scale the integral of the disturbed PSF equal to the undisturbed PSF - psf_int = psf_int / (4 / np.pi) * (1 - obstruction) + # Calculate the percentage of encircled energy by dividing by the infinite integral of the undisturbed + # airy disk + psf_int = psf_int / (4 / np.pi * 1 / (1 - obstruction)) # Calculate the reduced observation angle - reduced_observation_angle = np.argmax( - psf_int > contained_energy) * reduced_observation_angle_pixel.value / self.__osf * 2 + reduced_observation_angle = np.argmax(psf_int > contained_energy) * dx * 2 return reduced_observation_angle * u.dimensionless_unscaled