Begun to implement interferometer at phase level.

Author: Jammy2211

autoarray/data/imaging.py

@@ -710,12 +710,12 @@ def simulate(
         image = psf.convolved_array_from_array(array=image)
 
         if image_needs_trimming:
-            image = image.trimmed_from_kernel_shape(kernel_shape=psf.shape_2d)
+            image = image.trimmed_from_kernel_shape(kernel_shape_2d=psf.shape_2d)
             exposure_time_map = exposure_time_map.trimmed_from_kernel_shape(
-                kernel_shape=psf.shape_2d
+                kernel_shape_2d=psf.shape_2d
             )
             background_sky_map = background_sky_map.trimmed_from_kernel_shape(
-                kernel_shape=psf.shape_2d
+                kernel_shape_2d=psf.shape_2d
             )
 
         if add_noise is True:

autoarray/mask/regions.py

@@ -62,21 +62,21 @@ def _sub_border_1d_indexes(self):
         ).astype("int")
 
     @array_util.Memoizer()
-    def blurring_mask_from_kernel_shape(self, kernel_shape):
+    def blurring_mask_from_kernel_shape(self, kernel_shape_2d):
         """Compute a blurring mask, which represents all masked pixels whose light will be blurred into unmasked \
         pixels via PSF convolution (see grid.Grid.blurring_grid_from_mask_and_psf_shape).
 
         Parameters
         ----------
-        kernel_shape : (int, int)
+        kernel_shape_2d : (int, int)
            The shape of the psf which defines the blurring region (e.g. the shape of the PSF)
         """
 
