From fd4837a01f524c705798bbdf52d38c1202c26ee6 Mon Sep 17 00:00:00 2001 From: Nikki Date: Thu, 25 Jan 2024 18:51:39 +0100 Subject: [PATCH 01/50] created a skeleton function opsim_time_series_images_data to get observation information from opsim --- slsim/lsst_science_pipeline.py | 88 ++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 2bedc9280..135f06928 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -745,6 +745,94 @@ def dp0_time_series_images_data(butler, center_coord, radius="0.1", band="i", si return table_data +def opsim_time_series_images_data(butler, center_coord, radius="0.1", band="i", size=101): + """Creates time series data from opsim database. + + :param butler: butler object + :param center_coord: A coordinate point around which we need to create time series + images. + :param radius: radius for query + :param band: imaging band + :param size: cutout size of images + :return: An astropy table containg time series images and other information + """ + + expo_information = tap_query(center_coords=center_coord, radius=radius, band=band) + calexp_image = list_of_calexp(expo_information, butler=butler) + radec = dp0_center_radec(calexp_image[0]) + # Question: is radec_list only for 1 observation? Or can it be a list with multiple ra and decs? + # It might be better here to skip the butler and just get ra, dec from center_coord + radec_list = [(radec.getRa().asDegrees(), radec.getDec().asDegrees())] + + # Everything in this section below might be better in a separate opsim function + # ------------------------------------------------------------------ + # Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables) + # and the opsim database downloaded + from opsimsummary import SynOpSim + + opsim_path = '../data/OpSim_database/baseline_v3.0_10yrs.db' + + synopsim = SynOpSim.fromOpSimDB(opsim_path, opsimversion='fbsv2', usePointingTree=True, use_proposal_table=False, + subset='unique_all') + + gen = synopsim.pointingsEnclosing(radec_list[0], radec_list[1], circRadius=0., pointingRadius=1.75, + usePointingTree=True) + # ------------------------------------------------------------------ + + # Collect the next observation sequence from the opsim generator + # (if only 1 set of coordinates is supplied then there is only one sequence) + seq = next(gen) + + # To do: now, seq still contains all ugrizy bands. We can cut out the ones corresponding to 'band', + # but if you'd do this for many bands it would be inefficient and slow (better to initialise opsim summary once) + + # Get the observation times, exposure times and sky brightness from opsim + obs_time = np.array(seq['expMJD']) + expo_time = np.array(seq['visitExposureTime']) + sky_brightness = np.array(seq['filtSkyBrightness']) + + # Get the psf from opsim + psf_fwhm = np.array(seq['seeingFwhmGeom']) + # To do: make a psf kernel from psf_fwhm (either moffat kernel or match with similar dp0 kernel?) + pixels = radec_to_pix(radec, calexp_image) + psf_kernel = dp0_psf_kernels(pixels, calexp_image) + + # Get the zero point from opsim + m5_depth = np.array(seq['fiveSigmaDepth']) + # To do: convert m5_depth to zero point using opsim summary function + zero_point_mag = expo_information["zeroPoint"] + + radec_list.extend(radec_list * (len(calexp_image) - 1)) + cutout_image = calexp_cutout(calexp_image, radec, 450) + aligned_image = aligned_calexp(cutout_image) + aligned_image_cutout = calexp_cutout(aligned_image, radec, size) + + # To do: replace dp0 cutouts by noise background (using sky_brightness, expo_time, zero_point_mag) + dp0_time_series_cutout = [] + for i in range(len(aligned_image_cutout)): + dp0_time_series_cutout.append(aligned_image_cutout[i].image.array) + + table_data = Table( + [ + dp0_time_series_cutout, + psf_kernel, + obs_time, + expo_time, + zero_point_mag, + radec_list, + ], + names=( + "time_series_images", + "psf_kernel", + "obs_time", + "expo_time", + "zero_point", + "calexp_center", + ), + ) + return table_data + + def variable_lens_injection( lens_class, band, num_pix, transform_pix2angle, exposure_data ): From 461df2f944a536e0882fcfeab16fddfb10b6b879 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 25 Jan 2024 17:59:18 +0000 Subject: [PATCH 02/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- slsim/lsst_science_pipeline.py | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 135f06928..19f2c3a3a 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -745,7 +745,9 @@ def dp0_time_series_images_data(butler, center_coord, radius="0.1", band="i", si return table_data -def opsim_time_series_images_data(butler, center_coord, radius="0.1", band="i", size=101): +def opsim_time_series_images_data( + butler, center_coord, radius="0.1", band="i", size=101 +): """Creates time series data from opsim database. :param butler: butler object @@ -770,13 +772,23 @@ def opsim_time_series_images_data(butler, center_coord, radius="0.1", band="i", # and the opsim database downloaded from opsimsummary import SynOpSim - opsim_path = '../data/OpSim_database/baseline_v3.0_10yrs.db' + opsim_path = "../data/OpSim_database/baseline_v3.0_10yrs.db" - synopsim = SynOpSim.fromOpSimDB(opsim_path, opsimversion='fbsv2', usePointingTree=True, use_proposal_table=False, - subset='unique_all') + synopsim = SynOpSim.fromOpSimDB( + opsim_path, + opsimversion="fbsv2", + usePointingTree=True, + use_proposal_table=False, + subset="unique_all", + ) - gen = synopsim.pointingsEnclosing(radec_list[0], radec_list[1], circRadius=0., pointingRadius=1.75, - usePointingTree=True) + gen = synopsim.pointingsEnclosing( + radec_list[0], + radec_list[1], + circRadius=0.0, + pointingRadius=1.75, + usePointingTree=True, + ) # ------------------------------------------------------------------ # Collect the next observation sequence from the opsim generator @@ -787,18 +799,18 @@ def opsim_time_series_images_data(butler, center_coord, radius="0.1", band="i", # but if you'd do this for many bands it would be inefficient and slow (better to initialise opsim summary once) # Get the observation times, exposure times and sky brightness from opsim - obs_time = np.array(seq['expMJD']) - expo_time = np.array(seq['visitExposureTime']) - sky_brightness = np.array(seq['filtSkyBrightness']) + obs_time = np.array(seq["expMJD"]) + expo_time = np.array(seq["visitExposureTime"]) + sky_brightness = np.array(seq["filtSkyBrightness"]) # Get the psf from opsim - psf_fwhm = np.array(seq['seeingFwhmGeom']) + psf_fwhm = np.array(seq["seeingFwhmGeom"]) # To do: make a psf kernel from psf_fwhm (either moffat kernel or match with similar dp0 kernel?) pixels = radec_to_pix(radec, calexp_image) psf_kernel = dp0_psf_kernels(pixels, calexp_image) # Get the zero point from opsim - m5_depth = np.array(seq['fiveSigmaDepth']) + m5_depth = np.array(seq["fiveSigmaDepth"]) # To do: convert m5_depth to zero point using opsim summary function zero_point_mag = expo_information["zeroPoint"] From 1a6f3010d7fbb20efed206097a118971b8005e6f Mon Sep 17 00:00:00 2001 From: Nikki Date: Mon, 29 Jan 2024 15:15:13 +0100 Subject: [PATCH 03/50] commented out unused variables --- slsim/lsst_science_pipeline.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 19f2c3a3a..2b8c88401 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -801,16 +801,16 @@ def opsim_time_series_images_data( # Get the observation times, exposure times and sky brightness from opsim obs_time = np.array(seq["expMJD"]) expo_time = np.array(seq["visitExposureTime"]) - sky_brightness = np.array(seq["filtSkyBrightness"]) + # sky_brightness = np.array(seq["filtSkyBrightness"]) # Get the psf from opsim - psf_fwhm = np.array(seq["seeingFwhmGeom"]) + # psf_fwhm = np.array(seq["seeingFwhmGeom"]) # To do: make a psf kernel from psf_fwhm (either moffat kernel or match with similar dp0 kernel?) pixels = radec_to_pix(radec, calexp_image) psf_kernel = dp0_psf_kernels(pixels, calexp_image) # Get the zero point from opsim - m5_depth = np.array(seq["fiveSigmaDepth"]) + # m5_depth = np.array(seq["fiveSigmaDepth"]) # To do: convert m5_depth to zero point using opsim summary function zero_point_mag = expo_information["zeroPoint"] From 9fb415e29cb7ddee7aced3f169003a95d47ce1fe Mon Sep 17 00:00:00 2001 From: Nikki Date: Mon, 26 Feb 2024 17:39:37 +0100 Subject: [PATCH 04/50] restructured opsim_time_series_images_data --- slsim/lsst_science_pipeline.py | 152 +++++++++++++++------------------ 1 file changed, 71 insertions(+), 81 deletions(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 2b8c88401..586a368f6 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -745,104 +745,94 @@ def dp0_time_series_images_data(butler, center_coord, radius="0.1", band="i", si return table_data -def opsim_time_series_images_data( - butler, center_coord, radius="0.1", band="i", size=101 -): +def opsim_time_series_images_data(ra_list, dec_list, size=101): """Creates time series data from opsim database. - :param butler: butler object - :param center_coord: A coordinate point around which we need to create time series - images. - :param radius: radius for query - :param band: imaging band + :param ra_list: a list of ra points from objects we want to fetch observations for. + :param dec_list: a list of dec points from objects we want to fetch observations for. :param size: cutout size of images :return: An astropy table containg time series images and other information """ - expo_information = tap_query(center_coords=center_coord, radius=radius, band=band) - calexp_image = list_of_calexp(expo_information, butler=butler) - radec = dp0_center_radec(calexp_image[0]) - # Question: is radec_list only for 1 observation? Or can it be a list with multiple ra and decs? - # It might be better here to skip the butler and just get ra, dec from center_coord - radec_list = [(radec.getRa().asDegrees(), radec.getDec().asDegrees())] - - # Everything in this section below might be better in a separate opsim function # ------------------------------------------------------------------ - # Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables) - # and the opsim database downloaded - from opsimsummary import SynOpSim - - opsim_path = "../data/OpSim_database/baseline_v3.0_10yrs.db" - - synopsim = SynOpSim.fromOpSimDB( - opsim_path, - opsimversion="fbsv2", - usePointingTree=True, - use_proposal_table=False, - subset="unique_all", - ) - gen = synopsim.pointingsEnclosing( - radec_list[0], - radec_list[1], - circRadius=0.0, - pointingRadius=1.75, - usePointingTree=True, - ) + # Import opsimsummary + try: + from opsimsummary import SynOpSim + except: + raise ImportError("Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables)") + # Initialise opsimsummary with opsim database + try: + opsim_path = "../data/OpSim_database/opsim.db" + + synopsim = SynOpSim.fromOpSimDB(opsim_path, opsimversion="fbsv2", usePointingTree=True, + use_proposal_table=False, subset="unique_all") + except: + raise FileNotFoundError("Users need to have an opsim database downloaded at ../data/OpSim_database/opsim.db") + + # Fetch observations that cover the coordinates in ra_list and dec_list + gen = synopsim.pointingsEnclosing(ra_list, dec_list, circRadius=0.0, pointingRadius=1.75, usePointingTree=True) + # ------------------------------------------------------------------ - # Collect the next observation sequence from the opsim generator - # (if only 1 set of coordinates is supplied then there is only one sequence) - seq = next(gen) + table_data_list = [] - # To do: now, seq still contains all ugrizy bands. We can cut out the ones corresponding to 'band', - # but if you'd do this for many bands it would be inefficient and slow (better to initialise opsim summary once) + # Loop through all coordinates and compute the table_data + for i in range(len(ra_list)): - # Get the observation times, exposure times and sky brightness from opsim - obs_time = np.array(seq["expMJD"]) - expo_time = np.array(seq["visitExposureTime"]) - # sky_brightness = np.array(seq["filtSkyBrightness"]) + radec_list = [(ra_list[i], dec_list[i])] - # Get the psf from opsim - # psf_fwhm = np.array(seq["seeingFwhmGeom"]) - # To do: make a psf kernel from psf_fwhm (either moffat kernel or match with similar dp0 kernel?) - pixels = radec_to_pix(radec, calexp_image) - psf_kernel = dp0_psf_kernels(pixels, calexp_image) + # Collect the next observation sequence from the opsim generator + seq = next(gen) + seq = seq.sort_values(by=['expMJD']) - # Get the zero point from opsim - # m5_depth = np.array(seq["fiveSigmaDepth"]) - # To do: convert m5_depth to zero point using opsim summary function - zero_point_mag = expo_information["zeroPoint"] + # Check if the coordinates are in the opsim LSST footprint + opsim_ra = np.mean(seq['fieldRA']) + opsim_dec = np.mean(seq['fieldDec']) - radec_list.extend(radec_list * (len(calexp_image) - 1)) - cutout_image = calexp_cutout(calexp_image, radec, 450) - aligned_image = aligned_calexp(cutout_image) - aligned_image_cutout = calexp_cutout(aligned_image, radec, size) + if np.isnan(opsim_ra) or np.isnan(opsim_dec): + continue + # Should I save some documentation of this, or add a nan entry to the table_data? - # To do: replace dp0 cutouts by noise background (using sky_brightness, expo_time, zero_point_mag) - dp0_time_series_cutout = [] - for i in range(len(aligned_image_cutout)): - dp0_time_series_cutout.append(aligned_image_cutout[i].image.array) + # Get the observation times, exposure times, sky brightness, and bandpass from opsim + obs_time = np.array(seq["expMJD"]) + expo_time = np.array(seq["visitExposureTime"]) + sky_brightness = np.array(seq["filtSkyBrightness"]) + bandpass = np.array(seq['filter']) - table_data = Table( - [ - dp0_time_series_cutout, - psf_kernel, - obs_time, - expo_time, - zero_point_mag, - radec_list, - ], - names=( - "time_series_images", - "psf_kernel", - "obs_time", - "expo_time", - "zero_point", - "calexp_center", - ), - ) - return table_data + # Get the psf from opsim + # psf_fwhm = np.array(seq["seeingFwhmGeom"]) + # To do: make a psf kernel from psf_fwhm (first from moffat kernel) + psf_kernel = ... + + # Get the zero point from opsim + # m5_depth = np.array(seq["fiveSigmaDepth"]) + # To do: convert m5_depth to zero point using opsim summary function + zero_point_mag = ... + + table_data = Table( + [ + sky_brightness, + psf_kernel, + obs_time, + expo_time, + zero_point_mag, + radec_list, + bandpass, + ], + names=( + "sky_brightness", + "psf_kernel", + "obs_time", + "expo_time", + "zero_point", + "calexp_center", + "band", + ), + ) + + table_data_list.append(table_data) + return table_data_list def variable_lens_injection( From 92dba21b424fa73a08ecd076270f871fd41b4850 Mon Sep 17 00:00:00 2001 From: Nikki Date: Fri, 8 Mar 2024 11:07:21 +0000 Subject: [PATCH 05/50] added psf kernel and zero point calculation --- slsim/lsst_science_pipeline.py | 59 +++++++++++++++++++++------------- 1 file changed, 37 insertions(+), 22 deletions(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 586a368f6..b83a28062 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -9,6 +9,8 @@ from slsim.Util.param_util import transformmatrix_to_pixelscale from scipy import interpolate from slsim.image_simulation import point_source_coordinate_properties +import lenstronomy.Util.util as util +import lenstronomy.Util.kernel_util as kernel_util try: import lsst.geom as geom @@ -745,22 +747,23 @@ def dp0_time_series_images_data(butler, center_coord, radius="0.1", band="i", si return table_data -def opsim_time_series_images_data(ra_list, dec_list, size=101): +def opsim_time_series_images_data(ra_list, dec_list, delta_pix, size=101, moffat_beta=3.1): """Creates time series data from opsim database. - :param ra_list: a list of ra points from objects we want to fetch observations for. - :param dec_list: a list of dec points from objects we want to fetch observations for. - :param size: cutout size of images - :return: An astropy table containg time series images and other information + :param ra_list: a list of ra points (in degrees) from objects we want to collect observations for + :param dec_list: a list of dec points (in degrees) from objects we want to collect observations for + :param delta_pix: pixel scale in arcseconds for the psf kernel + :param size: cutout size of images (in pixels) + :param moffat_beta: power index of the moffat psf kernel + :return: a list of astropy tables containing observation information for each coordinate """ - # ------------------------------------------------------------------ - # Import opsimsummary try: from opsimsummary import SynOpSim except: raise ImportError("Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables)") + # Initialise opsimsummary with opsim database try: opsim_path = "../data/OpSim_database/opsim.db" @@ -770,11 +773,9 @@ def opsim_time_series_images_data(ra_list, dec_list, size=101): except: raise FileNotFoundError("Users need to have an opsim database downloaded at ../data/OpSim_database/opsim.db") - # Fetch observations that cover the coordinates in ra_list and dec_list + # Collect observations that cover the coordinates in ra_list and dec_list gen = synopsim.pointingsEnclosing(ra_list, dec_list, circRadius=0.0, pointingRadius=1.75, usePointingTree=True) - # ------------------------------------------------------------------ - table_data_list = [] # Loop through all coordinates and compute the table_data @@ -791,24 +792,38 @@ def opsim_time_series_images_data(ra_list, dec_list, size=101): opsim_dec = np.mean(seq['fieldDec']) if np.isnan(opsim_ra) or np.isnan(opsim_dec): + print(f"Coordinate ({ra_list[i]}, {dec_list[i]}) is not in the LSST footprint. This entry is skipped.") continue - # Should I save some documentation of this, or add a nan entry to the table_data? - # Get the observation times, exposure times, sky brightness, and bandpass from opsim + # Get the observation times, exposure times, sky brightness, bandpass, and psf fwhm from opsim obs_time = np.array(seq["expMJD"]) expo_time = np.array(seq["visitExposureTime"]) sky_brightness = np.array(seq["filtSkyBrightness"]) bandpass = np.array(seq['filter']) - - # Get the psf from opsim - # psf_fwhm = np.array(seq["seeingFwhmGeom"]) - # To do: make a psf kernel from psf_fwhm (first from moffat kernel) - psf_kernel = ... - - # Get the zero point from opsim - # m5_depth = np.array(seq["fiveSigmaDepth"]) - # To do: convert m5_depth to zero point using opsim summary function - zero_point_mag = ... + psf_fwhm = np.array(seq["seeingFwhmGeom"]) + m5_depth = np.array(seq["fiveSigmaDepth"]) + # Question: use 'FWHMeff' or 'seeingFwhmGeom' for the psf? + + # Create a Moffat psf kernel + psf_kernel = kernel_util.kernel_moffat(num_pix=size, delta_pix=delta_pix, fwhm=psf_fwhm, moffat_beta=moffat_beta) + psf_kernel = util.array2image(psf_kernel) + + # Calculate the zero point magnitude + # Code from OpSimSummary/opsimsummary/simlib.py/add_simlibCols + term1 = 2.0 * m5_depth - sky_brightness # * pixArea + term2 = - (m5_depth - sky_brightness) # * pixArea + area = (1.51 * psf_fwhm) ** 2. + opsim_snr = 5. + arg = area * opsim_snr * opsim_snr + # Background dominated limit assuming counts with system transmission only + # is approximately equal to counts with total transmission + zpt_approx = term1 + 2.5 * np.log10(arg) + val = -0.4 * term2 + tmp = 10.0 ** val + # Additional term to account for photons from the source, again assuming + # that counts with system transmission approximately equal counts with total transmission. + zpt_cor = 2.5 * np.log10(1.0 + 1.0 / (area * tmp)) + zero_point_mag = zpt_approx + zpt_cor table_data = Table( [ From df45d1379859e749063319a6ce049f3d8ec76b8c Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 8 Mar 2024 11:28:20 +0000 Subject: [PATCH 06/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- slsim/lsst_science_pipeline.py | 58 +++++++++++++++++++++++----------- 1 file changed, 39 insertions(+), 19 deletions(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index b83a28062..0df3a8d3e 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -747,34 +747,50 @@ def dp0_time_series_images_data(butler, center_coord, radius="0.1", band="i", si return table_data -def opsim_time_series_images_data(ra_list, dec_list, delta_pix, size=101, moffat_beta=3.1): +def opsim_time_series_images_data( + ra_list, dec_list, delta_pix, size=101, moffat_beta=3.1 +): """Creates time series data from opsim database. - :param ra_list: a list of ra points (in degrees) from objects we want to collect observations for - :param dec_list: a list of dec points (in degrees) from objects we want to collect observations for + :param ra_list: a list of ra points (in degrees) from objects we want to collect + observations for + :param dec_list: a list of dec points (in degrees) from objects we want to collect + observations for :param delta_pix: pixel scale in arcseconds for the psf kernel :param size: cutout size of images (in pixels) :param moffat_beta: power index of the moffat psf kernel - :return: a list of astropy tables containing observation information for each coordinate + :return: a list of astropy tables containing observation information for each + coordinate """ # Import opsimsummary try: from opsimsummary import SynOpSim except: - raise ImportError("Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables)") + raise ImportError( + "Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables)" + ) # Initialise opsimsummary with opsim database try: opsim_path = "../data/OpSim_database/opsim.db" - synopsim = SynOpSim.fromOpSimDB(opsim_path, opsimversion="fbsv2", usePointingTree=True, - use_proposal_table=False, subset="unique_all") + synopsim = SynOpSim.fromOpSimDB( + opsim_path, + opsimversion="fbsv2", + usePointingTree=True, + use_proposal_table=False, + subset="unique_all", + ) except: - raise FileNotFoundError("Users need to have an opsim database downloaded at ../data/OpSim_database/opsim.db") + raise FileNotFoundError( + "Users need to have an opsim database downloaded at ../data/OpSim_database/opsim.db" + ) # Collect observations that cover the coordinates in ra_list and dec_list - gen = synopsim.pointingsEnclosing(ra_list, dec_list, circRadius=0.0, pointingRadius=1.75, usePointingTree=True) + gen = synopsim.pointingsEnclosing( + ra_list, dec_list, circRadius=0.0, pointingRadius=1.75, usePointingTree=True + ) table_data_list = [] @@ -785,41 +801,45 @@ def opsim_time_series_images_data(ra_list, dec_list, delta_pix, size=101, moffat # Collect the next observation sequence from the opsim generator seq = next(gen) - seq = seq.sort_values(by=['expMJD']) + seq = seq.sort_values(by=["expMJD"]) # Check if the coordinates are in the opsim LSST footprint - opsim_ra = np.mean(seq['fieldRA']) - opsim_dec = np.mean(seq['fieldDec']) + opsim_ra = np.mean(seq["fieldRA"]) + opsim_dec = np.mean(seq["fieldDec"]) if np.isnan(opsim_ra) or np.isnan(opsim_dec): - print(f"Coordinate ({ra_list[i]}, {dec_list[i]}) is not in the LSST footprint. This entry is skipped.") + print( + f"Coordinate ({ra_list[i]}, {dec_list[i]}) is not in the LSST footprint. This entry is skipped." + ) continue # Get the observation times, exposure times, sky brightness, bandpass, and psf fwhm from opsim obs_time = np.array(seq["expMJD"]) expo_time = np.array(seq["visitExposureTime"]) sky_brightness = np.array(seq["filtSkyBrightness"]) - bandpass = np.array(seq['filter']) + bandpass = np.array(seq["filter"]) psf_fwhm = np.array(seq["seeingFwhmGeom"]) m5_depth = np.array(seq["fiveSigmaDepth"]) # Question: use 'FWHMeff' or 'seeingFwhmGeom' for the psf? # Create a Moffat psf kernel - psf_kernel = kernel_util.kernel_moffat(num_pix=size, delta_pix=delta_pix, fwhm=psf_fwhm, moffat_beta=moffat_beta) + psf_kernel = kernel_util.kernel_moffat( + num_pix=size, delta_pix=delta_pix, fwhm=psf_fwhm, moffat_beta=moffat_beta + ) psf_kernel = util.array2image(psf_kernel) # Calculate the zero point magnitude # Code from OpSimSummary/opsimsummary/simlib.py/add_simlibCols term1 = 2.0 * m5_depth - sky_brightness # * pixArea - term2 = - (m5_depth - sky_brightness) # * pixArea - area = (1.51 * psf_fwhm) ** 2. - opsim_snr = 5. + term2 = -(m5_depth - sky_brightness) # * pixArea + area = (1.51 * psf_fwhm) ** 2.0 + opsim_snr = 5.0 arg = area * opsim_snr * opsim_snr # Background dominated limit assuming counts with system transmission only # is approximately equal to counts with total transmission zpt_approx = term1 + 2.5 * np.log10(arg) val = -0.4 * term2 - tmp = 10.0 ** val + tmp = 10.0**val # Additional term to account for photons from the source, again assuming # that counts with system transmission approximately equal counts with total transmission. zpt_cor = 2.5 * np.log10(1.0 + 1.0 / (area * tmp)) From 605317e9ab70205c4248ad0075bc3410a53f8d2f Mon Sep 17 00:00:00 2001 From: Nikki Date: Fri, 8 Mar 2024 11:32:42 +0000 Subject: [PATCH 07/50] Changed bare except clauses --- slsim/lsst_science_pipeline.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index b83a28062..9e27ab7dc 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -761,7 +761,7 @@ def opsim_time_series_images_data(ra_list, dec_list, delta_pix, size=101, moffat # Import opsimsummary try: from opsimsummary import SynOpSim - except: + except ImportError: raise ImportError("Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables)") # Initialise opsimsummary with opsim database @@ -770,7 +770,7 @@ def opsim_time_series_images_data(ra_list, dec_list, delta_pix, size=101, moffat synopsim = SynOpSim.fromOpSimDB(opsim_path, opsimversion="fbsv2", usePointingTree=True, use_proposal_table=False, subset="unique_all") - except: + except FileNotFoundError: raise FileNotFoundError("Users need to have an opsim database downloaded at ../data/OpSim_database/opsim.db") # Collect observations that cover the coordinates in ra_list and dec_list From 838f808203500b9a795c28fa90400434c7eee29b Mon Sep 17 00:00:00 2001 From: Nikki Date: Fri, 8 Mar 2024 11:39:11 +0000 Subject: [PATCH 08/50] fixed some more merge conflict leftovers --- slsim/lsst_science_pipeline.py | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 479144180..6c6da25f7 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -768,9 +768,7 @@ def opsim_time_series_images_data( from opsimsummary import SynOpSim except ImportError: raise ImportError("Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables)") - except: - raise ImportError( - "Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables)" + # Initialise opsimsummary with opsim database try: opsim_path = "../data/OpSim_database/opsim.db" @@ -779,18 +777,6 @@ def opsim_time_series_images_data( except FileNotFoundError: raise FileNotFoundError("Users need to have an opsim database downloaded at ../data/OpSim_database/opsim.db") - synopsim = SynOpSim.fromOpSimDB( - opsim_path, - opsimversion="fbsv2", - usePointingTree=True, - use_proposal_table=False, - subset="unique_all", - ) - except: - raise FileNotFoundError( - "Users need to have an opsim database downloaded at ../data/OpSim_database/opsim.db" - ) - # Collect observations that cover the coordinates in ra_list and dec_list gen = synopsim.pointingsEnclosing( ra_list, dec_list, circRadius=0.0, pointingRadius=1.75, usePointingTree=True From ce23d58ba9927d44003ff64dbc75938c1a0deb5f Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 8 Mar 2024 11:39:39 +0000 Subject: [PATCH 09/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- slsim/lsst_science_pipeline.py | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 6c6da25f7..d2c26f098 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -767,15 +767,24 @@ def opsim_time_series_images_data( try: from opsimsummary import SynOpSim except ImportError: - raise ImportError("Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables)") + raise ImportError( + "Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables)" + ) # Initialise opsimsummary with opsim database try: opsim_path = "../data/OpSim_database/opsim.db" - synopsim = SynOpSim.fromOpSimDB(opsim_path, opsimversion="fbsv2", usePointingTree=True, - use_proposal_table=False, subset="unique_all") + synopsim = SynOpSim.fromOpSimDB( + opsim_path, + opsimversion="fbsv2", + usePointingTree=True, + use_proposal_table=False, + subset="unique_all", + ) except FileNotFoundError: - raise FileNotFoundError("Users need to have an opsim database downloaded at ../data/OpSim_database/opsim.db") + raise FileNotFoundError( + "Users need to have an opsim database downloaded at ../data/OpSim_database/opsim.db" + ) # Collect observations that cover the coordinates in ra_list and dec_list gen = synopsim.pointingsEnclosing( From c320667e20563e6d4e08d6b00730e01c6c566ac1 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 30 Jul 2024 16:28:03 +0200 Subject: [PATCH 10/50] started notebook to use opsim for simulated lensed SNe --- ...rnovae_plus_extended_source_tutorial.ipynb | 559 ++++++++++++++++++ 1 file changed, 559 insertions(+) create mode 100644 notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb new file mode 100644 index 000000000..1d26db9a2 --- /dev/null +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -0,0 +1,559 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from astropy.cosmology import FlatLambdaCDM\n", + "from astropy.units import Quantity\n", + "from slsim.lens_pop import LensPop\n", + "import numpy as np\n", + "from slsim.image_simulation import lens_image_series\n", + "from slsim.Plots.plot_functions import create_image_montage_from_image_list\n", + "from slsim.image_simulation import point_source_coordinate_properties\n", + "from slsim import lsst_science_pipeline\n", + "import matplotlib.pyplot as plt\n", + "import corner\n", + "import astropy.coordinates as coord\n", + "import astropy.units as u" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Supernovae plus extended source simulation\n", + "In this notebook, we simulate population of lensed supernovae and simulate image of a \n", + "\n", + "random lensed supernovae. It follows following steps:\n", + "\n", + "1. Simulate lensed supernovae population\n", + "2. Choose a lens at random\n", + "3. Set observation time and other image configuration\n", + "4. Simulate image of a selected lens\n", + "5. Visualize it\n", + "\n", + "Before running this notebook, please download the \"scotch_SNIa_host_galaxies.fits\"\n", + "\n", + "file from the following link: https://github.com/LSST-strong-lensing/data_public.git. \n", + "\n", + "This file contains type Ia supernovae host galaxies." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulate lensed supernovae population" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# define a cosmology\n", + "cosmo = FlatLambdaCDM(H0=70, Om0=0.3)\n", + "\n", + "\n", + "# define a sky area\n", + "sky_area = Quantity(value=0.1, unit=\"deg2\")\n", + "\n", + "\n", + "# define limits in the intrinsic deflector and source population (in addition to the\n", + "# skypy config\n", + "# file)\n", + "kwargs_deflector_cut = {\"z_min\": 0.01, \"z_max\": 2.5}\n", + "kwargs_source_cut = {}\n", + "## create a point plus extended source lens population.\n", + "supernova_lens_pop = LensPop(\n", + " deflector_type=\"elliptical\", # type of the deflector. It could be elliptical or\n", + " # all-galaxies.\n", + " source_type=\"supernovae_plus_galaxies\", # keyword for source type. it can be\n", + " # galaxies, quasar, quasar_plus_galaxies, and supernovae_plus_galaxies.\n", + " kwargs_deflector_cut=kwargs_deflector_cut, # cuts that one wants to apply for the\n", + " # deflector.\n", + " kwargs_source_cut=kwargs_source_cut, # cuts that one wants to apply for the\n", + " # source.\n", + " variability_model=\"light_curve\", # keyword for the variability model.\n", + " kwargs_variability={\"supernovae_lightcurve\", \"i\"}, # specify kewords for\n", + " # lightcurve. \"i\" is a band for the lightcurve.\n", + " sn_type=\"Ia\", # supernovae type.\n", + " sn_absolute_mag_band=\"bessellb\", # Band used to normalize to absolute magnitude\n", + " sn_absolute_zpsys=\"ab\", # magnitude system. It can be Optional, AB or Vega.\n", + " kwargs_mass2light=None, # mass-to-light relation for the deflector galaxy.\n", + " skypy_config=None, # Sky configuration for the simulation. If None, lsst-like\n", + " # configuration will be used.\n", + " sky_area=sky_area, # Sky area for the simulation, source / deflector sky area\n", + " cosmo=cosmo, # astropy cosmology\n", + " source_light_profile=\"double_sersic\", # light profile for the source galaxy\n", + " catalog_type=\"scotch\", # catalog type. It can be None or scotch\n", + " lightcurve_time=np.linspace(\n", + " -20, 100, 1000\n", + " ), # array of light curve observation time.\n", + " catalog_path=\"../data/Scotch/\"\n", + " + \"scotch_SNIa_host_galaxies.fits\",\n", + " # path for catalog. If not provided, small size catalog from\n", + " # /slsim/Source/SupernovaeCatalog will be used for\n", + " # source_type=\"supernovae_plus_galaxies\" case. For other cases, we do not need to\n", + " # provide outside catalog. One can download scotch_SNIa_host_galaxies.fits from\n", + " # https://github.com/LSST-strong-lensing/data_public.git\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 7810 potential lenses and 10000 potential sources.\n" + ] + } + ], + "source": [ + "print(\"Found\", supernova_lens_pop.deflector_number, \"potential lenses and\",\n", + " supernova_lens_pop.source_number, \"potential sources.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Choose a random lens" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# specifying cuts of the population\n", + "kwargs_lens_cuts = {}\n", + "# drawing population\n", + "supernovae_lens_population = supernova_lens_pop.draw_population(\n", + " kwargs_lens_cuts=kwargs_lens_cuts # speed_factor=200\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of strong lens systems: 17\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nikki/anaconda3/envs/slsim/lib/python3.12/site-packages/sncosmo/models.py:189: RuntimeWarning: divide by zero encountered in log10\n", + " result[i] = -2.5 * np.log10(f / zpf)\n", + "/Users/nikki/anaconda3/envs/slsim/lib/python3.12/site-packages/slsim/Sources/source.py:362: RuntimeWarning: divide by zero encountered in log10\n", + " mag_source0 = -2.5 * np.log10(w0 * flux)\n", + "/Users/nikki/anaconda3/envs/slsim/lib/python3.12/site-packages/sncosmo/models.py:189: RuntimeWarning: invalid value encountered in log10\n", + " result[i] = -2.5 * np.log10(f / zpf)\n" + ] + } + ], + "source": [ + "print(\"Number of strong lens systems:\", len(supernovae_lens_population))\n", + "\n", + "lens_samples = []\n", + "labels = [\n", + " r\"$\\sigma_v$\",\n", + " r\"$\\log(M_{*})$\",\n", + " r\"$\\theta_E$\",\n", + " r\"$z_{\\rm l}$\",\n", + " r\"$z_{\\rm s}$\",\n", + " r\"$m_{\\rm host}$\",\n", + " r\"$m_{\\rm ps}$\",\n", + " r\"$m_{\\rm lens}$\",\n", + "]\n", + "\n", + "for supernovae_lens in supernovae_lens_population:\n", + " vel_disp = supernovae_lens.deflector_velocity_dispersion()\n", + " m_star = supernovae_lens.deflector_stellar_mass()\n", + " theta_e = supernovae_lens.einstein_radius\n", + " zl = supernovae_lens.deflector_redshift\n", + " zs = supernovae_lens.source_redshift\n", + " source_mag = supernovae_lens.extended_source_magnitude(band=\"i\", lensed=True)\n", + " ps_source_mag = supernovae_lens.point_source_magnitude(band=\"i\")\n", + " deflector_mag = supernovae_lens.deflector_magnitude(band=\"i\")\n", + " lens_samples.append(\n", + " [\n", + " vel_disp,\n", + " np.log10(m_star),\n", + " theta_e,\n", + " zl,\n", + " source_mag,\n", + " ps_source_mag,\n", + " deflector_mag,\n", + " ]\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Choose a lens to simulate an image" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.832039, 0.5321404664052483, 24.688736, 26.831420679814215)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kwargs_lens_cut = {\"min_image_separation\": 1, \"max_image_separation\": 10}\n", + "rgb_band_list = [\"i\", \"r\", \"g\"]\n", + "lens_class = supernovae_lens_population[2]\n", + "(\n", + " lens_class.source.source_dict[\"z\"],\n", + " lens_class.einstein_radius,\n", + " lens_class.source.source_dict[\"mag_i\"],\n", + " lens_class.source.source_dict[\"ps_mag_i\"],\n", + " #lens_class._deflector_dict[\"mag_i\"],\n", + " #lens_class._deflector_dict[\"z\"],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "pix_coord = point_source_coordinate_properties(\n", + " lens_class,\n", + " band=\"i\",\n", + " mag_zero_point=27,\n", + " delta_pix=0.2,\n", + " num_pix=32,\n", + " transform_pix2angle=np.array([[0.2, 0], [0, 0.2]]),\n", + ")[\"image_pix\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[11.52138022, 14.5660759 ],\n", + " [15.49632453, 16.44243526]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pix_coord" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## See the light curve of a selected supernovae" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is a type Ia SN\n" + ] + } + ], + "source": [ + "light_curve = lens_class.source.variability_class.kwargs_model\n", + "\n", + "print(\"This is a type\", lens_class.source.sn_type, \"SN\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-22.0, 100.0)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(light_curve[\"MJD\"], light_curve[\"ps_mag_i\"])\n", + "# plt.ylim(12, 18)\n", + "plt.gca().invert_yaxis()\n", + "plt.ylabel(\"Magnitude\")\n", + "plt.xlabel(\"Time\" \"[Days]\")\n", + "plt.xlim(-22, 100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Get observation properties from OpSim" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Generate random points on the sky" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "N = 10\n", + "\n", + "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", + "ra_points = ra_points.wrap_at(180*u.degree)\n", + "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", + "dec_points = coord.Angle(dec_points * u.degree)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(ra_points, dec_points, \"baseline_v3.0_10yrs\",\n", + " MJD_min=60000, MJD_max=60300)\n", + "exposure_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "index = 0\n", + "bands = ['g','r','i','z']\n", + "num_pix = 200\n", + "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", + "\n", + "images = opsim_variable_lens_injection(lens_class, bands, num_pix, transform_pix2angle, exposure_data[index])\n", + "images" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set observation time and image configuration" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "time = np.array([-19.5, -15, -11.35135135135135, 0, 10, 20, 25, 30, 40, 44.86])\n", + "# time = sorted(np.random.uniform(-20, 100, 10))\n", + "# time = np.array([0, 50, 70, 120])\n", + "repeats = 10\n", + "# load your psf kernel and transform matrix. If you have your own psf, please provide\n", + "# it here.\n", + "path = \"../tests/TestData/psf_kernels_for_deflector.npy\"\n", + "psf_kernel = 1 * np.load(path)\n", + "psf_kernel[psf_kernel < 0] = 0\n", + "transform_matrix = np.array([[0.2, 0], [0, 0.2]])\n", + "\n", + "# let's set up psf kernel for each exposure. Here we have taken the same psf that we\n", + "# extracted above. However, each exposure can have different psf kernel and user should\n", + "# provide corresponding psf kernel to each exposure.\n", + "psf_kernel_list = [psf_kernel]\n", + "transform_matrix_list = [transform_matrix]\n", + "psf_kernels_all = psf_kernel_list * repeats\n", + "# psf_kernels_all = np.array([dp0[\"psf_kernel\"][:10]])[0]\n", + "\n", + "# let's set pixel to angle transform matrix. Here we have taken the same matrix for\n", + "# each exposure but user should provide corresponding transform matrix to each exposure.\n", + "transform_matrix_all = transform_matrix_list * repeats\n", + "\n", + "# provide magnitude zero point for each exposures. Here we have taken the same magnitude\n", + "# zero point for each exposure but user should provide the corresponding magnitude\n", + "# zero point for each exposure.\n", + "mag_list = [31.0]\n", + "mag_zero_points_all = mag_list * repeats\n", + "# mag_zero_points_all = np.array([dp0[\"zero_point\"][:10]])[0]\n", + "\n", + "expo_list = [30]\n", + "exposure_time_all = expo_list * repeats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulate Image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Simulate a lens image\n", + "image_lens_series = lens_image_series(\n", + " lens_class=lens_class,\n", + " band=\"i\",\n", + " mag_zero_point=mag_zero_points_all,\n", + " num_pix=32,\n", + " psf_kernel=psf_kernels_all,\n", + " transform_pix2angle=transform_matrix_all,\n", + " exposure_time=exposure_time_all,\n", + " t_obs=time,\n", + " with_deflector=True,\n", + " with_source=True,\n", + ")\n", + "\n", + "# Make opsim_lens_image_series function (main difference: bands [list] instead of band [number])\n", + "# Also make a function to plot light curve with observations" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "## Images in log scale\n", + "log_images = []\n", + "for i in range(len(image_lens_series)):\n", + " log_images.append(np.log10(image_lens_series[i]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize simulated images" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_montage = create_image_montage_from_image_list(\n", + " num_rows=2, num_cols=5, images=image_lens_series, time=time, image_center=pix_coord\n", + ")\n", + "\n", + "# add \"band=band\" and add as text to plots" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Notes\n", + "\n", + "- Can I make a separate function to calculate the zero point?\n", + "\n", + "- calexp_center just contains the object coordinates so is currently a lot of duplicates for each epoch. Maybe there's a more efficient way to save it (or maybe it doesn't matter). \n", + "\n", + "- 'injected_lens' now contains the same as 'lens', because there is no background image\n", + "\n", + "- if catalog_type=None instead of \"scotch\", something goes wrong with the column names. I get the error: ellipticity or semi-major and semi-minor axis are missing for the first light profile in galaxy_list columns.\n", + "- Light curve looks a bit strange for a type Ia SN?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (slsim)", + "language": "python", + "name": "slsim" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 42fc1bbffa922ba31f298f827afea275fd391ae0 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 30 Jul 2024 16:29:17 +0200 Subject: [PATCH 11/50] started new notebook to test the opsim implementation --- notebooks/lens_source_injection-Copy1.ipynb | 845 ++++++++++++++++++++ 1 file changed, 845 insertions(+) create mode 100644 notebooks/lens_source_injection-Copy1.ipynb diff --git a/notebooks/lens_source_injection-Copy1.ipynb b/notebooks/lens_source_injection-Copy1.ipynb new file mode 100644 index 000000000..5c098f92e --- /dev/null +++ b/notebooks/lens_source_injection-Copy1.ipynb @@ -0,0 +1,845 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "fd70c97a", + "metadata": {}, + "outputs": [], + "source": [ + "import opsimsummaryv2 as op" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "64d66921", + "metadata": { + "execution": { + "iopub.execute_input": "2023-08-14T22:44:03.255969Z", + "iopub.status.busy": "2023-08-14T22:44:03.254836Z", + "iopub.status.idle": "2023-08-14T22:44:06.388495Z", + "shell.execute_reply": "2023-08-14T22:44:06.387611Z", + "shell.execute_reply.started": "2023-08-14T22:44:03.255926Z" + }, + "scrolled": false, + "tags": [] + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import sys\n", + "from astropy.cosmology import FlatLambdaCDM\n", + "from astropy.units import Quantity\n", + "from slsim.lens_pop import LensPop\n", + "from slsim.image_simulation import (\n", + " sharp_image,\n", + " sharp_rgb_image,\n", + " rgb_image_from_image_list,\n", + ")\n", + "import galsim\n", + "import mpl_toolkits.axisartist.floating_axes as floating_axes\n", + "from mpl_toolkits.axisartist.grid_finder import MaxNLocator, DictFormatter\n", + "from matplotlib.transforms import Affine2D\n", + "# import lsst.daf.butler as dafButler\n", + "# import lsst.geom as geom\n", + "# import lsst.afw.display as afwDisplay\n", + "# from lsst.pipe.tasks.insertFakes import _add_fake_sources\n", + "from slsim import lsst_science_pipeline\n", + "import astropy.coordinates as coord\n", + "import astropy.units as u" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fee1fe4a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "28ee0ced", + "metadata": {}, + "outputs": [], + "source": [ + "print(\"done\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b1935849", + "metadata": {}, + "outputs": [], + "source": [ + "# Import OpSimSummaryV2\n", + "try:\n", + " import opsimsummaryv2 as op\n", + "except ImportError:\n", + " raise ImportError(\n", + " \"Users need to have OpSimSummaryV2 installed (https://github.com/bastiencarreres/OpSimSummaryV2)\"\n", + " )\n", + "\n", + "# Initialise OpSimSummaryV2 with opsim database\n", + "try:\n", + " opsim_path = \"../data/OpSim_database/\" + obs_strategy + \".db\"\n", + " OpSimSurv = op.OpSimSurvey(opsim_path)\n", + "except FileNotFoundError:\n", + " raise FileNotFoundError(\n", + " \"File not found: \" + opsim_path + \". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database\"\n", + " )\n", + "\n", + "# Collect observations that cover the coordinates in ra_list and dec_list\n", + "gen = OpSimSurv.get_obs_from_coords(ra_list, dec_list, is_deg=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bec351fa", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "993a0b60", + "metadata": {}, + "outputs": [], + "source": [ + "N = 10\n", + "\n", + "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", + "ra_points = ra_points.wrap_at(180*u.degree)\n", + "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", + "dec_points = coord.Angle(dec_points * u.degree)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0dac9d61", + "metadata": {}, + "outputs": [], + "source": [ + "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(ra_points, dec_points, \"baseline_v3.0_10yrs\",\n", + " MJD_min=60000, MJD_max=60300)\n", + "exposure_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5767de15", + "metadata": {}, + "outputs": [], + "source": [ + "# add galsim to requirements\n", + "# colossus is listed twice" + ] + }, + { + "cell_type": "markdown", + "id": "f3c701c3", + "metadata": {}, + "source": [ + "## Lensed source injection in DC2 data" + ] + }, + { + "cell_type": "markdown", + "id": "ab92b75c-4ce7-4d54-b8bb-68d3db80eb7b", + "metadata": {}, + "source": [ + "This notebook uses slsim to generate lens-deflector population. Then, we select a random lens-deflector\n", + "\n", + "and inject it to a patch of the DC2 data." + ] + }, + { + "cell_type": "markdown", + "id": "60e07f48-9aeb-45e0-9454-eacebcfc4921", + "metadata": {}, + "source": [ + "## Generate population of sources and deflectors" + ] + }, + { + "cell_type": "markdown", + "id": "d79f6fa6-296a-447c-8cfa-f133a4c0d7bd", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-21T18:51:20.484913Z", + "iopub.status.busy": "2023-07-21T18:51:20.484398Z", + "iopub.status.idle": "2023-07-21T18:51:20.490580Z", + "shell.execute_reply": "2023-07-21T18:51:20.489623Z", + "shell.execute_reply.started": "2023-07-21T18:51:20.484880Z" + }, + "tags": [] + }, + "source": [ + "Using slsim one can generate galaxy-galaxy lenses." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0d48388-dee5-4488-81f4-b3d636b3a698", + "metadata": { + "execution": { + "iopub.execute_input": "2023-08-14T22:43:59.996001Z", + "iopub.status.busy": "2023-08-14T22:43:59.994972Z", + "iopub.status.idle": "2023-08-14T22:44:00.000126Z", + "shell.execute_reply": "2023-08-14T22:43:59.999335Z", + "shell.execute_reply.started": "2023-08-14T22:43:59.995960Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "## Users should change this path to their slsim path\n", + "sys.path.insert(0, \"../slsim/\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "834ce91e-1958-4c80-b35a-107720c4ff72", + "metadata": { + "execution": { + "iopub.execute_input": "2023-08-14T22:44:11.102224Z", + "iopub.status.busy": "2023-08-14T22:44:11.101637Z", + "iopub.status.idle": "2023-08-14T22:44:43.143147Z", + "shell.execute_reply": "2023-08-14T22:44:43.142083Z", + "shell.execute_reply.started": "2023-08-14T22:44:11.102187Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# define a cosmology\n", + "cosmo = FlatLambdaCDM(H0=70, Om0=0.3)\n", + "\n", + "# define a sky area\n", + "sky_area = Quantity(value=0.1, unit=\"deg2\")\n", + "\n", + "\n", + "# define limits in the intrinsic deflector and source population (in addition to the skypy config\n", + "# file)\n", + "kwargs_deflector_cut = {\"band\": \"g\", \"band_max\": 28, \"z_min\": 0.01, \"z_max\": 2.5}\n", + "kwargs_source_cut = {\"band\": \"g\", \"band_max\": 28, \"z_min\": 0.1, \"z_max\": 5.0}\n", + "\n", + "# run skypy pipeline and make galaxy-galaxy population class using LensPop\n", + "gg_lens_pop = LensPop(\n", + " deflector_type=\"all-galaxies\",\n", + " source_type=\"galaxies\",\n", + " kwargs_deflector_cut=kwargs_deflector_cut,\n", + " kwargs_source_cut=kwargs_source_cut,\n", + " kwargs_mass2light=None,\n", + " skypy_config=None,\n", + " sky_area=sky_area,\n", + " cosmo=cosmo,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "568932d9-f62a-4a5e-945f-f5b82647039e", + "metadata": {}, + "source": [ + "## Select a lens at random and generate a high resolution image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "efa81c8a-8404-40f2-a0b3-70e13ff1611e", + "metadata": { + "execution": { + "iopub.execute_input": "2023-08-14T22:49:58.155179Z", + "iopub.status.busy": "2023-08-14T22:49:58.153874Z", + "iopub.status.idle": "2023-08-14T22:49:58.551444Z", + "shell.execute_reply": "2023-08-14T22:49:58.550418Z", + "shell.execute_reply.started": "2023-08-14T22:49:58.155139Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "kwargs_lens_cut = {\n", + " \"min_image_separation\": 3,\n", + " \"max_image_separation\": 10,\n", + " \"mag_arc_limit\": {\"g\": 22, \"r\": 22, \"i\": 22},\n", + "}\n", + "rgb_band_list = [\"i\", \"r\", \"g\"]\n", + "lens_class = gg_lens_pop.select_lens_at_random(**kwargs_lens_cut)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9dce1a91-2c90-4f6e-b3cb-b18547c33c87", + "metadata": { + "execution": { + "iopub.execute_input": "2023-08-14T22:50:02.322956Z", + "iopub.status.busy": "2023-08-14T22:50:02.321951Z", + "iopub.status.idle": "2023-08-14T22:50:02.432770Z", + "shell.execute_reply": "2023-08-14T22:50:02.431771Z", + "shell.execute_reply.started": "2023-08-14T22:50:02.322913Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "image_i_1 = sharp_image(\n", + " lens_class=lens_class,\n", + " band=rgb_band_list[0],\n", + " mag_zero_point=27,\n", + " delta_pix=0.2,\n", + " num_pix=200,\n", + ")\n", + "image_r_1 = sharp_image(\n", + " lens_class=lens_class,\n", + " band=rgb_band_list[1],\n", + " mag_zero_point=27,\n", + " delta_pix=0.2,\n", + " num_pix=200,\n", + ")\n", + "image_g_1 = sharp_image(\n", + " lens_class=lens_class,\n", + " band=rgb_band_list[2],\n", + " mag_zero_point=27,\n", + " delta_pix=0.2,\n", + " num_pix=200,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9f44dc9c-1999-481b-87d9-bbaa6782395d", + "metadata": { + "execution": { + "iopub.execute_input": "2023-08-14T22:50:05.761403Z", + "iopub.status.busy": "2023-08-14T22:50:05.760033Z", + "iopub.status.idle": "2023-08-14T22:50:05.958947Z", + "shell.execute_reply": "2023-08-14T22:50:05.958217Z", + "shell.execute_reply.started": "2023-08-14T22:50:05.761345Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# image_g.shape\n", + "plt.imshow(image_i_1, origin=\"lower\")\n", + "plt.xlim(75, 125)\n", + "plt.ylim(75, 125)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad707603-1867-4014-96b7-234d60fd03fb", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-21T18:48:11.924529Z", + "iopub.status.busy": "2023-07-21T18:48:11.923414Z", + "iopub.status.idle": "2023-07-21T18:48:12.102182Z", + "shell.execute_reply": "2023-07-21T18:48:12.101351Z", + "shell.execute_reply.started": "2023-07-21T18:48:11.924461Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "high_reso_rgb = sharp_rgb_image(\n", + " lens_class=lens_class,\n", + " rgb_band_list=rgb_band_list,\n", + " mag_zero_point=27,\n", + " delta_pix=0.2,\n", + " num_pix=200,\n", + ")\n", + "\n", + "plt.imshow(high_reso_rgb, origin=\"lower\")\n", + "plt.xlim(75, 125)\n", + "plt.ylim(75, 125)" + ] + }, + { + "cell_type": "markdown", + "id": "b7fdb441-5312-4615-a388-de5d4e2c2e7a", + "metadata": {}, + "source": [ + "## Inject the randomly selected lens " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3583a71-357a-4a32-8ffc-3093d58cffe6", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-31T21:23:45.432354Z", + "iopub.status.busy": "2023-07-31T21:23:45.431497Z", + "iopub.status.idle": "2023-07-31T21:23:45.435397Z", + "shell.execute_reply": "2023-07-31T21:23:45.434770Z", + "shell.execute_reply.started": "2023-07-31T21:23:45.432323Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "ra = 62.541629 # degrees\n", + "dec = -37.852021 # degrees\n", + "\n", + "ra_list = [ra]\n", + "dec_list = [dec]\n", + "delta_pix = 0.2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "af429deb", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "import opsimsummary\n", + "\n", + "Replace np.int by int \n", + "~/anaconda3/envs/slsim/lib/python3.12/site-packages/opsimsummary/summarize_opsim.py" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "42db18da-5d0a-4dfc-86e6-7314936b4005", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-31T21:23:47.574166Z", + "iopub.status.busy": "2023-07-31T21:23:47.573355Z", + "iopub.status.idle": "2023-07-31T21:23:58.136282Z", + "shell.execute_reply": "2023-07-31T21:23:58.135425Z", + "shell.execute_reply.started": "2023-07-31T21:23:47.574135Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "y = lsst_science_pipeline.lens_inejection(\n", + " gg_lens_pop, 201, 0.2, butler, ra, dec, flux=None\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "870ff6da-17d5-459a-90c5-8c0b0fb1b3f0", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-31T21:25:26.587461Z", + "iopub.status.busy": "2023-07-31T21:25:26.586546Z", + "iopub.status.idle": "2023-07-31T21:25:26.593078Z", + "shell.execute_reply": "2023-07-31T21:25:26.592444Z", + "shell.execute_reply.started": "2023-07-31T21:25:26.587426Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "## This line should display an astropy table containg lens image,dp0 cutout_image, injected_lens\n", + "## in r, g, and i band and center of the dp0 cutout images.\n", + "y" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "58113000", + "metadata": {}, + "outputs": [], + "source": [ + "import lenstronomy.Util.kernel_util as kernel_util\n", + "import lenstronomy.Util.util as util\n", + "import lenstronomy.Util.data_util as data_util\n", + "from astropy.table import Table, vstack\n", + "\n", + "size = 101\n", + "delta_pix = 0.2\n", + "psf_fwhm = 0.7\n", + "moffat_beta = 3.1\n", + "\n", + "# Create a Moffat psf kernel\n", + "psf_kernel = kernel_util.kernel_moffat(num_pix=size, delta_pix=delta_pix, fwhm=psf_fwhm, \n", + " moffat_beta=moffat_beta)\n", + "\n", + "psf_kernel = util.array2image(psf_kernel)\n", + "\n", + "psf_kernel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "163711f9", + "metadata": {}, + "outputs": [], + "source": [ + "def opsim_time_series_images_data2(\n", + " ra_list, dec_list, obs_strategy, MJD_min=60000, MJD_max=64000, size=101, moffat_beta=3.1, \n", + " readout_noise=10, delta_pix=0.2\n", + "):\n", + " \"\"\"Creates time series data from opsim database.\n", + "\n", + " :param ra_list: a list of ra points (in degrees) from objects we want to collect\n", + " observations for\n", + " :param dec_list: a list of dec points (in degrees) from objects we want to collect\n", + " observations for\n", + " :param obs_strategy: version of observing strategy corresponding to opsim database.\n", + " for example \"baseline_v3.0_10yrs\" (string)\n", + " :param size: cutout size of images (in pixels)\n", + " :param moffat_beta: power index of the moffat psf kernel\n", + " :param readout_noise: noise added per readout\n", + " :param delta_pix: size of pixel in units arcseonds\n", + " :return: a list of astropy tables containing observation information for each\n", + " coordinate\n", + " \"\"\"\n", + "\n", + " # Import OpSimSummaryV2\n", + " try:\n", + " import opsimsummaryv2 as op\n", + " except ImportError:\n", + " raise ImportError(\n", + " \"Users need to have OpSimSummaryV2 installed (https://github.com/bastiencarreres/OpSimSummaryV2)\"\n", + " )\n", + "\n", + " # Initialise OpSimSummaryV2 with opsim database\n", + " try:\n", + " opsim_path = \"../data/OpSim_database/\" + obs_strategy + \".db\"\n", + " OpSimSurv = op.OpSimSurvey(opsim_path)\n", + " except FileNotFoundError:\n", + " raise FileNotFoundError(\n", + " \"File not found: \" + opsim_path + \". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database\"\n", + " )\n", + "\n", + " # Collect observations that cover the coordinates in ra_list and dec_list\n", + " gen = OpSimSurv.get_obs_from_coords(ra_list, dec_list, is_deg=True)\n", + "\n", + " table_data_list = []\n", + "\n", + " # Loop through all coordinates and compute the table_data\n", + " for i in range(len(ra_list)):\n", + "\n", + " # Collect the next observation sequence from the opsim generator\n", + " seq = next(gen)\n", + " seq = seq.sort_values(by=[\"observationStartMJD\"])\n", + "\n", + " # Check if the coordinates are in the opsim LSST footprint\n", + " opsim_ra = np.mean(seq[\"fieldRA\"])\n", + " opsim_dec = np.mean(seq[\"fieldDec\"])\n", + "\n", + " if np.isnan(opsim_ra) or np.isnan(opsim_dec):\n", + " print(\n", + " f\"Coordinate ({ra_list[i]}, {dec_list[i]}) is not in the LSST footprint. This entry is skipped.\"\n", + " )\n", + " continue\n", + "\n", + " # Get the relevant properties from opsim\n", + " obs_time = np.array(seq[\"observationStartMJD\"])\n", + " \n", + " # Only give the observations between MJD_min and MJD_max\n", + " mask = (obs_time > MJD_min) & (obs_time < MJD_max)\n", + " obs_time = obs_time[mask]\n", + " \n", + " expo_time = np.array(seq[\"visitExposureTime\"])[mask]\n", + " sky_brightness = np.array(seq[\"skyBrightness\"])[mask]\n", + " bandpass = np.array(seq[\"filter\"])[mask]\n", + " psf_fwhm = np.array(seq[\"seeingFwhmGeom\"])[mask]\n", + " m5_depth = np.array(seq[\"fiveSigmaDepth\"])[mask]\n", + " # Question: use 'FWHMeff' or 'seeingFwhmGeom' for the psf?\n", + " \n", + " radec_list = [(ra_list[i], dec_list[i])] * len(obs_time)\n", + "\n", + " # Create a Moffat psf kernel for each epoch\n", + " \n", + " psf_kernels = []\n", + " \n", + " for psf in psf_fwhm:\n", + " \n", + " psf_kernel = kernel_util.kernel_moffat(\n", + " num_pix=size, delta_pix=delta_pix, fwhm=psf, moffat_beta=moffat_beta\n", + " )\n", + " psf_kernel = util.array2image(psf_kernel)\n", + " \n", + " psf_kernels.append(psf_kernel)\n", + " \n", + " psf_kernels = np.array(psf_kernels)\n", + "\n", + " # Calculate background noise\n", + " bkg_noise = data_util.bkg_noise(readout_noise, expo_time, sky_brightness, delta_pix, num_exposures=1)\n", + "\n", + " # Calculate the zero point magnitude\n", + " # Code from OpSimSummary/opsimsummary/simlib.py/add_simlibCols\n", + " # need to work in nvariance in photon electrons\n", + " term1 = 2.0 * m5_depth - sky_brightness # * pixArea whata units is sky birghtness? counts or photo electrons?\n", + " # per pixel or arcsec?\n", + " term2 = -(m5_depth - sky_brightness) # * pixArea\n", + " area = (1.51 * psf_fwhm) ** 2.0 # area = 1 / int(psf^2)\n", + " opsim_snr = 5.0\n", + " arg = area * opsim_snr * opsim_snr\n", + " # Background dominated limit assuming counts with system transmission only\n", + " # is approximately equal to counts with total transmission\n", + " zpt_approx = term1 + 2.5 * np.log10(arg)\n", + " val = -0.4 * term2\n", + " tmp = 10.0**val\n", + " # Additional term to account for photons from the source, again assuming\n", + " # that counts with system transmission approximately equal counts with total transmission.\n", + " zpt_cor = 2.5 * np.log10(1.0 + 1.0 / (area * tmp))\n", + " zero_point_mag = zpt_approx + zpt_cor\n", + " \n", + " table_data = Table(\n", + " [\n", + " bkg_noise,\n", + " psf_kernels,\n", + " obs_time,\n", + " expo_time,\n", + " zero_point_mag,\n", + " radec_list,\n", + " bandpass,\n", + " ],\n", + " names=(\n", + " \"bkg_noise\",\n", + " \"psf_kernel\",\n", + " \"obs_time\",\n", + " \"expo_time\",\n", + " \"zero_point\",\n", + " \"calexp_center\",\n", + " \"band\",\n", + " ),\n", + " )\n", + "\n", + " table_data_list.append(table_data)\n", + " return table_data_list" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05f8b9a2", + "metadata": {}, + "outputs": [], + "source": [ + "def opsim_variable_lens_injection(\n", + " lens_class, bands, num_pix, transform_pix2angle, exposure_data\n", + "):\n", + " \"\"\"Injects variable lens to the OpSim time series data (1 object).\n", + "\n", + " :param lens_class: Lens() object\n", + " :param bands: list of imaging bands of interest\n", + " :param num_pix: number of pixels per axis\n", + " :param transform_pix2angle: transformation matrix (2x2) of pixels into coordinate\n", + " displacements\n", + " :param exposure_data: An astropy table of exposure data. One entry of table_list_data\n", + " generated from the opsim_time_series_images_data function. It must contain the rms of\n", + " background noise fluctuations (column name should be \"bkg_noise\"), psf kernel for\n", + " each exposure (column name should be \"psf_kernel\", these are pixel psf kernel\n", + " for each single exposure images in time series image), observation time\n", + " (column name should be \"obs_time\", these are observation time in days for each\n", + " single exposure images in time series images), exposure time (column name should\n", + " be \"expo_time\", these are exposure time for each single exposure images in time\n", + " series images), magnitude zero point (column name should be \"zero_point\", these\n", + " are zero point magnitudes for each single exposure images in time series image),\n", + " coordinates of the object (column name should be \"calexp_center\"), these are\n", + " the coordinates in (ra, dec), and the band in which the observation is taken\n", + " (column name should be \"band\").\n", + "\n", + " :return: Astropy table of injected lenses and exposure information of dp0 data\n", + " \"\"\"\n", + "\n", + " final_image = []\n", + "\n", + " for obs in range(len(exposure_data[\"obs_time\"])):\n", + "\n", + " exposure_data_obs = exposure_data[obs]\n", + "\n", + " if exposure_data_obs[\"band\"] not in bands:\n", + " continue\n", + "\n", + " if \"bkg_noise\" in exposure_data_obs.keys():\n", + " std_gaussian_noise = exposure_data_obs[\"bkg_noise\"]\n", + " else:\n", + " std_gaussian_noise = None\n", + "\n", + " lens_images = lens_image(\n", + " lens_class,\n", + " band=exposure_data_obs[\"band\"],\n", + " mag_zero_point=exposure_data_obs[\"zero_point\"],\n", + " num_pix=num_pix,\n", + " psf_kernel=exposure_data_obs[\"psf_kernel\"],\n", + " transform_pix2angle=transform_pix2angle,\n", + " exposure_time=exposure_data_obs[\"expo_time\"],\n", + " t_obs=exposure_data_obs[\"obs_time\"],\n", + " std_gaussian_noise=std_gaussian_noise\n", + " )\n", + "\n", + " final_image.append(lens_images)\n", + "\n", + " lens_col = Column(name=\"lens\", data=final_image)\n", + " final_image_col = Column(name=\"injected_lens\", data=final_image)\n", + " \n", + " # Create a new Table with only the bands of interest\n", + " mask = np.isin(exposure_data['band'], bands)\n", + " exposure_data_new = exposure_data[mask]\n", + " exposure_data_new.add_columns([lens_col, final_image_col])\n", + " return exposure_data_new" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce7e0143", + "metadata": {}, + "outputs": [], + "source": [ + "N = 100\n", + "\n", + "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", + "ra_points = ra_points.wrap_at(180*u.degree)\n", + "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", + "dec_points = coord.Angle(dec_points * u.degree)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8bf9fa6b", + "metadata": {}, + "outputs": [], + "source": [ + "exposure_data = opsim_time_series_images_data2(ra_points, dec_points, \"baseline_v3.0_10yrs\",\n", + " MJD_min=60000, MJD_max=60300)\n", + "exposure_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cdbc63a1", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "from slsim.image_simulation import (\n", + " sharp_image,\n", + " lens_image,\n", + " lens_image_series,\n", + ")\n", + "from astropy.table import Column\n", + "\n", + "index = 1\n", + "bands = ['g','r','i','z']\n", + "num_pix = 200\n", + "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", + "\n", + "images = opsim_variable_lens_injection(lens_class, bands, num_pix, transform_pix2angle, exposure_data[index])\n", + "images" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cfc320b6", + "metadata": {}, + "outputs": [], + "source": [ + "print(\"band: \", images['band'][10])\n", + "plt.imshow(images['injected_lens'][10])\n", + "plt.xlim(75, 125)\n", + "plt.ylim(75, 125)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df583ea6", + "metadata": {}, + "outputs": [], + "source": [ + "np.array(exposure_data[0][\"band\"]) in np.array(bands)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "547d9c77", + "metadata": {}, + "outputs": [], + "source": [ + "len(exposure_data[0])" + ] + }, + { + "cell_type": "markdown", + "id": "6a20f7e9", + "metadata": {}, + "source": [ + "### Notes\n", + "\n", + "Can I make a separate function to calculate the zero point?\n", + "\n", + "calexp_center just contains the object coordinates so is currently a lot of duplicates for each epoch. Maybe there's a more efficient way to save it (or maybe it doesn't matter). \n", + "\n", + "'injected_lens' now contains the same as 'lens', because there is no background image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9544527b", + "metadata": {}, + "outputs": [], + "source": [ + "# Next steps: test it out for lensed SN (see the other notebook, try to recreate that with the opsim class)\n", + "# do the images make sense with the input?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "895352f9", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:opsimsummary_test]", + "language": "python", + "name": "conda-env-opsimsummary_test-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6b51978c48d95b300e11f1f4e19ddf52c6eddcd2 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 30 Jul 2024 16:37:10 +0200 Subject: [PATCH 12/50] created function opsim_variable_lens_injection --- slsim/lsst_science_pipeline.py | 160 +++++++++++++++++++++++++-------- 1 file changed, 121 insertions(+), 39 deletions(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 5fb0c9fab..7911b45a4 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -13,6 +13,7 @@ from slsim.image_simulation import point_source_coordinate_properties import lenstronomy.Util.util as util import lenstronomy.Util.kernel_util as kernel_util +import lenstronomy.Util.data_util as data_util from slsim.Util.param_util import random_ra_dec import h5py @@ -752,7 +753,8 @@ def dp0_time_series_images_data(butler, center_coord, radius="0.1", band="i", si def opsim_time_series_images_data( - ra_list, dec_list, delta_pix, size=101, moffat_beta=3.1 + ra_list, dec_list, obs_strategy, MJD_min=60000, MJD_max=64000, size=101, moffat_beta=3.1, + readout_noise=10, delta_pix=0.2 ): """Creates time series data from opsim database. @@ -760,51 +762,46 @@ def opsim_time_series_images_data( observations for :param dec_list: a list of dec points (in degrees) from objects we want to collect observations for - :param delta_pix: pixel scale in arcseconds for the psf kernel + :param obs_strategy: version of observing strategy corresponding to opsim database. + for example "baseline_v3.0_10yrs" (string) + :param MJD_min: minimum MJD for the observations + :param MJD_max: maximum MJD for the observations :param size: cutout size of images (in pixels) :param moffat_beta: power index of the moffat psf kernel + :param readout_noise: noise added per readout + :param delta_pix: size of pixel in units arcseonds :return: a list of astropy tables containing observation information for each coordinate """ - # Import opsimsummary + # Import OpSimSummaryV2 try: - from opsimsummary import SynOpSim + import opsimsummaryv2 as op except ImportError: raise ImportError( - "Users need to have the right branch of opsimsummary installed (Issue#325/proposalTables)" + "Users need to have OpSimSummaryV2 installed (https://github.com/bastiencarreres/OpSimSummaryV2)" ) - # Initialise opsimsummary with opsim database + # Initialise OpSimSummaryV2 with opsim database try: - opsim_path = "../data/OpSim_database/opsim.db" - synopsim = SynOpSim.fromOpSimDB( - opsim_path, - opsimversion="fbsv2", - usePointingTree=True, - use_proposal_table=False, - subset="unique_all", - ) + opsim_path = "../data/OpSim_database/" + obs_strategy + ".db" + OpSimSurv = op.OpSimSurvey(opsim_path) except FileNotFoundError: raise FileNotFoundError( - "Users need to have an opsim database downloaded at ../data/OpSim_database/opsim.db" + "File not found: " + opsim_path + ". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database" ) # Collect observations that cover the coordinates in ra_list and dec_list - gen = synopsim.pointingsEnclosing( - ra_list, dec_list, circRadius=0.0, pointingRadius=1.75, usePointingTree=True - ) + gen = OpSimSurv.get_obs_from_coords(ra_list, dec_list, is_deg=True) table_data_list = [] # Loop through all coordinates and compute the table_data for i in range(len(ra_list)): - radec_list = [(ra_list[i], dec_list[i])] - # Collect the next observation sequence from the opsim generator seq = next(gen) - seq = seq.sort_values(by=["expMJD"]) + seq = seq.sort_values(by=["observationStartMJD"]) # Check if the coordinates are in the opsim LSST footprint opsim_ra = np.mean(seq["fieldRA"]) @@ -816,33 +813,53 @@ def opsim_time_series_images_data( ) continue - # Get the observation times, exposure times, sky brightness, bandpass, and psf fwhm from opsim - obs_time = np.array(seq["expMJD"]) - expo_time = np.array(seq["visitExposureTime"]) - sky_brightness = np.array(seq["filtSkyBrightness"]) - bandpass = np.array(seq["filter"]) - psf_fwhm = np.array(seq["seeingFwhmGeom"]) - m5_depth = np.array(seq["fiveSigmaDepth"]) + # Get the relevant properties from opsim + obs_time = np.array(seq["observationStartMJD"]) + + # Only give the observations between MJD_min and MJD_max + mask = (obs_time > MJD_min) & (obs_time < MJD_max) + obs_time = obs_time[mask] + + expo_time = np.array(seq["visitExposureTime"])[mask] + sky_brightness = np.array(seq["skyBrightness"])[mask] + bandpass = np.array(seq["filter"])[mask] + psf_fwhm = np.array(seq["seeingFwhmGeom"])[mask] + m5_depth = np.array(seq["fiveSigmaDepth"])[mask] # Question: use 'FWHMeff' or 'seeingFwhmGeom' for the psf? - # Create a Moffat psf kernel - psf_kernel = kernel_util.kernel_moffat( - num_pix=size, delta_pix=delta_pix, fwhm=psf_fwhm, moffat_beta=moffat_beta - ) - psf_kernel = util.array2image(psf_kernel) + radec_list = [(ra_list[i], dec_list[i])] * len(obs_time) + + # Create a Moffat psf kernel for each epoch + + psf_kernels = [] + + for psf in psf_fwhm: + psf_kernel = kernel_util.kernel_moffat( + num_pix=size, delta_pix=delta_pix, fwhm=psf, moffat_beta=moffat_beta + ) + psf_kernel = util.array2image(psf_kernel) + + psf_kernels.append(psf_kernel) + + psf_kernels = np.array(psf_kernels) + + # Calculate background noise + bkg_noise = data_util.bkg_noise(readout_noise, expo_time, sky_brightness, delta_pix, num_exposures=1) # Calculate the zero point magnitude # Code from OpSimSummary/opsimsummary/simlib.py/add_simlibCols - term1 = 2.0 * m5_depth - sky_brightness # * pixArea + # need to work in nvariance in photon electrons + term1 = 2.0 * m5_depth - sky_brightness # * pixArea whata units is sky birghtness? counts or photo electrons? + # per pixel or arcsec? term2 = -(m5_depth - sky_brightness) # * pixArea - area = (1.51 * psf_fwhm) ** 2.0 + area = (1.51 * psf_fwhm) ** 2.0 # area = 1 / int(psf^2) opsim_snr = 5.0 arg = area * opsim_snr * opsim_snr # Background dominated limit assuming counts with system transmission only # is approximately equal to counts with total transmission zpt_approx = term1 + 2.5 * np.log10(arg) val = -0.4 * term2 - tmp = 10.0**val + tmp = 10.0 ** val # Additional term to account for photons from the source, again assuming # that counts with system transmission approximately equal counts with total transmission. zpt_cor = 2.5 * np.log10(1.0 + 1.0 / (area * tmp)) @@ -850,8 +867,8 @@ def opsim_time_series_images_data( table_data = Table( [ - sky_brightness, - psf_kernel, + bkg_noise, + psf_kernels, obs_time, expo_time, zero_point_mag, @@ -859,7 +876,7 @@ def opsim_time_series_images_data( bandpass, ], names=( - "sky_brightness", + "bkg_noise", "psf_kernel", "obs_time", "expo_time", @@ -873,6 +890,71 @@ def opsim_time_series_images_data( return table_data_list +def opsim_variable_lens_injection( + lens_class, bands, num_pix, transform_pix2angle, exposure_data +): + """Injects variable lens to the OpSim time series data (1 object). + + :param lens_class: Lens() object + :param bands: list of imaging bands of interest + :param num_pix: number of pixels per axis + :param transform_pix2angle: transformation matrix (2x2) of pixels into coordinate + displacements + :param exposure_data: An astropy table of exposure data. One entry of table_list_data + generated from the opsim_time_series_images_data function. It must contain the rms of + background noise fluctuations (column name should be "bkg_noise"), psf kernel for + each exposure (column name should be "psf_kernel", these are pixel psf kernel + for each single exposure images in time series image), observation time + (column name should be "obs_time", these are observation time in days for each + single exposure images in time series images), exposure time (column name should + be "expo_time", these are exposure time for each single exposure images in time + series images), magnitude zero point (column name should be "zero_point", these + are zero point magnitudes for each single exposure images in time series image), + coordinates of the object (column name should be "calexp_center"), these are + the coordinates in (ra, dec), and the band in which the observation is taken + (column name should be "band"). + + :return: Astropy table of injected lenses and exposure information of dp0 data + """ + + final_image = [] + + for obs in range(len(exposure_data["obs_time"])): + + exposure_data_obs = exposure_data[obs] + + if exposure_data_obs["band"] not in bands: + continue + + if "bkg_noise" in exposure_data_obs.keys(): + std_gaussian_noise = exposure_data_obs["bkg_noise"] + else: + std_gaussian_noise = None + + lens_images = lens_image( + lens_class, + band=exposure_data_obs["band"], + mag_zero_point=exposure_data_obs["zero_point"], + num_pix=num_pix, + psf_kernel=exposure_data_obs["psf_kernel"], + transform_pix2angle=transform_pix2angle, + exposure_time=exposure_data_obs["expo_time"], + t_obs=exposure_data_obs["obs_time"], + std_gaussian_noise=std_gaussian_noise + ) + + final_image.append(lens_images) + + lens_col = Column(name="lens", data=final_image) + final_image_col = Column(name="injected_lens", data=final_image) + + # Create a new Table with only the bands of interest + mask = np.isin(exposure_data['band'], bands) + exposure_data_new = exposure_data[mask] + exposure_data_new.add_columns([lens_col, final_image_col]) + return exposure_data_new + + def variable_lens_injection( lens_class, band, num_pix, transform_pix2angle, exposure_data ): From 3e7935f04ca8824f49ae7056d35d7c6e1f63b4d6 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 30 Jul 2024 16:43:25 +0200 Subject: [PATCH 13/50] updated .gitignore to exclude the large opsim and scotch files --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index f9400b5f8..5f6e86188 100644 --- a/.gitignore +++ b/.gitignore @@ -35,6 +35,8 @@ share/python-wheels/ .installed.cfg *.egg MANIFEST +data/OpSim_database/ +data/Scotch/ # PyInstaller # Usually these files are written by a python script from a template From 5b3c5f5636f1f4fc7a69d7960ed87c9a9a37b8a0 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 30 Jul 2024 14:50:54 +0000 Subject: [PATCH 14/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- ...rnovae_plus_extended_source_tutorial.ipynb | 29 ++++--- notebooks/lens_source_injection-Copy1.ipynb | 84 ++++++++++++------- slsim/lsst_science_pipeline.py | 58 ++++++++----- 3 files changed, 105 insertions(+), 66 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index 1d26db9a2..61181f0ad 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -94,8 +94,7 @@ " lightcurve_time=np.linspace(\n", " -20, 100, 1000\n", " ), # array of light curve observation time.\n", - " catalog_path=\"../data/Scotch/\"\n", - " + \"scotch_SNIa_host_galaxies.fits\",\n", + " catalog_path=\"../data/Scotch/\" + \"scotch_SNIa_host_galaxies.fits\",\n", " # path for catalog. If not provided, small size catalog from\n", " # /slsim/Source/SupernovaeCatalog will be used for\n", " # source_type=\"supernovae_plus_galaxies\" case. For other cases, we do not need to\n", @@ -118,8 +117,13 @@ } ], "source": [ - "print(\"Found\", supernova_lens_pop.deflector_number, \"potential lenses and\",\n", - " supernova_lens_pop.source_number, \"potential sources.\")" + "print(\n", + " \"Found\",\n", + " supernova_lens_pop.deflector_number,\n", + " \"potential lenses and\",\n", + " supernova_lens_pop.source_number,\n", + " \"potential sources.\",\n", + ")" ] }, { @@ -237,8 +241,8 @@ " lens_class.einstein_radius,\n", " lens_class.source.source_dict[\"mag_i\"],\n", " lens_class.source.source_dict[\"ps_mag_i\"],\n", - " #lens_class._deflector_dict[\"mag_i\"],\n", - " #lens_class._deflector_dict[\"z\"],\n", + " # lens_class._deflector_dict[\"mag_i\"],\n", + " # lens_class._deflector_dict[\"z\"],\n", ")" ] }, @@ -363,7 +367,7 @@ "N = 10\n", "\n", "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", - "ra_points = ra_points.wrap_at(180*u.degree)\n", + "ra_points = ra_points.wrap_at(180 * u.degree)\n", "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", "dec_points = coord.Angle(dec_points * u.degree)" ] @@ -374,8 +378,9 @@ "metadata": {}, "outputs": [], "source": [ - "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(ra_points, dec_points, \"baseline_v3.0_10yrs\",\n", - " MJD_min=60000, MJD_max=60300)\n", + "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(\n", + " ra_points, dec_points, \"baseline_v3.0_10yrs\", MJD_min=60000, MJD_max=60300\n", + ")\n", "exposure_data" ] }, @@ -386,11 +391,13 @@ "outputs": [], "source": [ "index = 0\n", - "bands = ['g','r','i','z']\n", + "bands = [\"g\", \"r\", \"i\", \"z\"]\n", "num_pix = 200\n", "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", "\n", - "images = opsim_variable_lens_injection(lens_class, bands, num_pix, transform_pix2angle, exposure_data[index])\n", + "images = opsim_variable_lens_injection(\n", + " lens_class, bands, num_pix, transform_pix2angle, exposure_data[index]\n", + ")\n", "images" ] }, diff --git a/notebooks/lens_source_injection-Copy1.ipynb b/notebooks/lens_source_injection-Copy1.ipynb index 5c098f92e..4acf28495 100644 --- a/notebooks/lens_source_injection-Copy1.ipynb +++ b/notebooks/lens_source_injection-Copy1.ipynb @@ -42,6 +42,7 @@ "import mpl_toolkits.axisartist.floating_axes as floating_axes\n", "from mpl_toolkits.axisartist.grid_finder import MaxNLocator, DictFormatter\n", "from matplotlib.transforms import Affine2D\n", + "\n", "# import lsst.daf.butler as dafButler\n", "# import lsst.geom as geom\n", "# import lsst.afw.display as afwDisplay\n", @@ -90,7 +91,9 @@ " OpSimSurv = op.OpSimSurvey(opsim_path)\n", "except FileNotFoundError:\n", " raise FileNotFoundError(\n", - " \"File not found: \" + opsim_path + \". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database\"\n", + " \"File not found: \"\n", + " + opsim_path\n", + " + \". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database\"\n", " )\n", "\n", "# Collect observations that cover the coordinates in ra_list and dec_list\n", @@ -115,7 +118,7 @@ "N = 10\n", "\n", "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", - "ra_points = ra_points.wrap_at(180*u.degree)\n", + "ra_points = ra_points.wrap_at(180 * u.degree)\n", "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", "dec_points = coord.Angle(dec_points * u.degree)" ] @@ -127,8 +130,9 @@ "metadata": {}, "outputs": [], "source": [ - "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(ra_points, dec_points, \"baseline_v3.0_10yrs\",\n", - " MJD_min=60000, MJD_max=60300)\n", + "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(\n", + " ra_points, dec_points, \"baseline_v3.0_10yrs\", MJD_min=60000, MJD_max=60300\n", + ")\n", "exposure_data" ] }, @@ -277,8 +281,7 @@ " \"mag_arc_limit\": {\"g\": 22, \"r\": 22, \"i\": 22},\n", "}\n", "rgb_band_list = [\"i\", \"r\", \"g\"]\n", - "lens_class = gg_lens_pop.select_lens_at_random(**kwargs_lens_cut)\n", - "\n" + "lens_class = gg_lens_pop.select_lens_at_random(**kwargs_lens_cut)" ] }, { @@ -478,8 +481,9 @@ "moffat_beta = 3.1\n", "\n", "# Create a Moffat psf kernel\n", - "psf_kernel = kernel_util.kernel_moffat(num_pix=size, delta_pix=delta_pix, fwhm=psf_fwhm, \n", - " moffat_beta=moffat_beta)\n", + "psf_kernel = kernel_util.kernel_moffat(\n", + " num_pix=size, delta_pix=delta_pix, fwhm=psf_fwhm, moffat_beta=moffat_beta\n", + ")\n", "\n", "psf_kernel = util.array2image(psf_kernel)\n", "\n", @@ -494,8 +498,15 @@ "outputs": [], "source": [ "def opsim_time_series_images_data2(\n", - " ra_list, dec_list, obs_strategy, MJD_min=60000, MJD_max=64000, size=101, moffat_beta=3.1, \n", - " readout_noise=10, delta_pix=0.2\n", + " ra_list,\n", + " dec_list,\n", + " obs_strategy,\n", + " MJD_min=60000,\n", + " MJD_max=64000,\n", + " size=101,\n", + " moffat_beta=3.1,\n", + " readout_noise=10,\n", + " delta_pix=0.2,\n", "):\n", " \"\"\"Creates time series data from opsim database.\n", "\n", @@ -527,7 +538,9 @@ " OpSimSurv = op.OpSimSurvey(opsim_path)\n", " except FileNotFoundError:\n", " raise FileNotFoundError(\n", - " \"File not found: \" + opsim_path + \". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database\"\n", + " \"File not found: \"\n", + " + opsim_path\n", + " + \". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database\"\n", " )\n", "\n", " # Collect observations that cover the coordinates in ra_list and dec_list\n", @@ -554,42 +567,46 @@ "\n", " # Get the relevant properties from opsim\n", " obs_time = np.array(seq[\"observationStartMJD\"])\n", - " \n", + "\n", " # Only give the observations between MJD_min and MJD_max\n", " mask = (obs_time > MJD_min) & (obs_time < MJD_max)\n", " obs_time = obs_time[mask]\n", - " \n", + "\n", " expo_time = np.array(seq[\"visitExposureTime\"])[mask]\n", " sky_brightness = np.array(seq[\"skyBrightness\"])[mask]\n", " bandpass = np.array(seq[\"filter\"])[mask]\n", " psf_fwhm = np.array(seq[\"seeingFwhmGeom\"])[mask]\n", " m5_depth = np.array(seq[\"fiveSigmaDepth\"])[mask]\n", " # Question: use 'FWHMeff' or 'seeingFwhmGeom' for the psf?\n", - " \n", + "\n", " radec_list = [(ra_list[i], dec_list[i])] * len(obs_time)\n", "\n", " # Create a Moffat psf kernel for each epoch\n", - " \n", + "\n", " psf_kernels = []\n", - " \n", + "\n", " for psf in psf_fwhm:\n", - " \n", + "\n", " psf_kernel = kernel_util.kernel_moffat(\n", " num_pix=size, delta_pix=delta_pix, fwhm=psf, moffat_beta=moffat_beta\n", " )\n", " psf_kernel = util.array2image(psf_kernel)\n", - " \n", + "\n", " psf_kernels.append(psf_kernel)\n", - " \n", + "\n", " psf_kernels = np.array(psf_kernels)\n", "\n", " # Calculate background noise\n", - " bkg_noise = data_util.bkg_noise(readout_noise, expo_time, sky_brightness, delta_pix, num_exposures=1)\n", + " bkg_noise = data_util.bkg_noise(\n", + " readout_noise, expo_time, sky_brightness, delta_pix, num_exposures=1\n", + " )\n", "\n", " # Calculate the zero point magnitude\n", " # Code from OpSimSummary/opsimsummary/simlib.py/add_simlibCols\n", " # need to work in nvariance in photon electrons\n", - " term1 = 2.0 * m5_depth - sky_brightness # * pixArea whata units is sky birghtness? counts or photo electrons?\n", + " term1 = (\n", + " 2.0 * m5_depth - sky_brightness\n", + " ) # * pixArea whata units is sky birghtness? counts or photo electrons?\n", " # per pixel or arcsec?\n", " term2 = -(m5_depth - sky_brightness) # * pixArea\n", " area = (1.51 * psf_fwhm) ** 2.0 # area = 1 / int(psf^2)\n", @@ -604,7 +621,7 @@ " # that counts with system transmission approximately equal counts with total transmission.\n", " zpt_cor = 2.5 * np.log10(1.0 + 1.0 / (area * tmp))\n", " zero_point_mag = zpt_approx + zpt_cor\n", - " \n", + "\n", " table_data = Table(\n", " [\n", " bkg_noise,\n", @@ -687,16 +704,16 @@ " transform_pix2angle=transform_pix2angle,\n", " exposure_time=exposure_data_obs[\"expo_time\"],\n", " t_obs=exposure_data_obs[\"obs_time\"],\n", - " std_gaussian_noise=std_gaussian_noise\n", + " std_gaussian_noise=std_gaussian_noise,\n", " )\n", "\n", " final_image.append(lens_images)\n", "\n", " lens_col = Column(name=\"lens\", data=final_image)\n", " final_image_col = Column(name=\"injected_lens\", data=final_image)\n", - " \n", + "\n", " # Create a new Table with only the bands of interest\n", - " mask = np.isin(exposure_data['band'], bands)\n", + " mask = np.isin(exposure_data[\"band\"], bands)\n", " exposure_data_new = exposure_data[mask]\n", " exposure_data_new.add_columns([lens_col, final_image_col])\n", " return exposure_data_new" @@ -712,7 +729,7 @@ "N = 100\n", "\n", "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", - "ra_points = ra_points.wrap_at(180*u.degree)\n", + "ra_points = ra_points.wrap_at(180 * u.degree)\n", "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", "dec_points = coord.Angle(dec_points * u.degree)" ] @@ -724,8 +741,9 @@ "metadata": {}, "outputs": [], "source": [ - "exposure_data = opsim_time_series_images_data2(ra_points, dec_points, \"baseline_v3.0_10yrs\",\n", - " MJD_min=60000, MJD_max=60300)\n", + "exposure_data = opsim_time_series_images_data2(\n", + " ra_points, dec_points, \"baseline_v3.0_10yrs\", MJD_min=60000, MJD_max=60300\n", + ")\n", "exposure_data" ] }, @@ -746,11 +764,13 @@ "from astropy.table import Column\n", "\n", "index = 1\n", - "bands = ['g','r','i','z']\n", + "bands = [\"g\", \"r\", \"i\", \"z\"]\n", "num_pix = 200\n", "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", "\n", - "images = opsim_variable_lens_injection(lens_class, bands, num_pix, transform_pix2angle, exposure_data[index])\n", + "images = opsim_variable_lens_injection(\n", + " lens_class, bands, num_pix, transform_pix2angle, exposure_data[index]\n", + ")\n", "images" ] }, @@ -761,8 +781,8 @@ "metadata": {}, "outputs": [], "source": [ - "print(\"band: \", images['band'][10])\n", - "plt.imshow(images['injected_lens'][10])\n", + "print(\"band: \", images[\"band\"][10])\n", + "plt.imshow(images[\"injected_lens\"][10])\n", "plt.xlim(75, 125)\n", "plt.ylim(75, 125)" ] diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 7911b45a4..f185cda5b 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -753,8 +753,15 @@ def dp0_time_series_images_data(butler, center_coord, radius="0.1", band="i", si def opsim_time_series_images_data( - ra_list, dec_list, obs_strategy, MJD_min=60000, MJD_max=64000, size=101, moffat_beta=3.1, - readout_noise=10, delta_pix=0.2 + ra_list, + dec_list, + obs_strategy, + MJD_min=60000, + MJD_max=64000, + size=101, + moffat_beta=3.1, + readout_noise=10, + delta_pix=0.2, ): """Creates time series data from opsim database. @@ -788,7 +795,9 @@ def opsim_time_series_images_data( OpSimSurv = op.OpSimSurvey(opsim_path) except FileNotFoundError: raise FileNotFoundError( - "File not found: " + opsim_path + ". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database" + "File not found: " + + opsim_path + + ". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database" ) # Collect observations that cover the coordinates in ra_list and dec_list @@ -844,12 +853,16 @@ def opsim_time_series_images_data( psf_kernels = np.array(psf_kernels) # Calculate background noise - bkg_noise = data_util.bkg_noise(readout_noise, expo_time, sky_brightness, delta_pix, num_exposures=1) + bkg_noise = data_util.bkg_noise( + readout_noise, expo_time, sky_brightness, delta_pix, num_exposures=1 + ) # Calculate the zero point magnitude # Code from OpSimSummary/opsimsummary/simlib.py/add_simlibCols # need to work in nvariance in photon electrons - term1 = 2.0 * m5_depth - sky_brightness # * pixArea whata units is sky birghtness? counts or photo electrons? + term1 = ( + 2.0 * m5_depth - sky_brightness + ) # * pixArea whata units is sky birghtness? counts or photo electrons? # per pixel or arcsec? term2 = -(m5_depth - sky_brightness) # * pixArea area = (1.51 * psf_fwhm) ** 2.0 # area = 1 / int(psf^2) @@ -859,7 +872,7 @@ def opsim_time_series_images_data( # is approximately equal to counts with total transmission zpt_approx = term1 + 2.5 * np.log10(arg) val = -0.4 * term2 - tmp = 10.0 ** val + tmp = 10.0**val # Additional term to account for photons from the source, again assuming # that counts with system transmission approximately equal counts with total transmission. zpt_cor = 2.5 * np.log10(1.0 + 1.0 / (area * tmp)) @@ -891,7 +904,7 @@ def opsim_time_series_images_data( def opsim_variable_lens_injection( - lens_class, bands, num_pix, transform_pix2angle, exposure_data + lens_class, bands, num_pix, transform_pix2angle, exposure_data ): """Injects variable lens to the OpSim time series data (1 object). @@ -900,20 +913,19 @@ def opsim_variable_lens_injection( :param num_pix: number of pixels per axis :param transform_pix2angle: transformation matrix (2x2) of pixels into coordinate displacements - :param exposure_data: An astropy table of exposure data. One entry of table_list_data - generated from the opsim_time_series_images_data function. It must contain the rms of - background noise fluctuations (column name should be "bkg_noise"), psf kernel for - each exposure (column name should be "psf_kernel", these are pixel psf kernel - for each single exposure images in time series image), observation time - (column name should be "obs_time", these are observation time in days for each - single exposure images in time series images), exposure time (column name should - be "expo_time", these are exposure time for each single exposure images in time - series images), magnitude zero point (column name should be "zero_point", these - are zero point magnitudes for each single exposure images in time series image), - coordinates of the object (column name should be "calexp_center"), these are - the coordinates in (ra, dec), and the band in which the observation is taken - (column name should be "band"). - + :param exposure_data: An astropy table of exposure data. One entry of + table_list_data generated from the opsim_time_series_images_data function. It + must contain the rms of background noise fluctuations (column name should be + "bkg_noise"), psf kernel for each exposure (column name should be "psf_kernel", + these are pixel psf kernel for each single exposure images in time series + image), observation time (column name should be "obs_time", these are + observation time in days for each single exposure images in time series images), + exposure time (column name should be "expo_time", these are exposure time for + each single exposure images in time series images), magnitude zero point (column + name should be "zero_point", these are zero point magnitudes for each single + exposure images in time series image), coordinates of the object (column name + should be "calexp_center"), these are the coordinates in (ra, dec), and the band + in which the observation is taken (column name should be "band"). :return: Astropy table of injected lenses and exposure information of dp0 data """ @@ -940,7 +952,7 @@ def opsim_variable_lens_injection( transform_pix2angle=transform_pix2angle, exposure_time=exposure_data_obs["expo_time"], t_obs=exposure_data_obs["obs_time"], - std_gaussian_noise=std_gaussian_noise + std_gaussian_noise=std_gaussian_noise, ) final_image.append(lens_images) @@ -949,7 +961,7 @@ def opsim_variable_lens_injection( final_image_col = Column(name="injected_lens", data=final_image) # Create a new Table with only the bands of interest - mask = np.isin(exposure_data['band'], bands) + mask = np.isin(exposure_data["band"], bands) exposure_data_new = exposure_data[mask] exposure_data_new.add_columns([lens_col, final_image_col]) return exposure_data_new From 61a909c8c2331e5ee6ed0fa6042db9d0c7070562 Mon Sep 17 00:00:00 2001 From: Nikki Date: Fri, 2 Aug 2024 17:55:18 +0200 Subject: [PATCH 15/50] demonstrated the injection and image_series functions with opsim. still using only one band --- ...rnovae_plus_extended_source_tutorial.ipynb | 387 +++++++++++------- 1 file changed, 243 insertions(+), 144 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index 1d26db9a2..3d730cd9c 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -17,14 +17,15 @@ "import matplotlib.pyplot as plt\n", "import corner\n", "import astropy.coordinates as coord\n", - "import astropy.units as u" + "import astropy.units as u\n", + "import time" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Supernovae plus extended source simulation\n", + "## Supernovae plus extended source simulation using OpSim\n", "In this notebook, we simulate population of lensed supernovae and simulate image of a \n", "\n", "random lensed supernovae. It follows following steps:\n", @@ -46,23 +47,53 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Simulate lensed supernovae population" + "## Simulate lens and source galaxy populations" ] }, { "cell_type": "code", "execution_count": 2, - "metadata": {}, - "outputs": [], + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nikki/Documents/Research/Projects/slsim/slsim/Sources/Supernovae/supernovae_pop.py:95: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n", + " If increasing the limit yields no improvement it is advised to analyze \n", + " the integrand in order to determine the difficulties. If the position of a \n", + " local difficulty can be determined (singularity, discontinuity) one will \n", + " probably gain from splitting up the interval and calling the integrator \n", + " on the subranges. Perhaps a special-purpose integrator should be used.\n", + " numerator = integrate.quad(\n", + "/Users/nikki/Documents/Research/Projects/slsim/slsim/Sources/Supernovae/supernovae_pop.py:95: IntegrationWarning: The occurrence of roundoff error is detected, which prevents \n", + " the requested tolerance from being achieved. The error may be \n", + " underestimated.\n", + " numerator = integrate.quad(\n", + "/Users/nikki/Documents/Research/Projects/slsim/slsim/Sources/Supernovae/supernovae_pop.py:95: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " numerator = integrate.quad(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.37 minutes needed to simulate 1 square degrees.\n" + ] + } + ], "source": [ "# define a cosmology\n", "cosmo = FlatLambdaCDM(H0=70, Om0=0.3)\n", "\n", "\n", "# define a sky area\n", - "sky_area = Quantity(value=0.1, unit=\"deg2\")\n", - "\n", + "area = 1\n", + "sky_area = Quantity(value=area, unit=\"deg2\")\n", "\n", + "start_time = time.time()\n", "# define limits in the intrinsic deflector and source population (in addition to the\n", "# skypy config\n", "# file)\n", @@ -70,7 +101,7 @@ "kwargs_source_cut = {}\n", "## create a point plus extended source lens population.\n", "supernova_lens_pop = LensPop(\n", - " deflector_type=\"elliptical\", # type of the deflector. It could be elliptical or\n", + " deflector_type=\"all-galaxies\", # type of the deflector. It could be elliptical or\n", " # all-galaxies.\n", " source_type=\"supernovae_plus_galaxies\", # keyword for source type. it can be\n", " # galaxies, quasar, quasar_plus_galaxies, and supernovae_plus_galaxies.\n", @@ -89,19 +120,19 @@ " # configuration will be used.\n", " sky_area=sky_area, # Sky area for the simulation, source / deflector sky area\n", " cosmo=cosmo, # astropy cosmology\n", - " source_light_profile=\"double_sersic\", # light profile for the source galaxy\n", - " catalog_type=\"scotch\", # catalog type. It can be None or scotch\n", - " lightcurve_time=np.linspace(\n", - " -20, 100, 1000\n", - " ), # array of light curve observation time.\n", - " catalog_path=\"../data/Scotch/\"\n", - " + \"scotch_SNIa_host_galaxies.fits\",\n", + " source_light_profile=\"single_sersic\", # light profile for the source galaxy\n", + " catalog_type=None, # catalog type. It can be None or scotch\n", + " lightcurve_time=np.linspace(-50, 100, 1000), # array of light curve observation time.\n", + " #catalog_path=\"../data/Scotch/\"\n", + " #+ \"scotch_SNIa_host_galaxies.fits\",\n", " # path for catalog. If not provided, small size catalog from\n", " # /slsim/Source/SupernovaeCatalog will be used for\n", " # source_type=\"supernovae_plus_galaxies\" case. For other cases, we do not need to\n", " # provide outside catalog. One can download scotch_SNIa_host_galaxies.fits from\n", " # https://github.com/LSST-strong-lensing/data_public.git\n", - ")" + ")\n", + "end_time = time.time()\n", + "print(np.around((end_time - start_time)/60,2), 'minutes needed to simulate ', area, 'square degrees.')" ] }, { @@ -113,34 +144,49 @@ "name": "stdout", "output_type": "stream", "text": [ - "Found 7810 potential lenses and 10000 potential sources.\n" + "Found 1204203 potential lenses and 2678 potential sources.\n" ] } ], "source": [ "print(\"Found\", supernova_lens_pop.deflector_number, \"potential lenses and\",\n", - " supernova_lens_pop.source_number, \"potential sources.\")" + " supernova_lens_pop.source_number, \"potential sources.\")\n", + "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Choose a random lens" + "## Generate strong lensing systems" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.77 minutes needed to generate strong lenses.\n", + "Number of strong lens systems: 7\n" + ] + } + ], "source": [ + "start_time = time.time()\n", "# specifying cuts of the population\n", "kwargs_lens_cuts = {}\n", "# drawing population\n", "supernovae_lens_population = supernova_lens_pop.draw_population(\n", - " kwargs_lens_cuts=kwargs_lens_cuts # speed_factor=200\n", - ")" + " kwargs_lens_cuts=kwargs_lens_cuts\n", + ")\n", + "\n", + "end_time = time.time()\n", + "print(np.around((end_time - start_time)/60,2), 'minutes needed to generate strong lenses.')\n", + "print(\"Number of strong lens systems:\", len(supernovae_lens_population))" ] }, { @@ -148,29 +194,16 @@ "execution_count": 5, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of strong lens systems: 17\n" - ] - }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/nikki/anaconda3/envs/slsim/lib/python3.12/site-packages/sncosmo/models.py:189: RuntimeWarning: divide by zero encountered in log10\n", - " result[i] = -2.5 * np.log10(f / zpf)\n", - "/Users/nikki/anaconda3/envs/slsim/lib/python3.12/site-packages/slsim/Sources/source.py:362: RuntimeWarning: divide by zero encountered in log10\n", - " mag_source0 = -2.5 * np.log10(w0 * flux)\n", "/Users/nikki/anaconda3/envs/slsim/lib/python3.12/site-packages/sncosmo/models.py:189: RuntimeWarning: invalid value encountered in log10\n", " result[i] = -2.5 * np.log10(f / zpf)\n" ] } ], "source": [ - "print(\"Number of strong lens systems:\", len(supernovae_lens_population))\n", - "\n", "lens_samples = []\n", "labels = [\n", " r\"$\\sigma_v$\",\n", @@ -214,24 +247,28 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 75, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "(1.832039, 0.5321404664052483, 24.688736, 26.831420679814215)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Chosen lens system properties:\n", + "z_lens = 0.18515243617298172\n", + "z_source = 2.3674687823642095\n", + "theta_E = 1.1984139515438024\n", + "Lens galaxy magnitude: 18.758226016429514\n", + "Host galaxy magnitude: 23.286907546282336\n", + "Supernova magnitude: 31.23713044554652\n" + ] } ], "source": [ + "index = 0\n", "kwargs_lens_cut = {\"min_image_separation\": 1, \"max_image_separation\": 10}\n", "rgb_band_list = [\"i\", \"r\", \"g\"]\n", - "lens_class = supernovae_lens_population[2]\n", + "lens_class = supernovae_lens_population[index]\n", "(\n", " lens_class.source.source_dict[\"z\"],\n", " lens_class.einstein_radius,\n", @@ -239,12 +276,21 @@ " lens_class.source.source_dict[\"ps_mag_i\"],\n", " #lens_class._deflector_dict[\"mag_i\"],\n", " #lens_class._deflector_dict[\"z\"],\n", - ")" + ")\n", + "\n", + "print(\"Chosen lens system properties:\")\n", + "print(\"z_lens = \", lens_class.deflector_redshift)\n", + "print(\"z_source = \", lens_class.source.source_dict[\"z\"])\n", + "print(\"theta_E = \", lens_class.einstein_radius)\n", + "print(\"Lens galaxy magnitude: \", lens_class.deflector_magnitude(band='i'))\n", + "print(\"Host galaxy magnitude: \", lens_class.source.source_dict[\"mag_i\"])\n", + "print(\"Supernova magnitude: \", lens_class.source.source_dict[\"ps_mag_i\"])\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 76, "metadata": {}, "outputs": [], "source": [ @@ -266,8 +312,8 @@ { "data": { "text/plain": [ - "array([[11.52138022, 14.5660759 ],\n", - " [15.49632453, 16.44243526]])" + "array([[26.57141984, 20.28503388],\n", + " [15.04963136, 15.0711548 ]])" ] }, "execution_count": 8, @@ -288,7 +334,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 77, "metadata": {}, "outputs": [ { @@ -307,22 +353,22 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 78, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(-22.0, 100.0)" + "(-50.0, 100.0)" ] }, - "execution_count": 10, + "execution_count": 78, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -335,9 +381,9 @@ "plt.plot(light_curve[\"MJD\"], light_curve[\"ps_mag_i\"])\n", "# plt.ylim(12, 18)\n", "plt.gca().invert_yaxis()\n", - "plt.ylabel(\"Magnitude\")\n", - "plt.xlabel(\"Time\" \"[Days]\")\n", - "plt.xlim(-22, 100)" + "plt.ylabel(r\"$i$-band magnitude\")\n", + "plt.xlabel(\"Time [days]\")\n", + "plt.xlim(-50, 100)" ] }, { @@ -370,142 +416,183 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 12, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading from database sqlite:///../data/OpSim_database/baseline_v3.0_10yrs.db\n", + "Read N = 2086079 observations in 43.41 seconds.\n", + "No host file.\n", + "Coordinate (-42.62275274912281 deg, 15.73605140756275 deg) is not in the LSST footprint. This entry is skipped.\n", + "Coordinate (64.49873263637397 deg, 34.67603238561339 deg) is not in the LSST footprint. This entry is skipped.\n" + ] + } + ], "source": [ "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(ra_points, dec_points, \"baseline_v3.0_10yrs\",\n", - " MJD_min=60000, MJD_max=60300)\n", - "exposure_data" + " MJD_min=60000, MJD_max=60300, \n", + " print_warning=True)\n" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "index = 0\n", - "bands = ['g','r','i','z']\n", - "num_pix = 200\n", - "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", - "\n", - "images = opsim_variable_lens_injection(lens_class, bands, num_pix, transform_pix2angle, exposure_data[index])\n", - "images" + "## Simulate variable_lens_injection with OpSim" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, + "execution_count": 79, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['bkg_noise', 'psf_kernel', 'obs_time', 'expo_time', 'zero_point', 'calexp_center', 'band', 'lens', 'injected_lens']\n", + "12 observations\n" + ] + } + ], "source": [ - "## Set observation time and image configuration" + "index = 5\n", + "bands = ['i']\n", + "num_pix = 200\n", + "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", + "\n", + "images = lsst_science_pipeline.opsim_variable_lens_injection(lens_class, bands, num_pix, transform_pix2angle, exposure_data[index])\n", + "print(images.keys())\n", + "print(len(images['obs_time']), \"observations\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 80, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(80.0, 120.0)" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "time = np.array([-19.5, -15, -11.35135135135135, 0, 10, 20, 25, 30, 40, 44.86])\n", - "# time = sorted(np.random.uniform(-20, 100, 10))\n", - "# time = np.array([0, 50, 70, 120])\n", - "repeats = 10\n", - "# load your psf kernel and transform matrix. If you have your own psf, please provide\n", - "# it here.\n", - "path = \"../tests/TestData/psf_kernels_for_deflector.npy\"\n", - "psf_kernel = 1 * np.load(path)\n", - "psf_kernel[psf_kernel < 0] = 0\n", - "transform_matrix = np.array([[0.2, 0], [0, 0.2]])\n", - "\n", - "# let's set up psf kernel for each exposure. Here we have taken the same psf that we\n", - "# extracted above. However, each exposure can have different psf kernel and user should\n", - "# provide corresponding psf kernel to each exposure.\n", - "psf_kernel_list = [psf_kernel]\n", - "transform_matrix_list = [transform_matrix]\n", - "psf_kernels_all = psf_kernel_list * repeats\n", - "# psf_kernels_all = np.array([dp0[\"psf_kernel\"][:10]])[0]\n", - "\n", - "# let's set pixel to angle transform matrix. Here we have taken the same matrix for\n", - "# each exposure but user should provide corresponding transform matrix to each exposure.\n", - "transform_matrix_all = transform_matrix_list * repeats\n", - "\n", - "# provide magnitude zero point for each exposures. Here we have taken the same magnitude\n", - "# zero point for each exposure but user should provide the corresponding magnitude\n", - "# zero point for each exposure.\n", - "mag_list = [31.0]\n", - "mag_zero_points_all = mag_list * repeats\n", - "# mag_zero_points_all = np.array([dp0[\"zero_point\"][:10]])[0]\n", - "\n", - "expo_list = [30]\n", - "exposure_time_all = expo_list * repeats" + "plt.imshow(images['lens'][0], origin=\"lower\")\n", + "plt.xlim(80, 120)\n", + "plt.ylim(80, 120)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Simulate Image" + "## Simulate lens_image_series with OpSim" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 81, "metadata": {}, "outputs": [], "source": [ + "im_times = images['obs_time'] - images['obs_time'][0] - 20\n", + "repeats = len(im_times)\n", + "transform_matrix = np.array([[0.2, 0], [0, 0.2]])\n", + "transform_matrix_list = [transform_matrix]\n", + "transform_matrix_all = transform_matrix_list * repeats\n", + "\n", "# Simulate a lens image\n", - "image_lens_series = lens_image_series(\n", + "images_opsim = lens_image_series(\n", " lens_class=lens_class,\n", " band=\"i\",\n", - " mag_zero_point=mag_zero_points_all,\n", + " mag_zero_point=images['zero_point'],\n", " num_pix=32,\n", - " psf_kernel=psf_kernels_all,\n", + " psf_kernel=images['psf_kernel'],\n", " transform_pix2angle=transform_matrix_all,\n", - " exposure_time=exposure_time_all,\n", - " t_obs=time,\n", + " exposure_time=images['expo_time'],\n", + " t_obs=im_times,\n", " with_deflector=True,\n", " with_source=True,\n", - ")\n", - "\n", - "# Make opsim_lens_image_series function (main difference: bands [list] instead of band [number])\n", - "# Also make a function to plot light curve with observations" + ")\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "## Images in log scale\n", "log_images = []\n", - "for i in range(len(image_lens_series)):\n", - " log_images.append(np.log10(image_lens_series[i]))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Visualize simulated images" + "for i in range(len(images_opsim)):\n", + " log_images.append(np.log10(images_opsim[i]))\n", + " \n", + "plt.imshow(log_images[0], origin=\"lower\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 83, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_montage = create_image_montage_from_image_list(\n", - " num_rows=2, num_cols=5, images=image_lens_series, time=time, image_center=pix_coord\n", + " num_rows=3, num_cols=5, images=images_opsim, time=im_times, image_center=pix_coord\n", ")\n", "\n", "# add \"band=band\" and add as text to plots" @@ -517,14 +604,26 @@ "source": [ "### Notes\n", "\n", - "- Can I make a separate function to calculate the zero point?\n", + "- Can I make a separate function to calculate the zero point? It's a bit messy now within opsim_time_series_images_data.\n", "\n", "- calexp_center just contains the object coordinates so is currently a lot of duplicates for each epoch. Maybe there's a more efficient way to save it (or maybe it doesn't matter). \n", "\n", - "- 'injected_lens' now contains the same as 'lens', because there is no background image\n", + "- 'injected_lens' now contains the same as 'lens', because there is no background image." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Issues\n", "\n", - "- if catalog_type=None instead of \"scotch\", something goes wrong with the column names. I get the error: ellipticity or semi-major and semi-minor axis are missing for the first light profile in galaxy_list columns.\n", - "- Light curve looks a bit strange for a type Ia SN?" + "- if ```catalog_type=None``` instead of ```\"scotch\"```, the ```double_sersic``` model is not defined. I get the error: ellipticity or semi-major and semi-minor axis are missing for the first light profile in galaxy_list columns.\n", + "- Light curve looks a bit strange for a type Ia SN?\n", + "- If the light curve goes down to very low magnitudes (~40), then I get a \"lam value too large\" error (see screenshot).\n", + "- Is it possible to give ```LensPop kwargs_variability={\"supernovae_lightcurve\", \"i\"}``` a list of bands instead of just one single band? Because otherwise I cannot compute the brightnesses in the other bands so I cannot simulate multiband images.\n", + "- ```lens_class._deflector_dict[\"mag_i\"]}```, and ```lens_class._deflector_dict[\"z\"]``` were not working for me, I replaced them with ```lens_class.deflector_magnitude(band='i')``` and ```lens_class.deflector_redshift```.\n", + "- Even when I have a lot of potential lens and source galaxies, the resulting strong lenses are very few (order of 10). A more efficient way to sample would be good.\n", + "- The magnitudes of the supernovae are all very faint, so in the images I only see the lens galaxy. I tend to sample very low-redshift lenses and high-redshift sources." ] }, { From 3dc99167844a37c5ac31a1a8b19c4d57212096a3 Mon Sep 17 00:00:00 2001 From: Nikki Date: Fri, 2 Aug 2024 17:56:48 +0200 Subject: [PATCH 16/50] added the print_warning argument to opsim_time_series_images_data --- slsim/lsst_science_pipeline.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 7911b45a4..6e1fc6c63 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -754,7 +754,7 @@ def dp0_time_series_images_data(butler, center_coord, radius="0.1", band="i", si def opsim_time_series_images_data( ra_list, dec_list, obs_strategy, MJD_min=60000, MJD_max=64000, size=101, moffat_beta=3.1, - readout_noise=10, delta_pix=0.2 + readout_noise=10, delta_pix=0.2, print_warning=True ): """Creates time series data from opsim database. @@ -770,6 +770,7 @@ def opsim_time_series_images_data( :param moffat_beta: power index of the moffat psf kernel :param readout_noise: noise added per readout :param delta_pix: size of pixel in units arcseonds + :param print_warning: if True, prints a warning of coordinates outside of the LSST footprint :return: a list of astropy tables containing observation information for each coordinate """ @@ -808,9 +809,10 @@ def opsim_time_series_images_data( opsim_dec = np.mean(seq["fieldDec"]) if np.isnan(opsim_ra) or np.isnan(opsim_dec): - print( - f"Coordinate ({ra_list[i]}, {dec_list[i]}) is not in the LSST footprint. This entry is skipped." - ) + if print_warning: + print( + f"Coordinate ({ra_list[i]}, {dec_list[i]}) is not in the LSST footprint. This entry is skipped." + ) continue # Get the relevant properties from opsim From 8c0f7a0381bf38266f4968c8436458d3807e4866 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 2 Aug 2024 16:16:19 +0000 Subject: [PATCH 17/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- ...rnovae_plus_extended_source_tutorial.ipynb | 28 ++++++++++--------- slsim/lsst_science_pipeline.py | 16 +++++++++-- 2 files changed, 28 insertions(+), 16 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index e4e868b9e..12e3604eb 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -204,7 +204,10 @@ ")\n", "\n", "end_time = time.time()\n", - "print(np.around((end_time - start_time)/60,2), 'minutes needed to generate strong lenses.')\n", + "print(\n", + " np.around((end_time - start_time) / 60, 2),\n", + " \"minutes needed to generate strong lenses.\",\n", + ")\n", "print(\"Number of strong lens systems:\", len(supernovae_lens_population))" ] }, @@ -293,18 +296,17 @@ " lens_class.einstein_radius,\n", " lens_class.source.source_dict[\"mag_i\"],\n", " lens_class.source.source_dict[\"ps_mag_i\"],\n", - " #lens_class._deflector_dict[\"mag_i\"],\n", - " #lens_class._deflector_dict[\"z\"],\n", + " # lens_class._deflector_dict[\"mag_i\"],\n", + " # lens_class._deflector_dict[\"z\"],\n", ")\n", "\n", "print(\"Chosen lens system properties:\")\n", "print(\"z_lens = \", lens_class.deflector_redshift)\n", "print(\"z_source = \", lens_class.source.source_dict[\"z\"])\n", "print(\"theta_E = \", lens_class.einstein_radius)\n", - "print(\"Lens galaxy magnitude: \", lens_class.deflector_magnitude(band='i'))\n", + "print(\"Lens galaxy magnitude: \", lens_class.deflector_magnitude(band=\"i\"))\n", "print(\"Host galaxy magnitude: \", lens_class.source.source_dict[\"mag_i\"])\n", - "print(\"Supernova magnitude: \", lens_class.source.source_dict[\"ps_mag_i\"])\n", - "\n" + "print(\"Supernova magnitude: \", lens_class.source.source_dict[\"ps_mag_i\"])" ] }, { @@ -569,7 +571,7 @@ } ], "source": [ - "plt.imshow(images['lens'][0], origin=\"lower\")\n", + "plt.imshow(images[\"lens\"][0], origin=\"lower\")\n", "plt.xlim(80, 120)\n", "plt.ylim(80, 120)" ] @@ -587,7 +589,7 @@ "metadata": {}, "outputs": [], "source": [ - "im_times = images['obs_time'] - images['obs_time'][0] - 20\n", + "im_times = images[\"obs_time\"] - images[\"obs_time\"][0] - 20\n", "repeats = len(im_times)\n", "transform_matrix = np.array([[0.2, 0], [0, 0.2]])\n", "transform_matrix_list = [transform_matrix]\n", @@ -597,15 +599,15 @@ "images_opsim = lens_image_series(\n", " lens_class=lens_class,\n", " band=\"i\",\n", - " mag_zero_point=images['zero_point'],\n", + " mag_zero_point=images[\"zero_point\"],\n", " num_pix=32,\n", - " psf_kernel=images['psf_kernel'],\n", + " psf_kernel=images[\"psf_kernel\"],\n", " transform_pix2angle=transform_matrix_all,\n", - " exposure_time=images['expo_time'],\n", + " exposure_time=images[\"expo_time\"],\n", " t_obs=im_times,\n", " with_deflector=True,\n", " with_source=True,\n", - ")\n" + ")" ] }, { @@ -639,7 +641,7 @@ "log_images = []\n", "for i in range(len(images_opsim)):\n", " log_images.append(np.log10(images_opsim[i]))\n", - " \n", + "\n", "plt.imshow(log_images[0], origin=\"lower\")" ] }, diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 926d0f2fd..cd48a1480 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -752,8 +752,17 @@ def dp0_time_series_images_data(butler, center_coord, radius="0.1", band="i", si return table_data -def opsim_time_series_images_data(ra_list, dec_list, obs_strategy, MJD_min=60000, MJD_max=64000, size=101, moffat_beta=3.1, - readout_noise=10, delta_pix=0.2, print_warning=True +def opsim_time_series_images_data( + ra_list, + dec_list, + obs_strategy, + MJD_min=60000, + MJD_max=64000, + size=101, + moffat_beta=3.1, + readout_noise=10, + delta_pix=0.2, + print_warning=True, ): """Creates time series data from opsim database. @@ -769,7 +778,8 @@ def opsim_time_series_images_data(ra_list, dec_list, obs_strategy, MJD_min=60000 :param moffat_beta: power index of the moffat psf kernel :param readout_noise: noise added per readout :param delta_pix: size of pixel in units arcseonds - :param print_warning: if True, prints a warning of coordinates outside of the LSST footprint + :param print_warning: if True, prints a warning of coordinates outside of the LSST + footprint :return: a list of astropy tables containing observation information for each coordinate """ From d7ca480e019101882504f61a2670e57b6c27316e Mon Sep 17 00:00:00 2001 From: Nikki Date: Fri, 2 Aug 2024 18:28:50 +0200 Subject: [PATCH 18/50] solved merge conflicts --- ...rnovae_plus_extended_source_tutorial.ipynb | 77 +------------------ 1 file changed, 4 insertions(+), 73 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index e4e868b9e..3d730cd9c 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -120,20 +120,11 @@ " # configuration will be used.\n", " sky_area=sky_area, # Sky area for the simulation, source / deflector sky area\n", " cosmo=cosmo, # astropy cosmology\n", - "<<<<<<< local\n", " source_light_profile=\"single_sersic\", # light profile for the source galaxy\n", " catalog_type=None, # catalog type. It can be None or scotch\n", " lightcurve_time=np.linspace(-50, 100, 1000), # array of light curve observation time.\n", " #catalog_path=\"../data/Scotch/\"\n", " #+ \"scotch_SNIa_host_galaxies.fits\",\n", - "=======\n", - " source_light_profile=\"double_sersic\", # light profile for the source galaxy\n", - " catalog_type=\"scotch\", # catalog type. It can be None or scotch\n", - " lightcurve_time=np.linspace(\n", - " -20, 100, 1000\n", - " ), # array of light curve observation time.\n", - " catalog_path=\"../data/Scotch/\" + \"scotch_SNIa_host_galaxies.fits\",\n", - ">>>>>>> remote\n", " # path for catalog. If not provided, small size catalog from\n", " # /slsim/Source/SupernovaeCatalog will be used for\n", " # source_type=\"supernovae_plus_galaxies\" case. For other cases, we do not need to\n", @@ -158,19 +149,9 @@ } ], "source": [ - "<<<<<<< local\n", "print(\"Found\", supernova_lens_pop.deflector_number, \"potential lenses and\",\n", " supernova_lens_pop.source_number, \"potential sources.\")\n", - "\n", - "=======\n", - "print(\n", - " \"Found\",\n", - " supernova_lens_pop.deflector_number,\n", - " \"potential lenses and\",\n", - " supernova_lens_pop.source_number,\n", - " \"potential sources.\",\n", - ")\n", - ">>>>>>> remote" + "\n" ] }, { @@ -307,37 +288,6 @@ "\n" ] }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(1.832039, 0.5321404664052483, 24.688736, 26.831420679814215)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "<<<<<<< LOCAL CELL DELETED >>>>>>>\n", - "kwargs_lens_cut = {\"min_image_separation\": 1, \"max_image_separation\": 10}\n", - "rgb_band_list = [\"i\", \"r\", \"g\"]\n", - "lens_class = supernovae_lens_population[2]\n", - "(\n", - " lens_class.source.source_dict[\"z\"],\n", - " lens_class.einstein_radius,\n", - " lens_class.source.source_dict[\"mag_i\"],\n", - " lens_class.source.source_dict[\"ps_mag_i\"],\n", - " # lens_class._deflector_dict[\"mag_i\"],\n", - " # lens_class._deflector_dict[\"z\"],\n", - ")" - ] - }, { "cell_type": "code", "execution_count": 76, @@ -459,7 +409,7 @@ "N = 10\n", "\n", "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", - "ra_points = ra_points.wrap_at(180 * u.degree)\n", + "ra_points = ra_points.wrap_at(180*u.degree)\n", "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", "dec_points = coord.Angle(dec_points * u.degree)" ] @@ -484,16 +434,9 @@ } ], "source": [ - "<<<<<<< local\n", "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(ra_points, dec_points, \"baseline_v3.0_10yrs\",\n", " MJD_min=60000, MJD_max=60300, \n", - " print_warning=True)\n", - "=======\n", - "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(\n", - " ra_points, dec_points, \"baseline_v3.0_10yrs\", MJD_min=60000, MJD_max=60300\n", - ")\n", - "exposure_data\n", - ">>>>>>> remote" + " print_warning=True)\n" ] }, { @@ -520,7 +463,6 @@ } ], "source": [ - "<<<<<<< local\n", "index = 5\n", "bands = ['i']\n", "num_pix = 200\n", @@ -528,18 +470,7 @@ "\n", "images = lsst_science_pipeline.opsim_variable_lens_injection(lens_class, bands, num_pix, transform_pix2angle, exposure_data[index])\n", "print(images.keys())\n", - "print(len(images['obs_time']), \"observations\")\n", - "=======\n", - "index = 0\n", - "bands = [\"g\", \"r\", \"i\", \"z\"]\n", - "num_pix = 200\n", - "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", - "\n", - "images = opsim_variable_lens_injection(\n", - " lens_class, bands, num_pix, transform_pix2angle, exposure_data[index]\n", - ")\n", - "images\n", - ">>>>>>> remote" + "print(len(images['obs_time']), \"observations\")" ] }, { From dca30b76bd5fc65345b24dfbfde5e6e7cee0d1b3 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 2 Aug 2024 16:30:43 +0000 Subject: [PATCH 19/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- ...rnovae_plus_extended_source_tutorial.ipynb | 46 +++++++++++++------ 1 file changed, 32 insertions(+), 14 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index 4807313f2..7f3a691f5 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -122,9 +122,11 @@ " cosmo=cosmo, # astropy cosmology\n", " source_light_profile=\"single_sersic\", # light profile for the source galaxy\n", " catalog_type=None, # catalog type. It can be None or scotch\n", - " lightcurve_time=np.linspace(-50, 100, 1000), # array of light curve observation time.\n", - " #catalog_path=\"../data/Scotch/\"\n", - " #+ \"scotch_SNIa_host_galaxies.fits\",\n", + " lightcurve_time=np.linspace(\n", + " -50, 100, 1000\n", + " ), # array of light curve observation time.\n", + " # catalog_path=\"../data/Scotch/\"\n", + " # + \"scotch_SNIa_host_galaxies.fits\",\n", " # path for catalog. If not provided, small size catalog from\n", " # /slsim/Source/SupernovaeCatalog will be used for\n", " # source_type=\"supernovae_plus_galaxies\" case. For other cases, we do not need to\n", @@ -132,7 +134,12 @@ " # https://github.com/LSST-strong-lensing/data_public.git\n", ")\n", "end_time = time.time()\n", - "print(np.around((end_time - start_time)/60,2), 'minutes needed to simulate ', area, 'square degrees.')" + "print(\n", + " np.around((end_time - start_time) / 60, 2),\n", + " \"minutes needed to simulate \",\n", + " area,\n", + " \"square degrees.\",\n", + ")" ] }, { @@ -149,9 +156,13 @@ } ], "source": [ - "print(\"Found\", supernova_lens_pop.deflector_number, \"potential lenses and\",\n", - " supernova_lens_pop.source_number, \"potential sources.\")\n", - "\n" + "print(\n", + " \"Found\",\n", + " supernova_lens_pop.deflector_number,\n", + " \"potential lenses and\",\n", + " supernova_lens_pop.source_number,\n", + " \"potential sources.\",\n", + ")" ] }, { @@ -411,7 +422,7 @@ "N = 10\n", "\n", "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", - "ra_points = ra_points.wrap_at(180*u.degree)\n", + "ra_points = ra_points.wrap_at(180 * u.degree)\n", "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", "dec_points = coord.Angle(dec_points * u.degree)" ] @@ -436,9 +447,14 @@ } ], "source": [ - "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(ra_points, dec_points, \"baseline_v3.0_10yrs\",\n", - " MJD_min=60000, MJD_max=60300, \n", - " print_warning=True)\n" + "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(\n", + " ra_points,\n", + " dec_points,\n", + " \"baseline_v3.0_10yrs\",\n", + " MJD_min=60000,\n", + " MJD_max=60300,\n", + " print_warning=True,\n", + ")" ] }, { @@ -466,13 +482,15 @@ ], "source": [ "index = 5\n", - "bands = ['i']\n", + "bands = [\"i\"]\n", "num_pix = 200\n", "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", "\n", - "images = lsst_science_pipeline.opsim_variable_lens_injection(lens_class, bands, num_pix, transform_pix2angle, exposure_data[index])\n", + "images = lsst_science_pipeline.opsim_variable_lens_injection(\n", + " lens_class, bands, num_pix, transform_pix2angle, exposure_data[index]\n", + ")\n", "print(images.keys())\n", - "print(len(images['obs_time']), \"observations\")" + "print(len(images[\"obs_time\"]), \"observations\")" ] }, { From f13c1880cbfbbbc93a7fe60a6f7a47b767dc5b69 Mon Sep 17 00:00:00 2001 From: Nikki Date: Mon, 5 Aug 2024 11:35:47 +0200 Subject: [PATCH 20/50] solved more merge conflicts --- slsim/lsst_science_pipeline.py | 1 - 1 file changed, 1 deletion(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 9f6f1939a..547e2347a 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -1018,7 +1018,6 @@ def multiple_dp0_time_series_images_data( if len(time_series_data) > 1: return expo_data_list return None ->>>>>>> slsim-project/main def variable_lens_injection( From cad04ff2253cbd4ad2243e2d51388fd647d60bce Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 5 Aug 2024 09:36:46 +0000 Subject: [PATCH 21/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- slsim/lsst_science_pipeline.py | 1 + 1 file changed, 1 insertion(+) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 547e2347a..2cb8090ec 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -983,6 +983,7 @@ def opsim_variable_lens_injection( exposure_data_new.add_columns([lens_col, final_image_col]) return exposure_data_new + def multiple_dp0_time_series_images_data( butler, center_coords_list, radius="0.034", band="i", size=101, output_file=None ): From a4b05545b653423209d93369f927a4bb90357e23 Mon Sep 17 00:00:00 2001 From: Nikki Date: Wed, 7 Aug 2024 16:13:02 +0200 Subject: [PATCH 22/50] modified create_image_montage_from_image_list() to take in an extra parameter band and display text with the band for each image --- slsim/Plots/plot_functions.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/slsim/Plots/plot_functions.py b/slsim/Plots/plot_functions.py index 1f1283543..ea5e7dfe0 100644 --- a/slsim/Plots/plot_functions.py +++ b/slsim/Plots/plot_functions.py @@ -7,7 +7,7 @@ def create_image_montage_from_image_list( - num_rows, num_cols, images, time=None, image_type="other", image_center=None + num_rows, num_cols, images, time=None, band=None, image_type="other", image_center=None ): """Creates an image montage from an image list. @@ -16,6 +16,8 @@ def create_image_montage_from_image_list( :param images: list of images :param time: array of observation time for point source images. If None, considers static case. + :param band: array of bands corresponding to the observations. If None, does not + display any information regarding the band. :param image_type: type of the provided image. It could be 'dp0' or any other name. :param image_center: center of the source images. :type image_center: array. eg: for two image, it should be like @@ -32,6 +34,10 @@ def create_image_montage_from_image_list( global_min = min(all_min) global_max = max(all_max) + # If band is one string, extend to list + if isinstance(band, str): + band = [band] * len(images) + fig, axes = plt.subplots(num_rows, num_cols, figsize=(num_cols * 3, num_rows * 3)) for i in range(num_rows): @@ -61,6 +67,17 @@ def create_image_montage_from_image_list( horizontalalignment="left", transform=axes[i, j].transAxes, ) + if band is not None: + axes[i, j].text( + 0.05, + 0.10, + f"Band: {band[i * num_cols + j]}", + fontsize=10, + color="white", + verticalalignment="top", + horizontalalignment="left", + transform=axes[i, j].transAxes, + ) if image_center is not None: for k in range(len(image_center)): axes[i, j].scatter( From bc781a9b9b5df3b712af9ca3c7db932e3ed92d6c Mon Sep 17 00:00:00 2001 From: Nikki Date: Wed, 7 Aug 2024 16:13:41 +0200 Subject: [PATCH 23/50] modified lens_image_series() to also accept a list or array of bands --- slsim/image_simulation.py | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/slsim/image_simulation.py b/slsim/image_simulation.py index 2131216d4..415eefbb6 100644 --- a/slsim/image_simulation.py +++ b/slsim/image_simulation.py @@ -590,8 +590,9 @@ def lens_image_series( to simulate time series images of a lens. :param lens_class: Lens() object - :param band: imaging band - :param mag_zero_point: list of magnitude zero point for sqeuence of exposure + :param band: imaging band (or list of bands). + if float: assumed to apply to the full image series. + :param mag_zero_point: list of magnitude zero point for sequence of exposure :param num_pix: number of pixels per axis :param psf_kernels: list of psf kernel for each exposure. :param transform_pix2angle: list of transformation matrix (2x2) of pixels into @@ -606,13 +607,18 @@ def lens_image_series( :param with_deflector: If True, simulates image with deflector. :return: list of series of images of a lens """ + + # If band is one string, extend to list + if isinstance(band, str): + band = [band] * len(mag_zero_point) + image_series = [] - for time, psf_kern, mag_zero, transf_matrix, expo_time in zip( - t_obs, psf_kernel, mag_zero_point, transform_pix2angle, exposure_time + for time, psf_kern, mag_zero, transf_matrix, expo_time, band_obs in zip( + t_obs, psf_kernel, mag_zero_point, transform_pix2angle, exposure_time, band ): image = lens_image( lens_class=lens_class, - band=band, + band=band_obs, mag_zero_point=mag_zero, num_pix=num_pix, psf_kernel=psf_kern, From e236552813c18d3bc65ea36b85c4d27c85ce2246 Mon Sep 17 00:00:00 2001 From: Nikki Date: Wed, 7 Aug 2024 16:15:16 +0200 Subject: [PATCH 24/50] added data/SALT3.NIR_WAVEEXT/ to the files to be ignored --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 5f6e86188..675b26161 100644 --- a/.gitignore +++ b/.gitignore @@ -37,6 +37,7 @@ share/python-wheels/ MANIFEST data/OpSim_database/ data/Scotch/ +data/SALT3.NIR_WAVEEXT/ # PyInstaller # Usually these files are written by a python script from a template From c1ee95f7b97e44e6b51ee1eb1ac76f8ecefb330e Mon Sep 17 00:00:00 2001 From: Nikki Date: Wed, 7 Aug 2024 16:16:01 +0200 Subject: [PATCH 25/50] tutorial can now use opsim to simulate time series images --- ...rnovae_plus_extended_source_tutorial.ipynb | 375 ++++++++++++------ 1 file changed, 243 insertions(+), 132 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index 7f3a691f5..0e8a70270 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -10,7 +10,7 @@ "from astropy.units import Quantity\n", "from slsim.lens_pop import LensPop\n", "import numpy as np\n", - "from slsim.image_simulation import lens_image_series\n", + "from slsim.image_simulation import lens_image_series, sharp_rgb_image\n", "from slsim.Plots.plot_functions import create_image_montage_from_image_list\n", "from slsim.image_simulation import point_source_coordinate_properties\n", "from slsim import lsst_science_pipeline\n", @@ -26,21 +26,19 @@ "metadata": {}, "source": [ "## Supernovae plus extended source simulation using OpSim\n", - "In this notebook, we simulate population of lensed supernovae and simulate image of a \n", + "In this notebook, we simulate a population of lensed supernovae and simulated data of a random lensed supernovae, using the observing strategy from [OpSim](https://www.lsst.org/scientists/simulations/opsim). These are simulated databases with observations form the Vera Rubin Observatory that contain the distribution of bands, observing times, sky locations, psf, limiting magnitudes, sky brightness, and more. \n", "\n", - "random lensed supernovae. It follows following steps:\n", + "This notebook follows the following steps:\n", "\n", "1. Simulate lensed supernovae population\n", "2. Choose a lens at random\n", - "3. Set observation time and other image configuration\n", - "4. Simulate image of a selected lens\n", - "5. Visualize it\n", + "3. Use OpSim to obtain the observation properties\n", + "4. Visualize the light curves and observations of the selected lens\n", + "4. Visualize time series of images of a selected lens\n", "\n", - "Before running this notebook, please download the \"scotch_SNIa_host_galaxies.fits\"\n", + "Before running this notebook, please download an OpSim database from [here](https://s3df.slac.stanford.edu/data/rubin/sim-data/) (for example, select ```sim-data/sims_featureScheduler_runs3.4/baseline/baseline_v3.4_10yrs.db```). Place it in the folder ```../data/OpSim_database/```.\n", "\n", - "file from the following link: https://github.com/LSST-strong-lensing/data_public.git. \n", - "\n", - "This file contains type Ia supernovae host galaxies." + "Additionally, download the SALT3.NIR_WAVEEXT directory from [here](https://github.com/LSST-strong-lensing/data_public/tree/main/sncosmo_sn_models) and place the directory in the folder ```../data/```. These files are a modified version of the type Ia models which have the lower and upper wavelength ranges extended." ] }, { @@ -80,28 +78,31 @@ "name": "stdout", "output_type": "stream", "text": [ - "3.37 minutes needed to simulate 1 square degrees.\n" + "Duration: 2.12 minutes\n" ] } ], "source": [ "# define a cosmology\n", - "cosmo = FlatLambdaCDM(H0=70, Om0=0.3)\n", + "H0 = 67.4\n", + "cosmo = FlatLambdaCDM(H0=H0, Om0=0.3)\n", + "\n", + "# define sky area scaling\n", + "sky_area = Quantity(value=50, unit=\"deg2\")\n", "\n", + "# define source and deflector sky areas (by keeping these low, the simulation is faster)\n", + "source_sky_area = Quantity(value=2, unit=\"deg2\")\n", + "deflector_sky_area = Quantity(value=2, unit=\"deg2\")\n", "\n", - "# define a sky area\n", - "area = 1\n", - "sky_area = Quantity(value=area, unit=\"deg2\")\n", + "# define limits in the intrinsic deflector and source population\n", + "kwargs_deflector_cut = {\"z_min\": 0.01, \"z_max\": 1.0}\n", + "kwargs_source_cut = {\"z_min\": 0.01, \"z_max\": 1.5}\n", "\n", "start_time = time.time()\n", - "# define limits in the intrinsic deflector and source population (in addition to the\n", - "# skypy config\n", - "# file)\n", - "kwargs_deflector_cut = {\"z_min\": 0.01, \"z_max\": 2.5}\n", - "kwargs_source_cut = {}\n", - "## create a point plus extended source lens population.\n", + "\n", + "## create a point plus extended source lens population\n", "supernova_lens_pop = LensPop(\n", - " deflector_type=\"all-galaxies\", # type of the deflector. It could be elliptical or\n", + " deflector_type=\"elliptical\", # type of the deflector. It could be elliptical or\n", " # all-galaxies.\n", " source_type=\"supernovae_plus_galaxies\", # keyword for source type. it can be\n", " # galaxies, quasar, quasar_plus_galaxies, and supernovae_plus_galaxies.\n", @@ -110,15 +111,18 @@ " kwargs_source_cut=kwargs_source_cut, # cuts that one wants to apply for the\n", " # source.\n", " variability_model=\"light_curve\", # keyword for the variability model.\n", - " kwargs_variability={\"supernovae_lightcurve\", \"i\"}, # specify kewords for\n", + " kwargs_variability={\"supernovae_lightcurve\", \"g\", \"r\", \"i\"}, # specify kewords for\n", " # lightcurve. \"i\" is a band for the lightcurve.\n", " sn_type=\"Ia\", # supernovae type.\n", " sn_absolute_mag_band=\"bessellb\", # Band used to normalize to absolute magnitude\n", " sn_absolute_zpsys=\"ab\", # magnitude system. It can be Optional, AB or Vega.\n", + " sn_modeldir='../data/SALT3.NIR_WAVEEXT', # extended wavelength models for SALT3\n", " kwargs_mass2light=None, # mass-to-light relation for the deflector galaxy.\n", " skypy_config=None, # Sky configuration for the simulation. If None, lsst-like\n", " # configuration will be used.\n", - " sky_area=sky_area, # Sky area for the simulation, source / deflector sky area\n", + " sky_area=sky_area, # Scaled sky area for the simulation\n", + " source_sky_area=source_sky_area,\n", + " deflector_sky_area=deflector_sky_area,\n", " cosmo=cosmo, # astropy cosmology\n", " source_light_profile=\"single_sersic\", # light profile for the source galaxy\n", " catalog_type=None, # catalog type. It can be None or scotch\n", @@ -134,12 +138,7 @@ " # https://github.com/LSST-strong-lensing/data_public.git\n", ")\n", "end_time = time.time()\n", - "print(\n", - " np.around((end_time - start_time) / 60, 2),\n", - " \"minutes needed to simulate \",\n", - " area,\n", - " \"square degrees.\",\n", - ")" + "print(\"Duration: \", np.around((end_time - start_time) / 60, 2), \"minutes\")" ] }, { @@ -151,7 +150,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Found 1204203 potential lenses and 2678 potential sources.\n" + "Found 2646425 potential deflector galaxies and 10650 potential source galaxies.\n" ] } ], @@ -159,9 +158,9 @@ "print(\n", " \"Found\",\n", " supernova_lens_pop.deflector_number,\n", - " \"potential lenses and\",\n", + " \"potential deflector galaxies and\",\n", " supernova_lens_pop.source_number,\n", - " \"potential sources.\",\n", + " \"potential source galaxies.\",\n", ")" ] }, @@ -169,7 +168,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Generate strong lensing systems" + "## Generate strong lensing systems and visualise properties" ] }, { @@ -181,8 +180,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "2.77 minutes needed to generate strong lenses.\n", - "Number of strong lens systems: 7\n" + "0.01 minutes needed to generate strong lenses.\n", + "Number of strong lens systems: 11\n" ] } ], @@ -192,7 +191,7 @@ "kwargs_lens_cuts = {}\n", "# drawing population\n", "supernovae_lens_population = supernova_lens_pop.draw_population(\n", - " kwargs_lens_cuts=kwargs_lens_cuts\n", + " kwargs_lens_cuts=kwargs_lens_cuts, speed_factor=10000\n", ")\n", "\n", "end_time = time.time()\n", @@ -206,15 +205,27 @@ { "cell_type": "code", "execution_count": 5, - "metadata": {}, + "metadata": { + "scrolled": false + }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ + "/Users/nikki/anaconda3/envs/slsim/lib/python3.12/site-packages/sncosmo/models.py:189: RuntimeWarning: divide by zero encountered in log10\n", + " result[i] = -2.5 * np.log10(f / zpf)\n", "/Users/nikki/anaconda3/envs/slsim/lib/python3.12/site-packages/sncosmo/models.py:189: RuntimeWarning: invalid value encountered in log10\n", " result[i] = -2.5 * np.log10(f / zpf)\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "z_l = [0.09 0.49 0.19 0.46 0.2 0.52 0.4 0.14 0.47 0.39 0.51]\n", + "z_s = [1.14 1.4 1.36 1.19 0.83 1.1 0.51 0.98 1.31 1.35 1.45]\n" + ] } ], "source": [ @@ -230,7 +241,14 @@ " r\"$m_{\\rm lens}$\",\n", "]\n", "\n", + "z_l = []\n", + "z_s = []\n", + "\n", "for supernovae_lens in supernovae_lens_population:\n", + " \n", + " z_l.append(supernovae_lens.deflector_redshift)\n", + " z_s.append(supernovae_lens.source_redshift)\n", + " \n", " vel_disp = supernovae_lens.deflector_velocity_dispersion()\n", " m_star = supernovae_lens.deflector_stellar_mass()\n", " theta_e = supernovae_lens.einstein_radius\n", @@ -245,23 +263,57 @@ " np.log10(m_star),\n", " theta_e,\n", " zl,\n", + " zs,\n", " source_mag,\n", " ps_source_mag,\n", " deflector_mag,\n", " ]\n", - " )" + " )\n", + " \n", + "print(\"z_l = \", np.around(z_l,2))\n", + "print(\"z_s = \", np.around(z_s, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hist2dkwargs = {\n", + " \"plot_density\": False,\n", + " \"plot_contours\": False,\n", + " \"plot_datapoints\": True,\n", + " \"color\": \"b\",\n", + " \"data_kwargs\": {\"ms\": 5},\n", + "}\n", + "corner.corner(\n", + " np.array(lens_samples), labels=labels, label_kwargs={\"fontsize\": 20}, **hist2dkwargs\n", + ")\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Choose a lens to simulate an image" + "## Choose one lens system to simulate LSST data" ] }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -269,33 +321,31 @@ "output_type": "stream", "text": [ "Chosen lens system properties:\n", - "z_lens = 0.18515243617298172\n", - "z_source = 2.3674687823642095\n", - "theta_E = 1.1984139515438024\n", - "Lens galaxy magnitude: 18.758226016429514\n", - "Host galaxy magnitude: 23.286907546282336\n", - "Supernova magnitude: 31.23713044554652\n" + " \n", + "z_lens = 0.456518871635215\n", + "z_source = 1.1928964311905985\n", + "theta_E = 0.5454736493768455\n", + "Number of images = 2\n", + "Time delays = [-36.97353321 9.05872107]\n", + "Lens galaxy magnitude: 24.978525100468065\n", + "Host galaxy magnitude: 24.27685981162744\n", + "Supernova magnitude: 24.877955939141234\n" ] } ], "source": [ - "index = 0\n", - "kwargs_lens_cut = {\"min_image_separation\": 1, \"max_image_separation\": 10}\n", + "index = 3\n", + "# kwargs_lens_cut = {\"min_image_separation\": 1, \"max_image_separation\": 10}\n", "rgb_band_list = [\"i\", \"r\", \"g\"]\n", "lens_class = supernovae_lens_population[index]\n", - "(\n", - " lens_class.source.source_dict[\"z\"],\n", - " lens_class.einstein_radius,\n", - " lens_class.source.source_dict[\"mag_i\"],\n", - " lens_class.source.source_dict[\"ps_mag_i\"],\n", - " # lens_class._deflector_dict[\"mag_i\"],\n", - " # lens_class._deflector_dict[\"z\"],\n", - ")\n", "\n", "print(\"Chosen lens system properties:\")\n", + "print(\" \")\n", "print(\"z_lens = \", lens_class.deflector_redshift)\n", "print(\"z_source = \", lens_class.source.source_dict[\"z\"])\n", "print(\"theta_E = \", lens_class.einstein_radius)\n", + "print(\"Number of images = \", lens_class.image_number)\n", + "print(\"Time delays = \", lens_class.point_source_arrival_times())\n", "print(\"Lens galaxy magnitude: \", lens_class.deflector_magnitude(band=\"i\"))\n", "print(\"Host galaxy magnitude: \", lens_class.source.source_dict[\"mag_i\"])\n", "print(\"Supernova magnitude: \", lens_class.source.source_dict[\"ps_mag_i\"])" @@ -303,7 +353,7 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -319,17 +369,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[26.57141984, 20.28503388],\n", - " [15.04963136, 15.0711548 ]])" + "array([[13.13094119, 20.27229935],\n", + " [15.38111176, 15.35063885]])" ] }, - "execution_count": 8, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -347,7 +397,7 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -356,34 +406,68 @@ "text": [ "This is a type Ia SN\n" ] + }, + { + "data": { + "text/plain": [ + "(-50.0, 100.0)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "light_curve = lens_class.source.variability_class.kwargs_model\n", "\n", - "print(\"This is a type\", lens_class.source.sn_type, \"SN\")" + "print(\"This is a type\", lens_class.source.sn_type, \"SN\")\n", + "\n", + "plt.figure(figsize=(5,3))\n", + "plt.plot(light_curve[\"MJD\"], light_curve[\"ps_mag_i\"], color='Midnightblue')\n", + "plt.gca().invert_yaxis()\n", + "plt.ylabel(r\"$i$-band magnitude\")\n", + "plt.xlabel(\"Time [days]\")\n", + "plt.xlim(-50, 100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## High-resolution rgb image" ] }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(-50.0, 100.0)" + "Text(0.5, 1.0, 'High-resolution RGB image')" ] }, - "execution_count": 78, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -391,12 +475,20 @@ } ], "source": [ - "plt.plot(light_curve[\"MJD\"], light_curve[\"ps_mag_i\"])\n", - "# plt.ylim(12, 18)\n", - "plt.gca().invert_yaxis()\n", - "plt.ylabel(r\"$i$-band magnitude\")\n", - "plt.xlabel(\"Time [days]\")\n", - "plt.xlim(-50, 100)" + "rgb_band_list = [\"i\", \"r\", \"g\"]\n", + "\n", + "high_reso_rgb = sharp_rgb_image(\n", + " lens_class=lens_class,\n", + " rgb_band_list=rgb_band_list,\n", + " mag_zero_point=28,\n", + " delta_pix=0.02,\n", + " num_pix=200,\n", + ")\n", + "plt.figure(figsize=(5,5))\n", + "plt.imshow(high_reso_rgb, origin=\"lower\")\n", + "plt.xlabel(\"pixels\")\n", + "plt.ylabel(\"pixels\")\n", + "plt.title(\"High-resolution RGB image\")" ] }, { @@ -415,7 +507,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -429,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": { "scrolled": false }, @@ -439,10 +531,11 @@ "output_type": "stream", "text": [ "Reading from database sqlite:///../data/OpSim_database/baseline_v3.0_10yrs.db\n", - "Read N = 2086079 observations in 43.41 seconds.\n", + "Read N = 2086079 observations in 43.19 seconds.\n", "No host file.\n", - "Coordinate (-42.62275274912281 deg, 15.73605140756275 deg) is not in the LSST footprint. This entry is skipped.\n", - "Coordinate (64.49873263637397 deg, 34.67603238561339 deg) is not in the LSST footprint. This entry is skipped.\n" + "Coordinate (172.90991640808832 deg, 49.631056110355445 deg) is not in the LSST footprint. This entry is skipped.\n", + "Coordinate (-109.93420854090337 deg, 60.24663542585676 deg) is not in the LSST footprint. This entry is skipped.\n", + "Coordinate (73.54234401592636 deg, 62.41016024697848 deg) is not in the LSST footprint. This entry is skipped.\n" ] } ], @@ -461,12 +554,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Simulate variable_lens_injection with OpSim" + "## Inject lensed SNe into empty image\n", + "\n", + "using ```opsim_variable_lens_injection()```" ] }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 27, "metadata": { "scrolled": false }, @@ -475,44 +570,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "['bkg_noise', 'psf_kernel', 'obs_time', 'expo_time', 'zero_point', 'calexp_center', 'band', 'lens', 'injected_lens']\n", - "12 observations\n" + "images.keys() : ['bkg_noise', 'psf_kernel', 'obs_time', 'expo_time', 'zero_point', 'calexp_center', 'band', 'lens', 'injected_lens']\n", + " \n", + "29 observations\n" ] - } - ], - "source": [ - "index = 5\n", - "bands = [\"i\"]\n", - "num_pix = 200\n", - "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", - "\n", - "images = lsst_science_pipeline.opsim_variable_lens_injection(\n", - " lens_class, bands, num_pix, transform_pix2angle, exposure_data[index]\n", - ")\n", - "print(images.keys())\n", - "print(len(images[\"obs_time\"]), \"observations\")" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "metadata": {}, - "outputs": [ + }, { "data": { "text/plain": [ - "(80.0, 120.0)" + "Text(0.5, 1.0, 'Injected lens system')" ] }, - "execution_count": 80, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -520,22 +597,41 @@ } ], "source": [ + "index = 0\n", + "bands = [\"g\", \"r\", \"i\"]\n", + "num_pix = 200\n", + "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", + "\n", + "images = lsst_science_pipeline.opsim_variable_lens_injection(\n", + " lens_class, bands, num_pix, transform_pix2angle, exposure_data[index]\n", + ")\n", + "print(\"images.keys() : \", images.keys())\n", + "print(\" \")\n", + "print(len(images[\"obs_time\"]), \"observations\")\n", + "\n", + "plt.figure(figsize=(3,3))\n", "plt.imshow(images[\"lens\"][0], origin=\"lower\")\n", "plt.xlim(80, 120)\n", - "plt.ylim(80, 120)" + "plt.ylim(80, 120)\n", + "plt.xlabel(\"pixels\")\n", + "plt.ylabel(\"pixels\")\n", + "plt.title(\"Injected lens system\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Simulate lens_image_series with OpSim" + "## Compute time series of images\n", + "Using ```lens_image_series()``` with OpSim input for ```band, mag_zero_point, psf_kernel, exposure_time, t_obs```." ] }, { "cell_type": "code", - "execution_count": 81, - "metadata": {}, + "execution_count": 28, + "metadata": { + "scrolled": false + }, "outputs": [], "source": [ "im_times = images[\"obs_time\"] - images[\"obs_time\"][0] - 20\n", @@ -547,7 +643,7 @@ "# Simulate a lens image\n", "images_opsim = lens_image_series(\n", " lens_class=lens_class,\n", - " band=\"i\",\n", + " band=list(images[\"band\"]),\n", " mag_zero_point=images[\"zero_point\"],\n", " num_pix=32,\n", " psf_kernel=images[\"psf_kernel\"],\n", @@ -561,24 +657,32 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 29, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6x/j1tbqdk91439t5vn1y800sb40000gn/T/ipykernel_10201/1074870882.py:4: RuntimeWarning: divide by zero encountered in log10\n", + " log_images.append(np.log10(images_opsim[i]))\n" + ] + }, { "data": { "text/plain": [ - "" + "Text(0.5, 1.0, 'log-scale image')" ] }, - "execution_count": 82, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -591,19 +695,25 @@ "for i in range(len(images_opsim)):\n", " log_images.append(np.log10(images_opsim[i]))\n", "\n", - "plt.imshow(log_images[0], origin=\"lower\")" + "plt.figure(figsize=(3,3))\n", + "plt.imshow(log_images[0], origin=\"lower\")\n", + "plt.xlabel(\"pixels\")\n", + "plt.ylabel(\"pixels\")\n", + "plt.title(\"log-scale image\")" ] }, { "cell_type": "code", - "execution_count": 83, - "metadata": {}, + "execution_count": 31, + "metadata": { + "scrolled": false + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -612,10 +722,9 @@ ], "source": [ "plot_montage = create_image_montage_from_image_list(\n", - " num_rows=3, num_cols=5, images=images_opsim, time=im_times, image_center=pix_coord\n", - ")\n", - "\n", - "# add \"band=band\" and add as text to plots" + " num_rows=6, num_cols=5, images=images_opsim, time=im_times, image_center=pix_coord, \n", + " band=list(images[\"band\"])\n", + ")" ] }, { @@ -638,12 +747,10 @@ "### Issues\n", "\n", "- if ```catalog_type=None``` instead of ```\"scotch\"```, the ```double_sersic``` model is not defined. I get the error: ellipticity or semi-major and semi-minor axis are missing for the first light profile in galaxy_list columns.\n", - "- Light curve looks a bit strange for a type Ia SN?\n", "- If the light curve goes down to very low magnitudes (~40), then I get a \"lam value too large\" error (see screenshot).\n", - "- Is it possible to give ```LensPop kwargs_variability={\"supernovae_lightcurve\", \"i\"}``` a list of bands instead of just one single band? Because otherwise I cannot compute the brightnesses in the other bands so I cannot simulate multiband images.\n", "- ```lens_class._deflector_dict[\"mag_i\"]}```, and ```lens_class._deflector_dict[\"z\"]``` were not working for me, I replaced them with ```lens_class.deflector_magnitude(band='i')``` and ```lens_class.deflector_redshift```.\n", - "- Even when I have a lot of potential lens and source galaxies, the resulting strong lenses are very few (order of 10). A more efficient way to sample would be good.\n", - "- The magnitudes of the supernovae are all very faint, so in the images I only see the lens galaxy. I tend to sample very low-redshift lenses and high-redshift sources." + "- In the code to generate data for the cornerplot, ```z_s``` was missing.\n", + "- The magnitudes of the supernovae are all very faint, so in the images I only see the lens galaxy. I tend to sample very low-redshift lenses and high-redshift sources. It would be great if there's a way to define a magnitude cut for point sources." ] }, { @@ -651,7 +758,11 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Brightness cut for SNe (23rd mag)\n", + "# Run the code without errors and for all bands (also z and y once added to ps_mag).\n", + "# Plot both light curves (with time delay) with LSST observations (new plot function?)" + ] } ], "metadata": { From 978c21bd4cc7304842fb36649b739d3e87acfd94 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 7 Aug 2024 16:27:28 +0000 Subject: [PATCH 26/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- ...rnovae_plus_extended_source_tutorial.ipynb | 28 +++++++++++-------- slsim/Plots/plot_functions.py | 8 +++++- 2 files changed, 23 insertions(+), 13 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index 0e8a70270..8a65054ad 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -116,7 +116,7 @@ " sn_type=\"Ia\", # supernovae type.\n", " sn_absolute_mag_band=\"bessellb\", # Band used to normalize to absolute magnitude\n", " sn_absolute_zpsys=\"ab\", # magnitude system. It can be Optional, AB or Vega.\n", - " sn_modeldir='../data/SALT3.NIR_WAVEEXT', # extended wavelength models for SALT3\n", + " sn_modeldir=\"../data/SALT3.NIR_WAVEEXT\", # extended wavelength models for SALT3\n", " kwargs_mass2light=None, # mass-to-light relation for the deflector galaxy.\n", " skypy_config=None, # Sky configuration for the simulation. If None, lsst-like\n", " # configuration will be used.\n", @@ -245,10 +245,10 @@ "z_s = []\n", "\n", "for supernovae_lens in supernovae_lens_population:\n", - " \n", + "\n", " z_l.append(supernovae_lens.deflector_redshift)\n", " z_s.append(supernovae_lens.source_redshift)\n", - " \n", + "\n", " vel_disp = supernovae_lens.deflector_velocity_dispersion()\n", " m_star = supernovae_lens.deflector_stellar_mass()\n", " theta_e = supernovae_lens.einstein_radius\n", @@ -269,8 +269,8 @@ " deflector_mag,\n", " ]\n", " )\n", - " \n", - "print(\"z_l = \", np.around(z_l,2))\n", + "\n", + "print(\"z_l = \", np.around(z_l, 2))\n", "print(\"z_s = \", np.around(z_s, 2))" ] }, @@ -433,8 +433,8 @@ "\n", "print(\"This is a type\", lens_class.source.sn_type, \"SN\")\n", "\n", - "plt.figure(figsize=(5,3))\n", - "plt.plot(light_curve[\"MJD\"], light_curve[\"ps_mag_i\"], color='Midnightblue')\n", + "plt.figure(figsize=(5, 3))\n", + "plt.plot(light_curve[\"MJD\"], light_curve[\"ps_mag_i\"], color=\"Midnightblue\")\n", "plt.gca().invert_yaxis()\n", "plt.ylabel(r\"$i$-band magnitude\")\n", "plt.xlabel(\"Time [days]\")\n", @@ -484,7 +484,7 @@ " delta_pix=0.02,\n", " num_pix=200,\n", ")\n", - "plt.figure(figsize=(5,5))\n", + "plt.figure(figsize=(5, 5))\n", "plt.imshow(high_reso_rgb, origin=\"lower\")\n", "plt.xlabel(\"pixels\")\n", "plt.ylabel(\"pixels\")\n", @@ -609,7 +609,7 @@ "print(\" \")\n", "print(len(images[\"obs_time\"]), \"observations\")\n", "\n", - "plt.figure(figsize=(3,3))\n", + "plt.figure(figsize=(3, 3))\n", "plt.imshow(images[\"lens\"][0], origin=\"lower\")\n", "plt.xlim(80, 120)\n", "plt.ylim(80, 120)\n", @@ -695,7 +695,7 @@ "for i in range(len(images_opsim)):\n", " log_images.append(np.log10(images_opsim[i]))\n", "\n", - "plt.figure(figsize=(3,3))\n", + "plt.figure(figsize=(3, 3))\n", "plt.imshow(log_images[0], origin=\"lower\")\n", "plt.xlabel(\"pixels\")\n", "plt.ylabel(\"pixels\")\n", @@ -722,8 +722,12 @@ ], "source": [ "plot_montage = create_image_montage_from_image_list(\n", - " num_rows=6, num_cols=5, images=images_opsim, time=im_times, image_center=pix_coord, \n", - " band=list(images[\"band\"])\n", + " num_rows=6,\n", + " num_cols=5,\n", + " images=images_opsim,\n", + " time=im_times,\n", + " image_center=pix_coord,\n", + " band=list(images[\"band\"]),\n", ")" ] }, diff --git a/slsim/Plots/plot_functions.py b/slsim/Plots/plot_functions.py index ea5e7dfe0..7b1e0cf7e 100644 --- a/slsim/Plots/plot_functions.py +++ b/slsim/Plots/plot_functions.py @@ -7,7 +7,13 @@ def create_image_montage_from_image_list( - num_rows, num_cols, images, time=None, band=None, image_type="other", image_center=None + num_rows, + num_cols, + images, + time=None, + band=None, + image_type="other", + image_center=None, ): """Creates an image montage from an image list. From 9782e9e3cfde9b7de44d5bd1c9d1264ee8277192 Mon Sep 17 00:00:00 2001 From: Nikki Arendse Date: Thu, 8 Aug 2024 18:32:58 +0200 Subject: [PATCH 27/50] Delete notebooks/lens_source_injection-Copy1.ipynb --- notebooks/lens_source_injection-Copy1.ipynb | 865 -------------------- 1 file changed, 865 deletions(-) delete mode 100644 notebooks/lens_source_injection-Copy1.ipynb diff --git a/notebooks/lens_source_injection-Copy1.ipynb b/notebooks/lens_source_injection-Copy1.ipynb deleted file mode 100644 index 4acf28495..000000000 --- a/notebooks/lens_source_injection-Copy1.ipynb +++ /dev/null @@ -1,865 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "fd70c97a", - "metadata": {}, - "outputs": [], - "source": [ - "import opsimsummaryv2 as op" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "64d66921", - "metadata": { - "execution": { - "iopub.execute_input": "2023-08-14T22:44:03.255969Z", - "iopub.status.busy": "2023-08-14T22:44:03.254836Z", - "iopub.status.idle": "2023-08-14T22:44:06.388495Z", - "shell.execute_reply": "2023-08-14T22:44:06.387611Z", - "shell.execute_reply.started": "2023-08-14T22:44:03.255926Z" - }, - "scrolled": false, - "tags": [] - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import sys\n", - "from astropy.cosmology import FlatLambdaCDM\n", - "from astropy.units import Quantity\n", - "from slsim.lens_pop import LensPop\n", - "from slsim.image_simulation import (\n", - " sharp_image,\n", - " sharp_rgb_image,\n", - " rgb_image_from_image_list,\n", - ")\n", - "import galsim\n", - "import mpl_toolkits.axisartist.floating_axes as floating_axes\n", - "from mpl_toolkits.axisartist.grid_finder import MaxNLocator, DictFormatter\n", - "from matplotlib.transforms import Affine2D\n", - "\n", - "# import lsst.daf.butler as dafButler\n", - "# import lsst.geom as geom\n", - "# import lsst.afw.display as afwDisplay\n", - "# from lsst.pipe.tasks.insertFakes import _add_fake_sources\n", - "from slsim import lsst_science_pipeline\n", - "import astropy.coordinates as coord\n", - "import astropy.units as u" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fee1fe4a", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "28ee0ced", - "metadata": {}, - "outputs": [], - "source": [ - "print(\"done\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b1935849", - "metadata": {}, - "outputs": [], - "source": [ - "# Import OpSimSummaryV2\n", - "try:\n", - " import opsimsummaryv2 as op\n", - "except ImportError:\n", - " raise ImportError(\n", - " \"Users need to have OpSimSummaryV2 installed (https://github.com/bastiencarreres/OpSimSummaryV2)\"\n", - " )\n", - "\n", - "# Initialise OpSimSummaryV2 with opsim database\n", - "try:\n", - " opsim_path = \"../data/OpSim_database/\" + obs_strategy + \".db\"\n", - " OpSimSurv = op.OpSimSurvey(opsim_path)\n", - "except FileNotFoundError:\n", - " raise FileNotFoundError(\n", - " \"File not found: \"\n", - " + opsim_path\n", - " + \". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database\"\n", - " )\n", - "\n", - "# Collect observations that cover the coordinates in ra_list and dec_list\n", - "gen = OpSimSurv.get_obs_from_coords(ra_list, dec_list, is_deg=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bec351fa", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "993a0b60", - "metadata": {}, - "outputs": [], - "source": [ - "N = 10\n", - "\n", - "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", - "ra_points = ra_points.wrap_at(180 * u.degree)\n", - "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", - "dec_points = coord.Angle(dec_points * u.degree)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0dac9d61", - "metadata": {}, - "outputs": [], - "source": [ - "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(\n", - " ra_points, dec_points, \"baseline_v3.0_10yrs\", MJD_min=60000, MJD_max=60300\n", - ")\n", - "exposure_data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5767de15", - "metadata": {}, - "outputs": [], - "source": [ - "# add galsim to requirements\n", - "# colossus is listed twice" - ] - }, - { - "cell_type": "markdown", - "id": "f3c701c3", - "metadata": {}, - "source": [ - "## Lensed source injection in DC2 data" - ] - }, - { - "cell_type": "markdown", - "id": "ab92b75c-4ce7-4d54-b8bb-68d3db80eb7b", - "metadata": {}, - "source": [ - "This notebook uses slsim to generate lens-deflector population. Then, we select a random lens-deflector\n", - "\n", - "and inject it to a patch of the DC2 data." - ] - }, - { - "cell_type": "markdown", - "id": "60e07f48-9aeb-45e0-9454-eacebcfc4921", - "metadata": {}, - "source": [ - "## Generate population of sources and deflectors" - ] - }, - { - "cell_type": "markdown", - "id": "d79f6fa6-296a-447c-8cfa-f133a4c0d7bd", - "metadata": { - "execution": { - "iopub.execute_input": "2023-07-21T18:51:20.484913Z", - "iopub.status.busy": "2023-07-21T18:51:20.484398Z", - "iopub.status.idle": "2023-07-21T18:51:20.490580Z", - "shell.execute_reply": "2023-07-21T18:51:20.489623Z", - "shell.execute_reply.started": "2023-07-21T18:51:20.484880Z" - }, - "tags": [] - }, - "source": [ - "Using slsim one can generate galaxy-galaxy lenses." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d0d48388-dee5-4488-81f4-b3d636b3a698", - "metadata": { - "execution": { - "iopub.execute_input": "2023-08-14T22:43:59.996001Z", - "iopub.status.busy": "2023-08-14T22:43:59.994972Z", - "iopub.status.idle": "2023-08-14T22:44:00.000126Z", - "shell.execute_reply": "2023-08-14T22:43:59.999335Z", - "shell.execute_reply.started": "2023-08-14T22:43:59.995960Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "## Users should change this path to their slsim path\n", - "sys.path.insert(0, \"../slsim/\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "834ce91e-1958-4c80-b35a-107720c4ff72", - "metadata": { - "execution": { - "iopub.execute_input": "2023-08-14T22:44:11.102224Z", - "iopub.status.busy": "2023-08-14T22:44:11.101637Z", - "iopub.status.idle": "2023-08-14T22:44:43.143147Z", - "shell.execute_reply": "2023-08-14T22:44:43.142083Z", - "shell.execute_reply.started": "2023-08-14T22:44:11.102187Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "# define a cosmology\n", - "cosmo = FlatLambdaCDM(H0=70, Om0=0.3)\n", - "\n", - "# define a sky area\n", - "sky_area = Quantity(value=0.1, unit=\"deg2\")\n", - "\n", - "\n", - "# define limits in the intrinsic deflector and source population (in addition to the skypy config\n", - "# file)\n", - "kwargs_deflector_cut = {\"band\": \"g\", \"band_max\": 28, \"z_min\": 0.01, \"z_max\": 2.5}\n", - "kwargs_source_cut = {\"band\": \"g\", \"band_max\": 28, \"z_min\": 0.1, \"z_max\": 5.0}\n", - "\n", - "# run skypy pipeline and make galaxy-galaxy population class using LensPop\n", - "gg_lens_pop = LensPop(\n", - " deflector_type=\"all-galaxies\",\n", - " source_type=\"galaxies\",\n", - " kwargs_deflector_cut=kwargs_deflector_cut,\n", - " kwargs_source_cut=kwargs_source_cut,\n", - " kwargs_mass2light=None,\n", - " skypy_config=None,\n", - " sky_area=sky_area,\n", - " cosmo=cosmo,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "568932d9-f62a-4a5e-945f-f5b82647039e", - "metadata": {}, - "source": [ - "## Select a lens at random and generate a high resolution image" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "efa81c8a-8404-40f2-a0b3-70e13ff1611e", - "metadata": { - "execution": { - "iopub.execute_input": "2023-08-14T22:49:58.155179Z", - "iopub.status.busy": "2023-08-14T22:49:58.153874Z", - "iopub.status.idle": "2023-08-14T22:49:58.551444Z", - "shell.execute_reply": "2023-08-14T22:49:58.550418Z", - "shell.execute_reply.started": "2023-08-14T22:49:58.155139Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "kwargs_lens_cut = {\n", - " \"min_image_separation\": 3,\n", - " \"max_image_separation\": 10,\n", - " \"mag_arc_limit\": {\"g\": 22, \"r\": 22, \"i\": 22},\n", - "}\n", - "rgb_band_list = [\"i\", \"r\", \"g\"]\n", - "lens_class = gg_lens_pop.select_lens_at_random(**kwargs_lens_cut)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9dce1a91-2c90-4f6e-b3cb-b18547c33c87", - "metadata": { - "execution": { - "iopub.execute_input": "2023-08-14T22:50:02.322956Z", - "iopub.status.busy": "2023-08-14T22:50:02.321951Z", - "iopub.status.idle": "2023-08-14T22:50:02.432770Z", - "shell.execute_reply": "2023-08-14T22:50:02.431771Z", - "shell.execute_reply.started": "2023-08-14T22:50:02.322913Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "image_i_1 = sharp_image(\n", - " lens_class=lens_class,\n", - " band=rgb_band_list[0],\n", - " mag_zero_point=27,\n", - " delta_pix=0.2,\n", - " num_pix=200,\n", - ")\n", - "image_r_1 = sharp_image(\n", - " lens_class=lens_class,\n", - " band=rgb_band_list[1],\n", - " mag_zero_point=27,\n", - " delta_pix=0.2,\n", - " num_pix=200,\n", - ")\n", - "image_g_1 = sharp_image(\n", - " lens_class=lens_class,\n", - " band=rgb_band_list[2],\n", - " mag_zero_point=27,\n", - " delta_pix=0.2,\n", - " num_pix=200,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9f44dc9c-1999-481b-87d9-bbaa6782395d", - "metadata": { - "execution": { - "iopub.execute_input": "2023-08-14T22:50:05.761403Z", - "iopub.status.busy": "2023-08-14T22:50:05.760033Z", - "iopub.status.idle": "2023-08-14T22:50:05.958947Z", - "shell.execute_reply": "2023-08-14T22:50:05.958217Z", - "shell.execute_reply.started": "2023-08-14T22:50:05.761345Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "# image_g.shape\n", - "plt.imshow(image_i_1, origin=\"lower\")\n", - "plt.xlim(75, 125)\n", - "plt.ylim(75, 125)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ad707603-1867-4014-96b7-234d60fd03fb", - "metadata": { - "execution": { - "iopub.execute_input": "2023-07-21T18:48:11.924529Z", - "iopub.status.busy": "2023-07-21T18:48:11.923414Z", - "iopub.status.idle": "2023-07-21T18:48:12.102182Z", - "shell.execute_reply": "2023-07-21T18:48:12.101351Z", - "shell.execute_reply.started": "2023-07-21T18:48:11.924461Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "high_reso_rgb = sharp_rgb_image(\n", - " lens_class=lens_class,\n", - " rgb_band_list=rgb_band_list,\n", - " mag_zero_point=27,\n", - " delta_pix=0.2,\n", - " num_pix=200,\n", - ")\n", - "\n", - "plt.imshow(high_reso_rgb, origin=\"lower\")\n", - "plt.xlim(75, 125)\n", - "plt.ylim(75, 125)" - ] - }, - { - "cell_type": "markdown", - "id": "b7fdb441-5312-4615-a388-de5d4e2c2e7a", - "metadata": {}, - "source": [ - "## Inject the randomly selected lens " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c3583a71-357a-4a32-8ffc-3093d58cffe6", - "metadata": { - "execution": { - "iopub.execute_input": "2023-07-31T21:23:45.432354Z", - "iopub.status.busy": "2023-07-31T21:23:45.431497Z", - "iopub.status.idle": "2023-07-31T21:23:45.435397Z", - "shell.execute_reply": "2023-07-31T21:23:45.434770Z", - "shell.execute_reply.started": "2023-07-31T21:23:45.432323Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "ra = 62.541629 # degrees\n", - "dec = -37.852021 # degrees\n", - "\n", - "ra_list = [ra]\n", - "dec_list = [dec]\n", - "delta_pix = 0.2" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "af429deb", - "metadata": { - "scrolled": false - }, - "outputs": [], - "source": [ - "import opsimsummary\n", - "\n", - "Replace np.int by int \n", - "~/anaconda3/envs/slsim/lib/python3.12/site-packages/opsimsummary/summarize_opsim.py" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "42db18da-5d0a-4dfc-86e6-7314936b4005", - "metadata": { - "execution": { - "iopub.execute_input": "2023-07-31T21:23:47.574166Z", - "iopub.status.busy": "2023-07-31T21:23:47.573355Z", - "iopub.status.idle": "2023-07-31T21:23:58.136282Z", - "shell.execute_reply": "2023-07-31T21:23:58.135425Z", - "shell.execute_reply.started": "2023-07-31T21:23:47.574135Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "y = lsst_science_pipeline.lens_inejection(\n", - " gg_lens_pop, 201, 0.2, butler, ra, dec, flux=None\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "870ff6da-17d5-459a-90c5-8c0b0fb1b3f0", - "metadata": { - "execution": { - "iopub.execute_input": "2023-07-31T21:25:26.587461Z", - "iopub.status.busy": "2023-07-31T21:25:26.586546Z", - "iopub.status.idle": "2023-07-31T21:25:26.593078Z", - "shell.execute_reply": "2023-07-31T21:25:26.592444Z", - "shell.execute_reply.started": "2023-07-31T21:25:26.587426Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "## This line should display an astropy table containg lens image,dp0 cutout_image, injected_lens\n", - "## in r, g, and i band and center of the dp0 cutout images.\n", - "y" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "58113000", - "metadata": {}, - "outputs": [], - "source": [ - "import lenstronomy.Util.kernel_util as kernel_util\n", - "import lenstronomy.Util.util as util\n", - "import lenstronomy.Util.data_util as data_util\n", - "from astropy.table import Table, vstack\n", - "\n", - "size = 101\n", - "delta_pix = 0.2\n", - "psf_fwhm = 0.7\n", - "moffat_beta = 3.1\n", - "\n", - "# Create a Moffat psf kernel\n", - "psf_kernel = kernel_util.kernel_moffat(\n", - " num_pix=size, delta_pix=delta_pix, fwhm=psf_fwhm, moffat_beta=moffat_beta\n", - ")\n", - "\n", - "psf_kernel = util.array2image(psf_kernel)\n", - "\n", - "psf_kernel" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "163711f9", - "metadata": {}, - "outputs": [], - "source": [ - "def opsim_time_series_images_data2(\n", - " ra_list,\n", - " dec_list,\n", - " obs_strategy,\n", - " MJD_min=60000,\n", - " MJD_max=64000,\n", - " size=101,\n", - " moffat_beta=3.1,\n", - " readout_noise=10,\n", - " delta_pix=0.2,\n", - "):\n", - " \"\"\"Creates time series data from opsim database.\n", - "\n", - " :param ra_list: a list of ra points (in degrees) from objects we want to collect\n", - " observations for\n", - " :param dec_list: a list of dec points (in degrees) from objects we want to collect\n", - " observations for\n", - " :param obs_strategy: version of observing strategy corresponding to opsim database.\n", - " for example \"baseline_v3.0_10yrs\" (string)\n", - " :param size: cutout size of images (in pixels)\n", - " :param moffat_beta: power index of the moffat psf kernel\n", - " :param readout_noise: noise added per readout\n", - " :param delta_pix: size of pixel in units arcseonds\n", - " :return: a list of astropy tables containing observation information for each\n", - " coordinate\n", - " \"\"\"\n", - "\n", - " # Import OpSimSummaryV2\n", - " try:\n", - " import opsimsummaryv2 as op\n", - " except ImportError:\n", - " raise ImportError(\n", - " \"Users need to have OpSimSummaryV2 installed (https://github.com/bastiencarreres/OpSimSummaryV2)\"\n", - " )\n", - "\n", - " # Initialise OpSimSummaryV2 with opsim database\n", - " try:\n", - " opsim_path = \"../data/OpSim_database/\" + obs_strategy + \".db\"\n", - " OpSimSurv = op.OpSimSurvey(opsim_path)\n", - " except FileNotFoundError:\n", - " raise FileNotFoundError(\n", - " \"File not found: \"\n", - " + opsim_path\n", - " + \". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database\"\n", - " )\n", - "\n", - " # Collect observations that cover the coordinates in ra_list and dec_list\n", - " gen = OpSimSurv.get_obs_from_coords(ra_list, dec_list, is_deg=True)\n", - "\n", - " table_data_list = []\n", - "\n", - " # Loop through all coordinates and compute the table_data\n", - " for i in range(len(ra_list)):\n", - "\n", - " # Collect the next observation sequence from the opsim generator\n", - " seq = next(gen)\n", - " seq = seq.sort_values(by=[\"observationStartMJD\"])\n", - "\n", - " # Check if the coordinates are in the opsim LSST footprint\n", - " opsim_ra = np.mean(seq[\"fieldRA\"])\n", - " opsim_dec = np.mean(seq[\"fieldDec\"])\n", - "\n", - " if np.isnan(opsim_ra) or np.isnan(opsim_dec):\n", - " print(\n", - " f\"Coordinate ({ra_list[i]}, {dec_list[i]}) is not in the LSST footprint. This entry is skipped.\"\n", - " )\n", - " continue\n", - "\n", - " # Get the relevant properties from opsim\n", - " obs_time = np.array(seq[\"observationStartMJD\"])\n", - "\n", - " # Only give the observations between MJD_min and MJD_max\n", - " mask = (obs_time > MJD_min) & (obs_time < MJD_max)\n", - " obs_time = obs_time[mask]\n", - "\n", - " expo_time = np.array(seq[\"visitExposureTime\"])[mask]\n", - " sky_brightness = np.array(seq[\"skyBrightness\"])[mask]\n", - " bandpass = np.array(seq[\"filter\"])[mask]\n", - " psf_fwhm = np.array(seq[\"seeingFwhmGeom\"])[mask]\n", - " m5_depth = np.array(seq[\"fiveSigmaDepth\"])[mask]\n", - " # Question: use 'FWHMeff' or 'seeingFwhmGeom' for the psf?\n", - "\n", - " radec_list = [(ra_list[i], dec_list[i])] * len(obs_time)\n", - "\n", - " # Create a Moffat psf kernel for each epoch\n", - "\n", - " psf_kernels = []\n", - "\n", - " for psf in psf_fwhm:\n", - "\n", - " psf_kernel = kernel_util.kernel_moffat(\n", - " num_pix=size, delta_pix=delta_pix, fwhm=psf, moffat_beta=moffat_beta\n", - " )\n", - " psf_kernel = util.array2image(psf_kernel)\n", - "\n", - " psf_kernels.append(psf_kernel)\n", - "\n", - " psf_kernels = np.array(psf_kernels)\n", - "\n", - " # Calculate background noise\n", - " bkg_noise = data_util.bkg_noise(\n", - " readout_noise, expo_time, sky_brightness, delta_pix, num_exposures=1\n", - " )\n", - "\n", - " # Calculate the zero point magnitude\n", - " # Code from OpSimSummary/opsimsummary/simlib.py/add_simlibCols\n", - " # need to work in nvariance in photon electrons\n", - " term1 = (\n", - " 2.0 * m5_depth - sky_brightness\n", - " ) # * pixArea whata units is sky birghtness? counts or photo electrons?\n", - " # per pixel or arcsec?\n", - " term2 = -(m5_depth - sky_brightness) # * pixArea\n", - " area = (1.51 * psf_fwhm) ** 2.0 # area = 1 / int(psf^2)\n", - " opsim_snr = 5.0\n", - " arg = area * opsim_snr * opsim_snr\n", - " # Background dominated limit assuming counts with system transmission only\n", - " # is approximately equal to counts with total transmission\n", - " zpt_approx = term1 + 2.5 * np.log10(arg)\n", - " val = -0.4 * term2\n", - " tmp = 10.0**val\n", - " # Additional term to account for photons from the source, again assuming\n", - " # that counts with system transmission approximately equal counts with total transmission.\n", - " zpt_cor = 2.5 * np.log10(1.0 + 1.0 / (area * tmp))\n", - " zero_point_mag = zpt_approx + zpt_cor\n", - "\n", - " table_data = Table(\n", - " [\n", - " bkg_noise,\n", - " psf_kernels,\n", - " obs_time,\n", - " expo_time,\n", - " zero_point_mag,\n", - " radec_list,\n", - " bandpass,\n", - " ],\n", - " names=(\n", - " \"bkg_noise\",\n", - " \"psf_kernel\",\n", - " \"obs_time\",\n", - " \"expo_time\",\n", - " \"zero_point\",\n", - " \"calexp_center\",\n", - " \"band\",\n", - " ),\n", - " )\n", - "\n", - " table_data_list.append(table_data)\n", - " return table_data_list" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "05f8b9a2", - "metadata": {}, - "outputs": [], - "source": [ - "def opsim_variable_lens_injection(\n", - " lens_class, bands, num_pix, transform_pix2angle, exposure_data\n", - "):\n", - " \"\"\"Injects variable lens to the OpSim time series data (1 object).\n", - "\n", - " :param lens_class: Lens() object\n", - " :param bands: list of imaging bands of interest\n", - " :param num_pix: number of pixels per axis\n", - " :param transform_pix2angle: transformation matrix (2x2) of pixels into coordinate\n", - " displacements\n", - " :param exposure_data: An astropy table of exposure data. One entry of table_list_data\n", - " generated from the opsim_time_series_images_data function. It must contain the rms of\n", - " background noise fluctuations (column name should be \"bkg_noise\"), psf kernel for\n", - " each exposure (column name should be \"psf_kernel\", these are pixel psf kernel\n", - " for each single exposure images in time series image), observation time\n", - " (column name should be \"obs_time\", these are observation time in days for each\n", - " single exposure images in time series images), exposure time (column name should\n", - " be \"expo_time\", these are exposure time for each single exposure images in time\n", - " series images), magnitude zero point (column name should be \"zero_point\", these\n", - " are zero point magnitudes for each single exposure images in time series image),\n", - " coordinates of the object (column name should be \"calexp_center\"), these are\n", - " the coordinates in (ra, dec), and the band in which the observation is taken\n", - " (column name should be \"band\").\n", - "\n", - " :return: Astropy table of injected lenses and exposure information of dp0 data\n", - " \"\"\"\n", - "\n", - " final_image = []\n", - "\n", - " for obs in range(len(exposure_data[\"obs_time\"])):\n", - "\n", - " exposure_data_obs = exposure_data[obs]\n", - "\n", - " if exposure_data_obs[\"band\"] not in bands:\n", - " continue\n", - "\n", - " if \"bkg_noise\" in exposure_data_obs.keys():\n", - " std_gaussian_noise = exposure_data_obs[\"bkg_noise\"]\n", - " else:\n", - " std_gaussian_noise = None\n", - "\n", - " lens_images = lens_image(\n", - " lens_class,\n", - " band=exposure_data_obs[\"band\"],\n", - " mag_zero_point=exposure_data_obs[\"zero_point\"],\n", - " num_pix=num_pix,\n", - " psf_kernel=exposure_data_obs[\"psf_kernel\"],\n", - " transform_pix2angle=transform_pix2angle,\n", - " exposure_time=exposure_data_obs[\"expo_time\"],\n", - " t_obs=exposure_data_obs[\"obs_time\"],\n", - " std_gaussian_noise=std_gaussian_noise,\n", - " )\n", - "\n", - " final_image.append(lens_images)\n", - "\n", - " lens_col = Column(name=\"lens\", data=final_image)\n", - " final_image_col = Column(name=\"injected_lens\", data=final_image)\n", - "\n", - " # Create a new Table with only the bands of interest\n", - " mask = np.isin(exposure_data[\"band\"], bands)\n", - " exposure_data_new = exposure_data[mask]\n", - " exposure_data_new.add_columns([lens_col, final_image_col])\n", - " return exposure_data_new" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ce7e0143", - "metadata": {}, - "outputs": [], - "source": [ - "N = 100\n", - "\n", - "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", - "ra_points = ra_points.wrap_at(180 * u.degree)\n", - "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", - "dec_points = coord.Angle(dec_points * u.degree)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8bf9fa6b", - "metadata": {}, - "outputs": [], - "source": [ - "exposure_data = opsim_time_series_images_data2(\n", - " ra_points, dec_points, \"baseline_v3.0_10yrs\", MJD_min=60000, MJD_max=60300\n", - ")\n", - "exposure_data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cdbc63a1", - "metadata": { - "scrolled": false - }, - "outputs": [], - "source": [ - "from slsim.image_simulation import (\n", - " sharp_image,\n", - " lens_image,\n", - " lens_image_series,\n", - ")\n", - "from astropy.table import Column\n", - "\n", - "index = 1\n", - "bands = [\"g\", \"r\", \"i\", \"z\"]\n", - "num_pix = 200\n", - "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", - "\n", - "images = opsim_variable_lens_injection(\n", - " lens_class, bands, num_pix, transform_pix2angle, exposure_data[index]\n", - ")\n", - "images" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cfc320b6", - "metadata": {}, - "outputs": [], - "source": [ - "print(\"band: \", images[\"band\"][10])\n", - "plt.imshow(images[\"injected_lens\"][10])\n", - "plt.xlim(75, 125)\n", - "plt.ylim(75, 125)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "df583ea6", - "metadata": {}, - "outputs": [], - "source": [ - "np.array(exposure_data[0][\"band\"]) in np.array(bands)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "547d9c77", - "metadata": {}, - "outputs": [], - "source": [ - "len(exposure_data[0])" - ] - }, - { - "cell_type": "markdown", - "id": "6a20f7e9", - "metadata": {}, - "source": [ - "### Notes\n", - "\n", - "Can I make a separate function to calculate the zero point?\n", - "\n", - "calexp_center just contains the object coordinates so is currently a lot of duplicates for each epoch. Maybe there's a more efficient way to save it (or maybe it doesn't matter). \n", - "\n", - "'injected_lens' now contains the same as 'lens', because there is no background image" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9544527b", - "metadata": {}, - "outputs": [], - "source": [ - "# Next steps: test it out for lensed SN (see the other notebook, try to recreate that with the opsim class)\n", - "# do the images make sense with the input?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "895352f9", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:opsimsummary_test]", - "language": "python", - "name": "conda-env-opsimsummary_test-py" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From ad3dff3437e80f5eed3827ab0f9c47652502bc17 Mon Sep 17 00:00:00 2001 From: Nikki Date: Fri, 9 Aug 2024 15:10:11 +0200 Subject: [PATCH 28/50] simplified code using OpSimSummaryV2 to calculate ZPT and added optional input for opsim_path --- ...rnovae_plus_extended_source_tutorial.ipynb | 91 ++++++++++--------- slsim/lsst_science_pipeline.py | 41 +++------ 2 files changed, 59 insertions(+), 73 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index 8a65054ad..1de07d348 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -78,11 +78,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Duration: 2.12 minutes\n" + "Duration: 2.03 minutes\n" ] } ], "source": [ + "np.random.seed(2)\n", + "\n", "# define a cosmology\n", "H0 = 67.4\n", "cosmo = FlatLambdaCDM(H0=H0, Om0=0.3)\n", @@ -150,7 +152,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Found 2646425 potential deflector galaxies and 10650 potential source galaxies.\n" + "Found 2639375 potential deflector galaxies and 9450 potential source galaxies.\n" ] } ], @@ -181,7 +183,7 @@ "output_type": "stream", "text": [ "0.01 minutes needed to generate strong lenses.\n", - "Number of strong lens systems: 11\n" + "Number of strong lens systems: 9\n" ] } ], @@ -223,8 +225,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "z_l = [0.09 0.49 0.19 0.46 0.2 0.52 0.4 0.14 0.47 0.39 0.51]\n", - "z_s = [1.14 1.4 1.36 1.19 0.83 1.1 0.51 0.98 1.31 1.35 1.45]\n" + "z_l = [0.14 0.37 0.42 0.33 0.55 0.21 0.47 0.52 0.4 ]\n", + "z_s = [1.45 0.73 1.4 0.75 0.83 0.83 1.28 0.85 1.45]\n" ] } ], @@ -281,7 +283,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -313,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -322,19 +324,19 @@ "text": [ "Chosen lens system properties:\n", " \n", - "z_lens = 0.456518871635215\n", - "z_source = 1.1928964311905985\n", - "theta_E = 0.5454736493768455\n", + "z_lens = 0.1362527877455851\n", + "z_source = 1.450319287113787\n", + "theta_E = 1.004557010696935\n", "Number of images = 2\n", - "Time delays = [-36.97353321 9.05872107]\n", - "Lens galaxy magnitude: 24.978525100468065\n", - "Host galaxy magnitude: 24.27685981162744\n", - "Supernova magnitude: 24.877955939141234\n" + "Time delays = [-20.46035531 3.46873864]\n", + "Lens galaxy magnitude: 21.233625435203756\n", + "Host galaxy magnitude: 26.133149007905207\n", + "Supernova magnitude: 25.68767802007754\n" ] } ], "source": [ - "index = 3\n", + "index = 0\n", "# kwargs_lens_cut = {\"min_image_separation\": 1, \"max_image_separation\": 10}\n", "rgb_band_list = [\"i\", \"r\", \"g\"]\n", "lens_class = supernovae_lens_population[index]\n", @@ -353,7 +355,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -369,17 +371,17 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[13.13094119, 20.27229935],\n", - " [15.38111176, 15.35063885]])" + "array([[20.33064151, 9.71880242],\n", + " [14.59358497, 16.29312347]])" ] }, - "execution_count": 20, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -397,7 +399,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -413,13 +415,13 @@ "(-50.0, 100.0)" ] }, - "execution_count": 21, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -450,7 +452,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -459,13 +461,13 @@ "Text(0.5, 1.0, 'High-resolution RGB image')" ] }, - "execution_count": 22, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -511,6 +513,7 @@ "metadata": {}, "outputs": [], "source": [ + "np.random.seed(1)\n", "N = 10\n", "\n", "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", @@ -531,11 +534,10 @@ "output_type": "stream", "text": [ "Reading from database sqlite:///../data/OpSim_database/baseline_v3.0_10yrs.db\n", - "Read N = 2086079 observations in 43.19 seconds.\n", + "Read N = 2086079 observations in 41.74 seconds.\n", "No host file.\n", - "Coordinate (172.90991640808832 deg, 49.631056110355445 deg) is not in the LSST footprint. This entry is skipped.\n", - "Coordinate (-109.93420854090337 deg, 60.24663542585676 deg) is not in the LSST footprint. This entry is skipped.\n", - "Coordinate (73.54234401592636 deg, 62.41016024697848 deg) is not in the LSST footprint. This entry is skipped.\n" + "Coordinate (-100.68318236082308 deg, 21.742694141247878 deg) is not in the LSST footprint. This entry is skipped.\n", + "Coordinate (108.83972614746231 deg, 49.133387519115274 deg) is not in the LSST footprint. This entry is skipped.\n" ] } ], @@ -545,7 +547,7 @@ " dec_points,\n", " \"baseline_v3.0_10yrs\",\n", " MJD_min=60000,\n", - " MJD_max=60300,\n", + " MJD_max=60500,\n", " print_warning=True,\n", ")" ] @@ -561,7 +563,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 14, "metadata": { "scrolled": false }, @@ -572,7 +574,7 @@ "text": [ "images.keys() : ['bkg_noise', 'psf_kernel', 'obs_time', 'expo_time', 'zero_point', 'calexp_center', 'band', 'lens', 'injected_lens']\n", " \n", - "29 observations\n" + "64 observations\n" ] }, { @@ -581,13 +583,13 @@ "Text(0.5, 1.0, 'Injected lens system')" ] }, - "execution_count": 27, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -628,7 +630,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 15, "metadata": { "scrolled": false }, @@ -657,14 +659,14 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/6x/j1tbqdk91439t5vn1y800sb40000gn/T/ipykernel_10201/1074870882.py:4: RuntimeWarning: divide by zero encountered in log10\n", + "/var/folders/6x/j1tbqdk91439t5vn1y800sb40000gn/T/ipykernel_22674/2729757473.py:4: RuntimeWarning: divide by zero encountered in log10\n", " log_images.append(np.log10(images_opsim[i]))\n" ] }, @@ -674,13 +676,13 @@ "Text(0.5, 1.0, 'log-scale image')" ] }, - "execution_count": 29, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -704,14 +706,14 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 17, "metadata": { "scrolled": false }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -737,8 +739,6 @@ "source": [ "### Notes\n", "\n", - "- Can I make a separate function to calculate the zero point? It's a bit messy now within opsim_time_series_images_data.\n", - "\n", "- calexp_center just contains the object coordinates so is currently a lot of duplicates for each epoch. Maybe there's a more efficient way to save it (or maybe it doesn't matter). \n", "\n", "- 'injected_lens' now contains the same as 'lens', because there is no background image." @@ -759,10 +759,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ + "# To do:\n", "# Brightness cut for SNe (23rd mag)\n", "# Run the code without errors and for all bands (also z and y once added to ps_mag).\n", "# Plot both light curves (with time delay) with LSST observations (new plot function?)" diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index 2cb8090ec..df976253d 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -776,6 +776,7 @@ def opsim_time_series_images_data( readout_noise=10, delta_pix=0.2, print_warning=True, + opsim_path=None ): """Creates time series data from opsim database. @@ -793,6 +794,8 @@ def opsim_time_series_images_data( :param delta_pix: size of pixel in units arcseonds :param print_warning: if True, prints a warning of coordinates outside of the LSST footprint + :param opsim_path: optional: provide a path to the opsim database. + if None: use "../data/OpSim_database/" + obs_strategy + ".db" as default path. :return: a list of astropy tables containing observation information for each coordinate """ @@ -806,8 +809,9 @@ def opsim_time_series_images_data( ) # Initialise OpSimSummaryV2 with opsim database - try: + if opsim_path is None: opsim_path = "../data/OpSim_database/" + obs_strategy + ".db" + try: OpSimSurv = op.OpSimSurvey(opsim_path) except FileNotFoundError: raise FileNotFoundError( @@ -817,7 +821,9 @@ def opsim_time_series_images_data( ) # Collect observations that cover the coordinates in ra_list and dec_list - gen = OpSimSurv.get_obs_from_coords(ra_list, dec_list, is_deg=True) + gen = OpSimSurv.get_obs_from_coords(ra_list, dec_list, is_deg=True, formatobs=True, + keep_keys=['visitExposureTime', 'seeingFwhmGeom', + 'fieldRA', 'fieldDec']) table_data_list = [] @@ -826,7 +832,7 @@ def opsim_time_series_images_data( # Collect the next observation sequence from the opsim generator seq = next(gen) - seq = seq.sort_values(by=["observationStartMJD"]) + seq = seq.sort_values(by=["expMJD"]) # Check if the coordinates are in the opsim LSST footprint opsim_ra = np.mean(seq["fieldRA"]) @@ -840,17 +846,17 @@ def opsim_time_series_images_data( continue # Get the relevant properties from opsim - obs_time = np.array(seq["observationStartMJD"]) + obs_time = np.array(seq["expMJD"]) # Only give the observations between MJD_min and MJD_max mask = (obs_time > MJD_min) & (obs_time < MJD_max) obs_time = obs_time[mask] expo_time = np.array(seq["visitExposureTime"])[mask] - sky_brightness = np.array(seq["skyBrightness"])[mask] - bandpass = np.array(seq["filter"])[mask] + bandpass = np.array(seq["BAND"])[mask] + zero_point_mag = np.array(seq["ZPT"])[mask] + sky_brightness = np.array(seq['SKYSIG'])[mask] ** 2 / (delta_pix ** 2 * expo_time) psf_fwhm = np.array(seq["seeingFwhmGeom"])[mask] - m5_depth = np.array(seq["fiveSigmaDepth"])[mask] # Question: use 'FWHMeff' or 'seeingFwhmGeom' for the psf? radec_list = [(ra_list[i], dec_list[i])] * len(obs_time) @@ -874,27 +880,6 @@ def opsim_time_series_images_data( readout_noise, expo_time, sky_brightness, delta_pix, num_exposures=1 ) - # Calculate the zero point magnitude - # Code from OpSimSummary/opsimsummary/simlib.py/add_simlibCols - # need to work in nvariance in photon electrons - term1 = ( - 2.0 * m5_depth - sky_brightness - ) # * pixArea whata units is sky birghtness? counts or photo electrons? - # per pixel or arcsec? - term2 = -(m5_depth - sky_brightness) # * pixArea - area = (1.51 * psf_fwhm) ** 2.0 # area = 1 / int(psf^2) - opsim_snr = 5.0 - arg = area * opsim_snr * opsim_snr - # Background dominated limit assuming counts with system transmission only - # is approximately equal to counts with total transmission - zpt_approx = term1 + 2.5 * np.log10(arg) - val = -0.4 * term2 - tmp = 10.0**val - # Additional term to account for photons from the source, again assuming - # that counts with system transmission approximately equal counts with total transmission. - zpt_cor = 2.5 * np.log10(1.0 + 1.0 / (area * tmp)) - zero_point_mag = zpt_approx + zpt_cor - table_data = Table( [ bkg_noise, From 9ddc2f02a6fdebe9d65b16f820ed8e73ec89a26d Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 9 Aug 2024 13:13:37 +0000 Subject: [PATCH 29/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- slsim/lsst_science_pipeline.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/slsim/lsst_science_pipeline.py b/slsim/lsst_science_pipeline.py index df976253d..c05818eee 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/lsst_science_pipeline.py @@ -776,7 +776,7 @@ def opsim_time_series_images_data( readout_noise=10, delta_pix=0.2, print_warning=True, - opsim_path=None + opsim_path=None, ): """Creates time series data from opsim database. @@ -821,9 +821,13 @@ def opsim_time_series_images_data( ) # Collect observations that cover the coordinates in ra_list and dec_list - gen = OpSimSurv.get_obs_from_coords(ra_list, dec_list, is_deg=True, formatobs=True, - keep_keys=['visitExposureTime', 'seeingFwhmGeom', - 'fieldRA', 'fieldDec']) + gen = OpSimSurv.get_obs_from_coords( + ra_list, + dec_list, + is_deg=True, + formatobs=True, + keep_keys=["visitExposureTime", "seeingFwhmGeom", "fieldRA", "fieldDec"], + ) table_data_list = [] @@ -855,7 +859,7 @@ def opsim_time_series_images_data( expo_time = np.array(seq["visitExposureTime"])[mask] bandpass = np.array(seq["BAND"])[mask] zero_point_mag = np.array(seq["ZPT"])[mask] - sky_brightness = np.array(seq['SKYSIG'])[mask] ** 2 / (delta_pix ** 2 * expo_time) + sky_brightness = np.array(seq["SKYSIG"])[mask] ** 2 / (delta_pix**2 * expo_time) psf_fwhm = np.array(seq["seeingFwhmGeom"])[mask] # Question: use 'FWHMeff' or 'seeingFwhmGeom' for the psf? From 47372da2b0eb496143470f1dab0ab18bcc369166 Mon Sep 17 00:00:00 2001 From: Nikki Date: Fri, 30 Aug 2024 17:24:00 +0200 Subject: [PATCH 30/50] changed file structure --- .../lsst_science_pipeline.py | 211 ----------------- slsim/LsstSciencePipeline/opsim_pipeline.py | 215 ++++++++++++++++++ 2 files changed, 215 insertions(+), 211 deletions(-) rename slsim/{ => LsstSciencePipeline}/lsst_science_pipeline.py (85%) create mode 100644 slsim/LsstSciencePipeline/opsim_pipeline.py diff --git a/slsim/lsst_science_pipeline.py b/slsim/LsstSciencePipeline/lsst_science_pipeline.py similarity index 85% rename from slsim/lsst_science_pipeline.py rename to slsim/LsstSciencePipeline/lsst_science_pipeline.py index c05818eee..c968f3b99 100644 --- a/slsim/lsst_science_pipeline.py +++ b/slsim/LsstSciencePipeline/lsst_science_pipeline.py @@ -11,9 +11,6 @@ from scipy.stats import norm, halfnorm import matplotlib.pyplot as plt from slsim.image_simulation import point_source_coordinate_properties -import lenstronomy.Util.util as util -import lenstronomy.Util.kernel_util as kernel_util -import lenstronomy.Util.data_util as data_util from slsim.Util.param_util import random_ra_dec, fits_append_table import h5py import os @@ -765,214 +762,6 @@ def dp0_time_series_images_data(butler, center_coord, radius="0.1", band="i", si return table_data -def opsim_time_series_images_data( - ra_list, - dec_list, - obs_strategy, - MJD_min=60000, - MJD_max=64000, - size=101, - moffat_beta=3.1, - readout_noise=10, - delta_pix=0.2, - print_warning=True, - opsim_path=None, -): - """Creates time series data from opsim database. - - :param ra_list: a list of ra points (in degrees) from objects we want to collect - observations for - :param dec_list: a list of dec points (in degrees) from objects we want to collect - observations for - :param obs_strategy: version of observing strategy corresponding to opsim database. - for example "baseline_v3.0_10yrs" (string) - :param MJD_min: minimum MJD for the observations - :param MJD_max: maximum MJD for the observations - :param size: cutout size of images (in pixels) - :param moffat_beta: power index of the moffat psf kernel - :param readout_noise: noise added per readout - :param delta_pix: size of pixel in units arcseonds - :param print_warning: if True, prints a warning of coordinates outside of the LSST - footprint - :param opsim_path: optional: provide a path to the opsim database. - if None: use "../data/OpSim_database/" + obs_strategy + ".db" as default path. - :return: a list of astropy tables containing observation information for each - coordinate - """ - - # Import OpSimSummaryV2 - try: - import opsimsummaryv2 as op - except ImportError: - raise ImportError( - "Users need to have OpSimSummaryV2 installed (https://github.com/bastiencarreres/OpSimSummaryV2)" - ) - - # Initialise OpSimSummaryV2 with opsim database - if opsim_path is None: - opsim_path = "../data/OpSim_database/" + obs_strategy + ".db" - try: - OpSimSurv = op.OpSimSurvey(opsim_path) - except FileNotFoundError: - raise FileNotFoundError( - "File not found: " - + opsim_path - + ". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database" - ) - - # Collect observations that cover the coordinates in ra_list and dec_list - gen = OpSimSurv.get_obs_from_coords( - ra_list, - dec_list, - is_deg=True, - formatobs=True, - keep_keys=["visitExposureTime", "seeingFwhmGeom", "fieldRA", "fieldDec"], - ) - - table_data_list = [] - - # Loop through all coordinates and compute the table_data - for i in range(len(ra_list)): - - # Collect the next observation sequence from the opsim generator - seq = next(gen) - seq = seq.sort_values(by=["expMJD"]) - - # Check if the coordinates are in the opsim LSST footprint - opsim_ra = np.mean(seq["fieldRA"]) - opsim_dec = np.mean(seq["fieldDec"]) - - if np.isnan(opsim_ra) or np.isnan(opsim_dec): - if print_warning: - print( - f"Coordinate ({ra_list[i]}, {dec_list[i]}) is not in the LSST footprint. This entry is skipped." - ) - continue - - # Get the relevant properties from opsim - obs_time = np.array(seq["expMJD"]) - - # Only give the observations between MJD_min and MJD_max - mask = (obs_time > MJD_min) & (obs_time < MJD_max) - obs_time = obs_time[mask] - - expo_time = np.array(seq["visitExposureTime"])[mask] - bandpass = np.array(seq["BAND"])[mask] - zero_point_mag = np.array(seq["ZPT"])[mask] - sky_brightness = np.array(seq["SKYSIG"])[mask] ** 2 / (delta_pix**2 * expo_time) - psf_fwhm = np.array(seq["seeingFwhmGeom"])[mask] - # Question: use 'FWHMeff' or 'seeingFwhmGeom' for the psf? - - radec_list = [(ra_list[i], dec_list[i])] * len(obs_time) - - # Create a Moffat psf kernel for each epoch - - psf_kernels = [] - - for psf in psf_fwhm: - psf_kernel = kernel_util.kernel_moffat( - num_pix=size, delta_pix=delta_pix, fwhm=psf, moffat_beta=moffat_beta - ) - psf_kernel = util.array2image(psf_kernel) - - psf_kernels.append(psf_kernel) - - psf_kernels = np.array(psf_kernels) - - # Calculate background noise - bkg_noise = data_util.bkg_noise( - readout_noise, expo_time, sky_brightness, delta_pix, num_exposures=1 - ) - - table_data = Table( - [ - bkg_noise, - psf_kernels, - obs_time, - expo_time, - zero_point_mag, - radec_list, - bandpass, - ], - names=( - "bkg_noise", - "psf_kernel", - "obs_time", - "expo_time", - "zero_point", - "calexp_center", - "band", - ), - ) - - table_data_list.append(table_data) - return table_data_list - - -def opsim_variable_lens_injection( - lens_class, bands, num_pix, transform_pix2angle, exposure_data -): - """Injects variable lens to the OpSim time series data (1 object). - - :param lens_class: Lens() object - :param bands: list of imaging bands of interest - :param num_pix: number of pixels per axis - :param transform_pix2angle: transformation matrix (2x2) of pixels into coordinate - displacements - :param exposure_data: An astropy table of exposure data. One entry of - table_list_data generated from the opsim_time_series_images_data function. It - must contain the rms of background noise fluctuations (column name should be - "bkg_noise"), psf kernel for each exposure (column name should be "psf_kernel", - these are pixel psf kernel for each single exposure images in time series - image), observation time (column name should be "obs_time", these are - observation time in days for each single exposure images in time series images), - exposure time (column name should be "expo_time", these are exposure time for - each single exposure images in time series images), magnitude zero point (column - name should be "zero_point", these are zero point magnitudes for each single - exposure images in time series image), coordinates of the object (column name - should be "calexp_center"), these are the coordinates in (ra, dec), and the band - in which the observation is taken (column name should be "band"). - :return: Astropy table of injected lenses and exposure information of dp0 data - """ - - final_image = [] - - for obs in range(len(exposure_data["obs_time"])): - - exposure_data_obs = exposure_data[obs] - - if exposure_data_obs["band"] not in bands: - continue - - if "bkg_noise" in exposure_data_obs.keys(): - std_gaussian_noise = exposure_data_obs["bkg_noise"] - else: - std_gaussian_noise = None - - lens_images = lens_image( - lens_class, - band=exposure_data_obs["band"], - mag_zero_point=exposure_data_obs["zero_point"], - num_pix=num_pix, - psf_kernel=exposure_data_obs["psf_kernel"], - transform_pix2angle=transform_pix2angle, - exposure_time=exposure_data_obs["expo_time"], - t_obs=exposure_data_obs["obs_time"], - std_gaussian_noise=std_gaussian_noise, - ) - - final_image.append(lens_images) - - lens_col = Column(name="lens", data=final_image) - final_image_col = Column(name="injected_lens", data=final_image) - - # Create a new Table with only the bands of interest - mask = np.isin(exposure_data["band"], bands) - exposure_data_new = exposure_data[mask] - exposure_data_new.add_columns([lens_col, final_image_col]) - return exposure_data_new - - def multiple_dp0_time_series_images_data( butler, center_coords_list, radius="0.034", band="i", size=101, output_file=None ): diff --git a/slsim/LsstSciencePipeline/opsim_pipeline.py b/slsim/LsstSciencePipeline/opsim_pipeline.py new file mode 100644 index 000000000..b47b2383b --- /dev/null +++ b/slsim/LsstSciencePipeline/opsim_pipeline.py @@ -0,0 +1,215 @@ +import numpy as np +from astropy.table import Table +from astropy.table import Column +from slsim.image_simulation import lens_image +import lenstronomy.Util.util as util +import lenstronomy.Util.kernel_util as kernel_util +import lenstronomy.Util.data_util as data_util + + +def opsim_time_series_images_data( + ra_list, + dec_list, + obs_strategy, + MJD_min=60000, + MJD_max=64000, + size=101, + moffat_beta=3.1, + readout_noise=10, + delta_pix=0.2, + print_warning=True, + opsim_path=None, +): + """Creates time series data from opsim database. + + :param ra_list: a list of ra points (in degrees) from objects we want to collect + observations for + :param dec_list: a list of dec points (in degrees) from objects we want to collect + observations for + :param obs_strategy: version of observing strategy corresponding to opsim database. + for example "baseline_v3.0_10yrs" (string) + :param MJD_min: minimum MJD for the observations + :param MJD_max: maximum MJD for the observations + :param size: cutout size of images (in pixels) + :param moffat_beta: power index of the moffat psf kernel + :param readout_noise: noise added per readout + :param delta_pix: size of pixel in units arcseonds + :param print_warning: if True, prints a warning of coordinates outside of the LSST + footprint + :param opsim_path: optional: provide a path to the opsim database. + if None: use "../data/OpSim_database/" + obs_strategy + ".db" as default path. + :return: a list of astropy tables containing observation information for each + coordinate + """ + + # Import OpSimSummaryV2 + try: + import opsimsummaryv2 as op + except ImportError: + raise ImportError( + "Users need to have OpSimSummaryV2 installed (https://github.com/bastiencarreres/OpSimSummaryV2)" + ) + + # Initialise OpSimSummaryV2 with opsim database + if opsim_path is None: + opsim_path = "../data/OpSim_database/" + obs_strategy + ".db" + try: + OpSimSurv = op.OpSimSurvey(opsim_path) + except FileNotFoundError: + raise FileNotFoundError( + "File not found: " + + opsim_path + + ". Input variable 'obs_strategy' should correspond to the name of an opsim database saved in the folder ../data/OpSim_database" + ) + + # Collect observations that cover the coordinates in ra_list and dec_list + gen = OpSimSurv.get_obs_from_coords( + ra_list, + dec_list, + is_deg=True, + formatobs=True, + keep_keys=["visitExposureTime", "seeingFwhmGeom", "fieldRA", "fieldDec"], + ) + + table_data_list = [] + + # Loop through all coordinates and compute the table_data + for i in range(len(ra_list)): + + # Collect the next observation sequence from the opsim generator + seq = next(gen) + seq = seq.sort_values(by=["expMJD"]) + + # Check if the coordinates are in the opsim LSST footprint + opsim_ra = np.mean(seq["fieldRA"]) + opsim_dec = np.mean(seq["fieldDec"]) + + if np.isnan(opsim_ra) or np.isnan(opsim_dec): + if print_warning: + print( + f"Coordinate ({ra_list[i]}, {dec_list[i]}) is not in the LSST footprint. This entry is skipped." + ) + continue + + # Get the relevant properties from opsim + obs_time = np.array(seq["expMJD"]) + + # Only give the observations between MJD_min and MJD_max + mask = (obs_time > MJD_min) & (obs_time < MJD_max) + obs_time = obs_time[mask] + + expo_time = np.array(seq["visitExposureTime"])[mask] + bandpass = np.array(seq["BAND"])[mask] + zero_point_mag = np.array(seq["ZPT"])[mask] + sky_brightness = np.array(seq["SKYSIG"])[mask] ** 2 / (delta_pix**2 * expo_time) + psf_fwhm = np.array(seq["seeingFwhmGeom"])[mask] + # Question: use 'FWHMeff' or 'seeingFwhmGeom' for the psf? + + radec_list = [(ra_list[i], dec_list[i])] * len(obs_time) + + # Create a Moffat psf kernel for each epoch + + psf_kernels = [] + + for psf in psf_fwhm: + psf_kernel = kernel_util.kernel_moffat( + num_pix=size, delta_pix=delta_pix, fwhm=psf, moffat_beta=moffat_beta + ) + psf_kernel = util.array2image(psf_kernel) + + psf_kernels.append(psf_kernel) + + psf_kernels = np.array(psf_kernels) + + # Calculate background noise + bkg_noise = data_util.bkg_noise( + readout_noise, expo_time, sky_brightness, delta_pix, num_exposures=1 + ) + + table_data = Table( + [ + bkg_noise, + psf_kernels, + obs_time, + expo_time, + zero_point_mag, + radec_list, + bandpass, + ], + names=( + "bkg_noise", + "psf_kernel", + "obs_time", + "expo_time", + "zero_point", + "calexp_center", + "band", + ), + ) + + table_data_list.append(table_data) + return table_data_list + + +def opsim_variable_lens_injection( + lens_class, bands, num_pix, transform_pix2angle, exposure_data +): + """Injects variable lens to the OpSim time series data (1 object). + + :param lens_class: Lens() object + :param bands: list of imaging bands of interest + :param num_pix: number of pixels per axis + :param transform_pix2angle: transformation matrix (2x2) of pixels into coordinate + displacements + :param exposure_data: An astropy table of exposure data. One entry of + table_list_data generated from the opsim_time_series_images_data function. It + must contain the rms of background noise fluctuations (column name should be + "bkg_noise"), psf kernel for each exposure (column name should be "psf_kernel", + these are pixel psf kernel for each single exposure images in time series + image), observation time (column name should be "obs_time", these are + observation time in days for each single exposure images in time series images), + exposure time (column name should be "expo_time", these are exposure time for + each single exposure images in time series images), magnitude zero point (column + name should be "zero_point", these are zero point magnitudes for each single + exposure images in time series image), coordinates of the object (column name + should be "calexp_center"), these are the coordinates in (ra, dec), and the band + in which the observation is taken (column name should be "band"). + :return: Astropy table of injected lenses and exposure information of dp0 data + """ + + final_image = [] + + for obs in range(len(exposure_data["obs_time"])): + + exposure_data_obs = exposure_data[obs] + + if exposure_data_obs["band"] not in bands: + continue + + if "bkg_noise" in exposure_data_obs.keys(): + std_gaussian_noise = exposure_data_obs["bkg_noise"] + else: + std_gaussian_noise = None + + lens_images = lens_image( + lens_class, + band=exposure_data_obs["band"], + mag_zero_point=exposure_data_obs["zero_point"], + num_pix=num_pix, + psf_kernel=exposure_data_obs["psf_kernel"], + transform_pix2angle=transform_pix2angle, + exposure_time=exposure_data_obs["expo_time"], + t_obs=exposure_data_obs["obs_time"], + std_gaussian_noise=std_gaussian_noise, + ) + + final_image.append(lens_images) + + lens_col = Column(name="lens", data=final_image) + final_image_col = Column(name="injected_lens", data=final_image) + + # Create a new Table with only the bands of interest + mask = np.isin(exposure_data["band"], bands) + exposure_data_new = exposure_data[mask] + exposure_data_new.add_columns([lens_col, final_image_col]) + return exposure_data_new \ No newline at end of file From f5aabc84b82acb32b0f6f78e1a4ff115d21e5ebe Mon Sep 17 00:00:00 2001 From: Nikki Date: Fri, 30 Aug 2024 17:24:54 +0200 Subject: [PATCH 31/50] expanded test function for create_image_montage_from_image_list --- .../test_lsst_science_pipeline.py | 0 .../test_opsim_pipeline.py | 81 +++++++++++++++++++ tests/test_Plots/test_plot_functions.py | 19 +++++ 3 files changed, 100 insertions(+) rename tests/{ => test_LsstSciencePipeline}/test_lsst_science_pipeline.py (100%) create mode 100644 tests/test_LsstSciencePipeline/test_opsim_pipeline.py diff --git a/tests/test_lsst_science_pipeline.py b/tests/test_LsstSciencePipeline/test_lsst_science_pipeline.py similarity index 100% rename from tests/test_lsst_science_pipeline.py rename to tests/test_LsstSciencePipeline/test_lsst_science_pipeline.py diff --git a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py new file mode 100644 index 000000000..94332160f --- /dev/null +++ b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py @@ -0,0 +1,81 @@ +import os +import numpy as np +from astropy.table import Table +from astropy.cosmology import FlatLambdaCDM +from slsim.lens import Lens +from slsim.lsst_science_pipeline import ( + variable_lens_injection, + multiple_variable_lens_injection, +) +import pytest + + +@pytest.fixture +def pes_lens_instance(): + path = os.path.dirname(__file__) + source_dict = Table.read( + os.path.join(path, "TestData/source_dict_ps.fits"), format="fits" + ) + deflector_dict = Table.read( + os.path.join(path, "TestData/deflector_dict_ps.fits"), format="fits" + ) + + cosmo = FlatLambdaCDM(H0=70, Om0=0.3) + while True: + pes_lens = Lens( + source_dict=source_dict, + deflector_dict=deflector_dict, + source_type="point_plus_extended", + variability_model="sinusoidal", + kwargs_variability={"amp", "freq"}, + cosmo=cosmo, + lightcurve_time=np.linspace(0, np.pi, 100), + ) + if pes_lens.validity_test(): + pes_lens = pes_lens + break + return pes_lens + + +def test_variable_lens_injection(pes_lens_instance): + lens_class = pes_lens_instance + path = os.path.dirname(__file__) + expo_data = Table.read( + os.path.join(path, "TestData/expo_data_1.fits"), format="fits" + ) + transf_matrix_single = np.array([[0.2, 0], [0, 0.2]]) + transform_matrices = [transf_matrix_single.copy() for _ in range(len(expo_data))] + results = variable_lens_injection( + lens_class, + band="i", + num_pix=301, + transform_pix2angle=transform_matrices, + exposure_data=expo_data, + ) + assert len(results) == len(expo_data) + + +def test_multiple_variable_lens_injection(pes_lens_instance): + lens_class = [pes_lens_instance, pes_lens_instance] + path = os.path.dirname(__file__) + expo_data_1 = Table.read( + os.path.join(path, "TestData/expo_data_1.fits"), format="fits" + ) + expo_data_2 = Table.read( + os.path.join(path, "TestData/expo_data_2.fits"), format="fits" + ) + expo_data = [expo_data_1, expo_data_2] + transf_matrix_single = np.array([[0.2, 0], [0, 0.2]]) + transform_matrices = [] + for data in expo_data: + transform_matrices.append( + [transf_matrix_single.copy() for _ in range(len(data))] + ) + results = multiple_variable_lens_injection( + lens_class, + band="i", + num_pix=301, + transform_matrices_list=transform_matrices, + exposure_data_list=expo_data, + ) + assert len(results) == len(expo_data) diff --git a/tests/test_Plots/test_plot_functions.py b/tests/test_Plots/test_plot_functions.py index b3e29e2ae..8baaedc68 100644 --- a/tests/test_Plots/test_plot_functions.py +++ b/tests/test_Plots/test_plot_functions.py @@ -71,6 +71,12 @@ def test_create_image_montage_from_image_list(quasar_lens_pop_instance): ) num_rows = 2 num_cols = 3 + + # Create different types of input for "band" to test the response of the function + band1 = "i" + band2 = ["i"] * len(image_list) + band3 = None + t = np.linspace(0, 10, 6) fig = create_image_montage_from_image_list( num_rows=num_rows, num_cols=num_cols, images=image_list, time=t @@ -82,10 +88,23 @@ def test_create_image_montage_from_image_list(quasar_lens_pop_instance): time=t, image_type="dp0", ) + fig3 = create_image_montage_from_image_list( + num_rows=num_rows, num_cols=num_cols, images=image_list, time=t, band=band1) + fig4 = create_image_montage_from_image_list( + num_rows=num_rows, num_cols=num_cols, images=image_list, time=t, band=band2) + fig5 = create_image_montage_from_image_list( + num_rows=num_rows, num_cols=num_cols, images=image_list, time=t, band=band3) + assert isinstance(fig, plt.Figure) assert fig.get_size_inches()[0] == np.array([num_cols * 3, num_rows * 3])[0] assert isinstance(fig2, plt.Figure) assert fig2.get_size_inches()[0] == np.array([num_cols * 3, num_rows * 3])[0] + assert isinstance(fig3, plt.Figure) + assert fig3.get_size_inches()[0] == np.array([num_cols * 3, num_rows * 3])[0] + assert isinstance(fig4, plt.Figure) + assert fig4.get_size_inches()[0] == np.array([num_cols * 3, num_rows * 3])[0] + assert isinstance(fig5, plt.Figure) + assert fig5.get_size_inches()[0] == np.array([num_cols * 3, num_rows * 3])[0] def test_plot_montage_of_random_injected_lens(quasar_lens_pop_instance): From b43ca7b4fe51e3b7db0dc45edbf8c91df854e2dd Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 30 Aug 2024 15:26:39 +0000 Subject: [PATCH 32/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- slsim/LsstSciencePipeline/opsim_pipeline.py | 2 +- tests/test_Plots/test_plot_functions.py | 9 ++++++--- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/slsim/LsstSciencePipeline/opsim_pipeline.py b/slsim/LsstSciencePipeline/opsim_pipeline.py index b47b2383b..35500cc3f 100644 --- a/slsim/LsstSciencePipeline/opsim_pipeline.py +++ b/slsim/LsstSciencePipeline/opsim_pipeline.py @@ -212,4 +212,4 @@ def opsim_variable_lens_injection( mask = np.isin(exposure_data["band"], bands) exposure_data_new = exposure_data[mask] exposure_data_new.add_columns([lens_col, final_image_col]) - return exposure_data_new \ No newline at end of file + return exposure_data_new diff --git a/tests/test_Plots/test_plot_functions.py b/tests/test_Plots/test_plot_functions.py index 8baaedc68..8faff48bb 100644 --- a/tests/test_Plots/test_plot_functions.py +++ b/tests/test_Plots/test_plot_functions.py @@ -89,11 +89,14 @@ def test_create_image_montage_from_image_list(quasar_lens_pop_instance): image_type="dp0", ) fig3 = create_image_montage_from_image_list( - num_rows=num_rows, num_cols=num_cols, images=image_list, time=t, band=band1) + num_rows=num_rows, num_cols=num_cols, images=image_list, time=t, band=band1 + ) fig4 = create_image_montage_from_image_list( - num_rows=num_rows, num_cols=num_cols, images=image_list, time=t, band=band2) + num_rows=num_rows, num_cols=num_cols, images=image_list, time=t, band=band2 + ) fig5 = create_image_montage_from_image_list( - num_rows=num_rows, num_cols=num_cols, images=image_list, time=t, band=band3) + num_rows=num_rows, num_cols=num_cols, images=image_list, time=t, band=band3 + ) assert isinstance(fig, plt.Figure) assert fig.get_size_inches()[0] == np.array([num_cols * 3, num_rows * 3])[0] From 78e5be667fbc8294bcd6071624fd0f7205ea0b7b Mon Sep 17 00:00:00 2001 From: Nikki Date: Fri, 30 Aug 2024 17:43:53 +0200 Subject: [PATCH 33/50] fixed imports --- tests/test_LsstSciencePipeline/test_lsst_science_pipeline.py | 2 +- tests/test_LsstSciencePipeline/test_opsim_pipeline.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_LsstSciencePipeline/test_lsst_science_pipeline.py b/tests/test_LsstSciencePipeline/test_lsst_science_pipeline.py index 94332160f..b06535e65 100644 --- a/tests/test_LsstSciencePipeline/test_lsst_science_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_lsst_science_pipeline.py @@ -3,7 +3,7 @@ from astropy.table import Table from astropy.cosmology import FlatLambdaCDM from slsim.lens import Lens -from slsim.lsst_science_pipeline import ( +from slsim.LsstSciencePipeline.lsst_science_pipeline import ( variable_lens_injection, multiple_variable_lens_injection, ) diff --git a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py index 94332160f..b06535e65 100644 --- a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py @@ -3,7 +3,7 @@ from astropy.table import Table from astropy.cosmology import FlatLambdaCDM from slsim.lens import Lens -from slsim.lsst_science_pipeline import ( +from slsim.LsstSciencePipeline.lsst_science_pipeline import ( variable_lens_injection, multiple_variable_lens_injection, ) From 2c1f7b8a87613a40e4ecdbac2f7e774c0b588ad0 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 10 Sep 2024 13:33:31 +0200 Subject: [PATCH 34/50] fixed paths to TestData --- .../test_lsst_science_pipeline.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/test_LsstSciencePipeline/test_lsst_science_pipeline.py b/tests/test_LsstSciencePipeline/test_lsst_science_pipeline.py index b06535e65..6132081db 100644 --- a/tests/test_LsstSciencePipeline/test_lsst_science_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_lsst_science_pipeline.py @@ -14,10 +14,10 @@ def pes_lens_instance(): path = os.path.dirname(__file__) source_dict = Table.read( - os.path.join(path, "TestData/source_dict_ps.fits"), format="fits" + os.path.join(path, "../TestData/source_dict_ps.fits"), format="fits" ) deflector_dict = Table.read( - os.path.join(path, "TestData/deflector_dict_ps.fits"), format="fits" + os.path.join(path, "../TestData/deflector_dict_ps.fits"), format="fits" ) cosmo = FlatLambdaCDM(H0=70, Om0=0.3) @@ -41,7 +41,7 @@ def test_variable_lens_injection(pes_lens_instance): lens_class = pes_lens_instance path = os.path.dirname(__file__) expo_data = Table.read( - os.path.join(path, "TestData/expo_data_1.fits"), format="fits" + os.path.join(path, "../TestData/expo_data_1.fits"), format="fits" ) transf_matrix_single = np.array([[0.2, 0], [0, 0.2]]) transform_matrices = [transf_matrix_single.copy() for _ in range(len(expo_data))] @@ -59,10 +59,10 @@ def test_multiple_variable_lens_injection(pes_lens_instance): lens_class = [pes_lens_instance, pes_lens_instance] path = os.path.dirname(__file__) expo_data_1 = Table.read( - os.path.join(path, "TestData/expo_data_1.fits"), format="fits" + os.path.join(path, "../TestData/expo_data_1.fits"), format="fits" ) expo_data_2 = Table.read( - os.path.join(path, "TestData/expo_data_2.fits"), format="fits" + os.path.join(path, "../TestData/expo_data_2.fits"), format="fits" ) expo_data = [expo_data_1, expo_data_2] transf_matrix_single = np.array([[0.2, 0], [0, 0.2]]) From e681c542e1a7fe2a0735aaf367bb9dbe6df52ec0 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 24 Sep 2024 12:03:59 +0200 Subject: [PATCH 35/50] changed notebook to match new version of slsim --- ...rnovae_plus_extended_source_tutorial.ipynb | 121 +++++++++++++++++- 1 file changed, 114 insertions(+), 7 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index 1de07d348..695b0e478 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -10,15 +10,20 @@ "from astropy.units import Quantity\n", "from slsim.lens_pop import LensPop\n", "import numpy as np\n", - "from slsim.image_simulation import lens_image_series, sharp_rgb_image\n", - "from slsim.Plots.plot_functions import create_image_montage_from_image_list\n", - "from slsim.image_simulation import point_source_coordinate_properties\n", - "from slsim import lsst_science_pipeline\n", "import matplotlib.pyplot as plt\n", "import corner\n", "import astropy.coordinates as coord\n", "import astropy.units as u\n", - "import time" + "import time\n", + "\n", + "import slsim.Sources as sources\n", + "import slsim.Pipelines as pipelines\n", + "import slsim.Deflectors as deflectors\n", + "\n", + "from slsim.image_simulation import lens_image_series, sharp_rgb_image\n", + "from slsim.Plots.plot_functions import create_image_montage_from_image_list\n", + "from slsim.image_simulation import point_source_coordinate_properties\n", + "from slsim.LsstSciencePipeline import lsst_science_pipeline, opsim_pipeline\n" ] }, { @@ -48,6 +53,108 @@ "## Simulate lens and source galaxy populations" ] }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 18\u001b[0m\n\u001b[1;32m 15\u001b[0m kwargs_deflector_cut \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mz_min\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;241m0.01\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mz_max\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;241m1.0\u001b[39m}\n\u001b[1;32m 16\u001b[0m kwargs_source_cut \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mz_min\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;241m0.01\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mz_max\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;241m1.5\u001b[39m}\n\u001b[0;32m---> 18\u001b[0m galaxy_simulation_pipeline \u001b[38;5;241m=\u001b[39m \u001b[43mpipelines\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSkyPyPipeline\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 19\u001b[0m \u001b[43m \u001b[49m\u001b[43mskypy_config\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 20\u001b[0m \u001b[43m \u001b[49m\u001b[43msky_area\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msky_area\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 21\u001b[0m \u001b[43m \u001b[49m\u001b[43mfilters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 22\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 24\u001b[0m lens_galaxies \u001b[38;5;241m=\u001b[39m deflectors\u001b[38;5;241m.\u001b[39mAllLensGalaxies(\n\u001b[1;32m 25\u001b[0m red_galaxy_list\u001b[38;5;241m=\u001b[39mgalaxy_simulation_pipeline\u001b[38;5;241m.\u001b[39mred_galaxies,\n\u001b[1;32m 26\u001b[0m blue_galaxy_list\u001b[38;5;241m=\u001b[39mgalaxy_simulation_pipeline\u001b[38;5;241m.\u001b[39mblue_galaxies,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 30\u001b[0m sky_area\u001b[38;5;241m=\u001b[39msky_area,\n\u001b[1;32m 31\u001b[0m )\n\u001b[1;32m 33\u001b[0m path \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 34\u001b[0m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mdirname(slsim\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__file__\u001b[39m)\n\u001b[1;32m 35\u001b[0m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/Sources/SupernovaeCatalog/supernovae_data.pkl\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 36\u001b[0m )\n", + "File \u001b[0;32m~/Documents/Research/Projects/slsim/slsim/Pipelines/skypy_pipeline.py:100\u001b[0m, in \u001b[0;36mSkyPyPipeline.__init__\u001b[0;34m(self, skypy_config, sky_area, filters, cosmo)\u001b[0m\n\u001b[1;32m 97\u001b[0m tmp_file\u001b[38;5;241m.\u001b[39mwrite(content)\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pipeline \u001b[38;5;241m=\u001b[39m Pipeline\u001b[38;5;241m.\u001b[39mread(tmp_file\u001b[38;5;241m.\u001b[39mname)\n\u001b[0;32m--> 100\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_pipeline\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;66;03m# Remove the temporary file after the pipeline has been executed\u001b[39;00m\n\u001b[1;32m 103\u001b[0m os\u001b[38;5;241m.\u001b[39mremove(tmp_file\u001b[38;5;241m.\u001b[39mname)\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/pipeline/_pipeline.py:185\u001b[0m, in \u001b[0;36mPipeline.execute\u001b[0;34m(self, parameters)\u001b[0m\n\u001b[1;32m 182\u001b[0m names \u001b[38;5;241m=\u001b[39m [n\u001b[38;5;241m.\u001b[39mstrip() \u001b[38;5;28;01mfor\u001b[39;00m n \u001b[38;5;129;01min\u001b[39;00m column\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m,\u001b[39m\u001b[38;5;124m'\u001b[39m)]\n\u001b[1;32m 183\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(names) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 184\u001b[0m \u001b[38;5;66;03m# Multi-column assignment\u001b[39;00m\n\u001b[0;32m--> 185\u001b[0m t \u001b[38;5;241m=\u001b[39m Table(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mevaluate\u001b[49m\u001b[43m(\u001b[49m\u001b[43msettings\u001b[49m\u001b[43m)\u001b[49m, names\u001b[38;5;241m=\u001b[39mnames)\n\u001b[1;32m 186\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate[table]\u001b[38;5;241m.\u001b[39madd_columns(t\u001b[38;5;241m.\u001b[39mcolumns)\n\u001b[1;32m 187\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 188\u001b[0m \u001b[38;5;66;03m# Single column assignment\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/pipeline/_pipeline.py:262\u001b[0m, in \u001b[0;36mPipeline.evaluate\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m 259\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {k: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mevaluate(v) \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m value\u001b[38;5;241m.\u001b[39mitems()}\n\u001b[1;32m 260\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(value, Item):\n\u001b[1;32m 261\u001b[0m \u001b[38;5;66;03m# evaluate item\u001b[39;00m\n\u001b[0;32m--> 262\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvalue\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mevaluate\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 263\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 264\u001b[0m \u001b[38;5;66;03m# everything else return unchanged\u001b[39;00m\n\u001b[1;32m 265\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m value\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/pipeline/_items.py:93\u001b[0m, in \u001b[0;36mCall.evaluate\u001b[0;34m(self, pipeline)\u001b[0m\n\u001b[1;32m 91\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m pipeline\u001b[38;5;241m.\u001b[39mevaluate(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwargs)\n\u001b[1;32m 92\u001b[0m log\u001b[38;5;241m.\u001b[39minfo(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCalling \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m---> 93\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/units/decorators.py:313\u001b[0m, in \u001b[0;36mQuantityInput.__call__..wrapper\u001b[0;34m(*func_args, **func_kwargs)\u001b[0m\n\u001b[1;32m 311\u001b[0m \u001b[38;5;66;03m# Call the original function with any equivalencies in force.\u001b[39;00m\n\u001b[1;32m 312\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m add_enabled_equivalencies(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mequivalencies):\n\u001b[0;32m--> 313\u001b[0m return_ \u001b[38;5;241m=\u001b[39m \u001b[43mwrapped_function\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mfunc_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mfunc_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 315\u001b[0m \u001b[38;5;66;03m# Return\u001b[39;00m\n\u001b[1;32m 316\u001b[0m ra \u001b[38;5;241m=\u001b[39m wrapped_signature\u001b[38;5;241m.\u001b[39mreturn_annotation\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/galaxies/_schechter.py:75\u001b[0m, in \u001b[0;36mschechter_lf\u001b[0;34m(redshift, M_star, phi_star, alpha, m_lim, sky_area, cosmology, noise)\u001b[0m\n\u001b[1;32m 72\u001b[0m alpha \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39minterp(z, redshift, alpha)\n\u001b[1;32m 74\u001b[0m \u001b[38;5;66;03m# sample galaxy magnitudes for redshifts\u001b[39;00m\n\u001b[0;32m---> 75\u001b[0m M \u001b[38;5;241m=\u001b[39m \u001b[43mschechter_lf_magnitude\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mM_star\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malpha\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mm_lim\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcosmology\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 77\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m z, M\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/utils/_decorators.py:65\u001b[0m, in \u001b[0;36mdependent_argument..decorator..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mcallable\u001b[39m(f):\n\u001b[1;32m 63\u001b[0m given\u001b[38;5;241m.\u001b[39marguments[dependent_arg] \\\n\u001b[1;32m 64\u001b[0m \u001b[38;5;241m=\u001b[39m f(\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mmap\u001b[39m(given\u001b[38;5;241m.\u001b[39marguments\u001b[38;5;241m.\u001b[39mget, independent_args))\n\u001b[0;32m---> 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mgiven\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mgiven\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/utils/_decorators.py:65\u001b[0m, in \u001b[0;36mdependent_argument..decorator..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mcallable\u001b[39m(f):\n\u001b[1;32m 63\u001b[0m given\u001b[38;5;241m.\u001b[39marguments[dependent_arg] \\\n\u001b[1;32m 64\u001b[0m \u001b[38;5;241m=\u001b[39m f(\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mmap\u001b[39m(given\u001b[38;5;241m.\u001b[39marguments\u001b[38;5;241m.\u001b[39mget, independent_args))\n\u001b[0;32m---> 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mgiven\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mgiven\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/galaxies/luminosity.py:56\u001b[0m, in \u001b[0;36mschechter_lf_magnitude\u001b[0;34m(redshift, M_star, alpha, m_lim, cosmology, size, x_max, resolution)\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124monly scalar alpha is supported\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 55\u001b[0m \u001b[38;5;66;03m# get x_min for each galaxy\u001b[39;00m\n\u001b[0;32m---> 56\u001b[0m x_min \u001b[38;5;241m=\u001b[39m m_lim \u001b[38;5;241m-\u001b[39m \u001b[43mcosmology\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistmod\u001b[49m\u001b[43m(\u001b[49m\u001b[43mredshift\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mvalue\n\u001b[1;32m 57\u001b[0m x_min \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m M_star\n\u001b[1;32m 58\u001b[0m x_min \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m0.4\u001b[39m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1351\u001b[0m, in \u001b[0;36mFLRW.distmod\u001b[0;34m(self, z)\u001b[0m\n\u001b[1;32m 1328\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Distance modulus at redshift ``z``.\u001b[39;00m\n\u001b[1;32m 1329\u001b[0m \n\u001b[1;32m 1330\u001b[0m \u001b[38;5;124;03mThe distance modulus is defined as the (apparent magnitude - absolute\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1345\u001b[0m \u001b[38;5;124;03mz_at_value : Find the redshift corresponding to a distance modulus.\u001b[39;00m\n\u001b[1;32m 1346\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1347\u001b[0m \u001b[38;5;66;03m# Remember that the luminosity distance is in Mpc\u001b[39;00m\n\u001b[1;32m 1348\u001b[0m \u001b[38;5;66;03m# Abs is necessary because in certain obscure closed cosmologies\u001b[39;00m\n\u001b[1;32m 1349\u001b[0m \u001b[38;5;66;03m# the distance modulus can be negative -- which is okay because\u001b[39;00m\n\u001b[1;32m 1350\u001b[0m \u001b[38;5;66;03m# it enters as the square.\u001b[39;00m\n\u001b[0;32m-> 1351\u001b[0m val \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5.0\u001b[39m \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mlog10(\u001b[38;5;28mabs\u001b[39m(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mluminosity_distance\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mvalue)) \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m25.0\u001b[39m\n\u001b[1;32m 1352\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m u\u001b[38;5;241m.\u001b[39mQuantity(val, u\u001b[38;5;241m.\u001b[39mmag)\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1271\u001b[0m, in \u001b[0;36mFLRW.luminosity_distance\u001b[0;34m(self, z)\u001b[0m\n\u001b[1;32m 1247\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Luminosity distance in Mpc at redshift ``z``.\u001b[39;00m\n\u001b[1;32m 1248\u001b[0m \n\u001b[1;32m 1249\u001b[0m \u001b[38;5;124;03mThis is the distance to use when converting between the bolometric flux\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1268\u001b[0m \u001b[38;5;124;03m.. [1] Weinberg, 1972, pp 420-424; Weedman, 1986, pp 60-62.\u001b[39;00m\n\u001b[1;32m 1269\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1270\u001b[0m z \u001b[38;5;241m=\u001b[39m aszarr(z)\n\u001b[0;32m-> 1271\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m (z \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1.0\u001b[39m) \u001b[38;5;241m*\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcomoving_transverse_distance\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1185\u001b[0m, in \u001b[0;36mFLRW.comoving_transverse_distance\u001b[0;34m(self, z)\u001b[0m\n\u001b[1;32m 1163\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcomoving_transverse_distance\u001b[39m(\u001b[38;5;28mself\u001b[39m, z):\n\u001b[1;32m 1164\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Comoving transverse distance in Mpc at a given redshift.\u001b[39;00m\n\u001b[1;32m 1165\u001b[0m \n\u001b[1;32m 1166\u001b[0m \u001b[38;5;124;03m This value is the transverse comoving distance at redshift ``z``\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1183\u001b[0m \u001b[38;5;124;03m This quantity is also called the 'proper motion distance' in some texts.\u001b[39;00m\n\u001b[1;32m 1184\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1185\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_comoving_transverse_distance_z1z2\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1210\u001b[0m, in \u001b[0;36mFLRW._comoving_transverse_distance_z1z2\u001b[0;34m(self, z1, z2)\u001b[0m\n\u001b[1;32m 1188\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Comoving transverse distance in Mpc between two redshifts.\u001b[39;00m\n\u001b[1;32m 1189\u001b[0m \n\u001b[1;32m 1190\u001b[0m \u001b[38;5;124;03mThis value is the transverse comoving distance at redshift ``z2`` as\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1207\u001b[0m \u001b[38;5;124;03mThis quantity is also called the 'proper motion distance' in some texts.\u001b[39;00m\n\u001b[1;32m 1208\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1209\u001b[0m Ok0 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_Ok0\n\u001b[0;32m-> 1210\u001b[0m dc \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_comoving_distance_z1z2\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz2\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1211\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m Ok0 \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 1212\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dc\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1123\u001b[0m, in \u001b[0;36mFLRW._comoving_distance_z1z2\u001b[0;34m(self, z1, z2)\u001b[0m\n\u001b[1;32m 1107\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_comoving_distance_z1z2\u001b[39m(\u001b[38;5;28mself\u001b[39m, z1, z2):\n\u001b[1;32m 1108\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Comoving line-of-sight distance in Mpc between redshifts ``z1`` and ``z2``.\u001b[39;00m\n\u001b[1;32m 1109\u001b[0m \n\u001b[1;32m 1110\u001b[0m \u001b[38;5;124;03m The comoving distance along the line-of-sight between two objects\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1121\u001b[0m \u001b[38;5;124;03m Comoving distance in Mpc between each input redshift.\u001b[39;00m\n\u001b[1;32m 1122\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1123\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_integral_comoving_distance_z1z2\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz2\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1161\u001b[0m, in \u001b[0;36mFLRW._integral_comoving_distance_z1z2\u001b[0;34m(self, z1, z2)\u001b[0m\n\u001b[1;32m 1145\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_integral_comoving_distance_z1z2\u001b[39m(\u001b[38;5;28mself\u001b[39m, z1, z2):\n\u001b[1;32m 1146\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Comoving line-of-sight distance in Mpc between objects at redshifts ``z1`` and ``z2``.\u001b[39;00m\n\u001b[1;32m 1147\u001b[0m \n\u001b[1;32m 1148\u001b[0m \u001b[38;5;124;03m The comoving distance along the line-of-sight between two objects remains\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1159\u001b[0m \u001b[38;5;124;03m Comoving distance in Mpc between each input redshift.\u001b[39;00m\n\u001b[1;32m 1160\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1161\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_hubble_distance \u001b[38;5;241m*\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_integral_comoving_distance_z1z2_scalar\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz2\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/_utils.py:63\u001b[0m, in \u001b[0;36mvectorize_redshift_method..wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39mzs, \u001b[38;5;241m*\u001b[39margs[nin:], \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 62\u001b[0m \u001b[38;5;66;03m# non-scalar. use vectorized func\u001b[39;00m\n\u001b[0;32m---> 63\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mwrapper\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__vectorized__\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mzs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m[\u001b[49m\u001b[43mnin\u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/numpy/lib/function_base.py:2372\u001b[0m, in \u001b[0;36mvectorize.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2369\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_init_stage_2(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 2370\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n\u001b[0;32m-> 2372\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_as_normal\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/numpy/lib/function_base.py:2365\u001b[0m, in \u001b[0;36mvectorize._call_as_normal\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2362\u001b[0m vargs \u001b[38;5;241m=\u001b[39m [args[_i] \u001b[38;5;28;01mfor\u001b[39;00m _i \u001b[38;5;129;01min\u001b[39;00m inds]\n\u001b[1;32m 2363\u001b[0m vargs\u001b[38;5;241m.\u001b[39mextend([kwargs[_n] \u001b[38;5;28;01mfor\u001b[39;00m _n \u001b[38;5;129;01min\u001b[39;00m names])\n\u001b[0;32m-> 2365\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_vectorize_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/numpy/lib/function_base.py:2455\u001b[0m, in \u001b[0;36mvectorize._vectorize_call\u001b[0;34m(self, func, args)\u001b[0m\n\u001b[1;32m 2452\u001b[0m \u001b[38;5;66;03m# Convert args to object arrays first\u001b[39;00m\n\u001b[1;32m 2453\u001b[0m inputs \u001b[38;5;241m=\u001b[39m [asanyarray(a, dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mobject\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m args]\n\u001b[0;32m-> 2455\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mufunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2457\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ufunc\u001b[38;5;241m.\u001b[39mnout \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 2458\u001b[0m res \u001b[38;5;241m=\u001b[39m asanyarray(outputs, dtype\u001b[38;5;241m=\u001b[39motypes[\u001b[38;5;241m0\u001b[39m])\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1143\u001b[0m, in \u001b[0;36mFLRW._integral_comoving_distance_z1z2_scalar\u001b[0;34m(self, z1, z2)\u001b[0m\n\u001b[1;32m 1125\u001b[0m \u001b[38;5;129m@vectorize_redshift_method\u001b[39m(nin\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m 1126\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_integral_comoving_distance_z1z2_scalar\u001b[39m(\u001b[38;5;28mself\u001b[39m, z1, z2, \u001b[38;5;241m/\u001b[39m):\n\u001b[1;32m 1127\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Comoving line-of-sight distance in Mpc between objects at redshifts ``z1`` and ``z2``.\u001b[39;00m\n\u001b[1;32m 1128\u001b[0m \n\u001b[1;32m 1129\u001b[0m \u001b[38;5;124;03m The comoving distance along the line-of-sight between two objects\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1141\u001b[0m \u001b[38;5;124;03m Returns `float` if input scalar, `~numpy.ndarray` otherwise.\u001b[39;00m\n\u001b[1;32m 1142\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1143\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mquad\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inv_efunc_scalar\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inv_efunc_scalar_args\u001b[49m\u001b[43m)\u001b[49m[\u001b[38;5;241m0\u001b[39m]\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/scipy/integrate/_quadpack_py.py:464\u001b[0m, in \u001b[0;36mquad\u001b[0;34m(func, a, b, args, full_output, epsabs, epsrel, limit, points, weight, wvar, wopts, maxp1, limlst, complex_func)\u001b[0m\n\u001b[1;32m 461\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m retval\n\u001b[1;32m 463\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m weight \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 464\u001b[0m retval \u001b[38;5;241m=\u001b[39m \u001b[43m_quad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfull_output\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepsabs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepsrel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlimit\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 465\u001b[0m \u001b[43m \u001b[49m\u001b[43mpoints\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 466\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 467\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m points \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/scipy/integrate/_quadpack_py.py:611\u001b[0m, in \u001b[0;36m_quad\u001b[0;34m(func, a, b, args, full_output, epsabs, epsrel, limit, points)\u001b[0m\n\u001b[1;32m 609\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m points \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 610\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m infbounds \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 611\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_quadpack\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_qagse\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mfull_output\u001b[49m\u001b[43m,\u001b[49m\u001b[43mepsabs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mepsrel\u001b[49m\u001b[43m,\u001b[49m\u001b[43mlimit\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 612\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 613\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _quadpack\u001b[38;5;241m.\u001b[39m_qagie(func, bound, infbounds, args, full_output, \n\u001b[1;32m 614\u001b[0m epsabs, epsrel, limit)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "start_time = time.time()\n", + "\n", + "# define a cosmology\n", + "H0 = 67.4\n", + "cosmo = FlatLambdaCDM(H0=H0, Om0=0.3)\n", + "\n", + "# define sky area scaling\n", + "sky_area = Quantity(value=5, unit=\"deg2\")\n", + "\n", + "# define source and deflector sky areas (by keeping these low, the simulation is faster)\n", + "source_sky_area = Quantity(value=2, unit=\"deg2\")\n", + "deflector_sky_area = Quantity(value=2, unit=\"deg2\")\n", + "\n", + "# define limits in the intrinsic deflector and source population\n", + "kwargs_deflector_cut = {\"z_min\": 0.01, \"z_max\": 1.0}\n", + "kwargs_source_cut = {\"z_min\": 0.01, \"z_max\": 1.5}\n", + "\n", + "galaxy_simulation_pipeline = pipelines.SkyPyPipeline(\n", + " skypy_config=None,\n", + " sky_area=sky_area,\n", + " filters=None,\n", + ")\n", + "\n", + "lens_galaxies = deflectors.AllLensGalaxies(\n", + " red_galaxy_list=galaxy_simulation_pipeline.red_galaxies,\n", + " blue_galaxy_list=galaxy_simulation_pipeline.blue_galaxies,\n", + " kwargs_cut=kwargs_deflector_cut,\n", + " kwargs_mass2light={},\n", + " cosmo=cosmo,\n", + " sky_area=sky_area,\n", + ")\n", + "\n", + "path = (\n", + " os.path.dirname(slsim.__file__)\n", + " + \"/Sources/SupernovaeCatalog/supernovae_data.pkl\"\n", + ")\n", + "with open(path, \"rb\") as f:\n", + " supernovae_data = pickle.load(f)\n", + "\n", + "source_galaxies = sources.PointPlusExtendedSources(\n", + " point_plus_extended_sources_list=supernovae_data,\n", + " cosmo=cosmo,\n", + " sky_area=sky_area,\n", + " kwargs_cut=kwargs_source_cut,\n", + " variability_model=\"light_curve\",\n", + " kwargs_variability_model={\"MJD\", \"ps_mag_r\"},\n", + " list_type=\"list\",\n", + ")\n", + "\n", + "pes_lens_pop = LensPop(\n", + " deflector_population=lens_galaxies,\n", + " source_population=source_galaxies,\n", + " cosmo=cosmo,\n", + ")\n", + "kwargs_lens_cut = {}\n", + "pes_lens_class = pes_lens_pop.select_lens_at_random(**kwargs_lens_cut)\n", + "\n", + "\n", + "end_time = time.time()\n", + "print(\"Duration: \", np.around((end_time - start_time) / 60, 2), \"minutes\")" + ] + }, { "cell_type": "code", "execution_count": 2, @@ -519,7 +626,7 @@ "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", "ra_points = ra_points.wrap_at(180 * u.degree)\n", "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", - "dec_points = coord.Angle(dec_points * u.degree)" + "dec_points = coord.Angle(dec_points * u.degree)\n" ] }, { From f4fb12fdeda1a083f40903f0411504a38bba61e8 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 24 Sep 2024 12:04:29 +0200 Subject: [PATCH 36/50] made test functions for opsim --- .../test_opsim_pipeline.py | 98 +++++++++++-------- 1 file changed, 56 insertions(+), 42 deletions(-) diff --git a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py index b06535e65..d053f9083 100644 --- a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py @@ -3,21 +3,21 @@ from astropy.table import Table from astropy.cosmology import FlatLambdaCDM from slsim.lens import Lens -from slsim.LsstSciencePipeline.lsst_science_pipeline import ( - variable_lens_injection, - multiple_variable_lens_injection, +from slsim.LsstSciencePipeline.opsim_pipeline import ( + opsim_variable_lens_injection, + opsim_time_series_images_data, ) import pytest - +import pickle @pytest.fixture def pes_lens_instance(): path = os.path.dirname(__file__) source_dict = Table.read( - os.path.join(path, "TestData/source_dict_ps.fits"), format="fits" + os.path.join(path, "../TestData/source_dict_ps.fits"), format="fits" ) deflector_dict = Table.read( - os.path.join(path, "TestData/deflector_dict_ps.fits"), format="fits" + os.path.join(path, "../TestData/deflector_dict_ps.fits"), format="fits" ) cosmo = FlatLambdaCDM(H0=70, Om0=0.3) @@ -37,45 +37,59 @@ def pes_lens_instance(): return pes_lens -def test_variable_lens_injection(pes_lens_instance): +def test_opsim_time_series_images_data(): + + # Test coordinates + dec_points = np.array([-9.3, -36.2, -70.9, 19.9, -9.5, 6.7, -45.9, -37.1]) + ra_points = np.array([150.6, 4.1, 52.8, 33.2, 67.0, 124.4, -14.5, -166.9]) + + # Create opsim_data instance + opsim_data = opsim_time_series_images_data( + ra_points, + dec_points, + obs_strategy="baseline_v3.0_10yrs", + MJD_min=60000, + MJD_max=60500, + print_warning=False) + + assert isinstance(opsim_data, list) # is opsim_data a list? + assert len(opsim_data) == len(dec_points) # does it have the same length as number of points given? + assert opsim_data[0].keys() == ['bkg_noise', # does it contain the right data columns? + 'psf_kernel', + 'obs_time', + 'expo_time', + 'zero_point', + 'calexp_center', + 'band'] + assert isinstance(opsim_data[0]['bkg_noise'][0], float) # are entries from bkg_noise floats? + assert opsim_data[0]['psf_kernel'][0].ndim == 2 # is psf_kernel a 2 dimensional array? + assert isinstance(opsim_data[0]['obs_time'][0], float) # are entries from obs_time floats? + assert isinstance(opsim_data[0]['expo_time'][0], float) # are entries from expo_time floats? + assert isinstance(opsim_data[0]['zero_point'][0], float) # are entries from zero_point floats? + assert isinstance(opsim_data[0]['calexp_center'][0], np.ndarray) # is calexp_center an array? + assert opsim_data[0]['calexp_center'][0].shape == (2,) # is calexp_center an array of length 2? + assert all(isinstance(item, float) for item in opsim_data[0]['calexp_center'][0]) # are entries floats? + assert isinstance(opsim_data[0]['band'][0], str) # are entries from band strings? + + +def test_opsim_variable_lens_injection(pes_lens_instance): lens_class = pes_lens_instance - path = os.path.dirname(__file__) - expo_data = Table.read( - os.path.join(path, "TestData/expo_data_1.fits"), format="fits" - ) - transf_matrix_single = np.array([[0.2, 0], [0, 0.2]]) - transform_matrices = [transf_matrix_single.copy() for _ in range(len(expo_data))] - results = variable_lens_injection( - lens_class, - band="i", - num_pix=301, - transform_pix2angle=transform_matrices, - exposure_data=expo_data, - ) - assert len(results) == len(expo_data) + # Load example opsim data format + with open('../TestData/expo_data_opsim.pkl', 'rb') as f: + expo_data = pickle.load(f) -def test_multiple_variable_lens_injection(pes_lens_instance): - lens_class = [pes_lens_instance, pes_lens_instance] - path = os.path.dirname(__file__) - expo_data_1 = Table.read( - os.path.join(path, "TestData/expo_data_1.fits"), format="fits" - ) - expo_data_2 = Table.read( - os.path.join(path, "TestData/expo_data_2.fits"), format="fits" - ) - expo_data = [expo_data_1, expo_data_2] - transf_matrix_single = np.array([[0.2, 0], [0, 0.2]]) - transform_matrices = [] - for data in expo_data: - transform_matrices.append( - [transf_matrix_single.copy() for _ in range(len(data))] - ) - results = multiple_variable_lens_injection( + transform_pix2angle = np.array([[0.2, 0], [0, 0.2]]) + bands = ["g", "r", "i"] + + # Create example images + results = opsim_variable_lens_injection( lens_class, - band="i", + bands=bands, num_pix=301, - transform_matrices_list=transform_matrices, - exposure_data_list=expo_data, + transform_pix2angle=transform_pix2angle, + exposure_data=expo_data, ) - assert len(results) == len(expo_data) + + mask = np.isin(expo_data["band"], bands) + assert len(results) == len(expo_data[mask]) From 410ca0e53311d9b884c05db23c258d95aebdc508 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 24 Sep 2024 13:37:12 +0200 Subject: [PATCH 37/50] ran notebook again --- ...rnovae_plus_extended_source_tutorial.ipynb | 401 +++--------------- 1 file changed, 64 insertions(+), 337 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index 695b0e478..78922cfda 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -14,8 +14,11 @@ "import corner\n", "import astropy.coordinates as coord\n", "import astropy.units as u\n", + "import pickle\n", "import time\n", + "import os\n", "\n", + "import slsim\n", "import slsim.Sources as sources\n", "import slsim.Pipelines as pipelines\n", "import slsim.Deflectors as deflectors\n", @@ -55,40 +58,26 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [ { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[5], line 18\u001b[0m\n\u001b[1;32m 15\u001b[0m kwargs_deflector_cut \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mz_min\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;241m0.01\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mz_max\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;241m1.0\u001b[39m}\n\u001b[1;32m 16\u001b[0m kwargs_source_cut \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mz_min\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;241m0.01\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mz_max\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;241m1.5\u001b[39m}\n\u001b[0;32m---> 18\u001b[0m galaxy_simulation_pipeline \u001b[38;5;241m=\u001b[39m \u001b[43mpipelines\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSkyPyPipeline\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 19\u001b[0m \u001b[43m \u001b[49m\u001b[43mskypy_config\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 20\u001b[0m \u001b[43m \u001b[49m\u001b[43msky_area\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msky_area\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 21\u001b[0m \u001b[43m \u001b[49m\u001b[43mfilters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 22\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 24\u001b[0m lens_galaxies \u001b[38;5;241m=\u001b[39m deflectors\u001b[38;5;241m.\u001b[39mAllLensGalaxies(\n\u001b[1;32m 25\u001b[0m red_galaxy_list\u001b[38;5;241m=\u001b[39mgalaxy_simulation_pipeline\u001b[38;5;241m.\u001b[39mred_galaxies,\n\u001b[1;32m 26\u001b[0m blue_galaxy_list\u001b[38;5;241m=\u001b[39mgalaxy_simulation_pipeline\u001b[38;5;241m.\u001b[39mblue_galaxies,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 30\u001b[0m sky_area\u001b[38;5;241m=\u001b[39msky_area,\n\u001b[1;32m 31\u001b[0m )\n\u001b[1;32m 33\u001b[0m path \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 34\u001b[0m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mdirname(slsim\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__file__\u001b[39m)\n\u001b[1;32m 35\u001b[0m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/Sources/SupernovaeCatalog/supernovae_data.pkl\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 36\u001b[0m )\n", - "File \u001b[0;32m~/Documents/Research/Projects/slsim/slsim/Pipelines/skypy_pipeline.py:100\u001b[0m, in \u001b[0;36mSkyPyPipeline.__init__\u001b[0;34m(self, skypy_config, sky_area, filters, cosmo)\u001b[0m\n\u001b[1;32m 97\u001b[0m tmp_file\u001b[38;5;241m.\u001b[39mwrite(content)\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pipeline \u001b[38;5;241m=\u001b[39m Pipeline\u001b[38;5;241m.\u001b[39mread(tmp_file\u001b[38;5;241m.\u001b[39mname)\n\u001b[0;32m--> 100\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_pipeline\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;66;03m# Remove the temporary file after the pipeline has been executed\u001b[39;00m\n\u001b[1;32m 103\u001b[0m os\u001b[38;5;241m.\u001b[39mremove(tmp_file\u001b[38;5;241m.\u001b[39mname)\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/pipeline/_pipeline.py:185\u001b[0m, in \u001b[0;36mPipeline.execute\u001b[0;34m(self, parameters)\u001b[0m\n\u001b[1;32m 182\u001b[0m names \u001b[38;5;241m=\u001b[39m [n\u001b[38;5;241m.\u001b[39mstrip() \u001b[38;5;28;01mfor\u001b[39;00m n \u001b[38;5;129;01min\u001b[39;00m column\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m,\u001b[39m\u001b[38;5;124m'\u001b[39m)]\n\u001b[1;32m 183\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(names) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 184\u001b[0m \u001b[38;5;66;03m# Multi-column assignment\u001b[39;00m\n\u001b[0;32m--> 185\u001b[0m t \u001b[38;5;241m=\u001b[39m Table(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mevaluate\u001b[49m\u001b[43m(\u001b[49m\u001b[43msettings\u001b[49m\u001b[43m)\u001b[49m, names\u001b[38;5;241m=\u001b[39mnames)\n\u001b[1;32m 186\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate[table]\u001b[38;5;241m.\u001b[39madd_columns(t\u001b[38;5;241m.\u001b[39mcolumns)\n\u001b[1;32m 187\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 188\u001b[0m \u001b[38;5;66;03m# Single column assignment\u001b[39;00m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/pipeline/_pipeline.py:262\u001b[0m, in \u001b[0;36mPipeline.evaluate\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m 259\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {k: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mevaluate(v) \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m value\u001b[38;5;241m.\u001b[39mitems()}\n\u001b[1;32m 260\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(value, Item):\n\u001b[1;32m 261\u001b[0m \u001b[38;5;66;03m# evaluate item\u001b[39;00m\n\u001b[0;32m--> 262\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mvalue\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mevaluate\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 263\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 264\u001b[0m \u001b[38;5;66;03m# everything else return unchanged\u001b[39;00m\n\u001b[1;32m 265\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m value\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/pipeline/_items.py:93\u001b[0m, in \u001b[0;36mCall.evaluate\u001b[0;34m(self, pipeline)\u001b[0m\n\u001b[1;32m 91\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m pipeline\u001b[38;5;241m.\u001b[39mevaluate(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwargs)\n\u001b[1;32m 92\u001b[0m log\u001b[38;5;241m.\u001b[39minfo(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCalling \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m---> 93\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/units/decorators.py:313\u001b[0m, in \u001b[0;36mQuantityInput.__call__..wrapper\u001b[0;34m(*func_args, **func_kwargs)\u001b[0m\n\u001b[1;32m 311\u001b[0m \u001b[38;5;66;03m# Call the original function with any equivalencies in force.\u001b[39;00m\n\u001b[1;32m 312\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m add_enabled_equivalencies(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mequivalencies):\n\u001b[0;32m--> 313\u001b[0m return_ \u001b[38;5;241m=\u001b[39m \u001b[43mwrapped_function\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mfunc_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mfunc_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 315\u001b[0m \u001b[38;5;66;03m# Return\u001b[39;00m\n\u001b[1;32m 316\u001b[0m ra \u001b[38;5;241m=\u001b[39m wrapped_signature\u001b[38;5;241m.\u001b[39mreturn_annotation\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/galaxies/_schechter.py:75\u001b[0m, in \u001b[0;36mschechter_lf\u001b[0;34m(redshift, M_star, phi_star, alpha, m_lim, sky_area, cosmology, noise)\u001b[0m\n\u001b[1;32m 72\u001b[0m alpha \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39minterp(z, redshift, alpha)\n\u001b[1;32m 74\u001b[0m \u001b[38;5;66;03m# sample galaxy magnitudes for redshifts\u001b[39;00m\n\u001b[0;32m---> 75\u001b[0m M \u001b[38;5;241m=\u001b[39m \u001b[43mschechter_lf_magnitude\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mM_star\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malpha\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mm_lim\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcosmology\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 77\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m z, M\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/utils/_decorators.py:65\u001b[0m, in \u001b[0;36mdependent_argument..decorator..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mcallable\u001b[39m(f):\n\u001b[1;32m 63\u001b[0m given\u001b[38;5;241m.\u001b[39marguments[dependent_arg] \\\n\u001b[1;32m 64\u001b[0m \u001b[38;5;241m=\u001b[39m f(\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mmap\u001b[39m(given\u001b[38;5;241m.\u001b[39marguments\u001b[38;5;241m.\u001b[39mget, independent_args))\n\u001b[0;32m---> 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mgiven\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mgiven\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/utils/_decorators.py:65\u001b[0m, in \u001b[0;36mdependent_argument..decorator..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mcallable\u001b[39m(f):\n\u001b[1;32m 63\u001b[0m given\u001b[38;5;241m.\u001b[39marguments[dependent_arg] \\\n\u001b[1;32m 64\u001b[0m \u001b[38;5;241m=\u001b[39m f(\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mmap\u001b[39m(given\u001b[38;5;241m.\u001b[39marguments\u001b[38;5;241m.\u001b[39mget, independent_args))\n\u001b[0;32m---> 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mgiven\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mgiven\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/skypy/galaxies/luminosity.py:56\u001b[0m, in \u001b[0;36mschechter_lf_magnitude\u001b[0;34m(redshift, M_star, alpha, m_lim, cosmology, size, x_max, resolution)\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124monly scalar alpha is supported\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 55\u001b[0m \u001b[38;5;66;03m# get x_min for each galaxy\u001b[39;00m\n\u001b[0;32m---> 56\u001b[0m x_min \u001b[38;5;241m=\u001b[39m m_lim \u001b[38;5;241m-\u001b[39m \u001b[43mcosmology\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistmod\u001b[49m\u001b[43m(\u001b[49m\u001b[43mredshift\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mvalue\n\u001b[1;32m 57\u001b[0m x_min \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m M_star\n\u001b[1;32m 58\u001b[0m x_min \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m0.4\u001b[39m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1351\u001b[0m, in \u001b[0;36mFLRW.distmod\u001b[0;34m(self, z)\u001b[0m\n\u001b[1;32m 1328\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Distance modulus at redshift ``z``.\u001b[39;00m\n\u001b[1;32m 1329\u001b[0m \n\u001b[1;32m 1330\u001b[0m \u001b[38;5;124;03mThe distance modulus is defined as the (apparent magnitude - absolute\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1345\u001b[0m \u001b[38;5;124;03mz_at_value : Find the redshift corresponding to a distance modulus.\u001b[39;00m\n\u001b[1;32m 1346\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1347\u001b[0m \u001b[38;5;66;03m# Remember that the luminosity distance is in Mpc\u001b[39;00m\n\u001b[1;32m 1348\u001b[0m \u001b[38;5;66;03m# Abs is necessary because in certain obscure closed cosmologies\u001b[39;00m\n\u001b[1;32m 1349\u001b[0m \u001b[38;5;66;03m# the distance modulus can be negative -- which is okay because\u001b[39;00m\n\u001b[1;32m 1350\u001b[0m \u001b[38;5;66;03m# it enters as the square.\u001b[39;00m\n\u001b[0;32m-> 1351\u001b[0m val \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5.0\u001b[39m \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mlog10(\u001b[38;5;28mabs\u001b[39m(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mluminosity_distance\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mvalue)) \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m25.0\u001b[39m\n\u001b[1;32m 1352\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m u\u001b[38;5;241m.\u001b[39mQuantity(val, u\u001b[38;5;241m.\u001b[39mmag)\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1271\u001b[0m, in \u001b[0;36mFLRW.luminosity_distance\u001b[0;34m(self, z)\u001b[0m\n\u001b[1;32m 1247\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Luminosity distance in Mpc at redshift ``z``.\u001b[39;00m\n\u001b[1;32m 1248\u001b[0m \n\u001b[1;32m 1249\u001b[0m \u001b[38;5;124;03mThis is the distance to use when converting between the bolometric flux\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1268\u001b[0m \u001b[38;5;124;03m.. [1] Weinberg, 1972, pp 420-424; Weedman, 1986, pp 60-62.\u001b[39;00m\n\u001b[1;32m 1269\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1270\u001b[0m z \u001b[38;5;241m=\u001b[39m aszarr(z)\n\u001b[0;32m-> 1271\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m (z \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1.0\u001b[39m) \u001b[38;5;241m*\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcomoving_transverse_distance\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1185\u001b[0m, in \u001b[0;36mFLRW.comoving_transverse_distance\u001b[0;34m(self, z)\u001b[0m\n\u001b[1;32m 1163\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcomoving_transverse_distance\u001b[39m(\u001b[38;5;28mself\u001b[39m, z):\n\u001b[1;32m 1164\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Comoving transverse distance in Mpc at a given redshift.\u001b[39;00m\n\u001b[1;32m 1165\u001b[0m \n\u001b[1;32m 1166\u001b[0m \u001b[38;5;124;03m This value is the transverse comoving distance at redshift ``z``\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1183\u001b[0m \u001b[38;5;124;03m This quantity is also called the 'proper motion distance' in some texts.\u001b[39;00m\n\u001b[1;32m 1184\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1185\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_comoving_transverse_distance_z1z2\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1210\u001b[0m, in \u001b[0;36mFLRW._comoving_transverse_distance_z1z2\u001b[0;34m(self, z1, z2)\u001b[0m\n\u001b[1;32m 1188\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Comoving transverse distance in Mpc between two redshifts.\u001b[39;00m\n\u001b[1;32m 1189\u001b[0m \n\u001b[1;32m 1190\u001b[0m \u001b[38;5;124;03mThis value is the transverse comoving distance at redshift ``z2`` as\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1207\u001b[0m \u001b[38;5;124;03mThis quantity is also called the 'proper motion distance' in some texts.\u001b[39;00m\n\u001b[1;32m 1208\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1209\u001b[0m Ok0 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_Ok0\n\u001b[0;32m-> 1210\u001b[0m dc \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_comoving_distance_z1z2\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz2\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1211\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m Ok0 \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 1212\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dc\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1123\u001b[0m, in \u001b[0;36mFLRW._comoving_distance_z1z2\u001b[0;34m(self, z1, z2)\u001b[0m\n\u001b[1;32m 1107\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_comoving_distance_z1z2\u001b[39m(\u001b[38;5;28mself\u001b[39m, z1, z2):\n\u001b[1;32m 1108\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Comoving line-of-sight distance in Mpc between redshifts ``z1`` and ``z2``.\u001b[39;00m\n\u001b[1;32m 1109\u001b[0m \n\u001b[1;32m 1110\u001b[0m \u001b[38;5;124;03m The comoving distance along the line-of-sight between two objects\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1121\u001b[0m \u001b[38;5;124;03m Comoving distance in Mpc between each input redshift.\u001b[39;00m\n\u001b[1;32m 1122\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1123\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_integral_comoving_distance_z1z2\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz2\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1161\u001b[0m, in \u001b[0;36mFLRW._integral_comoving_distance_z1z2\u001b[0;34m(self, z1, z2)\u001b[0m\n\u001b[1;32m 1145\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_integral_comoving_distance_z1z2\u001b[39m(\u001b[38;5;28mself\u001b[39m, z1, z2):\n\u001b[1;32m 1146\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Comoving line-of-sight distance in Mpc between objects at redshifts ``z1`` and ``z2``.\u001b[39;00m\n\u001b[1;32m 1147\u001b[0m \n\u001b[1;32m 1148\u001b[0m \u001b[38;5;124;03m The comoving distance along the line-of-sight between two objects remains\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1159\u001b[0m \u001b[38;5;124;03m Comoving distance in Mpc between each input redshift.\u001b[39;00m\n\u001b[1;32m 1160\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1161\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_hubble_distance \u001b[38;5;241m*\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_integral_comoving_distance_z1z2_scalar\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz2\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/_utils.py:63\u001b[0m, in \u001b[0;36mvectorize_redshift_method..wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39mzs, \u001b[38;5;241m*\u001b[39margs[nin:], \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 62\u001b[0m \u001b[38;5;66;03m# non-scalar. use vectorized func\u001b[39;00m\n\u001b[0;32m---> 63\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mwrapper\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__vectorized__\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mzs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m[\u001b[49m\u001b[43mnin\u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/numpy/lib/function_base.py:2372\u001b[0m, in \u001b[0;36mvectorize.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2369\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_init_stage_2(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 2370\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n\u001b[0;32m-> 2372\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_as_normal\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/numpy/lib/function_base.py:2365\u001b[0m, in \u001b[0;36mvectorize._call_as_normal\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2362\u001b[0m vargs \u001b[38;5;241m=\u001b[39m [args[_i] \u001b[38;5;28;01mfor\u001b[39;00m _i \u001b[38;5;129;01min\u001b[39;00m inds]\n\u001b[1;32m 2363\u001b[0m vargs\u001b[38;5;241m.\u001b[39mextend([kwargs[_n] \u001b[38;5;28;01mfor\u001b[39;00m _n \u001b[38;5;129;01min\u001b[39;00m names])\n\u001b[0;32m-> 2365\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_vectorize_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/numpy/lib/function_base.py:2455\u001b[0m, in \u001b[0;36mvectorize._vectorize_call\u001b[0;34m(self, func, args)\u001b[0m\n\u001b[1;32m 2452\u001b[0m \u001b[38;5;66;03m# Convert args to object arrays first\u001b[39;00m\n\u001b[1;32m 2453\u001b[0m inputs \u001b[38;5;241m=\u001b[39m [asanyarray(a, dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mobject\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m args]\n\u001b[0;32m-> 2455\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mufunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2457\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ufunc\u001b[38;5;241m.\u001b[39mnout \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 2458\u001b[0m res \u001b[38;5;241m=\u001b[39m asanyarray(outputs, dtype\u001b[38;5;241m=\u001b[39motypes[\u001b[38;5;241m0\u001b[39m])\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/astropy/cosmology/flrw/base.py:1143\u001b[0m, in \u001b[0;36mFLRW._integral_comoving_distance_z1z2_scalar\u001b[0;34m(self, z1, z2)\u001b[0m\n\u001b[1;32m 1125\u001b[0m \u001b[38;5;129m@vectorize_redshift_method\u001b[39m(nin\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m 1126\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_integral_comoving_distance_z1z2_scalar\u001b[39m(\u001b[38;5;28mself\u001b[39m, z1, z2, \u001b[38;5;241m/\u001b[39m):\n\u001b[1;32m 1127\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Comoving line-of-sight distance in Mpc between objects at redshifts ``z1`` and ``z2``.\u001b[39;00m\n\u001b[1;32m 1128\u001b[0m \n\u001b[1;32m 1129\u001b[0m \u001b[38;5;124;03m The comoving distance along the line-of-sight between two objects\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1141\u001b[0m \u001b[38;5;124;03m Returns `float` if input scalar, `~numpy.ndarray` otherwise.\u001b[39;00m\n\u001b[1;32m 1142\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1143\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mquad\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inv_efunc_scalar\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inv_efunc_scalar_args\u001b[49m\u001b[43m)\u001b[49m[\u001b[38;5;241m0\u001b[39m]\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/scipy/integrate/_quadpack_py.py:464\u001b[0m, in \u001b[0;36mquad\u001b[0;34m(func, a, b, args, full_output, epsabs, epsrel, limit, points, weight, wvar, wopts, maxp1, limlst, complex_func)\u001b[0m\n\u001b[1;32m 461\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m retval\n\u001b[1;32m 463\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m weight \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 464\u001b[0m retval \u001b[38;5;241m=\u001b[39m \u001b[43m_quad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfull_output\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepsabs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepsrel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlimit\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 465\u001b[0m \u001b[43m \u001b[49m\u001b[43mpoints\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 466\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 467\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m points \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/scipy/integrate/_quadpack_py.py:611\u001b[0m, in \u001b[0;36m_quad\u001b[0;34m(func, a, b, args, full_output, epsabs, epsrel, limit, points)\u001b[0m\n\u001b[1;32m 609\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m points \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 610\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m infbounds \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 611\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_quadpack\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_qagse\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mfull_output\u001b[49m\u001b[43m,\u001b[49m\u001b[43mepsabs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mepsrel\u001b[49m\u001b[43m,\u001b[49m\u001b[43mlimit\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 612\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 613\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _quadpack\u001b[38;5;241m.\u001b[39m_qagie(func, bound, infbounds, args, full_output, \n\u001b[1;32m 614\u001b[0m epsabs, epsrel, limit)\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nikki/Documents/Research/Projects/slsim/slsim/Deflectors/all_lens_galaxies.py:47: UserWarning: Angular size is converted to arcsec because provided input_catalog_type is skypy. If this is not correct, please refer to the documentation of the class you are using\n", + " red_galaxy_list = catalog_with_angular_size_in_arcsec(\n", + "/Users/nikki/Documents/Research/Projects/slsim/slsim/Deflectors/all_lens_galaxies.py:50: UserWarning: Angular size is converted to arcsec because provided input_catalog_type is skypy. If this is not correct, please refer to the documentation of the class you are using\n", + " blue_galaxy_list = catalog_with_angular_size_in_arcsec(\n", + "/Users/nikki/Documents/Research/Projects/slsim/slsim/lensed_population_base.py:53: UserWarning: No sky area provided, instead uses 0.1 deg2\n", + " warnings.warn(\"No sky area provided, instead uses 0.1 deg2\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Duration: 7.14 minutes\n" ] } ], @@ -100,11 +89,11 @@ "cosmo = FlatLambdaCDM(H0=H0, Om0=0.3)\n", "\n", "# define sky area scaling\n", - "sky_area = Quantity(value=5, unit=\"deg2\")\n", + "sky_area = Quantity(value=4, unit=\"deg2\")\n", "\n", "# define source and deflector sky areas (by keeping these low, the simulation is faster)\n", - "source_sky_area = Quantity(value=2, unit=\"deg2\")\n", - "deflector_sky_area = Quantity(value=2, unit=\"deg2\")\n", + "source_sky_area = Quantity(value=4, unit=\"deg2\")\n", + "deflector_sky_area = Quantity(value=1, unit=\"deg2\")\n", "\n", "# define limits in the intrinsic deflector and source population\n", "kwargs_deflector_cut = {\"z_min\": 0.01, \"z_max\": 1.0}\n", @@ -122,7 +111,7 @@ " kwargs_cut=kwargs_deflector_cut,\n", " kwargs_mass2light={},\n", " cosmo=cosmo,\n", - " sky_area=sky_area,\n", + " sky_area=deflector_sky_area,\n", ")\n", "\n", "path = (\n", @@ -135,117 +124,22 @@ "source_galaxies = sources.PointPlusExtendedSources(\n", " point_plus_extended_sources_list=supernovae_data,\n", " cosmo=cosmo,\n", - " sky_area=sky_area,\n", + " sky_area=source_sky_area,\n", " kwargs_cut=kwargs_source_cut,\n", " variability_model=\"light_curve\",\n", " kwargs_variability_model={\"MJD\", \"ps_mag_r\"},\n", " list_type=\"list\",\n", ")\n", "\n", - "pes_lens_pop = LensPop(\n", + "supernova_lens_pop = LensPop(\n", " deflector_population=lens_galaxies,\n", " source_population=source_galaxies,\n", " cosmo=cosmo,\n", ")\n", "kwargs_lens_cut = {}\n", - "pes_lens_class = pes_lens_pop.select_lens_at_random(**kwargs_lens_cut)\n", - "\n", - "\n", - "end_time = time.time()\n", - "print(\"Duration: \", np.around((end_time - start_time) / 60, 2), \"minutes\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/nikki/Documents/Research/Projects/slsim/slsim/Sources/Supernovae/supernovae_pop.py:95: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n", - " If increasing the limit yields no improvement it is advised to analyze \n", - " the integrand in order to determine the difficulties. If the position of a \n", - " local difficulty can be determined (singularity, discontinuity) one will \n", - " probably gain from splitting up the interval and calling the integrator \n", - " on the subranges. Perhaps a special-purpose integrator should be used.\n", - " numerator = integrate.quad(\n", - "/Users/nikki/Documents/Research/Projects/slsim/slsim/Sources/Supernovae/supernovae_pop.py:95: IntegrationWarning: The occurrence of roundoff error is detected, which prevents \n", - " the requested tolerance from being achieved. The error may be \n", - " underestimated.\n", - " numerator = integrate.quad(\n", - "/Users/nikki/Documents/Research/Projects/slsim/slsim/Sources/Supernovae/supernovae_pop.py:95: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", - " numerator = integrate.quad(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Duration: 2.03 minutes\n" - ] - } - ], - "source": [ - "np.random.seed(2)\n", - "\n", - "# define a cosmology\n", - "H0 = 67.4\n", - "cosmo = FlatLambdaCDM(H0=H0, Om0=0.3)\n", - "\n", - "# define sky area scaling\n", - "sky_area = Quantity(value=50, unit=\"deg2\")\n", - "\n", - "# define source and deflector sky areas (by keeping these low, the simulation is faster)\n", - "source_sky_area = Quantity(value=2, unit=\"deg2\")\n", - "deflector_sky_area = Quantity(value=2, unit=\"deg2\")\n", - "\n", - "# define limits in the intrinsic deflector and source population\n", - "kwargs_deflector_cut = {\"z_min\": 0.01, \"z_max\": 1.0}\n", - "kwargs_source_cut = {\"z_min\": 0.01, \"z_max\": 1.5}\n", + "supernova_lens_class = supernova_lens_pop.select_lens_at_random(**kwargs_lens_cut)\n", "\n", - "start_time = time.time()\n", "\n", - "## create a point plus extended source lens population\n", - "supernova_lens_pop = LensPop(\n", - " deflector_type=\"elliptical\", # type of the deflector. It could be elliptical or\n", - " # all-galaxies.\n", - " source_type=\"supernovae_plus_galaxies\", # keyword for source type. it can be\n", - " # galaxies, quasar, quasar_plus_galaxies, and supernovae_plus_galaxies.\n", - " kwargs_deflector_cut=kwargs_deflector_cut, # cuts that one wants to apply for the\n", - " # deflector.\n", - " kwargs_source_cut=kwargs_source_cut, # cuts that one wants to apply for the\n", - " # source.\n", - " variability_model=\"light_curve\", # keyword for the variability model.\n", - " kwargs_variability={\"supernovae_lightcurve\", \"g\", \"r\", \"i\"}, # specify kewords for\n", - " # lightcurve. \"i\" is a band for the lightcurve.\n", - " sn_type=\"Ia\", # supernovae type.\n", - " sn_absolute_mag_band=\"bessellb\", # Band used to normalize to absolute magnitude\n", - " sn_absolute_zpsys=\"ab\", # magnitude system. It can be Optional, AB or Vega.\n", - " sn_modeldir=\"../data/SALT3.NIR_WAVEEXT\", # extended wavelength models for SALT3\n", - " kwargs_mass2light=None, # mass-to-light relation for the deflector galaxy.\n", - " skypy_config=None, # Sky configuration for the simulation. If None, lsst-like\n", - " # configuration will be used.\n", - " sky_area=sky_area, # Scaled sky area for the simulation\n", - " source_sky_area=source_sky_area,\n", - " deflector_sky_area=deflector_sky_area,\n", - " cosmo=cosmo, # astropy cosmology\n", - " source_light_profile=\"single_sersic\", # light profile for the source galaxy\n", - " catalog_type=None, # catalog type. It can be None or scotch\n", - " lightcurve_time=np.linspace(\n", - " -50, 100, 1000\n", - " ), # array of light curve observation time.\n", - " # catalog_path=\"../data/Scotch/\"\n", - " # + \"scotch_SNIa_host_galaxies.fits\",\n", - " # path for catalog. If not provided, small size catalog from\n", - " # /slsim/Source/SupernovaeCatalog will be used for\n", - " # source_type=\"supernovae_plus_galaxies\" case. For other cases, we do not need to\n", - " # provide outside catalog. One can download scotch_SNIa_host_galaxies.fits from\n", - " # https://github.com/LSST-strong-lensing/data_public.git\n", - ")\n", "end_time = time.time()\n", "print(\"Duration: \", np.around((end_time - start_time) / 60, 2), \"minutes\")" ] @@ -259,7 +153,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Found 2639375 potential deflector galaxies and 9450 potential source galaxies.\n" + "Found 151704 potential deflector galaxies and 1 potential source galaxies.\n" ] } ], @@ -289,8 +183,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.01 minutes needed to generate strong lenses.\n", - "Number of strong lens systems: 9\n" + "0.0 minutes needed to generate strong lenses.\n", + "Number of strong lens systems: 0\n" ] } ], @@ -318,22 +212,12 @@ "scrolled": false }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/nikki/anaconda3/envs/slsim/lib/python3.12/site-packages/sncosmo/models.py:189: RuntimeWarning: divide by zero encountered in log10\n", - " result[i] = -2.5 * np.log10(f / zpf)\n", - "/Users/nikki/anaconda3/envs/slsim/lib/python3.12/site-packages/sncosmo/models.py:189: RuntimeWarning: invalid value encountered in log10\n", - " result[i] = -2.5 * np.log10(f / zpf)\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "z_l = [0.14 0.37 0.42 0.33 0.55 0.21 0.47 0.52 0.4 ]\n", - "z_s = [1.45 0.73 1.4 0.75 0.83 0.83 1.28 0.85 1.45]\n" + "z_l = []\n", + "z_s = []\n" ] } ], @@ -389,14 +273,17 @@ "metadata": {}, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "ename": "AssertionError", + "evalue": "I don't believe that you want more dimensions than samples!", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[6], line 8\u001b[0m\n\u001b[1;32m 1\u001b[0m hist2dkwargs \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 2\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mplot_density\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m 3\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mplot_contours\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdata_kwargs\u001b[39m\u001b[38;5;124m\"\u001b[39m: {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mms\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;241m5\u001b[39m},\n\u001b[1;32m 7\u001b[0m }\n\u001b[0;32m----> 8\u001b[0m \u001b[43mcorner\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcorner\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlens_samples\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlabels\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabel_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfontsize\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mhist2dkwargs\u001b[49m\n\u001b[1;32m 10\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/corner/corner.py:248\u001b[0m, in \u001b[0;36mcorner\u001b[0;34m(data, bins, range, axes_scale, weights, color, hist_bin_factor, smooth, smooth1d, labels, label_kwargs, titles, show_titles, title_quantiles, title_fmt, title_kwargs, truths, truth_color, scale_hist, quantiles, verbose, fig, max_n_ticks, top_ticks, use_math_text, reverse, labelpad, hist_kwargs, group, var_names, filter_vars, coords, divergences, divergences_kwargs, labeller, **hist2d_kwargs)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m 237\u001b[0m var_names \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 238\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m filter_vars \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 242\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m labeller \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 243\u001b[0m ):\n\u001b[1;32m 244\u001b[0m logging\u001b[38;5;241m.\u001b[39mwarning(\n\u001b[1;32m 245\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPlease install arviz to use the advanced features of corner\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 246\u001b[0m )\n\u001b[0;32m--> 248\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcorner_impl\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 249\u001b[0m \u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 250\u001b[0m \u001b[43m \u001b[49m\u001b[43mbins\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbins\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 251\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mrange\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mrange\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 252\u001b[0m \u001b[43m \u001b[49m\u001b[43maxes_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxes_scale\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 253\u001b[0m \u001b[43m \u001b[49m\u001b[43mweights\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mweights\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 254\u001b[0m \u001b[43m \u001b[49m\u001b[43mcolor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcolor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43mhist_bin_factor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhist_bin_factor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 256\u001b[0m \u001b[43m \u001b[49m\u001b[43msmooth\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msmooth\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 257\u001b[0m \u001b[43m \u001b[49m\u001b[43msmooth1d\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msmooth1d\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 258\u001b[0m \u001b[43m \u001b[49m\u001b[43mlabels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlabels\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 259\u001b[0m \u001b[43m \u001b[49m\u001b[43mlabel_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlabel_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 260\u001b[0m \u001b[43m \u001b[49m\u001b[43mtitles\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtitles\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 261\u001b[0m \u001b[43m \u001b[49m\u001b[43mshow_titles\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshow_titles\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 262\u001b[0m \u001b[43m \u001b[49m\u001b[43mtitle_quantiles\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtitle_quantiles\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 263\u001b[0m \u001b[43m \u001b[49m\u001b[43mtitle_fmt\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtitle_fmt\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 264\u001b[0m \u001b[43m \u001b[49m\u001b[43mtitle_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtitle_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 265\u001b[0m \u001b[43m \u001b[49m\u001b[43mtruths\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtruths\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 266\u001b[0m \u001b[43m \u001b[49m\u001b[43mtruth_color\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtruth_color\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 267\u001b[0m \u001b[43m \u001b[49m\u001b[43mscale_hist\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscale_hist\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 268\u001b[0m \u001b[43m \u001b[49m\u001b[43mquantiles\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mquantiles\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 269\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 270\u001b[0m \u001b[43m \u001b[49m\u001b[43mfig\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfig\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 271\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_n_ticks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_n_ticks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 272\u001b[0m \u001b[43m \u001b[49m\u001b[43mtop_ticks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtop_ticks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 273\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_math_text\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_math_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 274\u001b[0m \u001b[43m \u001b[49m\u001b[43mreverse\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreverse\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 275\u001b[0m \u001b[43m \u001b[49m\u001b[43mlabelpad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlabelpad\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 276\u001b[0m \u001b[43m \u001b[49m\u001b[43mhist_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhist_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 277\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mhist2d_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 278\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 280\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m arviz_corner(\n\u001b[1;32m 281\u001b[0m data,\n\u001b[1;32m 282\u001b[0m bins\u001b[38;5;241m=\u001b[39mbins,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 316\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mhist2d_kwargs,\n\u001b[1;32m 317\u001b[0m )\n", + "File \u001b[0;32m~/anaconda3/envs/slsim/lib/python3.12/site-packages/corner/core.py:90\u001b[0m, in \u001b[0;36mcorner_impl\u001b[0;34m(xs, bins, range, axes_scale, weights, color, hist_bin_factor, smooth, smooth1d, labels, label_kwargs, titles, show_titles, title_fmt, title_kwargs, truths, truth_color, scale_hist, quantiles, title_quantiles, verbose, fig, max_n_ticks, top_ticks, use_math_text, reverse, labelpad, hist_kwargs, **hist2d_kwargs)\u001b[0m\n\u001b[1;32m 88\u001b[0m \u001b[38;5;66;03m# Deal with 1D sample lists.\u001b[39;00m\n\u001b[1;32m 89\u001b[0m xs \u001b[38;5;241m=\u001b[39m _parse_input(xs)\n\u001b[0;32m---> 90\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m xs\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m xs\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m], (\n\u001b[1;32m 91\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mI don\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt believe that you want more \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdimensions than samples!\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 92\u001b[0m )\n\u001b[1;32m 94\u001b[0m \u001b[38;5;66;03m# Parse the weight array.\u001b[39;00m\n\u001b[1;32m 95\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m weights \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mAssertionError\u001b[0m: I don't believe that you want more dimensions than samples!" + ] } ], "source": [ @@ -422,26 +309,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Chosen lens system properties:\n", - " \n", - "z_lens = 0.1362527877455851\n", - "z_source = 1.450319287113787\n", - "theta_E = 1.004557010696935\n", - "Number of images = 2\n", - "Time delays = [-20.46035531 3.46873864]\n", - "Lens galaxy magnitude: 21.233625435203756\n", - "Host galaxy magnitude: 26.133149007905207\n", - "Supernova magnitude: 25.68767802007754\n" - ] - } - ], + "outputs": [], "source": [ "index = 0\n", "# kwargs_lens_cut = {\"min_image_separation\": 1, \"max_image_separation\": 10}\n", @@ -462,7 +332,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -478,21 +348,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[20.33064151, 9.71880242],\n", - " [14.59358497, 16.29312347]])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "pix_coord" ] @@ -506,37 +364,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This is a type Ia SN\n" - ] - }, - { - "data": { - "text/plain": [ - "(-50.0, 100.0)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "light_curve = lens_class.source.variability_class.kwargs_model\n", "\n", @@ -559,30 +389,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'High-resolution RGB image')" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "rgb_band_list = [\"i\", \"r\", \"g\"]\n", "\n", @@ -616,7 +425,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -631,23 +440,11 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Reading from database sqlite:///../data/OpSim_database/baseline_v3.0_10yrs.db\n", - "Read N = 2086079 observations in 41.74 seconds.\n", - "No host file.\n", - "Coordinate (-100.68318236082308 deg, 21.742694141247878 deg) is not in the LSST footprint. This entry is skipped.\n", - "Coordinate (108.83972614746231 deg, 49.133387519115274 deg) is not in the LSST footprint. This entry is skipped.\n" - ] - } - ], + "outputs": [], "source": [ "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(\n", " ra_points,\n", @@ -670,41 +467,11 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "images.keys() : ['bkg_noise', 'psf_kernel', 'obs_time', 'expo_time', 'zero_point', 'calexp_center', 'band', 'lens', 'injected_lens']\n", - " \n", - "64 observations\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Injected lens system')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "index = 0\n", "bands = [\"g\", \"r\", \"i\"]\n", @@ -737,7 +504,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": { "scrolled": false }, @@ -766,38 +533,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/6x/j1tbqdk91439t5vn1y800sb40000gn/T/ipykernel_22674/2729757473.py:4: RuntimeWarning: divide by zero encountered in log10\n", - " log_images.append(np.log10(images_opsim[i]))\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'log-scale image')" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "## Images in log scale\n", "log_images = []\n", @@ -813,22 +551,11 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": { "scrolled": false }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABccAAAb+CAYAAACc94jbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5hcZf028Hs2m55AICGkACK9CVJEBKQozQKIUkTkR1ewIVUQeVFRRBHEgiBKsaGIKCJIFSsWOkjvBAIBQnpPduf9I7qwkOw5gcnuJOfzuS6usDPfec5zZvfc+5zvnJ2p1ev1egAAAAAAoEJaenoCAAAAAADQ3TTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHJayxbu2LLX4pwHQIcb2i8rVSeXgO4il4BmI5eAZiOXgGZTJpdcOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOU0RXN8/1P2ynl3nNHT01hi7XTAdvnthIt7ehqwVJFLb4xcgsaTS2+MXILGk0tvjFyCxpNLjSWnqILWxb2BG9ov6/L+6y/+c7776QtyxXevWdxTed0+fMIHsvUeb8/K64zO7Jlzcv8/HsqPTvh5nnn42U51+5+yV9532A4ZtNygPPjvR/LdT/0oT93/TJdjb/3Bt+fAL384I1dfMc899nwu+sIvcvMVtyzO3YHKk0tyCZrN0pBLb3nnutnr2N2y1qarZeio5XPKHt/IP35362vqVllndA49/aPZcNv1Umup5an7ns6p+3wrLz49fqFjyyXofnJJLkGzWdJyaes9Ns++J34wo9YYkV69e+XZR8bl12f9Pjf+7K+d6oaOWj6Hnr5fNn/PxunTv0/GPvxczjz03Dxyx+MLHXu3T+yc3T+5S1ZcdXheGDM+l5x2eW786cvj7nTAdjnuok++5nHv7f+RzJ09t3E7CUuBxd4c33vkYR3/v90+W+aAL+2Tg9Y5suO22TPnZNb0WZk1fXHP5PXbcJv1c+X3r8tDtz6aXq29ctBX9s3p130hh65/VGbNmJ0k2ef43fOho96fbx50Tp55+Ll85KQP5evXn5yD1jkyM6fNWuC4626xVr7wy6Ny8f/7ZW7+7S3Zao/N84VLj8pR7zw5D97yaHfuIlSKXJJL0GyWhlzqN7BvHr/nqVx/8Z9yyuXHLbBm5Gor5lt/OzXXXHhTfvzFSzN98oyssu5KmTtrzkLHlUvQM+SSXIJms6Tl0pQJ03LJab/J0w+Ozdw587LF+zfNsRd+IpNemJzbrr87STJoyMCc/fdTc/ef7svn33taJr0wOaNWXzHTJi18J95/+E45+LSP5Fsf+0EeuvXRrLP5Gjnq/MMzbeL0/Ouq2zvqpk+e0en5SaIxDguw2JvjE5+f1PH/0yfPSL1e73RbMv/Kxq123zyHbzJ/wXLchZ/MwCED8tCtj2aPz7w3vfv2zuVnX5VLvvqbHPK1/bLLwe/K7Bmz8+NTLs11F/2pY5yho5bP4WcekE132jD19nru/fuD+f5nL8rzT734hvbh8+/9aqevv3nw9/PrFy7Impuulv/87YEkyR5Hvi+/OO03+ftv518tcMaB38uvxv0o7/rI1rn6/BsXOO4Hj3xfbr/hnvzy9CuSJL88/YpsuM36+eCR78tp+317ofPZ6YDtcsCX9skywwbntuvuzn03P9Dp/pGrrZjDzzwg626xZvoN7JcxDzyTCz5/Se7843+SJB89ec9ss+c78rGNjun0uHNu/Xpu+cMd+fEpl2bDbdfLYV/fP29af6W0zW3LU/c9ndP2+3ZeGLPwqydgSSGX5BI0m6Uhl2699q7ceu1dXdYc9JV9c8sf7syPPvezjtvGPfFCl4+RS9Az5NLCySXoGUtaLt3zl/s7ff3b7/whO/7ftll/63U6muP7fO4DefHpl/LNQ77fUVe0jR0+uk2uPv/G/OVX/0gyP7PW3WKt7HP8Bzo1xxf0/BSRU1RRU7zn+IK89V0bZOio5XP0tqfkvGN+nAO+uE++8vsTM23itHxmixNz1Q+uz5HnfiwrrDQ0SdK3f59886ZTMnP6rBy97Sk56p0nZ+a0WTntmpPS2nv+awAbbrtebmi/LCu+aYU3NLeByw5IkkydMC1JMuLNwzN05HId4ZYkc+fMyz1/uT/rvWPthY6z3jvWyu033N3pttuuvyvrbbnwx6yz+Ro55oIjcuW51+XwjY/L3X++Nx856UOdavoP6pdbrrkjx+94ao7Y5Ljcdv3dOfXKE7LCysOSJNdeeFNWWW+lrLXZ6h2PefNbVskaG6+a6y7+U1p6teRLvz0+9/z1/nx8o2Nz5JYn5eof3ph6veQTBEspubRgcgl6TjPn0qvVarW8/X2b5JlHns3Xrjkpvxr3o3znn6dly93f1uXj5BIsWeTSgskl6DnNkksbv2uDrLT2qPznry83nN+x62Z5+PbHcvKlR+dX436Uc2//Rt5z6Lu7HKd3396Z86q/bpk9c07W3nyN9Grt1XFb/0H98rMnvp9LxpyXU688Iau/ddUux5VTVFXTNsenTpiWcz5zYZ55+Nlcd9GfMubBsek7oE9+8bXfZuyj4/LLr12ReXPmZf2t5i9AtvvwVmlvr+esQ8/Nk/eOyZgHx+abB38/w1cZlo22Wy9JMnvGnIx5cGzmzW17Q3M7/MwD8p+/PZAn73s6SbL8iCFJkknPT+5UN/GFyR33LchyI4Zk4qsf8/zkLNfFY/b4zPty23V359KvX5GxjzyXK757TW67rvPC7PF7nsrV59+YJ+8dk7GPjsvFJ/8yzz3+fLbcbbMkyfixE3L7dXdl54O273jMzgdtn3v+cn/GPfFCBi4zIIOGDMy/r7o9zz3+fMY8ODY3/OQvXb7nHlSBXFowuQQ9p5lz6dWGDF82Awb3zz6f+0Buve6unLjzV3LzFbfklMuPzYbbrLfQx8klWLLIpQWTS9BzejKXBiwzIFdO+Wmumf2LfOWqE3POZy7MHTfe03H/yNWGZ9fDd8rYR5/Libt8JVf94Pp88tsHZ4f9t1nomLdff1fec8i7s+YmqyVJ1tp0texy0Pbp3ac1yw4bnCR5+sGxOeOgc/L/dv96TvvI2Zkza27O/vtXMnqNEQsdV05RVYv9bVVer6fueyb1V7x0NOn5yXnyvjEdX7e3t2fKS1MzZPiySeaHweg1RuTKKT/tNE6ffr0zcvURyQ335KFbH80h6312odvcYOt1ctofTur4+uzDf5CbLvl7p5pPf++QvHnDVXLUO09+zePrr3qpq1ZL8atfC3hMVw9aZd3Rr/mglwf+9XDetstbO77uN6BvPnrKXtnifZtm6Kjl0qu1V/r075MVVhnWUfOHH/0xx1xwRM47+sdpb2vPuz7yzpx/7E+SJFMnTst1F/0pX7v2pNx+wz2584//yV9+9Y9MGDepYGdg6SaXFkwuQc9p1lxakJaWWpLkn7+7Lb85++okyWN3P5n137F23v/xHXPPX+9f+IPlEiwx5NKCySXoOT2RS/8zc+rMHL7xcek/qF82fvcGOfzMA/Lc4893vOVKraUlD9/2WC486RdJksfuejJvWn/l7Hr4zp0+YPOVfnbq5VluxJB8559fTa1Wy8TnJ+f6H/85+xz/gbS3tSdJHvj3I3ng3490POa+mx/Kubd/I7t/+j35/pEXLXBcOUVVNW1zfN7ceZ2+rtfrr3lFrl6vp/bfBU2tpSUP3/54Tv/od14z1qQXp5Ta5sO3PZ7DN375g1pe/d5Mn/zOwdli181yzLanZPzYCR23/+8gXm7EkE4H9JAVlu3y/Z0mjpv0mqsLhgxf9jVXIbxSrVYr3I/Dztg/m+20Uc4/7qcZ++i4zJk5J//vsmPSu8/L3+5//v62zJ09L1vvsXnmzp6bPn1752+X/6vj/m8e8v389rt/yNt2eWu23XvLHHjqh3PCTqd2CleoGrm0YHIJek4z5tLCTB4/NfPmzstTDzzd6fYxDz6TDbZaZ6GPk0uwZJFLCyaXoOf0RC69ctxnHxuXZP6Lb6usu1L2PWGPjub4hOcmZswDz3R6zJgHxuadH9xioWPOmTUnZx5ybs7++PlZbsVlM+G5SXnvx3bI9CkzMnn81IXO46HbHs3oNUYudFw5RVU1bXN8UT1yx+PZdu8tM+mFyZkxdebrGmPOrDkdofVqn/ruIdnqA5vn2O1PybgnO39Ay7gnXshLz03MpjtumMfuejJJ0tq7NRtuu15+dMLPFjDafPf/8+FsusOGHVcpJMmmO26U+//x0EIf89T9z2Tdt6/Z6bZXf/2WrdfN9T/+c8crfv0G9suKq66Q/OXlmva29tzwkz9n5wO3z5zZc/OnS2/O7Jmd37PqsbuezGN3PZlfnn5Fvn3zV7P9R7YWVrAI5NLL5BI0h8WdS12ZN3deHrr1say81uhOt49ec1Sef2rhf0orl2DpJpdeJpegOTQilxaqVkvvvr07vrzv5oey0lqjOpWstNbIUh/82TavreMCqe332Sr/vuqO1/zl8CutvtGqeeLeMQu9X05RVU37nuOL6qaf/y1Txk/Jl644PhtsvU5GrDo8G26zXj5x9kEZNnr5JMnab1sjF9x/doaOWn6Rxv70OYfm3fu9M1/b79uZMXVWlltxSJZbcUj69OvTUfPbb1+dfU/8YLb6wOZZdf2Vc9xFn8zsGbM7/Tnf8Rd/Kgef9pGXH/Odq7PpThtln+N3z8prj8o+x++eTXZ4S37z7auzMFd89w/ZbJe3Zu/jdsvoNUdm90/uks1e8ScuSTL20XHZeo+3Z/WNVs1qG74pn//5kR2vgL7SNT/6Y976rg2y+Xs2znUX3tRx+4hVh+fg0z6SdbdYK8NXGZZNd9wwK601MmMeGLtIzxtUnVx6mVyC5rA4c6nfwH5ZfaNVs/pGqyaZ/8HAq2+0ascHNCXJZd+8Mtvus2Xec+i7M2r1Edn9k7vkHbtumivPva6jRi5Btcill8klaA6NyqUPn/CBbLLDhhnx5uFZee1R+dBR78+O+2+TP/785bdLufzsq7LuFmtm3xP3yKjVR2T7fbfOew/bIVd+/9qOmoNP+0iOv/hTHV+PXnNk3r3fOzN6jRFZ+21r5POXfDarbrByLjzpko6aj/6/PbPZTht15N4xFxyR1d+6aq4674aFzldOUVVLzZXjs2fOydHbnpJDT98vp1x+XAYM7pfxYyfkzpvuzYwp81/p6zugT1ZZZ3Rae/cqGK2z3Y7YOUly5p+/1On2Mw46J9f/+M9Jkku/8bv06d8nnz7n0AxebmAe/PejOWHnr2TmtFkd9cNXGZZ6+8uv4t3/z4fz1X3PzoGnfjgHfPnDee6xcfnqh7+VB295dKFzeeDfj+Ssw87L/31x7+x/yt6588b/5JKvXp79vrBnR815R1+cYy74RM6++SuZMn5qLv3GFRmwTP/XjDX20XG57x8PZZmhgzttc9aM2Vl57dHZ6dfbZvDQwZnw3MT87pxrc/UPFh6iwGvJJbkEzWZx5tJam62WM//0ciYdcdaBSZLrL/5zzjj4nCTJzVfckm8fcX72PWGPfPLbB+eZh57Nl/b8Zu67+cGOx8klqBa5JJeg2TQql/oN7JfPnHNohq00NLNnzsnTD47N6ft/N3/51T86ah6+7bF88YNn5JDT9stHT94z4554IecedXGnC5qGjlguw1/xnt69erVkz6N3zUprj0rb3Lbc9ad7c+RWX+h0tfmgIQPz2R98PMuNGJLpk2fksTufyNHbnpKHbpVT8Gq1eld/c/EKO7bstbjnQg+48IFv5+rzb8jl37qqp6cCHW5ov6xUnVxaOsklmpFcqja5RDOSS9Uml2hGcolXklM0gzK5tNRcOc6iGbLCMtlh/20ybPTyue6iP/X0dADkEtB05BLQbOQS0OzkFEsazfGKuuz5CzLpxSn51sd/kGmTpvf0dADkEtB05BLQbOQS0OzkFEsazfGK8mdMQLORS0CzkUtAs5FLQLOTUyxpWnp6AgAAAAAA0N00xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACqntacnAAANU6t137bq9e7bFgAAANBwrhwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAymnt6QnQYLVaY8ap17tvW41SZs5A92u2rGiU7tov2QYANNKStjazFgJgMXLlOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFROa09PgCZVq/X0DBZdd825Xu+e7UAzWBKzoEitQa8L19sbM06RRn0PZBcsmqUx/8qQFdC8yuRSmXVOd61hAMpyzkMPcuU4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVE5rT0+ARVSrFdzfmNc7ai0F22mgenu9sKbMfArHqbeXnRLQzWq9evX0FF6H4jl3Wy7Vi3MUKqVovdSw7SyB15kU5U6Z507mwKLrplwqd97UfdnVkPO4WC9Bj2hUbnXneqlRUVu0XpInS5UlcEUPAAAAAABvjOY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDmtPT0BXqFWK1HT9esZtZY3PkaSpMw4JdTK7FNbe2O21dL1OPX2Rr0WVGK+9XqDtgWvU5ljr2Hbap5cKpU5JdTLHMPtxTW1XkUbKp5vvcR2GpZLZZ4/+cbSoETmNCy7ymjQuittbYUljVkPWQtBJ41Yf3RjLtV6d+M6scx6qRHncfXGnFNCpRRlV3eulxq1Fipz7lQiL4pzp0GZY73UFFw5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJXT2tMTqIxarURN8WsVtZaCccqM0avEayItJWrK7FOJcWq92ovHaWsrLKnXu55PLSXGaK8Xz6WMMs9NvUHbgsWpm3IpRWMkqbV236+sEkdwuWO4vet8qxfHUmotxRlZZpxSuQRLggasqWq9ehWPUSaXyozToPVSmbVQqW21FWRKvUTmtJe5vqbE+s5aiCVBE53HNSyXytQUrGHmz6cx2VUvqCl3HieXoJNuWi+V6S/V+vV9w3Mprcw6Zs7c4nHmzisYpPj5Lco2mocrxwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByWnt6AkuFWq0xw7SUGKdXr4KpvPExkqTWu8SPRmuJmnq9uKa9RE1bW3HNvHldT6XEdmot7YU19fYSrynVi8eB161BmVNqU2Vyqdb1MVHrVeKYKZFLaSkep9and/E4ZTKnxDFcb2vAcd6IMZLC70ESucSSoUy+lfh5L8yuEtlW69OnuKZMvpVZL5XJwIJ1TpJkbomaOXO6vLteYsmVlCoqVub7XWYtCa9XN66pCjUql0plTjdeIzdn7hseokwK1ErkUqnzuJRYL8klelo3rZfK9IVqA/oX1/QvrqkP6FdYUyonZ5fInOkzimtmzOzy7vqs2cVj1MpkhcxpBq4cBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACqntacnUBm1xrwOUavVui7o1at4jD59ijfUp3fxOC0l9qlMTVtbYUm9rb14PsVbKt7O3HklqornW0rR9zJJ6vXGbIulS5mfizI/Xw3KpbQ0IJf69W3MXFqLf60V5mhKZk6tOC+KvlO19uLt1EtFTomiMt/vevF8YIlQkDu1MlnRt3i9VOtdvF5KiXFKrZdKrFHqc+YU1tQKMrs+c1bxGPUSOdouc6iOouMqSWNyqcw5WoPO9UopsV6ql1p/dL1iKrVeKrWudR4Hr1SUO6UyZ/Cgwpq5I4cU1sxcsV9hTVvf4mOv76Ti47zfM1MLa1rGT+zy/vYSfawySp3rlTsh5A1w5TgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUTmtPT4DGqvXqVVzUq/g1kVrv3sXjtJbYVkuJ11/a2ornM3tOYU29pVa8rQaoldhOvXiXknr9jU+GaqqV+Fmvdd9rn7Wi+ZTJgTJai39l1cpsq0RNmSyt19uLx6l3va363MIhUiuR2Skxl3q7zGHpUOb3cOEYJY7xUmuh/v0KS9oHFNfUyqwJSqy7yjwz9Xnzuh6jRNbWS6zdYIlQ5thrKXHOU0JD1ksljs/07VNYUu9dYpwS683avBLncWWe4/aux6m3F69z0lZiXVbmPK69Mesu6Gml1ksF66Fav+I1TNuQQYU1U1brX1jz0gbF820bVHzsDRxTvH5bYd7Awpr+02d2eX9tRtf3JyXXS2WWVGXO//WX3hBXjgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVoznO6zZq7sT8ZMz5GTV3Yk9PBSBJMmrepPxk3EUZNW9ST08FIEkyavaE/OyBb2fU7Ak9PRWAJMmoORPy08e/n1Fz5BLQHFYd/2L+ftqXs+r4F3t6KlRQa09PgFeoddNrFWW2U6sVlmw37cGs0DYt201/KJcs947XP5+WEvPp1au4pmi/SuxTWkrUtBWXQI+rtxeW1BpxXCXljuHC7RQfe7UyuTTrkazQPj3bzXoklyzz9gUXlZlvvV5cU+b5mzev6/tLzKU+t2AMYNGV+X1fIgfqJcbZfsp9WWHe1Gw/5b78fOS2C6xpby3OglqvEjk5Z25hTdpL5FvhhsrkvgUTS4Ay5welxnnja6FarxI5UGK+9dbi9cn2kx/KCvOmZbsZD+eSQe9c8DgNem5qcxr0HBdp1HlciTU0LFZljr1G9Y6KzkVKnO+09y9uK85avni++z3x74ycPDm7PnlLvrfp9gusWXHItMJxxk8bXlgzb1DxftV7F+xXmcxhiaE5ziJZdc6LWWPO/Ffydph6f5Lk3VPvywutyyRJHu0zPE/2XaHH5gdUz6pzx2eNueOTJDtMfyBJ8u7pD+aFXv/Npd4r5Mk+w3psfkD1vHn2C1l99gtJkh0n3p0k2WHCPXm+z5AkyWMDRuSJ/iv21PSACnplLu0w8T/z/510T17ovWyS5LH+K+aJfnIJ6D5rvvhs1n1xbJJkj7vvmv/vX+/K2GFDkiT3rzoyD71pRA/NjirRHGeR7Df5X9l65mNJkv9ddzRy3uQc8+K1SZK/D1gjXx2xew/NDqii/abemq1nP57kFbnUNjnHTLwhSfL3fqvnq8Pe10OzA6pov5f+ka2nP5LkFbk0Z2KOG/O7JMnfl10np662dw/NDqiiBefSpBw79vdJkr8PXjtfedOePTQ7oIqO+Pd12eGx+S/W/S+XVnl+Qs449zdJkms3Xy+fOnrfHpodVeI9x1kkZw3dOX8csE6Sl8Prf//eOGjdnDX8PT0yL6C6zhry7vyx31pJFpBL/dfOWcvv2CPzAqrrzBHvzR8Hr5dkAbm03FvyzTe5kADoXl3m0rIb5MyVdu2ReQHV9YWd9s3v1940yWtz6bfv3CifO+KDPTIvqkdznEUys6VPvjlslzzTOiT/e4elWpKney+XM4e/NzNb+vTk9IAKmtnSJ99cbsc80+tVudQ6JGcO3VkuAd1uZkufnDHifXmm93Kdc6nv0Jyx6h6Z2atvT04PqKCF5lKf5fPNlXeXS0C3m9GnX07aZb88OWSFTrn02MhhOe6Te2Z6f7lE99AcZ5ENnzclK82blFqSWbXW1JKsPHdiVpg3paenBlTU8HlTslLbq3Jp3qSsMG9qT08NqKjhcydnpbkT/5tLvefn0uyXssKcyT09NaCiOufSf9dLcybIJaDHjJwyIatOejG1JDP7zF8vrf7c+IwcP6mHZ0aVaI6zyNab/WyS5LJl35YPv+kTuWzZzZIk688a25PTAipsvbnjkiSXDdo0Hx55WC4btEmSZP05z/bktIAKW2/m/HXRr4Zvmb3fckx+NfwdSZINpo3pyWkBFdaRS8PekX3WPSqXDdsiSbL+jKd7clpAhW387BNJkh/sunU2P/+EnL/r1kmSzR58qienRcX4QE4W2d8HrJlH+gzP2P4rJEkuHLptrhv8loz77yedA3S3v/dbPY+ssELG9h2WJLlwyNa5buD6Gde6TA/PDKiqvw9eO4f2G5Gnlx+dJLlg9I65bujGea7vcj08M6Cq/pdLzwwekSS5YMS7c91yb81zfYb07MSAyrp+zY1y/4or5/73DkySfGO/nXPZ9pvk6eHL9/DMqBLNcRbZvFqvjO3dOajG9hFcQM+ZV+uVsa2dG05je2tAAT1nXq1XnnnV+uiZfsN6aDYAC8mlvkN7aDYAybxerXlyueFJpnfc9sSoFXpuQlSS5ngzqbcXl9RrXd7f9b3lt5N6vftq5rUV17SXmXNBTZm5tBfX1EvUlFIr8d0qM2dYkFo3vmtW0fHZq1fxGN35sz5vXnFNS4nnr61EdjXi+9BSIitKTAV6XJnfe92lzO/7ErlUayuxPplTInPai7OiNmtu8Thl1lRFrD2gZzQql2YXZ0W9RB7XWovXb7UymdOIc7BmO4+TkyxOpX6+Sqw/UuIcrOh8psT5Tsvs4nVO//HF853xxIDCmnFDij+gc/ALxfnWe0rxftXmdr1fDcsTmoL3HAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDKae3pCbCI2utd3l1vayscojavVlhTnzu3eJwS20pL8esv9XnziscpU1Pw3ECl1NtLlBQfn7WWEuPUu86UWnvxGCmRJ6WO8HpxVa1MLs0pzsAy2yrcrzLPjWxjaVHmmKmVWKOUOCZqtUasl0qsPUpkRa1MLpXY78wtnk991qzicQr2vcxzU+Z3TCllfiagp5X5eS9YCyXF66VSa5gy65MSeVJrKZE5M2cX15SYc5k1VeH5YJn1UqNyCXpamTVBCWXWS4VrghLril4vTS2sWebxXoU1vWf0K6xp61383PSZMqewpu+44jnXZ8zs+v4y66XuXFPxhrhyHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACqntacnUBn19hIlxa9V1HoVFLS1FW+npcR25swtHqewIklLrbimvcRIZfZr3ryu7y8xRpnvE/S4eoljplbi2GuUomO4zPFbYp9qrQ3KiuJRklpxThZlTpJkbtdZWma/y/3+aMw4sEQo87Nc7zoDSx2/c0pcQ1Lm2CuzFiqT2WXyYm7xftXnzOm6oMQ+NSxzGrXf0MPKHBO1WkFNwZph/nbK5F+JmrYGrQnKrFFmF2ROUrh+q5eYr7UQS43uPNcrOvZmzS4eY9r0wpLWZ4rP0Qa91Ld4WyX2uzavxPng1OI512fN6vr+EmvJUrlUhrXQYufKcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKic1p6eAK9Qby9RU+v67rbiIWqZW7yZtjIDdT2XJElLiddf2kvsd4n51NsKxinx/Nbb68VzKfN9KqNeYluwOJU6JoqP4VpL1+OUyaVSx0OZzCmzrTLKzKdEdtWLximROaVyCZYWDcqCouOmViYs5pZYL5WoSa9exTVL2HrJWoilRqPWH2XWVA1Yo5SYSUodVUU5kJTLnDLZVSqXCmoalTmwtCj1+7MB53rz5hWPMXVaYU1t9pzimumNaU+W6WXVy+xX0Thlemal1lTWQs3AleMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOa09PYGlQr1eXFOrNWZT7V1vq9bSXjzGvOKa1Eq8btLSmH0qpWC/kyT1rver6LkrM0ZpZX4mYHFqVC6VOCbq7V3nRZlcSsEYSVKfN6+wptaorC3z/JXJlMINNSpzGjQOLC0K1wQl1jklMqeUtm48PktldkF2WQtBj6i3tTVmoEZlTqPO9ZzHQc8o9bP8xtdLtRRnV33mzOKaXr0Ka0ppxDlaSmSy86+liivHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMpp7ekJVEa9XlxTq5UYp73ru9tKzKVW/JpIraXr7SRJymyrQertJZ6/7lLmewl0KHP8lsmc+twSx15LiRxtkIbkUkGmN5TsYmnRiDVViWOv1JqqjFqTHXvdmTuwNGjY7883fuw1LJfKaNC2aiXWZoVrqkbllrUQdFZ4TDRovVSiB5X2eSUGahBrIV7FleMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojlN5o+tTc0nblRldn9rTUwFI8t9car9KLgFNQy4BzUYuAc1GLi2ZNMepvO3rT2WFzMz29TE9PRWAJMn2GTM/l/J0T08FIIlcApqPXAKajVxaMrX29ASgJ7y5Pilr1CcmSXasP/nff5/I8+mfJHk0Q/JEbUgPzQ6oojfXJ2WNTEqS7Fh/6r//PpnnMyCJXAK6n1wCmo1cApqNXFryaY5TSfu335t3ZmySpP7f20Zmeo6v35ok+VtG58u1LXtodkAV7V+/Xy4BTUUuAc1GLgHNRi4t+bytCpV0Rsvbc2PelOTl8PrfvzfkTTmj9rYemRdQXWfU3pYbs0oSuQQ0B7kENBu5BDQbubTkc+X4kqZe7/r+Wq3EGO3FJW0l51OkVuL1lxLzabSZ6ZWvt2yetdtfykqZliSpJRmTQfnG/4Kr6LmGJV3Dfsbf+DFcKnNK5Em9vcmO20XIt5m13vl67e1Zu32CXII3qhHHSpk1VRk9sM7p0iKsJeUSNFA3ncc1m4acV77iuZuZ1ny9tnnWrsslWOwadSyVCYJSGdig+TRqjfdf1ktLPleOU1nD69OzcqallmRWeqWWZJVMywr1GT09NaCi5BLQbOQS0GzkEtBs5NKSTXOcylo/LyVJLs3a2au2Wy7N2kmSDTK+J6cFVJhcApqNXAKazcu5tFb2yq65NGslkUtAz7FeWrLV6vVy1/bv2LLX4p4Ljfgzkgb/ecgb1qRvq5IkrfX2jMj0PFMb3HHbSu1T8lwGpq3MvFlsbmi/rFSdXGoS3ZU7S+JxuYj5Jpeal1yqoGZbUzXKIq4l5VLzkktLmaU1cxrhVbm1wFyqT5VLTUAu8botwW+rklgvNbMyueQ9x6msebWWPJPBnW57ZZABdDe5BDQbuQQ0G7kENBu5tGTz8gUAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI4P5Gwmjfjk3TJjdOcnodfbGzROgz6VGGi8ouOzUZnTqDwBKKOqa4+q7jf0tEYde2XWXY06Z+zOOQNLt+5cf1jr8CquHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDKae3pCdAD6vWenkFntVpPzwBYnMpkTpkcaNQ4ZTRbTgIAlNGoNUx3roWsuwDoQa4cBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMpp7ekJQOr1np4B0NMalQPyBAAAACjJleMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUTiWa49+86Ys54lsH9vQ0ADrIJaDZyCWg2cgloNnIJVj6tHbHRo678JPZ6cDtOr6e8tLUPHTrY/nh536aJ/4zpjumANCJXAKajVwCmo1cApqNXAIarduuHL/lmjuz98jDsvfIw3L8Dl9O27y2fOX3J3bX5t+w1t7d8joC0I3kEtBs5BLQbOQS0GzkEtBI3XZEzp09NxOfn5Qkmfj8pFz6jSvyrb+emmWHLZPJ46ckSQ49fb9s9YHNM2yloZk4blL+eMnf8rMv/zpt89qSJPufsle22n3z/Pqs3+eAL++TwcsNyi3X3Jlvfey8zJw2K0nSb0DffOb7h2XrD749M6bOzK/PvPJ1zfenj5+Tay74Y0avPjJb7bF5br7ilpxx0Dlv/IkAmoZcApqNXAKajVwCmo1cAhqpR95zvN/Afnn3fu/M2Eeey5SXpnbcPmPqzJxx0Dk5dP2j8v3PXpT3HrpDPnTU+zo9duTqK2bL3d+Wk3c9PV/Y9WvZcNv18uET9ui4/7Az9s9G26+fL37wjJyw81ey4bbrZ81NV+s0xv6n7JWfPl4cRHsfu3ueuG9MPrHZ5/Lzr1z+BvcaaGZyCWg2cgloNnIJaDZyCXijuu3K8S3ev2munPLTJEn/Qf3y0rMT8oVdT0+9Xu+oueSrv+n4/+efejG/Puv32W7vLfOrM15+da7WUssZB53T8UrejT/7azZ+1wa5KPNDcZeD35VvHPC93HHjPUmSMw48J5c8fV6nuUwZPzXPPfZ84ZzvvOne/PrM37/ufQaam1wCmo1cApqNXAKajVwCGqnbmuN3/em+fOcTP0ySDF5+UHY7Yuec9ofP51NvPzEvjBmfJHnnh7bIB498X0atMSL9B/VLr9aWTJ8ys9M4zz/5YkdwJcmE5yZmyPBlkySjVl8xffr2zv3/fLjj/qkTp+WZh57tNMbvzrk2vzvn2sI5P3L7Y69vZ4ElglwCmo1cApqNXAKajVwCGqnb3lZl1vRZefaxcXn2sXF56NZHc+ah56bfwH5572E7JEnWffuaOekXn82t196Zk3f9Wo7Y5Lhcctpv0rtP5/5929y2Tl/X6/XUWmpJklqt1tA5z5w+q7gIWGLJJaDZyCWg2cgloNnIJaCReuQ9x5P5odPe3p6+/fskSdbfau08/9SLueS03+Th2x/P2EfHZcU3rbBIY459dFzmzpmXdbdYs+O2QUMGZvRaIxs6d2DpJJeAZiOXgGYjl4BmI5eAN6Lb3lald9/eWW7FIUmSwcsNzO6f2iX9B/XLP39/W5L5wTN8lWHZbp8t89Ctj+Xt79skW31g80Xaxqzps3LthTflY9/YP1NfmpqJz0/OQV/ZN/X2eqe63T+5S7b6wOY5fscvN2TfgCWTXAKajVwCmo1cApqNXAIaqdua45u/Z+P86rn57wk1fcqMPP3gszl177Nyz1/uT5L888rbcvnZV+dT3z0kvfv2zr+vviM/+8qv83+n7L1I2zn/uJ+m/8B++dLvPpeZU2fl12f9PgOXHdCpZplhgzNy9RUbs2PAEksuAc1GLgHNRi4BzUYuAY1Uq7/y43y7sGPLXot7LgBJkhvaLytVJ5eA7iKXgGYjl4BmI5eAZlMml3rsPccBAAAAAKCnaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJVTq9fr9Z6eBAAAAAAAdCdXjgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDmtZQt3bNlrcc4DoMMN7ZeVqpNLQHeRS0CzkUtAs5FLQLMpk0uuHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqJymaI7vf8peOe+OM3p6GkuNnQ7YLr+dcHFPTwOWaHKpseQSvHFyqbHkErxxcqmx5BK8cXKpvA23XS83tF+WgcsO6OmpQI9qXdwbuKH9si7vv/7iP+e7n74gV3z3msU9lVK23mPz7HviBzNqjRHp1btXnn1kXH591u9z48/+2qlu6Kjlc+jp+2Xz92ycPv37ZOzDz+XMQ8/NI3c8vtCxd/vEztn9k7tkxVWH54Ux43PJaZfnxp92HnfgsgNy8Ff3zVZ7vD2DlxuYcU+8kB8c+5Pccs2di2V/oYqWtFx6pe322TIn/eKo3HzFLfniB19e9L3lnetmr2N3y1qbrpaho5bPKXt8I//43a2F4xXl0pvWWykHfGmfrLnpahmx6vB8/6iL8ttv/2Gx7BtUmVx6WZn1UtG2gTduacyl/U/ZK/93yt6daieMm5R9Rh3W5XjWS9AclsRcKtPj2fWInbLXsbtn6MghefK+Z3LuURfl3r8/2OW4i7JeArq22Jvje498eaGx3T5b5oAv7ZOD1jmy47bZM+dk1vRZmTV9cc+knCkTpuWS036Tpx8cm7lz5mWL92+aYy/8RCa9MDm3XX93kmTQkIE5+++n5u4/3ZfPv/e0THphckatvmKmTVr4Trz/8J1y8Gkfybc+9oM8dOujWWfzNXLU+Ydn2sTp+ddVtydJWnu35uvXn5xJL0zJqXudmRefeSkrrDwsM6fO7JZ9h6pY0nLpf4avMiwfO+P/cs9f73/Nff0G9s3j9zyV6y/+U065/LhS45XJpb4D+ua5J17IX3/9zxx+1oGN3B3gFeTSfGVyqcy2gTduacylJHni3jH53I6ndnzd3tbe5XjWS9A8lrRcKtPj2XbvLXPEtw7Kdz/5w9x380N538d3zGl/OCmHrH9UXnx6/ALHXZT1ElBssTfHJz4/qeP/p0+ekXq93um2ZP4r+FvtvnkO32T+idNxF34yA4cMyEO3Ppo9PvPe9O7bO5effVUu+epvcsjX9ssuB78rs2fMzo9PuTTXXfSnjnGGjlo+h595QDbdacPU2+u59+8P5vufvSjPP/Vi6fne85fOi6jffucP2fH/ts36W6/T0Rzf53MfyItPv5RvHvL9jrqibezw0W1y9fk35i+/+keSZNwTL2TdLdbKPsd/oCO8djl4+wxeflCO3OoLaZvXliR5YcyCw/CVdjpguxzwpX2yzLDBue26u3PfzQ90un/kaivm8DMPyLpbrJl+A/tlzAPP5ILPX5I7//ifJMlHT94z2+z5jnxso2M6Pe6cW7+eW/5wR358yqXZcNv1ctjX98+b1l8pbXPb8tR9T+e0/b5dan7QbJa0XEqSlpaWnPizI/OTL/4qb9l63Qwc0vlP32699q7ceu1dizRmmVx6+LbH8vBtjyVJDvnafqXHlkuwaOTSfGVyqcy2F0QuwaJZGnMpSdrntb9mP7pivQTNY0nLpTI9ng8d9f5ce+FNueaCm5Ik5x51cTbbaaPsesROufDzlyxw3LLrpVfb/D0b54hvHZgVVh6WB/71cG74yV863T94+UH59HcPyQbvXDeDlx+U5x57Pr/42m/yp1/ePH+7+2+TI846MB8e/bHMnTOv43H/77JjMmv67HzjwO9ltQ3flCO+dWDW2mz11Ov1jH1kXL59+A/y8O0Lf5cF6GlN8Z7jC/LWd22QoaOWz9HbnpLzjvlxDvjiPvnK70/MtInT8pktTsxVP7g+R577sayw0tAkSd/+ffLNm07JzOmzcvS2p+Sod56cmdNm5bRrTkpr7/mvAfzv/ZRWfNMKpeex8bs2yEprj8p//vryQuUdu26Wh29/LCdfenR+Ne5HOff2b+Q9h767y3F69+2dObPmdLpt9sw5WXvzNdKrtVfHuPf/8+F8+pxD86vnfpjz7zkz+564R1paFv5tWmfzNXLMBUfkynOvy+EbH5e7/3xvPnLShzrV9B/UL7dcc0eO3/HUHLHJcbnt+rtz6pUnZIWVhyVJrr3wpqyy3kpZa7PVOx7z5reskjU2XjXXXfyntPRqyZd+e3zu+ev9+fhGx+bILU/K1T+8MfV6uecQlhY9mUsf/X97ZtKLU3LthTc1bH/K5NLrIZeg+1Q1lxZ123IJuk+z59KoNUfkl8/8ID957Jx8/pLPZsSbh3c5pvUSLPl6KpeKejytvVuz1qar5fb/Xoj5P7ffcE/Wf8faCx339eTSCisNzSmXH5tbrrkzh298XK654I+veTGvT78+efiOx3PyrqfnsLccnat/eEM+95NPZ53N10iS/PWyf6WlV0vesdtmHY9ZZujgvP39m+a6i+e/sHDCzz6T8c9MyKc2PyGf3OxzufTrv828uW0L3RdoBk3bHJ86YVrO+cyFeebhZ3PdRX/KmAfHpu+APvnF136bsY+Oyy+/dkXmzZmX9beaHxjbfXirtLfXc9ah5+bJe8dkzINj882Dv5/hqwzLRtutlySZPWNOxjw4tvDAHLDMgFw55ae5ZvYv8pWrTsw5n7kwd9x4T8f9I1cbnl0P3yljH30uJ+7ylVz1g+vzyW8fnB3232ahY95+/V15zyHvzpqbrJYkWWvT1bLLQdund5/WLDtscJJkxGorZps9t0hLr5ac9L6v5ZKvXp49j941Hznpgwsdd4/PvC+3XXd3Lv36FRn7yHO54rvX5LbrOgfr4/c8lavPvzFP3jsmYx8dl4tP/mWee/z5bPnfQBs/dkJuv+6u7HzQ9h2P2fmg7XPPX+7PuCdeyMBlBmTQkIH591W357nHn8+YB8fmhp/8ZaF/4gNLq57KpfW3XDu7HPyufOtj5zV0f8rk0ushl6D7VDGXXs+25RJ0n2bOpQf//Ui+ccD3csIuX823PnZelh8xJN+++asZvPyghT7GegmWfD2VS0U9nmWHDU6v1l6vufp94vOTstyIIQsd9/Xk0q5H7JTnHn8h5x51cZ55+NncdMnfc/2P/9yp5qVnJ+TXZ/4+j939ZMY98UJ+971rc9t1d2ebvd6RJJkza05u+sXfs/OBL2fOu/d7Z8Y/81Lu/vN9Sea/tdUdf7wnTz/0bMY+Oi5//fW/8vg9Ty10X6AZLPa3VXm9nrrvmdRf8ZL2pOcn58n7xnR83d7enikvTc2Q4csmmR8Go9cYkSun/LTTOH369c7I1UckN9yTh259NIes99nCbc+cOjOHb3xc+g/ql43fvUEOP/OAPPf48x1vuVJracnDtz2WC0/6RZLksbuezJvWXzm7Hr7zQj8A4WenXp7lRgzJd/751dRqtUx8fnKu//Gfs8/xH+h4n7uWllomvTAlZ3/sB2lvb88jdzyeoaOWz17H7pafnfrrBY67yrqjc/MVt3S67YF/PZy37fLWjq/7Deibj56yV7Z436YZOmq59GrtlT79+2SFVYZ11PzhR3/MMRcckfOO/nHa29rzro+8M+cf+5MkydSJ03LdRX/K1649KbffcE/u/ON/8pdf/SMTxk0qfC5hadITudR/UL987qefybc+dl6mvDS1oftTJpdeD7kE3adqufR6ty2XoPs0cy698q2enrw3eeCfD+fHj34vOx2wXS7/1lULfIz1Eiz5eqq/VLbH8+q/5qjVap3m+2qvJ5dWXmelPPDvhzvddv8/H3rVfFvy4RM+kG333jLDRi+f3n17p3ff1syaPquj5g8/vDHn3HJ6ho5aPi89OyE7H7h9pyb75d+6Kkf/8PDs8NFtcscf/5O/XvbPPPf4810+T9DTmrY5Pm/uvE5f1+v117wiV6/XU2upJflvw/r2x3P6R7/zmrEmvThlkbZdr9fz7GPjkiSP3f1kVll3pex7wh4dzfEJz03MmAee6fSYMQ+MzTs/uMVCx5wza07OPOTcnP3x87PcistmwnOT8t6P7ZDpU2Zk8vip/x13UubNnZf29pfDbMwDz2ToyOXS2rv1Nc9JMj80ixx2xv7ZbKeNcv5xP83YR8dlzsw5+X+XHZPefV7+9v/z97dl7ux52XqPzTN39tz06ds7f7v8Xx33f/OQ7+e33/1D3rbLW7Pt3lvmwFM/nBN2OjUP/PuRwu3D0qIncmnU6iMy8s3Dc+qVJ3Tc9r/xr53zyxy0zpGve7FRJpdeD7kE3adqubTahm96XduWS9B9lqRcmjVjdp74z5iMXnPkQse2XoIlX0/1l4p6PJPHT03bvLYs/6qrxIcMXzaTnp+80HFfTy6ViJzsecz788HPvi/nHnVxnvjPmMyaPjtHfOvAtL4icx6768k8dvdT2fH/tslt192dVd+ySk7e7fSO+3/6pcty0yV/z9vft0k232Xj/N8X985p+579mhcDoZk0bXN8UT1yx+PZdu8tM+mFyZnxik/+bYhaLb379u748r6bH8pKa43qVLLSWiNLfTBD27y2jB87IUmy/T5b5d9X3dHxiuB9/3gw2++7dadXCVdaa1ReenbCAhvjSfLU/c9k3bev2em2V3/9lq3XzfU//nNHGPUb2C8rrrpC8orPXmhva88NP/lzdj5w+8yZPTd/uvTmzJ7Z+T2sHrvryTx215P55elX5Ns3fzXbf2RriyroQiNyacyDY3PYW47udNuBp344Awb3z/c/e1FefPqlNzzPrnLp9ZBL0LyW9Fx6vduWS9C8ejKXevdpzSrrjs69f39ggfe/kvUSVEej+ktlejwP3/54Ntlxw07N40122DD/uPLWwvEXJZfGPPBMttx98063rbvFWp2+3mDrdfOPK2/LH3/+tyTzX8QbvebI11wces0Ff8yHPvu+DBs9NHfeeE9efKZzxo595Ln85uyr85uzr87nf35kdj5we81xmlrTvuf4orrp53/LlPFT8qUrjs8GW6+TEasOz4bbrJdPnH1Qho1ePkmy9tvWyAX3n52ho5Zf6DgfPuED2WSHDTPizcOz8tqj8qGj3p8d998mf/z5y2+XcvnZV2XdLdbMvifukVGrj8j2+26d9x62Q678/rUdNQef9pEcf/GnOr4evebIvHu/d2b0GiOy9tvWyOcv+WxW3WDlXHjSy58+/Ptzr88yQwfnE98+KKPXHJnN37tJ9j1xj1z5/esWOt8rvvuHbLbLW7P3cbtl9Jojs/snd8lmr/hTvCQZ++i4bL3H27P6RqtmtQ3flM///MiOV0Rf6Zof/TFvfdcG2fw9G+e6V3yIzYhVh+fg0z6SdbdYK8NXGZZNd9wwK601MmMeGLvQeQGNyaW5s+fmyfue7vTf9EkzMmPqzDx539Mdi6p+A/tl9Y1WzeobrZokGfHm4Vl9o1U7PrApeX251Nq7tWPc3n1aM2z00Ky+0aoZtfqIhe63XILmtaTnUtltv5pcgubVnbn0sTP2z4bbrJcRqw7POpuvkZMvOyYDlunf6S0BrJeARvWXyvR4Lv/WVXnPIe/Ozgdtn1XWGZ3Dzzogw1cZlqvOu76j5vXk0mvmct4NGbn6ivn4mQdkpbVGZft9t85OB2zXqebZx8Zl0x02zHrvWCurrDM6n/3Bx15zVfv/np+ho5fPew59d6696E8dt/fp1yef+u4h2XDb9TJ8lWFZf8u1s9bb1siYB595zRjQTJaaK8dnz5yTo7c9JYeevl9Oufy4DBjcL+PHTsidN92bGVPmv9LXd0CfrLLO6LT2Xvinivcb2C+fOefQDFtpaGbPnJOnHxyb0/f/bv7yq3901Dx822P54gfPyCGn7ZePnrxnxj0x/0MNbrrk7x01Q0csl+GveC+4Xr1asufRu2altUelbW5b7vrTvTlyqy90utr8xWdeygk7fyVHnHVAzr/7mxk/dkJ++50/5NKv/26h833g34/krMPOy/99ce/sf8reufPG/+SSr16e/b6wZ0fNeUdfnGMu+ETOvvkrmTJ+ai79xhUZsEz/14w19tFxue8fD2WZoYPz4C2Pdtw+a8bsrLz26Oz0620zeOjgTHhuYn53zrW5+gc3LHReQONyqYy1NlstZ/7pSx1fH3HWgUmS6y/+c844+Jwkry+Xho5aLufdeUbH13sfu1v2Pna33P3n+3Lsu764wLnIJWheS0MuvR5yCZpXd+bSsNFD8/lLjswyw5bJ5Ben5IF/PZzPvOOkvDDm5Q+otF4CGpVLZXo8f/nVP7LM0EH56Ml7ZvmRy+XJe5/OSe877Q3n0mvm8vT4fHnPb+aIsw7MbkfslAdveTQXnXRJjr3wkx01Pz/18oxYdXi+du0XMnvG7Fz9wxtz8xW3ZOCyAzqNNWPqzPz98n/n7e/bJP94xRXh7W3tWWb5Qfncjz+dISsumynjp+bvv/13fnzKr0o869BzavWSfwu2Y8tei3suNIELH/h2rj7/hoV+IA10hxvaLytVJ5eqQS7RDOQSrySXaAZyiVeSSzQDuVQdp193csY8+Ey+f+RFPT0V6FKZXFpqrhznjRmywjLZYf9tMmz08rnuFX8WA9BT5BLQbOQS0GzkEtCdBi83KJvutGHe+q4N8r1PX9DT04GG0BwnSXLZ8xdk0otT8q2P/yDTJk3v6ekAyCWg6cgloNnIJaA7ff/2r2fwcoPyoxN+lmcefranpwMNoTlOEn/WBDQfuQQ0G7kENBu5BHSn/Vf7ZHERLGFaenoCAAAAAADQ3TTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMpp7ekJAAAAAAVqtZ6eQc+o13t6BgAsxVw5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJXT2tMTYClXqxXX1OvdNw7QnMoc40sjuQVLtu7MLuslWLI1Ii9qjbm2rdZSPJd6ezNlRXtxiYyE5rUknuvJgkpx5TgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUTmtPT4AeUKs1aJxGvbbS3phhivarXm/MdoDOGpUphdtpTObUWornW2/vrrwokX+yCxqv6dZCZbbVqIEKckfmQGfdlBdl1iel9OrVkGFqjRkmKbOmqnedS/X2MlnboHNKqJJG5Fs3nqM1SqlzvaLpFOTW/BprqiWFK8cBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgclp7egIsolqt4P7GvN5R69WruKilYC6N1NZWWFJvrxdUtBdvp140BlRMUeaUGaJMnpTJrhKZUysz35bibdXai/OiXiYvCrKr3l4ms2UXLLIGrJdqZdY53ZhdjcicpEzulMicMuQSS4IGrHPmj9OATCmxXiq3piqROY061ys8/0rq8+aVGKcgd9pKrMuK4y+pl8i3Mj8T8o0lQZmf5Qb0jxqVJ6XGKaFeYi1UK7Mp53GV4spxAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqJzWnp4Ar1Crlajp+vWMWq9exUP0KvGaSO/exeP0Ka4ppa2tsKQ+d17xOHPmdj1G8WaStBeX1OtlBoLqKMillMml1uJfR7U+fYrn0o25lNlzimvmdp1LaSvOHNkFr9KI9VJL8RhlMqdMdpXJwDJK7HXqc0rk0ryCNVWZdVmZjCzzfZJLLAmK1jkplylFWVDqPK5v3xI1JdZLZbKrzDFclCdJMq/Mmmp21/eXybYSSq2p6iXWVNDTyhyfZYYpyq7uPI8rk0tl1m/tJdYWRZmTEmsq53FLFVeOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOW09vQEeIVa8WsVtZZa1/f3KjHGwAHFNYMGFtbUB/YvrmktMZ9ZcwtrWqZOL97W9Bld3t8+c1bxGG2FJUnai0vq9TIDQc+qdZ0n82tKHMO9enV5f0vfvsXb6d+vuGaZQYUl9QHF2yqTSy0zy+RS15mTJPWpU7sumDW7cIzUizOnVHaV+X7LLnpaN+VSrXfxErhWIpdqA4rXVPUBJfKttev5JklmzyksaZlWIpdmzOzy/vbZJXKpvURWlMguWBIUnX/9t6i4pLXr3Kn1K17DlMqcwcU17f17F9akpcQ+zZlXXDO9+BysNr1EBhaol8iuWr34e1nufBCWACVyKUXrpT59CodoKdFfqg8u018qXi816jyuNqW4v5RpBTUzu15PJSl3Htde4vskmBY7V44DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAldPa0xOojFqtMeP06tX1Zvr3Lx5j6HKFJbNHL1tYM/nNfQtr5g0o3u+B49oKawY90a+wpuWZ9i7vr82bVzhG6l2PkST14umW+37X6yUGgtepzM9grfj10VpL8Ti13gW/SvoWZ0WWL86cWaOXKayZNrpPYU1bien0f6k4CwY+XTxQa8HzV2+bVDyZtuK5pFYiT0rkGywtar26zrdaiVyqLVucOXNHDimsmbliifVSv+Ks7TeheAHS/+kphTVFW6q1lVjolKgptV6CxalBa6FSmyrInPk1b/w8rn3ZQYU1c1cYUFgza/nehTVtfYqfv76Tiw/0vuOLWw6t7QXrmLlzC8coc65XL9pOUm5NlRJrKud6vF4N6h2VOo8ryqV+xX2YeonzuJkrF6+ppo8skUslzuMGvFh8fA54pvicsfW5goIyvaOZJXKgvUSfSn9psXPlOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFROa09PgJfVWmrFNa1df8tq/foWjjF3hcGFNS++tV9hTa/tXyqsWXfoC4U1/7pzrcKa0W2DCmsGT57R5f21mbMKx6i3tRXWpL1eXFNvL66BJUGtxGuovXp1PUSJXJozrPgYn7Rmn8KaiZvMK6zpPWhOYc20xwYU1rS09S+sGTR5Zpf31/r0Lhwjc+cW15TInHqJeIMlQa0gc5IkLV1nV61vcZ60LV+cS1NWLV4vTdigeH03b3DxMTzwyeK8WGFe8Zz7z5zd5f21WSXWS/OKs7bUeikl1kv1MuPAYlRmLVSQOUmSot/5JdYEbcsWZ86M4cX5NmPF4vm2FW8qcweUOH9tK14H9pre9dqsNqPr9VSSpOA8OSl5rme9xJKgTC414jxuQHEQzF2u+LypzHncpI2Kz3laBxbXTH2y+BxtxXrxnAcXnMdlZolcYonhynEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEc53Vb5dkJue7A72SVZyf09FQAkiSrPj8+/zrutKz6/PiengpAkuRN41/M3077ct40/sWengpAkmSViS/m+gu+lFUmyiWgOTiPoydpjvO6vecv92bFl6Zml7/c19NTAUiS7P7vOzNy4uTsdstdPT0VgCTJbnfdkZFTJmfXu+7s6akAJEne+9AdGTFtct7z8B09PRWAJM7j6FmtPT0BGqy1+Fs6r3+vwpoZI+oLvH3t557N+mPHJkk++o9b5v/7t3/nLRvOv23CugMycZ2BHfX7Dn6+cFvbTV2usGbW7SsW1gzuXbDvvYr3G1h0tVqt64LW4mOvvU/xa7Wzhi54O2s9/2zWGzc/g/a+5dYkyT633Jppq/dJkjy0xop59M3DX65f7oXCbf1t2tqFNXMHFO9XvW/XuVRraUwu1dsXnNnQVIqyIklqDbpuo2hbJdYE7X2Ka2Yvt+D5rjn+2azz4vxc+sDd83Npj3tuzdNvHpwkue9NI/PgKiM76ocOnVa4rUnThxbWzB1cvA7s18u1MdCM6iWOzXprcY7OGbTgmjVfejZrvzQ/l3Z96Nb//ntbnl5h+STJ/SNG5+EVR3XUt/UvXlu0zC6eT1u/EvvVq+txat14HldrKd6neluZgUr8zqtbv9GzakW5U+LYK9Nfmj1kwbcv9Dxujd5JkodXXzGPrvbyedw6Jc7j/jyjxHncwOL1Ur1f7y7vr5VYs5bKrrbiQKm3l1i7lQomFkZznEXymRuuzy73/idJ8r9f5YOfnp13nvBYkuTJHZfLn79XHEYAjfKpv16XnR7snEujn5uUU866Okly05Zr5YSTP9hDswOq6PB/X5cdHu+cS6u8MCFn/vDXSZJrNls/R3xmvx6aHVBFH7vz+rz7yc65tPLEl3L673+RJLl+7bfkM3sd1EOzA6pooedxZ/4hSfKnrdbKCSfv0UOzo0pcOsIiOX7vD+e3G2+ywPse3X1Y/n76Gt08I6DqTtxt3/zuLZsmeXlR9b9/r37X+vnyMe/rkXkB1XXyjvvmqrUXnEuXb/XWHHvYnj0yL6C6Ttnmw7l69fnnca/OpSvesmlO3G3fHpkXUF1dncf94d3r58vHvLdH5kX1aI6zSKb365dj990vjw9bodPtk9/cL3//xhqZN8hblwDda3rffvncB/bLE8uvkP/9AWstyZMrLZ8vHbdrZgzo25PTAypoRp9+OWmn/fLkkM659NiIYTnm43tnen+5BHSvGX365eTt98uTy3bOpceHrpATdt8v0/v268npARXU9Xnc+53H0W00x1lkoyZOyGrjX0wtybx+LaklWfaJWRn47OyenhpQUaMmTcibJ8zPpZl9W1NLsuozE7LiC5N7empARY2cMiGrTpqfSzP69E4tyerjxmfU+Ek9PDOgqkZOnZBVJ/93vdQ6P5dWe+nFjJw8saenBlTUws/jpvT01KgQzXEW2aZPPpkk+c+hI/PLf26a/xwy/wOlht8+tQdnBVTZJk8/kST5yZ5vz86//Ex+uufbkyRvve+ZnpwWUGFvfW5+Lp33vm2y6Tkn5bz3vjNJstnDT/bgrIAq2+j5J5MkP3zH9tny6C/nR+/YPkmy6dOP9+CsgCrrOI/b6+3Z5dJP56d7bp4k2ch5HN3IB3KyyK59y4bZYfRK+ehhf0mS3H78m/LInsMzdWV/8gL0jOvW2yj3jVw5L+02/+vvHrJ9frfzhhk7YkiPzguorhvW2Cj3D1859+y0TJLk9A+/J7/adrOMWWH5Hp4ZUFU3vnnDPDBspTywzopJkm++e9dc/ta35+khQ3t4ZkBV/e88bsLu899t/HuHbp8rd94wY0cO6dmJUSmuHGeRzW1tzRPDh3e6bcpq/VPv7ccJ6Blze7XmiWGdc2nMSkPT1upzEICeMa9Xa55arnMuPT5yhcyTS0APmderNU8N6ZxLTwwdnnm95BLQMxZ4Hrey8zi6l24mAAAAAACV421VljT1etf3z51bOETvacU1A54rfouUbz20Q2HNlcuPL6x57pEVCmtWmtBWWJN5BTVtJcZoL3h+yyr6PkEzqLeXKCp+xb5e8PNeKzo2k/SaOa+wpt9LfQprnh9T/HYFL4xfprCm73PFvx77TC3er9rcgpp5xfsNS40yvxtri38aSUqtCVpK5VJxjs4YU7ymmjChON8GjSt+cvpMLp5zUSbXy6yFGrVegsWpUZlTar1UZpyC9VJb8XZqc4tr+kwv3u+504p3vNfs4preM4q31WtWif1qKxinvXiMovVoWaUyEJYWRT/vc4vXFb1mFx+f/cYXH1fjnix+e6cXJw4urOk7tnhN1WdaifXSrIK+WZnfDSWyq5RG/R5ioVw5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJXT2tMT4GX19npxUVtb12PMmlU4ROsLUwprVri7+Edj6oTlCmue6F9cM2p8e2HNwCenFtbUpk7v8v72efMKx0i9eC6lamq1EuOU+H5DTyvz8z53btdDzJpdOETrxBmFNcs9XJxLfab0Lqxp69u3sKb/hK6zNkn6P9t15iRJbUrXNfWCTJ9fU+J7AEuLEplTLz5sknld/x6uz55TOESvSdMKawY/VZxLvWcUZ05bn+J1Q9+JxVna9/niOWdm12vFMrlU6ncD9LRS6/EyP8u9ikvaS4xTdGyVyKXWycXnegPGFc+31+zi9VJ7iU5B7+nF+913QnF21WZ2XVMvWGsmKX5+k6TM+XajONejp5VZUxX1SOYU51Lv8cVrjyGPF+dS7+llzuP6F9b0m1ScBQOeKT73rE2f2eX99TnFuVQvkQOl+oAsdq4cBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMpp7ekJsIja2rq8uz5nbvEYEycXlvQt2E6S9HlhQGFNvVYrrKnNnlNYkynTCkvaZ8zsei4l9qneXi+eSxn1Bo0Dr1eZn8ESx2epTbW1d10wa1bxVCYU51K/2cX51uf5foU19d69CmtaZswurKlNm1G8raJcmlMi/+oFz2/ZGqiSovXS7OJjPFOmFpb0njuvsKZ1fHEupVfx9Sq1mcVzrs8sztvC9dK84n0qtV4qlV3WSyxGzbQWSpKi87TWEmuPKcVZ0Wde8TlP69S+hTVl1GYXb6tlRnEupSiXypwvtjdovWRNRU8r9buxzM9p8TlPYY+k4NhMkjIp2r/EeVzfcQ06j5tZvK3alOnF25re9bleqfO4Ej0omoMrxwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByWnt6ApVRr5coai8epr3g9Yy580pspsR25hWPU5s8pbimVuL1l7a2hsynXrTv9eL9LlUDS4sSuVQvcXymVjDOnDnFY5TZzpy5xVOZMrW4pkwutRfPp73EfDK365pS2dZe5vdHCaV+D8ESoMTv6sasl2YUb6dMLk2bVrytErlUL7PfJeZTmOtl8th6iQop83u41lLi+Cw6tmbOKp5MW4ljb9bswpJe03oXj9NSZr1UYr9nF8+ncI1XsJ5KknqJ56ZhaypYApQ5j6sVjVHmPK5EDjTsPK5Xr+JtlTi/KnMeV7jvJfKkVOaU6lPJrsXNleMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOa09PQFeoV4vUdTe9RBtJTbTVlxUmzeveJxevYo31l5mn0qod73f80satK3CDXXTdmBJUXB81ucW50lK5FKp7KrVirdVQr1Rx3nBnEvlVon8g6VGw37HvvH1Uqljr63E+qSlMblUak3ViPVSozLHeoklQQPOv5Kk3l58zVktjVgTlKiZM6d4mFkl5tuoNVWZ88qiNV6zrZfkGz2tzM9giWO4IcdeiZoyOdCt53ENyBTncUsXV44DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAldPa0xNgEdXrBQXtjdlMW4mi9qK5lN1YY+YMLAaFmZOkVisYo/gYb1TmlEmlWkvBfJPUG5VvxRtq0DjdNF9YUjRgvVQql2oljr0y43SnRuSOzKFKSv28l8iU9q6vS6u1lBhj7rwScymhzFqoMVsqp63roCy1LnNOCZ1113ncvBLHXq3EdbklcqkM53G8Hq4cBwAAAACgcjTHAQAAAACoHM1xKm90fWouab8qo+tTe3oqAEnkEtB85BLQbEbXp+aStivlEtA0rJeWTJrjVN72GZMVMjPb5+mengpAErkENB+5BDSb7etPzc+l+piengpAEuulJZUP5KSS3lyflDUyKUmyY/2p//77ZJ7PgCTJoxmSJ2pDemh2QBXJJaDZLDyX+ieRS0D3e3N9UtaoT0wyP4/m//uEXAJ6jPO4JZ/mOJW0f/3+vDNjk7z8SewjMz3H129Nkvwto/Pl2pY9NDugiuQS0GwWmku5LUnyt4zKlyOXgO6zf/u91ktAU3Eet+TztipU0hm1t+XGrJLk5fD637835E05o/a2HpkXUF1yCWg2XefSKjkjcgnoXme0vD035k1JrJeA5uA8bsmnOU4lzaz1ztdb3p6nMyi1/95WSzImg/ONls0zs9a7J6cHVJBcAprNwnNpUL5Rk0tA95tZ652v99oiT2ew9RLQFJzHLfm8rcrSpl4vrimjViuuqbeXqOnG+Syi4fXpWTnTkiSz0iv90pZVMjUr1GfkxdqAhm8PllqNOs4LlcicEuptDRlmsVhoLrVPl0vQSA3LrcbkUlN51XOz4FyaZr0Ei6rg3KnU+qTWmOyq1YvPrertxduqtTRmnFLnla8wP5emJlkM53Hdtq6FJtCIn/cG9Y6a+RytDOdxSzZXjlNZ6+elJMmlWTt71XbLpVk7SbJBxvfktIAKk0tAs3k5l9bKXtk1l2atJHIJ6DnWS0CzkUtLtlq9Xu6loh1b9lrcc6GZNOpK7Sa+cry13p4RmZ5naoM7blupPjXPZWDaal28buRqgsXuhvbLStXJpYpZDDnQbBaYS+1TinOJxU4usUBLYy69ap3zutdLLHZyqYl0VxY06Jhr1BXfPXXl+GLNJed6b4hcqqClcS30OjiPa15lcsnbqlBZ82oteSaDO932yiAD6G5yCWg2cgloNnIJaDZyacnm5QsAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKqe1pydAk6rXe3oGnTXbfIDuJweAZiOXgKQbs6C9IaPU2xoyTMPGaQh5DD3DscdSwJXjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDmtPT0BAAAAoEC9XlxTq3XfOGWU2RYA9CBXjgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDltPb0BAAAAIAGqNebaxwAaHKuHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDKqURz/Js3fTFHfOvARXrMTx8/J3sc+d7FMyGg8uQS0GxeTy4BLE7WS0CzkUuw9Gntjo0cd+Ens9OB23V8PeWlqXno1sfyw8/9NE/8Z0x3TGGRfWrzEzNr+qyengawmMgloNksibkELN2WxFyyXoKlm1wCGq3brhy/5Zo7s/fIw7L3yMNy/A5fTtu8tnzl9yd21+YX2eTxUzJ75pyengawGMkloNksabn0aq29u+W6C6AbLWm5ZL0ESz+5BDRStzXH586em4nPT8rE5yflsbufzKXfuCLDVxmWZYct01Fz6On75aIHv53fT/tZfvLo93LAl/dJr9ZeHffvf8peOe+OM7LDR7fJTx8/J1dM/HE+f8ln039Qv46afgP65viLP5Urp/w0vxx7fvY8+v2va77+7AWWfnIJaDZLYi595KQP5rgLP5krJv44R53/8de/80BTWhJzyXoJlm5yCWikHnnP8X4D++Xd+70zYx95LlNemtpx+4ypM3PGQefk0PWPyvc/e1Hee+gO+dBR7+v02JGrr5gtd39bTt719Hxh169lw23Xy4dP2KPj/sPO2D8bbb9+vvjBM3LCzl/JhtuunzU3Xa3TGPufsld++vg5i3cngSWKXAKazZKSS3sfu3ueuG9MPrHZ5/Lzr1z+BvcaaGZLSi4B1SGXgDeq2/72dYv3b5orp/w0SdJ/UL+89OyEfGHX01Ov1ztqLvnqbzr+//mnXsyvz/p9ttt7y/zqjCs7bq+11HLGQedk5rT579d048/+mo3ftUEuyvxQ3OXgd+UbB3wvd9x4T5LkjAPPySVPn9dpLlPGT81zjz2/uHYVWELIJaDZLIm5dOdN9+bXZ/7+de8z0NyWxFwClm5yCWikbmuO3/Wn+/KdT/wwSTJ4+UHZ7Yidc9ofPp9Pvf3EvDBmfJLknR/aIh888n0ZtcaI9B/UL71aWzJ9ysxO4zz/5IsdwZUkE56bmCHDl02SjFp9xfTp2zv3//PhjvunTpyWZx56ttMYvzvn2vzunGsXy34CSw65BDSbJTGXHrn9sde3s8ASYUnMJWDpJpeARuq2t1WZNX1Wnn1sXJ59bFweuvXRnHnouek3sF/ee9gOSZJ1375mTvrFZ3PrtXfm5F2/liM2OS6XnPab9O7TuX/fNret09f1ej21llqSpFardc/OAEsFuQQ0myUxl2ZOn1VcBCyxlsRcApZucglopB55z/Fkfui0t7enb/8+SZL1t1o7zz/1Yi457Td5+PbHM/bRcVnxTSss0phjHx2XuXPmZd0t1uy4bdCQgRm91siGzh1YOskloNnIJaDZyCWg2cgl4I3otrdV6d23d5ZbcUiSZPByA7P7p3ZJ/0H98s/f35ZkfvAMX2VYtttnyzx062N5+/s2yVYf2HyRtjFr+qxce+FN+dg39s/Ul6Zm4vOTc9BX9k29vd6pbvdP7pKtPrB5jt/xyw3ZN2DJJJeAZiOXgGYjl4BmI5eARuq25vjm79k4v3pu/ntCTZ8yI08/+GxO3fus3POX+5Mk/7zytlx+9tX51HcPSe++vfPvq+/Iz77y6/zfKXsv0nbOP+6n6T+wX770u89l5tRZ+fVZv8/AZQd0qllm2OCMXH3FxuwYsMSSS0CzkUtAs5FLQLORS0Aj1eqv/DjfLuzYstfingtAkuSG9stK1ckloLvIJaDZyCWg2cgloNmUyaUee89xAAAAAADoKZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5tXq9Xu/pSQAAAAAAQHdy5TgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJXTWrZwx5a9Fuc8ADrc0H5ZqTq5BHQXuQQ0G7kENBu5BDSbMrnkynEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACqnKZrj+5+yV86744yensZSY6cDtstvJ1zc09OAJZpcaiy5BG+cXGosuQRvnFxqLLkEb5xcaiy5RBW0Lu4N3NB+WZf3X3/xn/PdT1+QK757zeKeSmkDlx2Qg7+6b7ba4+0ZvNzAjHvihfzg2J/klmvu7KjZ9Yidstexu2foyCF58r5ncu5RF+Xevz/Y5bi7fWLn7P7JXbLiqsPzwpjxueS0y3PjT//acf97Dn13dtx/26y6wcpJkkdufzwXnvSLPHTro4tnR6GilsZc2v+UvfJ/p+zd6TETxk3KPqMO63Lcolx603or5YAv7ZM1N10tI1Ydnu8fdVF+++0/NH4HoeLk0suKcmnrPTbPvid+MKPWGJFevXvl2UfG5ddn/T43/uyvXYwKLKqlMZd++vg5GbHq8Nc87srvX5vvfuqChY77ro9snb2P2z2j1xyZ6ZNn5LZr78oPjvtJpk6YliT55k1fzEbbrf+ax/376jvyhV2/1qC9A+TSy+QSNM5ib47vPfLlE6Dt9tkyB3xpnxy0zpEdt82eOSezps/KrOmLeybltPZuzdevPzmTXpiSU/c6My8+81JWWHlYZk6d2VGz7d5b5ohvHZTvfvKHue/mh/K+j++Y0/5wUg5Z/6i8+PT4BY77/sN3ysGnfSTf+tgP8tCtj2adzdfIUecfnmkTp+dfV92eJNlo2/Xzp1/+Pff/4+HMmTUnex+/e06/7gs5dIOj89KzE7pl/6EKlsZcSpIn7h2Tz+14asfX7W3tXY5bJpf6Duib5554IX/99T9z+FkHNnzfgPnk0nxlcmnKhGm55LTf5OkHx2bunHnZ4v2b5tgLP5FJL0zObdff3fidhYpaGnPpU5ufmJZeL//x9KobrJxv3PD/8pfL/rnQcdffap0c/+NP57yjL86/fn97ho5ePkeee1iO/uER+dKH5l+d+qUPfTOtfV4+tV5m6KD84K5v5q+/Xvi4wKKTS/PJJWisxd4cn/j8pI7/nz55Rur1eqfbkvlXFm21++Y5fJPjkiTHXfjJDBwyIA/d+mj2+Mx707tv71x+9lW55Ku/ySFf2y+7HPyuzJ4xOz8+5dJcd9GfOsYZOmr5HH7mAdl0pw1Tb6/n3r8/mO9/9qI8/9SLpee7y8HbZ/Dyg3LkVl9I27y2JMkLYzo3vD901Ptz7YU35ZoLbkqSnHvUxdlsp42y6xE75cLPX7LAcXf46Da5+vwb85df/SNJMu6JF7LuFmtln+M/0HGyd/r+3+n0mG8d9oO880NbZON3b9DpiqlX2+mA7XLAl/bJMsMG57br7s59Nz/Q6f6Rq62Yw888IOtusWb6DeyXMQ88kws+f0nu/ON/kiQfPXnPbLPnO/KxjY7p9Lhzbv16bvnDHfnxKZdmw23Xy2Ff3z9vWn+ltM1ty1P3PZ3T9vv2a54bWBIsjbmUJO3z2l+zH10pk0sP3/ZYHr7tsSTJIV/br/TYcgkWjVyar0wu3fOX+zs95rff+UN2/L9ts/7W63TZHJdLsGiWxlyaPH5Kp68/fMIHMvbRca/JlVdad4s18/yTL3RciTruyRdy9fk3ZO/jdu+omTpxWqfHbPfhLTNrxuz8tYvmViKXYFHJpfnkEjRWU7zn+IK89V0bZOio5XP0tqfkvGN+nAO+uE++8vsTM23itHxmixNz1Q+uz5HnfiwrrDQ0SdK3f59886ZTMnP6rBy97Sk56p0nZ+a0WTntmpPS2nv+awAbbrtebmi/LCu+aYWFbvcdu26W+//5cD59zqH51XM/zPn3nJl9T9wjLS3zn6rW3q1Za9PVcvurTr5uv+GerP+OtRc6bu++vTNn1pxOt82eOSdrb75GerX2WuBj+g7ok9berR1/FrMg62y+Ro654Ihcee51OXzj43L3n+/NR076UKea/oP65ZZr7sjxO56aIzY5Lrddf3dOvfKErLDysCTJtRfelFXWWylrbbZ6x2Pe/JZVssbGq+a6i/+Ull4t+dJvj889f70/H9/o2By55Um5+oc3pl5f6LRgqdSsufQ/o9YckV8+84P85LFz8vlLPpsRb37tn+e90uvJpTLkEnQfuZRs/K4NstLao/Kfvz6wwPsTuQTdqdlz6X9ae7fm3fu9M9dddFOX+3P/Px7KsJWGZvP3bJwkGTJ82WzzoXfklj/csdDHvOfgd+fPl/4js2bMXmiNXILuI5fkEnSlaZvjUydMyzmfuTDPPPxsrrvoTxnz4Nj0HdAnv/jabzP20XH55deuyLw587L+VvMb0tt9eKu0t9dz1qHn5sl7x2TMg2PzzYO/n+GrDMtG262XJJk9Y07GPDg28+a2LXS7I1ZbMdvsuUVaerXkpPd9LZd89fLsefSu+chJH0ySLDtscHq19nrNq5MTn5+U5UYMWei4t19/V95zyLuz5iarJUnW2nS17HLQ9undpzXLDhu8wMccevp+GT92Qu648T8LHXePz7wvt113dy79+hUZ+8hzueK71+S26zo37h+/56lcff6NefLeMRn76LhcfPIv89zjz2fL3TZLkowfOyG3X3dXdj5o+47H7HzQ9rnnL/dn3BMvZOAyAzJoyMD8+6rb89zjz2fMg2Nzw0/+stC3kIGlVbPmUpI8+O9H8o0DvpcTdvlqvvWx87L8iCH59s1fzeDlBy103NeTS2XIJeg+Vc2lAcsMyJVTfpprZv8iX7nqxJzzmQtzx433LHRcuQTdp5lz6ZW2/MDbMmjIwFx/8Z+73J/7//lwTv/od3LSL4/KNbN/kcvG/SjTJk3P9z594QLr137bGnnzW1bJNT/6Y5fjyiXoPnJJLkFXFvvbqrxeT933TOqveOlo0vOT8+R9Yzq+bm9vz5SXpmbI8GWTzD95Gr3GiFw55aedxunTr3dGrj4iueGePHTrozlkvc92ud2WllomvTAlZ3/sB2lvb88jdzyeoaOWz17H7pafnfrrjrpXv6pVq9U6zffVfnbq5VluxJB8559fTa1Wy8TnJ+f6H/85+xz/gQW+/+bex+2W7T68dY7d/pTMnT13oeOusu7o3HzFLZ1ue+BfD+dtu7y14+t+A/rmo6fslS3et2mGjlouvVp7pU//PllhlWEdNX/40R9zzAVH5Lyjf5z2tva86yPvzPnH/iTJ/D/Hue6iP+Vr156U22+4J3f+8T/5y6/+kQnjJi10XrA0auZcuvXauzrqn7w3eeCfD+fHj34vOx2wXS7/1lULHHdRc6ksuQTdp6q5NHPqzBy+8XHpP6hfNn73Bjn8zAPy3OPPL/RPkOUSdJ9mzqVXes/B78ot19yZl56b2OW4q6y7Uj757YPys1N/nduuuytDRy6Xw76xf44872M569BzX1O/yyHvyhP/GZOHbn20YFy5BN1FLskl6ErTNsfnzZ3X6et6vf6aV+Tq9XpqLbUkSa2lJQ/f/nhO/2jn9+1OkkkvTnnNbQsz4blJmTd3XtrbXz4BG/PAMxk6crm09m7N5PFT0zavLcu/6irxIcOXzaTnJy903Dmz5uTMQ87N2R8/P8utuGwmPDcp7/3YDpk+ZUYmj5/aqXbPY3bNvid+MJ/b8ct54j9jFjLifLVarXCfDjtj/2y200Y5/7ifZuyj4zJn5pz8v8uOSe9XfDjDP39/W+bOnpet99g8c2fPTZ++vfO3y//Vcf83D/l+fvvdP+Rtu7w12+69ZQ489cM5YadT88C/HyncPiwtmjWXXj2vJJk1Y3ae+M+YjF5z5ELHXZRcWhRyCbpPVXOpXq/n2cfGJUkeu/vJrLLuStn3hD0W2hyXS9B9loRcGr7KsGy8w4YdH1zXlX1P2CP33fxQLvvmlUmSJ/4zJjOnz87Zfzs1F3/hF50aOn3798n2+2yVH59yaeG4cgm6j1ySS9CVpm2OL6pH7ng82+69ZSa9MDkzXvHJv4vqvn88mO333brTleArrTUqLz07oSO4Hr798Wyy44adXlHbZIcN848rby0cv21eW8aPnZAk2X6frfLvq+7o9ArmXsfulv1O+lBO3OUrefj2xwvHe+r+Z7Lu29fsdNurv37L1uvm+h//uWO+/Qb2y4qrrpD85eWa9rb23PCTP2fnA7fPnNlz86dLb87smZ3f8/Oxu57MY3c9mV+efkW+ffNXs/1HthZe0IXuzKVX692nNausOzr3/n3h78H7P0W5tKjkEjSvpTaXarX07tt7oXfLJWhePZFLOx+0fSa9MDn/vnrh78/7P30H9EnbvM5/Ufe/v2R5dSNp2723TO++rbnxZ38tHFcuQfOSSy+TS1RB077n+KK66ed/y5TxU/KlK47PBluvkxGrDs+G26yXT5x9UIaNXj7J/PdZuuD+szN01PILHef3516fZYYOzie+fVBGrzkym793k+x74h658vvXddRc/q2r8p5D3p2dD9o+q6wzOoefdUCGrzIsV513fUfNwad9JMdf/KmOr0evOTLv3u+dGb3GiKz9tjXy+Us+m1U3WDkXnnRJR83ex+2WA0/9cL55yPcz7skXs9yKQ7LcikPSb2C/hc73iu/+IZvt8tbsfdxuGb3myOz+yV2y2Sv+5CVJxj46Llvv8fasvtGqWW3DN+XzPz+y4xXRV7rmR3/MW9+1QTZ/z8a57sKXPwBixKrDc/BpH8m6W6yV4asMy6Y7bpiV1hqZMQ+MXei8gO7NpY+dsX823Ga9jFh1eNbZfI2cfNkxGbBM/1z/4z931LyeXGrt3ZrVN1o1q2+0anr3ac2w0UOz+karZtTqIxY6X7kEzWtpyKUPn/CBbLLDhhnx5uFZee1R+dBR78+O+2+TP/584Sd9cgmaV3fmUjK/cbTzgdvnhp/8ZYFvI/fqXPrXVbdn6w9unvcfvlNGvHl41t9y7Xzy2wflgX8/8pq3Ptjl4Hfl5ituzdQJ0wr3Wy5B85JLcolqWWquHJ89c06O3vaUHHr6fjnl8uMyYHC/jB87IXfedG9mTJn/Sl/fAX2yyjqj09q710LHefGZl3LCzl/JEWcdkPPv/mbGj52Q337nD7n067/rqPnLr/6RZYYOykdP3jPLj1wuT977dE5632l5YczLHyAwdMRyGf6K91zq1aslex69a1Zae1Ta5rblrj/dmyO3+kKef+rFjppdj9g5ffr2zim/PrbTnH7ypV/lp1+6bIHzfeDfj+Ssw87L/31x7+x/yt6588b/5JKvXp79vrBnR815R1+cYy74RM6++SuZMn5qLv3GFRmwTP/XjDX20XG57x8PZZmhg/PgLS+/F9WsGbOz8tqjs9Ovt83goYMz4bmJ+d051+bqH9yw0OcR6N5cGjZ6aD5/yZFZZtgymfzilDzwr4fzmXec9IZzaeio5XLenS//ad/ex+6WvY/dLXf/+b4c+64vLnC+cgma19KQS/0G9stnzjk0w1Yamtkz5+TpB8fm9P2/m7/86h8Lna9cgubVnbmUJJv8f/buM0Cusn4b8D1bkk2DQCAkhBLpCIICIgLSRMACiAVRRIoNxK4gtj8iKirYXkWxoGBBEVEsSFPBitKlg9RIQkIK6X133g+RJQvJnhOY7M7mXNeXZGd++5znzO655zm/OTuz//Oywabr5/LlmjXLe2ouXXn+NRkyoiOHnnhQ3nnWWzJv5rzc/Kfb871TftLj+8ZtOTbPe8m2+cgBp5fab7kEzUsuySWqpVYv+bfzL2t5/eqeC03g+3d9LZd+56qVflAW9IWrulb8YtBTyaVqkEs0A7nE8uQSzUAusTy5RDOQSyxPLtEMyuTSGnPlOM/OyPXXyv5H7ZX1xq2bK35wdX9PB0AuAU1HLgHNRi4BzUYuMdBojpMkuWjKuZk5dXa+8s5vZ+7Mef09HQC5BDQduQQ0G7kENBu5xECjOU4Sf9YENB+5BDQbuQQ0G7kENBu5xEDT0t8TAAAAAACAvqY5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFROW39PgAGsViuuqdf7bhwAAAAAgJJcOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACV09bfE6Af1GoDb1tlxqnXG7MtoDn1ZXY1ilyCgWsgZk4jyC1oXmtqLskdAPqRK8cBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgctr6ewKsolqtAWMUvyZSa2nAdkqqd9UbM1DRlOtdxWPUGzQX4EmNyK2kVHY1nxK5U0QuQU+NypTC7fRd5pRZdzVsvVS0Hirz+MolaLw1db1U5hysaN9lDvSPvlpzJY3LrjKZ05DtyKU1SZM9cwIAAAAAwOqnOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUTlt/T4Dl1GrPfojW1hJFxa+J1FpLvG7S0pjXVmpdXYU19c7imtR7r6l3lZlvme3US4wDa4gG5FKpzGkpsZ0S+VZrxHyT1Msc510lauq9z6fe2Vk8Rpl9kkuwSppuvVRiLVTqOG9ELpUZw3oJVl3R83kfrpfKKLOmatR6qXA9VGZ5V3AuuKxGLkEPDcilUptpUC6VU2JbJfKieD1UInPKkEtNwZXjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDlt/T2ByqjVGjNMa2vvBUX3J6m1Ff/Ya+0lfjVKjFNmPlm6tHg+S4pr6kXjlBmjs7AkSVdxSb1eZiBYM9R6f521TJ4UZluS2qD24rmUyaWC+SZJras4DOqLl5SoWdz7dgpHSOpdZfJELrGGaNB6qfA4b9R6qcw6p0x2lVArcQyXyaUsKajpLM6Thq2XypBdDARlsqtovVQml8qsqcqshcqc65XYp1qZvChYCyVJlva+rXqJ87hSyvycZA5rir7KpdYS19y2F6+FSo1T4jwunSXO40r0oIr6R6XWQvUSayG51BRcOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACV09bfE2A5tRKvVRTU1NqKf6S1oUOLa4YX13QNG1I8Tr1eWJMlS4vHmbegeJx583q/v6ureIx6cU29s3iY1GoltlXisYHVqczvaYlcqrW29n5/mVwaPqx4LiOKa+pDBxfXtPc+3yRpWbCkuGZ2QeYkqc+d2+v9XQsWFo5RS3HoyCWqpChzkiRFuTRoUPF2BpeoKZFd9aEdxTUtJbJ2cYlcmlMilxYu6r1gQYk1V6PWSzAQ9NV6qb3EemlIcZ40KpdSIpeyaHHxMHPnF89nfu+5U+IsLukss14STKwhGpVLLb2P06e5VGLdlbbiNWBtQcE6J0kKMqdUTdF6KiXXQiXWVKx+rhwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKqetvyewRqjVGjNMa2txTXvvP7Jax+DiDa09vLBk8Zi1C2sWji7eVueg4sdm8MzOwpqOyfMKa1q6unov6KoXjlHvLBgjSWrF46ReYhwYAGotxcdwYS4N6Sje0Mi1CksWblycS3M3GlRYs2Ro8T4NnVqcSyMeKs7A1km950WtRObUFy4qrJFL0FPRmqrWUSKXSqyXlowukV0l1ktdbcW51D6nzHqpOANbpszovaCzeDvWS9BTqfVSa+/XpZVZL9XWLs6cJQ06jyuTS4NmLi2sGTy5eFst03q/v1Yml0qc65XKpZTIpXqZcWAAKFovDWovHKI2osR6acN1CmsWjCnOwKWDi3NpyPTiXOp4ZHZhTa0oU0rkUpl1Tr3EMKx+rhwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAymnr7wlURq1Br0O0tva+mSFDCofoXGd4Yc3cTToKa2ZtVrxPnUPqhTVDJrcX1qxTH1o8ztwFvRcsXFQ4Rq21xM+p3lVc0lk8DKxWtVqJmgblUsG2ah3FebJ4/eJcmvHcwYU1s3cqPs7XGTWnsOaxO0YV1rR0FufSiFnze72/Nr8gt5LUWxYX1kTmMBA0KpdK1RTk0qDitUfn2sXH+NxNitdds55TYr1UHJMZOrl4nNbFxfMZPKegZlFx5pRZL9U7BRMDQJlcapSW3o+b2qBBhUN0rjOssGb2c0rk0pbFx/DSocXnccMeKV6bjSoeJh3zel8P1RYuLByjvnRp8YbEEhVSaynOt1pBfymDi4/xrpHF53GzNyvOpWkvKCxJ5/Dig3j4/cVZOrpzRGFNx8KC9dCi4vPO+pISuVQrEZIp7kGlXmYcVsaV4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVoznOM7bp9Km55qunZdPpU/t7KgBJkvGTp+Xa95+R8ZOn9fdUAJIkm86Ymqu/flo2nWG9BDSHTadPzZ+/5DwOaB7jp07N3087PeOnyiX6nuY4z9irbr8pY+bMyivvuKm/pwKQJDn02lsy9vHZOeSf/+7vqQAkSV55h/US0FxedetNGTN7Vl51m1wCmsMhN92csbNm5eCbbu7vqVBBbf09AVZNrVYrKigco2tQa2HNorVWPM6W0ydlm6kTkySH3HF9kuTQO27IwxuNTJLcsdG43D1uw+76+vClhdtqWTyosKazo8TrOIPae7+/1WtBsMpqJY6bloKatuLM6Rxa/HS0YHR9hbdvPXlSnjtpWS696brr/vfvv9Kx3ZIkyUNbjcqELUZ1179yvVsLt/WpOQcX1iy6a0hhzfCO3nOpViKXCnM/yYofGaiuWmtB7hTlVpKuQcW5tHjEytdLW09flkuH/m+9dMidT66X7hw3Lndv+OR6qXNEZ+G2WhcWrHOSLBlWPOdBgwvGaSnOnDJqJcapF+82rF71Es+gJZ6HS62XGpFLg4uP8SXDezmPm/a/XLr9f7l0+/V5aNO1kyR3bDwud280tru+feTCwm0tXDC8xHyK14GD2wv2q8zjW4JcYkBoVOY04LiplcilpUOL1ycLRq14nK2mPtlfes0t13f/O3nLYUmSu8aPyT3jx3TXbzFqRuG2/jNv48KaJSOKc6mjqKBB6yWag+Y4q+Sd11+Z/R+8LcmTzZhNpk3Pl35yYZLksh22zwlvO6Z/JgdU0nv+eGUOvLNnLm0wcU7e9Zk/J0n+tff4fOWMl/XT7IAqeseNV+alDz1lvTR9es766bL10uXP2z7vOvaY/pkcUEnvvOHKvPQp53GbTp2RL5/38yTJZS/YPscf/5Z+mh1QRcf/84q87P6nrJemPJ4vfONXSZIrXrRt3nvSEf00O6rEpbSskv/b74j8bsudkjwZXk/8e/ELd86H3yy4gL71kdcdkUt23GmF9/3loC3yrU/s3cczAqru1H2OyKVbrHi99Mudd85Jb7ReAvrW/+3by3nci3bKh445vF/mBVTXJw58Y367zc5Jnp5Ll+y1Yz767sP6ZV5Uj+Y4q2T+oI58Yv8j89Da6+eJPyKpJbl/9Pr50FFvzLyOwj8+AWioeYM7ctLhR+aBUev3uH3iJmvnm/+3bxYOK37rJoBGmj+oI5/cbwXrpfXXz4ePtF4C+t78QR355EtXkEsbrJ8PHneEXAL63PxBHfnYQUfmoZE9c+mBDUflI+99TeYNGdyf06NCNMdZZWPnzMj4WVNTSzK/vT21JJs/NjUbzni8v6cGVNSGj8/IZtOX5dKiwW2pJRk3YVZGTZ7b31MDKmr59dKCJ9ZLU6dmw8etl4D+0eM8btD/cmmK8zig/4ydPSPjZ/5vvfS/XNps0vSMnTqzn2dGlWiOs8qe/+hDSZJzXrpPdv7cp3LOS/dJkuzywIP9Nymg0nae8FCS5DdH7pB3/P7N+c2ROyRJtrl1cj/OCqiyHac8lCT59r77ZJdPfyrf3nefJNZLQP/ZcfJDSZJvHbBPdjrr1JxzwLK3nnvhfQ/136SASnvBpGXrou8eukde/P2T871D90iS7Hz3hP6cFhXjAzlZZVdtvkPuXH+j/Hv3ZW9h8PlDX5Wf77ZrJqw3qp9nBlTV5dvtkNvfv1HWPXzZJ5hfcOKLcvWrts5j49bq55kBVfWH5+yQuw7fKP/ebdl66QsHvyo/f9Gu+e8o6yWgf/xhsx1y1/ob5eZ9l+XQGa99ZS7c44WZsL5cAvrHlVvumDtHb5x7DxmSJDnzqAPyi/12yn83WKefZ0aVuHKcVba0tS0PrzO6x20PbDA6S1tb+2lGQNUtaWvLg+v3zKVHNx2ZzjZPc0D/WNralodH9sylB0dbLwH9Z0W59MAYuQT0n6WtbXlo3aesl8atl6Vtcom+o2sAAAAAAEDleFuVAaZer/d6f62rq3CMlsWdhTWDZ/W+nSQZMrn4tZWlQ9sLazqmFZakbUHxfmXJ0t7v7yweo+jxBZ6BomMzSdu84pohUwYV1vzzvucU1tw1bYPCmtrDQwprOmYVZ2ltweLeC+QSrBaF66WlxZnTsrC4ZtDsEuulKSXWS3OKazpmFG+rvUSW1hYt6fX+elfxdsrkUplxSqnVimvkJM9Umd+vRik6TytzHreo+BjveLxELk0sbgMsfXxYYc3gGYUlaZ9TYr1UsFasdxaPUUbDcglWp1LPaSX6I/Vnn2/1BuXSkGnF48x/YHhhzT1Ti8/RRkwsXlO1z+59LZQkKcodebJGceU4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVE5bf09gjVCvlyjqKjFOrbims7P3IRYuLByiZea8wpoRE1oLa9oXDCqs6Wot3qdBs5YW1gx+rHjOtfm973vX0uLtlFHvKvPzhn7Wl7m0ZEnvQyxaVDhE27S5hTWj7izOpcGzBhfWLO0orhk9vfixGfrfErm0oPd9L5VLMoc1RTOtlwpyK0la5swvrBn+3+KldPv84sypF8db2uf0vk9JMqjEeikLel8v1RcvLh6jL3Op1O8NPENlfr9qJTKnXiK7inKpxLHX+njxMT68xHlc66KOwpp6ifO49tklzuOmFK/x6vMX9H5/wWOXpFwulfk5wRqiVN+i4NiqFawZkqR12uzCmrUeKF4vDZ5dvF5aMrT4+t4h04rPPcvlUsF6qcx5XJnMKVVjLbS6uXIcAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKqetvyfAk+pd9eKiJUt7v7+2qHCI2sw5hTXtRdtJ0vZ4R2FNarXimsVLioeZO7+wpr5gQe8FS4q3k87O4pp6V3ENrCFK5VJnwTGxYGHhELXpjxfWdCxaXFgzaMrQwpp6e2thTcvC4m3VZs8r3tacub3fv7h4O6Uyp1RNiZ8lDAANWS+VyaUSc+nT9VKJbdXmlMilhQX73qi1kPUSFdKQ9dLC4vO4ZHZhRVuJrBheJpdainOptqj4/Ko+r8R53Pzez+PqS4v3qV4mu8qwXmJNUeZ5uOC4KXWuMrv3850kaS/KvyRt0wYXb6vEeqlWor9UL7EOrM/vPbvqJbK21HMDTcGV4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5bf09AVZRvav3u5cuLR5j3rzimjLjzJlbXNPS2pBtdZWZz5Ilvd5d5rGpd9WLt1NGvUHjwOpU6ve098xJknpnQcHiUrMptrj3YzxJanOL861WZltlcmlJiUwpGqez6MFrYC7BQNCgXEq99yO91Hpp/oLimjLjlMil1EokU4nHpmvhouJxCnLHegmeopnWSyXmUm/QeqmMesG5aZLU+2i9VHSeDDxd4fN5mTXB/PmFNbXFxQFXm9uY9mSZNUq9xHzqnQW9tzK5xIDhynEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAAConLb+nkBl1OslirqKh+ksGqLEdkrU1DuLNpTUarXibZVQL/PYlNmveu+PX70BYyyrKfOzhAopOvaK4yRZVCL/aiVez120qLCkTHbJJRjYCtcxZY69EmuhRq2XSmVOGc2US1AlDTjXK7VeKnPslVgv1VsWl9hYgzTo3LMhrJdYUzTsd7kBudSoNdXiJcXjtJToQTVoHVO4HmrUWkguNQVXjgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACV09bfE2A59XpxTa1WMEZX8WY6S8ylTE1LwVxKqneV2O9yAzVmHOBJzZRLtRJzKTFOgxKnMcrkVpmfAVRJQ46JErnUVeIakq6lxeOUmU5f6qv1kuyCngqPiQatl8oshmpNdo2c8zjoH0W5VHSelzTduV4pMoenaLJnRQAAAAAAWP00xwEAAAAAqBzNcSpvXH1OLuj6XcbV5/T3VACSyCWg+cgloNnIJaDZyKWBSXOcyts3E7J+FmTf/Le/pwKQRC4BzUcuAc1GLgHNRi4NTD6Qk0p6Tn1mtsjMJMnL6g//79+HMiVDkyT3ZWQerI3sp9kBVbTyXBqSRC4Bfc96CWg2cgloNnJp4NMcp5KOqt+Zl2RikuSJz0Qem3k5uX59kuSvGZdP13bvp9kBVbTSXMoNSZK/ZsN8OnIJ6DvWS0CzkUtAs5FLA5+3VaGSzqy9MH/IJkmeDK8n/r0qm+bM2gv7ZV5AdfWeS5vkzMgloG9ZLwHNRi4BzUYuDXya41TSglp7vtDyovw3w1P73221JBMyIl9s2TULau39OT2gglaeS8PzxZpcAvqe9RLQbOQS0Gzk0sDnbVUGmnq9uKZQVwPGSOqdDRmm34yuz8vGmZskWZjWdKQzm2RO1u+al6m1of08OxhAGpJLZTQmu5rKUx67FefS3Kxfny+XoJFK5dYamDlllMol6yVouEatp2q14pr6AMs3uQT9o8/O8zLgG0xyaWBz5TiVtV2mJ0kuzNZ5fe2QXJitkyTbZ1p/TguosCdzaau8PgfnwmyVRC4B/UcuAc1GLgHNRi4NbLV6vdxLQS9ref3qngt9pczVBBXQVu/KmMzLI7UR3bdt1DU7j2ZYOmteN+pPV3VdVKpOLlXMmphdT3kKXmEu1efIpSYglypoTcycMuTSgCGXWKE1Mbvk0oAhl6gqudS8yuSSt1WhspbWWvJIRvS4bfkgA+hrcgloNnIJaDZyCWg2cmlg8/IFAAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJXT1t8ToB/U6/09A4BVJ7uAvtSozKnV+m5bAPIEAFaJK8cBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgctr6ewIAALDGqtf7ewYAAMBKuHIcAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHIq0Rw/60+fyglfOaa/pwHQ7Znk0o8eODuHve8Vq2dCQOVZLwHNRi4BzUYuwZqnrS82ctL3T8wBx+zT/fXs6XNyz/X357sf+VEevG1CX0wBoIeBmEvv3vWjWThvYX9PA1hNBmIuAWs2uQQ0G7kENFqfXTl+3WU35/Cxb8/hY9+ek/f/dDqXduYzv/1oX23+WWtr75PXEYA+NNByada02Vm0YHF/TwNYjQZaLj2V9RKseeQS0GzkEtBIfXZELlm0JI9PmZkkeXzKzFz4xUvylb+cnrXXWyuzps1Okrzt80dmj1fvmvU2GpXHJ8/MHy/4a3786V+kc2lnkuSoU1+fPQ7dNb/48m9z9KffkBHrDM91l92cr7zjnCyYu+xqyo6hg/Peb749e77mRZk/Z0F+8aXfPKP5/uiBs3PZuX/MuM3HZo/Dds3fL7kuZx579rN/IICmMRBz6ZdfuzS/+trvn/3OA01pIOaS9RKs2eQS0GzkEtBI/fKe4x3DOvLSI1+Sif95NLOnz+m+ff6cBTnz2LPztu0+kG++/wd5xdv2z2s/8Moe3zt28w2y+6EvzCcP/nw+cfAZ2WHv5+aIUw7rvv/tZx6VHffdLp96zZk55cDPZIe9t8uWO2/WY4yjTn19fvRAcRAd/uFD8+AdE/KuXT6Sn3zm4me510AzGyi5BFTHQMkl6yWoDrkENBu5BDxbfXbl+G6v2jm/mf2jJMmQ4R2ZPmlGPnHw51Ov17trLvjsL7v/P+XhqfnFl3+bfQ7fPT8/88lX52ottZx57Nndr+T94cd/yQv22z4/yLJQPOi4/fLFo7+Rm/5wa5LkzGPOzgX/PafHXGZPm5NH759SOOeb/3R7fvGl3z7jfQaa20DMJWDNNhBzyXoJ1mxyCWg2cglopD5rjt9y9R35f+/6bpJkxLrDc8gJB+Zzv/9Y3v2ij+axCdOSJC957W55zftemQ23GJMhwzvS2taSebMX9BhnykNTu4MrSWY8+nhGjl47SbLh5htk0OD23Hntvd33z3l8bh65Z1KPMX599uX59dmXF875Pzfe/8x2FhgQBmIuAWu2gZhL1kuwZpNLQLORS0Aj9dnbqiyctzCT7p+cSfdPzj3X35cvve1b6RjWkVe8ff8kybYv2jIf/+n7c/3lN+eTB5+RE3Y6KRd87pdpH9Szf9+5pLPH1/V6PbWWWpKkVqs1dM4L5i0sLgIGrIGYS8CabSDmkvUSrNnkEtBs5BLQSP3ynuPJstDp6urK4CGDkiTb7bF1pjw8NRd87pe598YHMvG+ydlg0/VXacyJ903OksVLs+1uW3bfNnzksIzbamxD5w6smeQS0GzkEtBs5BLQbOQS8Gz02duqtA9uzzobjEySjFhnWA5990EZMrwj1/72hiTLgmf0Jutlnzfsnnuuvz8veuVO2ePVu67SNhbOW5jLv/+nvOOLR2XO9Dl5fMqsHPuZN6beVe9Rd+iJB2WPV++ak1/26YbsGzAwySWg2cgloNnIJaDZyCWgkfqsOb7ry1+Qnz+67D2h5s2en//ePSmnH/7l3PrnO5Mk1/7mhlz81Uvz7q+/Ne2D2/OvS2/Kjz/zi7zl1MNXaTvfOelHGTKsI6f9+iNZMGdhfvHl32bY2kN71Ky13oiM3XyDxuwYMGDJJaDZyCWg2cgloNnIJaCRavXlP863Fy9ref3qngtAkuSqrotK1ckloK/IJaDZyCWg2cgloNmUyaV+e89xAAAAAADoL5rjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDl1Or1er2/JwEAAAAAAH3JleMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFROW9nCl7W8fnXOA6DbVV0XlaqTS0BfkUtAs5FLQLORS0CzKZNLrhwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKBymqI5ftSpr885N53Z39NYYxxw9D751Yzz+nsaMKDJpcaSS/DsyaXGkkvw7MmlxpJL8OzJpcaSS1RB2+rewFVdF/V6/5XnXZOvv+fcXPL1y1b3VEobtvbQHPfZN2aPw16UEesMy+QHH8u3P/zDXHfZzUmSHz1wdsaMH/207/vNNy/P19997krH3e9Ne+bwkw7NuC3HZt6s+bnh8lvy7ZN+mDkz5iZJWtta88aPHpaXvWXvrDdu3fz3nkn53ik/yQ1X3LJa9hOqSi49SS5BcxhouXTWnz6VHffZ7mm3/+vSm/KJg89Ikhxxyquz52EvysbbjMuiBYtz5z/uyfdO+UkeuXdSr2MX5VKZbQPP3pqYS686/oAcfPwB2WD8+kmSh+94JD8+/aJcf/ktvY59yLsOzKEnHpQNxo/OYxOm5YLPXZw//Ogv3fdv+tyNcvRpb8iWO2+WMeNH55sf+EF+9bXfN27ngCRrZi6trvO4pPgcElhmtTfHDx/79u7/7/OG3XP0aW/Isdu8r/u2RQsWZ+G8hVk4b3XPpJy29rZ84cpPZuZjs3P667+UqY9Mz/obr5cFcxZ017x714+mpfXJi+7Hb79xvnjV/+XPF1270nG322ObnHz+e3LOB8/LP397Y0aNWzfv+9bb88HvnpDTXrvsVc1jP3NEXnrkXvnKO87JhLsnZpcDn59P/fKkvG+Pj+f+Wx5abfsMVSOXlpFL0DwGWi6d9tqz0jboyWXkWqOG59u3nJW//OLJzNlhr+3ym29ekXuuvy+tba059jNvzOev+ETett0HsnD+ohWOWyaXymwbePbWxFya9sj0nPvRn2TifZOTLLsi8rRLPpITdjopD9/5yArHfdXxB+S4z70pX3nHt3PP9fdlm123yAe+c3zmPj4v//zdjUmSwUMH59EHH8tffnFtjv/yMatvJ6Hi1sRcWl3ncWXOIYFlVntz/PEpM7v/P2/W/NTr9R63Jcv+7GWPQ3fN8TudlCQ56fsnZtjIobnn+vty2HtfkfbB7bn4q7/LBZ/9Zd56xpE56Lj9smj+opx/6oW54gdXd48zasN1c/yXjs7OB+yQelc9t//t7nzz/T/IlIenlp7vQcftmxHrDs/79vhEOpd2JkkemzCtR82sabN7fH3EKa/OxPsm59Y/37nScbfdbctMeeix7lcwJz/0WC79zlU5/KRDu2v2f/NeueBzv+x+Fe9351yZXQ7YMa/74MH5wlu+vtKxDzh6nxx92huy1nojcsMV/84df7+rx/1jN9sgx3/p6Gy725bpGNaRCXc9knM/dkFu/uNtSZI3f/J12et1L847dvxQj+87+/ov5Lrf35TzT70wO+z93Lz9C0dl0+02SueSzjx8x3/zuSO/9rTHBgYCubSMXILmMdByac7jc3t8vc8Ru2fh/EX5y3Inch97xWd71Jx13Dfzi8fOzZY7b5bb/tozE55QJpfKbHtF5BKsmjUxl55oZj/hB5/4aV51/AHZdretVtoc3//Ne+XS7/whf/75P5Ikkx98LNvutlXecPKru8e794b7c+8N9ydJ3nrGkaXnLJdg1ayJubS6zuPKnEOuiFyiipriPcdX5Pn7bZ9RG66bD+59as750Pk5+lNvyGd++9HMfXxu3rvbR/O7b1+Z933rHVl/o1FJksFDBuWsP52aBfMW5oN7n5oPvOSTWTB3YT532cfT1r7sNYAd9n5uruq6KBtsuv5Kt/vig3fJndfem/ec/bb8/NHv5ju3filv/OhhaWlZ8UPV1t6Wlx75klzxgz/1uj93/uOerLfRqOz68hckSUaOXjt7vfbFue73N3XXtA9uz+KFS3p83+IFi7P9ntusdNxtdt0iHzr3hPzmW1fk+BeclH9fc3ve9PHX9qgZMrwj1112U05+2ek5YaeTcsOV/87pvzkl62+8XpLk8u//KZs8d6Nstcvm3d/znOdtki1eMD5XnHd1WlpbctqvTs6tf7kz79zxw3nf7h/Ppd/9Q+r1XncZ1jhyaRm5BM2jv3LpqV5+3EtzzYX/WOkV4cmyP+1N0uPPfZ+qTC49k23LJeg7AyWXWlpass8bdk/HsMG589p7VzrOsrXQ4h63LVqwOFvvukVa21pLz+ep5BL0nYGSS408j1vVc8hELlFdTdscnzNjbs5+7/fzyL2TcsUPrs6Euydm8NBB+ekZv8rE+ybnZ2dckqWLl2a7PbZOkuxzxB7p6qrny2/7Vh66fUIm3D0xZx33zYzeZL3suM9zkySL5i/OhLsnZumSzpVud8xmG2Sv1+2WltaWfPyVZ+SCz16c133w4Lzp469ZYf3ur35hho8clivPu6bX/bnz2nvz+Tf/v3z8Zx/IZYt+mosmfy9zZ87LN97z/e6aG674d177gVdl3BZjUqvVstP+O+TFh74w645dZ6XjHvbeV+aGK/6dC79wSSb+59Fc8vXLcsMV/+5R88CtD+fS7/whD90+IRPvm5zzPvmzPPrAlOx+yC5JkmkTZ+TGK27Jgcfu2/09Bx67b279852Z/OBjGbbW0AwfOSz/+t2NefSBKZlw98Rc9cM/Z+p/vapHtcgluQTNpr9yaXlbv3CLPOd5m+Sy7/2x17rjv3R0bvvrXXnojv+utKZMLj2Tbcsl6DvNnkvjt98kv5n9o/x+4QV537fekdNec2Ym3LXiq8aT5MYrb8nL3/rSbLnTZkmSrXbeLAcdu2/aB7Vl7fVGrOrD000uQd9p9lx6QiPP41b1HDKRS1TXan9blWfq4TseSX25l45mTpmVh+6Y0P11V1dXZk+fk5Gj106ybJEybosx+c3sH/UYZ1BHe8ZuPia56tbcc/19eetz39/rdltaapn52Ox89R3fTldXV/5z0wMZteG6ef2HD8mPT//F0+pfftx+ue6ymzP90cd7HXeTbTfKiV87Nj8+/Re54YpbMmrsOnn7F4/K+855R778tm8lSb75/h/kA995Z86962tJvZ5J90/JleddnQOO2beXccfl75dc1+O2u/55b1540PO7v+4YOjhvPvX12e2VO2fUhuukta01g4YMyvqbrNdd8/vv/TEfOveEnPPB89PV2ZX93vSSfOfDP0yy7E+BrvjB1Tnj8o/nxqtuzc1/vC1//vk/MmPyzF73GdY0ckkuQbPpr1xa3kFv3S8P3jYh91x/30pr3vONt+Y5O2ySD7zkk72OVSaXVnXby8aVS9BXmj2XHrlnUo5/wUkZPnJo9nztbjnpvHfnQ/ucutIG+Y9PvzjrjBmZ/3ftZ1Or1fL4lFm58vxr8oaTX52uzq7Sc3oquQR9p9lz6QmNPI9b1XPIZePKJaqpaZvjS5cs7fF1vV5/2ity9Xo9tZZakqTW0pJ7b3wgn3/z/3vaWDOnzn7abSsz49GZWbpkabq6nlzoTLjrkYwau07a2tt6zGv0JuvlBfvv0P2BB7154ymH5Y6/35OLzvpNkuTB2yZkwbxF+epfT895n/hpZkyemVnTZudTrzkz7YPbs9aoEZk+aUbe9vkjM/nBx1Y6bq1WK9z22888KrscsGO+c9KPMvG+yVm8YHH+76IPpX25D4a49rc3ZMmipdnzsF2zZNGSDBrcnr9e/M/u+8966zfzq6//Pi886PnZ+/Ddc8zpR+SUA07PXf/6T+H2YU0hl+QSNJv+yqUnDB4yKPu+YY+cf+qFK6058f8dl90O3iUf2vvUTJs4o9fxyuTSqmz7CXIJ+k6z59LSJUsz6f5lH8h5740PZOtdNs9h73tFvnb8d1ZYv3jh4nzprd/KV9/5nayzwdqZ8ejMvOId+2fe7PmZNW3OKs/vCXIJ+k6z51LS+PO4VTmHfIJcoqqatjm+qv5z0wPZ+/DdM/OxWZn/LD59945/3J1937hnarVa9yuLG221YaZPmvG08Djw2H0z87FZ+delK38fzCcMHjoonUt7XlnwxJUGTw2gJYuWZPqkGWlta82er9ktf7noHysd9+E7H8m2L9qyx21P/fp5e26bK8+/pvsVwI5hHdlg/PrJn3vO5aofXpMDj9k3ixctydUX/j2LFvR8b737b3ko99/yUH72+Uvytb9/Nvu+aU/hBb2QS0+SS9AcGpVLT9j78N3TPrgtf/jxX1Z4/7u//tbs8epd8+F9T83kh1b+otoTViWXira9PLkEzauvc+mparVaBg1qL6zrXNrZ/QLfvm/YI//63U09rkRdVXIJmld/5FKjz+NW5RzyCXKJqmra9xxfVX/6yV8ze9rsnHbJydl+z20yZvzo7LDXc/Ourx6b9catm2TZezyde+dXM2rDdVc6zm+/dWXWGjUi7/rasRm35djs+oqd8saPHpbffPOKHnW1Wi0HHrNvrvrhn1f453THfe5NOfm8d3d//c/f3Zg9X7NrXnX8ARnznNHZbvetc+LXjs1d//pP95/MbLPrFtnzsF0z5jmjs/2e2+SMyz6elpZaLvzir1c630u+/vvsctDzc/hJh2TclmNz6IkHZZfl/uQlSSbeNzl7HvaibL7j+Gy2w6b52E/e1/2K6PIu+94f8/z9ts+uL39Brvj+kx8AMWb86Bz3uTdl2922yuhN1svOL9shG201NhPumrjSeQFySS5B82lULj3hoOP2y98vuX6FH7L5nrPflpce+ZKcceTXMn/Owqyzwciss8HIDOoY1F3zTHKpzLafSi5B8+rLXDrus2/M9ntukw02XT/jt98kx37mjdlhn+3yxwv++mTNU3Jp3JZj89IjX5JxW4zJ1i/cIh+74P0Zv/3G+f7HL+iuaWtvy+Y7js/mO45P+6C2rDduVDbfcXw23HzMSucpl6B59WUuJavnPK7sOeTy5BJVtcZcOb5oweJ8cO9T87bPH5lTLz4pQ0d0ZNrEGbn5T7dn/uxlr/QNHjoom2wzLm3tK/9U8amPTM8pB34mJ3z56Hzn32dl2sQZ+dX/+30u/ELPRtBO+z8vG2y6fi7//oo/RXjUmHUyern3XLry/GsyZERHDj3xoLzzrLdk3sx5uflPt+d7p/yku2ZQx6Acc/obM3az0Vkwd2Gu+/3N+cJbvp55s+avdL53/es/+fLbz8lbPnV4jjr18Nz8h9tywWcvzpGfeF13zTkfPC8fOvdd+erfP5PZ0+bkwi9ekqFrDXnaWBPvm5w7/nFP1ho1Indf9+T7YC2cvygbbz0uB/xi74wYNSIzHn08vz778lz67atWOi9ALsklaD6NyqVkWcPoeS/ZNh854PQV3n/ICQcmSb50zWk9bj/z2LNz5fnXJHlmuVRm208ll6B59WUujdxgZD7yw/dk3bHrZN6s+Xnw1ofzsZd/Njf94dbumqfmUmtrS173wYOz0dYbpnNJZ265+va8b49PZMrDU5/8ng3XyTk3P/lWCId/+JAc/uFD8u9r7siH9/vUCucil6B59WUuJavnPK7sOeTy5BJVVauX/Fuwl7W8fnXPhSbw/bu+lku/c1Uu/srv+nsqVNhVXReVqpNL1SCXaAZyieXJJZqBXGJ5colmIJdYnlyiGZTJpTXmynGenZHrr5X9j9or641bN1f84Or+ng6AXAKajlwCmo1cApqNXGKg0RwnSXLRlHMzc+rsfOWd387cmfP6ezoAcgloOnIJaDZyCWg2comBRnOcJP6sCWg+cgloNnIJaDZyCWg2comBpqW/JwAAAAAAAH1NcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKqetvydAk6rVimvq9YG3LQCAMsqsT9ZE1lzQvNbUXJI7sGbry+wqkyd6UDyFK8cBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgctr6ewI0WK3Wd9tqaW3MOPWu4ppG7Fe9/uzHAFZdX+ZSGbUGvS5cJrsKx5BLsFo0IncalBW1lsZkYL2rr/KiAdmWyDd4qibKpXKbKp5v43LJmgqaUqPO4/owu1JmynpQPIUrxwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKBy2vp7AqyiWq3g/uLXO2otBWOUHKeUMtvqqhfX1LtKlBSNUzxG6iXmAvTUTLlUZpwySuVS8bbkEqwGRZmTFOZFozKn1loml0rUlNinWmdn8Tgl1Jcu7f3+rhLzLbEug0opk0uFY5TJnNbicUrkW60R801SZpR6Z5m1Tu8jFa+nEmsqeIq+yqUya6oS2VUml+qNOoZLrKkKc6fMWqjMz0AuNQVXjgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDltPX3BFhOrVaipvfXM2otxWPUBg0q3k5ra4lx2ovHKWPJ0sKS+tLimnR29j5Gie0kXSVqSqjXGzMO9Le+yqW2Ek9H7cWZU2qcMgryJGmyXJI5rCkakDnLSgrGKbXOKV4v1QaXqGlQLtU7S2TBksXFNYsLHr8y67LiiIzsgp5qRblTJttKnH/V2ktkTplcKpGTWbykuKbEeqm+uPfsqqXEuqyrzHV/cgl6KDqPK7Neai2TXSV6UCWyq8QqsZR6mewqyKVS54slamgOrhwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAymnr7wmwnFrxaxW1llrv9w8aVDzGkI7imuHDCmvqw4cW17SV2KcFiwtrWubMK97WvPm93t/VVS8eo7OwJKl3lSiCAaDWe54sq2miXBoxvLCmPmxIcU1r8X7XFi4prGmZPbd4W/MX9Hp/w3IpJXKpXrwtWK3KZE6ZYQoyJ0lqbb0vcUvl0rAS65wRxeulzhHF+ZaW4qxtmV+8XqrN7X0tlCQpkV2FSqyFSmVXmd8J2UV/a9B6qaimNqi9eIihxblUK3OO1lGcgfXW1uJtLSpxHlcil+oLen9s6gsXFY6RpUuLt1NqTQUDQKPO4wqO81K51Kj+Ul+ex5XqL/W+ra5FxblUZuVb7ywRTNZCq50rxwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDKaevvCVRGrdaYcVpbe9/M4MHFY6w7srBk4SbrFNbM3mRQYc3SIcX7PeyxzsKa4Q92FNa0Tur9/lpn8XayqKuwpF5imFI/73q9xEAwADRRLs0aX5xLXcUlGTK9+Phc697i/WqZPL3X+0vl0uLikvrS4uyCAaFW4rqNMjUtBTVDitcV9XXWKqxZsHFxzfzR7YU1S4cUlmTI9OLjfNh/iwOucPH/eHEu1ctkV1eJdU5ddrFmqBWshZbV9J5LtY4S66WRIwpLlowuzqWF65dYL7UVn88Mml2cBYOnlFgvTev9sal3lsiKMjW1MudfJcZxHscAUGspPoYLc2lQiROnEudxi8atXVgzZ6PirOgqXlJlyIziXBr2YPF+tTzW+/21EjlQX7iosEYuNQdXjgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDltPX3BHhSraVWXNPa2vv9HYMLx1gyeq3CmqnPLx6nda8ZhTVbr/dYYc11N2xVWLPRkmGFNcNnL+j1/tqC3u9PkvrSpYU16aoX19S7imtgAOizXFpvRGHNtB2Kxxm8/9TCmueuO6Ww5m83bFtY07p4eGHN8LkFubRwYeEY9cVLCmtSK/Nad4lcqpfINxgAam29L3HL5NLiUcVrj1mbtRfWzNyu+NirDytef3Q8WDznWn1oYc2IeYt7L5g3v3g7iwvGSJISzx/1zuJhYLWqFf+elnuOLaG997yoDRpUOETn2sXH+NyNOgprZm1WvE9LhxavCYY+2vsaMElGLSnOwMFzCtZLBZmeJPWW4lyq1eUS9NCA87ilI4tzacbWxeM8/vzig699ZPG505x7i9dvY5YUn8cNndf7tkr1l0qshSJzmoIrxwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RznGdtk0oxccezXssmkGf09FYAkycYTZ+TSo76RjSfKJaA5jH9saq79+Gcy/rGp/T0VgCTJpjOm5uqvn5ZNZ8gloDmMnzI1//zIZzN+ilyi77X19wRYRbVa7/cPai8cYsnw4h/7gtH1wprP3nFJxkyfk8/eeUlu32/cCmuOGPF44Th7zV27sGbRjWMKa4a3+3WGhquVeA21KJfaio/NpcOKa+ZtWCKXbvt1Npg+J5+9/de5e98V58arh80tHGfPWesV1iy4aYPCmsJcKvP4thQ8vknSWVwCa4wyx0SR1tbCks7Bxcfn4rWL5/Kau67L2Jmz8pq7r8/Zz9tnhTUbrTuzcJz7525YWLNkSPF86m2971etxGOTlj68vqboOSZJ6sXPD9D0SqyXugYX1ywqkUsH3X9jxsyZlQMfuCnf2PyAFdYsXWdp4Titixpz7jlocME4JXK/ViIrJAUDQpnnvTLnEGUUPZ+X6C91Di2uWTyyeJ+Ovu9vGTtzVo6+/+85f/cXr7Bmu5GTC8e5dO7zCmsWrVWcS0OL9r1RPwOagm4iq2TrRydlu4kTkyTPuXb6sn8vmZ55Gw5Okjz+3KGZuc3QfpsfUD3bTJqU5/4vlzb5x7Irxjf51YzMHzcoSTLzuUMye5sh/TY/oHq2emxStp28LJdeff2/kySHXnNLJq4/Mkly1/gxuWd88Qv/AI2y5fRJ2Wbaslx6za03LPv3xhsyaZ11kiR3bDgu92xY/CIcQKMsv1466KY7kyQHXnlHJm+wVpLkP1uMzgObrd9v86M6NMdZJe+96socdPttSZ585X34hEV58SkPJkkmHDAyf/vGlv00O6CK3nvl03Np2ITF2eXkCUmSiQesnX998zn9NDugit711ytywL09c2mTKY/nC9/4VZLkihdtm/eedEQ/zQ6oonfecGVe+tBTcmn69Jx54c+SJJdv/7ycePQx/TM5oJJWtF7a8NFZ+dgXL0+S/HnPLfJ/nzq0n2ZHlfg7AFbJyYcfkV+9YKcV3vfgoaPyz89v1sczAqrupCOOyK92WnEuPfzqdXLjFzfp4xkBVfexV70xv9lu5yRPnuw98e8le+2Yj777sH6ZF1Bd/7fvEfndFsvWS0/NpV/utHNOfoMX7IC+1dt66Yr9t80ZJ7+8X+ZF9WiOs0rmdXTkw288Mg+s1/NPW2Y9pyPXnrlZlg4v8T6VAA00r6MjH3rTkXlg/Z65NOc5g3PjWZvKJaDPzR/ckVMOOTIPrrt+nniXzVqSBzYclY+89zWZN2Rwf04PqKD5gzryyZcemYfW7plL96+/fk5645syr6OjP6cHVNDK1ksTNlonnzvlFVkwdFB/To8K0RxnlW34+IxsNm1qakmWdrSklmTtBxdm6KRF/T01oKI2nDEjm019IpdqqSUZ8eCiDJm0uL+nBlTUhrNm5DkzluXSgkHtqSXZbNL0jJ06s59nBlTV2DkzMn7W/3KpfVkubT51asY+/nh/Tw2oqOXXSwsHt6WWZJNHHs/oKbP7e2pUiOY4q2znhx5Kktz59jG5+J/Pz51vW/aBUuvfOLcfZwVU2S7/y6V73jE6l163fe59++gkyagb5vXjrIAqe8Ejyz6P5buH7pEXf//kfO/QPZIkO989oT+nBVTYjpMfSpJ8e59988JPnZbv7L1PkmSXhx7sv0kBlfbEeumCN7wwh/7iXfnp4bskSXa4fWJ/TouK8YGcrLLLn7dD9h+3UY57x5+SJLecvHHuf916mbuxPxEG+sdlO+yQ2zbaKCe+44okye0f2TAPvX7dzJNLQD+5cpsdc8eYjXP/AUOSJGcedUB+sd9O+e8G6/TzzICq+sNmO+Su9TfKbbssu4jgC686OD/f9UX576hR/TwzoKqeWC/NO3xJkuScd+ydS1/+vEwau3Y/z4wqceU4q2xJW1seHD26x21zNhuSertfJ6B/rCiX5m7WkXp7bSXfAbB6LWlty0OjeubSg+PWy9I2n4MA9I+lrW15eORTcmn06CxtlUtA/1jReum/G6+bTusl+pArxweaer33+5d2Fg4xaFbxe/AOmVL8wQen3/6Kwpqfr/9YYc0jd29QWLPRrOL9qi3sfb8KHjlgRepdJWqKcmlp4RBt84trhk0svgr8/+44uLDmZ+tPKayZdO/6hTUbzSiRS4uW9Hp/vczj21UivcqMAzxpSYlcWlB8jA+eUXx8Pj55aGHNfTOLPwhvyJTik8RBc4v3q7akYL86i/e7TxU9x8CaosR6qWV+7+uKJBk8qzhPOqYVX9S0ZEF78bZmFJakbV4D1ktl1kIlNGocWK3KPO816vqfouf8xcWZ07qwOLvKrJceuq+4L/TI2sV/fdcxobiXNXh28X4V7rvzrzWKS30BAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgctr6ewI8qd5VL6ypdXX1Psb8BYVjtE2ZVVgz+ubiX43Z09cqrHm4o7hm3NTe9ylJhj04u7AmBfteX7K0eIzOzuKaevF8Uy/+WcJAUCaXio6b+sJFhUO0PVZ8jK//79bCmjkzRhbW/KejuKZRuVSfN7/3+xcvKRyjVOZAlZTIpXrR83mZXHq89+M3SdZ+qHi91D6/uKazvbimY1bxGmXoxOI51+YU5NLS4vVS4eObks8fMBCUWvvXimuKzuOWFK8JWgqO3yQZ8XDxeqltYUdhTb21eJ/aZxfnxaBp8wprsmBh73MplUvWS1RIqfOD4iwozKXFiwuHKHMet+49xXMZPGtwYc3SjiGFNUOmF+fFkEfmFtbU5vaet11l+kvWQgOGK8cBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgctr6ewKVUa+XKOoqHmbp0t4LFi0q3szM2YUlgx8onst6kzuKt9VS4vWXxUuKa2bPLSzpmjuv1/sLH7sk9a4yPydYQzQol9LZ2ftmSuRSbfrMwprBi4qzYtDkIYU19fbW4vnML5Gls4pzqT5/fu/3L+nDXCr184Z+Vi+ROfVacUnRc/7ChYVjtMyYVVjTUWINM3hK8Xqp3la8XmpZULyt2pzeMycpkUtl1mVlcqnMzxL6W5nnxlpx5pTaVNGxVeK8qVZi7dG2tPd1WZIMnzW4sKbUfpfIi9qC4jVVfcGC3guWlMilUs8fZWqsl1gzlDqH6Cw4JhYUr5fKZMWgh4uPvfZpJc7jWou3VVuwuLhmTu+9oySpz+89l0r1lwrOk5cVyaVm4MpxAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqJy2/p4Aq6beVe+9YPHixmxnxtLCmtrsxvz61JcWbyudncXjLOl9nHqJMVLvKlFT8DOAiik8tsrkUlfxsVcvMU5t7rzimuLZlMucEtkll2A5ZX5Pa8VHaJnjpmiUMnlS4shLbcmS4ppZc4trWkokU6NyaXHvcy7KraRkdpUhu1hDFJ6jJam19J4q9YWLijdU5thbVGKcQe3FNWV0FidlV5lzvYIsLZVtJX4GsMYo9fxZ4vyqEU/n8xcU1xSsPZIks+YUlpRaL5XIgq4S68DC3LEWWqO4chwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqp62/J8By6vUSRV29D9FV/HpHfeGiwppaa2vxOCkeJy214pquEvtd732/l5UUjFNiDOApyuRSrffjvN7ZWbyZEjlQay2RA4uXFNbIJWhiDcicpPjYq6VELpVYL9UXLy6sKbOmKrNPKZOlZR6/gsemTGaXyq5S61oYABpwjpYk9aJDq9agtUeJY7hWIrvKaETmLBuo6By3MY+NXIKnKDr2SiwJSuXSkqXF45Q5RyvDeRzPgCvHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMpp6+8JsIrq9YKCrsZsZmmJcWolXlvpLLOxxsy5IQofX+BpGnLcFOeAXAJKKziG62VyoFZ87NXqteKpdJbZWGPUu0rkRSPyTS5BT2WOiVpBXpQ4NutdJdY5XUuLa1qKs6uMUpnTmA31zXZgTdJX52gNWlOVOkfrS3KnUlw5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4lTeuPicXdP0u4+pz+nsqAEnkEtB85BLQbOQS0Gzk0sCkOU7l7ZsJWT8Lsm/+299TAUgil4DmI5eAZiOXgGYjlwamtv6eAPSH59RnZovMTJK8rP7w//59KFMyJElyX0bmwdrIfpodUEVyCWg2cgloNivPpaFJ5BLQ9+TSwKc5TiUdVb8zL8nEJEn9f7eNzbycnBuSJH/Nhvl0du+n2QFVJJeAZiOXgGaz0lyqX58k+WvG5dM1uQT0Hbk08HlbFSrpzNoL84dskuTJ8Hri36uySc7MC/tlXkB1ySWg2cgloNn0nkub5syaXAL6llwa+Fw5vqap14trGratzuKaWq1B22rsfi1IW75Q2zVb12dko8xNktSSTMjwfLG2a0O3BZTQqGO8TC41KbkEJTUiL8qsT+pdxSUDN3JKWVBrzxdqL8rWXXIJnrWGrHWKc6mMgZxdvefS/xpQfXlODGuyhh1LjcmuhimzX6vQy5JLA58rx6ms0fV52ThzU0uyMK2pJdkkc7N+fX5/Tw2oKLkENBu5BDQbuQQ0G7k0sGmOU1nbZXqS5MJsldfn4FyYrZIk22daf04LqDC5BDSbJ3Np67y+dkguzNZJ5BLQf+QS0Gzk0sBWq9fLXdv/spbXr+65sCZq0rdVSZK2elfGZF4eqY3ovm2j+pw8mmHprHndqD9d1XVRqTq5xJpGLjUvubSGadT6pAJWmEtds+VSE5BLFSS7ksilZiaXWKFmy64Gv61KIpeaWZlc8p7jVNbSWkseyYgety0fZAB9TS4BzUYuAc1GLgHNRi4NbF6+AAAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK8YGcrF5lPgUYAKAv9eX6pFYrrrFeAsqQFcBANBCzayDOmWfMleMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOW39PQEAAFhj1ev9PQMAAGAlXDkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDmVaI6f9adP5YSvHLNK3/OjB87OYe97xeqZEFB5cgloNnIJaDbPJJcAVie5BGuetr7YyEnfPzEHHLNP99ezp8/JPdffn+9+5Ed58LYJfTGFVfbuXT+ahfMW9vc0gNVELgHNRi4BzWYg5hKwZpNLQKP12ZXj1112cw4f+/YcPvbtOXn/T6dzaWc+89uP9tXmV9msabOzaMHi/p4GsBrJJaDZyCWg2Qy0XHqqtvY+uR4M6ENyCWikPmuOL1m0JI9PmZnHp8zM/f9+KBd+8ZKM3mS9rL3eWt01b/v8kfnB3V/Lb+f+OD+87xs5+tNvSGtba/f9R536+pxz05nZ/8175UcPnJ1LHj8/H7vg/RkyvKO7pmPo4Jx83rvzm9k/ys8mfiev++CrntF8/ZkwrPnkEtBs5BLQbAZiLr3p46/JSd8/MZc8fn4+8J13PvOdB5qSXAIaqV/ec7xjWEdeeuRLMvE/j2b29Dndt8+fsyBnHnt23rbdB/LN9/8gr3jb/nntB17Z43vHbr5Bdj/0hfnkwZ/PJw4+Izvs/dwcccph3fe//cyjsuO+2+VTrzkzpxz4meyw93bZcufNeoxx1Kmvz48eOHv17iQwoMgloNnIJaDZDJRcOvzDh+bBOybkXbt8JD/5zMXPcq+BZiaXgGerz/6WY7dX7ZzfzP5RkmTI8I5MnzQjnzj486nX6901F3z2l93/n/Lw1Pziy7/NPofvnp+f+Zvu22sttZx57NlZMHfZ+1v+4cd/yQv22z4/yLJQPOi4/fLFo7+Rm/5wa5LkzGPOzgX/PafHXGZPm5NH75+yunYVGCDkEtBs5BLQbAZiLt38p9vziy/99hnvM9Dc5BLQSH3WHL/l6jvy/9713STJiHWH55ATDsznfv+xvPtFH81jE6YlSV7y2t3ymve9MhtuMSZDhnekta0l82Yv6DHOlIemdgdXksx49PGMHL12kmTDzTfIoMHtufPae7vvn/P43Dxyz6QeY/z67Mvz67MvXy37CQwccgloNnIJaDYDMZf+c+P9z2xngQFBLgGN1Gdvq7Jw3sJMun9yJt0/Ofdcf1++9LZvpWNYR17x9v2TJNu+aMt8/Kfvz/WX35xPHnxGTtjppFzwuV+mfVDP/n3nks4eX9fr9dRaakmSWq3WNzsDrBHkEtBs5BLQbAZiLi2Yt7C4CBiw5BLQSP3ynuPJstDp6urK4CGDkiTb7bF1pjw8NRd87pe598YHMvG+ydlg0/VXacyJ903OksVLs+1uW3bfNnzksIzbamxD5w6smeQS0GzkEtBs5BLQbOQS8Gz02duqtA9uzzobjEySjFhnWA5990EZMrwj1/72hiTLgmf0Jutlnzfsnnuuvz8veuVO2ePVu67SNhbOW5jLv/+nvOOLR2XO9Dl5fMqsHPuZN6beVe9Rd+iJB2WPV++ak1/26YbsGzAwySWg2cgloNnIJaDZyCWgkfqsOb7ry1+Qnz+67D2h5s2en//ePSmnH/7l3PrnO5Mk1/7mhlz81Uvz7q+/Ne2D2/OvS2/Kjz/zi7zl1MNXaTvfOelHGTKsI6f9+iNZMGdhfvHl32bY2kN71Ky13oiM3XyDxuwYMGDJJaDZyCWg2cgloNnIJaCRavXlP863Fy9ref3qngtAkuSqrotK1ckloK/IJaDZyCWg2cgloNmUyaV+e89xAAAAAADoL5rjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDl1Or1er2/JwEAAAAAAH3JleMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFROW9nCl7W8fnXOA6DbVV0XlaqTS0BfkUtAs5FLQLORS0CzKZNLrhwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKicpmiOH3Xq63POTWf29zTWGAccvU9+NeO8/p4GDGhyqbHkEjx7cqmx5BI8e3KpseQSPHtyqbwd9n5uruq6KMPWHtrfU4F+1ba6N3BV10W93n/ledfk6+85N5d8/bLVPZVSzvrTp7LjPts97fZ/XXpTPnHwGUmSHz1wdsaMH/20mt988/J8/d3nrnTs/d60Zw4/6dCM23Js5s2anxsuvyXfPumHmTNjbpKkta01b/zoYXnZW/bOeuPWzX/vmZTvnfKT3HDFLY3ZOSDJwMulJDnsfa/IwccfmNGbrJdZ02bnrxf/M+d+9IIsWbQkybJF4FtOPbzH98yYPDNv2PDtvY57yLsOzKEnHpQNxo/OYxOm5YLPXZw//Ogv3fe//G0vzcuO2jvjt984SfKfGx/I9z/+09xz/X0N3kOotoGWS2XWLM97ybZ5/YcPyVY7b5ZRG66bUw/7Yv7x6+sLxy7KpQOO3icn/eDEp33fK4a8qTsTgWdPLj2pKJeS4rUa8Oytibl0xCmvzp6HvSgbbzMuixYszp3/uCffO+UneeTeSb2OXdRfAspb7c3xw8c+2ZjZ5w275+jT3pBjt3lf922LFizOwnkLs3De6p5JOae99qy0DXryYVlr1PB8+5az8pdfXNt927t3/WhaWp+86H789hvni1f9X/580bVZme322CYnn/+enPPB8/LP396YUePWzfu+9fZ88Lsn5LTXLntV89jPHJGXHrlXvvKOczLh7onZ5cDn51O/PCnv2+Pjuf+Whxq/s1BRAy2X9nvTnnnbGUfmrLd+K3f+455stNXY7sbQOR88v7vuwdsn5CMvO737667Orl7HfdXxB+S4z70pX3nHt3PP9fdlm123yAe+c3zmPj4v//zdjUmSHffeLlf/7G+58x/3ZvHCxTn85EPz+Ss+kbdt/8FMnzRjNewtVNNAy6Uya5aOYYPzwK0P58rzrs6pF59UatwyuZQk82bN7/H4JNGAggaTS8uUyaWyazXg2VkTc2mHvbbLb755Re65/r60trXm2M+8cdn51nYfyML5i1Y4bpn+ElDeam+OPz5lZvf/582an3q93uO2ZNkVj3scumuO32nZAuWk75+YYSOH5p7r78th731F2ge35+Kv/i4XfPaXeesZR+ag4/bLovmLcv6pF+aKH1zdPc6oDdfN8V86OjsfsEPqXfXc/re78833/yBTHp5aer5zHu/5Kts+R+yehfMX5S/LNb5nTZvdo+aIU16difdNzq1/vnOl426725aZ8tBj3a9gTn7osVz6naty+EmHdtfs/+a9csHnfpnrLrs5SfK7c67MLgfsmNd98OB84S1fX+nYBxy9T44+7Q1Za70RueGKf+eOv9/V4/6xm22Q4790dLbdbct0DOvIhLseybkfuyA3//G2JMmbP/m67PW6F+cdO36ox/edff0Xct3vb8r5p16YHfZ+bt7+haOy6XYbpXNJZx6+47/53JFfy2MTpq10XtCsBlouPffFW+eOv9+Tq3/6tyTJlIen5uqf/T1bv3CLHnVdS7ueth+92f/Ne+XS7/whf/75P5Ikkx98LNvutlXecPKru0/2Pn/U/+vxPV95+7fzktfulhe8dPunXTG1PLkEq2ag5VKZNcv1l9+S6y+/ZZUehzK5lGSFj08RuQSrRi49OW5RLpVdqz2VXIJVsybm0sde8dke33PWcd/MLx47N1vuvFlu++tdTxszKddfWpFdX/6CnPCVY7L+xuvlrn/em6t++Oce949Yd3je8/W3ZvuXbJsR6w7Po/dPyU/P+GWu/tnfl+3PUXvlhC8fkyPGvSNLFi/t/r7/u+hDWThvUb54zDey2Q6b5oSvHJOtdtk89Xo9E/8zOV87/tu598YHSj9u0Nea4j3HV+T5+22fURuumw/ufWrO+dD5OfpTb8hnfvvRzH18bt6720fzu29fmfd96x1Zf6NRSZLBQwblrD+dmgXzFuaDe5+aD7zkk1kwd2E+d9nH09a+7DWAJ95PaYNN1y89j5cf99Jcc+E/VvqKXVt7W1565EtyxQ/+1Os4d/7jnqy30ajs+vIXJElGjl47e732xbnu9zd117QPbs/ihT2velq8YHG233OblY67za5b5EPnnpDffOuKHP+Ck/Lva27Pmz7+2h41Q4Z35LrLbsrJLzs9J+x0Um648t85/TenZP2N10uSXP79P2WT526UrXbZvPt7nvO8TbLFC8bnivOuTktrS0771cm59S935p07fjjv2/3jufS7f0i93usuwxqnv3Lp9r/dlS133qz7BGvMc0Zn15e/IP9aLj+SZMMtx+Rnj3w7P7z/7HzsgvdnzHOe/vZPy1uWOYt73LZoweJsvesWaW1rXeH3DB46KG3tbb3+uZ5cgr7TX7n0TNYsZZTNpSHDO/LjB7+ZCyack9N/c0o2f/74XseVS9B3qphLZddqy5NL0HcGUi498f7fvZ1vlekvPdX6G43KqRd/ONdddnOOf8FJuezcP+atZxzZo2ZQx6Dce9MD+eTBn8/bn/fBXPrdq/KRH74n2+y6LNv+ctE/09Lakhcfskv396w1akRe9Kqdc8V5y15YOOXH7820R2bk3buekhN3+Ugu/MKvsnRJ50rnBc2gaZvjc2bMzdnv/X4euXdSrvjB1Zlw98QMHjooPz3jV5l43+T87IxLsnTx0my3x9ZJkn2O2CNdXfV8+W3fykO3T8iEuyfmrOO+mdGbrJcd93lukmTR/MWZcPfE0gfm1i/cIs953ia57Ht/XGnN7q9+YYaPHJYrz7um17HuvPbefP7N/y8f/9kHctmin+aiyd/L3Jnz8o33fL+75oYr/p3XfuBVGbfFmNRqtey0/w558aEvzLpj11npuIe995W54Yp/58IvXJKJ/3k0l3z9stxwxb971Dxw68O59Dt/yEO3T8jE+ybnvE/+LI8+MCW7/y/Qpk2ckRuvuCUHHrtv9/cceOy+ufXPd2byg49l2FpDM3zksPzrdzfm0QemZMLdE3PVD/+cqf91tQHV0l+5dM2F/8h5//ezfOWvp+eyRT/Nj+4/O7dcc0cu/MIl3TV3/+s/+eLR38gpB302X3nHOVl3zMh87e+fzYh1h6903BuvvCUvf+tLs+VOmyVJttp5sxx07L5pH9SWtdcbscLvedvnj8y0iTNy0x9uW+m4cgn6Tn/l0jNZs5RRJpf+e/fEnHns2fm/Q7+Qz73pq1m8cEm++rfPZNwWY1Y6rlyCvlPFXCqzVnsquQR9ZyDl0vFfOjq3/fWuPHTHf1daU6a/9FQHn3BAHn3gsXzrA+flkXsn5U8X/C1Xnn9Nj5rpk2bkF1/6be7/90OZ/OBj+fU3Ls8NV/w7e73+xUmSxQsX508//VsOPObJzHnpkS/JtEem59/X3JEkGb3Jernpj7fmv/dMysT7Jucvv/hnHrj14ZXOC5rBan9blWfq4TseSX25l7RnTpmVh+6Y0P11V1dXZk+fk5Gj106ybJEybosx+c3sH/UYZ1BHe8ZuPia56tbcc/19eetz3196Dge9db88eNuEXj947uXH7ZfrLrs50x99vNexNtl2o5z4tWPz49N/kRuuuCWjxq6Tt3/xqLzvnHfky2/7VpLkm+//QT7wnXfm3Lu+ltTrmXT/lFx53tU5YLngefq44/L3S67rcdtd/7w3Lzzo+d1fdwwdnDef+vrs9sqdM2rDddLa1ppBQwZl/U3W6675/ff+mA+de0LO+eD56ersyn5vekm+8+EfJln2VjNX/ODqnHH5x3PjVbfm5j/elj///B+ZMXlmr/sMa5r+yqUd9n5u3vSx1+brJ343d/3rvozbYkze9dVjM+PRx/OTz1ycJD3+RPih25O7rr0359/3jRxw9D65+Cu/W+G4Pz794qwzZmT+37WfTa1Wy+NTZuXK86/JG05+9Qrfr/zwkw7JPkfsmQ/ve2qv7+0rl6Dv9FcuPZM1Sxllcumuf/0nd/3rP93fc8ff78m3bvxiDn3Py/PN9/1ghePKJeg7VcylMmu1p5JL0HcGSi695xtvzXN22CQfeMknex23TH/pqTbeZqPc9a97e9x257X39Pi6paUlR5zy6ux9+O5Zb9y6aR/cnvbBbVk4b2F3ze+/+4ecfd3nM2rDdTN90owceMy+PZrsF3/ld/ngd4/P/m/eKzf98bb85aJr8+gDU3rdH+hvTdscX7pkaY+v6/X6016Rq9frqbXUkiS1lpbce+MD+fybe74/bpLMnDr7abcVGTxkUPZ9wx45/9QLV1ozepP18oL9dyj1gQdvPOWw3PH3e3LRWb9Jkjx424QsmLcoX/3r6TnvEz/NjMkzM2va7HzqNWemfXB71ho1ItMnzcjbPn9kJj/42ErHrdVqhdt++5lHZZcDdsx3TvpRJt43OYsXLM7/XfShtC/3waPX/vaGLFm0NHsetmuWLFqSQYPb89eL/9l9/1lv/WZ+9fXf54UHPT97H757jjn9iJxywOk9Tk5hTddfuXTMp4/IH378l1x27rK3b3ro9gnpGDY47//2O3PBZ3/ZY6H3hIXzF+XB2yZk3JZjVzru4oWL86W3fitffed3ss4Ga2fGozPzinfsn3mz52fWtDk9al/3oYPzxo++Jh952afz4G0TVjLiMnIJ+k5/5dIzWbOUsSq59IR6vZ57brgv47ZYed7JJeg7VcylZ7JWk0vQdwZCLp34/47Lbgfvkg/tfWqmTZzR67hl+ktPVSJy8roPvSqvef8r860PnJcHb5uQhfMW5YSvHJO25TLn/lseyv3/fjgve8teueGKf2f88zbJJw/5fPf9Pzrtovzpgr/lRa/cKbse9IK85VOH53Nv/OrTXgyEZtK0zfFV9Z+bHsjeh++emY/Nyvw5C571eHsfvnvaB7flDz9e+QfOHXjsvpn52Kz869KVv6/TEwYPHZTOpT2vxHziSoOnLoyWLFqS6ZNmpLWtNXu+Zrf85aJ/rHTch+98JNu+aMsetz316+ftuW2uPP+a7jDqGNaRDcavnyz32QtdnV256ofX5MBj9s3iRUty9YV/z6IFPd9b7/5bHsr9tzyUn33+knzt75/Nvm/a06IKetGoXBo8dHDqXU/Pj1qtllqttsITrvZBbdlk23G5/W8r/hCX5XUu7exegO37hj3yr9/d1GPM13/4kBz58dfmowd9ptQHqcglaF6NXi+typplVRTl0lNtvuP4PHj7yl+4k0vQvNaEXHomazW5BM2rr3Pp3V9/a/Z49a758L6nZvJDxS/orUp/6QkT7nokux+6a4/btt1tqx5fb7/ntvnHb27IH3/y1+6xxm05NhPueqRH3WXn/jGvff8rs964Ubn5D7dm6iPTe9w/8T+P5pdfvTS//Oql+dhP3pcDj9lXc5ym1rTvOb6q/vSTv2b2tNk57ZKTs/2e22TM+NHZYa/n5l1fPTbrjVs3ybL3ED/3zq9m1IbrFo530HH75e+XXL/SD0Go1Wo58Jh9c9UP/7zCtx847nNvysnnvbv763/+7sbs+Zpd86rjD8iY54zOdrtvnRO/dmzu+td/ut+SZZtdt8ieh+2aMc8Zne333CZnXPbxtLTUcuEXf73SeV7y9d9nl4Oen8NPOiTjthybQ088KLss96d4STLxvsnZ87AXZfMdx2ezHTbNx37yvu5XRJd32ff+mOfvt312ffkLcsX3n/yA0THjR+e4z70p2+62VUZvsl52ftkO2WirsZlw18ReH0Ooukbl0j9/d0NedfwB2ecNu2fM+NHZaf8dcvSnj8i1v7khXf87EXvHmUdlh72emzHjR2ebXbfIJy/6UIauNaTHn7g9NZfGbTk2Lz3yJRm3xZhs/cIt8rEL3p/x22+c73/8gu6aw086JMecfkTOeus3M/mhqVlng5FZZ4OR6RjWsdL5yiVoXo3KpTJrlo5hHdl8x/HZfMfxSZZ9QN3mO47v/iC55Jnl0pv/73XZ5YAdu8f70LknZPPnj8/vzrlqpfOVS9C81oRcKrNWeyq5BM2rL3PpPWe/LS898iU548ivZf6chd3nW4M6BnXXPJP+0lP99pyrMnbzDfLOLx2djbbaMPu+cc8ccPQ+PWom3T85O++/Q5774q2yyTbj8v5vvyPrjhm5wsdn1Lh18/K3vTSX/+Dq7tsHdQzKu7/+1uyw93MzepP1st3uW2erF26RCXc/8rQxoJmsMVeOL1qwOB/c+9S87fNH5tSLT8rQER2ZNnFGbv7T7Zk/e9krfYOHDsom24xLW3trr2ON23JsnveSbfORA05fac1O+z8vG2y6fi5fbvGxvFFj1sno5d4L7srzr8mQER059MSD8s6z3pJ5M+fl5j/dnu+d8pPumkEdg3LM6W/M2M1GZ8Hchbnu9zfnC2/5eubNmr/Sedz1r//ky28/J2/51OE56tTDc/MfbssFn704R37idd0153zwvHzo3Hflq3//TGZPm5MLv3hJhq415GljTbxvcu74xz1Za9SI3H3dk++zvnD+omy89bgc8Iu9M2LUiMx49PH8+uzLc+m3V34SCjQul37ymYtTr9dzzOlvzHrj1s2sqbPzz9/dkO9//KfdNeuNG5WPXfC+rLXeWpk1dXbu+ue9ee+LP57HJjz5gUtPzaXW1pa87oMHZ6OtN0znks7ccvXted8en8iUh6d21xx8woEZNLg9p/7iwz3m9MPTfp4fnXbRCucrl6B5NSqXyqxZttpls3zp6tO6vz7hy8ckSa4875qcedzZSZ5ZLg0fOSzv//Y7s86YkZk3a37uv/nBfHDvU3v9jBi5BM1rTcilMmu1p5JL0Lz6MpcOOeHAJMmXrjmtx/eeeezZ3Rc6PZP+0lNN/e+0fPp1Z+WELx+TQ044IHdfd19+8PEL8uHvn9hd85PTL86Y8aNzxuWfyKL5i3Lpd/+Qv19yXYatPbTHWPPnLMjfLv5XXvTKnfKP5a4I7+rsylrrDs9Hzn9PRm6wdmZPm5O//epfOf/Un690XtAMavXe/kZ1OS9ref3qngtN4Pt3fS2XfueqlX6AH/SFq7pW3HR9KrlUDXKJZiCXWJ5cohnIJZYnl2gGcqk6Pn/FJzPh7kdW+mHo0CzK5NIac+U4z87I9dfK/kftlfXGrZsrlvuzGID+IpeAZiOXgGYjl4C+NGKd4dn5gB3y/P22zzfec25/TwcaQnOcJMlFU87NzKmz85V3fjtzZ87r7+kAyCWg6cgloNnIJaAvffPGL2TEOsPzvVN+nEfundTf04GG0BwniT9rApqPXAKajVwCmo1cAvrSUZudWFwEA0xLf08AAAAAAAD6muY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5bT19wQAoOnUasU19frqnwcAAACw2rhyHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACqnrb8nAACp1fp7BquuEXOu15/9GMDAVyZP5AUwENdLZcg3APqRK8cBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgctr6ewL0g1qtv2fQP+r1/p4BrJkakSm1NfS12npX7/c3Ko/lG6yavlwLlcm3oqxI+m7O8gRWXV8dn2vqeiklMrAR5Bs03praX5IXlbKmPrsCAAAAAMBKaY4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJWjOQ4AAAAAQOVojgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAldPW3xNgFdVqDRijMa+J1FoaMJeS6l31BozSVWJDjdgOrEEakDm11tYGTCSlsqvWWlxTb9RxXiaX6r0/fqWyrV4iu8r8nOQbVdJH66XGrYUak5N9tl4qQ+ZATw04ByuVOWW206jsakjmxHoJ+ksT9ZfKbaox2VXv7CyxsQZsS54MGK4cBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMpp6+8JsJxa7dkP0dpaoqjEayItxXOplZlvS4ltdXUV19TrxTWdnb0P0VXmtaAScymjzHyhv5U5hkvkRa0oL8qM0V7i6ahEvtVaS2yrq/j4rJc5hstkV0EuZenS4rmUya56ibmU+XnLLgaCBmRXYW6VGCMplzml1kKNOj6LMidJCjKwXmIImUOlNGi9VDhEg9Y5pTKnzDljGY1YCyWp13t/jGspMUaj1kuwpuir/lIZDRqnTA+qzHlcrUxmF+RFvcQ5Zan+krVQU3DlOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFROW39PoDJqtRI1xa9V1FoKxmltLR5j0KASNe2FNWkr/vWptRTvU33x4uJxlix99uMsLTFGV4nXi+pdxTXQ38pkTplhijInKcydWpmsKJNLg4tryuRSWktk7dLOwpr64iXF21q0qPf7S2RkyuRf8XRlFwNDX2VXs62XSux3vcQ6plYil8qsuwrHkDmsKfrqHC0pXi+VmEuZXEqJXCqzNivz2NRLrJfKnIOlIJfqxSOklhJrtzLneimRXfUyM4LVqFHrpaL1UJn8K5M57SUyp0wulVArcXyWOo/rLMiURp2jyZym4MpxAAAAAAAqR3McAAAAAIDK0RwHAAAAAKByNMcBAAAAAKgczXEAAAAAACpHcxwAAAAAgMrRHAcAAAAAoHI0xwEAAAAAqJy2/p4AT6q11IqLWlt7H2PQoMIhWoYNLayprzW8sKZrWEdhTdqKX3+pLV5aWNMya17xtmbN6f3+BQuKx1haPJd6V5nXlLqKS+r1EuPACtRKZEWpcUr8LpeoqbX1/lRSG1KcFbUyuTS8uKZraHEGdpXIpZYyuTS7RKbMLvhZzS8xRmdnYUmtXvw7US8eptzvluzimWpQdtUK1kJJCtdLLWVyaciQwppSuTS8eJy0Fj82LQuWFNbU5s4v3tbcgjXVgoXFY5RQKnNKFcGaoVaQgbWOwcVjlMillMi3ekfxeqlUZi8pXi/VFiwqHmdBwdps0eLCIeqLi2vSVTxfWGM04Fyv1l7cMix1rjd8WGFNfWiJ/lKZXFpcvF5qKbFeqhf1j7qKez71EudxNAdXjgMAAAAAUDma4wAAAAAAVI7mOAAAAAAAlaM5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACV09bfE6iMWmNeh6i1tvZ+/9AhhWPUR40srJm/6VqFNXM3LP716eyoFdYMmdZVWDPigeJttXUWjNPZWThGvV4vrEnX0uIaWJ3K/J629J4VSVJrKT4+a63F2VVr7/34rHV0FI7RNXJ4Yc3CscU1C9Yr3u+utuL97phZnBcdj5XIpYL7ayVyqVR2dZX4naiVqKkX5zGsVmXWSyVqitZLGTy4cIz6yBGFNQs2WbuwZv7o9sKazkGFJRnyePHxOey/xQMVpuSS4nVOvVR2FZekVpzHpZR5XoTVqShzkqS9IAvK5NKw4nO9rrWHFtYsWbt4bZYSh2frwuIDvXVWcQa2FB3DRed5SbJkSXFNiZ9TfWmJbZXJLrlEPyt1rld0Hleiv1Rbq3i9tGTsyMKahesXr2E624v3adDsEudxk4vztuWx3u+vl8ilWomaepn1Ukrkksx5Vlw5DgAAAABA5WiOAwAAAABQOZrjAAAAAABUjuY4AAAAAACVozkOAAAAAEDlaI4DAAAAAFA5muMAAAAAAFSO5jgAAAAAAJXT1t8TWCPUasU19a4S47QXl7T1/iOrdQwuHGPxekMLax7fungu8144v7BmreELCmseu2fdwpqWpcVzXmvuot4LFhTPpbZ0aWFNOjsLS+rFJfDM9WHmpKXEa6gFuVTvGFQ4xJJ1hhTWzNug+Clr7ibFj01XiWe+RY+XKKoXlwybt7jX+1vmFv8M6q29j5GkVC5FLrGmaCk+zhuyXho1rLBm9vjiY3jm1sVh0bVW8fpjyIPFWZp68XppxLyC9dK84vVdbXGJXCrxcyq1XqqXCFtYkTLrpVrxOqdWJnNKbKvW2vu2au3FedI1vHi9tGj94hxYNLK1eFsllkLt84qLhnQVH8Mt8xf2XrCoxGRai/cpnWXWxyXWvmXW2fBMNSi7StUUHDdF66kk6Vx3eGHNnE07Cmtmblk8386O4jwZNrE4C9ZdWjzO4Hm951JtYcF6Kkm9pcx5XHEJq58rxwEAAAAAqBzNcQAAAAAAKkdzHAAAAACAytEcBwAAAACgcjTHAQAAAACoHM1xAAAAAAAqR3OcZ2z8o9Py9xO/mPGPTuvvqQAkSTadPjXXfOW0bDp9an9PBSBJMn7q1PzjU6dn/FS5BDSHjedMza8vOT0bz5FLQHPYdPrU/PlLzuPoH5rjPGOH/P3WjJ0xOwf/49b+ngpAkuRVt9+UMXNm5ZW339TfUwFIkhxy480ZO2tWDr7p5v6eCkCS5ICHbs4GC2blZQ/LJaA5vOq2Zedxr7rNeRx9r62/J1AZtRKvQ7TUnn1NS/F2lna0FtYsHFVf4e1bT56U506amCR547XXd/87aJuuJMmDW43KhC1GddfvuvZDhdv65py9C2sWjegorKkP6v3XuVbmZ9DVVVwDA0GZ3/d6id/3WolcKtJe/FTTNah4vkuGr3guW06blG2mLsulQ25flkuH3n5DHt5wZJLkzo3G5e4NN3xyW0OK97tlcfGcl3YUz7neXpC3bX33NFwr8RxT7+yDibBmakRWNFLR73tr8Vqoc2jx8blo5Iq3s9Vj/7+9O4+Xs6rvB/6ZuyQ3ATQIhCUIKCBYEFQQKKKAgqKCuOKCKCjutq7gXlyooqittVhq61YUd4u7LHWpv9YqiCsIyBICAQJkIXtyl/n9EQwEyT0nMLkzN8/7/Xr5wtw59zznmTvPZ77nO3Pn3pSHz1uTS8/5zZpces6vL86tu01Pklz+kO1y1S7brR0/8wFLi8eas2y74pjh2RXX+cD42dWquG9q6k2YFGpqoVRcEzVKtVlFjo5Nqciuqfc+z6533Jzd71iTS0+5/pI1/539q8yd8aAkyRVbzcrVD7qrXhotb7/SN1Ie066o8doDhfOq2Sf3mprnxfa977lhorRKj9OKvUqprkiS1evbx82/KXveviaXjv393fZxO81Ikly24w65Yse7cimblUNn1bKpxTHDm5ezdGqp1qnIpeL9WzmPPdrGpznOBvmb/7ogT77890mSPz+Vbzt3SV57+k+SJL84dJd89INP6s7igEZ61S/PzxHXrptLO82fn49+6StJkh88Yu+85qUndmdxQCO95v+dnyddtW4uPXjewpzxz+clSS448OH521Of153FAY100hUX5rCb/5Dkrlzaccn8vPdnX06S/NfOj8ipTzyxO4sDGumVl1yQJ86+xz7u9vn56H/cuY975N559Ste0qXV0STe9sEGeetznp/z9n30vd7206N2z1nvOmxiFwQ03ruPeEG++7D9ktxVVP35v9/cf7+c8sLnd2VdQHO942kvyLf3uvdcOu/x++Ttf/OMbiwLaLC/f/Rx+eGOj0ryl7n03V33y3ser14CJtbfHf78fHe3Nf2le+bSNw54dN7yYm8kYGJojrNBlk0dyinHHZ9rt9pmna/P3emBOevvDs/KzaZ0aWVAUy2fMpR3Pun4zJ6xTf78S2mtJNfM3CZvPv4FWTZU8XvBAB20fOpQ3nbM8bluy3Vz6dodtsrbXv+sLJtW/pVfgE5aMTiU0/d/QeZstvU6uTT7gdvktENfmOWD6iVgYi2fMpR3P/H4zH7gPfZx226TN59oH8fE0Rxng+2wcEEeOv+2tJKsmjqQVpJZc+7IVreUPy8TYGPYfvGC7LJoTS4tHxxMK8mut96WHRYu7PbSgIba4Y4FecjCNbm0YsqaXHroTfOz/W2LurwyoKm2Xb4wOy27fU0u9a/JpV3uuC3bLVUvAd2x/ZIF2eWOO/dxd9ZLu867LTsskEtMHM1xNth+c2YnSb51/L45+fsn5FvH75Mk2fN3t3RxVUCTPfLm65IkZz/hsOz//vfkXw8/LEmy/7XXdW9RQKM96sY1+fNvz3hsDv7sKfn3Yw9Okux3xZxuLgtosH3mz06SfO4Rh+eIF743n3/EYUmSR85TLwHdse8ts5MkZx95WPb70Hty9hGHJkn2v2Z29xZF4/iDnGywH+61T/7whh0z47g1r+R98bUH5UdH75lbZz2gyysDmurC3fbN5TMfnN/vv3WS5IynH52vHnRA5my1VZdXBjTVBXvum8u2e3CuPWrNrwR/5MVPyjee+OjcsO2WXV4Z0FQ/nvWIXDFjVq7aefskyT895ph862EHZu4W6iWgOy566D754zY75jeH3rmPe9bR+epjD8icreUSE8c7x9lgwwMDuW6bmet87eadZ2R0wMMJ6I6R/oFcv+W6uXTtzJkZ6e/v0oqAphvuH8jsrdbNpetmbZ2RAbkEdMdI30Bu2GLdXLr+gTMz0ieXgO4Y6R/I9TPusY/b1j6OiaWbCQAAAABA4/hYlV4y1i4OaY+OjXt7a2z825NkYOVocczQ7VOKY3559S7FMX/YYvvimNaN5b9APHVx+bxaq4bHHzBWPm/gHtrlXCqOGSlfe32ry9f41Dsqxswvv+Y7OtQqjpmyuDgkU5aWz6u1cmT8ASOF2zuoXfEcA/dZTVa0ytdeq688pkrp8T5cvvb6l5fHTF04WByzaM7mxTHXbz6tOGbabeV8m7K0vObWcCG7RivqpYp6E7iH9v2/bvpWVWTXyvJxBleU86S/sLVKkoEVFXu0ihqvVagV2zW5VPM8NJF6bT1wL0rXVqtir1KsK5JMXVy+HqbdWH6n+PAW5eyaWvF3PKfcUXNe44+p2Vu1K3LAHq03eOc4AAAAAACNozkOAAAAAEDjaI4DAAAAANA4muMAAAAAADSO5jgAAAAAAI2jOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANM5AtxfABhodHffm9rLlxSkGby+P2fLK8kNj6qKpxTHD04eKY2bcOv45JclmN5TX3Foy/pj28EhxjvboWHnMWLs4BrquXX4sJ/3lIWMV8xRyqbV8ZXGKwYUrimOmTym/nts3Us6usYpnvilLyrk0df6q8nqWjX9e7eHh8mIK92+SRC6xiah5jm21ymPapetmZfn6HZy/rDhmxjXlHB1cNlgcMzZYUXfdUc6C6TeW19xaWsil1eVcarcrfgZyiW6reJym1SpPU/NYrjlWaZ+xenVxitayck01dX45l/pXTSmOafeV75u+1eVcGlhcXnNKuVOxR6uqWWvq46oaGjaimjxJzWO5fA0X+0sVe5X+BUuLYza/vlznDC4t95dGppf3g1MXlLO0pieWFeNnV7sis+3RJg/vHAcAAAAAoHE0xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDGGej2AjYJ7XbFoLHyNKP3fylZtbo4pG/+ouKY6auHi2Om3TxUHNPub5XXs3KkOKa1eFn5WEuXjn/76vJ9k3b551Q1Bjammsxpla+99ljFPKMVj/fhwjW8cmVxir4F5ddqh4bLITll4dTimHb5rknf6vKxWktXlCdaUTj3iqxtj5bXUjOmLt9qns9gI6p4nFbVSyOFC70mlxYuLo6ZWsq/JFNur6iXBsoZ2FpVPvG+O8avhZKkvXT8mqo9Uj6n1Dx/QJNU1VSFa7hUMyRpVdR3/RW1W9+SweKY9FUUTCMV9dLK8h6sXcjkmn1cu1M1TKvi/YNjndi4w8bVkb3eylXlOSpyaXCsnEsDC8r7uJpcaq0q76+yvLyPa5fGdGz/ZY/WC7xzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGgczXEAAAAAABpnoNsL4G7aYxVjWuPfvHp1cYqKo6Q1PFwes6i/PKZv/PUmSUZGikPawxVjCuferjnOWLs4pkq7Q/NAt1XkUvHaWlFxPdRcexX51r9kSnmeGlW5VM7J9urxx9RkdkZHy2M6pVWR2fKN+6rmsVP1GKyoZArXTVW9NFY+TmtVeZ7WovJ7UfoGyiV5VR1TyJw1Ywr10mhF7tfkUlVdK0/YNFRdEyUVmVOloj5JRea0KvK4Ki+GyzlZ2uvV5F9NvVS116vJLvUS3Vb1+Kp5Pi8MqNiq1GjX1EtTBjtzrJosqMiuUpZOaH+Jjc47xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxBrq9gMZot8tjWq3yNKOj4w8YqzhOxZj26tXFMa3+/vKxaoyNFYe0a+6/wn3Trrlv2uW1wKRQc82k4tobK7+G2krh2qtYSVasKI+pyKX0r6w5WlEnMiepyOyaOTqVXVWPCeiyTtVLheumlFs1cyRJe2SkOKamXqq6OjtVLxXOq5hbiXqJTUeH6qW0yvVS1bVVUlMLVeRSVY5WLKdKTa1T+jlMZL1UQ03FZNCBfGvXxNaqiuuqpnc0PFxxsLJO1EJrJircN/ZomxTvHAcAAAAAoHE0xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaZ6DbC+Bu2u3ymFarMMdY+TAj5TFpVbxuMjpaHlOhPVZx3p05UIfmmaD1wsZW9ViuyJSxQl6MjZQP01fItiQZrVhLX8WxanQqlwq5M2H5B5uSDmRXu6aEaVUcp2aeDtVLNTqSKTX1klqIJulQvVQ8TE1U1FyfNfu4GjW1WU3mdGAPVpVt9nrQeTX9pZrsqriGa668VkUudWx/1YlMkSeThneOAwAAAADQOJrjAAAAAAA0juY4jTervSTnjn03s9pLur0UgCR35tLot+US0DPUS0CvUS8BvUa9NDlpjtN4h2dOtsmKHJ4bur0UgCTJ4e3r1+RSe063lwKQRL0E9B71EtBr1EuTkz/ISSM9pL0ou2VRkuTI9vV3/nd25mV6kuTqzMh1rRldWh3QRA9pL8pu7YVJ1uTRmv9el3ljd+ZSa0u5BEyo9ddL05Kol4CJt956SS4BXaJemvw0x2mkE9qX53GZm+Suv4q8fZbl1PbFSZKfZVbe1zq4S6sDmuiEsT+sJ5d+mST5WXtW3td/SJdWBzTReuulXJIk+Vl2yPuiXgImzvrrJfs4oDvUS5Ofj1Whkc5sPSYXZackd4XXn/97YXbOma3HdGVdQHOd2XdgLsrOSdaTS30HdmVdQHONXy/tlDOjXgImVrFeso8DJph6afLTHKeRVrQG86G+A3NDNk/rzq+1kszJFvlw3wFZ0Rrs5vKABlrRGsyH+g/KDdniL3Op/yC5BEy49ddLm+fDLfUSMPHGrZfs44AuUC9Nfj5WZbJpt8tjSlqt8pj2WHnI6P1fSkeV7pt7nPfM9rI8OEuTJCvTn6GMZqcsyTZjy3Jba/rGWiVMLlWZU86L4mHGal6rrQidXsulkntk7ZpcWvOXzdfNpaXj51InnhtgU7KBNcG9z3H/sy3pwXppA917vbQ027SXq5fgz2qeh0u506n9V6tDNcFEZtcG5u1666VSLqmXYF091F+q0cs1lXppcvPOcRprr8xPknwle+S5rafnK9kjSbJ3bu/msoAGk0tAr5FLQK+RS0CvkUuTW6vdrnup6Mi+527stTBRal7Zm4w28F1iA+2xbJdlubG1xdqv7Ti2ODdns4y2vG7UTReOfa1qnFzqEZ3IlKZec/d4F8W95lJ7STmXvBNqo5NLm5hNtRbaCNRLvUsuTTITlTuT8brcwHeVqpd6l1xqIDVVEvVSL6vJJR+rQmONtPpyY7ZY52t3DzKAiSaXgF4jl4BeI5eAXiOXJjcvXwAAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOAPdXgBd0G53ewXd0dTzho2tI9fWWAfmmIRq7rtWa+OvA5qmUzVBzfWp/gCSchZ06vm+raYCJpBrj02Ad44DAAAAANA4muMAAAAAADSO5jgAAAAAAI2jOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA4wx0ewEAkHa72yvoXe4b6F2uT6BT5AkAdIV3jgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjAAAAAAA0juY4AAAAAACNozkOAAAAAEDjaI4DAAAAANA4muMAAAAAADSO5jgAAAAAAI2jOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjAAAAAAA0juY4AAAAAACNozkOAAAAAEDjaI4DAAAAANA4muMAAAAAADSO5jgAAAAAAI2jOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjAAAAAAA0juY4AAAAAACNozkOAAAAAEDjaI4DAAAAANA4muMAAAAAADSO5jgAAAAAAI2jOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOI1ojn/kR+/Jq//hxA36nnOuPSvPfP1TN86CgMaTS0CvkUtAr7kvuQSwMckl2PQMTMRBTvnMa/OkEw9b++/F85fkyouvyb+99Zxc9/s5E7GEDfa6A96elctWdnsZwEYil4BeI5eAXjMZcwnYtMkloNMm7J3jv/zBr3Pc9i/Pcdu/PKce8b6Mjozm9O+8faIOv8HuuH1xVq1Y3e1lABuRXAJ6jVwCes1ky6V7GhickPeDARNILgGdNGHN8eFVw1k4b1EWzluUa347O1/58HmZudPWeeDWD1g75uQzjs9nr/h4vrP0C/mPq/85L3nf89I/0L/29hNOe27OvvTMHPGix+eca8/KeQs/n3ec+4ZM23xo7Zih6VNz6udel28vPidfnvupPOdNR9+n9fo1Ydj0ySWg18gloNdMxlx64TuflVM+89qct/DzeeOnXnnfTx7oSXIJ6KSufOb40GZDeeLxj8vcP92cxfOXrP368iUrcuZJZ+Xkvd6YT77hs3nqyUfk2W982jrfu/2u2+bgYx+Tdx9zRt51zAezz6F/lee/7Zlrb3/5mSdk38P3ynuedWbe9uTTs8+he2X3/R66zhwnnPbcnHPtWRv3JIFJRS4BvUYuAb1msuTScW85NtddNiev2f+t+eLp37ifZw30MrkE3F8T9rscBx29X769+JwkybTNhzL/pgV51zFnpN1urx1z7t9/c+3/n3f9bfn6x76Tw447OF8989trv97qa+XMk87KiqVrPt/yoi/8dx71hL3z2awJxaNe+oR8+CX/nEsv+l2S5MwTz8q5N5y9zloW374kN18zb2OdKjBJyCWg18gloNdMxlz69Y/+kK9/9Dv3+ZyB3iaXgE6asOb4b358Wf7pNf+WJNniQZvn6a9+cj7w/XfkdQe+PbfOuT1J8rhnH5Rnvf5p2WG37TJt86H0D/Rl2eIV68wzb/Zta4MrSRbcvDAzZj4wSbLDrttmytTBXP7zq9bevmTh0tx45U3rzPGts36Yb531w41ynsDkIZeAXiOXgF4zGXPpT7+65r6dLDApyCWgkybsY1VWLluZm665JTddc0uuvPjqfPTkf8nQZkN56suPSJI8/MDd884vvSEX//DXefcxH8yrH31Kzv3ANzM4Zd3+/ejw6Dr/brfbafW1kiStVmtiTgbYJMgloNfIJaDXTMZcWrFsZXkQMGnJJaCTuvKZ48ma0BkbG8vUaVOSJHs9do/Mu/62nPuBb+aqX12buVffkm133maD5px79S0ZXj2Shx+0+9qvbT5js8x62PYdXTuwaZJLQK+RS0CvkUtAr5FLwP0xYR+rMjh1MFtuOyNJssWWm+XY1x2VaZsP5effuSTJmuCZudPWOex5B+fKi6/JgU97dB77jAM26Bgrl63MDz/zo7ziwydkyfwlWTjvjpx0+gvSHmuvM+7Y1x6Vxz7jgJx65Ps6cm7A5CSXgF4jl4BeI5eAXiOXgE6asOb4AU95VL5685rPhFq2eHluuOKmvP+4j+V3P708SfLzb1+Sb/zj9/K6T7wsg1MH84vvXZovnP71vPi04zboOJ865ZxM22wo7/3WW7Niycp8/WPfyWYPnL7OmAdsvUW233XbzpwYMGnJJaDXyCWg18gloNfIJaCTWu27/znfcRzZ99yNvRaAJMmFY1+rGieXgIkil4BeI5eAXiOXgF5Tk0td+8xxAAAAAADoFs1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGgczXEAAAAAABpHcxwAAAAAgMbRHAcAAAAAoHE0xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGicVrvdbnd7EQAAAAAAMJG8cxwAAAAAgMbRHAcAAAAAoHE0xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGgczXEAxoW2YAAAM59JREFUAAAAABpHcxwAAAAAgMYZqB14ZN9zN+Y6ANa6cOxrVePkEjBR5BLQa+QS0GvkEtBranLJO8cBAAAAAGgczXEAAAAAABpHcxwAAAAAgMbRHAcAAAAAoHE0xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGicnmiOn3Dac3P2pWd2exmbjCe95LD854LPdXsZMKnJpc6SS3D/yaXOkktw/8mlzpJLcP/Jpc6SSzTBwMY+wIVjXxv39gs+95N84m8+nfM+8YONvZQq/QP9ecHbn5kjX3xotp71oNxw5U3597d9MZec/5u1Y57/tmfkkGcemAfvOSurVqzO5f97Zf79bV/MjVfdNO7cT3jhITnulGMza/fts+yO5bnkh7/Jv57yH1myYGmSZOe/2jEvee/zsvt+D812u8zMJ9/42fznx7+/MU8XGkku3aWUS4c884C84O3Pyg67bZf+wf7c9Kdb8vWPfScXfeG/N+YpQ+PIpbuUcunuDnvewXnnl96Y/znvl3nPs2yEoZM2xVy6u+e/7Rl52QeOzzc//r38yxs/N+7cpVza0GMD941cusvTX/PkHPvao7LtLjNz65zbc+4HvpGLzrlrj/aUk5+YI084NLvs/eAkyZ9+dW0+884v5cqLr+7U6cEmY6M3x4/b/uVr//9hzzs4L3nv83LSnq9f+7VVK1Zn5bKVWblsY6+kzkmnPz9PPP7x+YdXnJ05V8zN/k9+ZN7zzVPy+se+M9f8ZnaSZJ/H75Vvf/L8XHnx1ekf6M9Jp78gZ5z/rpy81xuzcvmqe513r8fumVM//zc5+02fy/9951fZataD8vp/eXne9G+vznufvWYzN3X61Nx83a3576//PK/62IkTdMbQPHJpjZpcWrxgac79wDdzwxVzM7x6JAcdvV/e8pnXZNGtd+SSC347UXcBbPLk0ho1ufRnM3faOq8488X53X9fvrFPFxppU8ylP3vY/rvmqS8/Mtf8dva9znV3Nbm0IccG7ju5tMbRr3pSXvqBF+YfXvGvufLiq7PnAbvljZ96VZYuXJb/++6vkiT7HrpXfvzl/5fL//eqrF65OsedeuyaOmzvN2X+TQs2wtnC5LXRm+ML5y1a+/+X3bE87XZ7na8la37t5bHHHpBXPfqUJMkpn3ltNpsxPVdefHWe+bdPzeDUwXzjH7+bc//+m3nZB4/PUS99QlYtX5XPn/aVnP/ZH6+dZ6sdHpRXffQl2e9J+6Q91s4f/t8V+eQbPpt5199Wvd4jXvT4nPuBb+aXP/h1kuS7Z1+Q/Z+0b57zpmPyoRd/Iknyjqf+/Trf85GXfjJfv/XT2X2/h+b3P/vjvc778IN2z7zZt659BfOW2bfme5+6MMedcuzaMVddck2uuuSaJMnLPnh89Zqf9JLD8pL3Pi8P2HqLXHL+b3PZ/6y7hu0fum1e9dGX5OEH7Z6hzYYy54835tPvODe//q/fJ0le9O7n5PHP+eu8Yt83r/N9Z138ofzy+5fm86d9Jfsc+ld5+YdOyM577ZjR4dFcf9kN+cDxH8+tc26vXif0Crm0Rk0u/e6n6zad/vOfvp8jX3xo9jpkz3Gb43IJNoxcWqMml5Kkr68vb//C6/Mf7/lqHnHIw7PZjOnFNcsl2DCbYi4lydBmQ3n7F/42//CKs3P8O59dnLcml2qPfU9yCTaMXLpr3u996qL89Kv/myS55bpb8/CDHpbnnfqMtc3xM074p3W+5x9e/q953LMPyqOeuPc67zC/J7lEE/XEZ47fm0c+Ye9stcOD8qZDT8vZb/58XvKe5+X077w9Sxcuzd8e9PZ8918vyOv/5RXZZsetkiRTp03JR350WlYsW5k3HXpa3vi4d2fF0pX5wA/emYHBNa8B7HPoX+XCsa9l2523We9xB6cOZvXK4XW+tnrF6ux9yJ7r/Z7NHrhmQ3Zvv+77Z5f/75XZesetcsBTHpUkmTHzgXn8s/86v/z+pXV3yHrsecBuefOnX51v/8v5edWjTslvf/KHvPAeYTpt86H88geX5tQj359XP/qUXHLBb/P+b78t2zx46yTJDz/zo+z0VzvmYfvvuvZ7HvKInbLbo3bJ+Z/7cfr6+/Le/zw1v/vvy/PKfd+S1x/8znzv3y5Ku32/lg6TjlxKHvWEvbPjHjvk9/99742tRC7BRGpqLr3o756TRbctzg8/86Nx7p27yCWYOL2eS3/zzy/LL75/6dpGTklNLt2XTJRLMHE2tVxaM+/qdb62asXq7HHAbukf6L/X75k6fUoGBgfGrcPkEk3Vs83xJQuW5qy//UxuvOqmnP/ZH2fOFXMzdfqUfOmD/5m5V9+SL3/wvIysHslej90jSXLY8x+bsbF2Pnbyv2T2H+ZkzhVz85GXfjIzd9o6+x72V0mSVctXZ84VczMyPLre415y/m/z7DcenVm7bZdWq5VHH7FP/vrYx+RB22+53u951Udfkt//7I+ZfdkN6x1z+c+vyhkv+qe888tvzA9WfSlfu+Xfs3TRsvzz33zmPt5Dazzzb5+WS87/bb7yofMy908357xP/CCXnL/uuzmv/d31+d6nLsrsP8zJ3Ktvyefe/eXcfO28HPz0/ZMkt89dkF+d/5s8+aTD137Pk086PL/76eW55bpbs9kDpmfzGZvlF9/9VW6+dl7mXDE3F/7HT3PbDV7Vo1mamkvTHzA93158Tn6w6ks5/btvz1l/+5lcetHv1juvXIKJ08Rc2uvgPXLUS5+Qf3jF2dX3k1yCidPLuXTY8w7O7o9+aD799nOrz6cml+5LJsolmDibWi796oLf5Ckve2J2f/RDkyQP2++hOeqkwzM4ZSAP3HqLe/2ek884PrfPXZBLL1p/A14u0VQb/WNV7qvrL7sx7bu9dLRo3h2Zfdmctf8eGxvL4vlLMmPmA5OsCYNZu22Xby8+Z515pgwNZvtdt0su/F2uvPjqvOyv3jDucT/5hs/mjZ96ZT79x48n7XZuumZeLvjcj/OkEw+/1/F/888vy0P22SlvfNy7x513p4fvmNd+/KR84f1fzyXn/yZbbb9lXv7hE/L6s1+Rj538L+N+7/jzzsr/nPfLdb72x/+7Ko856pFr/z00fWpedNpzc9DT9stWO2yZ/oH+TJk2JdvstPXaMd//9//Kmz/96pz9ps9nbHQsT3jh4/Kpt/xHkmTJwqU5/7M/zgd/+M786sLf5df/9fv89Kv/mwW3LLrP64bJqKm5tGLJirzqUadk2uZDedQT986rPvqS3HztvL/4yJW75pVLMFGalkvTNh/KW89Z82vHi+cvGXeudeeVSzBRejWXttlxq7zmH0/K2558eoZXDY87193V1Esbmolr5pVLMFE2tVz6wvu/kS23m5F/+vnfp9VqZeG8O3LB53+S5536jIyNjv3F+ONOeXoOe/4hecvhp417HLlEU/Vsc3xkeGSdf7fb7b94Ra7dbqfV10qStPr6ctWvrs0ZL1r3c5WSZNFti6uPe8fti/OeZ52ZwamDecBWW2T+TQty8hnH55brbv2Lsa/9p5fmoGP2z5sPPS23zx3/Dxq84G3PzGX/c2W+9pFvJ0mu+/2crFi2Kv/4s/fnc+/60n0OglarVRzz8jNPyP5P2jefOuWczL36lqxesTp/97U3Z3DKXT/+n3/nkgyvGskhzzwgw6uGM2XqYH72jf9be/tHXvbJ/Ocnvp/HHPXIHHrcwTnx/c/P2570/vzxF3+6T+uGyaipudRut3PTNbckSa757ezs9PAd84K3PXO9zXG5BBOnabm05bYzsv1DZub9337b2u/587n9cPWXc9Ker8/N1877i3nlEkycXs2l3fd7aLbcdkY+ecmH1n5P/0B/HvH4h+fY1x6Vpw69MGNjf9lUqqmXNiQT/0wuwcTZ1HJp9crV+ejL/iX/+MpPZcttH5gFNy/KU19xRJYtXp47bl/3zQPPefMxecHbn5W3Hvm+XPf7OX8x193JJZqqZ5vjG+pPl16bQ487OItuvSPLl6y43/MNrxrO/JsWpH+gP4c866D899f+d53bX/eJl+Wxzzggbzn8tNwye/1Fz59NnT4loyPrhtqfX9GrCaD1uf7yG/PwA3df52v3/PcjDnl4Lvj8T9a+Aji02VC23WWb5KfrruXC//hJnnzi4Vm9ajg//sr/ZNWKdT/D6prfzM41v5mdL59xXj7+P3+fw194iPCCcWyyudRqZXDq4HpvlkvQuyZ7Ls25Ym5e/og3rXP7ie9/fqZvMS2ffMNnc9sN8+91XrkEvWuicunX//X7v8iPt3zmNbnhipvylQ+fd68NqGTD6qVSJt6dXILe1eu59GejI6Nr33hw+PMem19899J13iH/3Lc8Pce/89l5+1Gn56pfXVtcp1yiqXr2M8c31I+++LMsvn1x3nveqdn7kD2z3S4zs8/j/yqv+ceTsvWsByVJ9njMbvn05f+YrXZ40Hrn2fOA3XLIMw/Idg+Zmb0P2TMf/ME709fXylc+/K21Y/7mrJPzxOMflw8e//EsX7IyW247I1tuOyNThqasHfPSD7wwp37udWv//X/f/VUOedYBOfpVT8p2D5mZvQ7eI6/9+En54y/+lPk3L0ySDAwOZNd9d8mu++6SwSkD2XrWVtl1312yw67brXe9533i+9n/qEfmuFOenlm7b59jX3tU9r/br7wkydyrb8khzzwwu+67Sx66z855xxdfv/YV0bv7wb//Vx75hL1zwFMelfPv9geutttlZl76gRfm4Qc9LDN32jr7HblPdnzY9pnzx7nrXRewaeTS89/2jDz6iH2y3UNm5sF77JBnv/HoHHnC4/NfX1z/XziXS9C7JnsuDa8azuzLbljnf8sWLc/yJSsy+7Ib/uKdYX8ml6B3TVQurVi68i/yY+WyVVm8YMk6fwvhvtRLNZl4T3IJelev59Ks3bfPE49/XGbttl32eMxuece5b8guez84n3nnXZ9bftwpT8+J739+PvKyT+aW2betrcOGNhta73rlEk21ybxzfNWK1XnToafl5DOOz2nfOCXTtxjK7XMX5Nc/+kOWL17zSt/U6VOy056zMjB473+9N0mmDE3Jie9/QbZ/6MysWLoyv/z+r/OhF38iy+5YvnbM01/95CTJR3/y3nW+98yTzsoFn/9JkmSr7bbMzLt95tIFn/9Jpm0xlGNfe1Re+ZEXZ9miZfn1j/6Qf3/bF9eO2WqHLXP2r89c++/j3vL0HPeWp+e3P7ksb3nCe+51vX/8xZ/ysZefnRe/57iccNpx+fVFv8+5f/+NHP+u56wdc/abPpc3f/o1+cf/OT2Lb1+Sr3z4vEx/wLS/mGvu1bfksv+9Mg/Yaotc8cur13595fJVefAes/Kkrx+aLbbaIgtuXphvnfXDfO9fL1zv/QhsGrk0tNlQ/vask7P1jltl1YrVueGKuTnjhE/kp19d/zuh5BL0rk0hl+4LuQS9ayJzqcZ9yaX7cmy5BL2r13Opv78vz3nTMdlxjx0yOjya3/z4D3n9Y9+VedfftnbMMa9+cqZMHcxpX3/LOnP9x3u/mnPe+7V7PY5coqla7bv/zsU4jux77sZeCz3gM3/8eL73qQvzjX/4breXQoNdOHbvT9b3JJeaQS7RC+QSdyeX6AVyibuTS/QCucTdySV6QU0ubTLvHOf+mbHNA3LECY/P1rMelPM/++NuLwdALgE9Ry4BvUYuAb1GLjHZaI6TJPnavE9n0W2L8w+v/NcsXbSs28sBkEtAz5FLQK+RS0CvkUtMNprjJPFrTUDvkUtAr5FLQK+RS0CvkUtMNn3dXgAAAAAAAEw0zXEAAAAAABpHcxwAAAAAgMbRHAcAAAAAoHE0xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGgczXEAAAAAABpHcxwAAAAAgMbRHAcAAAAAoHE0xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDGGej2AgAAAACAHtJqdXsFvavd7vYK6CDvHAcAAAAAoHE0xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDGGej2AuhRrdbEHavdnrhjAb1pIjOnl8g/6I6azKm5Pnstu2QKAFBrouqYVo+9L7c9dv/n6NR9p3brCT32CAUAAAAAgI1PcxwAAAAAgMbRHAcAAAAAoHE0xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABonIFuL4AOa7U6NE+HXjdpj5XH9PV3Zp5OaLcn5jgwWXQqU4rH6UzmtPrK622PTeB1XsqumvtXLsGG60R21czRqXqpY9RLsEmbqLpsoskU6LyO1ELlOqdm/9WpY1Wp6h1V9KCKh6nIrZq12A/2hF6r6AEAAAAAYKPTHAcAAAAAoHE0xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaZ6DbC2ADtVqF2zvzekerr3Cc6mP13++1JEna5fW0x9qlAeXjlO7fJGkXjgNN04Hcqcqc/s7kSatmmlKeVGqPdmKWiuySSzRJzXN1cY5ybnWsFqqZp0OZ05F6qYpcgo6rybaJ3Ot1SF3mVGRK8UAyh01EJ+qcpKf2aK2ac+qrWO9YTVaU52nX5EUhu1p95bW0xyrOqaZPxUbnneMAAAAAADSO5jgAAAAAAI2jOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOAPdXgB302pVjBn/9YxWX8Uc/f3lw1SMqVJzTu12ecjoaMWhxp+nXZ4iaY+Vx3TonKDrOpA5VYepypyK40xkdlVoj4yUB5UyuSLb2mM1P4OK7Kohu+i2mlyqmqdQL01gLqWvPE+r4rxraqGaTMloIS8qaqGO5ZLMYVPRieyqqLmq6pyK/WBN5nRMKXOSpD3+eqryzx6NJunAHi0pZ0rH9miDFa3HmnOq6tdUzFOzjyvkTlWPKvZ6k4V3jgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjAAAAAAA0juY4AAAAAACNozkOAAAAAEDjDHR7AY3RalWMKb9W0ervL9xeMceUKeW1DFY8NAY69PAZaxeHtIZXF8e0Vw/f/7W0yz+n9ujo/T8ObGydypy+inlKuVSRFTW51JpakV2dyqV2OZeyalVxSKuQS+3V5WzLyEhxSHus4rXu9lh5DGxMNblUNc8E1UtDU8trGazIrimD5XkqtCrqj/ZwRS20spBdNXVOp3IpFblUk8ewMXWopipOUbH/KmVbUpk5NfVSzTmNVeRFzR6tJrsK2hV7SplD13WqFqo5VE1elOqhwXKetIaGymNqcqmvInNq9qY1WVCzBytlV8UcNWnSSkV9Z6+30XnnOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjAAAAAAA0juY4AAAAAACNozkOAAAAAEDjaI4DAAAAANA4muMAAAAAADTOQLcXsElotTozTV95nlb/+K9ntKZMKc8xfVp5MdOGikPa0yvGDJRff2ktX1Ues6I8JitWFAasLE7RHh4pH6fVLo/JWHlIu2Ye6LJWxTU8MP5TSasiT1rTyrnU3mJ6cczYtMHimPRVnNPqchb0LSllTtJetrwwoCIHKsa0MlqeZqzm9XDZRZfVZE5/f3nMYCGXpk4tz7H5ZsUxNbk0uln5WO2KUrJvVWdyKX3Lxl/L8kJuJcloRVZU5BI0SSm7SvVUkrSmlzOntXl5THuovGds12TtqtXFMX3LK/ZgS5YWxxSNlDOyXRNLNXt7tRBdVtM7Ss2YwfH3Tq2hin3cZhX7uJre0ZRyBlb1l4bLF3pdvVTIrnZn9k3tsZo86VBNJd/WyzvHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGgczXEAAAAAABpHcxwAAAAAgMYZ6PYCGqNV8TpEzZj+/vFvnzJYnKK9xWbFMSPbbFEcs3rLKcUxYwOt4pjBJdOLY6bcuqw4pnjvjY4W58jYWHlMuzymXXGotMr3Tdrtiongvmn1VTwGK8a0CrnUmjq1OMfYAzcvjlm9bTm7Vm5VzsCxime+wWXl63zavPKx+m8f//5r1eRSxZj2WE1W1AQTbBpaA+Nf6K3p04pz1OTSyh3L9dLKLQu1W+rqpamLy9dwTS4VI3CsIitq6hP1EpNBzeOrZpqaemmwkEtD5XopFbk0vM0DimNWbls+1uiU8t50yh0jxTFDc5cWx/QV9mDtmmt8tGIf1+pMdsG96lCedKp3VNqjJRX10tSKns/m5X7OyJblumt48/Imrd1fvo/7V5ev4SmD5fumb1HhWDW9o5pcqtjrtdrl826PVTxu5Nt6eec4AAAAAACNozkOAAAAAEDjaI4DAAAAANA4muMAAAAAADSO5jgAAAAAAI2jOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANM5AtxfA3fS1ikNag+P/yFpTpxbnGN18WnHMypnleZbMKj98xgaLQzI0v784ZouxdnHMlJWrxh+wonwcmBRa5azo2KH6K66bQi5l6pTiFCNblnNp2fblQFk6q/yab00uTV1UnqdvuJyT05cUcqnm/q35eVc8f2S0PKRKzXra5cxmE9OhXGrV1EL9Fe/tKF1bNbk0Y6g4Ztl25VpoyS7lcxoZKl8z0+eVj9U3Us6lvuXjn1dr2fLiHFU/71bFz6lVkRXtsfIY2JiqHss1Y8a/blqD5QJldIvpxTFLdinXVHc8tLze0ZpcuqWcpVuOblYcM1TYx7VK+7wk6R8uDmmPdqoYgi6rqf1rnqsLNVV7qHyNj21eHjP8gHINs2Kriv5SxdZpyrJyvrUq6qUpK0fGvb1v2YryYmpq1oqfk53Vxued4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjAAAAAAA0juY4AAAAAACNoznOfbbTotty/mffm50W3dbtpQAkSXZecFt+dNZ7s/MCuQT0hp3n35affvS92Xm+XAJ6w84LbstPPq5eAnrHgxfflu9+7X158GK5xMTTHOc+e8pVl2a7ZXfkKVdd2u2lACRJnnb5pdluyR156uVyCegNR//u0my3+I4c/Xu5BPSGo/+wpl562h/kEtAbnnztpdl2+R158nW/7vZSaKCBbi+gKVp9rfKYVnlM0UB/ccjYtPKPfXjavb9ustvCm/KwhXOTJMdceXGS5OirLskN2zwoSfLHbWflqpk7rB0/OrV4qPQNl897bErF6ziDhfPqK9836a8YMzJSHgPd1prA1z4L2dXuL6+lPVDOgdWb3/uY3efflD1vW5NLT79sTS49/fJLcsN2WyZJLt9+Vq7c/q5cGtmsXTxW/+rymkfWk5N31x4Yf0zfQDmP23099jp2u3z/QdcVcqcml0anl6/P1VusJ5duvykPvzOXjv39xXf+95JcP2tGkuSyHXfIFbPuyqX2tLHisVatGiyOGd6sXMdMK2R2TT0qBeAeKvZ6KT2fD5av8Zp93Hpzaf5N2fP2deulYy+7JNc/eEaS5PJZs9bJpbHpo8Vj9a+uWPPUijqmdN/U3L8TqWbfrl7iPqrpHWWsQ4+vUv+jYh8yVtjvJMnw9Hsfs+uim7LHopuSJE+79pIkyVOvvSRzt1yzj7ti61n501Z3y6X+8n3TV46ujA1W3MelY9X0jiZyT879ojnOBjn59xfk8Bv/kOSujdGDF83PB7/3pSTJBQ97RN7wrJO6tDqgiV558QU54rrfJ7krl3ZaMD8f/vqXkyTn7/WIvO74E7uzOKCRXv2L83PENffIpdvn56Nf+EqS5Af77p1Xn/ySLq0OaKJXXnJBnjj7Hrk0f34++sU7c2mfvfOal53YncUBjfSyyy7M4XPX7S/tuHh+3vfjNfu4/3rII/KWJ5/YncXRKF7GYIO876+fnx/s8ugkd4XXn//7rb32yzue9oKurAtorr97wvPz3d3vPZf+85H75a3PeX5X1gU017uOfEG+s8d+Sf4yl77xmEfnLS96XlfWBTTX3x3+/Hx3t3uvl765/3455Xj1EjCxTj/gefnBTveeS9/dfb/83eFyiYmhOc4GWT44lPcc/MJcv8U2+fMvmbSSXPugbfL2Y47P8qlD3Vwe0EDLpwzlXUccn9kPvEcubb1NTj3uhVkml4AJtnzKUN755OMze8a6uXTNzG3y5he/IMuG5BIwsZZPGcq7n/iX9dI1M7fJm0+QS8DEWz44lPcd9IJcv/nW6+TSdTO2ybuf+MIsnyKXmBia42yw7ZYtyM5LbksryYqBwbSSPHTBbdn+joXdXhrQUNsvWZBd7rgzlwbvzKXbb8v2i+QS0B3bL16QXRatyaXld+bSrrfelh0WyCWgO+5eL8kloBdst2xhdl56+zr9pYcsui3bLZFLTBzNcTbYPrfNTpL8+4GH55C/fV8+feDhSZJH33htF1cFNNkjb56dJPnU4w/Pge98b/7tcYclSfaffV33FgU02qNuXpM/Zx9xWPb74Hty9hMPTZLsf+3sLq4KaLJ9b5mdJDn7iYdl/79/T/71CYclSfa/Vr0EdMc+t89Oknz2kYfnCS95bz6372FJkkfeIpeYOP4gJxvsRw/eJ1ccvWMu23u7JMlHDz8m39jnwNw4Y6surwxoqgt33SeXb7NjLt9nZpLkw085Jl/b/8Dc8CC5BHTHBbvtm8tnPji/O2BNDp3xjKPz1b8+IHO2lktAd1z00H3yx212zG8P3iZJcsaxR+erB8kloHt+tOMjcsWWp+SqXdb0lz7+18fkvIcfmLlbyCUmjuY4G2ykfyBzHjBzna/N3mrmekYDbHwj/QO5fst1c+i6beQS0D0j/QOZveXMJKNrv3bttnIJ6J6R/oFcP2Nm7vqTd3IJ6K576y+tySmYOD5WBQAAAACAxvHO8R7SbreLY1pjhTGjY8U5+laMFMcMrijPM3VhqzhmZFp5zJTF5fPuW11eT/Hcx0bHvz1JKn4GVVoVrzu1K84J7quqx1d/echYxTyF66ZVk0sV1/jUiqxYvbh87fWtKufS4JLysQYqcrJ037RHynlcpfTcABtbzfNnq3zt1R2qol4q5E5rpFwTDCwrX59TlgwWx0y9vZy1o9PL2TV1UXFIVS61RsYfU3P/dqxegk1FzfNwqaaqqAn6VpXHDC0s58DQvIpcqtjHTbu1Yh+3qiaXxs/kdsX9W/Xc0Fc+p3bFllEGcq86VAvVPN5bgxU1VV9FT2J0/Ad8Tb3UGi2vt3+4Zm9VHJLRwc7s0foq1lOql6p+3oX7l97hneMAAAAAADSO5jgAAAAAAI2jOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOAPdXkBTtMfaxTGt/op5RkfHH7BqdXGOvqUrimOm3VR+3aR/5VBxTLvinAaXjhTHDCwsr7m1bPwx7eHycYr3b632WMWY8mMCNqaaXKp5nLZK19aKlcU5+u8oj5k+rxwo/avLT2tj/a3imClLy1kw9fbymvuWjj+mPVLOpUxkLkGXVdVLrfKY0rXVWrmqOEdNLm1xQzmXBlYOFseMVdRLUxeXs2DotvKaW0uXj3t7e/VweTFjNXWOzGETUVXXl2uL0vN5e3V5H9e/cFlxzGZzy7XQ4PIpxTEjQ+X94JQ7ynXM0M1Li2OyvLCPq6mXKp4/qmpfmAxqHss1e4jSXq+ihzKwuFx7TK3Yf/WtKtdLqYjavpHyfTNYUeO1VoxfK9bUS+2KvXTVmKp9u7rr/vDOcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGicgW4vgLsZHS0OaZcGrFxZnKO1uFUcMzBSXkv/kvKx0iofKxXHai1bURzTXrVq/NtHRsprGSvew2lXjIGNql3xGKy59mrUXBOla2v16uIcfYuWFMdMrcjIwQVTimMyUH5duG95ec2t5eUMbC9dPv6A4XIutSvOO+2x8pgaNY8t6Laax/vw8PhTrCjXFX0Ly1kxteIannL7YHFMe7C/OKa1snysvpp6qZBdNfVSe7T8M6iql2p+lnKJjalDNVXV47103awcfy+zZi3lemmwIpcG5g+Vj9VfzsDWynK9lBUV9VJpD1vI9DWT1OSJzGETUfFYrtlDtAp5UVMvtfrKGTlYcV0NLCnXQp2ql1o1eVvKruGK/KvZx01kf0m+rZd3jgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjAAAAAAA0juY4AAAAAACNozkOAAAAAEDjDHR7AZuEdrti0Fh5mrHyaxWtjI4/x+rVFWupsHq4PGag4uHT1yqPGR3/nJKkXbGe9sjI+LcPj3/7mkHln1PVGJgMqh7v5Wu4fG2tLB9nrCJHV5XzrX/KYHmeVodyabgil1aMf+6l3KpeS839B902gfVSRgvz1NQ5WVYeUjFP30B/eZ6+8jnV5EVVvVSoFatySS1Ek3Qqu0pP5yMV9cnyFeUxNdfw8uXlMRX1UlUulfI4FXvYijpHLcQmo+I5tqp31Kq4bkrXcFX+lbUq6pNWzT6u5jqvWHPVPm7VqsIcNflX3sepqXqDd44DAAAAANA4muMAAAAAADSO5jgAAAAAAI2jOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA4wx0ewGN0W5XDBorTzM2/usZrYyW51i9uryU4eHymL4JfG1lrOK+GS2MadfcvzU/pwpVP2/YiGoeg61WeZrRcqa0+gtzDI+U11Jxjae/cKAk7ZXlXGrVnHfN/Vdx3xTvv4rMqcqlinyTS0wKnaqXypdnxRwV+be6XC+1KzKnqqaqycmaXCrdxzVzyCXYcIVroq5eqqgbKq7hGh2rlzqQF506J+i6Du3R6o5VUS8VcqdV04epqU9GKvJt5arymBo1513qHSXFeqgqlyaypuJ+8c5xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGgczXEAAAAAABpHcxwAAAAAgMbRHAcAAAAAoHEGur0ANlB7rHBzxesdYyPlMX2tygUVtCrWUzinNUPaHVhMhYq1pD1Ba4GNreax3CpnQfn6HK1YS8W1N1oxpkK7Jt86lTnFzK44Ts19A6yrdO1VxFJNdGW0YlBNLVSjQ1nQkZpKvQTr6kRNVbMnGqm49ioyp1VRC9VcwRO2R+sUucRkUPU4remh1NQfhTqmU8/3NfVSX4fqpbGK+6ZmzaV861Qfq1N7Pfl2v3jnOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjNN6s9pKcO/rtzGov6fZSAJLIJaD3yCWg18xqL8m5Y9+VS0DP2KG9JF8c/lZ2kEuTiuY4jXd4+/pskxU5vD2n20sBSCKXgN4jl4Bec3jmrMml3NDtpQAkSZ4wdme9NHZ9t5fCBhjo9gKgGx7SXpTd2guTJEe2Z9/53+syL9OSJFdnRq5rzejS6oAmkktAr5FLQK95SHtRdsuiJMmR7evv/O/szMv0JHIJmHh3r5eOGLsuSXLk2OzMa92ZS60t5VKP0xynkU4Y+0Mel7lJkvadX9s+y3Jq++Ikyc8yK+9rHdyl1QFNJJeAXiOXgF5zQvtyuQT0lBeN/iGPa9+Y5O65tDSntn+ZJPlZe1be139Il1ZHDR+rQiOd2XdgLsrOSe4Krz//98LsnDNbj+nKuoDmkktAr5FLQK85s/WYXJSdksgloDd8pP/AXNQap17qO7Ar66Ked473kna7PKbVKswx1pmljFYMatW8tlIxUYfWvCFWpD8f6jsge4zNz45ZmiRpJZmTLfLhvgMmfD3Qs2pyKff/Gq7LnJq1VKg5VqdsQL7dr1yq+jnBJmLS1UsTeH12uKZafy5tng//uQElf6BOJ66VUrYlVTlQlV295G733YoM5EOtA7JHe4FcgvF0oCZoj1X0fMZGymP6KrKrRk0PqlM13lh9jizPQD7Ud1D2GF2QHbPmD3Gu3cf1H9SR9bBxeec4jTWzvSwPztK0kqxMf1pJdsqSbNNe3u2lAQ0ll4Bec++5tFQuAV0jl4BesyaXltzLPm5Zt5dGBc1xGmuvzE+SfCV75Lmtp+cr2SNJsndu7+aygAaTS0CvkUtAr7krlx6W5+aYfCUPSyKXgO7Zq70mf77S2jPP7XtGvtLaM0myd1suTQatdrvud46O7Hvuxl4LNWp+lW6iVH2sSoUufKxKkgy0x7JdluXG1hZrv7Zje0luzmYZHe/c/JreRnfh2NeqxsmlHjFRudSpzJlIG5hvcql3yaVJZlOsl2pshJrqXnNpbHE5l9jo5FID9VK2TaR71Dn3uV5io5NLE2SS7b9am/jHqiTJQHv0zlx6wNqv7dhenJuzeWEf16HazX5wvWpyyWeO01gjrb7cmC3W+drdCyyAiSaXgF4jl4BeI5eAXjPS6s+NecA6X7t7o5ze5mVVAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGgcf5Bzspmov0Bb89ePO/VXdWv4y7vQuzpxffZa5nSK7ILuUC8Bm6JOXeNV2SVPoGdNVBZ0qIZpj9aspea9uzUTVeilfaWs7QneOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjAAAAAAA0juY4AAAAAACNM9DtBdCj2u1urwBoEpkDTEY12dVqdWYegE6ROUDSmSyoqXNqtMc6M89EkaObFO8cBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGgczXEAAAAAABpHcxwAAAAAgMYZ6PYCAABgk9Vud3sFAAAbhzqHTYB3jgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjAAAAAAA0juY4AAAAAACNozkOAAAAAEDjaI4DAAAAANA4muMAAAAAADSO5jgAAAAAAI2jOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjAAAAAAA0juY4AAAAAACNozkOAAAAAEDjaI4DAAAAANA4muMAAAAAADSO5jgAAAAAAI2jOQ4AAAAAQONojgMAAAAA0Dia4wAAAAAANI7mOAAAAAAAjaM5DgAAAABA42iOAwAAAADQOJrjAAAAAAA0juY4AAAAAACNozkOAAAAAEDjaI4DAAAAANA4jWiOf+RH78mr/+HEbi8DYK37kkvnXHtWnvn6p26cBQGNJ5eAXmMfB/Qa9RJsegYm4iCnfOa1edKJh6399+L5S3Llxdfk3956Tq77/ZyJWALAOiZjLr3ugLdn5bKV3V4GsJHIJaDXTMZcAjZtkzGX1EvQ2ybsneO//MGvc9z2L89x2788px7xvoyOjOb077x9og5/vw0MTsjrCMAEmmy5dMfti7NqxepuLwPYiOQS0GsmWy7dk30cbHomWy6pl6C3TVhzfHjVcBbOW5SF8xblmt/Ozlc+fF5m7rR1Hrj1A9aOOfmM4/PZKz6e7yz9Qv7j6n/OS973vPQP9K+9/YTTnpuzLz0zR7zo8Tnn2rNy3sLP5x3nviHTNh9aO2Zo+tSc+rnX5duLz8mX534qz3nT0fdpvedce1Ze+M5n5ZTPvDbnLfx83vipV973kwd60mTMJb+OB5s2uQT0msmYS/ZxsGmbjLmkXoLe1ZXPHB/abChPPP5xmfunm7N4/pK1X1++ZEXOPOmsnLzXG/PJN3w2Tz35iDz7jU9b53u333XbHHzsY/LuY87Iu475YPY59K/y/Lc9c+3tLz/zhOx7+F55z7POzNuefHr2OXSv7L7fQ9eZ44TTnptzrj2ruM7j3nJsrrtsTl6z/1vzxdO/cT/PGuhlkyWXgOaQS0CvmSy5ZB8HzTFZcgnoXRP2O2YHHb1fvr34nCTJtM2HMv+mBXnXMWek3W6vHXPu339z7f+fd/1t+frHvpPDjjs4Xz3z22u/3upr5cyTzsqKpWs+r+miL/x3HvWEvfPZrAnFo176hHz4Jf+cSy/6XZLkzBPPyrk3nL3OWhbfviQ3XzOvuOZf/+gP+fpHv3OfzxnobZMxl4BNm1wCes1kzCX7ONi0TcZcAnrXhDXHf/Pjy/JPr/m3JMkWD9o8T3/1k/OB778jrzvw7bl1zu1Jksc9+6A86/VPyw67bZdpmw+lf6AvyxavWGeeebNvWxtcSbLg5oWZMfOBSZIddt02U6YO5vKfX7X29iULl+bGK29aZ45vnfXDfOusHxbX/KdfXXPfThaYFCZjLgGbNrkE9JrJmEv2cbBpm4y5BPSuCftYlZXLVuama27JTdfckisvvjofPflfMrTZUJ768iOSJA8/cPe880tvyMU//HXefcwH8+pHn5JzP/DNDE5Zt38/Ojy6zr/b7XZafa0kSavV6uiaV/hrwrBJm4y5BGza5BLQayZjLtnHwaZtMuYS0Lu68pnjyZrQGRsby9RpU5Ikez12j8y7/rac+4Fv5qpfXZu5V9+SbXfeZoPmnHv1LRlePZKHH7T72q9tPmOzzHrY9h1dO7BpkktAr5FLQK+RS0CvkUvA/TFhH6syOHUwW247I0myxZab5djXHZVpmw/l59+5JMma4Jm509Y57HkH58qLr8mBT3t0HvuMAzboGCuXrcwPP/OjvOLDJ2TJ/CVZOO+OnHT6C9Iea68z7tjXHpXHPuOAnHrk+zpybsDkJJeAXiOXgF4jl4BeI5eATpqw5vgBT3lUvnrzms+EWrZ4eW644qa8/7iP5Xc/vTxJ8vNvX5Jv/OP38rpPvCyDUwfzi+9dmi+c/vW8+LTjNug4nzrlnEzbbCjv/dZbs2LJynz9Y9/JZg+cvs6YB2y9RbbfddvOnBgwackloNfIJaDXyCWg18gloJNa7bv/Od9xHNn33I29FoAkyYVjX6saJ5eAiSKXgF4jl4BeI5eAXlOTS137zHEAAAAAAOgWzXEAAAAAABpHcxwAAAAAgMbRHAcAAAAAoHE0xwEAAAAAaBzNcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGgczXEAAAAAABpHcxwAAAAAgMbRHAcAAAAAoHFa7Xa73e1FAAAAAADARPLOcQAAAAAAGkdzHAAAAACAxtEcBwAAAACgcTTHAQAAAABoHM1xAAAAAAAaR3McAAAAAIDG0RwHAAAAAKBxNMcBAAAAAGgczXEAAAAAABrn/wNZwQT184GdpAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_montage = create_image_montage_from_image_list(\n", " num_rows=6,\n", @@ -866,7 +593,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ From 4b8b6236d2fa46bebf420f482d1888e3ac56b149 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 24 Sep 2024 13:37:34 +0200 Subject: [PATCH 38/50] added test file for opsim data --- tests/TestData/expo_data_opsim.hdf5 | Bin 0 -> 13371 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 tests/TestData/expo_data_opsim.hdf5 diff --git a/tests/TestData/expo_data_opsim.hdf5 b/tests/TestData/expo_data_opsim.hdf5 new file mode 100644 index 0000000000000000000000000000000000000000..43ee8d97f7824bf9fb4d126f5aebe8ceb6989027 GIT binary patch literal 13371 zcmeHsXIN89xGr`91qq=yrFTSn3E9$%NRwUygwT600R%)kY)YsCLO@VD2-1-nrG?%E zLJz(7dU31gIrlv0{J8hW{d4!^NxpB*_s+Lwy)$dgyCz}s(y|ZnDDiN9mizZ{ZsR=q z$Nlqj^}C4i|El?O{3mYw+qv=EhW@tsH-9-daDIMpaL9kx6aCKrUvaP0Wn^%!k$>|4 zvA>()Y~TLn-TzbZul@gu0eP9{sy{DS=l50rnWf);&$B;dn3=em{Ph3KNBKX2|4VxV z=gvR5zWz>lsJ*% z&f|Za-?U%*KjSxW%wXoWCa$pm;Q#*b@ws*LrtsaLiGQX1ITZgCjh8CYKimCzjy%5Z z!@uSKoPnRu>l@ds|9MXTv1WgW{Vypk34T>X;r_CJ#`zDdoAj5*^gI4%&isk%KK|u3 z{937S{_C*$vHd~*vVY?LG4TI;_}`;{8Tglhe;N3ffqxnJmx2EW40sxCq$*ny>jP0+ z-HcxG%yxrfDROkal;N`VB5s_q zKwgGjJvRJR4n4^UB>Zp9E-A~Qn&AvdWH)4kk-sWaTkL+6)mm-5By_xSGqR7hP;*k% zyIoI-%N35a?zhmeHW?bgrP0-(bh6JKNllbp&i^zZ%%qgtkWZ!=!Q(0|BgFE)Rz%q; zIJ#pvwIx<_FOMywFLobjelssOHO#pmD7VaNP5=r}%4?#KSP63v432*9q>9JnURpQ)UN_=)=4wlPOdluFEfTrxJWP_fQCGcGUG5=FA zeyJ?!WS=bj5SdQwL<>@8)5({E8hzAdT4P-$a$vwOGbc4CBAx2HFCm0%AR1kB<7dau z`;LJAK){8MZ9PZXZdRZ5gw{rFnDUOa&lRQ}%!JO1zpWB9u#wIDDjMZsXTEDPo3g^D3%($iD5)JyS4X)3@2RT% zeoC(6kga2z+C8ata?-Bou{0w z)e@*r#CNZU6Rnqi?{9{8$V?h((2My-j0u|Pi_|h{G#+2eyQeYGyV$8fspHo+9(@*+ zzJx7rEBIUQmH4XAQdE(YF{_zNe=oEyMEVWc0lfx7s-uyl#SBT)&veOU&v}A1pFH`{ z7B38#W0yc94N0f7(Qf-7f;5RS+1XY?$nYA)hh9Y!`9hK9$RQ|K)O&ZISdRJ7jk~*8 zzO@eOdNP8r2-8=oh-U*-)D`Nl^niq6TTVs#$B}+Qeg4$$4W%((3DKpd-Qfbb=|ma2 zG&&)7|2`V5Mx#{;gIavEG~i6ViVV^079A;$$~A!E$cj#pxnzVl$`S@7V2Q)LQxg8-E0v&8t!+eqPHXyvCe31 zKWuUkIWvx=^O>?LEJCYcUA`5t3TISnE%0b6O^2m=R9a!Oc{Y5s#ndVmF4QaO!8ep% ztpc&CXJ``-%EOCo;(#VmDL;}xX$Px90M{4FZG#_gvH3UFeQn;_q0u^_sZxq zk2qfmojh|Rqx^6|crkd1|1hPN86$b%g~nTA+Vl*bpzBD5lT|^t`)@&>91ralJVlr? z^J?K@#=Yz}TKG%==*Lz=CAVzWpA4PIV9A%DS)v;*LX5Yhnr*Tc`zrfXpHesqQJt1M=agpDmWYe|~9 zz!>SGIBxL*y5`2x*OQ{*zE9aTMSK=%(bCEvxN)P+jy2ZSswy^0en?a@w;oe}8&V$H z_w-(5w|J%3-gtGR3OfU(gRgMpk~4OAkIDy*rOkV8$(vl%g!r1>Jrg;6jtz&8ofRKS zwyHiI+5IRm=2YOq=w84#w)0V7gzRGAX zEtb_s0k{=-Yb>v1M)yc8t@Si57Er9Ppfw@1(M0O~$ZyKMzy-6}U+i1w;MQpG^Qe(D z^)N3M5^ukb(22ml*(zOj@S-cral!UX-u82WfW(9VKqhZG@X64gv+U9f2ARGV7d&;a(toEIk|ch`2zJ4ecQd%}u!Sfmi94 zoq2GK>nszGvOvOtBb0HU&Xaqcis_kOUPzokk|~@G9mu+3Ik(j0$x0swi2( zGTKVl{OAf`*J1jhZ0)M9T6If{lRc^h`DlCt>|wBcpE4pvc2-R@%usW&mPE!%xVlfR z`x+oCtyx#Bmyi*JPZL%^8rFei$^LZEudiNW5W(TfFH>aYykZV)Uz(AWd!GCpG6VyPO))6w<-nKd8dWU?esL7u(d{bm8i&`~ORi8I;%=49Ha_~>wdx=NmdYel3c%XibI z7nJGK>y@GOqYm|vUGt-&=BIKNnZDspBHEg=#DZ;M{848B?T^Ds>NlwUliIWv=y=WM z+imjjJc#;nWz?%~b%|E_rpWCA=f(atjxTe1-m}_6>@k8(&V+hgx!X2Y2o&o_Hl>pX z3NPm*S)B-Ixtse`cHL7+;t zg>D5~`FzRuKHCqrlzt?-5e$Z;yN)f#r*T063)@ zaEg&_s%1(kJwZ7r6@a7`c~im$6HYX(o@e3fge~mkUDxtvu@;28sX7EkpO;W-`atp z?tISnF1#b-?(1%J$`Eh*h|NU}_^oD14Jpax^AyQ#pFZk1oHrm_`fOU9K*hwD3!Ode zxXyl_pGqn{7IlUR%0F8nPk;YhR7T1Q6gbEA8ud6IkVw#nMC$@gKd zA4DJmCWg-1wD0|IxrJY!fnNLgCvrbNm>RVVD%vPMNtg{rAY=6hXp&v>vy zXGmbYx&<%kh1f-B+?m0WrEIRWW73%_IB&%#Rl57j3T8hvqhBdCPg~e%?tme3s-s4s zTO_K+w>0c)l~;t!=7p&i`IoNlPy<~+2)+RKB9g}NoP;LVVOf0h#BE{b#>LBs&$4Xg z_&1(}wsPle`w`6(I$nw{rK8S~r4cPgoe?ZkXM$QLVozqZ#wpZ9+oJpstL%ZEmjM~H zSzWFXe(e|jD%p>Sd+*~uVLPXvM8&qP@sSe;9|>P^EE#s3Ym}bh9jZs2%&M#;&Y1=O zAcy79+E_Ap3r13kgeP;W-n`f*Kk|(yVAy17x%Y&zqg`Q#GP;@^05;})LQN{ji{)Kn zHg>_Q0&Noo@?f-rNjNwFaq)lKbKmxC28rLefXBhf5gf`JmP+)o96t7AqAc+++XIc% zGJo`gz5NZ_f~orCBf8Yyl+hlIL|E6|Xtu7}lXoXsR<}-0UW@RWknC9)d(a*>Y!4Fn z54>FAWaT(va%rRui;KlMT(N)EfisfjG;{%7V0i2IG{R+0bMQ8K#z=jUvJP2cfiPg? zOQnj<2TtOpf)677oXpMTH`DY>K@aIb+rxO7idws|3l_Xff6IRc(Zd+ug6tpJth()Q z)2~|NQTvCYmDiTcl$!*MJiZHB3yIazn4|J9;<$`P9h653(=yX8ak_xkwnXluCgA(v zvZBKLhVqKjXUzSZA&N2b6e1B9v)m&{WlAZ-o&W~(u#sXt3%j6b6N^cNGfjy~&0Mhw z_C0i@$~tPKgA*N_M7W%!JT?`4G486BVAQ`Eo6F>6LKm-9#JYNBQwSC+m8(a2A3V5l zA~^{ikzJGBAhPHbm~Wh?*zNTWsrL})+f3k?qpp-&%dT9@FH_jRG%5T}XzYK(&wExy zuetuth_=LcmMbLpZ?D^g>77Xdy|!pmC~WFVyi-6?DX?H@Eq_<#t(NH5M_$AiEN5R-)|oVX^#30PNyZ zH@YseT-_`4Ii*GJIhd@sC%Z?n#$PKlP1>-TefEsFm)=LCB72IV>r9O6Wp+<^Rm(Ho z&OM(F15WE;%@&U)S;kY&#S7nacb(2NA;36ey*`lCi-rS>DKe|DtjI3UPhlIy0ATUU z6|9~&i!Guq(L z0{F{}yxea+YSaKS?(2?@KY!JlntLd83rxp_!t*6KIS}F~KQC5Wr z2Jv0Rh^F6)hvsAl@}=?Y$|K(DedNnJ2UC(Zm}M|(N8f3k*7K#MWMSHd6{|L ztg{tthU8VruGX!eMW)dTZdlftEfk&ehk(Ff4Xypa+C;PGx@Ah!9UVX-L`Ah(ID&+YJ0n)=Kg$R zW)5?>M&QIU)oPCY>i17nD9nt(&C%38=D;d?q325G;jJyc!Y-EM_h*eV|4Jwd{Sx1p ztHJ+Q5dZZi$6H77*DjbjJ*o-*EW2B$%PCH#vuf1S)%Sv={&pmYjbgRVLri>(I9=v{ zICwv5K-e(*dm;C%ClLGAsff^SqF?Z>1U+93=aN8*oU_jSMGr;)2nU}WXw#98J&#z8 zKs~&d;gEx03Ecm%Rsr90>gx_?ukxH8p51AmV1NWm-)MJs2{f2~wqb+4tJ?{%SM#vK z$eq`&4!_mC^GMCwtmaZe)+{=Z)u?r27IDz}gm1h>h&$&RvsY zN@|*Yn$3N}YAoNkW`D~l!4G=Z!l!}x6!%@;cbAa8w{=C*Uz-twoV3Jfu zAqG9z9bQOlK4Eizga}9xJm7XJw0Q;fmWl%=#SP>nBo@yKgw0noDmXaW(byFuH&{>i z&2?XXjluJm4cXZ`{~1M|C@f4oFrPwg~IX4 zeA${>93$^<44ubRqq;r^rHaP*(8X?j2Xzv|CJqLMXK9^0sv)%>3{?_n7io80=JG89lGIAj?o=Ap zKPqO?aO)6T1kLxn+VGwZ#3Hg;iFXAj6b9&)U1)sKEplRTnHddqIIs4){4TT%TUxAV z8vUm1TI9!2wWW#%iPVSHiV{Xsh=du~){%Xp^`?8pb6R`OcgcN~z4iP+YD;ps%4Y)c z%KWP{tw2?nAK&t|fGXN1>+MCrwMyaZj{$bW0GAwGmrBC3NmyaQS~9jFzW~?qe6Dsm zW!L=E=($)xRBG8w`izbv(wwDq3H?gNi^tpVM%QiYLNXVB8eg7PIXbui3>#h*NRlaC z!c}J7u7=4gyX-cN@r*oJC0z;$gd6O0dXf1S1e6&=i&Uo6kG6L|MpZ(ahreb!;BpRf z%Y=RVQW_1C#poUjKZNY8rSk05Wo^rKB=_4`f@@`jx$BzpKZPv z+H@_Q_vksa87N#!rInr0p|ft!NxH{hEL}%6kd+`xYOn|1Z*&8z*+Yxla`TqK_~2XH zqYs*bQ`zptTXHx8(d6kmE*(3Ob&(dI7!S9xyPs`F_uhN6^y&P7Bo#x#B&?~e{HC6f z`Av&WsaoBE6qO53hRSSv${f2ZX6$7tI?iys`~n?2A-^x z5e@bVOdS)wl`)mMfD(PvvaDqTPyB=7MezKFBTJcIZm!{e6E0Zcm``59|DZEOT3m#Z z5#RG_C!^S;5uz$vYTt9bb^B;YZWggTHD+)wGiPx27pmrvEUe~uihPx;K5rVg_c*Vf zVG}=jZ?qI_|1~5f=kS|+WAr;X*WSXKZe6DpxD5K8i7f;)9lfyTwOI~n=seI(9@Rc+ z0<&R`BHD=+j86Js>cF z0}Yov3&nfO4`*rJNYKafZwq5Zh`Eo=0*juHL0MD?o?di5TW=!sZ@K_KhBbWrDUu8=iB~95m=v?r9A#69Ga}-_iT&0I zyvkaxO3*udqIOXGhSiZQEK5g_1DFGAV1-rgKkkzJNQTYMsPK8hT5MGFzLdMj8E7~{ zrLU?3^nT(^yq}%q_xjzH*r1bnMoOC>qaD5PZlO3OXwFaM;-`zU#weSzgLT#=@BAFKPM)uxqhy6 zw%NCS#lO^@UGdQwwl6B%&zi)u`aOT0sv*#bUyxg0uRqpc2x&Afuxdyg71oh%{VE|vGNR$zW4=K}%MtUTGL9m-4!**co@zMWq^(S{3xMCy9W&TI6C?KPi5{i@uYWZ#G;=;Iw7hV@qfQvnw>zqMF`n zE;AI?4&g;Sdx(yTqsZ+n?~=qOizHn3ePVw-!DDg#Za`eUrEDvdy=iP{3l{s{F%0CjZm=25%cs%1xB#6>U8%Ua|!T8CKr7CUZ#ni~(zB3pfAg1_lc zmMziUXeu|3LuICL$Ym7d=?_E^T<@uMd^WbFS!!G8-e%X(*>5P>BBdNg=`MS^$nIav zwu-(Ar=5N)Hu-wON-7~l2Yi;AZp>gCc@c5(jd>hs1fIJfk52zu;}^NoGG^YbU~GR| zBJf$n2#-w<9*tdZXsr?3Me`ofbHvd5yra^WlUsh1XYuPkZI{G#E%v4Q>)drAqg?e( zfzWti4*>L(w~E+>l2?ekf>l5(TR(m@jzn}sl%ZZKl3ID4Z*q}#2>nQ`=Q1kUp#sI( zKFymqLni4d66|q&#v2W3J{ctU0M6GvEeR{NoGMQ&>?_lvRt)hhTY955|HCX=>rmtj z;BgAvJmLA)jIYHwgnRGJd`tdz(9^I{)@i!0W%RRmdanYV@}6EQb=x3xtD3dRB~I*9 zid!sQSE8c%&81h|D$C(I;I94>+#!@jC^mC>g;%i04~qXyD(xww!6Vvc8Oh1(bqMhq zDJLxW#^t5Sjrk9}evkGfQ0KD8Va*WBkNTd$D`$SWx>@u51imrbk*tVH5*w9U)(!Ya z?vDpY!tHy5=nu!vS>l1gO4f;G<1z{U*?|m3c~RPoSk4yy(;G-3-oy7 z@0$ZsJ_8vy2Q_w*kMW?QeM0`mz2r-WU*-7V?X&S)2}XumTG|jTYCSs&KJ~XC(EvP$ zR!Uc(065C$JlYNE*K$7nBm3~np~b+9{?PecWZTIA?_4sQH*-U!+=g#em#I$uW7nWX z?xpmW^Pug)+x}|DmA&C^zPf2nk(#o{pK=f7?_>zAmNmJVfM_JIF5lL!;>bz9BQBY+ zpTHM~TT%Z{?;P7F3Ds_uN^45$!SaHqrU%&6KG3hEH%5 zYy&ix42Uf`V^a5I3ErJn~s*@sespjn$3F1u)?rd_%oZ&}%X6#H0pu>_#G;^gJ}?Rz`xJD|f_vciXJ!@T<_<+B(4 z@AgXOypEW*O1Dz|pFE{q)x}#N_Lt8iQSC|RSj{=IlzBn&W zE(gVTq*ui$pi6mfM9=Q7d>db`8A}_h85>`AH6!N?n<;e|fO1fHNW`lzBjh~aDl}hj zer<%HPYKhri`!BZx;gjjGo&$Ft9X--J-*{)3_BRpiA3W@m;yip8`e(X9iu%Asq)kUwFpl)kP6y@ zUhTBuVdkxSJ2ms9BSmWK3{h1f`9%pf(_AN{H%nSKNGy;RbE5?xKBWOPhDQr}+t9K< zIE+HbZpJxGr%U>RJ_}6%=2%Bc^tbu$``amjnj{$EixbfnjqdOd%Gugm&%haOMmOq7kR7`_ycHVU^YBDwXpa z=yQ)*7F_?0?K(rF24{ur%`Hj=LW$9rCOo(%D(kXMTYoE-+CTK}J)_QwE?@bUremY2 zG54~^qte4V6;Pzx7A2dmbyXxADF151eVZBnl=y&%75(NGmleY zVaYVg1ny2~>YU-ivKWIaP&^?ye`nSej?7B>kiNw11s|TY)i&Z?@i9zc_s(3zVQOn} zBifh#UnCU@%hi)H9xFesC+4~JK`x95(?s?XWxDR|cBc!wwK^E9nkadGrBG}1{p!jp zMYph`g@d!{3T?^EYaxT-IyrBG@I{Dl=zUq(yPEG|)Zz@@p$bEkUT>*qHtC;`N{ttRY4){E0)?U%6+3GAjJZUb)(Q)`|N)Kfm9$n literal 0 HcmV?d00001 From ea4a8175623cbca73afe214c454c7e7ac26a9c26 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 24 Sep 2024 13:37:58 +0200 Subject: [PATCH 39/50] replaced pickle file by hdf5 --- tests/test_LsstSciencePipeline/test_opsim_pipeline.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py index d053f9083..317545fcd 100644 --- a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py @@ -76,8 +76,7 @@ def test_opsim_variable_lens_injection(pes_lens_instance): lens_class = pes_lens_instance # Load example opsim data format - with open('../TestData/expo_data_opsim.pkl', 'rb') as f: - expo_data = pickle.load(f) + expo_data = Table.read('../TestData/expo_data_opsim.hdf5', path='data') transform_pix2angle = np.array([[0.2, 0], [0, 0.2]]) bands = ["g", "r", "i"] From c444a1ef50293b21d3bfb7c8c528cc7882dd8220 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 24 Sep 2024 11:40:05 +0000 Subject: [PATCH 40/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- ...rnovae_plus_extended_source_tutorial.ipynb | 7 +-- .../test_opsim_pipeline.py | 60 +++++++++++++------ 2 files changed, 44 insertions(+), 23 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index 78922cfda..2464837e1 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -26,7 +26,7 @@ "from slsim.image_simulation import lens_image_series, sharp_rgb_image\n", "from slsim.Plots.plot_functions import create_image_montage_from_image_list\n", "from slsim.image_simulation import point_source_coordinate_properties\n", - "from slsim.LsstSciencePipeline import lsst_science_pipeline, opsim_pipeline\n" + "from slsim.LsstSciencePipeline import lsst_science_pipeline, opsim_pipeline" ] }, { @@ -115,8 +115,7 @@ ")\n", "\n", "path = (\n", - " os.path.dirname(slsim.__file__)\n", - " + \"/Sources/SupernovaeCatalog/supernovae_data.pkl\"\n", + " os.path.dirname(slsim.__file__) + \"/Sources/SupernovaeCatalog/supernovae_data.pkl\"\n", ")\n", "with open(path, \"rb\") as f:\n", " supernovae_data = pickle.load(f)\n", @@ -435,7 +434,7 @@ "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", "ra_points = ra_points.wrap_at(180 * u.degree)\n", "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", - "dec_points = coord.Angle(dec_points * u.degree)\n" + "dec_points = coord.Angle(dec_points * u.degree)" ] }, { diff --git a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py index 317545fcd..f1ef0a4b2 100644 --- a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py @@ -10,6 +10,7 @@ import pytest import pickle + @pytest.fixture def pes_lens_instance(): path = os.path.dirname(__file__) @@ -50,33 +51,54 @@ def test_opsim_time_series_images_data(): obs_strategy="baseline_v3.0_10yrs", MJD_min=60000, MJD_max=60500, - print_warning=False) + print_warning=False, + ) assert isinstance(opsim_data, list) # is opsim_data a list? - assert len(opsim_data) == len(dec_points) # does it have the same length as number of points given? - assert opsim_data[0].keys() == ['bkg_noise', # does it contain the right data columns? - 'psf_kernel', - 'obs_time', - 'expo_time', - 'zero_point', - 'calexp_center', - 'band'] - assert isinstance(opsim_data[0]['bkg_noise'][0], float) # are entries from bkg_noise floats? - assert opsim_data[0]['psf_kernel'][0].ndim == 2 # is psf_kernel a 2 dimensional array? - assert isinstance(opsim_data[0]['obs_time'][0], float) # are entries from obs_time floats? - assert isinstance(opsim_data[0]['expo_time'][0], float) # are entries from expo_time floats? - assert isinstance(opsim_data[0]['zero_point'][0], float) # are entries from zero_point floats? - assert isinstance(opsim_data[0]['calexp_center'][0], np.ndarray) # is calexp_center an array? - assert opsim_data[0]['calexp_center'][0].shape == (2,) # is calexp_center an array of length 2? - assert all(isinstance(item, float) for item in opsim_data[0]['calexp_center'][0]) # are entries floats? - assert isinstance(opsim_data[0]['band'][0], str) # are entries from band strings? + assert len(opsim_data) == len( + dec_points + ) # does it have the same length as number of points given? + assert opsim_data[0].keys() == [ + "bkg_noise", # does it contain the right data columns? + "psf_kernel", + "obs_time", + "expo_time", + "zero_point", + "calexp_center", + "band", + ] + assert isinstance( + opsim_data[0]["bkg_noise"][0], float + ) # are entries from bkg_noise floats? + assert ( + opsim_data[0]["psf_kernel"][0].ndim == 2 + ) # is psf_kernel a 2 dimensional array? + assert isinstance( + opsim_data[0]["obs_time"][0], float + ) # are entries from obs_time floats? + assert isinstance( + opsim_data[0]["expo_time"][0], float + ) # are entries from expo_time floats? + assert isinstance( + opsim_data[0]["zero_point"][0], float + ) # are entries from zero_point floats? + assert isinstance( + opsim_data[0]["calexp_center"][0], np.ndarray + ) # is calexp_center an array? + assert opsim_data[0]["calexp_center"][0].shape == ( + 2, + ) # is calexp_center an array of length 2? + assert all( + isinstance(item, float) for item in opsim_data[0]["calexp_center"][0] + ) # are entries floats? + assert isinstance(opsim_data[0]["band"][0], str) # are entries from band strings? def test_opsim_variable_lens_injection(pes_lens_instance): lens_class = pes_lens_instance # Load example opsim data format - expo_data = Table.read('../TestData/expo_data_opsim.hdf5', path='data') + expo_data = Table.read("../TestData/expo_data_opsim.hdf5", path="data") transform_pix2angle = np.array([[0.2, 0], [0, 0.2]]) bands = ["g", "r", "i"] From 9109127fa66a854de77017b2f646e5268dc3cb3a Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 24 Sep 2024 13:43:33 +0200 Subject: [PATCH 41/50] removed unused imports --- tests/test_LsstSciencePipeline/test_opsim_pipeline.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py index 317545fcd..bfcf5f84a 100644 --- a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py @@ -8,7 +8,6 @@ opsim_time_series_images_data, ) import pytest -import pickle @pytest.fixture def pes_lens_instance(): From 816dcb5aabbc3521b6a9cda83cf8c2ebdd827584 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 24 Sep 2024 13:48:07 +0200 Subject: [PATCH 42/50] updated opsim functions --- ...sim_supernovae_plus_extended_source_tutorial.ipynb | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index 2464837e1..52da79ba5 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -26,7 +26,7 @@ "from slsim.image_simulation import lens_image_series, sharp_rgb_image\n", "from slsim.Plots.plot_functions import create_image_montage_from_image_list\n", "from slsim.image_simulation import point_source_coordinate_properties\n", - "from slsim.LsstSciencePipeline import lsst_science_pipeline, opsim_pipeline" + "from slsim.LsstSciencePipeline import opsim_pipeline\n" ] }, { @@ -115,7 +115,8 @@ ")\n", "\n", "path = (\n", - " os.path.dirname(slsim.__file__) + \"/Sources/SupernovaeCatalog/supernovae_data.pkl\"\n", + " os.path.dirname(slsim.__file__)\n", + " + \"/Sources/SupernovaeCatalog/supernovae_data.pkl\"\n", ")\n", "with open(path, \"rb\") as f:\n", " supernovae_data = pickle.load(f)\n", @@ -434,7 +435,7 @@ "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", "ra_points = ra_points.wrap_at(180 * u.degree)\n", "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", - "dec_points = coord.Angle(dec_points * u.degree)" + "dec_points = coord.Angle(dec_points * u.degree)\n" ] }, { @@ -445,7 +446,7 @@ }, "outputs": [], "source": [ - "exposure_data = lsst_science_pipeline.opsim_time_series_images_data(\n", + "exposure_data = opsim_pipeline.opsim_time_series_images_data(\n", " ra_points,\n", " dec_points,\n", " \"baseline_v3.0_10yrs\",\n", @@ -477,7 +478,7 @@ "num_pix = 200\n", "transform_pix2angle = np.array([[0.2, 0], [0, 0.2]])\n", "\n", - "images = lsst_science_pipeline.opsim_variable_lens_injection(\n", + "images = opsim_pipeline.opsim_variable_lens_injection(\n", " lens_class, bands, num_pix, transform_pix2angle, exposure_data[index]\n", ")\n", "print(\"images.keys() : \", images.keys())\n", From 3a23c6232a91b851d4b9b684f315fda6fd075636 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 24 Sep 2024 11:49:29 +0000 Subject: [PATCH 43/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../Opsim_supernovae_plus_extended_source_tutorial.ipynb | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb index 52da79ba5..da1288464 100644 --- a/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb +++ b/notebooks/Opsim_supernovae_plus_extended_source_tutorial.ipynb @@ -26,7 +26,7 @@ "from slsim.image_simulation import lens_image_series, sharp_rgb_image\n", "from slsim.Plots.plot_functions import create_image_montage_from_image_list\n", "from slsim.image_simulation import point_source_coordinate_properties\n", - "from slsim.LsstSciencePipeline import opsim_pipeline\n" + "from slsim.LsstSciencePipeline import opsim_pipeline" ] }, { @@ -115,8 +115,7 @@ ")\n", "\n", "path = (\n", - " os.path.dirname(slsim.__file__)\n", - " + \"/Sources/SupernovaeCatalog/supernovae_data.pkl\"\n", + " os.path.dirname(slsim.__file__) + \"/Sources/SupernovaeCatalog/supernovae_data.pkl\"\n", ")\n", "with open(path, \"rb\") as f:\n", " supernovae_data = pickle.load(f)\n", @@ -435,7 +434,7 @@ "ra_points = coord.Angle(np.random.uniform(low=0, high=360, size=N) * u.degree)\n", "ra_points = ra_points.wrap_at(180 * u.degree)\n", "dec_points = np.arcsin(2 * np.random.uniform(size=N) - 1) / np.pi * 180\n", - "dec_points = coord.Angle(dec_points * u.degree)\n" + "dec_points = coord.Angle(dec_points * u.degree)" ] }, { From 7bf3ffae0e4ea49fcfb11f0b1baa581058f6d279 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 24 Sep 2024 16:06:55 +0200 Subject: [PATCH 44/50] debugged test functions --- slsim/LsstSciencePipeline/opsim_pipeline.py | 6 +++++- tests/test_LsstSciencePipeline/test_opsim_pipeline.py | 4 +++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/slsim/LsstSciencePipeline/opsim_pipeline.py b/slsim/LsstSciencePipeline/opsim_pipeline.py index 35500cc3f..e1d9f9867 100644 --- a/slsim/LsstSciencePipeline/opsim_pipeline.py +++ b/slsim/LsstSciencePipeline/opsim_pipeline.py @@ -209,7 +209,11 @@ def opsim_variable_lens_injection( final_image_col = Column(name="injected_lens", data=final_image) # Create a new Table with only the bands of interest - mask = np.isin(exposure_data["band"], bands) + expo_bands = np.array([b for b in exposure_data["band"]]) + mask = np.isin(expo_bands, bands) exposure_data_new = exposure_data[mask] + + # if len(exposure_data_new) > 0: exposure_data_new.add_columns([lens_col, final_image_col]) + return exposure_data_new diff --git a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py index 5934bf764..541b00b29 100644 --- a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py @@ -51,6 +51,7 @@ def test_opsim_time_series_images_data(): MJD_min=60000, MJD_max=60500, print_warning=False, + opsim_path="../../data/OpSim_database/baseline_v3.0_10yrs.db" ) assert isinstance(opsim_data, list) # is opsim_data a list? @@ -111,5 +112,6 @@ def test_opsim_variable_lens_injection(pes_lens_instance): exposure_data=expo_data, ) - mask = np.isin(expo_data["band"], bands) + expo_bands = np.array([b for b in expo_data["band"]]) + mask = np.isin(expo_bands, bands) assert len(results) == len(expo_data[mask]) From 33f9d4f6f8ada2952f224b58396876b7dedf0c79 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 24 Sep 2024 14:07:35 +0000 Subject: [PATCH 45/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- tests/test_LsstSciencePipeline/test_opsim_pipeline.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py index 541b00b29..b9eafcd61 100644 --- a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py @@ -51,7 +51,7 @@ def test_opsim_time_series_images_data(): MJD_min=60000, MJD_max=60500, print_warning=False, - opsim_path="../../data/OpSim_database/baseline_v3.0_10yrs.db" + opsim_path="../../data/OpSim_database/baseline_v3.0_10yrs.db", ) assert isinstance(opsim_data, list) # is opsim_data a list? From c8e05fab0719513068f32d56fa32287f2f9c3e50 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 8 Oct 2024 16:02:41 +0200 Subject: [PATCH 46/50] added opsimsummaryv2 in test_requirements.txt --- test_requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/test_requirements.txt b/test_requirements.txt index 94f1423b6..b5345a31b 100644 --- a/test_requirements.txt +++ b/test_requirements.txt @@ -1,3 +1,4 @@ # git+https://github.com/aymgal/coolest@main#egg=coolest +git+https://github.com/LSSTDESC/OpSimSummaryV2 coolest==0.1.8 galsim \ No newline at end of file From 3e5c936a49ea1cea1d9ce63f3fa6fa042da374e9 Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 8 Oct 2024 16:03:03 +0200 Subject: [PATCH 47/50] changed path definition --- tests/test_LsstSciencePipeline/test_opsim_pipeline.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py index b9eafcd61..8097ce043 100644 --- a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py @@ -98,7 +98,11 @@ def test_opsim_variable_lens_injection(pes_lens_instance): lens_class = pes_lens_instance # Load example opsim data format - expo_data = Table.read("../TestData/expo_data_opsim.hdf5", path="data") + path = os.path.dirname(__file__) + module_path, _ = os.path.split(path) + expo_data = Table.read( + os.path.join(path, "../TestData/expo_data_opsim.hdf5"), path="data" + ) transform_pix2angle = np.array([[0.2, 0], [0, 0.2]]) bands = ["g", "r", "i"] From 85e17548c4fc8883ae19956b01ed0c6e96706d3b Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 8 Oct 2024 16:36:49 +0200 Subject: [PATCH 48/50] changed python-version to 3.9 to be compatible with opsimsummaryv2 --- .github/workflows/tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 529a8d7b9..398bdd9b6 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -13,7 +13,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.8] + python-version: [3.9] steps: - uses: actions/checkout@v4 From 164d7b0c08f46082608088e2af9f66197faa220b Mon Sep 17 00:00:00 2001 From: Nikki Date: Tue, 8 Oct 2024 17:02:57 +0200 Subject: [PATCH 49/50] changed function test_opsim_time_series_images_data() to only run if OpSim database is downloaded in the folder data/OpSim_database --- .../test_opsim_pipeline.py | 118 ++++++++++-------- 1 file changed, 66 insertions(+), 52 deletions(-) diff --git a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py index 8097ce043..4b4ca6f3f 100644 --- a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py @@ -38,60 +38,71 @@ def pes_lens_instance(): def test_opsim_time_series_images_data(): + """ + Only run this test function if user has an OpSim database downloaded in the folder data/OpSim_database + """ - # Test coordinates - dec_points = np.array([-9.3, -36.2, -70.9, 19.9, -9.5, 6.7, -45.9, -37.1]) - ra_points = np.array([150.6, 4.1, 52.8, 33.2, 67.0, 124.4, -14.5, -166.9]) - - # Create opsim_data instance - opsim_data = opsim_time_series_images_data( - ra_points, - dec_points, - obs_strategy="baseline_v3.0_10yrs", - MJD_min=60000, - MJD_max=60500, - print_warning=False, - opsim_path="../../data/OpSim_database/baseline_v3.0_10yrs.db", - ) + path = os.path.dirname(__file__) + opsim_path = os.path.join(path, "../../data/OpSim_database/") + if os.path.exists(opsim_path): + files_in_folder = os.listdir(opsim_path) + + if files_in_folder: + opsim_path_db = os.path.join(opsim_path, files_in_folder[0]) + + # Test coordinates + dec_points = np.array([-9.3, -36.2, -70.9, 19.9, -9.5, 6.7, -45.9, -37.1]) + ra_points = np.array([150.6, 4.1, 52.8, 33.2, 67.0, 124.4, -14.5, -166.9]) - assert isinstance(opsim_data, list) # is opsim_data a list? - assert len(opsim_data) == len( - dec_points - ) # does it have the same length as number of points given? - assert opsim_data[0].keys() == [ - "bkg_noise", # does it contain the right data columns? - "psf_kernel", - "obs_time", - "expo_time", - "zero_point", - "calexp_center", - "band", - ] - assert isinstance( - opsim_data[0]["bkg_noise"][0], float - ) # are entries from bkg_noise floats? - assert ( - opsim_data[0]["psf_kernel"][0].ndim == 2 - ) # is psf_kernel a 2 dimensional array? - assert isinstance( - opsim_data[0]["obs_time"][0], float - ) # are entries from obs_time floats? - assert isinstance( - opsim_data[0]["expo_time"][0], float - ) # are entries from expo_time floats? - assert isinstance( - opsim_data[0]["zero_point"][0], float - ) # are entries from zero_point floats? - assert isinstance( - opsim_data[0]["calexp_center"][0], np.ndarray - ) # is calexp_center an array? - assert opsim_data[0]["calexp_center"][0].shape == ( - 2, - ) # is calexp_center an array of length 2? - assert all( - isinstance(item, float) for item in opsim_data[0]["calexp_center"][0] - ) # are entries floats? - assert isinstance(opsim_data[0]["band"][0], str) # are entries from band strings? + # Create opsim_data instance + opsim_data = opsim_time_series_images_data( + ra_points, + dec_points, + obs_strategy="baseline_v3.0_10yrs", + MJD_min=60000, + MJD_max=60500, + print_warning=False, + opsim_path=opsim_path_db, + ) + + assert isinstance(opsim_data, list) # is opsim_data a list? + assert len(opsim_data) == len( + dec_points + ) # does it have the same length as number of points given? + assert opsim_data[0].keys() == [ + "bkg_noise", # does it contain the right data columns? + "psf_kernel", + "obs_time", + "expo_time", + "zero_point", + "calexp_center", + "band", + ] + assert isinstance( + opsim_data[0]["bkg_noise"][0], float + ) # are entries from bkg_noise floats? + assert ( + opsim_data[0]["psf_kernel"][0].ndim == 2 + ) # is psf_kernel a 2 dimensional array? + assert isinstance( + opsim_data[0]["obs_time"][0], float + ) # are entries from obs_time floats? + assert isinstance( + opsim_data[0]["expo_time"][0], float + ) # are entries from expo_time floats? + assert isinstance( + opsim_data[0]["zero_point"][0], float + ) # are entries from zero_point floats? + assert isinstance( + opsim_data[0]["calexp_center"][0], np.ndarray + ) # is calexp_center an array? + assert opsim_data[0]["calexp_center"][0].shape == ( + 2, + ) # is calexp_center an array of length 2? + assert all( + isinstance(item, float) for item in opsim_data[0]["calexp_center"][0] + ) # are entries floats? + assert isinstance(opsim_data[0]["band"][0], str) # are entries from band strings? def test_opsim_variable_lens_injection(pes_lens_instance): @@ -119,3 +130,6 @@ def test_opsim_variable_lens_injection(pes_lens_instance): expo_bands = np.array([b for b in expo_data["band"]]) mask = np.isin(expo_bands, bands) assert len(results) == len(expo_data[mask]) + + +test_opsim_time_series_images_data() \ No newline at end of file From fc4294122c3c7b89771969d80e9eaca1e9aee602 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 8 Oct 2024 15:03:39 +0000 Subject: [PATCH 50/50] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- tests/test_LsstSciencePipeline/test_opsim_pipeline.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py index 4b4ca6f3f..df4418ecd 100644 --- a/tests/test_LsstSciencePipeline/test_opsim_pipeline.py +++ b/tests/test_LsstSciencePipeline/test_opsim_pipeline.py @@ -38,9 +38,8 @@ def pes_lens_instance(): def test_opsim_time_series_images_data(): - """ - Only run this test function if user has an OpSim database downloaded in the folder data/OpSim_database - """ + """Only run this test function if user has an OpSim database downloaded in the + folder data/OpSim_database.""" path = os.path.dirname(__file__) opsim_path = os.path.join(path, "../../data/OpSim_database/") @@ -102,7 +101,9 @@ def test_opsim_time_series_images_data(): assert all( isinstance(item, float) for item in opsim_data[0]["calexp_center"][0] ) # are entries floats? - assert isinstance(opsim_data[0]["band"][0], str) # are entries from band strings? + assert isinstance( + opsim_data[0]["band"][0], str + ) # are entries from band strings? def test_opsim_variable_lens_injection(pes_lens_instance): @@ -132,4 +133,4 @@ def test_opsim_variable_lens_injection(pes_lens_instance): assert len(results) == len(expo_data[mask]) -test_opsim_time_series_images_data() \ No newline at end of file +test_opsim_time_series_images_data()