From 9070be89c615b781089dc0d73771b82de127e91b Mon Sep 17 00:00:00 2001
From: narayan <nkhadka@ksu.edu>
Date: Fri, 15 Nov 2024 18:57:46 -0500
Subject: [PATCH 1/9] changed the upper limit of MJD in opsim_pipeline.

---
 slsim/LsstSciencePipeline/opsim_pipeline.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/slsim/LsstSciencePipeline/opsim_pipeline.py b/slsim/LsstSciencePipeline/opsim_pipeline.py
index f04c77495..4b23e0186 100644
--- a/slsim/LsstSciencePipeline/opsim_pipeline.py
+++ b/slsim/LsstSciencePipeline/opsim_pipeline.py
@@ -10,8 +10,8 @@ def opsim_time_series_images_data(
     dec_list,
     obs_strategy,
     MJD_min=60000,
-    MJD_max=64000,
-    size=101,
+    MJD_max=64500,
+    num_pix=101,
     moffat_beta=3.1,
     readout_noise=10,
     delta_pix=0.2,
@@ -28,7 +28,7 @@ def opsim_time_series_images_data(
         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 num_pix: 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
@@ -111,7 +111,7 @@ def opsim_time_series_images_data(
 
         for psf in psf_fwhm:
             psf_kernel = kernel_util.kernel_moffat(
-                num_pix=size, delta_pix=delta_pix, fwhm=psf, moffat_beta=moffat_beta
+                num_pix=num_pix, delta_pix=delta_pix, fwhm=psf, moffat_beta=moffat_beta
             )
             psf_kernel = util.array2image(psf_kernel)
 

From 625f5653965ea7ed47efbb0d2d1ce6199c34255b Mon Sep 17 00:00:00 2001
From: narayan <nkhadka@ksu.edu>
Date: Mon, 18 Nov 2024 14:06:20 -0500
Subject: [PATCH 2/9] added afunctionality to convert MJD time to days for
 transient events.

---
 slsim/LsstSciencePipeline/util_lsst.py | 30 +++++++++++++-------------
 slsim/Util/param_util.py               | 23 ++++++++++++++++++++
 tests/test_param_util.py               | 10 +++++++++
 3 files changed, 48 insertions(+), 15 deletions(-)

diff --git a/slsim/LsstSciencePipeline/util_lsst.py b/slsim/LsstSciencePipeline/util_lsst.py
index f688edbf2..9255a171b 100644
--- a/slsim/LsstSciencePipeline/util_lsst.py
+++ b/slsim/LsstSciencePipeline/util_lsst.py
@@ -1,7 +1,7 @@
 import numpy as np
 from astropy.table import Column
 from slsim.image_simulation import lens_image_series, lens_image
-from slsim.Util.param_util import fits_append_table
+from slsim.Util.param_util import fits_append_table, convert_mjd_to_days, zero_point_mjd
 import os
 
 
@@ -28,17 +28,13 @@ def variable_lens_injection(
         in days for each single exposure images in time series images)
     :return: Astropy table of injected lenses and exposure information of dp0 data
     """
-    # the range of observation time of single exposure images might be outside of the
-    # lightcurve time. So, we use random observation time from the lens class lightcurve
-    # time to ensure simulation of reasonable images.
-    observation_time = np.random.uniform(
-        min(lens_class.max_redshift_source_class.lightcurve_time),
-        max(lens_class.max_redshift_source_class.lightcurve_time),
-        size=len(exposure_data["obs_time"]),
-    )
-    observation_time.sort()
-    new_obs_time = Column(name="obs_time", data=observation_time)
-    exposure_data.replace_column("obs_time", new_obs_time)
+    ## chose transient starting point randomly. 
+    zero_point_mjd_time = zero_point_mjd(min(exposure_data["obs_time"]),
+                                        max(exposure_data["obs_time"]))
+    ## Convert mjd observation time to days. We should do this because lightcurves are
+    #  in the unit of days.
+    observation_time = convert_mjd_to_days(exposure_data["obs_time"],
+                                            zero_point_mjd_time)
     lens_images = lens_image_series(
         lens_class,
         band=band,
@@ -47,7 +43,7 @@ def variable_lens_injection(
         psf_kernel=exposure_data["psf_kernel"],
         transform_pix2angle=transform_pix2angle,
         exposure_time=exposure_data["expo_time"],
-        t_obs=exposure_data["obs_time"],
+        t_obs=observation_time,
     )
 
     final_image = []
@@ -147,12 +143,16 @@ def opsim_variable_lens_injection(
     :return: Astropy table of injected lenses and exposure information of dp0 data
     """
 
+    ## chose transient starting point randomly. 
+    zero_point_mjd_time = zero_point_mjd(min(exposure_data["obs_time"]),
+                                        max(exposure_data["obs_time"]))
     final_image = []
 
     for obs in range(len(exposure_data["obs_time"])):
 
         exposure_data_obs = exposure_data[obs]
-
+        observation_time = convert_mjd_to_days(exposure_data_obs["obs_time"],
+                                                zero_point_mjd_time)
         if exposure_data_obs["band"] not in bands:
             continue
 
@@ -169,7 +169,7 @@ def opsim_variable_lens_injection(
             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"],
+            t_obs=observation_time,
             std_gaussian_noise=std_gaussian_noise,
         )
 
diff --git a/slsim/Util/param_util.py b/slsim/Util/param_util.py
index 52d30b1da..c43d4b023 100644
--- a/slsim/Util/param_util.py
+++ b/slsim/Util/param_util.py
@@ -350,3 +350,26 @@ def catalog_with_angular_size_in_arcsec(galaxy_catalog, input_catalog_type="skyp
         )
         warnings.warn(warning_msg, category=UserWarning, stacklevel=2)
     return copied_galaxy_catalog
+
+def convert_mjd_to_days(reference_mjd, zero_point_mjd):
+    """
+    Convert reference MJD(s) to days relative to a chosen zero-point MJD.
+
+    :param reference_mjd: The reference MJD(s) to convert. 
+    :type reference_mjd: float, list, or numpy.ndarray
+    :param zero_point_mjd: The zero-point MJD to use as the reference.
+    :return: The time(s) in days relative to the zero-point MJD.
+    """
+    # Ensure input is a NumPy array for consistent handling
+    reference_mjd = np.array(reference_mjd)
+    return reference_mjd - zero_point_mjd
+
+def zero_point_mjd(min_mjd, max_mjd):
+    """ Produces a random MJD time with in the given range
+    
+    :param min_mjd: Minimum bound for the MJD time
+    :param max_mjd: Maximum bound for the MJD time
+    :return: A MJD time between given min and max bounds.
+    """
+    zero_mjd=np.random.randint(min_mjd, max_mjd)
+    return zero_mjd
diff --git a/tests/test_param_util.py b/tests/test_param_util.py
index 5096e1dff..891117de4 100644
--- a/tests/test_param_util.py
+++ b/tests/test_param_util.py
@@ -16,6 +16,8 @@
     ellipticity_slsim_to_lenstronomy,
     fits_append_table,
     catalog_with_angular_size_in_arcsec,
+    convert_mjd_to_days,
+    zero_point_mjd,
 )
 from slsim.Sources.SourceVariability.variability import Variability
 from astropy.io import fits
@@ -250,6 +252,14 @@ def test_catalog_with_angular_size_in_arcsec():
     assert galaxy_cat2["angular_size"].unit == u.rad
     assert galaxy_cat["angular_size"].unit == u.arcsec
 
+def test_convert_mjd_to_days():
+    result = convert_mjd_to_days(60100, 60000)
+    assert result==100
+
+def test_zero_point_mjd():
+    result = zero_point_mjd(60000, 60400)
+    assert 60000 <= result <=60400
+
 
 if __name__ == "__main__":
     pytest.main()

From b2f26f905102b0db2ef8de7bca3c6b8bcc926296 Mon Sep 17 00:00:00 2001
From: narayan <nkhadka@ksu.edu>
Date: Mon, 18 Nov 2024 14:09:37 -0500
Subject: [PATCH 3/9] minor change

---
 slsim/Util/param_util.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/slsim/Util/param_util.py b/slsim/Util/param_util.py
index c43d4b023..904102e94 100644
--- a/slsim/Util/param_util.py
+++ b/slsim/Util/param_util.py
@@ -369,7 +369,7 @@ def zero_point_mjd(min_mjd, max_mjd):
     
     :param min_mjd: Minimum bound for the MJD time
     :param max_mjd: Maximum bound for the MJD time
-    :return: A MJD time between given min and max bounds.
+    :return: A random MJD time between given min and max bounds.
     """
     zero_mjd=np.random.randint(min_mjd, max_mjd)
     return zero_mjd

From 8afbc92488ce315571f77fa18fd9af717a6e2b34 Mon Sep 17 00:00:00 2001
From: narayan <nkhadka@ksu.edu>
Date: Mon, 18 Nov 2024 16:43:46 -0500
Subject: [PATCH 4/9] minor change

---
 slsim/Util/param_util.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/slsim/Util/param_util.py b/slsim/Util/param_util.py
index 904102e94..8de036807 100644
--- a/slsim/Util/param_util.py
+++ b/slsim/Util/param_util.py
@@ -351,25 +351,25 @@ def catalog_with_angular_size_in_arcsec(galaxy_catalog, input_catalog_type="skyp
         warnings.warn(warning_msg, category=UserWarning, stacklevel=2)
     return copied_galaxy_catalog
 
-def convert_mjd_to_days(reference_mjd, zero_point_mjd):
+def convert_mjd_to_days(reference_mjd, start_point_mjd):
     """
     Convert reference MJD(s) to days relative to a chosen zero-point MJD.
 
     :param reference_mjd: The reference MJD(s) to convert. 
     :type reference_mjd: float, list, or numpy.ndarray
-    :param zero_point_mjd: The zero-point MJD to use as the reference.
+    :param start_point_mjd: The zero-point MJD to use as the reference.
     :return: The time(s) in days relative to the zero-point MJD.
     """
     # Ensure input is a NumPy array for consistent handling
     reference_mjd = np.array(reference_mjd)
-    return reference_mjd - zero_point_mjd
+    return reference_mjd - start_point_mjd
 
-def zero_point_mjd(min_mjd, max_mjd):
+def start_point_mjd(min_mjd, max_mjd):
     """ Produces a random MJD time with in the given range
     
     :param min_mjd: Minimum bound for the MJD time
     :param max_mjd: Maximum bound for the MJD time
     :return: A random MJD time between given min and max bounds.
     """
-    zero_mjd=np.random.randint(min_mjd, max_mjd)
-    return zero_mjd
+    start_mjd=np.random.randint(min_mjd, max_mjd)
+    return start_mjd

From c12e0d3c8b2f24dee870dd97cc3375944e3f6652 Mon Sep 17 00:00:00 2001
From: narayan <nkhadka@ksu.edu>
Date: Mon, 18 Nov 2024 16:51:11 -0500
Subject: [PATCH 5/9] minor change

---
 slsim/LsstSciencePipeline/util_lsst.py | 11 ++++++-----
 slsim/Util/param_util.py               |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/slsim/LsstSciencePipeline/util_lsst.py b/slsim/LsstSciencePipeline/util_lsst.py
index 9255a171b..2afd98c78 100644
--- a/slsim/LsstSciencePipeline/util_lsst.py
+++ b/slsim/LsstSciencePipeline/util_lsst.py
@@ -1,7 +1,8 @@
 import numpy as np
 from astropy.table import Column
 from slsim.image_simulation import lens_image_series, lens_image
-from slsim.Util.param_util import fits_append_table, convert_mjd_to_days, zero_point_mjd
+from slsim.Util.param_util import (fits_append_table, convert_mjd_to_days,
+                                    transient_event_time_mjd)
 import os
 
 
@@ -29,12 +30,12 @@ def variable_lens_injection(
     :return: Astropy table of injected lenses and exposure information of dp0 data
     """
     ## chose transient starting point randomly. 
-    zero_point_mjd_time = zero_point_mjd(min(exposure_data["obs_time"]),
+    start_point_mjd_time = transient_event_time_mjd(min(exposure_data["obs_time"]),
                                         max(exposure_data["obs_time"]))
     ## Convert mjd observation time to days. We should do this because lightcurves are
     #  in the unit of days.
     observation_time = convert_mjd_to_days(exposure_data["obs_time"],
-                                            zero_point_mjd_time)
+                                            start_point_mjd_time)
     lens_images = lens_image_series(
         lens_class,
         band=band,
@@ -144,7 +145,7 @@ def opsim_variable_lens_injection(
     """
 
     ## chose transient starting point randomly. 
-    zero_point_mjd_time = zero_point_mjd(min(exposure_data["obs_time"]),
+    start_point_mjd_time = transient_event_time_mjd(min(exposure_data["obs_time"]),
                                         max(exposure_data["obs_time"]))
     final_image = []
 
@@ -152,7 +153,7 @@ def opsim_variable_lens_injection(
 
         exposure_data_obs = exposure_data[obs]
         observation_time = convert_mjd_to_days(exposure_data_obs["obs_time"],
-                                                zero_point_mjd_time)
+                                                start_point_mjd_time)
         if exposure_data_obs["band"] not in bands:
             continue
 
diff --git a/slsim/Util/param_util.py b/slsim/Util/param_util.py
index 8de036807..339794550 100644
--- a/slsim/Util/param_util.py
+++ b/slsim/Util/param_util.py
@@ -364,7 +364,7 @@ def convert_mjd_to_days(reference_mjd, start_point_mjd):
     reference_mjd = np.array(reference_mjd)
     return reference_mjd - start_point_mjd
 
-def start_point_mjd(min_mjd, max_mjd):
+def transient_event_time_mjd(min_mjd, max_mjd):
     """ Produces a random MJD time with in the given range
     
     :param min_mjd: Minimum bound for the MJD time

From ac21275a093fa47449ffab2daa322be931972bc4 Mon Sep 17 00:00:00 2001
From: narayan <nkhadka@ksu.edu>
Date: Mon, 18 Nov 2024 16:53:18 -0500
Subject: [PATCH 6/9] minor change

---
 tests/test_param_util.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/test_param_util.py b/tests/test_param_util.py
index 891117de4..2e375a127 100644
--- a/tests/test_param_util.py
+++ b/tests/test_param_util.py
@@ -17,7 +17,7 @@
     fits_append_table,
     catalog_with_angular_size_in_arcsec,
     convert_mjd_to_days,
-    zero_point_mjd,
+    transient_event_time_mjd,
 )
 from slsim.Sources.SourceVariability.variability import Variability
 from astropy.io import fits
@@ -256,8 +256,8 @@ def test_convert_mjd_to_days():
     result = convert_mjd_to_days(60100, 60000)
     assert result==100
 
-def test_zero_point_mjd():
-    result = zero_point_mjd(60000, 60400)
+def test_start_point_mjd_time():
+    result = transient_event_time_mjd(60000, 60400)
     assert 60000 <= result <=60400
 
 

From c7bb6a0be3b79337b3f929d9687eab9a73f800d5 Mon Sep 17 00:00:00 2001
From: narayan <nkhadka@ksu.edu>
Date: Mon, 18 Nov 2024 18:29:21 -0500
Subject: [PATCH 7/9] added a notebook to show supernova injection to opsim
 data.

---
 .../supernovae_injection_to_opsim_data.ipynb   | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 notebooks/supernovae_injection_to_opsim_data.ipynb

diff --git a/notebooks/supernovae_injection_to_opsim_data.ipynb b/notebooks/supernovae_injection_to_opsim_data.ipynb
new file mode 100644
index 000000000..709d82cff
--- /dev/null
+++ b/notebooks/supernovae_injection_to_opsim_data.ipynb
@@ -0,0 +1,18 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 9e2ef89fe76334a8f33bfb6e8df34da67df2ac25 Mon Sep 17 00:00:00 2001
From: narayan <nkhadka@ksu.edu>
Date: Mon, 18 Nov 2024 18:31:11 -0500
Subject: [PATCH 8/9] added a notebook to show supernova injection to opsim
 data.

---
 .../supernovae_injection_to_opsim_data.ipynb  | 446 +++++++++++++++++-
 1 file changed, 445 insertions(+), 1 deletion(-)

diff --git a/notebooks/supernovae_injection_to_opsim_data.ipynb b/notebooks/supernovae_injection_to_opsim_data.ipynb
index 709d82cff..0ee71984f 100644
--- a/notebooks/supernovae_injection_to_opsim_data.ipynb
+++ b/notebooks/supernovae_injection_to_opsim_data.ipynb
@@ -1,5 +1,435 @@
 {
  "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "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 astropy.table import Table\n",
+    "from astropy.units import Quantity\n",
+    "import slsim.Sources as sources\n",
+    "import slsim.Deflectors as deflectors\n",
+    "import slsim.Pipelines as pipelines\n",
+    "from slsim.Sources.point_sources import PointSources\n",
+    "from slsim.Sources.QuasarCatalog.quasar_pop import QuasarRate\n",
+    "import corner\n",
+    "import matplotlib.pyplot as plt\n",
+    "from astropy.table import Table\n",
+    "from slsim.Sources.source import Source\n",
+    "from slsim.image_simulation import point_source_coordinate_properties\n",
+    "from slsim.image_simulation import lens_image_series, rgb_image_from_image_list\n",
+    "from slsim.Plots.plot_functions import create_image_montage_from_image_list\n",
+    "import math"
+   ]
+  },
+  {
+   "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": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cosmo = FlatLambdaCDM(H0=70, Om0=0.3)\n",
+    "deflector_sky_area = Quantity(value=2, unit=\"deg2\")\n",
+    "source_sky_area = Quantity(value=5, unit=\"deg2\")\n",
+    "sky_area = Quantity(value=2000, unit=\"deg2\")\n",
+    "\n",
+    "kwargs_deflector_cut = {\"band\": \"g\", \"band_max\": 24, \"z_min\": 0.01, \"z_max\": 2.5}\n",
+    "kwargs_source_cut = {\"z_min\": 0.1, \"z_max\": 5.0}\n",
+    "\n",
+    "time_range = np.linspace(-50, 100, 500)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate galaxy population using skypy pipeline.\n",
+    "galaxy_simulation_pipeline = pipelines.SkyPyPipeline(\n",
+    "    skypy_config=None, sky_area=sky_area, filters=None, cosmo=cosmo\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/narayankhadka/slsim/slsim/Deflectors/all_lens_galaxies.py:54: 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/narayankhadka/slsim/slsim/Deflectors/all_lens_galaxies.py:57: 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"
+     ]
+    }
+   ],
+   "source": [
+    "# Initiate deflector population class.\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=None,\n",
+    "    cosmo=cosmo,\n",
+    "    sky_area=sky_area,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "supernovae_catalog = sources.SupernovaeCatalog.SupernovaeCatalog(\n",
+    "    sn_type=\"Ia\",\n",
+    "    band_list=[\"i\"],\n",
+    "    lightcurve_time=time_range,\n",
+    "    absolute_mag_band=\"bessellb\",\n",
+    "    absolute_mag=None,\n",
+    "    mag_zpsys=\"ab\",\n",
+    "    cosmo=cosmo,\n",
+    "    skypy_config=None,\n",
+    "    sky_area=source_sky_area,\n",
+    ")\n",
+    "supernovae_data = supernovae_catalog.supernovae_catalog(\n",
+    "    host_galaxy=False, lightcurve=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initiate source population class.\n",
+    "supernovae_sourece = sources.PointSources(\n",
+    "    point_source_list=supernovae_data,\n",
+    "    cosmo=cosmo,\n",
+    "    sky_area=source_sky_area,\n",
+    "    kwargs_cut=kwargs_source_cut,\n",
+    "    variability_model=\"light_curve\",\n",
+    "    kwargs_variability_model={\"supernovae_lightcurve\", \"i\", \"r\", \"g\"},\n",
+    "    lightcurve_time=time_range,\n",
+    "    sn_type=\"Ia\",\n",
+    "    sn_absolute_mag_band=\"bessellb\",\n",
+    "    sn_absolute_zpsys=\"ab\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initiate LensPop class\n",
+    "supernova_lens_pop = LensPop(\n",
+    "    deflector_population=lens_galaxies,\n",
+    "    source_population=supernovae_sourece,\n",
+    "    sky_area=sky_area,\n",
+    "    cosmo=cosmo\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Draw lens population"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "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=100, multi_source=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Choose a lens to simulate an image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "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[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/narayankhadka/slsim/slsim/Sources/supernovae.py:109: UserWarning: bandpass 'lsstg' [3866, .., 5670] outside spectral range [4231.25, .., 42312.5]\n",
+      "Ignoring bandpass for now. Use extended wavelength SN models found here: https://github.com/LSST-strong-lensing/data_public/tree/main/sncosmo_sn_models\n",
+      "  warn(\n",
+      "/opt/anaconda3/lib/python3.9/site-packages/sncosmo/models.py:189: RuntimeWarning: divide by zero encountered in log10\n",
+      "  result[i] = -2.5 * np.log10(f / zpf)\n"
+     ]
+    }
+   ],
+   "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": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[array([[18.28767419, 11.13214571]]), array([[14.84482128, 15.23258164]])]"
+      ]
+     },
+     "execution_count": 36,
+     "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": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "light_curve = lens_class.source[0].variability_class.kwargs_model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-22.0, 100.0)"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "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": [
+    "## Set observation time and image configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "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": 32,
+   "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",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "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": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABCUAAAGoCAYAAABxHl8zAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAAsTAAALEwEAmpwYAABka0lEQVR4nO3deWAU9f3/8dfuJiEJhCMEBEFFBG9REBBBxYN61LNVq/XGW/CoB4K31lq16s+rWq0HovXbqvVo1WqtiloVQVRQUbyQ24MECEfu3f39EYxg5j1lhsl+dpPn4y+d3Z2ZnZ3XfmY/TN7vWDqdFgAAAAAAQKbFXe8AAAAAAABom5iUAAAAAAAATjApAQAAAAAAnGBSAgAAAAAAOMGkBAAAAAAAcCLP78GfxY+kNQfg4z+pJ2Lr+1zyBPgjT0B01jdPZAnwx9gERMfKE3dKAAAAAAAAJ5iUAAAAAAAATjApAQAAAAAAnGBSAgAAAAAAOMGkBAAAAAAAcIJJCQAAAAAA4ASTEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE7kRbGSktIOuunlqyRJXXp0ViqZUuWSFdq4Xw/955HXdefY+6PYzHrZ44hhOv6qX2nTbXrpnF0u0efvzZEk5eXn6Tf3nK4tB2+hVCqlu38zUR++/kmz1x9/1ZH6+amjVLlkhSTpwcv+T9Ne+MB3m+MeHKt3nn9P/33ynejfENqcXMjTRpt10wOf3KaFny2WJH069XPdftZ9zd9Llw667G/nq0efbvp27hL97qj/p1XLV/tu8+ZXr9afxz3ctC0grFzIUklpB135xIXaakg/vTTpNf3xnAc8X3/ib4/S8EOGKJ1Ka/n3lbpp9F2q+GaZBozcVr99Zry+/fp7SdKbT0/VX679u+++7Hvintpy8BbmtgAvrvN09ITDtP/J+yiVTOnu8x7U9JdmNntOjz7ddelff6OOXUv0xXtzdOMJd6qhvsF3vY/MuUtjh0zQioqVLbXrQDMu8+Q37vQf1FfjJo5VQVGBpr3wvu4+b6LnOsbcPlpDDxik2qpa3TT6Ln35wde+2zz+qiNVvapGf7/l2UjfC1qPSCYlVi5dpTMHjZPk/qSb+/ECXXP4zfrNPaevs/znp+0jSTp9xwvVuVtHXfevy3T20AlKp9PN1vHkbc8RGjiTC3mSpMVffdu0n5ajJhymD179SI/d+IyOGn+Yjp5wmO6f8GhL7S6wjlzIUn1NvR668jFtvv0m6rP9pubrn7jpn5p05WOSpMPOOUDHXXlE00TgR//9VFccckPL7Twgt3nadJve2vOoETpt+/PVdeNS3fifKzR6q/OUSqXWed6pNxyrp257Tq899rbO+9Np2v+UvfXcPS9lZB+BIFzmyW/cOffu03Tr6ffo06lf6LrnL9WQ/XfSuy/OWOc5Qw8YqF79euqkLc/RNrv017l3n6Zzd700I/uO1iuSSQnLgJHb6sgLD9EVh9yg4686Uj36dFfPvhup+6ZluueCh7T1sC01dP+BKl+0VFcccoOSDUn1H9RXZ95yogo7FGpF+QrdNPouLf12+Xpvc/7sRZ7LN9u2t2ZM/liStHzJCq1evlpbDt5Cn737Zaj3dvadp2jQqAFasqBcDXU/zsIfd8URGnbQziooKtAnUz7XbWfcq559N9IVj1+gMYPHS5J69euhy/52vsYMHq9Trj9Wux48WMmGpN77z0z9edwjofYHrV825Wl9DT9kiC7aq/FfAv4z6TXdPPmaZpMSBYUFuujBMdpix800f/ZiFRQVND127t2naavBW6igqED/ffIdPXz149ppr+112DkH6Opf3iRJGjRqgA4+az9de+QtuvD+s9R/cF8pLb048VU9ddvzG7T/aJ2yKUs1VbWa9dZs9erXw/f1VSurm/67sH07ecyn+9rvpD119IRfaNXyKs35cK7qaxvHrWEH7axjLjtc+QV5WlGxUtcfd4cql6zQxNm367wRl6uyfIVisZgmfnaHzht+mXbcc1sdd+WRSiVTWl1ZpQv3vCrYjqDVyUSehh86WK899pbq6xr07dzvtfjLb7XV0H769J3P13neTntvr98fe7sk6aVJr+uEq45sNilRUtpBl/3fb9S1V6k+fedzxWKxpseufmqcum1SpoLCfD19x7/0r/te1n6j91LfAZvpT+c/JEk64NR9tNm2vfXQ5X/T5Y9doLLepYon4nr0d0/q9cffjuagos3KRJ6scae0R2cVdyzSp1O/kCS9/MjrGn7Y0GaTErseOkQvP/K6JOnTqV+oQ+f2Ku3Rudk2j7n0l/rZCSO1/PsVWrKgXJ+/33iH4AGn7qMDTxulvII8Lf7yW914wp2KJ+K6d+YtGr3VuUo2JFVcUqR7Ztys0Vudq4PP2lcHnbGvkg1JzftkoX5/zG0bdIyRnTJaU2LjLXpo3D7X6MpDb9T4R87VzMkf6/QdL1RtdZ12OXCQEnkJjb3jZP32yFs0dsh4vThxskZf92tJ0kFn/EwHnfGz0Nv+auY87XrwYMUTcfXo0139d+6rbpt09XzuoWP3170zbtaFD5ylDp3bN3t8t18MVe8tN9ap252vP5z4R207fKumx/7xxxd19i6X6PQBF6pdYYGGHbSzvpnznVZXVmmLHftIkvYbvZf+/dBklZR20IjDhurU7c/XGTtdpEd/92To94e2x2WeJKnH5t31p/f+oFsmX6Ptd9va8zldNurUNEgt/Xa5umzUqdlzDj5rX9VW1+qU7c7Xw1c/pi137tv02MTL/qqxQyfojB0v0oA9ttXmO2yqGZM/1iZb91Knso6SpP1O2kv/nviqttipj7r2KtXpAy7U6TteqH9PnLxB7w9th+ssra/Rv/u1Hp33J+19zO5Nd01I0ra7bql7PrhJ1z1/qTbbtnez15X26KwTrj5Kv9ntCp2/+xXabJsfn/Pxm7N17q6X6qydL9Zrj72loy4+VOl0Wi8/+ob2PnY3SdKgUTtozsy5qixfoeOuOFKX7H+dzhw4TlceemPLv2nknJbIU1mvrlqyoKLp/5csWqqyXqXrPKdj1xKtWl6lVLLx7onyhRXq+pPnSI3/Kv3xW7N12g4X6M2np2mjzbo1PXbLKX/S2CHjNXbIBB12zgEqKe2g1x+fomEH7axEXkJS45jz4oOTNXj/nVTxzVKdOXCcTh9wYbMfbkAUMjk+lfUqVfnCtXK2sEJlGzfPUNnGpfp+rTyWL6xolsf+g/pqz6NG6MyB43TZgb/XlkP6NT325lNTdfYul+jMgeM0f/Yi7X/K3qpeVaMPX5ulXQ4cJEna8+gReuvpqUo2JHX0+MN01qBxOmOni3T7WX9e7/eD3NKid0r81LsvfqBkQ1JffzRf8US86Qt87sfztVGfbtpkq43VZ/tNdONLV0iS4om4ln6zTJL03L3/2aBtv/jgq9p0m166+90b9d28Jfrk7c+aBq61Pfunl/TotU8qnU7rpGuP1hm3nKBbTvnTOs/ZYY9tNflvbyqVSqnim2Wa8erHTY/tuNd2+tW4Q1VY3E4lpR0095MFeue59/TCA69ov9F76Z4LJmnkr4br7F0u0erKKtXV1OnCB87S1Ofe0zvPvb9B7xFti8s8Lf1mmY7d7CytXLpK/Qf11dVPj9Np21+wzr/mevH6c6kddt9Gz9z5giTp64/ma86H85oeG/mrXfXz00YpkZdQac8u2mzb3vr6o/l65S9vaJ/jdte/J07WNrtuqRtPvFPFJUXq2be7xt5xsqY+/77e8/h7Y8CLyywFMfHyv2ri5X/V0RMO06Fn76+Hr35cX77/tY7tM0Y1q2s09ICBuubpi3XSVueu87qtd+mvma/NUmV5Y62k1x5/W7233FiSVNa7qy7/2/kq7dlFeQV5TbUp/v3gZF3zzMV6+vZ/ab/Re+vfDzVO8s16e7bGTRyr1594W28+NTVj7x25I9vzNGD3bXX14Y132k371/tasXRV02OHnXuARhw2VJLUfZMy9e7fU59O/UIzJn+sYQftrPmfLlRefkJzP56v+tp6nXHzCTr1hmP1znPv6eM3Z7f4vqPtyfY8WbbffWu99cw01VbXSZKmPDu96bHNt99UJ117tDp0bq/CDoV676UZkqQXHnhFvxp3qN7+x7va76S9dOvp90iS5nw4XxP+cp7e/sc0vfXMuxl/L8iMjE5K1NXWS2r8YZKsTzYtT6VSjTPQsZjmzVqo80Zctt7rvOiBMeo3cHNVLF6qyw663nxeKpnSPRdMavr/2978nRZ+/k2z5y3/vrLpv/9138u69tkJ670v+e3yde5dp2rskAlasrBCx191pAoK8yVJ/31yqo6/8kh98OpH+uK9OVq5ZhA8Z5dLNHCfHbT7EcN0yNgDdPGoa9Z7e2jbXOapvq5B9WvO4S/en6NvvvpOvbfs2aw45bLvKptu6Svt0VnLv1+x3vvSo093HXHhITp76AStWr5a4x4cq4LCxj/t+PfEyfrtPyeorqZeb/x9ilLJlFYtX60zdhqnwfvtqIPO+JlG/mrXZhOKgBeXWQrjlUff1HXPX6KHr358nYnAaS98oHPuOlUdu5asd9G+s+84WU/e+pymPDtdA0ZuqxOu+pWkxn8hW/ZdpXbaa3ttPbSfbjjuDknS7Wfdp62H9tMuB+6su6ffqDGDxzeNZ4DUMnkqX1Sxzt2t3XqVqnzR0nWes6JipTp0LlY8EVcqmVJZ766q+Mlz/AwYua0G7TNA5w2/TLXVdbr51auVv+Ya7oX7X9GvL/mlFny2qGmCbtEX32jMzuM19OcDNfraX+uDVz/6n0VmgaBaIk+W8kVLVdZ7rZz17qryxc0zVL54qbpv0lWz1vx/We+uzfLo56KJY3X1L/6gOR/O074n7qkdR24nSZr19mfaqE83DRi5reKJuObOWiBJuvyg67XDHtto2MGDdcylv9RpAy70/Idl5Lasagm68LPF6tSto7YZtqUkKZGX8LwVdW03n3K3zhw07n9e9LUrKlBhcTtJjX+DnmxIav6nC5s9r7RH56b/HvGLoZr78YJmz/nojU+056+GKx6Pq7RHZ+24V2OYfpiAqCxfqcL2hdr98GFNr6mvrdf0l2bqvLtPaxrQCtsXqn2nYk174QP96fxJ2mLHzXzfAxBES+apU1lHxeONXx89Nu+uXv176ps53zd73pRnp+tnJ+4pSfrZiXvq7X82n+H+6L+fau9jGm8T77PdJuo7oDEHxR2LVLO6Rqsrq9S5eycNOWCnptdUfLNMFYuX6tjLDtdLa/5Mo2PXEsXjMb351FQ9dMXf1H9g32bbAsJoySytr7X/9nf4oYO1YHZj55suG3VuWr7VkH6Kx+PNJiRmT/1CA0Zuq5LSDkrkJbTHEbs2Pda+U3HTxeS+J+y5zuteeOAVTXjknMaJvzUFBXv23Uizp32pSVc9psolK9R9k7JI3h/ajjB5mvLP6drzqBHKL8hTjz6NY85n05rXBJs5eZb2OKLx2mvfE0d6jjkf/veTpjFnyP47qWNpB0mNWVi5bJVqq+u0yVYba5th/ZteM3val+q2SVft9evdNPmvb0mSuvbsopqqWr3y6H/1+M3/UL+Bm4c4GsCGCZMny9Jvl6tqRbW22aXx3B91/EhN+UfzDE3553SNOn6kJGmbXfprdWVVs3oSH73xqYYfOkQFhQUq6lCoXQ/auemx4pJCLf1mmRJ5Ce19zO7rvO7lR17XpY+e1/RbKRaLqdsmXTXztVm6f/xf1L5TsYo6FIZ6f8huGb1T4n9pqG/QtUfeojG3j1b7TsVK5CX01O3Pa94nC5v+Jup/3Yo04rChGnvHyerUraN+99wl+mrGXF1ywHXq3L2Trn/xcqVTKZUvWqobT7iz6TUX3HemnrvnJX3+3hydduPx2mKnPkqn0/pu7hLddua9zbbx5tPTtNPeO+j+Wbfq+/nl+nRKY6Gl1ZVV+tf9r+i+j27Rsm+X6/N3v1rnda8++l+NOGyo3nvpQ0mNobzmmfEqKMxXLBbTPRdOarYtIKyWzNMOe2yjE685Ssn6pFKplG4/689auazxX0vXztPfbnhaVzx2gQ44eW99N2+JfnfUrc228eyfXtJFD47RA7Nu1fxPFzXdbTHnw3n66oO5evDT27RkQYVmvfXZOq979f/+q87dOjYVECzrVaqLHhzTNFnywKV0+UA0WjJLUmNLwuKOxcovyNPwQ4down6/0/xPF66TpVOuP1a9t9pY6VRa381b0tR5Y48jhumgMxsLgNVV1+m6XzfP2NJvl+uRax7XHW9fp1XLq/TVzLlNjz18zeO64vELtHLZas2Y/LF6bN696bEp/5yuix4cs059ltP/cLx69e8pxaQZr368zrqA9REmT/M+Wag3npii+2fdqmRDSneefX/TRNl1z12i/3faPar4Zpnum/AXXfbX83XStb/WVx98rRcfeLXZ9h+55gld9n+/0V4f7aZPpnym7+YtkSRNf3GGDjpjXz0w61Yt+GyxPn3ni3Ve9/oTU7TFjn2a2lpvvsOmOu0PxyudSquhvkF3jGneFhtoaWHHJ2vcuXPsfbpo4li1KyrQuy/O0LQXPpCkddY17V/va5efD9SkL+5UbVWdbj75rmbr//KDr/X642/r3hk3afn3K/TZWr+JHrryMd3xzvWqXLJCs6d9oeIORU2PvfLomzrp2l9r8l/flNT45ygTHjlX7TsVSzHp6Ttf0OrKqugOILJGzOtvvH/ws/iRAet7w88RFx6s9p2KfyxQtlbF54zzK91u7VfQcu9twH9ST6z3h0ieIrLm/Dz7jpP15Yyv9eKDWV7Q0soNOWuGPDngMw5tuXNjRfcL1qfDRpgxxaU2kLP1zRNZWj/X/nOCnrrtOX2wVh2x9ZKN57+fNpCNoBibMmf3w4dp+CFDdONJf3S9K83x2ykSVp6y6k6J1uyqJ8dp4y020rh9qBkBbKi7pt2gmtU1uveih13vCtAqHXXxoTr4zH11/fF3uN4VwKn2nYr1x6nXa87MecEnJACst7F3nKwh+w/UZQf+3vWuwAHulHCJOyVyHrPnDrSWf3UiZ82QJweiyhN3SmQd7pTIEtl4/vtpA9kIirHJgWzMDb+dImHlKasKXQIAAAAAgLaDSQkAAAAAAOAEkxIAAAAAAMAJCl1asvFvmaIU5v1FeUz4G6vWqbXnJoygx4Sc4Qe5lKdc2lfJf3/JTW4K85nm2nmbCZkYg/j7+9zWVnPj+reTpZXkhjslAAAAAACAE0xKAAAAAAAAJ5iUAAAAAAAATjApAQAAAAAAnGBSAgAAAAAAOJGb3TfaatVXP7GA80vpVMvsx/oK+hm2ksqyWSloFexszV/QDPhxnY+o0Mkje+RabqwMhMlZ0HW5zh+5yQ5Rdmhwmb+2PDZF2X2KLLWMbB2bgooyZ2G4zGaYzzAL88SdEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADiRmy1BXYqw5Uws7t3CJZ3ybtNiPd+Pta6MtM6Jsj1OK2l340yY4xdlmyjXrZoCiiUSgZ5v5iyMbG35FmV7vlyXrS3UosxZwHX5jU/pVMD9yrXxyQ/tr/25HpvMbWTpmJWN+0WWskdbGJvMTQT7TdUCOxDs+a6v9bIwT1n47QYAAAAAANoCJiUAAAAAAIATTEoAAAAAAAAnmJQAAAAAAABOMCkBAAAAAACccN99I8eqKIfpgBF4GwEr//uvK8SLIqoIG7jieoTblpSVlWVbXI51zIg0T5mofGxsIxaP7rwNlZvgG4luXa2hK4fLiuU5Nj6F2d/A41AGqpI7H58sud5pqpVkyd5EmG4hDv/9L8Q5G7hbQZj35zJL2ZSXsFx32YiwO1OLb9vh7yB/3jsWqluI604eEeFOCQAAAAAA4ASTEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE5E332jtXfTsLYdorJsLAPHKh2qyrBRqjZgRVi/jgRmdVmXVZz9Po9sq9acpV02IsuTH2MbwfNkbzt4bnzKO0eYm6BC5awt5ikTwnStyKk8BWfnLLo8Weez37HNyvGpLWbGkmNZMjcRYcaizJLZrSDKTh5c660fh7+pnHZHk5zmybo+9L02bO1jUwa62XCnBAAAAAAAcIJJCQAAAAAA4ASTEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE5E3xI0Kplo+eS3naBt0uI++xvmNRGJpYyWLyFauKSVDPaClP3+grY9NNvgNK4s0LoiayuVCZloB2Vtug3nyXznYfJktFdLJ608hWjJG+U5TZ7WYz1tYHyynp7wPj/DtJ8OnLPGDQV6TTptbMUnTxkZn6Jqxya5aWPoMEv2qnz2qZWMTeamrQdCZCnKsSkrs5SNGJu8XhT8NVExchMLca3H2LT+uFMCAAAAAAA4waQEAAAAAABwgkkJAAAAAADgBJMSAAAAAADACSYlAAAAAACAE+G6b0TZESDKSrEBq8FKISrCGpXHYwmf92G8RnFrefCKrKaUUUXZrK7ssx3rWBnrSvt9tFZnDqPqq191YN/qslFpyS4YuZYnv3VZObDyZLz3WL7PV1NUefJjnVNWnnzOwXRDg+dy87snwjwFrdQsZShPLSlb82Sxzmfl1vgUC9Mdxuyk4bMuKx/G8hjjU3bIRJZ8thF4bIoyS9bn45N9k3U+WRkzxh9JSieN89naX6tbh19ntoBZCiVXunJk69iUiWu9TIxNUYrwt5M5NmUgT7k2NnGnBAAAAAAAcIJJCQAAAAAA4ASTEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACfCdd8II2B1V9+qywG7bJiVhCWfirBGdVejK0CsoMDeRp5xmI11pfOMbVuVyiXFjCrKZqXYunpzXel678diDd7HMW1U27Wqnks+1WVDVGq2zhWzsmyuVGr2E2WeLC7zlJ9vb8N6LBN5qjcqmRuZkSRZ1aWNqug5l6cwcqFbgI9QebKyka15MnJj5smH0/HJ2ief/EeZJ1PQivcuxqcwOW3t13qZGJv8pIwq+9bY5JMlc9yyxiZjG+YxVPAs+XWMCjwGca23futqw3mKNQTsslFbZ67L7LRmjU1W9xsj45JP16hMjE1h1uUzznrhTgkAAAAAAOAEkxIAAAAAAMAJJiUAAAAAAIATTEoAAAAAAAAnmJQAAAAAAABOZK77RlB+FWeDVor1qQwcM6q4Kt+7m0asnffydHGhuY10cTvP5cn23utKFQSfK4rXeVdFTayq9Vweq/JeLkmxau/HzKrnRnXntE8FWeuzClxZtnFD9mNtjFl5OdfyVOSdGUlKt/fOWqR5qvWuvJyoMjKwusZcV+A81RrPN7dgV2vOSJ5cVTiPsoOH8R4y0mWjteTJ5wS18+RdyTzU+GRURY8Zn61VKV2KNk9WN4FIu9nkgFBZstYVJkvWY+28sxEmS6kORd7Li727CCTbGd8VPhXrA1/r+Y1NtUYXgxpjXWGyZCwP3OFGGcpSFOOKy+5SQbv6KHt/O6WMscnMU6GRJ5/zI9LfTjXeY5CdJ6PLjbkFKWZcN2ZkbMrAtR53SgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADjBpAQAAAAAAHCCSQkAAAAAAOCEf0vQMG1tArajCdMmymxfEzfauvm0tTHb1xR6t31KlxR7Lm/o5N0KSpJqunuvq6rMe78a2nu/v3i93Sgmf5X38qJy79Y57Srsjz5hHcfV3s9PJ71bO5ktg2S3vIkZ60r7NsnJERnIU6QykSejhVpDZ++cSVLNRt7rqi713q96I08xny5GBSu8z7eicu8WTu0q7GMSWZ5S3q2gJClttaGMME/Wd3VOtTaMKk9h1mN9Rj7fk8rzfsxsr9axvefyhs4+41O3YONTfQdrfDI3oYKV3udI8RLv91GwNMT4ZDw/bbQri5k91KR00tiG1So01/PkcmzyWU8sYTxmZclvbAra+tO61uviMzYFzFKyyDjuPqeAPTYZ13rLvJdLUmKp9yBktSQNet0mSWnj3DLbwud6lsLKxG+nKPMU1bVeiDxVdw02NsXs01PtKr2/0wsrQvx2qgw6bniL+bTYTKdy7Fov4NjCnRIAAAAAAMAJJiUAAAAAAIATTEoAAAAAAAAnmJQAAAAAAABOMCkBAAAAAACc8O++ESGzUqxVcTZEZVmrgqx8qpvH8rxfky70riyb7Fjouby6p/dySarc3Hsbq/p6V0st6Fblubyh3ud9LPDefsc5RvX2lHdVW0kqrDOq/9d7dx6INXgvTyd92hsYFdRlVH02l0tSyppb8ym5m+OizJNZYTkTeSoJkac+Rp628P6823X3zlN9nc/7WBgwT2l7f9vVe+cgYeRJ9UYbg4RPnoLmJkyefCpC57qM5Mn6zvOpcB4zOgYEHp96OB6fjDw1GHkqidn7WxgwT6HGp4Advnzz1HqHIU9hugKYrONtLfcbmwq8q+mni7wzZo5NIbK0sp/3OVhYVu25vL7e5zthvncXA2ts8lNY631yJhqMa0ArS35dGqxs+HTsMFnfx21xbLKEyV+YPAW91jM6FPrlafkWxti0uZGnbt55qqv16ZhhjE0lZp58xiZjTDHHJqtjRoPP/QLWZ2Xlye98yMJrPe6UAAAAAAAATjApAQAAAAAAnGBSAgAAAAAAOMGkBAAAAAAAcIJJCQAAAAAA4ETGum9Eyqg+GrMqZlvLJSnPOARGpeaG9t7Lq7va8zurNveuirrboE89lx9RNt1z+Zy67uY2Huk41HN5VXWZ5/J2K+yPPn+l93uMVRudB/wqLztkVS1Op3wqpbtgVZTO2Pa9j5OZp7jP523kKV3kXZG5vqP38qoynzwZXTaC5mleXTdzGxNLhnkuX13T1XN5u+X2Mcmv9D4m8dXer4kZ32/pKKvaZ4LfeZ3j1dLNbIR5jW+ejMfaeefGGp+quvnkyeiyYeXpmG5TPZd/5TM+3d9hhPd+VZV6Li9cau9vQaGRp6oIx6egFc7xv0XYaS1UlqzP1LrW6xBibDKytMuALz2XH7/R257L59RuZG5jYgdjbKr1HpsKfcamguUBxybretnqGCX7s0qH6WSTbdduQUV5rRdmXdZvp4SVzeDXelH+dlrdx8jTjt55Orr7NM/lC+q8syFJEzt656nKuNbzzZN1rWd0MbE7dUXYQSXHxizulAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADjBpAQAAAAAAHCCSYksFatPa4drFylWn+OFfYAsQJ6A6MTq09rmt9+QJ2ADxerT2u63i8kSEIFYfVoDrl1InnIUkxJZqmzqKm0xqUJl01a53hUg55EnIDpdp67W5pOWqnTaate7AuS0rlNXq++kpepKloAN1m3qKvWbVM61Xo4K1xI0Ay0MfVuume2gjOV+LcGMVjjpPO/lqXzv5cl29v7GOtV5Lh/ScV6zZds8vVij7vxcsZUppWPS8DFzlS6Jq258J330i+XmNl4u2cZz+edF3m1t0n4fYYh2d55yrYWhK37tEa2sZaKNaJjPz2otZbUFM3KWLPTJU0fvPA3v9FWzZVs9/Y32uuOrZnlqGN9Jcw5fYm7j3x239Vz+eYF3C0O/PKUTAY+j1dopjJTD1puu2n5maYtdM09+ObNyk+89piULjDwV+GyjxLudn5Wnve/4SlqTp6FnzZdK4moY30Ub/7LS3MTzHXfwXP5lUZfg+2sdL79WgkHWEzXjfEznQqu2XLvW8/tMA1/rea+roSj42LR36exmy7Z8+lvtefuPY9Ows+Y1jU2f/XKZuY3/dPK+1pttjE1J706MknzGJuu4B82YpLT1mjBjU463knYu6LV9hHmyxibfPBm/nfbs8lmzZT+91tttzJy1rvW+M7fxXHvvsenrdt55Svn9ao7qt1Mbxp0SWWbuyDKl+uRJ9WnF0pLq00ptnqeGfYpc7xqQc+aN7Kr0T/KU3jxPyVHFrncNyDnzRnZVqk/+T8anfKXIExDI/JGljE1ARLjWax2YlMgy1aUFqhvXSaqX0sUxqV6qu6iT1NXnbg8AnmpKC9Rwced18tQwrjN5AkKoKS1Q8id5SpInIDDGJiA65Kl1YFIiC+W9UaN0j4RqbypVukdCeW/UuN4lIGfFX69WukdC9Td1VbpHQvE3ql3vEpCz4q9XSz0SaripTCJPQGiMTUB0yFPuC1dTAi2q7qyOqjuno1QUV8N+RVKD6z0CclfDmE5qOLeTVBRXcn/yBGyI5JjOSp7bWSqKq27/YvIEhMTYBESHPOU+JiWyUclaN7AUcTMLsEHIExAd8gREgywB0SFPOS9rJyXMir2SYmY13xB9aa11Jb2Xx+u9q//GfXrippe281z++tL+nsvbxb2roX9V093cxuffdvNcnl/pXQ02r8auYhyrN6qCW9XCreVhPo+2WJE5TIVz6z0b6/KtcJ6JPBnLrTwlanzytLzAc/lz3w/wXJ4f8z4//fL05fdl3utaGTxP8TorH8ZrwmQgA1020mHOBxfCdLPJBOv4+XVhSAY7R8w81fp8dsu88/SvJd5VyS3za707PUnSV0aeCpZ55ym/2idPtcY/fwXNk9/5HGU2jfMxZlS2z6qc5VqW/I5dwGu9mPH0/CqfscnI0kvl3t2cUmnvc8D3Wu8741pvRYgsNQQ8z6O81otQVmXGMd9rPUuYscnIU8w4pxJ10V3rRTk2zavw7gBl5SlR6/i3UwbGJpeYSgIAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADjBpAQAAAAAAHCCSQkAAAAAAOBEuO4bWVqR2erYEWvwaVbb4H0IYvXer0lUeS8vXmIfyoY5Cc/lH6T6eS5/r/Nm3iuq8V6PJBUt9t5+yQLvz6rdMu8OH5IUr/J+zDomaatCvG9Vee/HzK4rIaormxWZw1Sc9ekGs8Fc5ylo1V6//TXOhViN9zll5qncJ09feefg0wbv3MzqvLH3imrtPBUaeeqwwPs8KFhhf8fEjfdu5qnByI3x/MYXee9XqDzlcreADAnVHcpeWeDHrDzlr/Je7js+fe2dg08a+ngu/6i0l/eKfPJUtMh7++2/MfJUaZ/rsRrvx8w8Wd9vft9jUeYpl2Vg/Ik2Sz6fqfG9ap03eUaWiirs87zEyNKMeuNar0sf7xXV2cfdzNJiI0vLfcamVXWey2N13u891LVe0OuL1polKSPXepHmyY91nWIsz1tt5clnbPrCO0+z6vp4Lv/YGJvSfr+dFgbLU7tlPnmyfjvVGnmyfpuG6HqSkd9OGcCdEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJwI133DNauab8y7OrxfJVOr+mmsptZzeV6l9zxOkVGZXpLidQWeywuXeleETRZ6Pz/mU3y/3Qrv92hVis1b7v3+JCleVeP9QK13pWYZxzAdZUVmrMOqjhszigz7VmQ2cmN9frGkXck4XW9VH/bOTV5ltefyIjtOite1835Nufc2GoqC56lglfd7L6zwflFBRZW5rviq1pGnSCsyt2Q3myiZ1dLtDJirsvKUiC5PiRXe6/IdnxqC5am+2DtPCeN0luw8WeNT/lIjM7LH5uB58slMhB2JAucmTHeoXJCJLPmNTYGv9YwsWdeZ8rnWKzeu9QryvffJ5xQIOjblL7OzFPhaLxWwa1rjg8FfE5Vsy1KU3WzC5Mn4XgvTuTBtjFtWnhIrvN97ccI+JonagL+d2hnXej6XTtZvp8Kl3mNvqN9OxjhudavzzYbL304ZyBN3SgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADjBpAQAAAAAAHCCSYk2JpFKauxnzyqR9ilHC+B/asqSUZEcwPojT0B0uNYDopFIJTX2c8amTMhYS1CzhWHcaDGSsudL0sZDMav1kE/rL6vlTdro7BIz3kdeg32yJlZZbaK820GlrRY5Pm1i4nXe249XrdvaaeCqr3XEwrf1XsPGmlG8mffKjJY+Vns6q9WW3/6aLW+s9mlRtlxrBWJWiz/rOEWZJ582UVazNOsTsp6f55PZxGrvdmWF33t/naUKjNZVPqeNladY9Y8ZGLRyjo5Y+Lam5/fRzFhPe2WtJU/Z1l7NJZ/vnLSCtf70zZORc3N8MtbjOz5VeZ+HhUu88xRqfKr3Pnea5WnB25qe10cz8nqZ64pVB8xTndWOzadVeNA8udZS7RX9Mm+0N7Sv9YyzM1NZMrdhPN+61rPOJ0mJ1YWeywvLA2bJR7zWaG1at+7yH8an95K97Gs9o/VnpFmyHsvWa72WbFXqOk/WtZ7xGfkdiVb/22mtsWngqjk6fOEUTc/bXDPiGbjWi3JsyrE8ZWxSAm6NWjZTJ33/uopTdUpLuuK7f6gq3k6TuozQyx23d717QM4YtXSmRn/3mopTtUpLunLe31UVKyBLQAhWnh7qupte7rSD690DcsqoijV5Sjbm6Ypvn2m81ivdjfEJCGDUspk66bvXm8amK+ZzrdfS+PONNuLdkn5aXNBFeemkYpLy0iktyu+sd9v3db1rQE55t+NPs5QkS0BInnkq6KJ322/heteAnPNuJ671gCg0/93EtV5LY1KijajMa6+Hu49UXjqp6li+8pTUX7qMUGWi2PWuATmlMq+9JvVYk6V4vvLSZAkIyytPj3Qdoco88gQE1SxPSuovpYxPQFCVee318EZr/W7iWq/FMSnRhgxaNUcVeSW6vdfPVZHooIHVc13vEpCTdl45RxX5Jbqt14GqyC8hS8AGaJan1XNd7xKQs5ry1PtAVSRKNLBqnutdAnLSj7+bDlRFHtd6LY2aEm3I38t21d+6jVBdPF9T8jZTnihcB4TxRLfh+mv33VQXz9fbHbdSwerVrncJyFk/zVN+dbXrXQJy1hPdh+uvGzXm6Z0E13pAWGv/bnq745bKr6pyvUutWvSTElalT6OybOD1SGYnAbNSs99mvIsPm5VirUrCViVaya4WHs/zriCtmNVZwaeKqfVY/Y/79cNlXky1qm1oUO06S9diVdUNWHnZrLosBa4UG6pKbCvuFhC4InOYbVjnut9rjOVm5XNrG0ZVcEmKVXlXXg6cJz8p49xZ0xXkhwLTcdWqQVJDfXqtpesKXMncer5f/jORJ+s7vBXkLHCeQoxPigU/Tub4FPA71zdPUY1Pfqxzd03l9eZ5Siom74u/qDoDRDk+hRJ0XS3aFcBYt99nnYlrPRnnoPX97LcZY3nM+o60smScf5JPlvKDdd+wrj8l/c+xSVo3T3X1DWpMf/NrPStLa183rrsNrvVaTFR58mMdW5djk99vpyrvayorT6HGJuvcXTM2/fi7qUb1kuoaUvL83SRJxhgUtMtGW84Tf74BAAAAAACcYFICAAAAAAA4waQEAAAAAABwgkkJAAAAAADgBJMSAAAAAADACectQSPtImB1zDC6ckg+XQGMCsexhHc1aLO6qmRXzzUqL4diVc+2Kq/6VHc1K79alWKDblvKzkqxLVndPKyAFZntPIXoFmDtkl+ejNyYlZfzjKrkfnmyOglY3xlhKjJbrHPEN0/GsQ/aZYM8bbjI8hS8K0HaOkV8jlPQ8UnWuWZ1ppCkfOMxKzdRdmGx9tdnXWaeglYyz1SeouLbCSMLs/YTobJkfabmOeiTJWtsShkdPqzzzG9sMq4PVRMsS+kwWYpybMrWLOXK2BSmm03QTZjHz+f6zMia07EpW387WazONOK3UxS4UwIAAAAAADjBpAQAAAAAAHCCSQkAAAAAAOAEkxIAAAAAAMAJJiUAAAAAAIAT/t03oqwgG1HV88aXBKwY6tNdwK+TgCerumrcZ34n6PHyW5fFqnhrVnf1qW4epiKs54p8thHhunJGW8iT9ZBZtdvYdrbmyeJT4dxi5izMulx2BXAla/NkbN/aRojxKWa9R+OYpP2OSZgxLSjGpw2XAx02JGVvlqyHjOr/VsbSSb+xyaeTgBcrY0HHHz9+543VkaS1jE25khnXIhybLOHyZOQ/6NgUJk+ZGJtCjBtZOTZFiDslAAAAAACAE0xKAAAAAAAAJ5iUAAAAAAAATjApAQAAAAAAnGBSAgAAAAAAOMGkBAAAAAAAcMK/JWgmBGwf1fgS75YogdtHSTK72ljtq2S1dsnS1kNh2jFF1EImVCuotthazW9/grY3DNViKNjcpG8L0aB5CtpCNFv5nesBP5OszY25bfK07ktaPk9pa3xMWi12Q7RJdSnCDETakrCtjU+ZyFKIaz1LpGOTda1nZUwKnDOzTWKU54DrLOVYS8KsE/T4ZWueIrzWy0huLBnIgPOcORyDuFMCAAAAAAA4waQEAAAAAABwgkkJAAAAAADgBJMSAAAAAADACSYlAAAAAACAE+G6b0RZkdncRstXPffjW3XWS441C/ATabVyeyMRriuLqpW3AeHOD++AxNIhvi98qkt7ykD175zLjO92yFMmRZonq/p/lOOTlT/HVfYDH0fXXQHIWaMwn4NV4T8TWfIT8BrU7PDh+6LoztvIxi2ytH6y9LdTRvIU4bVe4Nxk6PxsNXlyiDslAAAAAACAE0xKAAAAAAAAJ5iUAAAAAAAATjApAQAAAAAAnGBSAgAAAAAAOBGu+4Yfq7psVJVlfbftuupsK5GNlV9zpbpy1DKRpyg/74CdMaKs7pxzXOaMPK2rTecpqODdClpVdxrPbbfBPLWSaz17E21gbOJaL3sEfd+ZGLOCdjrz3QR5ciLH8sSdEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADgRfUtQi8t2N36ysYVLa+H3mVufb461r3EmaDu2MJ9FGC7zZLWvagsZJzcbhvFpg6VzrHubL5ftLnNdth67HMpSm8CYtWHCHL+gGczWzLTlaz1LK8kTd0oAAAAAAAAnmJQAAAAAAABOMCkBAAAAAACcYFICAAAAAAA4waQEAAAAAABwInPdN4KKspKo66rPrUWUn0krqRSbdcIc12ytlh5UtlZejrJTCrJDlJXPM9UZp7XLRG7IZnhc02Ufxqa2hWs9N8jNeuNOCQAAAAAA4ASTEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE5kb/eNKGWi6nOUFdSjrJBL1VeEla3nTmvJU7YeX7SMKDvjWDJRRT1MnqJ8H+QG2XoORNW1wvX5n63HFy0jE593lL+d6BrTanGnBAAAAAAAcIJJCQAAAAAA4ASTEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACfaRveNKGWignpLrwfIZeQJ8ObynKYzDdo6xibAWyZ+O5GbnMedEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADjBpAQAAAAAAHCCSQkAAAAAAOAEkxIAAAAAAMAJJiUAAAAAAIATTEoAAAAAAAAnmJQAAAAAAABOxNLptOt9AAAAAAAAbRB3SgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADjBpAQAAAAAAHCCSQkAAAAAAOAEkxIAAAAAAMAJJiUAAAAAAIATTEoAAAAAAAAn8vwe/Fn8yHSmdgTIRf9JPRFb3+eSJ8AfeQKis755IkuAP8YmIDpWnrhTAgAAAAAAOMGkBAAAAAAAcIJJCQAAAAAA4ASTEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADiRF8VKSko76KaXr5IkdenRWalkSpVLVmjjfj30n0de151j749iM54GjRqgU64/VvkFeaqva9B9Fz+iGZM/liT1H9RX4yaOVUFRgaa98L7uPm+i5zrG3D5aQw8YpNqqWt00+i59+cHXvts8/qojVb2qRn+/5dnI3w+QrXm6+dWrVdqzi+qq6yRJE/a7VsuXrGi2jqMnHKb9T95HqWRKd5/3oKa/NNN3m/ueuKe2HLyF/njOA9G/IbRpLrO01ZB+Ov/eMxr/JyY9cs0TeuuZaZKkwfvtpDG3jVY8EdcLD7yix258ptnr8wvydPGkc9R/575aUbFS1x19q76bt8R3m+MeHKt3nn9P/33ynajfDuA0Tz/otkmZHph1qx6+5vGmazDyhFyUrXmSpHg8rrvevUHli5bqikNu8HzdxQ+NVYfO7RVPxPXAJY9q2gsfSJI232FT/eaeM1TcsUjpVFpjh05QfW29uQ8DRm6rIy88xHM7aFsimZRYuXSVzhw0TlLmf7BXlq/QlYfcoIpvlqnPdpvo+hcv1683abwQPPfu03Tr6ffo06lf6LrnL9WQ/XfSuy/OWOf1Qw8YqF79euqkLc/RNrv017l3n6Zzd700I/sOeMnWPEnSDcfdrs/fm2O+ftNtemvPo0botO3PV9eNS3Xjf67Q6K3OUyqVysTuA+twmaW5H8/XmCHjlUqmVNqjs+6ZcbOmPDtdSkvn/PEUjd/3WpUvXKo/TrteU/45XfM/XbjO6/c/ZW+tWr5KJ215jvY8arhOveE4XffrWzOy74AXl3n6wZm3nKh31/z4kRp/PJEn5KJszNMPfnHezzX/00Uq7ljk+bpjLz9crz8xRc/d85I23aa3rnv+Eh3fd6ziibgmPHKubjzhTs35cJ5KSjsoWZ9s6beBViKSSQnL2rNfx191pHr06a6efTdS903LdM8FD2nrYVtq6P4Dm2bikg1J9R/UV2fecqIKOxRqRfkK3TT6Li39drm5ja9mzG3677mzFqigqED5BXkqKe2g4o5F+nTqF5Kklx95XcMPG9psUmLXQ4fo5UdelyR9OvULdejcXqU9Ojfb5jGX/lI/O2Gkln+/QksWlOvz9xt/mB1w6j468LRRyivI0+Ivv9WNJ9ypeCKue2feotFbnatkQ1LFJUW6Z8bNGr3VuTr4rH110Bn7KtmQ1LxPFur3x9y2oYe5USzmvTydjmb9cM5lnurrGtZrH4cfOlivPfaW6usa9O3c77X4y2+11dB++vSdz9d53n4n7amjJ/xCq5ZXac6Hc1Vf27j+YQftrGMuO1z5BXlaUbFS1x93hyqXrNDE2bfrvBGXq7J8hWKxmCZ+dofOG36ZdtxzWx135ZFKJVNaXVmlC/e8KvBxRduTiSzVrrmjSJIKCguavou3GtpPi7/8Vt9+/b0k6bXH3tLwQwc3+xE1/JAheviaJyRJb/z9HZ195yme2zn7zlM0aNQALVlQroa1cnrcFUdo2EE7q6CoQJ9M+Vy3nXGvevbdSFc8foHGDB4vSerVr4cu+9v5GjN4vE65/ljtevBgJRuSeu8/M/XncY8EP7BokzKRJ0kafugQfTv3e9WsrmlaRp7Q2rjMkySV9SrVLj8fpP/7/VM6/PyDPF+bTqfVfs2ERftOxapYvEySNHjfHTXnw3ma8+E8SY0TL14G77eTzrr1JNVW1erjt2Y3Ld9qSD+NuW20CgrzVVtdp5tPvlsLP1+sW167RnefN1FfzZwrSbr1jWt159n3q0Pn9hpz2+imfbpg5JWqXlXjtUnkgIzWlNh4ix4at881uvLQGzX+kXM1c/LHOn3HC1VbXaddDhykRF5CY+84Wb898haNHTJeL06crNHX/VqSdNAZP9NBZ/zMd/27Hz5MX74/R/V1DSrrVaryhRVNjy1ZWKGyjUubvaZs41J9v+DH55UvrFBZr3Wf139QX+151AidOXCcLjvw99pySL+mx958aqrO3uUSnTlwnObPXqT9T9lb1atq9OFrs7TLgYMkSXsePUJvPT1VyYakjh5/mM4aNE5n7HSRbj/rz8EPIrBGJvP0g4seHKt73r9Jx15+uOdrynp11ZK18rRk0dJmeSrt0VknXH2UfrPbFTp/9yu02Ta9mx77+M3ZOnfXS3XWzhfrtcfe0lEXH6p0Oq2XH31Dex+7myRp0KgdNGfmXFWWr9BxVxypS/a/TmcOHKcrD70x2AEE1mipLG09tJ/u++j/6c8f3qLbz7pPqWRKZb1KtWTh2mPOUpX16trstV17lWrJgnJJapp069i1ZJ3n7PaLoeq95cY6dbvz9YcT/6hth2/V9Ng//viizt7lEp0+4EK1KyzQsIN21jdzvtPqyiptsWMfSdJ+o/fSvx+arJLSDhpx2FCduv35OmOni/To757coOOJtq0l8lTYvlBHXXyYHlkzsfAD8oTWLpN5kqSzbh2t+8b/xfcO10euflz7HLuH/m/+Pbru+Ut017kPSpJ6bdlTSkvXv3CZ7p5+o3417pBmr81vl6/z/3yGrjzkBo0ZPF6lG3VuemzB7EU6f48rdNbOF2vSVY/p5DXv48UHX9W+J+3ZuI3+PVVQmK85H87TERcerDvPvl9nDhqn8/e4cp1/DEDuadE7JX7q3Rc/ULIhqa8/mq94It5018Lcj+droz7dtMlWG6vP9pvoxpeukCTFE3Et/aZx9u25e//ju+7Ntu2tU284VhP2+13k+7397lvrrWemNZ3sU56d3vTY5ttvqpOuPVodOrdXYYdCvfdS43t64YFX9Ktxh+rtf7yr/U7aS7eefo8kac6H8zXhL+fp7X9M01vPvBv5vqLtyHSerj/uDlUsXqqiDoW66u8XadTxe+jlR94IvN9b79JfM1+bpcryxnoUrz3+tnpvubEkqax3V13+t/NV2rOL8grymv71698PTtY1z1ysp2//l/Ybvbf+/dBkSdKst2dr3MSxev2Jt/XmU1MD7wsgtVyWZk/7UqftcIE23bqXxj10dtPf3EZlhz221eS/valUKqWKb5ZpxqsfNz22417b6VfjDlVhcTuVlHbQ3E8W6J3n3tMLD7yi/UbvpXsumKSRvxqus3e5RKsrq1RXU6cLHzhLU597T+88936k+4m2pSXydMLVR+rJ255r9q+6USJPyEaZzNMuBw7S8iWV+uL9ORowcltzn/b69W56adJk/f3/Padthm2p8Q+fo9N2uECJvIS2221rnT10gmqravWHl6/SF+/N0QdrZWnTrXvp26+/16Ivv5UkvfLof/Xz00ZJarzrYtxDZ6tX/x5SWkrkJyRJbzwxRcdefoT+PO4R7X/y3npp0muSpFlvf6YzbjlRr/7ff/XmU1NVvoi7JHJZRicl6tYUOkmn0+v8jVEqlVIiLyHFYpo3a6HOG3FZoPWW9SrV1U+N0x9O/KO+mfOdJKl80VKV9f5xtrxb764qX7y02WvLFy9V9026atYP6+rdVeWLmj/PctHEsbr6F3/QnA/nad8T99SOI7eT1BiUjfp004CR2yqeiGvurAWSpMsPul477LGNhh08WMdc+kudNuBCpZL8vT2Cy2SeJKliTX6qV9Xo1b++qa2H9m82KVG+qELdNlkrd71KA+Xp7DtO1pO3Pqcpz07XgJHb6oSrfiWp8U6nZd9Vaqe9ttfWQ/vphuPukCTdftZ92npoP+1y4M66e/qNGjN4vHm7IGBpqSz9YP7sRapeVaPNt99E5YuWqttaY1NZ71KVL6po9pqKRUvVbZMylS9aqngirvadirWiYuV6bS+/Xb7OvetUjR0yQUsWVuj4q45UQWG+JOm/T07V8VceqQ9e/UhfvDenKS/n7HKJBu6zg3Y/YpgOGXuALh51Taj3CrREnrYe2l+7Hz5Mp914nDp0bq9UKq36mnp9/t4c8oRWLZN56tqrVLsePFhDDxiogsICFXcs0viHz9GNJ9y5zuv3P3lvXXrAdZKkT9/5XAWF+epUVqLyhRX66I1PmrI17YX31W9Q33UmJfyc9NujNfO1j3XN4Tdpo8266ebJV0tq/HPI91/+UMMPHaKRR+7a9CdTj934jKY+/752+flA3fbm73TJ/r/Tgs8Wr/dxQHbJqpagCz9brE7dOmqbYVtKkhJ5CW22bW/f17TvVKzfPXeJHrjkUc16+7Om5Uu/Xa6qFdXaZpf+kqRRx4/UlH80vzNhyj+na9TxIyVJ2+zSX6srq5r9HdZHb3yq4YcOUUFhgYo6FGrXg3Zueqy4pFBLv1mmRF5Cex+z+zqve/mR13Xpo+c1/atuLBZTt026auZrs3T/+L+ofadiFXUoXM+jAwQTZZ7iiXjTra6JvIR2OXBnzf14frPXT/nndO151AjlF+SpR5/u6tW/pz6b9uU6z5k99QsNGLmtSko7KJGX0B5H7LrO9n+YxNj3hD3Xed0LD7yiCY+cozf+PqXptsKefTfS7GlfatJVj6lyyQp136RsPY8OsP7CZKlHn+6KJxqH2O6blmnTrTfWt3OX6LN3v1Sv/j3Vo0935eXnac+jRmjKP6c3e/2UZ6dr3xMbx6Y9jhi2zr/a/uCjNz7Rnr8arng8rtIenbXjXo2T4j/8YKosX6nC9oXa/fBhTa+pr63X9Jdm6ry7T2samwrbF6p9p2JNe+ED/en8Sdpix82CHiJgvYXJ0wUjr9Txfcfq+L5j9dTtz+uv1z+lf9z1InlCmxdlnh689P90zKZn6vi+Y3Xdr2/VjFc/bjYhIUnfzy/XwH12kNR450NBYb6WL1mh6f+eqc132FTtigoUT8Q1YI9tNe+Tdeu7zJ+9qKlOhiTtdfSIpseK174GXPPnGj944f5XNPb20frs3a+0avlqSY3XgHM/nq/H/vAPffbuV9pk614BjhyyTUbvlPhfGuobdO2Rt2jM7aPVvlOxEnkJPXX785r3ycKmv4n66a1Ih569vzbu10PHXXGkjrviSEk/tiq8c+x9umjiWLUrKtC7L85ounV27XVN+1fjDNukL+5UbVWdbj75rmb79eUHX+v1x9/WvTNu0vLvV+izd79qeuyhKx/THe9cr8olKzR72hcq7vBjpdpXHn1TJ137a03+65uS1FSVtn2nYikmPX3nC1pdWRXhEQR+FGWealbX6voXL1defkLxRFwfvPKR/nXfK5KkXQ8erC0Hb6FJVz2meZ8s1BtPTNH9s25VsiGlO8++v9nfJS79drkeueZx3fH2dVq1vKqpcJEkPXzN47ri8Qu0ctlqzZj8sXps3r3psSn/nK6LHhyjf0+c3LTs9D8cr179e0oxacarH6+zLiAqYbK0/W5b66jxhylZn1QqldIdY+9v+tejP57zgK5/8TLFE3H9e+Lkpou2E685Sp9P/0pTnp2uFx54VRMePkcPfX6nVi5d5dkp4M2np2mnvXfQ/bNu1ffzy/XplMaCsqsrq/Sv+1/RfR/domXfLtfna41ZkvTqo//ViMOG6r2XPpTUOLl+zTPjVVCYr1gspnsunBTtAQTWEiZPllQyRZ7QpkWZJz9r5+neix7WBX8+Q7/8zYFSWrppdONvp1XLV+vJW5/TH6fdoHQ6rWkvfKBp/1r3z5fqa+t16xn36nfPXdJY6PLN2Soqafzt9PhN/9DFD43VsZcdrqk/ed0X78/R6hXVTZN/kvTL3xyoHffcTulUWvNmLfDsJILcEUv7dGf4WfxIWjdsgN0PH6bhhwzRjSf9seU3Zn2OVleOKLfRhv0n9cR6H2DytGG23Lmvzvx/J+mCXOuwETSbYbLcSrJJnlrIT86dIy44WO07FWvSVY8FX1eYcy3KcSgqrSQzftY3T2Rpwxxx4Zo8XWnkKRvP/zDaQGYsjE0tJEA2uvbsoptfvUonb3u+/H675ozW8B5CsvKUVXdKtCZj7zhZQ/YfqMsO/L3rXQFy3lHjD9PBZ+6r69fUkgAQzlVPXqSN+26kcaN+63pXgJx31ZPjtPEWG2ncPtSMAFrKqOP30Ohrj9a9Fz3cOiYk4Ik7JTIhE7Pk3CnhBLPnDuTavzpxp8R6I08txPU4kI2ZbSWZ8cOdElkiG8//MNpAZiyMTS2ktWQjDPLUTFYVugQAAAAAAG0HkxIAAAAAAMAJJiUAAAAAAIATFLpsLX/PlIn3EXQbfn8vFfTv6ZEbWkueohT0mIQ5huSpbXGZs9aS8TDvgzy1Pq3lfM4EMoMfkJsN57LeYJbiTgkAAAAAAOAEkxIAAAAAAMAJJiUAAAAAAIATTEoAAAAAAAAnmJQAAAAAAABOtK7uG7lWDTZmzAmlU8GeHzVr+0FF2UXAT45Vl80ZuZYnSyZy45eZoDmPEnnKvFzLTbaOQ5ZM5MZCtfTMyrUsWVxmxmVepGi7tqFltOWcuc5HS/P7bLMwa9wpAQAAAAAAnGBSAgAAAAAAOMGkBAAAAAAAcIJJCQAAAAAA4ASTEgAAAAAAwAkmJQAAAAAAgBPZ2xI0W1vURNjaKRa33mPCc2k6Zbdvsdbl9xqflQV/TVBRtuGxzpUsbHeTlbIxayHOwUgzEHzjmXmNJRN5MrfdBnOWjZmRoj2nXLf+tATdr9be8i3Xuc5SjrXEDTzOuc5x0PxFeT4wNjnYfm7lyfn2vWRqzMrC305Z+GkAAAAAAIC2gEkJAAAAAADgBJMSAAAAAADACSYlAAAAAACAE0xKAAAAAAAAJzLXfcNllc+MdMxoebGEd1cO39fEW76Ka6QdPugisGEyUXk5A50xosxZmNwErhQd4XmbtXkyt519FZwDc1mx3PX41Mqrj6dTWdrlxtIa8uQlS8cmc1Vhxo2oOg/4nWfGazJxrWfxHbPoltMy2kKeAm8ktzoHRtoxx+VvJz8Bx60svBoBAAAAAABtAZMSAAAAAADACSYlAAAAAACAE0xKAAAAAAAAJ5iUAAAAAAAATmSu+4YlyiqfEXYFiHIbCriNWKRVdb33N+1XETVg9X+r6nOr6SIgZV/lc8e5sVcV8FwPU5HZ2EaUuUmng64rxPswO48EP9ezsopzNuYpx7psuByfoh2HvNnjEHnKWbnWFcDKmLWNUJ2hvM9nO2PB31/wMcuHdf4b57Lf91So68CohDkXW/PY5DI3lig7rWVkzAqxDcam9cadEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADgRfUvQqFqyZKJ9mt92omxtaB2TuPe2rbY2fm08zdckk97PN9ckuyVSymj9abTIicV8WisFbEWTTmWg3U22tf2UWn2ezBZORjbWvCjYPvmty9pE0BcYOZNk58barRDnetDWUr5t2oKeK1nYVqrFtYU8hchNUDEjG76srCWscdN4fz4ZyEieguYm21rsMjZ5vSj4a4JsW/Z1oPkKv4wZ60rLGs+M69xIs9Q6Whs60xbyZIlyzDJyEwvzXRsL9tvJ+dhkryzY80PgTgkAAAAAAOAEkxIAAAAAAMAJJiUAAAAAAIATTEoAAAAAAAAnmJQAAAAAAABOhOu+EVXVZSkzlWJ9OmMErghrrCuW8Hkf1vatbRvHxPd9W1020sZH7NMtIJ00Kqwa+xsz1mV2F5DsDgNGdVe/925Wlw1a9dxVdfNszVOIdZmVl60MhMmTtV95xrkeprK0lQ/rPEj67K91flrbsPLkdw5mIk9tUWsZn/y+Y/KN3AQcn3xzZp1TKSMDfueglQ9rDIxyfDL4VUSPbHxyoRWNTeaYEuW1njUGWfy6thliGciS+bm3lms9P1Ge8y257kyMTT7byEiegl7rWdrC2JSt13oBz3nulAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADjBpAQAAAAAAHCCSQkAAAAAAOBEuO4bYQSsFOtbJTbouvyqf5oVYY2qyAX53s/3qwbbriDQttN5xrb9qu8bj8XqG7yfX1dvr6veeKzBe11po9quVVlWktKyKttmaUXylqzIHEYm8mR10ogyT0bl/1iBkRnJzGDa6iJgVYP2yVPM6kBj5cnIhiSljTzFGryPo7VXMZ/9dZqnMJXPc6XCubWJMB1dwnTGiCpP+d6ZaXyNkad2xmuizJM1RtTWmetKG1kz8xRifFLMe3/tzlQ+VeqNzhw53ZXDT5RjkyXKsckaN4xruoxc6/mINQTr2uR3rZdrY5N1rkTaRaAlO61lQNaOTZn47eTXycPQlq/1AucpzNgUME/cKQEAAAAAAJxgUgIAAAAAADjBpAQAAAAAAHCCSQkAAAAAAOAEkxIAAAAAAMAJ/+4bYaqYB6y8HErQystWNViFqLzcrp3n8nRxobmNdHvvxxo6eFeWTedbFU7NTShe7139NF7lXQ02vqraXFesutZ780ZF9FjM6MqR8qn6alXPDVpZVjlU3TxbuwJkIk/53ud6zKiu7JunYu8MJtt7rytVEPw7KV7rfR4mjDzFVteY6wqeJ+/9tboOSJL1qWckT7nSFcCPccwzUsncL0/WY8Y4FCs0xqci7+VSluapyjszjY95Z83Mk7yX+9YEt8Yu63yIsvp/GBs6tmTr2BRlljIwNqWMa71UsXfnATNLftd6dRGOTTVGNmq882eOM1YHA0kxI0tp62vEZ2yyxhq7i4CjzlBR5ino2BTiN1iu5SnZ3ugYlWe8d5+PI9KxybrWs/IU5lovA3lyiTslAAAAAACAE0xKAAAAAAAAJ5iUAAAAAAAATjApAQAAAAAAnGBSAgAAAAAAOMGkBAAAAAAAcMK/JWgGhGlrY7aviRutc3za2pitP4uKPJenO3gvb+hSbG6ippt3y7Xqrt771VAcvJ1QwQrvHlJFS7xb57SrsI9vwji+dttBb7Gk0Y5QUtp4zPps0/4N3FqvqFrshllPlHmy2kGVeOcmTJ6qyow8tfc+p+L19jlVsNL7scKl3u+jXbl9TBLWcTSen7baniXt74W0ldlM5CmXWuxG1fozzPhktTe0WqtJwfNkjU+dffLUPdj4VN/BONd8Pu6CSmN8KvdufVbok6d4VONTym7tlrY+K2Pc8s2Tea7Y42NOCDqmZKBVoe/YFLRVYXsjS2UdzE3UlHmvy8ySMTbFfE4Na2yystSuwmdsWm5sP+29DXNskt3CMJ2KMEutWVTXen6bSBjbCJMna2yy2lJH+dupNODY5HNKWb+dir/3PqcLlvrkyVhujk3VRp7M/p6ZyZPdYjdENgNep3GnBAAAAAAAcIJJCQAAAAAA4ASTEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACcy1n0jcJcNv2roRjV7q4KsuVxSrJ1RKbbQu4pyspN3BdnqHoXmNlZs5r39lf28q6UWdKvyXN7Q4FORfL73ftXP9f6IO6W837ckFdYZnTEarOXeVWqtCuaNDxpVXK2OHX7nQ8qqqO9d2TZUBdksE7hbgM/zzQrLYfKU793tJV3kfb6ZedrIzlNlX+/tr+obLE/1dfbXX2Kh9/ZL5livsfe3MOl9HibqvXNj5snKTOOD3svD5Ml4SaQVmXNFlBXRg45bCpGnEu/zsLqnT542t8Yn7/OwyMhTXa33vkpSbIH39jsaeYql7f1t1xBRnvzGJ5/OUZ58xyfvfLTWPEU5NtmvMbLk08kmluf9eZtZMroCVBvdaiSfLPUPmCWfsSlmXOt1/DrE2FRvZCnotZ4xxkmyPytrzPIb53K8YU0Ykf52skQ5NkX426myT8CxqXvwaz0tMH47FRu/nfzyFPS3U733NkLlKcLfTi3eOc0Hd0oAAAAAAAAnmJQAAAAAAABOMCkBAAAAAACcYFICAAAAAAA4waQEAAAAAABwIlz3jSgrkkcoFjOqjOb5vE2jkmm6nXcF2Yb23hVnq7vax2TlFt5VUXcb9Knn8l+Wve+5fEFdV3Mb9xcP91xes7qL5/KipfYxyV/h/R5jVd6VcM3uDVFWAfarhu6wUmwkosxThOsy85Tw2UaBUYHfWF7fwchTmU+ejMrLuw74wnP5sRtN8Vw+t66buY37S0Z4Lq+qKvVcXrjcrlJdsNw7a3GjGryZp/p6cxvWZ5UOkyfrHMqVnGVifArRHcrMk7VcsscuI08NJd7jlt/4tGpz73Nh951mey4/pttUz+Vz68rMbdzdfg/P5VVV3uNT4TJ7f/MrjTytMo57iPHJek06aFeOXOf6Ws/4HGLWGBQiS+a1XnF0Y5OVpSPKpnsuX1BvX+v9uXg3z+VV1d5Zauc3NllZWm0cd+v4hrnWCyPXx6YMMD8jKfjY5HetF3BsShZ5P993bDJ+O+0+0DtPR3Wb5rn8i9oe5jYeKRnqubxqtfd4VrTUzlN+ZY79dspC2Tm7AAAAAAAAWj0mJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE4wKZGlYvVpDbh2oWL1ade7AuS8WH1a2/12MXkCIhCrT2ub335DnoANFKtPa4drF5ElIAJc6+U2JiWyVLepq9RvUrnKpq1yvStAzus6dbX6TlqqrtNWu94VIOd1nbpam09aqlLyBGyQsqmrtMWkCq71gAhwrZfbwrUEzQDftjZRtiWyWt4kvNeVLPB+fn2xve14aa3n8p1KFjZbtt0zi7T/nbOllSmlY9JuY+ZIJXE1jO+irw7/ztzGcyU7eC7/un1nz+Upv08+Q92dIkObqP8p0jz5tYmzWlPmeb8mle+9vKHQJ08dvFtjjujyZbNlWz/9jUbd8UVTnoadNa8pT5//cqm5jRc6be+5/PMi77ZrSaMTqiSlM9AuLZ02/lUg5TADfudJS2bTb90RtTjMWJ6M8cnKkzU+NRT5tL/sXOe5fFDH+c2Wbfv0Yu1352dNeRp61nypJK70hFJ9+ItKcxsvdvHO0ydFnT2Xp/L8jq+x3GqJZmXA5zM089RK2q5FIRbR95pvlgKvLHiWrGu9VIgsxTt6j01DOs5rtmybpxfrZ3d+3pSl4WPmSiVxJcd30Ye/WGZu49mOAzyXzyns7Lk8bXcwDM46/5EbMjE2Wb+d2nmfiMl2PvkvCZ+nta/1evmNTe2381w+p9i7La/vb6eg34lRfve5vNaLEN8wWWbOHt2U6pMv1acVS0uqTyu1eb5So4pd7xqQc+aO7EqegIh8PbJM2jxfqldTnrR5vrRPB9e7BuSUuSPLlO6zbpbSm+crPaq9610Dcs7ckWVc67UCTEpkmerSAiUv7izVS+nimFQvJcd1lrpGOd0NtA015AmITHVpgdLjujb+gFqTp/S4rlIZeQKCqC4tUOriLutkKTWuC2MTEAK/nVoHJiWyUPz1aqlHQg03lUk9Eoq/Ue16l4CcRZ6A6MRer5J6JpS+ubvUM6HYG1WudwnISbE1Y1Pypm5Sj4RijE1AaFzr5b6srSnRliXHdFby3M5SUVx1+xdLDa73CMhd5AmITnpsF+m8LlJRXOn925MnIKTUmM5KrRmbGhibgA3CtV7uY1IiG5WsdQNLETezABuEPAHRIU9ANMgSEB3ylPOydlLCrH6tiJtDWNtJei+P13tXOM2rtvc3Vd7Oc/kbFf09l3dKeN8OO7u6p7mNr5eUei4vWO59tPKq7Uqt1ns0q7talcdTPn2CrXWZy33WZVTbT/u9xourbgEZkLE8JY3jZGw/buQsr8be33RlgefyV8q39lxeGPOu4PxVTXdzG59/4/1Y/gojTzX2+ZGotfIRYZ6CykSeXGUmog4boflkLbJ1RTg+pZd658kanzob49Osql7mNj75ZiPP5VaeEnUhxqegHTCs7yo/EVY4D5ynLGPtf9CuHK3pWs8amyZXbOm5PD/m/U+5fmPT10u8uwIUVGbgWi/M9Zklwmu9nOF6bIpSwO9P61yL1/l83su925pZeYrHvLcxp7qbuYm55d6/nfKtPPlc68XrAl7rNRi3coT57RRGFuapFSUEAAAAAADkEiYlAAAAAACAE0xKAAAAAAAAJ5iUAAAAAAAATjApAQAAAAAAnMja7hu+rCrKVsVSvwqjDd7VUmP13lVR81Z7Ly9eYh/KhjkJz+UfpTb3XD6zU2/vFVV7r0eSCr/13n77xd7HpN1y744EkhSr9n4sVuu9PG12XAhe2dWvEneLy8JKtBkRNE8pnyr3xrpiNd7nTt5K7+VFFfa5XvKV92Mz67fwXP5Bp828V1Rnz8kWLfDOU8kC73OkcKmdp3hVnedy6zvGzJNfdwHjMad5asVCdQwIkydrfKoz8mSMT0UV9vhU8rWRp2TAPNX65GlxBvJkjU/GMYw0T1F2DMimcchvX1x2EghzrWd8r1rfw4mqEFn60shSrZGlLpt6r6jGHv+sLLVfFPxaL7Is+R73lh+bzE422ZSlDPEdm4zHrGuOWJ7P8Qt4rWflKcxvp5kN3nmaUeqdp7RPngoDjk3tfMYm87dTlNd6QYXojOOyMxR3SgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADjBpAQAAAAAAHAiXPcN1xWZU97bTxsVS2MNZj10pRPeVVljNbWey/Mqvd9fkbkFKd7Qzvs1S7zX1VBc4L1P3gVcJUntVnq/98Jy72qw+ctrzHXFV1d7P1BvVJ1tCFhZVoq2umxQ2VaROVvzZFVX9vns0sY5EjMq8+dVep9rRXZklaj1zkfREu8sNxTmey6P++SpwMpThZGnZUZmJMWqjKzVelc+t/PkkxnjMwxTeTmwbMtTCFa16ZhdtDv4NqzxyRiDJCltdNmI5XsP3WHyFK8LOD5lIk9Lq8x1mXkKOj75Vf8PmifXGWitXXaszg1x73MzZnzWks/YVGONTca1XqRZ8h7LwmSpqNx7PMkLMTal64KOTT7nv5Uli+sstWbWZxEzTmqfzzVtXL/EEtFd68XrA+apyPjt5HPpVFhpjU3B82T+drKu9eq9l/te6wXtZhNlnjKQTe6UAAAAAAAATjApAQAAAAAAnGBSAgAAAAAAOMGkBAAAAAAAcIJJCQAAAAAA4ASTEm1MIpXU2M+fVSLtsPsF0Ao0ZSlFloANRZ6A6CRSSY354jmu9YAN1JQlxqYWF64laAhmy7W41XrLni9JGw/FjJYofu2KzBZStd59aqzuNXkN9smaqPJu+9LOaP2puLEVn/Z+8Trv9xH/ybYHrvpahy+aounJXppRvJn3yqqNNlFGS620dQz9Wkda7WtCtFyzzq02yTpOYfJktR7y2XzMaGFovSZcnrzbRLWr8P46S1t58nkjZp6qf3x/TVnK66MZ8Z72yoz2wlZLrUjzZL7AcZ5asoVhlC12w+RJAVt/hmiPnDa+o2PGWJfnMwYmVnufh4XfG3nKN95HmPEpRJ6s9y7ruycTefLB+LRGlo5NVjvEmPG55dXb/ToTVd7bKCyPcGyqMbJUY1zrNfTUjCLva720MTaZrT+tLFnteBXiWs+HmaVI2x624rEp6G8nnxa71rWbdU6Fu9YLmCejHanv2GTlqerH9zFw9ZosxTfTjITP2GTlyRqbrHHZ5xzMuTwFlLFJCbg1atmHOmnJ6ypO1Skt6Yrv/qGqeDtN6jJCL3fc3vXuATlj1LKZOun7tbK04ElVxQo0qctwvVxCloAgyBMQnWbXet8/q6p4gSZ1HqGXS7ZzvXtAzhi1/EOdVP7Gj1la9JSqYvlkqQXx5xttxLsl/bS4oIvy0knFJOWlU1qU31nvtu/reteAnNI8S8nGLBWTJSAo8gREx/NaL6+L3i3e3PWuATnl3Q79tDj/J2MTWWpRTEq0EZV5xXq42x7KSydVHctXnpL6S5cRqkwUu941IKdU5rXXw91H/pildFJ/6TycLAEhkCcgOt7XeruSJyCgxiztvu7YRJZaFJMSbcig1V+rIq9Et298gCoSHTSweq7rXQJy0qBVcxqz1Ovnqsgr0cDqea53CchZ5AmITvNrPfIEhNGUpZ4HMDZlADUl2pC/dx2mv5UNV108X1Py+yhP7oqZALns72W76m/dRqgunq+3S7ZUflWV610CchZ5AqKzzrVeYjPlGcV3Afj7e+kw/a1rY5be7tBf+TXVrnepVcvNSQmrYmgs+I/stHfhcXsbRjVas7KzpFi1d0XW+AqjirlRDdq3KrD12FqVbRujlFRM9aqtb1DtWkvXEVEV87RfVfmMVFHOkYrMIdjdbKwaxz6izJOx3KzUbJwjMaMzheSTp7wI82RVhF6TgR9SE1O16iXVNaTkmSVJqje6bFiVl608+e1vwDyF6gjgsCJzTgmYJ78K59Y5GjhPPtXxY1X5nsvj+cblQZjvQitPqcZj8mOeahvzVBciT1ZXBLMrV3Tjk2+e2lhuAo9NfsfH6CRgdrjx2y/zAWP71rWeX5ZqvM/NuNUVIG4s34CxSVo7TzWqra9fc63nMdFnddkImiXXY1MrFmmeZHVOivBaz/pco7zWy0Se1uR87Sw1Xusl5ZklSTKu6dJ1xnvM1ms9qxNMmLEs4PUCf74BAAAAAACcYFICAAAAAAA4waQEAAAAAABwgkkJAAAAAADgBJMSAAAAAADACf/uG1bVTKuavWRX5zSqedqVZUNUg00b++VTZTtmVJ01K8smvbfhW0E9EbArQBjWZ2VVXvU5JmZV8qCVYiOsSJ6R6uYt3WEj1/JknSI+x8nMk1Xd2aqW7Jcnn+rn3jsVImfWezQ7zfhVkI+oy0aIDDitZJ5lHWskkScvVvVzq8J5GORpw2VbniLLUojxL2BXDsknS0nvdcWM/fW91rPGJmsMClPl3sqG2fWALDXfeJZlScpMnqxz2vrFE2psMn7vmN3GfM7PqPKUirDTUlvIU9DfVBHmiTslAAAAAACAE0xKAAAAAAAAJ5iUAAAAAAAATjApAQAAAAAAnGBSAgAAAAAAOOHffSNKEVWW9ROzKi9bFVklpa2H6oyK5FbVV6vquSTFjGrN1musCq5hmNVd7W2EqgjrtR6fDh+BRdVhQ8rOysstzC9PZrXmgJXPJZ88GRXLY0ZnGt9zx8qTJUzOgp4jGciTXwYCf1+2hjyF6WZjriu68SkTeYoF7ZBkdBhoXFnA40WeAq0rJ+Raliw+6zKzZHURsK4Bo7zWs4S5BnR4rZe1WWJs+slLAh5bv7HJ6NhhvkNzbPK71gvxe8tLtuYpxLne2vPEnRIAAAAAAMAJJiUAAAAAAIATTEoAAAAAAAAnmJQAAAAAAABOMCkBAAAAAACcYFICAAAAAAA4kbmWoJaA7W78V2W0qPFrgxOwa2Xa2q9sbTMZorWq0/ZmOda+xpmgx8mvLW7AcyRUnsz2VVYLtRCtszIhA3kK0w45qm3jJ0KMT5nIkzkOWXLtu9DvGLaWPOXaZ7KhIsxS4NaGElny0lqyhPUS6dhkbSPgbyolfbZhXAfGjFahZkvOMLjWc4I7JQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJxgUgIAAAAAADgRrvtGmAqnRrVUexs+lUQDVksOU+E0ZlX/t/YraMXZLBZZRdhMVYPNtWrYP9Um8hTwXMhEnvzed4TnLnnKML/9D5obcxshPguzA02Y4+0dEHPcYnzyWlE06/mf2zH21zoXsyl/WZqldCq6f0/LyrEpQpFW+Lc30vLb8N1+FmXGT5R5inAMsjeRgWs9v31KeocteMecLLye899Iy2/Dd/vu8sSdEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE4wKQEAAAAAAJwI130jjKAVqH3XFWF1V3MTOVLNN5NcVoTNlerKuSgDn2vaqlgeIpvRyVAZddeVlL201TxFOQ4F3naE50GknTxauUzkL0yeWmsGM5Ex591vWrlszUxrlq25CbyJoNd0Ya7Dcq4FjsNt51bOuFMCAAAAAAA4waQEAAAAAABwgkkJAAAAAADgBJMSAAAAAADACSYlAAAAAACAE0xKAAAAAAAAJzLXEtSlbGzJFzWrtWKuvfcca1/jTNDjlImWh2FE2Not5871KJGbDZNreWrL57pL5OxHQY+Fy3a8ktvMBB2z/FplB32N6+8KMrNhGJuai/Jcz9bcWFp5nrhTAgAAAAAAOMGkBAAAAAAAcIJJCQAAAAAA4ASTEgAAAAAAwAkmJQAAAAAAgBPuu29EWUnUqjrrtw3XlWqjkolKsa286murlomcZUq2VkW2BK06T86yX2vKU2tHnrJbmOsz1508ggo6ZoUZ46IcF8lM7grz2WVrbiyRnusOryfJWTPcKQEAAAAAAJxgUgIAAAAAADjBpAQAAAAAAHCCSQkAAAAAAOAEkxIAAAAAAMAJ9903ohSmkmlU1U/DVK+Nsip/lFWqqQgLP6475mTjNsJwvX1kB9fnQdCxK8oxJVuziewQ9DzI1vPG5fUZ13r4X7K1mxTjRpvDnRIAAAAAAMAJJiUAAAAAAIATTEoAAAAAAAAnmJQAAAAAAABOMCkBAAAAAACcaF3dN1yKsuprJrqIUKUW2SAT5yHnOmCLKh8uu18B2czl9RkZQyZxTYcNwJ0SAAAAAADACSYlAAAAAACAE0xKAAAAAAAAJ5iUAAAAAAAATjApAQAAAAAAnGBSAgAAAAAAOMGkBAAAAAAAcIJJCQAAAAAA4ASTEgAAAAAAwAkmJQAAAAAAgBNMSgAAAAAAACeYlAAAAAAAAE7E0um0630AAAAAAABtEHdKAAAAAAAAJ5iUAAAAAAAATjApAQAAAAAAnGBSAgAAAAAAOMGkBAAAAAAAcIJJCQAAAAAA4MT/B7Qa6kKPW6KQAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1080x432 with 10 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "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,\n",
+    "      image_center=[pix_coord[0][0], pix_coord[1][0]]\n",
+    ")"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -9,8 +439,22 @@
   }
  ],
  "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
   "language_info": {
-   "name": "python"
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
   }
  },
  "nbformat": 4,

