mega refactor done

Author: Jammy2211

autoarray/__init__.py

@@ -23,26 +23,21 @@
 from .fit.fit_imaging import FitImaging
 from .fit.fit_interferometer import FitInterferometer
 from .geometry.geometry_2d import Geometry2D
-from .inversion.pixelization.mappers.abstract import AbstractMapper
-from .inversion.pixelization import mesh
-from .inversion.pixelization import image_mesh
+from .inversion.mesh import mesh
+from .inversion.mesh import image_mesh
 from .inversion import regularization as reg
 from .settings import Settings
 from .inversion.inversion.abstract import AbstractInversion
 from .inversion.regularization.abstract import AbstractRegularization
 from .inversion.inversion.factory import inversion_from as Inversion
 from .inversion.inversion.dataset_interface import DatasetInterface
-from .inversion.pixelization.border_relocator import BorderRelocator
-from .inversion.pixelization.pixelization import Pixelization
-from .inversion.pixelization.mappers.abstract import AbstractMapper
-from .inversion.pixelization.mappers.rectangular import MapperRectangular
-from .inversion.pixelization.mappers.delaunay import MapperDelaunay
-from .inversion.pixelization.mappers.rectangular_uniform import MapperRectangularUniform
-from .inversion.pixelization.mappers.knn import MapperKNNInterpolator
-from .inversion.pixelization.image_mesh.abstract import AbstractImageMesh
-from .inversion.pixelization.mesh.abstract import AbstractMesh
-from .inversion.pixelization.interpolator.rectangular import InterpolatorRectangular
-from .inversion.pixelization.interpolator.delaunay import InterpolatorDelaunay
+from .inversion.mesh.border_relocator import BorderRelocator
+from .inversion.pixelization import Pixelization
+from .inversion.mappers.abstract import Mapper
+from .inversion.mesh.image_mesh.abstract import AbstractImageMesh
+from .inversion.mesh.mesh.abstract import AbstractMesh
+from .inversion.mesh.interpolator.rectangular import InterpolatorRectangular
+from .inversion.mesh.interpolator.delaunay import InterpolatorDelaunay
 from .inversion.inversion.imaging.mapping import InversionImagingMapping
 from .inversion.inversion.imaging.sparse import InversionImagingSparse
 from .inversion.inversion.imaging.inversion_imaging_util import ImagingSparseOperator
@@ -78,10 +73,10 @@
 from .structures.grids.uniform_2d import Grid2D
 from .operators.over_sampling.over_sampler import OverSampler
 from .structures.grids.irregular_2d import Grid2DIrregular
-from .inversion.pixelization.mesh_geometry.rectangular import MeshGeometryRectangular
-from .inversion.pixelization.mesh_geometry.delaunay import MeshGeometryDelaunay
-from .inversion.pixelization.interpolator.rectangular import InterpolatorRectangular
-from .inversion.pixelization.interpolator.delaunay import InterpolatorDelaunay
+from .inversion.mesh.mesh_geometry.rectangular import MeshGeometryRectangular
+from .inversion.mesh.mesh_geometry.delaunay import MeshGeometryDelaunay
+from .inversion.mesh.interpolator.rectangular import InterpolatorRectangular
+from .inversion.mesh.interpolator.delaunay import InterpolatorDelaunay
 from .structures.arrays.kernel_2d import Kernel2D
 from .structures.vectors.uniform import VectorYX2D
 from .structures.vectors.irregular import VectorYX2DIrregular

autoarray/dataset/grids.py

@@ -5,7 +5,7 @@
 from autoarray.structures.arrays.kernel_2d import Kernel2D
 from autoarray.structures.grids.uniform_2d import Grid2D
 
-from autoarray.inversion.pixelization.border_relocator import BorderRelocator
+from autoarray.inversion.mesh.border_relocator import BorderRelocator
 
 from autoarray import exc
 

autoarray/fixtures.py

@@ -365,7 +365,7 @@ def make_border_relocator_2d_7x7():
 
 def make_rectangular_mapper_7x7_3x3():
 
