def two_step_optimize(self, macromodel=None, datatofit=None, realizations=None, multiplane=False, method=None, ray_trace=None, sigmas=None,
identifier=None, srcx=None, srcy=None, res=None,
source_shape='GAUSSIAN', source_size=None, print_mag=False, raytrace_with=None,
filter_by_position=False, polar_grid=False, filter_kwargs={},solver_type='PROFILE_SHEAR',
N_iter_max=100,shr_coords=1):
# optimizes the macromodel first, then uses it to optimize with additional halos in the lens model
assert datatofit is not None
if sigmas is None:
sigmas = default_sigmas
if raytrace_with is None:
raytrace_with = raytrace_with_default
if source_size is None:
source_size = default_source_size_kpc
if source_shape is None:
source_shape = default_source_shape
if res is None:
res = default_res(source_size)
if method is None:
method = default_solve_method
if identifier is None:
identifier = default_file_identifier
if method == 'lensmodel':
_,macromodel_init = self.macromodel_initialize(macromodel=copy.deepcopy(macromodel), datatofit=datatofit,
multiplane=multiplane, method='lensmodel', sigmas=sigmas,
identifier=identifier, res=res,
source_shape=source_shape, source_size=source_size, print_mag=print_mag,
shr_coords=shr_coords)
optimized_data, newsystem = self.fit(macromodel=macromodel_init, datatofit=datatofit,
realizations=realizations, multiplane=multiplane,
ray_trace=ray_trace, sigmas=sigmas, identifier=identifier, srcx=srcx,
srcy=srcy, res=res,method='lensmodel',
source_shape=source_shape, source_size=source_size,
print_mag=print_mag, raytrace_with=raytrace_with,
filter_by_position=filter_by_position, polar_grid=polar_grid,
filter_kwargs=filter_kwargs,shr_coords=shr_coords)
else:
optimized_data, newsystem = self.fit(macromodel=macromodel, datatofit=datatofit,
realizations=realizations, multiplane=multiplane, method=method,
ray_trace=ray_trace, sigmas=sigmas, identifier=identifier, srcx=srcx,
srcy=srcy, res=res,
source_shape=source_shape, source_size=source_size,
print_mag=print_mag, raytrace_with=raytrace_with,
filter_by_position=filter_by_position, polar_grid=polar_grid,
filter_kwargs=filter_kwargs, solver_type=solver_type,N_iter_max=N_iter_max)
return optimized_data,newsystem
def solve_lens_equation(self, full_system=None, macromodel=None, realizations=None, multiplane=None, method=None,
ray_trace=True, identifier=None, srcx=None, srcy=None, res=None,
source_shape='GAUSSIAN', source_size_kpc=None, sort_by_pos=None, filter_subhalos=False,
filter_by_pos=False, filter_kwargs={}, raytrace_with=None, polar_grid=False, shr_coords=1,
brightimg=True, LOS_mass_sheet_back = 6, LOS_mass_sheet_front = 6, centroid_0 = [0, 0],
satellites = None, adaptive_grid=False):
if raytrace_with is None:
raytrace_with = raytrace_with_default
if source_shape is None:
source_shape = default_source_shape
if source_size_kpc is None:
source_size_kpc = default_source_size_kpc
if res is None:
res = default_res(source_size_kpc)
if method is None:
method = default_solve_method
if identifier is None:
identifier = default_file_identifier
lens_systems = []
if full_system is None:
assert macromodel is not None
if realizations is not None:
for real in realizations:
lens_systems.append(self.build_system(main=macromodel, realization=real, multiplane=multiplane, LOS_mass_sheet_back = LOS_mass_sheet_back,
LOS_mass_sheet_front = LOS_mass_sheet_front, satellites=satellites))
else:
lens_systems.append(self.build_system(main=copy.deepcopy(macromodel), realization=None, multiplane=multiplane,LOS_mass_sheet_back = LOS_mass_sheet_back,
LOS_mass_sheet_front = LOS_mass_sheet_front, satellites=satellites))
else:
lens_systems.append(copy.deepcopy(full_system))
assert method is not None
assert method in ['lensmodel', 'lenstronomy']
data = self._solve_4imgs(lens_systems=lens_systems, method=method, identifier=identifier, srcx=srcx + centroid_0[0],
srcy=srcy + centroid_0[1],
res=res, source_shape=source_shape, ray_trace=ray_trace,
raytrace_with=raytrace_with, source_size_kpc=source_size_kpc, polar_grid=polar_grid,
shr_coords=shr_coords,brightimg=brightimg, adaptive_grid=adaptive_grid)
if sort_by_pos is not None:
data[0].sort_by_pos(sort_by_pos.x,sort_by_pos.y)
return data
def optimize_4imgs_lenstronomy(self, lens_systems=None, datatofit=None, macromodel=None, realization=None, multiplane=None, source_shape='GAUSSIAN',
source_size_kpc=None, grid_res = None, tol_source=1e-5, tol_mag = 0.2, tol_centroid = 0.05, centroid_0=[0, 0],
n_particles = 50, n_iterations = 250, polar_grid = False,
optimize_routine = 'fixed_powerlaw_shear', verbose=False, re_optimize=False,
particle_swarm = True, restart=1,
constrain_params=None, pso_convergence_mean=5000,
pso_compute_magnification=200, tol_simplex_params=5e-3, tol_simplex_func = 0.05,
simplex_n_iter=300, LOS_mass_sheet_front = 7.7, LOS_mass_sheet_back = 8,
chi2_mode='source', tol_image = 0.005, satellites=None, use_finite_source=True,
adaptive_grid=False, grid_rmax_scale=1):
if source_shape is None:
source_shape = default_source_shape
if source_size_kpc is None:
source_size_kpc = default_source_size_kpc
if grid_res is None:
grid_res = default_res(source_size_kpc)
if lens_systems is None:
lens_systems = []
if realization is not None:
lens_systems.append(self.build_system(main=macromodel, realization=realization,
multiplane=multiplane,LOS_mass_sheet_front=LOS_mass_sheet_front,
LOS_mass_sheet_back=LOS_mass_sheet_back, satellites=satellites))
else:
lens_systems.append(self.build_system(main=copy.deepcopy(macromodel),multiplane=multiplane, LOS_mass_sheet_front=LOS_mass_sheet_front,
LOS_mass_sheet_back=LOS_mass_sheet_back, satellites=satellites))
optimized_data, model, _, info = self._optimize_4imgs_lenstronomy(lens_systems, data2fit=datatofit, tol_source=tol_source,
tol_mag=tol_mag, tol_centroid=tol_centroid, centroid_0=centroid_0,
n_particles=n_particles, n_iterations=n_iterations,
res=grid_res, source_shape=source_shape,
source_size_kpc=source_size_kpc, polar_grid=polar_grid,
optimizer_routine=optimize_routine, verbose=verbose, re_optimize=re_optimize,
particle_swarm=particle_swarm, restart=restart,
constrain_params=constrain_params, pso_convergence_mean=pso_convergence_mean,
pso_compute_magnification=pso_compute_magnification,
tol_simplex_params=tol_simplex_params, tol_simplex_func = tol_simplex_func,
simplex_n_iter=simplex_n_iter, chi2_mode = chi2_mode, tol_image = tol_image,
finite_source_magnification=use_finite_source,
adaptive_grid=adaptive_grid, grid_rmax_scale=grid_rmax_scale)
return optimized_data, model, info
def _trace(self, lens_system, data=None, multiplane=None,res=None, source_shape=None, source_size=None,
raytrace_with=None, srcx=None, srcy=None, build=False, realizations=None):
if raytrace_with is None:
raytrace_with = raytrace_with_default
if source_shape is None:
source_shape = default_source_shape
if source_size is None:
source_size = default_source_size_kpc
if res is None:
res = default_res(source_size)
if build:
lens_system = self.build_system(main=lens_system, realization=realizations, multiplane=multiplane)
if raytrace_with == 'lensmodel':
xsrc,ysrc = data.srcx,data.srcy
if srcx is not None:
xsrc = srcx
if srcy is not None:
ysrc = srcy
fluxes = self.do_raytrace_lensmodel(lens_system=lens_system,xpos=data.x,ypos=data.y,xsrc=xsrc,ysrc=ysrc,
multiplane=multiplane,res=res,source_shape=source_shape,source_size=source_size,
cosmology=self.cosmo,zsrc=self.cosmo.zsrc,raytrace_with=raytrace_with)
elif raytrace_with == 'lenstronomy':
lenstronomy_wrap = LenstronomyWrap(multiplane=multiplane,cosmo=self.cosmo,z_source=self.cosmo.zsrc)
lenstronomy_wrap.assemble(lens_system)
fluxes = self.do_raytrace_lenstronomy(lenstronomy_wrap,data.x,data.y,multiplane=multiplane,res=res,
source_shape=source_shape,source_size=source_size,cosmology=self.cosmo.cosmo,zsrc=self.cosmo.zsrc)
return fluxes*max(fluxes)**-1
def fit(self, macromodel=None, datatofit=None, realizations=None, multiplane = None, method=None, ray_trace=True, sigmas=None,
identifier=None, srcx=None, srcy=None, res=None,
source_shape='GAUSSIAN', source_size=None, print_mag=False, raytrace_with=None, filter_by_position=False,
polar_grid=False,filter_kwargs={},which_chi = 'src',solver_type='PROFILE_SHEAR',N_iter_max=100,shr_coords=1):
# uses source plane chi^2
if which_chi == 'src':
basic_or_full = 'basic'
else:
basic_or_full = 'full'
if raytrace_with is None:
raytrace_with = raytrace_with_default
if source_shape is None:
source_shape = default_source_shape
if source_size is None:
source_size = default_source_size_kpc
if res is None:
res = default_res(source_size)
if method is None:
method = default_solve_method
if sigmas is None:
sigmas = default_sigmas
if method is None:
method = default_solve_method
if identifier is None:
identifier = default_file_identifier
lens_systems= []
################################################################################
# If macromodel is a list same length as realizations, build the systems and fit each one
if isinstance(macromodel,list):
assert len(macromodel) == len(realizations), 'if macromodel is a list, must have same number of elements as realizations'
for macro,real in zip(macromodel,realizations):
lens_systems.append(self.build_system(main=macro, realization=real, multiplane=multiplane))
else:
if realizations is not None:
for real in realizations:
lens_systems.append(self.build_system(main=copy.deepcopy(macromodel), realization=real,
multiplane=multiplane))
else:
lens_systems.append(self.build_system(main=copy.deepcopy(macromodel),multiplane=multiplane))
if method == 'lenstronomy':
optimized_data, model = self.optimize_4imgs_lenstronomy(lens_systems=lens_systems, datatofit=datatofit,
multiplane = multiplane, res=res, source_shape=source_shape,
source_size_kpc=source_size, raytrace_with=raytrace_with, polar_grid=polar_grid, initialize = False,
solver_type=solver_type, n_particles=40, n_iterations=200, tol_source=1e-3, tol_centroid=0.05,
tol_mag=0.2, centroid_0=[0,0])
else:
optimized_data, model = self._optimize_4imgs_lensmodel(lens_systems=lens_systems, data2fit=datatofit,
method=method,
sigmas=sigmas, identifier=identifier,
res=res, source_shape=source_shape,
ray_trace=ray_trace,
source_size_kpc=source_size, print_mag=print_mag,
opt_routine=basic_or_full,
raytrace_with=raytrace_with, polar_grid=polar_grid,
solver_type=solver_type, shr_coords=shr_coords)
return optimized_data,model
def hierarchical_optimization(self, datatofit=None, macromodel=None, realization=None, multiplane=True,
source_shape='GAUSSIAN',
source_size_kpc=None, grid_res=None, tol_source=1e-5, tol_mag=0.2, tol_centroid=0.05,
centroid_0=[0, 0],
n_particles=50, n_iterations=250, polar_grid=False,
optimize_routine='fixed_powerlaw_shear', verbose=False, re_optimize=False,
particle_swarm=True, restart=1,
constrain_params=None, pso_convergence_mean=5000,
pso_compute_magnification=200, tol_simplex_params=1e-3, tol_simplex_func=0.01,
simplex_n_iter=300, background_globalmin_masses=None,
background_aperture_masses=None, background_filters=None,
min_mass=6, m_break=0, LOS_mass_sheet_front = 7.7, LOS_mass_sheet_back = 8, satellites=None,
adaptive_grid=False, grid_rmax_scale=1, check_foreground_fit=False,
foreground_aperture_masses=None,foreground_globalmin_masses=None,foreground_filters=None,
reoptimize_scale_filters=None, particle_swarm_reopt_filters=None,
reoptimize_scale_background=None,particle_swarm_reopt_background=None,optimize_iteration_background=None):
if source_shape is None:
source_shape = default_source_shape
if source_size_kpc is None:
source_size_kpc = default_source_size_kpc
if grid_res is None:
grid_res = default_res(source_size_kpc)
assert multiplane is True
if centroid_0[0] != 0 or centroid_0[1] != 0:
realization = realization.shift_centroid(centroid_0)
assert isinstance(source_size_kpc, float) or isinstance(source_size_kpc, int)
foreground_realization, background_realization = split_realization(datatofit, realization)
if verbose: print('optimizing foreground... ')
if foreground_aperture_masses is not None:
assert foreground_globalmin_masses is not None
assert foreground_filters is not None
assert reoptimize_scale_filters is not None
assert particle_swarm_reopt_filters is not None
assert len(foreground_aperture_masses) == len(foreground_globalmin_masses)
assert len(reoptimize_scale_filters) == len(foreground_globalmin_masses)
assert len(particle_swarm_reopt_filters) == len(reoptimize_scale_filters)
else:
foreground_aperture_masses, foreground_globalmin_masses, foreground_filters, \
reoptimize_scale_filters, particle_swarm_reopt_filters = foreground_mass_filters(foreground_realization, LOS_mass_sheet_front)
foreground_rays, foreground_macromodel, foreground_halos, keywords_lensmodel, data_foreground = optimize_foreground(macromodel,
[foreground_realization], datatofit, tol_source, tol_mag, tol_centroid, centroid_0, n_particles,
n_iterations, source_shape, source_size_kpc, polar_grid, optimize_routine, re_optimize, verbose, particle_swarm,
restart, constrain_params, pso_convergence_mean, pso_compute_magnification, tol_simplex_params,
tol_simplex_func, simplex_n_iter, self, LOS_mass_sheet_front, LOS_mass_sheet_back,
centroid_0, satellites, check_foreground_fit,foreground_aperture_masses, foreground_globalmin_masses,
foreground_filters, reoptimize_scale_filters, particle_swarm_reopt_filters)
if data_foreground is None:
return None, None, None
if check_foreground_fit:
if chi_square_img(datatofit.x, datatofit.y, data_foreground[0].x, data_foreground[0].y, 0.003) >= 1:
return None, None, None
#if np.sum(realization.redshifts > self.zmain) == 0:
# return data_foreground, foreground_macromodel, None, keywords_lensmodel
if verbose: print('optimizing background... ')
if background_aperture_masses is not None:
assert background_globalmin_masses is not None
assert background_filters is not None
assert reoptimize_scale_background is not None
assert particle_swarm_reopt_background is not None
assert optimize_iteration_background is not None
assert len(background_aperture_masses) == len(background_globalmin_masses)
assert len(reoptimize_scale_background) == len(background_aperture_masses)
assert len(particle_swarm_reopt_background) == len(optimize_iteration_background)
else:
background_aperture_masses, background_globalmin_masses, background_filters, \
reoptimize_scale_background, particle_swarm_reopt_background, optimize_iteration_background = background_mass_filters(background_realization,
LOS_mass_sheet_back)
optimized_data, model, outputs, keywords_lensmodel = optimize_background(foreground_macromodel, foreground_halos[0], background_realization, foreground_rays,
keywords_lensmodel['source_x'], keywords_lensmodel['source_y'], datatofit, tol_source, tol_mag, tol_centroid, centroid_0, n_particles, n_iterations,
source_shape, source_size_kpc, polar_grid, optimize_routine, re_optimize, verbose,
particle_swarm, restart, constrain_params, pso_convergence_mean, pso_compute_magnification,
tol_simplex_params, tol_simplex_func, simplex_n_iter, self,
background_globalmin_masses = background_globalmin_masses,
background_aperture_masses = background_aperture_masses, background_filters = background_filters,
reoptimize_scale = reoptimize_scale_background, particle_swarm_reopt = particle_swarm_reopt_background,
LOS_mass_sheet_front = LOS_mass_sheet_front, LOS_mass_sheet_back = LOS_mass_sheet_back,
optimize_iteration=optimize_iteration_background, centroid = centroid_0, satellites=satellites)
fluxes = self._ray_trace_finite(optimized_data[0].x, optimized_data[0].y, optimized_data[0].srcx, optimized_data[0].srcy, True,
keywords_lensmodel['lensModel'], keywords_lensmodel['kwargs_lens'], grid_res, source_shape,
source_size_kpc, polar_grid, adaptive_grid, grid_rmax_scale)
optimized_data[0].set_mag(fluxes)
optimized_data[0].sort_by_pos(datatofit.x,datatofit.y)
if satellites is not None:
if 'position_convention' in satellites.keys() and \
satellites['position_convention'] == 'lensed':
physical_kwargs = keywords_lensmodel['lensModel']._full_lensmodel.\
lens_model._convention(keywords_lensmodel['kwargs_lens'])
physical_x, physical_y = physical_kwargs[2]['center_x'], physical_kwargs[2]['center_y']
model[0]._satellite_physical_location = np.array([physical_x, physical_y])
else:
model[0]._satellite_physical_location = np.array([keywords_lensmodel['kwargs_lens'][2]['center_x'],
keywords_lensmodel['kwargs_lens'][2]['center_y']])
return optimized_data, model, outputs, keywords_lensmodel