From 6e309c0b5a0fa67969728765fe9e1df89d7336a9 Mon Sep 17 00:00:00 2001
From: narayan <nkhadka@ksu.edu>
Date: Mon, 18 Nov 2024 20:15:31 -0500
Subject: [PATCH 9/9] added a notebook to show supernova injection to opsim
 data.

---
 .../supernovae_injection_to_opsim_data.ipynb  | 242 ++++++++----------
 1 file changed, 109 insertions(+), 133 deletions(-)

diff --git a/notebooks/supernovae_injection_to_opsim_data.ipynb b/notebooks/supernovae_injection_to_opsim_data.ipynb
index 0ee71984f..d96cf771d 100644
--- a/notebooks/supernovae_injection_to_opsim_data.ipynb
+++ b/notebooks/supernovae_injection_to_opsim_data.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -10,21 +10,18 @@
     "from astropy.units import Quantity\n",
     "from slsim.lens_pop import LensPop\n",
     "import numpy as np\n",
-    "from astropy.table import Table\n",
     "from astropy.units import Quantity\n",
     "import slsim.Sources as sources\n",
     "import slsim.Deflectors as deflectors\n",
     "import slsim.Pipelines as pipelines\n",
-    "from slsim.Sources.point_sources import PointSources\n",
-    "from slsim.Sources.QuasarCatalog.quasar_pop import QuasarRate\n",
-    "import corner\n",
     "import matplotlib.pyplot as plt\n",
