def __init__(
self,
redshift,
pixelization=None,
regularization=None,
hyper_galaxy=None,
**kwargs,
):
"""Class representing a galaxy, which is composed of attributes used for fitting hyper_galaxies (e.g. light profiles, \
mass profiles, pixelizations, etc.).
All *has_* methods retun *True* if galaxy has that attribute, *False* if not.
Parameters
----------
redshift: float
The redshift of the galaxy.
light_profiles: [lp.LightProfile]
A list of the galaxy's light profiles.
mass_profiles: [mp.MassProfile]
A list of the galaxy's mass profiles.
hyper_galaxy : HyperGalaxy
The hyper_galaxies-parameters of the hyper_galaxies-galaxy, which is used for performing a hyper_galaxies-analysis on the noise-map.
Attributes
----------
pixelization : inversion.Pixelization
The pixelization of the galaxy used to reconstruct an observed image using an inversion.
regularization : inversion.Regularization
The regularization of the pixel-grid used to reconstruct an observed using an inversion.
"""
super().__init__()
self.redshift = redshift
self.hyper_model_image = None
self.hyper_galaxy_image = None
for name, val in kwargs.items():
setattr(self, name, val)
self.pixelization = pixelization
self.regularization = regularization
if pixelization is not None and regularization is None:
raise exc.GalaxyException(
"If the galaxy has a pixelization, it must also have a regularization."
)
if pixelization is None and regularization is not None:
raise exc.GalaxyException(
"If the galaxy has a regularization, it must also have a pixelization."
)
self.hyper_galaxy = hyper_galaxy
def mass_within_circle_in_units(
self,
radius: dim.Length,
unit_mass="angular",
redshift_source=None,
cosmology=cosmo.Planck15,
):
""" Integrate the mass profiles's convergence profile to compute the total mass within a circle of \
specified radius. This is centred on the mass profile.
The following unit_label for mass can be specified and output:
- Dimensionless angular unit_label (default) - 'angular'.
- Solar masses - 'angular' (multiplies the angular mass by the critical surface mass density).
Parameters
----------
radius : dim.Length
The radius of the circle to compute the dimensionless mass within.
unit_mass : str
The unit_label the mass is returned in (angular | angular).
critical_surface_density : float or None
The critical surface mass density of the strong lens configuration, which converts mass from angulalr \
unit_label to phsical unit_label (e.g. solar masses).
"""
if self.has_mass_profile:
return sum(
map(
lambda p: p.mass_within_circle_in_units(
radius=radius,
unit_mass=unit_mass,
redshift_object=self.redshift,
redshift_source=redshift_source,
cosmology=cosmology,
),
self.mass_profiles,
))
else:
raise exc.GalaxyException(
"You cannot perform a mass-based calculation on a galaxy which does not have a mass-profile"
)
def dark_mass_within_circle_in_units(
self,
radius: dim.Length,
unit_mass="angular",
redshift_source=None,
cosmology=cosmo.Planck15,
):
if self.has_dark_profile:
return sum([
profile.mass_within_circle_in_units(
radius=radius,
unit_mass=unit_mass,
redshift_object=self.redshift,
redshift_source=redshift_source,
cosmology=cosmology,
) for profile in self.dark_profiles
])
else:
raise exc.GalaxyException(
"You cannot perform a dark mass-based calculation on a galaxy which does not have a dark mass-profile"
)
def __init__(
self,
galaxy_data,
mask,
pixel_scale_interpolation_grid=None,
use_image=False,
use_convergence=False,
use_potential=False,
use_deflections_y=False,
use_deflections_x=False,
):
""" A galaxy-fit data_type is a collection of fit data_type components which are used to fit a galaxy to another galaxy. \
This is where a component of a galaxy's light profiles (e.g. image) or mass profiles (e.g. surface \
density, potential or deflection angles) are fitted to one another.
This is primarily performed for automatic prior linking, as a means to efficiently link the priors of a galaxy \
using one inferred parametrization of light or mass profiles to a new galaxy with a different parametrization \
of light or mass profiles.
This omits a number of the fit data_type components typically used when fitting an image (e.g. the observed image, PSF, \
exposure time map), but still has a number of the other components (e.g. an effective noise_map, grid_stacks).
Parameters
----------
galaxy_data : GalaxyData
The collection of data_type about the galaxy (image of its profile map, noise-map, etc.) that is fitted.
mask: aa.AbstractMask
The 2D masks that is applied to image fit data_type.
sub_size : int
The size of the sub-grid used for computing the SubGrid (see imaging.masks.SubGrid).
Attributes
----------
noise_map_1d : ndarray
The masked 1D arrays of the noise_map
grid_stacks : imaging.masks.GridStack
Grids of (y,x) Cartesian coordinates which map over the masked 1D fit data_type arrays's pixels (includes an \
grid, sub-grid, etc.)
"""
self.mask = mask
self.galaxy_data = galaxy_data
self.mapping = mask.mapping
self.pixel_scales = galaxy_data.pixel_scales
self.image = masked_structures.MaskedArray.manual_2d(
array=galaxy_data.image.in_2d_binned, mask=mask.mask_sub_1)
self.noise_map = masked_structures.MaskedArray.manual_2d(
array=galaxy_data.noise_map.in_2d_binned, mask=mask.mask_sub_1)
self.signal_to_noise_map = self.image / self.noise_map
self.sub_size = mask.sub_size
self.grid = grids.Grid.from_mask(mask=mask)
self.pixel_scale_interpolation_grid = pixel_scale_interpolation_grid
if pixel_scale_interpolation_grid is not None:
self.grid = self.grid.new_grid_with_interpolator(
pixel_scale_interpolation_grid=pixel_scale_interpolation_grid)
if all(not element for element in [
use_image,
use_convergence,
use_potential,
use_deflections_y,
use_deflections_x,
]):
raise exc.GalaxyException(
"The galaxy fit data_type has not been supplied with a use_ method."
)
if (sum([
use_image,
use_convergence,
use_potential,
use_deflections_y,
use_deflections_x,
]) > 1):
raise exc.GalaxyException(
"The galaxy fit data_type has not been supplied with multiple use_ methods, only supply "
"one.")
self.use_image = use_image
self.use_convergence = use_convergence
self.use_potential = use_potential
self.use_deflections_y = use_deflections_y
self.use_deflections_x = use_deflections_x