def make_analysis(self, dataset, xy_mask):
masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask)
transformers = []
for i in range(masked_dataset.uv_wavelengths.shape[0]):
transformers.append(
self.transformer_class(
uv_wavelengths=masked_dataset.uv_wavelengths[i],
grid=masked_dataset.grid_3d.grid_2d.in_radians))
"""
def get_continuum(masked_dataset, regions):
pass
continuum = np.zeros(
shape=(dataset.visibilities.shape[0], ),
dtype=bool
)
for region in self.regions:
continuum += region
def func(masked_dataset, continuum):
argspec = inspect.getargspec(MaskedDatasetLite.__init__)
args = {}
for argname in argspec.args:
if argname not in ["self"]:
if hasattr(masked_dataset, argname):
array = getattr(masked_dataset, argname)
args[argname] = reshape_array(
array=array[~continuum]
)
return MaskedDatasetLite(**args)
masked_dataset_continuum = func(masked_dataset, continuum)
#print(masked_dataset_continuum.uv_wavelengths.shape)
transformer_continuum = self.transformer_class(
uv_wavelengths=masked_dataset_continuum.uv_wavelengths,
grid=masked_dataset.grid_3d.grid_2d.in_radians
)
# dirty_image = transformer_continuum.image_from_visibilities(
# visibilities=masked_dataset_continuum.visibilities
# )
# plt.figure()
# plt.imshow(dirty_image[::-1], cmap="jet")
# plt.xticks([])
# plt.yticks([])
# plt.show()
"""
return Analysis(masked_dataset=masked_dataset,
transformers=transformers,
transformer_continuum=None,
lens_redshift=self.lens_redshift,
source_redshift=self.source_redshift,
image_path=self.optimizer.paths.image_path)
def make_analysis(self, dataset, xy_mask):
# NOTE: Multiple lines can be present in a cube, in which
# case region will be a list (renamed to regions)
masked_dataset = MaskedDataset(
dataset=dataset,
xy_mask=xy_mask,
region=self.region
)
masked_dataset_continuum = RegionMaskedDataset(
dataset=masked_dataset.dataset_outside_region,
uv_mask=masked_dataset.uv_mask_outside_region,
continuum=True
)
masked_dataset_line = RegionMaskedDataset(
dataset=masked_dataset.dataset_inside_region,
uv_mask=masked_dataset.uv_mask_inside_region,
continuum=False
)
transformers = []
for i in range(masked_dataset.uv_wavelengths.shape[0]):
transformers.append(
self.transformer_class(
uv_wavelengths=masked_dataset.uv_wavelengths[i],
grid=masked_dataset.grid_3d.grid_2d.in_radians
)
)
transformer_continuum = self.transformer_class(
uv_wavelengths=masked_dataset_continuum.uv_wavelengths,
grid=masked_dataset.grid_3d.grid_2d.in_radians
)
# # NOTE: EXPERIMENTAL
# holder = RegionMaskedDatasetsHolder(
# region_masked_datasets=[
# masked_dataset_continuum,
# masked_dataset_line
# ]
# )
# exit()
# TODO: region_masked_datasets can be a class that holds individual
# masked datasets and it's only function will be to differentiate between
# a masked_dataset corresponding to the continuum and the rest.
return Analysis(
masked_dataset=masked_dataset,
region_masked_datasets=[
masked_dataset_continuum,
masked_dataset_line
],
transformers=transformers,
transformer_continuum=transformer_continuum,
image_path=self.optimizer.paths.image_path
)
def make_analysis(self, dataset, xy_mask):
masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask)
transformer = self.transformer_class(
uv_wavelengths=masked_dataset.uv_wavelengths,
grid=masked_dataset.grid.in_radians)
return Analysis(masked_dataset=masked_dataset,
transformer=transformer,
self_calibration=self.self_calibration,
image_path=self.optimizer.paths.image_path)
def make_analysis(self, dataset, xy_mask):
masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask)
transformers = []
for i in range(masked_dataset.uv_wavelengths.shape[0]):
transformers.append(
self.transformer_class(
uv_wavelengths=masked_dataset.uv_wavelengths[i],
grid=masked_dataset.grid_3d.grid_2d.in_radians))
return Analysis(masked_dataset=masked_dataset,
transformers=transformers,
image_path=self.optimizer.paths.image_path)
def test(dataset,
xy_mask,
tracer,
self_calibration,
transformer_class=al.TransformerFINUFFT):
masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask)
grid = masked_dataset.grid
transformer = transformer_class(
uv_wavelengths=masked_dataset.uv_wavelengths, grid=grid.in_radians)
model_data = tracer.profile_visibilities_from_grid_and_transformer(
grid=grid, transformer=transformer)
if self_calibration:
phase_errors = calibration_utils.phase_errors_from_A_and_B_matrices(
phases=masked_dataset.phases,
model_phases=model_data.phases,
A=masked_dataset.A,
B=masked_dataset.B)
model_phases_corrected = np.add(
model_data.phases, np.matmul(masked_dataset.f.T, phase_errors))
model_data = aa.structures.visibilities.Visibilities(
visibilities_1d=np.stack(arrays=(
model_data.amplitudes * np.cos(model_phases_corrected),
model_data.amplitudes * np.sin(model_phases_corrected)),
axis=-1))
fit_temp = fit.DatasetFit(masked_dataset=masked_dataset,
model_data=model_data)
# print("likelihood = ", fit_temp.likelihood)
#
# fit_plots.residual_map(
# fit=fit_temp,
# transformer=transformer,
# output_filename=None,
# output_path=None,
# output_format="show",
# )
return fit_temp.likelihood
def test(dataset,
xy_mask,
tracer,
self_calibration,
transformer_class=al.TransformerFINUFFT):
masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask)
grid = masked_dataset.grid
transformer = transformer_class(
uv_wavelengths=masked_dataset.uv_wavelengths, grid=grid.in_radians)
model_data = tracer.profile_visibilities_from_grid_and_transformer(
grid=grid, transformer=transformer)
fit_plots.residual_map(fit=fit.DatasetFit(
masked_dataset=masked_dataset, model_data=model_data),
transformer=transformer,
output_format="show")
# ncols=8,
# cube_contours=cube,
#
# )
# exit()
line_emission_region = region(
n=dataset.uv_wavelengths.shape[0],
n_min=11,
n_max=23,
invert=False
)
masked_dataset = MaskedDataset(
dataset=dataset,
xy_mask=xy_mask,
region=line_emission_region
)
# plot_utils.plot_cube(
# cube=dirty_cube_from_visibilities(
# visibilities=masked_dataset.visibilities_outside_region,
# transformers=[transformer for (i, transformer) in enumerate(transformers)
# if not masked_dataset.region[i]
# ],
# shape=(masked_dataset.visibilities_outside_region.shape[0], ) + grid_3d.shape_2d,
# invert=True
# ),
# ncols=5,
#
# )
# exit()
# cube=autolens_plot_utils.dirty_cube_from_visibilities(
# visibilities=dataset.visibilities,
# transformers=transformers,
# shape=cube.shape,
# invert=True
# ),
# ncols=8,
# cube_contours=lensed_cube,
#
# )
# exit()
emission_line_region = Region.from_limits(n=n_channels, n_min=11, n_max=23)
masked_dataset = MaskedDataset(
dataset=dataset,
xy_mask=xy_mask,
)
# pixelization_shape_0 = 20
# pixelization_shape_1 = 20
# regularization_coefficient = 10.0
#
# source_galaxy = al.Galaxy(
# redshift=source_redshift,
# pixelization=al.pix.VoronoiMagnification(
# shape=(pixelization_shape_0, pixelization_shape_1)
# ),
# regularization=al.reg.Constant(
# coefficient=regularization_coefficient
# ),
# )
def make_analysis(self, dataset, xy_mask):
# NOTE: The masked_dataset is no longer being used, instead each compoent
# (i.e. continuum + emission line regions) each have their own masked_dataset
# which is initialized here.
def masked_datasets_from_regions(masked_dataset, regions):
args = {
"continuum":{}
}
idx = np.zeros(
shape=(masked_dataset.visibilities.shape[0], ),
dtype=bool
)
for i, region in enumerate(regions):
idx += region.idx
args["region_{}".format(i)] = {}
if all(idx):
continuum = False
else:
continuum = True
argspec = inspect.getargspec(MaskedDatasetLite.__init__)
#args = {}
for argname in argspec.args:
if argname not in ["self"]:
if hasattr(masked_dataset, argname):
array = getattr(masked_dataset, argname)
if continuum:
args["continuum"][argname] = reshape_array(
array=array[~idx]
)
for i, region in enumerate(regions):
args["region_{}".format(i)][argname] = reshape_array(
array=array[region.idx]
)
#args["region_{}".format(i)][argname] = np.average(a=array[region.idx], axis=0)
masked_datasets = {
"continuum":MaskedDatasetLite(**args["continuum"]) if continuum else None
}
for i, region in enumerate(regions):
masked_datasets["region_{}".format(i)] = MaskedDatasetLite(**args["region_{}".format(i)])
return masked_datasets
# NOTE: Multiple lines can be present in a cube, in which
# case region will be a list (renamed to regions) - DONE
# NOTE: Can we skip the initialization of the masked dataset?
masked_dataset = MaskedDataset(
dataset=dataset,
xy_mask=xy_mask,
)
masked_datasets = masked_datasets_from_regions(
masked_dataset=masked_dataset,
regions=self.regions
)
transformers = {}
for key in masked_datasets.keys():
if masked_datasets[key] is not None:
transformers[key] = self.transformer_class(
uv_wavelengths=masked_datasets[key].uv_wavelengths,
grid=masked_dataset.grid_3d.grid_2d.in_radians
)
else:
transformers[key] = None
return Analysis(
masked_datasets=masked_datasets,
transformers=transformers,
grid=masked_dataset.grid_3d.grid_2d,
image_path=self.optimizer.paths.image_path
)
def make_analysis(self, dataset, mask):
masked_dataset = MaskedDataset(dataset=dataset, mask=mask)
return Analysis(masked_dataset=masked_dataset,
image_path=self.optimizer.paths.image_path)
def test(dataset,
xy_mask,
profiles,
lens_redshift,
source_redshift,
transformer_class=al.TransformerFINUFFT):
def src_model_from_profiles(profiles, masked_dataset):
return sum([
profile.profile_cube_from_grid(
grid=masked_dataset.grid_3d.grid_2d,
shape_3d=masked_dataset.grid_3d.shape_3d,
z_step_kms=masked_dataset.z_step_kms)
for profile in profiles
])
masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask)
transformers = []
for i in range(masked_dataset.uv_wavelengths.shape[0]):
transformers.append(
transformer_class(
uv_wavelengths=masked_dataset.uv_wavelengths[i],
grid=masked_dataset.grid_3d.grid_2d.in_radians))
len_profiles = []
src_profiles = []
for profile in profiles:
if isinstance(profile, al.mp.MassProfile):
len_profiles.append(profile)
else:
src_profiles.append(profile)
galaxies = []
for profile in len_profiles:
galaxies.append(al.Galaxy(
redshift=lens_redshift,
mass=profile,
))
galaxies.append(
al.Galaxy(redshift=source_redshift, light=al.lp.LightProfile()))
tracer = al.Tracer.from_galaxies(galaxies=galaxies)
cube = src_model_from_profiles(profiles=src_profiles,
masked_dataset=masked_dataset)
lensed_cube = autolens_tracer_utils.lensed_cube_from_tracer(
tracer=tracer, grid=masked_dataset.grid_3d.grid_2d, cube=cube)
model_data = np.zeros(shape=masked_dataset.data.shape)
for i in range(model_data.shape[0]):
model_data[i] = transformers[i].visibilities_from_image(
image=Image(array_2d=lensed_cube[i]))
# dirty_cube = autolens_plot_utils.dirty_cube_from_visibilities(
# visibilities=masked_dataset.data,
# transformers=transformers,
# shape=masked_dataset.grid_shape_3d
# )
#
# dirty_model_cube = autolens_plot_utils.dirty_cube_from_visibilities(
# visibilities=model_data,
# transformers=transformers,
# shape=masked_dataset.grid_shape_3d
# )
#
#
# velocities = np.linspace(
# -n_channels * z_step_kms / 2.0,
# +n_channels * z_step_kms / 2.0,
# n_channels
# )
# dirty_moment_0 = spectral_utils.moment_0(
# cube=dirty_cube,
# velocities=velocities
# )
# dirty_model_moment_0 = spectral_utils.moment_0(
# cube=dirty_model_cube,
# velocities=velocities
# )
# plt.figure()
# plt.imshow(dirty_moment_0 - dirty_model_moment_0, cmap="jet")
# plt.show()
# exit()
fit_plots.residual_map(fit=fit.DatasetFit(
masked_dataset=masked_dataset, model_data=model_data),
transformers=transformers)
data=np.add(
cube,
noise_map
),
noise_map=noise_map,
z_step_kms=z_step_kms
)
# plot_utils.plot_cube(
# cube=dataset.data,
# ncols=8
# )
# exit()
masked_dataset = MaskedDataset(
dataset=dataset,
mask=mask_3d
)
# ================================================ #
# NOTE: ...
"""
model_temp = profiles.Kinematical(
centre=(0.0, 0.0),
z_centre=16.0,
intensity=1.0,
effective_radius=0.5,
inclination=30.0,
phi=50.0,
turnover_radius=0.05,
maximum_velocity=200.0,