-    "from astropy.table import Table\n",
-    "from slsim.Sources.source import Source\n",
     "from slsim.image_simulation import point_source_coordinate_properties\n",
-    "from slsim.image_simulation import lens_image_series, rgb_image_from_image_list\n",
     "from slsim.Plots.plot_functions import create_image_montage_from_image_list\n",
-    "import math"
+    "import astropy.coordinates as coord\n",
+    "import astropy.units as u\n",
+    "from slsim.LsstSciencePipeline import opsim_pipeline\n",
+    "from slsim.LsstSciencePipeline.util_lsst import opsim_variable_lens_injection\n",
+    "from slsim.Plots.plot_functions import create_image_montage_from_image_list"
    ]
   },
   {
@@ -58,14 +55,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "cosmo = FlatLambdaCDM(H0=70, Om0=0.3)\n",
-    "deflector_sky_area = Quantity(value=2, unit=\"deg2\")\n",
+    "deflector_sky_area = Quantity(value=1, unit=\"deg2\")\n",
     "source_sky_area = Quantity(value=5, unit=\"deg2\")\n",
-    "sky_area = Quantity(value=2000, unit=\"deg2\")\n",
+    "sky_area = Quantity(value=1, unit=\"deg2\")\n",
+    "sky_area_full = Quantity(value=2000, unit=\"deg2\")\n",
     "\n",
     "kwargs_deflector_cut = {\"band\": \"g\", \"band_max\": 24, \"z_min\": 0.01, \"z_max\": 2.5}\n",
     "kwargs_source_cut = {\"z_min\": 0.1, \"z_max\": 5.0}\n",
@@ -115,9 +113,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/narayankhadka/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/narayankhadka/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/narayankhadka/slsim/slsim/Sources/Supernovae/supernovae_pop.py:95: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n",
+      "  numerator = integrate.quad(\n"
+     ]
+    }
+   ],
    "source": [
     "supernovae_catalog = sources.SupernovaeCatalog.SupernovaeCatalog(\n",
     "    sn_type=\"Ia\",\n",
@@ -137,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -158,7 +176,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -166,7 +184,7 @@
     "supernova_lens_pop = LensPop(\n",
     "    deflector_population=lens_galaxies,\n",
     "    source_population=supernovae_sourece,\n",
-    "    sky_area=sky_area,\n",
+    "    sky_area=sky_area_full,\n",
     "    cosmo=cosmo\n",
     ")"
    ]
