def from_fits(cls, file_path, quadrant_letter):
"""
Use the input .fits file and quadrant letter to extract the quadrant from the full CCD, perform
the rotations required to give correct arctic clocking and convert the image from units of COUNTS / CPS to
ELECTRONS.
See the docstring of the `FrameACS` class for a complete description of the Euclid FPA, quadrants and
rotations.
"""
hdu = fits_hdu_from_quadrant_letter(quadrant_letter=quadrant_letter)
array = array_2d_util.numpy_array_2d_from_fits(file_path=file_path,
hdu=hdu)
return cls.from_ccd(array_electrons=array,
quadrant_letter=quadrant_letter)
def from_fits(cls, file_path, hdu):
"""
Create `Visibilities` (see `AbstractVisibilities.__new__`) by loading the(real, imag) values from a .fits file.
The `.fits` file stores these values as a real set of values of shape [total_visibilities, 2] which are
converted to a 1d complex NumPy array.
Parameters
----------
file_path : str
The path the file is loaded from, including the filename and the ``.fits`` extension,
e.g. '/path/to/filename.fits'
hdu : int
The Header-Data Unit of the .fits file the visibilitiy data is loaded from.
"""
visibilities_1d = array_2d_util.numpy_array_2d_from_fits(
file_path=file_path, hdu=hdu)
return cls.manual_slim(visibilities=visibilities_1d)
def from_fits(
cls,
file_path: str,
pixel_scales: (float, float),
hdu: int = 0,
sub_size: int = 1,
origin: (float, float) = (0.0, 0.0),
resized_mask_shape: (int, int) = None,
) -> "Mask2D":
"""
Loads the image from a .fits file.
Parameters
----------
file_path : str
The full path of the fits file.
hdu : int
The HDU number in the fits file containing the image image.
pixel_scales : float or (float, float)
The scaled units to pixel units conversion factor of each pixel.
sub_size : int
The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin : (float, float)
The (y,x) scaled units origin of the mask's coordinate system.
"""
if type(pixel_scales) is not tuple:
if type(pixel_scales) is float or int:
pixel_scales = (float(pixel_scales), float(pixel_scales))
mask = cls(
array_2d_util.numpy_array_2d_from_fits(file_path=file_path,
hdu=hdu),
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin,
)
if resized_mask_shape is not None:
mask = mask.resized_mask_from_new_shape(
new_shape=resized_mask_shape)
return mask
def from_fits(cls, file_path, pixel_scales, sub_size=1, origin=(0.0, 0.0)):
"""Create a Grid2D (see *Grid2D.__new__*) from a mask, where only unmasked pixels are included in the grid (if the
grid is represented in its native 2D masked values are (0.0, 0.0)).
The mask's pixel_scales, sub_size and origin properties are used to compute the grid (y,x) coordinates.
Parameters
----------
mask : Mask2D
The mask whose masked pixels are used to setup the sub-pixel grid.
"""
sub_grid_2d = array_2d_util.numpy_array_2d_from_fits(
file_path=file_path, hdu=0)
return Grid2D.manual(
grid=sub_grid_2d,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin,
)
def from_fits(
cls,
visibilities_path,
noise_map_path,
uv_wavelengths_path,
real_space_mask,
visibilities_hdu=0,
noise_map_hdu=0,
uv_wavelengths_hdu=0,
settings=SettingsInterferometer(),
):
"""Factory for loading the interferometer data_type from .fits files, as well as computing properties like the noise-map,
exposure-time map, etc. from the interferometer-data_type.
This factory also includes a number of routines for converting the interferometer-data_type from unit_label not supported by PyAutoLens \
(e.g. adus, electrons) to electrons per second.
Parameters
----------
"""
visibilities = vis.Visibilities.from_fits(
file_path=visibilities_path, hdu=visibilities_hdu
)
noise_map = vis.VisibilitiesNoiseMap.from_fits(
file_path=noise_map_path, hdu=noise_map_hdu
)
uv_wavelengths = array_2d_util.numpy_array_2d_from_fits(
file_path=uv_wavelengths_path, hdu=uv_wavelengths_hdu
)
return Interferometer(
real_space_mask=real_space_mask,
visibilities=visibilities,
noise_map=noise_map,
uv_wavelengths=uv_wavelengths,
settings=settings,
)
def from_fits(cls, file_path, pixel_scales, hdu=0, sub_size=1, origin=(0.0, 0.0)):
"""
Create an Array2D (see `AbstractArray2D.__new__`) by loading the array values from a .fits file.
Parameters
----------
file_path : str
The path the file is loaded from, including the filename and the ``.fits`` extension,
e.g. '/path/to/filename.fits'
hdu : int
The Header-Data Unit of the .fits file the array data is loaded from.
pixel_scales: (float, float) or float
The (y,x) scaled units to pixel units conversion factors of every pixel. If this is input as a ``float``,
it is converted to a (float, float) structure.
sub_size : int
The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin : (float, float)
The (y,x) scaled units origin of the mask's coordinate system.
"""
array_2d = array_2d_util.numpy_array_2d_from_fits(file_path=file_path, hdu=hdu)
return cls.manual_native(
array=array_2d, pixel_scales=pixel_scales, sub_size=sub_size, origin=origin
)
def from_fits(
cls,
file_path,
quadrant_letter,
bias_subtract_via_prescan=False,
bias_path=None,
use_calibrated_gain=True,
):
"""
Use the input .fits file and quadrant letter to extract the quadrant from the full CCD, perform
the rotations required to give correct arctic clocking and convert the image from units of COUNTS / CPS to
ELECTRONS.
See the docstring of the `FrameACS` class for a complete description of the Euclid FPA, quadrants and
rotations.
"""
hdu = fits_hdu_from_quadrant_letter(quadrant_letter=quadrant_letter)
header_sci_obj = array_2d_util.header_obj_from_fits(
file_path=file_path, hdu=0)
header_hdu_obj = array_2d_util.header_obj_from_fits(
file_path=file_path, hdu=hdu)
header = HeaderACS(
header_sci_obj=header_sci_obj,
header_hdu_obj=header_hdu_obj,
hdu=hdu,
quadrant_letter=quadrant_letter,
)
if header.header_sci_obj["TELESCOP"] != "HST":
raise exc.ArrayException(
f"The file {file_path} does not point to a valid HST ACS dataset."
)
if header.header_sci_obj["INSTRUME"] != "ACS":
raise exc.ArrayException(
f"The file {file_path} does not point to a valid HST ACS dataset."
)
array = array_2d_util.numpy_array_2d_from_fits(
file_path=file_path, hdu=hdu, do_not_scale_image_data=True)
array = header.array_from_original_to_electrons(array=array)
if use_calibrated_gain:
array = array * header.calibrated_gain
else:
array = array * header.gain
if bias_path is not None:
bias = array_2d_util.numpy_array_2d_from_fits(
file_path=bias_path, hdu=hdu, do_not_scale_image_data=True)
header_sci_obj = array_2d_util.header_obj_from_fits(
file_path=bias_path, hdu=0)
header_hdu_obj = array_2d_util.header_obj_from_fits(
file_path=bias_path, hdu=hdu)
bias_header = HeaderACS(
header_sci_obj=header_sci_obj,
header_hdu_obj=header_hdu_obj,
hdu=hdu,
quadrant_letter=quadrant_letter,
)
if bias_header.original_units != "COUNTS":
raise exc.ArrayException(
"Cannot use bias frame not in counts.")
bias = bias * bias_header.calibrated_gain
else:
bias = None
return cls.from_ccd(
array_electrons=array,
quadrant_letter=quadrant_letter,
header=header,
bias_subtract_via_prescan=bias_subtract_via_prescan,
bias=bias,
)