-        if kernel_shape[0] % 2 == 0 or kernel_shape[1] % 2 == 0:
+        if kernel_shape_2d[0] % 2 == 0 or kernel_shape_2d[1] % 2 == 0:
             raise exc.MaskException("psf_size of exterior region must be odd")
 
         blurring_mask = mask_util.blurring_mask_2d_from_mask_2d_and_kernel_shape_2d(
-            mask_2d=self.mask, kernel_shape_2d=kernel_shape
+            mask_2d=self.mask, kernel_shape_2d=kernel_shape_2d
         )
 
         return msk.Mask(

autoarray/masked/masked_data.py

@@ -43,7 +43,7 @@ def __init__(
         self,
         imaging,
         mask,
-        trimmed_psf_shape_2d=None,
+        psf_shape_2d=None,
         pixel_scale_interpolation_grid=None,
         inversion_pixel_limit=None,
         inversion_uses_border=True,
@@ -64,7 +64,7 @@ def __init__(
         sub_size : int
             The size of the sub-grid used for each lens SubGrid. E.g. a value of 2 grid each image-pixel on a 2x2 \
             sub-grid.
-        trimmed_psf_shape_2d : (int, int)
+        psf_shape_2d : (int, int)
             The shape of the PSF used for convolving model image generated using analytic light profiles. A smaller \
             shape will trim the PSF relative to the input image PSF, giving a faster analysis run-time.
         positions : [[]]
@@ -98,14 +98,14 @@ def __init__(
 
         if imaging.psf is not None:
 
-            if trimmed_psf_shape_2d is None:
-                self.trimmed_psf_shape_2d = imaging.psf.shape_2d
+            if psf_shape_2d is None:
+                self.psf_shape_2d = imaging.psf.shape_2d
             else:
-                self.trimmed_psf_shape_2d = trimmed_psf_shape_2d
+                self.psf_shape_2d = psf_shape_2d
 
             self.psf = kernel.Kernel.manual_2d(
                 array=imaging.psf.resized_from_new_shape(
-                    new_shape=self.trimmed_psf_shape_2d
+                    new_shape=self.psf_shape_2d
                 ).in_2d
             )
 
@@ -114,7 +114,7 @@ def __init__(
             if mask.pixel_scales is not None:
 
                 self.blurring_grid = self.grid.blurring_grid_from_kernel_shape(
-                    kernel_shape=self.trimmed_psf_shape_2d
+                    kernel_shape_2d=self.psf_shape_2d
                 )
 
                 if pixel_scale_interpolation_grid is not None:
@@ -132,15 +132,15 @@ def manual(
         cls,
         imaging,
         mask,
-        trimmed_psf_shape_2d=None,
+        psf_shape_2d=None,
         pixel_scale_interpolation_grid=None,
         inversion_pixel_limit=None,
         inversion_uses_border=True,
     ):
         return cls(
             imaging=imaging,
             mask=mask,
-            trimmed_psf_shape_2d=trimmed_psf_shape_2d,
+            psf_shape_2d=psf_shape_2d,
             pixel_scale_interpolation_grid=pixel_scale_interpolation_grid,
             inversion_pixel_limit=inversion_pixel_limit,
             inversion_uses_border=inversion_uses_border,
@@ -161,7 +161,7 @@ def binned_from_bin_up_factor(self, bin_up_factor):
         return self.__class__(
             imaging=binned_imaging,
             mask=binned_mask,
-            trimmed_psf_shape_2d=self.trimmed_psf_shape_2d,
+            psf_shape_2d=self.psf_shape_2d,
             pixel_scale_interpolation_grid=self.pixel_scale_interpolation_grid,
             inversion_pixel_limit=self.inversion_pixel_limit,
             inversion_uses_border=self.inversion_uses_border,
@@ -176,7 +176,7 @@ def signal_to_noise_limited_from_signal_to_noise_limit(self, signal_to_noise_lim
         return self.__class__(
             imaging=imaging_with_signal_to_noise_limit,
             mask=self.mask,
-            trimmed_psf_shape_2d=self.trimmed_psf_shape_2d,
+            psf_shape_2d=self.psf_shape_2d,
             pixel_scale_interpolation_grid=self.pixel_scale_interpolation_grid,
             inversion_pixel_limit=self.inversion_pixel_limit,
             inversion_uses_border=self.inversion_uses_border,
@@ -188,7 +188,7 @@ def __init__(
         self,
         interferometer,
         real_space_mask,
-        trimmed_primary_beam_shape_2d=None,
+        primary_beam_shape_2d=None,
         pixel_scale_interpolation_grid=None,
         inversion_pixel_limit=None,
         inversion_uses_border=True,
@@ -209,7 +209,7 @@ def __init__(
         sub_size : int
             The size of the sub-grid used for each lens SubGrid. E.g. a value of 2 grid each image-pixel on a 2x2 \
             sub-grid.
-        trimmed_primary_beam_shape_2d : (int, int)
+        primary_beam_shape_2d : (int, int)
             The shape of the primary_beam used for convolving model image generated using analytic light profiles. A smaller \
             shape will trim the primary_beam relative to the input image primary_beam, giving a faster analysis run-time.
         positions : [[]]
@@ -233,21 +233,21 @@ def __init__(
         )
 
         if self.interferometer.primary_beam is None:
-            self.trimmed_primary_beam_shape_2d = None
+            self.primary_beam_shape_2d = None
         elif (
-            trimmed_primary_beam_shape_2d is None
-            and self.interferometer.primary_beam is not None
+                primary_beam_shape_2d is None
+                and self.interferometer.primary_beam is not None
         ):
-            self.trimmed_primary_beam_shape_2d = (
+            self.primary_beam_shape_2d = (
                 self.interferometer.primary_beam.shape_2d
             )
         else:
-            self.trimmed_primary_beam_shape_2d = trimmed_primary_beam_shape_2d
+            self.primary_beam_shape_2d = primary_beam_shape_2d
 
-        if self.trimmed_primary_beam_shape_2d is not None:
+        if self.primary_beam_shape_2d is not None:
             self.primary_beam = kernel.Kernel.manual_2d(
                 array=interferometer.primary_beam.resized_from_new_shape(
-                    new_shape=self.trimmed_primary_beam_shape_2d
+                    new_shape=self.primary_beam_shape_2d
                 ).in_2d
             )
 
@@ -271,15 +271,15 @@ def manual(
         cls,
         interferometer,
         real_space_mask,
-        trimmed_primary_beam_shape_2d=None,
+        primary_beam_shape_2d=None,
         pixel_scale_interpolation_grid=None,
         inversion_pixel_limit=None,
         inversion_uses_border=True,
     ):
         return cls(
             interferometer,
             real_space_mask=real_space_mask,
-            trimmed_primary_beam_shape_2d=trimmed_primary_beam_shape_2d,
+            primary_beam_shape_2d=primary_beam_shape_2d,
             pixel_scale_interpolation_grid=pixel_scale_interpolation_grid,
             inversion_pixel_limit=inversion_pixel_limit,
             inversion_uses_border=inversion_uses_border,

autoarray/operators/convolution.py

@@ -267,7 +267,7 @@ def frame_at_coordinates_jit(coordinates, mask, mask_index_array, kernel_2d):
         ----------
         coordinates: (int, int)
             The coordinates of mask_index_array on which the frame should be centred
-        kernel_shape: (int, int)
+        kernel_shape_2d: (int, int)
             The shape of the kernel for which this frame will be used
         """
 

autoarray/simulator/simulator.py

@@ -55,7 +55,7 @@ def lsst(
         shape=(101, 101),
         pixel_scales=0.2,
         sub_size=8,
-        psf_shape=(31, 31),
+        psf_shape_2d=(31, 31),
         psf_sigma=0.5,
         exposure_time=100.0,
         background_sky_level=1.0,
@@ -67,7 +67,7 @@ def lsst(
 
         This can be customized by over-riding the default input values."""
         psf = aa.kernel.from_gaussian(
-            shape_2d=psf_shape, sigma=psf_sigma, pixel_scales=pixel_scales
+            shape_2d=psf_shape_2d, sigma=psf_sigma, pixel_scales=pixel_scales
         )
         return ImagingSimulator(
             shape_2d=shape,
@@ -87,7 +87,7 @@ def euclid(
         shape=(151, 151),
         pixel_scales=0.1,
         sub_size=8,
-        psf_shape=(31, 31),
+        psf_shape_2d=(31, 31),
         psf_sigma=0.1,
         exposure_time=565.0,
         background_sky_level=1.0,
@@ -99,7 +99,7 @@ def euclid(
 
         This can be customized by over-riding the default input values."""
         psf = aa.kernel.from_gaussian(
-            shape_2d=psf_shape, sigma=psf_sigma, pixel_scales=pixel_scales
+            shape_2d=psf_shape_2d, sigma=psf_sigma, pixel_scales=pixel_scales
         )
         return ImagingSimulator(
             shape_2d=shape,
@@ -119,7 +119,7 @@ def hst(
         shape=(251, 251),
         pixel_scales=0.05,
         sub_size=8,
-        psf_shape=(31, 31),
+        psf_shape_2d=(31, 31),
         psf_sigma=0.05,
         exposure_time=2000.0,
         background_sky_level=1.0,
@@ -131,7 +131,7 @@ def hst(
 
         This can be customized by over-riding the default input values."""
         psf = aa.kernel.from_gaussian(
-            shape_2d=psf_shape, sigma=psf_sigma, pixel_scales=pixel_scales
+            shape_2d=psf_shape_2d, sigma=psf_sigma, pixel_scales=pixel_scales
         )
         return ImagingSimulator(
             shape_2d=shape,
@@ -151,7 +151,7 @@ def hst_up_sampled(
         shape=(401, 401),
         pixel_scales=0.03,
         sub_size=8,
-        psf_shape=(31, 31),
+        psf_shape_2d=(31, 31),
         psf_sigma=0.05,
         exposure_time=2000.0,
         background_sky_level=1.0,
@@ -164,7 +164,7 @@ def hst_up_sampled(
 
         This can be customized by over-riding the default input values."""
         psf = aa.kernel.from_gaussian(
-            shape_2d=psf_shape, sigma=psf_sigma, pixel_scales=pixel_scales
+            shape_2d=psf_shape_2d, sigma=psf_sigma, pixel_scales=pixel_scales
         )
         return ImagingSimulator(
             shape_2d=shape,
@@ -184,7 +184,7 @@ def keck_adaptive_optics(
         shape=(751, 751),
         pixel_scales=0.01,
         sub_size=8,
-        psf_shape=(31, 31),
+        psf_shape_2d=(31, 31),
         psf_sigma=0.025,
         exposure_time=1000.0,
         background_sky_level=1.0,
@@ -196,7 +196,7 @@ def keck_adaptive_optics(
 
         This can be customized by over-riding the default input values."""
         psf = aa.kernel.from_gaussian(
-            shape_2d=psf_shape, sigma=psf_sigma, pixel_scales=pixel_scales
+            shape_2d=psf_shape_2d, sigma=psf_sigma, pixel_scales=pixel_scales
         )
         return ImagingSimulator(
             shape_2d=shape,

autoarray/structures/arrays.py

@@ -148,9 +148,9 @@ def resized_from_new_shape(self, new_shape):
 
         return resized_mask_2d.mapping.array_from_array_2d(array_2d=resized_array_2d)
 
-    def trimmed_from_kernel_shape(self, kernel_shape):
-        psf_cut_y = np.int(np.ceil(kernel_shape[0] / 2)) - 1
-        psf_cut_x = np.int(np.ceil(kernel_shape[1] / 2)) - 1
+    def trimmed_from_kernel_shape(self, kernel_shape_2d):
+        psf_cut_y = np.int(np.ceil(kernel_shape_2d[0] / 2)) - 1
+        psf_cut_x = np.int(np.ceil(kernel_shape_2d[1] / 2)) - 1
         array_y = np.int(self.mask.shape[0])
         array_x = np.int(self.mask.shape[1])
         trimmed_array_2d = self.in_2d[

autoarray/structures/grids.py

@@ -178,10 +178,10 @@ def in_1d_binned(self):
     def in_2d_binned(self):
         return self.mask.mapping.grid_2d_binned_from_sub_grid_1d(sub_grid_1d=self)
 
-    def blurring_grid_from_kernel_shape(self, kernel_shape):
+    def blurring_grid_from_kernel_shape(self, kernel_shape_2d):
 
         blurring_mask = self.mask.regions.blurring_mask_from_kernel_shape(
-            kernel_shape=kernel_shape
+            kernel_shape_2d=kernel_shape_2d
         )
 
         blurring_grid_1d = grid_util.grid_1d_via_mask_2d(
@@ -314,11 +314,11 @@ def relocated_grid_from_grid_jit(grid, border_grid):
 
         return grid
 
-    def padded_grid_from_kernel_shape(self, kernel_shape):
+    def padded_grid_from_kernel_shape(self, kernel_shape_2d):
 
         shape = self.mask.shape
 
-        padded_shape = (shape[0] + kernel_shape[0] - 1, shape[1] + kernel_shape[1] - 1)
+        padded_shape = (shape[0] + kernel_shape_2d[0] - 1, shape[1] + kernel_shape_2d[1] - 1)
 
         padded_mask = msk.Mask.unmasked(
             shape_2d=padded_shape,
@@ -524,7 +524,7 @@ def from_sub_grid_2d_and_mask(cls, sub_grid_2d, mask):
         return mask.mapping.grid_from_sub_grid_2d(sub_grid_2d=sub_grid_2d)
 
     @classmethod
-    def blurring_grid_from_mask_and_kernel_shape(cls, mask, kernel_shape):
+    def blurring_grid_from_mask_and_kernel_shape(cls, mask, kernel_shape_2d):
         """Setup a blurring-grid from a mask, where a blurring grid consists of all pixels that are masked, but they \
         are close enough to the unmasked pixels that a fraction of their light will be blurred into those pixels \
         via PSF convolution. For example, if our mask is as follows:
@@ -584,7 +584,7 @@ def blurring_grid_from_mask_and_kernel_shape(cls, mask, kernel_shape):
         """
 
         blurring_mask = mask.regions.blurring_mask_from_kernel_shape(
-            kernel_shape=kernel_shape
+            kernel_shape_2d=kernel_shape_2d
         )
 
         blurring_grid_1d = grid_util.grid_1d_via_mask_2d(

autoarray/util/mask_util.py

@@ -447,7 +447,7 @@ def blurring_mask_2d_from_mask_2d_and_kernel_shape_2d(mask_2d, kernel_shape_2d):
                      [True, False, True]
                      [True, True, True]])      
     
-    blurring_mask = blurring_mask_from_mask_and_psf_shape(mask=mask, psf_shape=(3,3)) 
+    blurring_mask = blurring_mask_from_mask_and_psf_shape(mask=mask, psf_shape_2d=(3,3)) 
     
     """
 
@@ -895,7 +895,7 @@ def sub_mask_2d_index_for_sub_mask_1d_index_via_mask_2d(mask_2d, sub_size):
                      [True, False, True]
                      [True, True, True]])
 
-    blurring_mask = blurring_mask_from_mask_and_psf_shape(mask=mask, psf_shape=(3,3))
+    blurring_mask = blurring_mask_from_mask_and_psf_shape(mask=mask, psf_shape_2d=(3,3))
 
     """
 

test_autoarray/mock/mock_mask.py

@@ -39,21 +39,21 @@ def __init__(
     ):
         pass
 
-    def blurring_mask_from_kernel_shape(self, kernel_shape):
+    def blurring_mask_from_kernel_shape(self, kernel_shape_2d):
         """Compute a blurring mask, which represents all masked pixels whose light will be blurred into unmasked \
         pixels via PSF convolution (see grid.Grid.blurring_grid_from_mask_and_psf_shape).
 
         Parameters
         ----------
-        kernel_shape : (int, int)
+        kernel_shape_2d : (int, int)
            The shape of the psf which defines the blurring region (e.aa. the shape of the PSF)
         """
 
-        if kernel_shape[0] % 2 == 0 or kernel_shape[1] % 2 == 0:
+        if kernel_shape_2d[0] % 2 == 0 or kernel_shape_2d[1] % 2 == 0:
             raise exc.MaskException("psf_size of exterior region must be odd")
 
         blurring_mask = mask_util.blurring_mask_2d_from_mask_2d_and_kernel_shape_2d(
-            self, kernel_shape
+            self, kernel_shape_2d
         )
 
         return MockMask(mask_2d=blurring_mask, pixel_scales=self.pixel_scales)

test_autoarray/unit/mask/test_regions.py

@@ -61,7 +61,7 @@ def test__blurring_mask_for_psf_shape__compare_to_array_util(self):
         )
 
         blurring_mask = mask.regions.blurring_mask_from_kernel_shape(
-            kernel_shape=(3, 3)
+            kernel_shape_2d=(3, 3)
         )
 
         assert (blurring_mask == blurring_mask_via_util).all()