@@ -180,7 +198,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -201,63 +219,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "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[0]"
+    "lens_class = supernovae_lens_population[51]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 57,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/narayankhadka/slsim/slsim/Sources/supernovae.py:109: UserWarning: bandpass 'lsstg' [3866, .., 5670] outside spectral range [4231.25, .., 42312.5]\n",
-      "Ignoring bandpass for now. Use extended wavelength SN models found here: https://github.com/LSST-strong-lensing/data_public/tree/main/sncosmo_sn_models\n",
-      "  warn(\n",
-      "/opt/anaconda3/lib/python3.9/site-packages/sncosmo/models.py:189: RuntimeWarning: divide by zero encountered in log10\n",
-      "  result[i] = -2.5 * np.log10(f / zpf)\n"
-     ]
-    }
-   ],
+   "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",
+    "    num_pix=63,\n",
     "    transform_pix2angle=np.array([[0.2, 0], [0, 0.2]]),\n",
     ")[\"image_pix\"]"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[array([[18.28767419, 11.13214571]]), array([[14.84482128, 15.23258164]])]"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "pix_coord"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -267,7 +253,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -276,7 +262,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -285,20 +271,18 @@
        "(-22.0, 100.0)"
       ]
      },
-     "execution_count": 30,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -315,118 +299,110 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Set observation time and image configuration"
+    "## Get observation properties from OpSim"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 31,
+   "cell_type": "raw",
    "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"