-    from autoarray.inversion.pixelization.mesh.rectangular_adapt_density import (
+    from autoarray.inversion.mesh.mesh.rectangular_adapt_density import (
         overlay_grid_from,
     )
 
@@ -377,13 +377,14 @@ def make_rectangular_mapper_7x7_3x3():
 
     mesh = aa.mesh.RectangularUniform(shape=shape_native)
 
-    return mesh.mapper_from(
-        mask=make_mask_2d_7x7(),
+    interpolator = mesh.interpolator_from(
         source_plane_data_grid=make_grid_2d_sub_2_7x7(),
         source_plane_mesh_grid=aa.Grid2DIrregular(source_plane_mesh_grid),
-        image_plane_mesh_grid=None,
         adapt_data=aa.Array2D.ones(shape_native, pixel_scales=0.1),
-        border_relocator=None,
+    )
+
+    return aa.Mapper(
+        interpolator=interpolator,
         regularization=make_regularization_constant(),
     )
 
@@ -408,14 +409,16 @@ def make_delaunay_mapper_9_3x3():
 
     mesh = aa.mesh.Delaunay()
 
-    return mesh.mapper_from(
-        mask=make_mask_2d_7x7(),
+    interpolator = mesh.interpolator_from(
         source_plane_data_grid=make_grid_2d_sub_2_7x7(),
         source_plane_mesh_grid=grid_9,
-        image_plane_mesh_grid=aa.Grid2D.uniform(shape_native=(3, 3), pixel_scales=0.1),
         adapt_data=aa.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1),
-        border_relocator=None,
+    )
+
+    return aa.Mapper(
+        interpolator=interpolator,
         regularization=make_regularization_constant(),
+        image_plane_mesh_grid=aa.Grid2D.uniform(shape_native=(3, 3), pixel_scales=0.1),
     )
 
 
@@ -439,14 +442,16 @@ def make_knn_mapper_9_3x3():
 
     mesh = aa.mesh.KNearestNeighbor(split_neighbor_division=1)
 
-    return mesh.mapper_from(
-        mask=make_mask_2d_7x7(),
+    interpolator = mesh.interpolator_from(
         source_plane_data_grid=make_grid_2d_sub_2_7x7(),
         source_plane_mesh_grid=grid_9,
-        image_plane_mesh_grid=aa.Grid2D.uniform(shape_native=(3, 3), pixel_scales=0.1),
         adapt_data=aa.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1),
-        border_relocator=None,
+    )
+
+    return aa.Mapper(
+        interpolator=interpolator,
         regularization=make_regularization_constant(),
+        image_plane_mesh_grid=aa.Grid2D.uniform(shape_native=(3, 3), pixel_scales=0.1),
     )
 
 

autoarray/inversion/inversion/abstract.py

@@ -9,7 +9,7 @@
 from autoarray.dataset.interferometer.dataset import Interferometer
 from autoarray.inversion.inversion.dataset_interface import DatasetInterface
 from autoarray.inversion.linear_obj.linear_obj import LinearObj
-from autoarray.inversion.pixelization.mappers.abstract import AbstractMapper
+from autoarray.inversion.mappers.abstract import Mapper
 from autoarray.inversion.regularization.abstract import AbstractRegularization
 from autoarray.settings import Settings
 from autoarray.preloads import Preloads
@@ -143,7 +143,7 @@ def param_range_list_from(self, cls: Type) -> List[List[int]]:
         - The first `Mapper` values are in the entries `[3:103]`.
         - The second `Mapper` values are in the entries `[103:303]
 
-        For this example, `param_range_list_from(cls=AbstractMapper)` therefore returns the
+        For this example, `param_range_list_from(cls=Mapper)` therefore returns the
         list `[[3, 103], [103, 303]]`.
 
         Parameters
@@ -239,7 +239,7 @@ def mapper_indices(self) -> np.ndarray:
 
         mapper_indices = []
 
-        param_range_list = self.param_range_list_from(cls=AbstractMapper)
+        param_range_list = self.param_range_list_from(cls=Mapper)
 
         for param_range in param_range_list:
 
@@ -713,7 +713,7 @@ def regularization_weights_from(self, index: int) -> np.ndarray:
     def regularization_weights_mapper_dict(self) -> Dict[LinearObj, np.ndarray]:
         regularization_weights_dict = {}
 
-        for index, mapper in enumerate(self.cls_list_from(cls=AbstractMapper)):
+        for index, mapper in enumerate(self.cls_list_from(cls=Mapper)):
             regularization_weights_dict[mapper] = self.regularization_weights_from(
                 index=index,
             )
@@ -773,7 +773,7 @@ def max_pixel_list_from(
         -------
 
         """
-        mapper = self.cls_list_from(cls=AbstractMapper)[mapper_index]
+        mapper = self.cls_list_from(cls=Mapper)[mapper_index]
         reconstruction = self.reconstruction_dict[mapper]
 
         max_pixel_list = []
@@ -818,7 +818,7 @@ def max_pixel_centre(self, mapper_index: int = 0) -> Grid2DIrregular:
         -------
         The centre of the brightest pixel in the mapper values.
         """
-        mapper = self.cls_list_from(cls=AbstractMapper)[mapper_index]
+        mapper = self.cls_list_from(cls=Mapper)[mapper_index]
         reconstruction = self.reconstruction_dict[mapper]
 
         max_pixel = np.argmax(reconstruction)

autoarray/inversion/inversion/imaging/abstract.py

@@ -4,7 +4,7 @@
 from autoarray.dataset.imaging.dataset import Imaging
 from autoarray.inversion.inversion.dataset_interface import DatasetInterface
 from autoarray.inversion.linear_obj.func_list import AbstractLinearObjFuncList
-from autoarray.inversion.pixelization.mappers.abstract import AbstractMapper
+from autoarray.inversion.mappers.abstract import Mapper
 from autoarray.inversion.inversion.abstract import AbstractInversion
 from autoarray.inversion.linear_obj.linear_obj import LinearObj
 from autoarray.settings import Settings
@@ -255,7 +255,7 @@ def mapper_operated_mapping_matrix_dict(self) -> Dict:
         """
         mapper_operated_mapping_matrix_dict = {}
 
-        for mapper in self.cls_list_from(cls=AbstractMapper):
+        for mapper in self.cls_list_from(cls=Mapper):
             operated_mapping_matrix = self.psf.convolved_mapping_matrix_from(
                 mapping_matrix=mapper.mapping_matrix, mask=self.mask, xp=self._xp
             )

autoarray/inversion/inversion/imaging/mapping.py

@@ -7,7 +7,7 @@
 from autoarray.inversion.inversion.dataset_interface import DatasetInterface
 from autoarray.inversion.inversion.imaging.abstract import AbstractInversionImaging
 from autoarray.inversion.linear_obj.linear_obj import LinearObj
-from autoarray.inversion.pixelization.mappers.abstract import AbstractMapper
+from autoarray.inversion.mappers.abstract import Mapper
 from autoarray.settings import Settings
 from autoarray.preloads import Preloads
 from autoarray.structures.arrays.uniform_2d import Array2D

autoarray/inversion/inversion/imaging/sparse.py

@@ -9,7 +9,7 @@
 from autoarray.inversion.linear_obj.linear_obj import LinearObj
 from autoarray.settings import Settings
 from autoarray.inversion.linear_obj.func_list import AbstractLinearObjFuncList
-from autoarray.inversion.pixelization.mappers.abstract import AbstractMapper
+from autoarray.inversion.mappers.abstract import Mapper
 from autoarray.preloads import Preloads
 from autoarray.structures.arrays.uniform_2d import Array2D
 
@@ -72,13 +72,13 @@ def _data_vector_mapper(self) -> np.ndarray:
         in the inversion, and is separated into a separate method to enable preloading of the mapper `data_vector`.
         """
 
-        if not self.has(cls=AbstractMapper):
+        if not self.has(cls=Mapper):
             return None
 
         data_vector = self._xp.zeros(self.total_params)
 
-        mapper_list = self.cls_list_from(cls=AbstractMapper)
-        mapper_param_range = self.param_range_list_from(cls=AbstractMapper)
+        mapper_list = self.cls_list_from(cls=Mapper)
+        mapper_param_range = self.param_range_list_from(cls=Mapper)
 
         for mapper_index, mapper in enumerate(mapper_list):
 
@@ -121,7 +121,7 @@ def data_vector(self) -> np.ndarray:
         """
         if self.has(cls=AbstractLinearObjFuncList):
             return self._data_vector_func_list_and_mapper
-        elif self.total(cls=AbstractMapper) == 1:
+        elif self.total(cls=Mapper) == 1:
             return self._data_vector_x1_mapper
         return self._data_vector_multi_mapper
 
@@ -158,7 +158,7 @@ def _data_vector_multi_mapper(self) -> np.ndarray:
 
         data_vector_list = []
 
-        for mapper in self.cls_list_from(cls=AbstractMapper):
+        for mapper in self.cls_list_from(cls=Mapper):
 
             rows, cols, vals = mapper.sparse_triplets_data
 
@@ -243,7 +243,7 @@ def curvature_matrix(self) -> np.ndarray:
         """
         if self.has(cls=AbstractLinearObjFuncList):
             curvature_matrix = self._curvature_matrix_func_list_and_mapper
-        elif self.total(cls=AbstractMapper) == 1:
+        elif self.total(cls=Mapper) == 1:
             curvature_matrix = self._curvature_matrix_x1_mapper
         else:
             curvature_matrix = self._curvature_matrix_multi_mapper
@@ -276,13 +276,13 @@ def _curvature_matrix_mapper_diag(self) -> Optional[np.ndarray]:
         other calculations to enable preloading of this calculation.
         """
 
-        if not self.has(cls=AbstractMapper):
+        if not self.has(cls=Mapper):
             return None
 
         curvature_matrix = self._xp.zeros((self.total_params, self.total_params))
 
-        mapper_list = self.cls_list_from(cls=AbstractMapper)
-        mapper_param_range_list = self.param_range_list_from(cls=AbstractMapper)
+        mapper_list = self.cls_list_from(cls=Mapper)
+        mapper_param_range_list = self.param_range_list_from(cls=Mapper)
 
         for i in range(len(mapper_list)):
             mapper_i = mapper_list[i]
@@ -304,13 +304,13 @@ def _curvature_matrix_mapper_diag(self) -> Optional[np.ndarray]:
             else:
                 curvature_matrix = curvature_matrix.at[start:end, start:end].set(diag)
 
-            if self.total(cls=AbstractMapper) == 1:
+            if self.total(cls=Mapper) == 1:
                 return curvature_matrix
 
         return curvature_matrix
 
     def _curvature_matrix_off_diag_from(
-        self, mapper_0: AbstractMapper, mapper_1: AbstractMapper
+        self, mapper_0: Mapper, mapper_1: Mapper
     ) -> np.ndarray:
         """
         The `curvature_matrix` is a 2D matrix which uses the mappings between the data and the linear objects to
@@ -362,11 +362,11 @@ def _curvature_matrix_multi_mapper(self) -> np.ndarray:
 
         curvature_matrix = self._curvature_matrix_mapper_diag
 
-        if self.total(cls=AbstractMapper) == 1:
+        if self.total(cls=Mapper) == 1:
             return curvature_matrix
 
-        mapper_list = self.cls_list_from(cls=AbstractMapper)
-        mapper_param_range_list = self.param_range_list_from(cls=AbstractMapper)
+        mapper_list = self.cls_list_from(cls=Mapper)
+        mapper_param_range_list = self.param_range_list_from(cls=Mapper)
 
         for i in range(len(mapper_list)):
             mapper_i = mapper_list[i]
@@ -401,8 +401,8 @@ def _curvature_matrix_func_list_and_mapper(self) -> np.ndarray:
 
         curvature_matrix = self._curvature_matrix_multi_mapper
 
-        mapper_list = self.cls_list_from(cls=AbstractMapper)
-        mapper_param_range_list = self.param_range_list_from(cls=AbstractMapper)
+        mapper_list = self.cls_list_from(cls=Mapper)
+        mapper_param_range_list = self.param_range_list_from(cls=Mapper)
 
         linear_func_list = self.cls_list_from(cls=AbstractLinearObjFuncList)
         linear_func_param_range_list = self.param_range_list_from(
@@ -491,7 +491,7 @@ def _mapped_reconstructed_data_dict_from(
         """
         Shared implementation for mapping a reconstruction to image-plane arrays for each linear object.
 
-        For AbstractMapper objects this uses the sparse operator mapping, and optionally applies the PSF.
+        For Mapper objects this uses the sparse operator mapping, and optionally applies the PSF.
         For linear-func objects this uses either the operated or unoperated mapping matrix dict.
         """
         mapped_dict = {}
@@ -504,7 +504,7 @@ def _mapped_reconstructed_data_dict_from(
 
             reconstruction = reconstruction_dict[linear_obj]
 
-            if isinstance(linear_obj, AbstractMapper):
+            if isinstance(linear_obj, Mapper):
 
                 rows, cols, vals = linear_obj.sparse_triplets_curvature