+    "Generate random points on the sky"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 29,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "## Simulate Image"
+    "#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",
+    "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": 32,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading from database sqlite:////Users/narayankhadka/downloads/baseline_v3.4_10yrs.db\n",
+      "Read N = 2146797 observations in 31.70 seconds.\n",
+      "No host file.\n",
+      "Coordinate (-29.610298340248505 deg, 15.139325286485471 deg) is not in the LSST footprint. This entry is skipped.\n",
+      "Coordinate (-148.54533161882097 deg, 77.27652525868886 deg) is not in the LSST footprint. This entry is skipped.\n",
+      "Coordinate (-154.53996614062493 deg, 61.26860785418272 deg) is not in the LSST footprint. This entry is skipped.\n",
+      "Coordinate (-106.79085603571352 deg, 27.918324749459078 deg) is not in the LSST footprint. This entry is skipped.\n",
+      "Coordinate (-82.67094082370238 deg, 32.545704814609024 deg) is not in the LSST footprint. This entry is skipped.\n"
+     ]
+    }
+   ],
    "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",
+    "# opsim_path is a path for opsim summary data. One need to download baseline_v3.4_10yrs.db \n",
+    "# to run this pipeline. Please download this data from and replace opsim_path with your path: \n",
+    "# https://epyc.astro.washington.edu/~lynnej/opsim_downloads/fbs_3.4/initial/initial_v3.4_10yrs.db\n",
+    "exposure_data = opsim_pipeline.opsim_time_series_images_data(\n",
+    "    ra_points,\n",
+    "    dec_points,\n",
+    "    \"baseline_v3.0_10yrs\",\n",
+    "    print_warning=True,\n",
+    "    num_pix=63,\n",
+    "    opsim_path=\"/Users/narayankhadka/downloads/baseline_v3.4_10yrs.db\"\n",
     ")"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 33,
+   "cell_type": "markdown",
    "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]))"
+    "## Inject selected lens to a prepared time series data "
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 60,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "## Visualize simulated images"
+    "#There are multiple time series datasets, so I chose the first one.\n",
+    "index = 0\n",
+    "bands = [\"i\"]\n",
+    "num_pix = 63\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",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 64,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 1080x432 with 10 Axes>"
+       "<Figure size 1500x600 with 10 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
+    "## Plot first 10 images. One can plot any number of images\n",
     "plot_montage = create_image_montage_from_image_list(\n",
-    "    num_rows=2, num_cols=5, images=image_lens_series, time=time,\n",
-    "      image_center=[pix_coord[0][0], pix_coord[1][0]]\n",
+    "    num_rows=2, num_cols=5, images=images[\"injected_lens\"][:10], image_center=[pix_coord[0][0], pix_coord[1][0]],\n",
+    "    time=images[\"obs_time\"][:10]\n",
     ")"
    ]
   },
@@ -458,5 +434,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }