diff --git a/.gitignore b/.gitignore index e1c2577..5008f39 100644 --- a/.gitignore +++ b/.gitignore @@ -145,3 +145,6 @@ tmp/ _results/ _html/ .hypothesis + +# Dev files +*.fits \ No newline at end of file diff --git a/README.md b/README.md index 4869bf5..0614fec 100644 --- a/README.md +++ b/README.md @@ -1,71 +1,113 @@ # BATSim -BATSim is designed to enable the application of non-affine shear -transformations to GalSim images. It works by trasnforming the stamp pixel -grid, distorting the location of the pixel centers. When a GalSim image is -sampled onto this distorted grid, the resulting image will be sheared due to -the transformation of the pixel grid. +BATSim renders GalSim surface-brightness profiles on coordinate grids that can +be transformed before sampling. This makes it possible to apply non-affine shear +fields, such as intrinsic alignment and flexion, while keeping the rendering +pipeline close to GalSim's image conventions. + +The current renderer samples profiles on a supersampled grid, optionally applies +sub-pixel block integration, and performs PSF and pixel convolution in Fourier +space. The default render path uses: + +- `psf_mode="kvalue"` for analytic PSF Fourier sampling through BATSim's C++ layer +- `force_input_flux=True` to preserve the input galaxy flux after convolution +- `use_true_center=True` to match GalSim's true-image-center convention +- `integration_order=2` for Gauss-Legendre block integration +- `compensate_integration="quadrature"` to remove the matching Gauss-Legendre + transfer function; pass `"exact_sinc"` for ideal top-hat compensation or + `None` to disable compensation +- `backend="np"` by default, with optional CuPy support for FFT-heavy steps + +## Quickstart + +```python +import galsim +import batsim + +galaxy = galsim.Sersic(n=1.0, half_light_radius=0.7, flux=1.0) +psf = galsim.Gaussian(fwhm=0.7) +transform = batsim.IaTransform(scale=0.2, hlr=0.7, A=0.02) + +image = batsim.simulate_galaxy( + galaxy, + scale=0.2, + ngrid=64, + transform_obj=transform, + psf_obj=psf, +) +``` + +`simulate_galaxy` returns a NumPy array. NumPy is used by default; pass +`backend="cp"` to request CuPy for FFT-heavy steps. + +## Public API -Non-affine transforms can simualate complex shear effects such as intrinsic -alignment, flexion, and optical field distrotion maps. Custom transform -functions can also be passed to Stamp objects. +The stable top-level API is: -## Building and installing BATSim from source (Conda + GalSim C++) +- `batsim.simulate_galaxy` +- `batsim.clear_backend_memory` +- `batsim.Stamp` +- `batsim.Transform` base class for custom coordinate transforms +- `batsim.LensTransform` and `batsim.AffineLensingTransform` +- `batsim.IaTransform` and `batsim.IATransform` +- `batsim.FlexionTransform` +- `batsim.experimental` for non-stable helpers such as SIP WCS parsing -The package is not currently available on PyPI and only installable on Linux while in early development. We suggest using conda/mamba to build the package and install its dependencies. This is because the primary dependency, Galsim, does not ship a pre-built C++ library via pip. +`batsim.pltutil` remains available for legacy plotting utilities used by older +examples and validation notebooks. -The below instructions will work with pure conda, but we recommend using mamba to make the installation of dependencies much quicker. +## Building and Installing BATSim from Source -First, make sure to clone and switch to the repository root: +BATSim currently expects GalSim's C++ shared library to be available at build +time. The recommended route is to use conda or mamba with dependencies from +conda-forge. + +First, clone the repository and switch to the repository root: ```bash git clone https://github.com/CMacM/BATSim.git cd BATSim ``` -## Regular Install (not editable) +### Regular Install + +Create and activate a build environment: -### 1. Create build environment and activate ```bash mamba create -n batsim -c conda-forge -c defaults python=3.10 conda-build boa mamba activate batsim ``` -### 2. Build the package -From the repository root: +Build the package: + ```bash -# mambabuild is sometimes only recognised as a conda command conda mambabuild --override-channels -c conda-forge -c defaults conda/recipe ``` -This will: -- Create an isolated environment to build and run batsim -- Install all required dependencies -- Compile the BATSim C++ extension and link it to Galsim's C++ API -- Produce a conda package in: +This creates an isolated build environment, installs dependencies, compiles the +BATSim C++ extension, links it to GalSim's C++ API, and produces a conda package +under: + ```bash $CONDA_PREFIX/conda-bld/linux-64/ ``` -### 3. Install the built package -Install the locally built package into the new environment: +Install the built package: + ```bash mamba install -c local batsim ``` -If this fails, install directly from the build artifact: +If needed, install directly from the build artifact: + ```bash mamba install $CONDA_PREFIX/conda-bld/linux-64/batsim-*.tar.bz2 ``` -## Development Installation (Editable) - -For development you can install BATSim in editable mode so that Python changes -take effect immediately without reinstalling. +### Development Install -### 1. Create a development environment and activate - -Note: You may encounter issues if some of these packages are already installed locally and have different builds. To fix, remove them and ensure they are installed through conda-forge. +For development, install BATSim in editable mode so Python changes take effect +without reinstalling: ```bash mamba create -n batsim-dev -c conda-forge -c defaults \ @@ -78,26 +120,44 @@ mamba create -n batsim-dev -c conda-forge -c defaults \ astropy \ matplotlib mamba activate batsim-dev +pip install -e . ``` -### 2. Install BATSim in editable mode +Verify the installation: ```bash -pip install -e . +python -c "import batsim; import batsim._gsinterface; print('BATSim installed successfully')" +``` + +## Running Benchmarks + +BATSim uses ASV for performance benchmarks. Install the optional benchmark extra +into a working BATSim development environment: + +```bash +pip install -e ".[benchmark]" ``` -After following either of the above installation routes, with the conda environment active, verify the installation: +Then run discovery and a quick smoke benchmark: ```bash -python -c "import batsim; import batsim._gsinterface; print('BATSim installed successfully')" +cd benchmarks +asv check +asv run --quick --show-stderr ``` -## Pip only installation +The default benchmark suite uses deterministic analytic GalSim profiles and +CPU-backed NumPy renders. Optional CuPy benchmarks skip automatically when a +working CUDA runtime is not available. -We currently do not provide a pip only installation route as Galsim requires the shared C++ library to be built and linked manually when installed via pip. If you wish to build via pip only, you will need to install all dependencies and build and link the Galsim C++ headers. You can find details on how to do this [here][https://galsim-developers.github.io/GalSim/_build/html/install_pip.html]. You may then need to update your LD\_LIBRARY\_PATH, LIBRARY\_PATH, and CPLUS\_INCLUDE\_PATH to point to build and include folders for the GalSim C++ shared library. +## Pip-Only Installation -We plan to add a pure pip installation route in future. +A pure pip installation route is not currently provided because BATSim links +against GalSim's shared C++ library. If you build GalSim's C++ library manually, +set `GALSIM_LIB_DIR` and `GALSIM_INCLUDE_DIR` before installing BATSim. GalSim's +pip build notes are available in the +[GalSim documentation](https://galsim-developers.github.io/GalSim/_build/html/install_pip.html). ![BATSim Logo](./image/batsim_logo.png) -(repo icon created using images by Frepik and brgfx on Freepik) +Repository icon created using images by Frepik and brgfx on Freepik. diff --git a/benchmarks/asv.conf.json b/benchmarks/asv.conf.json index 07151fb..e4f4934 100644 --- a/benchmarks/asv.conf.json +++ b/benchmarks/asv.conf.json @@ -5,28 +5,14 @@ "branches": [ "HEAD" ], - "build_command": [ - "python -m build --wheel -o {build_cache_dir} {build_dir}" - ], "dvcs": "git", - "environment_type": "virtualenv", - "show_commit_url": "Change this value according to the instructions on RTD", + "environment_type": "existing", "pythons": [ "3.10" ], - "matrix": { - "Cython": [], - "build": [], - "packaging": [] - }, "benchmark_dir": ".", "env_dir": "env", "results_dir": "_results", "html_dir": "_html", - "build_cache_size": 8, - "benchmarks": { - "name": "time_shear_speed", - "params": [], - "number": 1 - } + "build_cache_size": 8 } diff --git a/benchmarks/benchmarks.py b/benchmarks/benchmarks.py deleted file mode 100644 index b736b46..0000000 --- a/benchmarks/benchmarks.py +++ /dev/null @@ -1,211 +0,0 @@ -"""Benchmarks to check computation time and memory usage for batsim.""" -import batsim.stamp as batstamp -import batsim.transforms as batforms -import batsim -import contextlib -import galsim -import io -import numpy as np -import time - -def time_shear_speed(nn=64, scale=0.2): - - # create galaxy - gal = galsim.Sersic(n=1.5, half_light_radius=1.5, flux=40) - - # start timing for batsim - start = time.time() - - # generate stamp, shear and sample - gal_stamp = batstamp.Stamp(nn=nn, scale=scale, centering='galsim') - lens = batforms.LensTransform(gamma1=0.2, gamma2=0, kappa=0, - center=[-0.5*0.2, -0.5*0.2]) - gal_stamp.transform_grids(lens) - bat_array = gal_stamp.sample_galaxy(gal) - - end = time.time() - - bat_time = end-start - - # start timing for galsim - start = time.time() - - gal_shear = gal.shear(g1=0.2) - gal_array = gal_shear.drawImage(nx=nn, ny=nn, scale=scale).array - - end = time.time() - - gal_time = end-start - - return {'batsim time': bat_time, 'galsim time' : gal_time} - -def time_ia_speed(nn=128, scale=0.1): - ''' - Times the time taken to apply an IA shear to a 128x128 pixel - image and compares it with the time required to apply an - affine shear. - ''' - # initialise a galaxy object - gal = galsim.Sersic(n=1.5, half_light_radius=1.5, flux=40) - - # start timing for ia transform - ia_start = time.time() - - # crete stamp, apply transform, and sample gal obj - ia_stamp = batstamp.Stamp(nn=nn, scale=scale) - ia = batforms.IaTransform(scale=scale, hlr=1.5, phi=0.2) - ia_stamp.transform_grids(ia) - ia_gal = ia_stamp.sample_galaxy(gal) - - # stop timing - ia_end = time.time() - ia_time = ia_end - ia_start - - # get equivalent shear at hlr to pass to lens transform - g1, g2 = ia.get_g1g2(1.5,0) - - # start timing for lens - aff_start = time.time() - - # crete stamp, apply transform, and sample gal obj - lens_stamp = batstamp.Stamp(nn=nn, scale=scale) - lens = batforms.LensTransform(gamma1=g1, gamma2=g2, kappa=0) - lens_stamp.transform_grids(lens) - lens_gal = lens_stamp.sample_galaxy(gal) - - # stop timing - aff_end = time.time() - aff_time = aff_end - aff_start - - return {'IA time' : ia_time, 'Lens time' : aff_time} - - -def _parse_simulate_profile_logs(log_lines): - stats = {} - timings = {} - for line in log_lines: - msg = line.split("] ", 1)[-1] - if msg.startswith("stats "): - for token in msg[6:].split(): - if "=" not in token: - continue - key, value = token.split("=", 1) - try: - stats[key] = int(value) - except ValueError: - try: - stats[key] = float(value) - except ValueError: - stats[key] = value - elif "=" in msg: - key, value = msg.split("=", 1) - value = value[:-1] if value.endswith("s") else value - try: - timings[key] = float(value) - except ValueError: - timings[key] = value - return {"timings": timings, "stats": stats} - - -def _extract_parametric_profile_info(cosmos_catalog, catalog_index, gal_obj): - info = { - "catalog_index": int(catalog_index), - "gsobject_type": type(gal_obj).__name__, - } - for attr in ("flux", "nyquist_scale"): - if hasattr(gal_obj, attr): - try: - info[attr] = float(getattr(gal_obj, attr)) - except Exception: - pass - param_cat = getattr(cosmos_catalog, "param_cat", None) - if param_cat is None: - return info - keys = [] - if hasattr(param_cat, "colnames"): - keys = ["mag_auto", "flux_radius", "zphot"] + [k for k in ("use_bulgefit", "viable_sersic") if k in param_cat.colnames] - elif hasattr(param_cat, "dtype") and param_cat.dtype.names: - keys = [k for k in ("mag_auto", "flux_radius", "zphot", "use_bulgefit", "viable_sersic") if k in param_cat.dtype.names] - if not keys: - return info - row = param_cat[int(catalog_index)] - for key in keys: - try: - value = row[key] - if hasattr(value, "item"): - value = value.item() - info[key] = value - except Exception: - pass - return info - - -def benchmark_parametric_cosmos_profiles( - n_galaxies=5, - ngrid=128, - pix_scale=0.2, - psf_obj=None, - draw_method="auto", - truncate_ratio=1.0, - maximum_num_grids=4096, - force_ngrid=False, - seed=1234, - cosmos_catalog=None, -): - """Run a lightweight per-galaxy benchmark using parametric COSMOS profiles. - - Returns a list of dictionaries containing profile metadata, parsed - `simulate_galaxy(profile=True)` logs, and end-to-end elapsed time. - """ - cosmos_catalog = cosmos_catalog or galsim.COSMOSCatalog() - rng = np.random.RandomState(seed) - indices = rng.choice(len(cosmos_catalog), size=n_galaxies, replace=(n_galaxies > len(cosmos_catalog))) - - records = [] - for i, idx in enumerate(indices): - gal = cosmos_catalog.makeGalaxy(index=int(idx), gal_type="parametric") - profile_info = _extract_parametric_profile_info(cosmos_catalog, idx, gal) - - log_buf = io.StringIO() - t0 = time.perf_counter() - with contextlib.redirect_stdout(log_buf): - image = batsim.simulate_galaxy( - ngrid=ngrid, - pix_scale=pix_scale, - gal_obj=gal, - psf_obj=psf_obj, - truncate_ratio=truncate_ratio, - maximum_num_grids=maximum_num_grids, - draw_method=draw_method, - force_ngrid=force_ngrid, - profile=True, - ) - elapsed_s = time.perf_counter() - t0 - - profile_logs = [line for line in log_buf.getvalue().splitlines() if line.startswith("[simulate_galaxy]")] - parsed_logs = _parse_simulate_profile_logs(profile_logs) - record = { - "galaxy_number": i, - "profile": profile_info, - "logger": parsed_logs, - "elapsed_s": elapsed_s, - "image_shape": tuple(image.shape), - "image_sum": float(np.sum(image)), - } - records.append(record) - - print( - f"[benchmark_parametric_cosmos_profiles] i={i} idx={int(idx)} " - f"nn={parsed_logs['stats'].get('nn')} downsample_ratio={parsed_logs['stats'].get('downsample_ratio')} " - f"elapsed_s={elapsed_s:.4e}" - ) - print(f"[benchmark_parametric_cosmos_profiles] profile={profile_info}") - for line in profile_logs: - print(line) - return records - -if __name__ == "__main__": - time_shear_speed() - time_ia_speed() - - diff --git a/benchmarks/debug_benchmrks.ipynb b/benchmarks/debug_benchmrks.ipynb deleted file mode 100644 index 6e8f7ec..0000000 --- a/benchmarks/debug_benchmrks.ipynb +++ /dev/null @@ -1,84 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 54, - "id": "e316effe-2ff9-45ca-9963-018840d72c0a", - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "%reload_ext autoreload\n", - "%autoreload 2\n", - "import sys\n", - "\n", - "sys.path.append('home.b7009348/Documents/BATSim_Work/BATSim/src')\n", - "\n", - "import benchmarks" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "id": "bed7a323-ba64-4f78-a843-379d028702c9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'batsim time': 0.059325456619262695, 'galsim time': 0.02140974998474121}" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "benchmarks.time_shear_speed(nn=128, scale=0.02)" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "id": "567e7f6d-9368-442a-a6b7-79a9416c78fa", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'IA time': 0.06277155876159668, 'Lens time': 0.060240745544433594}" - ] - }, - "execution_count": 61, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "benchmarks.time_ia_speed()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:galsim]", - "language": "python", - "name": "conda-env-galsim-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.11.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/benchmarks/peakmem_render.py b/benchmarks/peakmem_render.py new file mode 100644 index 0000000..1a2fc40 --- /dev/null +++ b/benchmarks/peakmem_render.py @@ -0,0 +1,76 @@ +"""Peak-memory benchmarks for representative CPU renders.""" + +import batsim + +try: + from benchmarks import utils +except ImportError: + import utils + + +class PeakMemRenderSize: + """Track memory growth for medium and large renders.""" + + params = [128, 256] + param_names = ["ngrid"] + timeout = 180 + + def setup(self, ngrid): + self.kwargs = utils.render_kwargs( + gal_obj=utils.sersic_galaxy(), + ngrid=ngrid, + psf_obj=utils.gaussian_psf(), + backend="np", + ) + + def teardown(self, ngrid): + utils.cleanup_backend("np") + + def peakmem_render_size(self, ngrid): + batsim.simulate_galaxy(**self.kwargs) + + +class PeakMemPsfPath: + """Compare memory for PSF-convolved and no-PSF render paths.""" + + params = [False, True] + param_names = ["with_psf"] + timeout = 180 + + def setup(self, with_psf): + self.kwargs = utils.render_kwargs( + gal_obj=utils.sersic_galaxy(), + ngrid=128, + psf_obj=utils.gaussian_psf() if with_psf else None, + draw_method="auto", + backend="np", + ) + + def teardown(self, with_psf): + utils.cleanup_backend("np") + + def peakmem_render_psf_path(self, with_psf): + batsim.simulate_galaxy(**self.kwargs) + + +class PeakMemIntegrationOrder: + """Compare memory for low and high block-integration order.""" + + params = [1, 4] + param_names = ["integration_order"] + timeout = 180 + + def setup(self, integration_order): + self.kwargs = utils.render_kwargs( + gal_obj=utils.compact_sersic_galaxy(), + ngrid=128, + psf_obj=utils.gaussian_psf(), + integration_order=integration_order, + backend="np", + ) + + def teardown(self, integration_order): + utils.cleanup_backend("np") + + def peakmem_render_integration_order(self, integration_order): + batsim.simulate_galaxy(**self.kwargs) diff --git a/benchmarks/time_components.py b/benchmarks/time_components.py new file mode 100644 index 0000000..35f5a9b --- /dev/null +++ b/benchmarks/time_components.py @@ -0,0 +1,216 @@ +"""Component-level BATSim benchmarks.""" + +import numpy as np + +import batsim +from batsim.fft import ( + _apply_centering_phase, + _apply_pixel_response, + _compensate_block_integration, + _extract_centered_coarse_image, + _rfft_centered_image, +) +from batsim.sampling import _sample_galaxy_profile, _sample_psf_spectrum +from batsim.stamp import Stamp + +try: + from benchmarks import utils +except ImportError: + import utils + + +class TimeGridSizing: + """Benchmark supersampling and fine-grid decisions.""" + + params = ( + ["typical", "compact", "elliptical"], + [1, 2, 4], + ) + param_names = ["profile", "integration_order"] + + def setup(self, profile, integration_order): + if profile == "typical": + self.galaxy = utils.sersic_galaxy() + elif profile == "compact": + self.galaxy = utils.compact_sersic_galaxy() + elif profile == "elliptical": + self.galaxy = utils.elliptical_sersic_galaxy() + else: + raise ValueError(f"Unknown profile: {profile}") + + def time_grid_decision(self, profile, integration_order): + utils.grid_decision(self.galaxy, integration_order=integration_order) + + +class TimeStampConstruction: + """Benchmark coordinate stamp construction on NumPy.""" + + params = [256, 512, 1024] + param_names = ["nn"] + + def time_stamp_construction(self, nn): + Stamp(nn=nn, scale=utils.SCALE, backend=np, dtype=np.float64) + + +class TimeTransformApplication: + """Benchmark public transforms over flattened coordinate arrays.""" + + params = ( + ["lens", "ia", "flexion"], + [256, 512], + ) + param_names = ["transform", "nn"] + + def setup(self, transform, nn): + self.coords = utils.coordinate_grid(nn, dtype=np.float64) + self.transform = utils.transform_for_name(transform) + + def time_transform(self, transform, nn): + self.transform.transform(self.coords) + + +class TimeCppSampling: + """Benchmark GalSim profile sampling through BATSim's C++ bridge.""" + + params = ( + ["gaussian", "sersic"], + [128, 256], + ) + param_names = ["profile", "nn"] + + def setup(self, profile, nn): + self.galaxy = utils.gaussian_galaxy() if profile == "gaussian" else utils.sersic_galaxy() + self.coords = utils.coordinate_grid(nn, dtype=np.float64) + + def time_sample_galaxy_profile(self, profile, nn): + _sample_galaxy_profile( + gal_obj=self.galaxy, + coords=self.coords, + fine_scale=utils.SCALE, + real_dtype=np.float64, + ) + + +class TimeFFTGrid: + """Benchmark FFT helper operations on square NumPy grids.""" + + params = [512, 1024] + param_names = ["n"] + + def setup(self, n): + rng = np.random.default_rng(12345) + self.image = rng.normal(size=(n, n)).astype(np.float32) + self.spectrum = np.fft.rfft2(self.image).astype(np.complex64) + + def time_rfft_centered_image(self, n): + _rfft_centered_image( + xp=np, + image=self.image, + real_dtype=np.float32, + complex_dtype=np.complex64, + center_index=n // 2, + ) + + def time_apply_centering_phase(self, n): + spectrum = self.spectrum.copy() + _apply_centering_phase(np, spectrum, n, center_index=n // 2) + + def time_apply_pixel_response(self, n): + spectrum = self.spectrum.copy() + _apply_pixel_response( + xp=np, + spectrum=spectrum, + n=n, + fine_scale=utils.SCALE / 4, + pix_scale=utils.SCALE, + ) + + def time_compensate_block_integration(self, n): + spectrum = self.spectrum.copy() + _compensate_block_integration( + xp=np, + spectrum=spectrum, + n=n, + fine_scale=utils.SCALE / 4, + mode="quadrature", + integration_order=2, + ) + + def time_extract_centered_coarse_image(self, n): + _extract_centered_coarse_image( + xp=np, + image=self.image, + downsample_ratio=4, + center_index=n // 2, + ) + + +class TimePsfSpectrum: + """Benchmark analytic PSF spectrum sampling through the C++ bridge.""" + + params = ( + ["gaussian", "moffat"], + [512, 1024], + ) + param_names = ["psf", "n"] + + def setup(self, psf, n): + self.psf = utils.gaussian_psf() if psf == "gaussian" else utils.moffat_psf() + + def time_sample_psf_spectrum(self, psf, n): + _sample_psf_spectrum( + psf_obj=self.psf, + n=n, + fine_scale=utils.SCALE / 4, + complex_dtype=np.complex64, + ) + + +class TrackGridDecisions: + """Track grid sizing decisions for representative profiles.""" + + params = ["typical", "compact", "elliptical"] + param_names = ["profile"] + + def setup(self, profile): + if profile == "typical": + self.galaxy = utils.sersic_galaxy() + elif profile == "compact": + self.galaxy = utils.compact_sersic_galaxy() + elif profile == "elliptical": + self.galaxy = utils.elliptical_sersic_galaxy() + else: + raise ValueError(f"Unknown profile: {profile}") + + self.decision = utils.grid_decision(self.galaxy, integration_order=2) + + def track_supersample(self, profile): + return self.decision["supersample"] + + def track_fft_supersample(self, profile): + return self.decision["fft_supersample"] + + def track_integration_order(self, profile): + return self.decision["integration_order"] + + def track_fine_ngrid(self, profile): + return self.decision["fine_ngrid"] + + def track_fine_compact(self, profile): + return self.decision["fine_compact"] + + +class TrackRenderFlux: + """Track flux residual for a small stable render.""" + + def setup(self): + self.kwargs = utils.render_kwargs( + gal_obj=utils.gaussian_galaxy(), + ngrid=64, + psf_obj=utils.gaussian_psf(), + backend="np", + ) + + def track_flux_residual(self): + image = batsim.simulate_galaxy(**self.kwargs) + return utils.flux_residual(image) diff --git a/benchmarks/time_render.py b/benchmarks/time_render.py new file mode 100644 index 0000000..80ed00b --- /dev/null +++ b/benchmarks/time_render.py @@ -0,0 +1,175 @@ +"""End-to-end ``simulate_galaxy`` benchmarks.""" + +import batsim + +try: + from benchmarks import utils +except ImportError: + import utils + + +class TimeRenderScenarios: + """Benchmark representative public render paths.""" + + params = ( + ["minimal", "pixel", "psf_kvalue", "psf_real", "lens", "ia", "flexion"], + [64, 128, 256], + ) + param_names = ["scenario", "ngrid"] + timeout = 180 + + def setup(self, scenario, ngrid): + self.galaxy = utils.sersic_galaxy() + self.psf = None + self.transform = None + self.draw_method = "auto" + self.psf_mode = "kvalue" + + if scenario == "minimal": + self.draw_method = "no_pixel" + elif scenario == "pixel": + pass + elif scenario == "psf_kvalue": + self.psf = utils.gaussian_psf() + elif scenario == "psf_real": + self.psf = utils.gaussian_psf() + self.psf_mode = "real" + elif scenario in ("lens", "ia", "flexion"): + self.psf = utils.gaussian_psf() + self.transform = utils.transform_for_name(scenario) + else: + raise ValueError(f"Unknown render scenario: {scenario}") + + self.kwargs = utils.render_kwargs( + gal_obj=self.galaxy, + ngrid=ngrid, + transform_obj=self.transform, + psf_obj=self.psf, + draw_method=self.draw_method, + psf_mode=self.psf_mode, + backend="np", + ) + + def teardown(self, scenario, ngrid): + utils.cleanup_backend("np") + + def time_render(self, scenario, ngrid): + batsim.simulate_galaxy(**self.kwargs) + + +class TimeIntegrationScaling: + """Benchmark block-integration order in a controlled medium render.""" + + params = [1, 2, 4] + param_names = ["integration_order"] + timeout = 180 + + def setup(self, integration_order): + self.kwargs = utils.render_kwargs( + gal_obj=utils.compact_sersic_galaxy(), + ngrid=128, + psf_obj=utils.gaussian_psf(), + integration_order=integration_order, + backend="np", + ) + + def teardown(self, integration_order): + utils.cleanup_backend("np") + + def time_render_integration_order(self, integration_order): + batsim.simulate_galaxy(**self.kwargs) + + +class TimeFluxOption: + """Benchmark the cost of final input-flux normalization.""" + + params = [True, False] + param_names = ["force_input_flux"] + + def setup(self, force_input_flux): + self.kwargs = utils.render_kwargs( + ngrid=128, + psf_obj=utils.gaussian_psf(), + force_input_flux=force_input_flux, + backend="np", + ) + + def time_render_force_input_flux(self, force_input_flux): + batsim.simulate_galaxy(**self.kwargs) + + +class TimeCenteringOption: + """Benchmark true-center versus integer-center grid alignment.""" + + params = [True, False] + param_names = ["use_true_center"] + + def setup(self, use_true_center): + self.kwargs = utils.render_kwargs( + ngrid=128, + psf_obj=utils.gaussian_psf(), + use_true_center=use_true_center, + backend="np", + ) + + def time_render_use_true_center(self, use_true_center): + batsim.simulate_galaxy(**self.kwargs) + + +class TimeIntegrationCompensation: + """Benchmark integration-compensation modes on a compact profile.""" + + params = [None, "exact_sinc", "quadrature"] + param_names = ["compensate_integration"] + + def setup(self, compensate_integration): + self.kwargs = utils.render_kwargs( + gal_obj=utils.compact_sersic_galaxy(), + ngrid=128, + psf_obj=utils.gaussian_psf(), + integration_order=2, + compensate_integration=compensate_integration, + backend="np", + ) + + def time_render_compensate_integration(self, compensate_integration): + batsim.simulate_galaxy(**self.kwargs) + + +class TimePrecisionOption: + """Benchmark single versus double precision in a medium PSF render.""" + + params = ["single", "double"] + param_names = ["precision"] + + def setup(self, precision): + self.kwargs = utils.render_kwargs( + ngrid=128, + psf_obj=utils.moffat_psf(), + precision=precision, + backend="np", + ) + + def time_render_precision(self, precision): + batsim.simulate_galaxy(**self.kwargs) + + +class TimeCuPyRender: + """Optional GPU render benchmark that skips when CuPy is unavailable.""" + + params = [128] + param_names = ["ngrid"] + + def setup(self, ngrid): + utils.get_cupy() + self.kwargs = utils.render_kwargs( + ngrid=ngrid, + psf_obj=utils.gaussian_psf(), + backend="cp", + ) + + def teardown(self, ngrid): + utils.cleanup_backend("cp") + + def time_render_cupy(self, ngrid): + batsim.simulate_galaxy(**self.kwargs) diff --git a/benchmarks/utils.py b/benchmarks/utils.py new file mode 100644 index 0000000..d7f18a8 --- /dev/null +++ b/benchmarks/utils.py @@ -0,0 +1,173 @@ +"""Shared fixtures and helpers for BATSim ASV benchmarks.""" + +import gc + +import galsim +import numpy as np + +import batsim + +SCALE = 0.2 +HLR = 0.7 +FLUX = 1.0 +DEFAULT_MAX_FINE_GRID = 2048 + + +def gaussian_galaxy(): + """Return a cheap analytic galaxy profile.""" + return galsim.Gaussian(sigma=0.55, flux=FLUX) + + +def sersic_galaxy(n=1.0, half_light_radius=HLR): + """Return a representative analytic Sersic galaxy.""" + return galsim.Sersic(n=n, half_light_radius=half_light_radius, flux=FLUX) + + +def compact_sersic_galaxy(): + """Return a compact high-n profile that stresses supersampling decisions.""" + return galsim.Sersic(n=4.0, half_light_radius=0.35, flux=FLUX) + + +def elliptical_sersic_galaxy(): + """Return a sheared profile that stresses compact image support sizing.""" + return galsim.Sersic(n=3.0, half_light_radius=0.8, flux=FLUX).shear(e1=0.75) + + +def gaussian_psf(): + """Return a cheap Gaussian PSF.""" + return galsim.Gaussian(fwhm=0.55, flux=1.0) + + +def moffat_psf(): + """Return a broader Moffat PSF for convolution benchmarks.""" + return galsim.Moffat(beta=3.5, fwhm=0.75, trunc=3.0, flux=1.0) + + +def transform_for_name(name): + """Build one of the public transform objects used in render benchmarks.""" + if name == "none": + return None + if name == "lens": + return batsim.LensTransform(gamma1=0.12, gamma2=0.04, kappa=0.0) + if name == "ia": + return batsim.IaTransform(scale=SCALE, hlr=HLR, A=0.04, beta=0.8, phi=0.2) + if name == "flexion": + return batsim.FlexionTransform( + gamma1=0.05, + gamma2=0.02, + kappa=0.0, + F1=0.005, + F2=-0.003, + G1=0.002, + G2=0.001, + ) + + raise ValueError(f"Unknown transform benchmark name: {name}") + + +def render_kwargs( + *, + gal_obj=None, + ngrid=128, + transform_obj=None, + psf_obj=None, + draw_method="auto", + integration_order=2, + psf_mode="kvalue", + backend="np", + precision="single", + force_input_flux=True, + compensate_integration="quadrature", + use_true_center=True, + max_fine_grid=DEFAULT_MAX_FINE_GRID, +): + """Return current-public-API render kwargs shared by benchmarks.""" + return { + "gal_obj": sersic_galaxy() if gal_obj is None else gal_obj, + "scale": SCALE, + "ngrid": int(ngrid), + "transform_obj": transform_obj, + "psf_obj": psf_obj, + "draw_method": draw_method, + "integration_order": int(integration_order), + "psf_mode": psf_mode, + "backend": backend, + "precision": precision, + "force_input_flux": force_input_flux, + "compensate_integration": compensate_integration, + "use_true_center": use_true_center, + "max_fine_grid": max_fine_grid, + } + + +def coordinate_grid(nn, scale=SCALE, dtype=np.float64): + """Return flattened ``(2, nn * nn)`` NumPy coordinates for transform benchmarks.""" + ind = (np.arange(nn, dtype=dtype) - 0.5 * (nn - 1)) * scale + yy, xx = np.meshgrid(ind, ind, indexing="ij") + return np.stack([xx.ravel(), yy.ravel()], axis=0) + + +def grid_decision(gal_obj, integration_order=2, ngrid=128, max_fine_grid=DEFAULT_MAX_FINE_GRID): + """Return the grid sizing decisions used by the public renderer.""" + import batsim.sim as sim + + sim_ngrid = sim._resolve_simulation_ngrid(gal_obj, None, SCALE) + supersample = sim._determine_supersampling( + gal_obj, + SCALE, + integration_order, + sim_ngrid=sim_ngrid, + pad=16, + max_supersample=64, + min_supersample=4, + max_fine_grid=max_fine_grid, + ) + fft_supersample, resolved_integration_order = sim._resolve_integration_sampling( + supersample=supersample, + integration_order=integration_order, + ) + fft_supersample = max(fft_supersample, 4) + grid = sim._make_fine_grid( + gal_obj=gal_obj, + scale=SCALE, + sim_ngrid=sim_ngrid, + supersample=fft_supersample, + pad=16, + max_fine_grid=max_fine_grid, + ) + + return { + "output_ngrid": int(ngrid), + "sim_ngrid": int(sim_ngrid), + "supersample": int(supersample), + "fft_supersample": int(fft_supersample), + "integration_order": int(resolved_integration_order), + "fine_ngrid": int(grid.fine_ngrid), + "fine_compact": int(grid.fine_compact), + } + + +def flux_residual(image, target_flux=FLUX): + """Return absolute flux residual for a rendered image.""" + return abs(float(np.sum(image)) - float(target_flux)) + + +def get_cupy(): + """Return CuPy if a working CUDA runtime is available, otherwise skip.""" + try: + import cupy as cp + + cp.cuda.runtime.getDeviceCount() + return cp + except Exception as exc: + raise NotImplementedError("CuPy/CUDA is not available for GPU benchmarks.") from exc + + +def cleanup_backend(backend="np"): + """Release transient memory after benchmarks that allocate large arrays.""" + gc.collect() + try: + batsim.clear_backend_memory(backend) + except RuntimeError: + if backend not in ("cp", "cupy"): + raise diff --git a/conda/recipe/meta.yaml b/conda/recipe/meta.yaml index d8a6a4f..09de46b 100644 --- a/conda/recipe/meta.yaml +++ b/conda/recipe/meta.yaml @@ -1,5 +1,5 @@ {% set name = "batsim" %} -{% set version = "0.0.0" %} +{% set version = "0.0.1" %} package: name: {{ name|lower }} @@ -14,36 +14,30 @@ build: # skip: true # [not linux] # uncomment if you want linux-only builds requirements: - # Do not request conda-forge compiler toolchain packages on this cluster - # (they are unavailable, and the solve fails). Use system gcc/g++ instead. build: [] host: - - python + - python >=3.10,<3.13 - pip - setuptools - wheel - - numpy - - pybind11 - - galsim + - pybind11 >=3,<4 - eigen + - numpy >=1.26,<2.0 + - galsim - fitsio run: - - python - - numpy - - pybind11 + - python >=3.10,<3.13 + - numpy >=1.26,<2.0 - galsim - - eigen - fitsio - - matplotlib - - astropy + - matplotlib >=3.8,<3.9 + - astropy >=6.0,<6.1 test: - commands: - - test -d "$PREFIX/include/eigen3/Eigen" imports: - batsim - batsim._gsinterface about: license: MIT - summary: "BATSim package (links against GalSim C++ library)" \ No newline at end of file + summary: "BATSim package with GalSim C++ sampling and optional CuPy GPU support" diff --git a/docs/index.rst b/docs/index.rst index 22a54f5..c01e9f7 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,45 +1,77 @@ -.. batsim documentation main file. - You can adapt this file completely to your liking, but it should at least - contain the root `toctree` directive. +BATSim +====== -Welcome to batsim's documentation! -======================================================================================== +BATSim renders GalSim profiles on coordinate grids that can be transformed +before sampling. This supports non-affine shear fields, including +intrinsic-alignment-style radial shear and flexion, while preserving the current +GalSim image-centering and flux conventions used by the renderer. -Dev Guide - Getting Started ---------------------------- +Current Rendering Defaults +-------------------------- -Before installing any dependencies or writing code, it's a great idea to create a -virtual environment. LINCC-Frameworks engineers primarily use `conda` to manage virtual -environments. If you have conda installed locally, you can run the following to -create and activate a new environment. +The public render entry point is :func:`batsim.simulate_galaxy`. Its current +default pipeline uses: -.. code-block:: bash +* ``psf_mode="kvalue"`` to sample the analytic PSF Fourier profile through the + compiled BATSim/GalSim bridge. +* ``force_input_flux=True`` to preserve the input galaxy flux after convolution. +* ``use_true_center=True`` to align the fine grid with GalSim's true image + center convention. +* ``integration_order=2`` to use Gauss-Legendre block integration before the + FFT convolution path. +* ``compensate_integration="quadrature"`` to remove the matching + Gauss-Legendre transfer function. Pass ``"exact_sinc"`` for ideal top-hat + compensation, or None to disable compensation. +* ``backend="np"`` by default. Passing ``backend=None`` also selects NumPy; + pass ``backend="cp"`` to request CuPy. - >> conda create env -n python=3.10 - >> conda activate +Quickstart +---------- +.. code-block:: python -Once you have created a new environment, you can install this project for local -development using the following commands: + import galsim + import batsim -.. code-block:: bash + galaxy = galsim.Sersic(n=1.0, half_light_radius=0.7, flux=1.0) + psf = galsim.Gaussian(fwhm=0.7) + transform = batsim.IaTransform(scale=0.2, hlr=0.7, A=0.02) - >> pip install -e .'[dev]' - >> pre-commit install - >> conda install pandoc + image = batsim.simulate_galaxy( + galaxy, + scale=0.2, + ngrid=64, + transform_obj=transform, + psf_obj=psf, + ) +``image`` is returned as a NumPy array, even when CuPy is used internally for +FFT-heavy work. -Notes: +Installation Notes +------------------ -1) The single quotes around ``'[dev]'`` may not be required for your operating system. -2) ``pre-commit install`` will initialize pre-commit for this local repository, so - that a set of tests will be run prior to completing a local commit. For more - information, see the Python Project Template documentation on - `pre-commit `_. -3) Install ``pandoc`` allows you to verify that automatic rendering of Jupyter notebooks - into documentation for ReadTheDocs works as expected. For more information, see - the Python Project Template documentation on - `Sphinx and Python Notebooks `_. +BATSim links against GalSim's shared C++ library. The recommended installation +route is currently a conda or mamba environment using conda-forge packages for +GalSim, Eigen, pybind11, and NumPy, followed by ``pip install -e .`` for local +development. See the repository README for full build instructions. + +Public API +---------- + +The stable top-level API includes: + +* :func:`batsim.simulate_galaxy` +* :func:`batsim.clear_backend_memory` +* :class:`batsim.Stamp` +* :class:`batsim.Transform`, a base class for custom coordinate transforms +* :class:`batsim.LensTransform` and :class:`batsim.AffineLensingTransform` +* :class:`batsim.IaTransform` and :class:`batsim.IATransform` +* :class:`batsim.FlexionTransform` + +Experimental helpers live under :mod:`batsim.experimental`. They are available +for development and validation work, but are not part of the stable top-level +API. .. toctree:: diff --git a/notebooks/dev/charlie.png b/notebooks/dev/charlie.png new file mode 100644 index 0000000..5e18b6d Binary files /dev/null and b/notebooks/dev/charlie.png differ diff --git a/notebooks/dev/cpu-only-render.ipynb b/notebooks/dev/cpu-only-render.ipynb new file mode 100644 index 0000000..c1b765e --- /dev/null +++ b/notebooks/dev/cpu-only-render.ipynb @@ -0,0 +1,249 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5fc7a3a3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Draw + FFT time: 23.5488 seconds\n", + "Conv time: 28.1799 seconds\n", + "GalSim draw time: 0.0160 seconds\n", + "Mode: with pixel\n", + "PSF method: real-space FFT\n", + "Supersample: 256\n", + "GalSim flux: 0.99896991\n", + "FFT flux: 0.99897554\n", + "Max abs residual: 3.134e-06\n", + "Max abs residual as % of max flux: 0.008%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import galsim\n", + "import numpy as np\n", + "from time import time\n", + "import matplotlib.pyplot as plt\n", + "\n", + "use_pixel = True # Whether to include the pixel response\n", + "kpsf = False # Whether to draw the PSF directly in k-space\n", + "supersample = 256 # Super-sample grid size for direct FFT approach\n", + "pad = 16 # Extra padding around image to ignore distant flux from FFTs\n", + "scale = 0.2 # Pixel scale of the output image\n", + "\n", + "# Construct psf and galaxy profiles\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "gal = galsim.Sersic(n=2, half_light_radius=0.2, flux=1).shear(g1=0.02)\n", + "objs = [gal, psf]\n", + "conv_gal = galsim.Convolve(objs)\n", + "\n", + "# Determine image size\n", + "# Use the convolved profile's own good image size rather than the pre-convolution galaxy size.\n", + "size = conv_gal.getGoodImageSize(scale)\n", + "fft_size = size + 2*pad\n", + "fine_scale = scale / supersample\n", + "fine_fft_size = fft_size * supersample\n", + "dk = 2 * np.pi / (fine_fft_size * fine_scale)\n", + "\n", + "start = time()\n", + "# Draw the galaxy without pixel convolution.\n", + "gal_im = gal.drawImage(nx=fine_fft_size, ny=fine_fft_size, scale=fine_scale,\n", + " method=\"no_pixel\", use_true_center=False).array\n", + "gal_fft = galsim.fft.fft2(gal_im, shift_in=True, shift_out=True)\n", + "\n", + "# Draw the PSF either directly in k-space or in real space and then fft.\n", + "if kpsf:\n", + " psf_fft = psf.drawKImage(nx=fine_fft_size, ny=fine_fft_size, scale=dk).array\n", + "else:\n", + " psf_im = psf.drawImage(nx=fine_fft_size, ny=fine_fft_size, scale=fine_scale,\n", + " method=\"no_pixel\", use_true_center=False).array\n", + " psf_fft = galsim.fft.fft2(psf_im, shift_in=True, shift_out=True)\n", + "\n", + "# Draw the pixel if requested.\n", + "if use_pixel:\n", + " # Draw the pixel directly in Fourier space, rather than use fft2.\n", + " # The direct fft doesn't work especially well with only a single non-zero pixel.\n", + " # (Nor even when supersampling to sxs pixels.)\n", + " pix_fft = galsim.Pixel(scale).drawKImage(nx=fine_fft_size, ny=fine_fft_size, scale=dk).array\n", + "end = time()\n", + "print(f\"Draw + FFT time: {end - start:.4f} seconds\")\n", + "\n", + "start = time()\n", + "# Convolve and IFFT\n", + "bat_conv_fft = gal_fft * psf_fft\n", + "if use_pixel:\n", + " bat_conv_fft *= pix_fft\n", + "bat_conv_im = galsim.fft.ifft2(bat_conv_fft, shift_in=True, shift_out=True).real\n", + "\n", + "# Recover the coarse-grid image by taking the matching fine-grid sample phase and multiplying by\n", + "# the area ratio.\n", + "if supersample > 1:\n", + " bat_conv_im = (supersample**2) * bat_conv_im[::supersample, ::supersample]\n", + "end = time()\n", + "print(f\"Conv time: {end - start:.4f} seconds\")\n", + "\n", + "start = time()\n", + "# Draw a padded GalSim image too\n", + "draw_method = \"auto\" if use_pixel else \"no_pixel\"\n", + "gal_conv_im = conv_gal.drawImage(\n", + " nx=fft_size, ny=fft_size, scale=scale, method=draw_method, use_true_center=False\n", + ").array\n", + "end = time()\n", + "print(f\"GalSim draw time: {end - start:.4f} seconds\")\n", + "\n", + "# Crop both images to the same central region before computing the residual.\n", + "gal_conv_im = gal_conv_im[pad:pad+size, pad:pad+size]\n", + "bat_conv_im = bat_conv_im[pad:pad+size, pad:pad+size]\n", + "residual = gal_conv_im - bat_conv_im\n", + "print(f\"Mode: {'with pixel' if use_pixel else 'no pixel'}\")\n", + "print(f\"PSF method: {'k-space' if kpsf else 'real-space FFT'}\")\n", + "print(f\"Supersample: {supersample}\")\n", + "print(f\"GalSim flux: {gal_conv_im.sum():.8f}\")\n", + "print(f\"FFT flux: {bat_conv_im.sum():.8f}\")\n", + "print(f\"Max abs residual: {abs(residual).max():.3e}\")\n", + "\n", + "perc_residual = 100 * abs(residual).max() / gal_conv_im.max()\n", + "print(f\"Max abs residual as % of max flux: {perc_residual:.3f}%\")\n", + "\n", + "# Plot\n", + "plt.subplots(1, 3, figsize=(15, 5))\n", + "plt.subplot(1, 3, 1)\n", + "plt.imshow(gal_conv_im, origin='lower', cmap='gray')\n", + "plt.colorbar()\n", + "plt.title(\"GalSim Convolution\")\n", + "plt.subplot(1, 3, 2)\n", + "plt.imshow(bat_conv_im, origin='lower', cmap='gray')\n", + "plt.colorbar()\n", + "plt.title(\"Direct FFT Convolution\")\n", + "plt.subplot(1, 3, 3)\n", + "plt.imshow(residual, origin='lower', cmap='gray')\n", + "plt.colorbar()\n", + "plt.title(\"Residual (Galsim - BATSim)\")\n", + "plt.savefig('charlie.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4026dcf9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "galsim.Shear(g1=0.004824522485723136,g2=-4.795381291994292e-14)\n", + "galsim.Shear(g1=0.004824534593762056,g2=-4.8053450036177683e-14)\n", + "Percentage difference in g1: 0.00%\n" + ] + } + ], + "source": [ + "# Measure shear using adaptive moments on both images\n", + "psf_final_im = psf.drawImage(\n", + " nx=fft_size, ny=fft_size, scale=scale, method=draw_method, use_true_center=False\n", + ").array\n", + "psf_final_im = psf_final_im[pad:pad+size, pad:pad+size]\n", + "\n", + "# create galsim images from all arrays\n", + "psf_final_im = galsim.Image(psf_final_im, scale=scale)\n", + "bat_conv_im = galsim.Image(bat_conv_im, scale=scale)\n", + "gal_conv_im = galsim.Image(gal_conv_im, scale=scale)\n", + "\n", + "manual_result = galsim.hsm.EstimateShear(bat_conv_im, psf_final_im)\n", + "print(manual_result.observed_shape)\n", + "\n", + "galsim_result = galsim.hsm.EstimateShear(gal_conv_im, psf_final_im)\n", + "print(galsim_result.observed_shape)\n", + "\n", + "manual_g1 = manual_result.observed_shape.g1\n", + "galsim_g1 = galsim_result.observed_shape.g1\n", + "\n", + "perc_diff_g1 = 100 * abs(manual_g1 - galsim_g1) / abs(galsim_g1)\n", + "print(f\"Percentage difference in g1: {perc_diff_g1:.2f}%\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "48599ae6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "galsim.Shear(g1=0.02698008192948362,g2=-4.3253633125057155e-12)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "galaxy = galsim.Sersic(n=1, half_light_radius=0.5, flux=1).shear(g1=0.05)\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "final = galsim.Convolve(galaxy, psf)\n", + "final_image = final.drawImage(scale=0.2, use_true_center=False)\n", + "final_epsf_image = psf.drawImage(scale=0.2, use_true_center=False)\n", + "result = galsim.hsm.EstimateShear(final_image, final_epsf_image)\n", + "\n", + "print(result.observed_shape)\n", + "\n", + "plt.imshow(final_image.array, origin='lower', cmap='gray')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "batsim-gpu", + "language": "python", + "name": "python3" + }, + "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.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/dev/cupy-test-rendering.ipynb b/notebooks/dev/cupy-test-rendering.ipynb new file mode 100644 index 0000000..36cb229 --- /dev/null +++ b/notebooks/dev/cupy-test-rendering.ipynb @@ -0,0 +1,612 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "ab8a2471", + "metadata": {}, + "outputs": [], + "source": [ + "import galsim\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cupy as cp\n", + "import batsim\n", + "# import cupyx.scipy.fft as cp_fft\n", + "\n", + "from time import time\n", + "from tqdm import tqdm\n", + "\n", + "#print(cp.cuda.is_available())" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0aa84a48", + "metadata": {}, + "outputs": [], + "source": [ + "def fft_on_gpu(image):\n", + " # Execute the FFT on the GPU and shift the zero-frequency component to the center of the spectrum.\n", + " return cp.fft.fftshift(cp.fft.fft2(cp.fft.ifftshift(image)))\n", + "\n", + "def ifft_on_gpu(image_fft):\n", + " # Execute the inverse FFT on the GPU and shift back.\n", + " return cp.fft.fftshift(cp.fft.ifft2(cp.fft.ifftshift(image_fft)))\n", + "\n", + "def pixel_fft_gpu_shifted(n, fine_scale, pixel_scale):\n", + " kfreq = 2 * cp.pi * cp.fft.fftshift(cp.fft.fftfreq(n, d=fine_scale))\n", + " ky, kx = cp.meshgrid(kfreq, kfreq, indexing=\"ij\")\n", + "\n", + " pix_fft = cp.sinc(kx * pixel_scale / (2 * cp.pi))\n", + " pix_fft *= cp.sinc(ky * pixel_scale / (2 * cp.pi))\n", + " \n", + "\n", + " return pix_fft.astype(cp.complex64)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bfae6101", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "14336 0.0015625\n", + "9692\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/b7009348/FPFS-project/BATSim/src/batsim/stamp.py:75: RuntimeWarning: CuPy unavailable; falling back to NumPy stamp coordinates.\n", + " self.xp = _get_array_backend() if backend is None else backend\n" + ] + }, + { + "ename": "CUDARuntimeError", + "evalue": "cudaErrorInsufficientDriver: CUDA driver version is insufficient for CUDA runtime version", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mCUDARuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[4], line 45\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[38;5;66;03m# Draw the pixel if requested.\u001b[39;00m\n\u001b[1;32m 38\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m use_pixel:\n\u001b[1;32m 39\u001b[0m \u001b[38;5;66;03m# Draw the pixel directly in Fourier space, rather than use fft2.\u001b[39;00m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;66;03m# The direct fft doesn't work especially well with only a single non-zero pixel.\u001b[39;00m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;66;03m# (Nor even when supersampling to sxs pixels.)\u001b[39;00m\n\u001b[1;32m 42\u001b[0m \u001b[38;5;66;03m# pix_fft = galsim.Pixel(scale).drawKImage(nx=fine_fft_size, ny=fine_fft_size, scale=dk).array\u001b[39;00m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;66;03m# pix_fft = cp.asarray(pix_fft)\u001b[39;00m\n\u001b[0;32m---> 45\u001b[0m pix_fft \u001b[38;5;241m=\u001b[39m \u001b[43mpixel_fft_gpu_shifted\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 46\u001b[0m \u001b[43m \u001b[49m\u001b[43mn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfine_fft_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 47\u001b[0m \u001b[43m \u001b[49m\u001b[43mfine_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfine_scale\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 48\u001b[0m \u001b[43m \u001b[49m\u001b[43mpixel_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscale\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 49\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 50\u001b[0m end \u001b[38;5;241m=\u001b[39m time()\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDraw time: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mend\u001b[38;5;250m \u001b[39m\u001b[38;5;241m-\u001b[39m\u001b[38;5;250m \u001b[39mstart\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m seconds\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "Cell \u001b[0;32mIn[2], line 10\u001b[0m, in \u001b[0;36mpixel_fft_gpu_shifted\u001b[0;34m(n, fine_scale, pixel_scale)\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mpixel_fft_gpu_shifted\u001b[39m(n, fine_scale, pixel_scale):\n\u001b[0;32m---> 10\u001b[0m kfreq \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m cp\u001b[38;5;241m.\u001b[39mpi \u001b[38;5;241m*\u001b[39m cp\u001b[38;5;241m.\u001b[39mfft\u001b[38;5;241m.\u001b[39mfftshift(\u001b[43mcp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfft\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfftfreq\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfine_scale\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 11\u001b[0m ky, kx \u001b[38;5;241m=\u001b[39m cp\u001b[38;5;241m.\u001b[39mmeshgrid(kfreq, kfreq, indexing\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mij\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 13\u001b[0m pix_fft \u001b[38;5;241m=\u001b[39m cp\u001b[38;5;241m.\u001b[39msinc(kx \u001b[38;5;241m*\u001b[39m pixel_scale \u001b[38;5;241m/\u001b[39m (\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m cp\u001b[38;5;241m.\u001b[39mpi))\n", + "File \u001b[0;32m~/miniconda3/envs/batsim-dev/lib/python3.10/site-packages/cupy/fft/_fft.py:1065\u001b[0m, in \u001b[0;36mfftfreq\u001b[0;34m(n, d)\u001b[0m\n\u001b[1;32m 1053\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfftfreq\u001b[39m(n, d\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.0\u001b[39m):\n\u001b[1;32m 1054\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Return the FFT sample frequencies.\u001b[39;00m\n\u001b[1;32m 1055\u001b[0m \n\u001b[1;32m 1056\u001b[0m \u001b[38;5;124;03m Args:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1063\u001b[0m \u001b[38;5;124;03m .. seealso:: :func:`numpy.fft.fftfreq`\u001b[39;00m\n\u001b[1;32m 1064\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1065\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cupy\u001b[38;5;241m.\u001b[39mhstack((\u001b[43mcupy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marange\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;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[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfloat64\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[1;32m 1066\u001b[0m cupy\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m-\u001b[39m(n \u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m), \u001b[38;5;241m0\u001b[39m, dtype\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mfloat64))) \u001b[38;5;241m/\u001b[39m (n \u001b[38;5;241m*\u001b[39m d)\n", + "File \u001b[0;32m~/miniconda3/envs/batsim-dev/lib/python3.10/site-packages/cupy/_creation/ranges.py:58\u001b[0m, in \u001b[0;36marange\u001b[0;34m(start, stop, step, dtype)\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 56\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cupy\u001b[38;5;241m.\u001b[39marray([start], dtype\u001b[38;5;241m=\u001b[39mnumpy\u001b[38;5;241m.\u001b[39mbool_)\n\u001b[0;32m---> 58\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[43mcupy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mempty\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[43msize\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 59\u001b[0m typ \u001b[38;5;241m=\u001b[39m numpy\u001b[38;5;241m.\u001b[39mdtype(dtype)\u001b[38;5;241m.\u001b[39mtype\n\u001b[1;32m 60\u001b[0m _arange_ufunc(typ(start), typ(step), ret, dtype\u001b[38;5;241m=\u001b[39mdtype)\n", + "File \u001b[0;32m~/miniconda3/envs/batsim-dev/lib/python3.10/site-packages/cupy/_creation/basic.py:32\u001b[0m, in \u001b[0;36mempty\u001b[0;34m(shape, dtype, order)\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mempty\u001b[39m(\n\u001b[1;32m 14\u001b[0m shape: _ShapeLike,\n\u001b[1;32m 15\u001b[0m dtype: DTypeLike \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mfloat\u001b[39m,\n\u001b[1;32m 16\u001b[0m order: _OrderCF \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mC\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 17\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m NDArray[Any]:\n\u001b[1;32m 18\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Returns an array without initializing the elements.\u001b[39;00m\n\u001b[1;32m 19\u001b[0m \n\u001b[1;32m 20\u001b[0m \u001b[38;5;124;03m Args:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 30\u001b[0m \n\u001b[1;32m 31\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m---> 32\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcupy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mndarray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43morder\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43morder\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32mcupy/_core/core.pyx:167\u001b[0m, in \u001b[0;36mcupy._core.core.ndarray.__new__\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mcupy/_core/core.pyx:254\u001b[0m, in \u001b[0;36mcupy._core.core._ndarray_base._init\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mcupy/cuda/memory.pyx:875\u001b[0m, in \u001b[0;36mcupy.cuda.memory.alloc\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mcupy/cuda/memory.pyx:1579\u001b[0m, in \u001b[0;36mcupy.cuda.memory.MemoryPool.malloc\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mcupy/cuda/memory.pyx:1599\u001b[0m, in \u001b[0;36mcupy.cuda.memory.MemoryPool.malloc\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mcupy/cuda/device.pyx:40\u001b[0m, in \u001b[0;36mcupy.cuda.device.get_device_id\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mcupy_backends/cuda/api/runtime.pyx:202\u001b[0m, in \u001b[0;36mcupy_backends.cuda.api.runtime.getDevice\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mcupy_backends/cuda/api/runtime.pyx:146\u001b[0m, in \u001b[0;36mcupy_backends.cuda.api.runtime.check_status\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mCUDARuntimeError\u001b[0m: cudaErrorInsufficientDriver: CUDA driver version is insufficient for CUDA runtime version" + ] + } + ], + "source": [ + "use_pixel = True # Whether to include the pixel response\n", + "supersample = 128 # Super-sample grid size for direct FFT approach\n", + "pad = 16 # Extra padding around image to ignore distant flux from FFTs\n", + "scale = 0.2 # Pixel scale of the output image\n", + "\n", + "# Construct psf and galaxy profiles\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "gal = galsim.Sersic(n=5, half_light_radius=0.2, flux=1)\n", + "objs = [gal, psf]\n", + "conv_gal = galsim.Convolve(objs)\n", + "\n", + "# Determine image size\n", + "# Use the convolved profile's own good image size rather than the pre-convolution galaxy size.\n", + "size = conv_gal.getGoodImageSize(scale)\n", + "fft_size = size + 2*pad\n", + "fine_scale = scale / supersample\n", + "fine_fft_size = fft_size * supersample\n", + "print(fine_fft_size, fine_scale)\n", + "dk = 2 * np.pi / (fine_fft_size * fine_scale)\n", + "\n", + "start = time()\n", + "compact_size = gal.getGoodImageSize(fine_scale)\n", + "print(compact_size)\n", + "# gal_im = gal.drawImage(nx=compact_size, ny=compact_size, scale=fine_scale,\n", + "# method=\"no_pixel\", use_true_center=False).array\n", + "stamp = batsim.Stamp(nn=fine_fft_size, scale=fine_scale)\n", + "coords = stamp.coords\n", + "coords = cp.asnumpy(coords).astype(np.float64)\n", + "gal_im = batsim._gsinterface.getFluxVec(fine_scale, gal._sbp, coords)\n", + "\n", + "# Draw the PSF either directly in k-space or in real space and then fft.\n", + "# psf_fft = psf.drawKImage(nx=fine_fft_size, ny=fine_fft_size, scale=dk).array\n", + "# psf_fft = cp.asarray(psf_fft)\n", + "psf_compact = psf.getGoodImageSize(fine_scale)\n", + "psf_im = psf.drawImage(nx=fine_fft_size, ny=fine_fft_size, scale=fine_scale, method=\"no_pixel\", use_true_center=False).array\n", + "\n", + "# Draw the pixel if requested.\n", + "if use_pixel:\n", + " # Draw the pixel directly in Fourier space, rather than use fft2.\n", + " # The direct fft doesn't work especially well with only a single non-zero pixel.\n", + " # (Nor even when supersampling to sxs pixels.)\n", + " # pix_fft = galsim.Pixel(scale).drawKImage(nx=fine_fft_size, ny=fine_fft_size, scale=dk).array\n", + " # pix_fft = cp.asarray(pix_fft)\n", + "\n", + " pix_fft = pixel_fft_gpu_shifted(\n", + " n=fine_fft_size,\n", + " fine_scale=fine_scale,\n", + " pixel_scale=scale,\n", + " )\n", + "end = time()\n", + "print(f\"Draw time: {end - start:.4f} seconds\")\n", + "\n", + "start = time()\n", + "# Send to GPU\n", + "gal_im = cp.asarray(gal_im)\n", + "psf_im = cp.asarray(psf_im)\n", + "#Execute the FFT on the GPU and shift the zero-frequency component to the center of the spectrum.\n", + "gal_fft = fft_on_gpu(gal_im)\n", + "psf_fft = fft_on_gpu(psf_im)\n", + "end = time()\n", + "print(f\"FFT time: {end - start:.4f} seconds\")\n", + "\n", + "start = time()\n", + "# Convolve and IFFT\n", + "bat_conv_fft = gal_fft * psf_fft\n", + "if use_pixel:\n", + " bat_conv_fft *= pix_fft\n", + "bat_conv_im = ifft_on_gpu(bat_conv_fft)\n", + "\n", + "# Recover the coarse-grid image by taking the matching fine-grid sample phase and multiplying by\n", + "# the area ratio.\n", + "if supersample > 1:\n", + " bat_conv_im = (supersample**2) * bat_conv_im[::supersample, ::supersample]\n", + "end = time()\n", + "print(f\"Conv time: {end - start:.4f} seconds\")\n", + "\n", + "start = time()\n", + "# Draw a padded GalSim image too\n", + "draw_method = \"auto\" if use_pixel else \"no_pixel\"\n", + "gal_conv_im = conv_gal.drawImage(\n", + " nx=fft_size, ny=fft_size, scale=scale, method=draw_method, use_true_center=False\n", + ").array\n", + "end = time()\n", + "print(f\"GalSim draw time: {end - start:.4f} seconds\")\n", + "\n", + "# Crop both images to the same central region before computing the residual.\n", + "gal_conv_im = gal_conv_im[pad:pad+size, pad:pad+size]\n", + "bat_conv_im = bat_conv_im[pad:pad+size, pad:pad+size]\n", + "\n", + "# Move back to CPU for comparison and plotting.\n", + "bat_conv_im = cp.asnumpy(bat_conv_im).real\n", + "\n", + "# clean up GPU memory\n", + "cp._default_memory_pool.free_all_blocks()\n", + "cp._default_pinned_memory_pool.free_all_blocks()\n", + "\n", + "residual = gal_conv_im - bat_conv_im\n", + "print(f\"Mode: {'with pixel' if use_pixel else 'no pixel'}\")\n", + "print(f\"Supersample: {supersample}\")\n", + "print(f\"GalSim flux: {gal_conv_im.sum():.8f}\")\n", + "print(f\"FFT flux: {bat_conv_im.sum():.8f}\")\n", + "print(f\"Max abs residual: {abs(residual).max():.3e}\")\n", + "\n", + "perc_residual = 100 * abs(residual).max() / gal_conv_im.max()\n", + "print(f\"Max abs residual as % of max flux: {perc_residual:.3f}%\")\n", + "\n", + "# Plot\n", + "plt.subplots(1, 3, figsize=(15, 5))\n", + "plt.subplot(1, 3, 1)\n", + "plt.imshow(gal_conv_im, origin='lower', cmap='gray')\n", + "plt.colorbar()\n", + "plt.title(\"GalSim Convolution\")\n", + "plt.subplot(1, 3, 2)\n", + "plt.imshow(bat_conv_im, origin='lower', cmap='gray')\n", + "plt.colorbar()\n", + "plt.title(\"Direct FFT Convolution\")\n", + "plt.subplot(1, 3, 3)\n", + "plt.imshow(residual, origin='lower', cmap='gray')\n", + "plt.colorbar()\n", + "plt.title(\"Residual (Galsim - BATSim)\")\n", + "plt.savefig('charlie.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b7fff553", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "538.1658703643784\n", + "0.005837591766015747\n", + "Recommended supersampling: 8\n" + ] + } + ], + "source": [ + "def galsim_sampling_hint(obj, pixel_scale, safety=2.0,integration_order=2, attenuation_target=0.05):\n", + " \"\"\"\n", + " Estimate supersampling from GalSim's internal maxk/stepk style scale info.\n", + " \"\"\"\n", + " maxk = float(obj.maxk)\n", + " coarse_nyquist = np.pi / float(pixel_scale)\n", + "\n", + " raw = safety * maxk / coarse_nyquist\n", + "\n", + " q = max(1, int(integration_order))\n", + "\n", + " if q <= 1:\n", + " effective = raw\n", + " else:\n", + " # Block integration behaves approximately like a square/tophat\n", + " # prefilter over the FFT-grid cell. Its Fourier response is sinc-like.\n", + " #\n", + " # Rather than using a fixed empirical division, use q to define the\n", + " # strongest plausible reduction. q=2 usually permits about 4--8x less\n", + " # effective supersampling in your tests, so q^2 is a reasonable base.\n", + " #\n", + " # attenuation_target lets you tune how much high-k leakage you tolerate.\n", + " integration_reduction = q ** 2 / attenuation_target**0.5\n", + "\n", + " # Avoid absurd reductions for high q.\n", + " integration_reduction = min(integration_reduction, 8.0 * q)\n", + "\n", + " effective = raw / integration_reduction\n", + "\n", + " # Do not allow the requested effective supersampling to fall below q,\n", + " # otherwise fft_supersample may collapse too aggressively.\n", + " effective = max(effective, q)\n", + "\n", + " # Round up to power of two\n", + " s_pow2 = 2 ** int(np.ceil(np.log2(max(1, effective))))\n", + "\n", + " return int(np.clip(s_pow2, 1, 1024))\n", + "\n", + "gal = galsim.Sersic(n=3, half_light_radius=0.2)\n", + "\n", + "print(gal.maxk)\n", + "print(gal.nyquist_scale)\n", + "\n", + "supersample = galsim_sampling_hint(gal, pixel_scale=scale)\n", + "print(f\"Recommended supersampling: {supersample}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8b08aed2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Recommended supersampling: 32\n", + "Grid sizing: sim_ngrid=1340, supersample=16, integration_order=2, fft_supersample=8, fine_ngrid=4096, fine_compact=10712, max_fine_grid=4096\n", + "Stamp construction took 0.116 seconds\n", + "Build coordinates and transforms took 0.971 seconds\n", + "Transfer coords to CPU took 0.000 seconds\n", + "Galaxy sampling took 0.106 seconds\n", + "Transfer galaxy profile to NumPy took 0.000 seconds\n", + "Sampling PSF spectrum took 0.013 seconds\n", + "Transfer PSF spectrum to NumPy took 0.000 seconds\n", + "FFT and convolution took 1.158 seconds\n", + "BATSim simulation time: 2.3545 seconds\n", + "GalSim draw time: 0.0887 seconds\n", + "GalSim flux: 3.52486086\n", + "BATSim flux: 3.56863256\n", + "Max abs residual: 3.441e-04\n", + "Max abs residual as % of max flux: 0.624%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_method = \"auto\"\n", + "scale = 0.2 # Pixel scale of the output image\n", + "\n", + "# Construct psf and galaxy profiles\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "\n", + "cosmos = galsim.COSMOSCatalog()\n", + "\n", + "gal = cosmos.makeGalaxy(index=29024, gal_type=\"parametric\")\n", + "#gal = galsim.Sersic(n=1, half_light_radius=0.2, flux=1).shear(g1=0.2, g2=0.5)\n", + "objs = [gal.shear(g1=0.05), psf]\n", + "conv_gal = galsim.Convolve(objs)\n", + "#conv_gal = conv_gal.shift(0.5*scale, 0.5*scale)\n", + "\n", + "supersample = galsim_sampling_hint(gal, pixel_scale=scale)\n", + "print(f\"Recommended supersampling: {supersample}\")\n", + "\n", + "start = time()\n", + "LensTransform = batsim.LensTransform(\n", + " gamma1=0.05,\n", + " gamma2=0.0,\n", + " kappa=0.0,\n", + " backend=None\n", + ")\n", + "# Simulate using BATSim\n", + "bat_conv_im = batsim.simulate_galaxy(\n", + " gal_obj=gal,\n", + " scale=scale,\n", + " psf_obj=psf,\n", + " transform_obj=LensTransform,\n", + " ngrid=64,\n", + " precision=\"single\",\n", + " draw_method=draw_method,\n", + " profile=True,\n", + " pad=16,\n", + " psf_mode=\"kvalue\",\n", + " max_supersample=32,\n", + " min_supersample=4,\n", + " max_fine_grid=4096,\n", + " integration_order=2,\n", + " force_input_flux=True,\n", + " backend=\"numpy\",\n", + " compensate_integration=False\n", + ")\n", + "im_size = bat_conv_im.shape\n", + "end = time()\n", + "print(f\"BATSim simulation time: {end - start:.4f} seconds\")\n", + "\n", + "start = time()\n", + "# Draw a padded GalSim image too\n", + "gal_conv_im = conv_gal.drawImage(\n", + " nx=im_size[0], ny=im_size[1], scale=scale, method=draw_method, use_true_center=True\n", + ").array\n", + "end = time()\n", + "print(f\"GalSim draw time: {end - start:.4f} seconds\")\n", + "\n", + "residual = gal_conv_im - bat_conv_im\n", + "print(f\"GalSim flux: {gal_conv_im.sum():.8f}\")\n", + "print(f\"BATSim flux: {bat_conv_im.sum():.8f}\")\n", + "print(f\"Max abs residual: {abs(residual).max():.3e}\")\n", + "\n", + "perc_residual = 100 * abs(residual).max() / gal_conv_im.max()\n", + "print(f\"Max abs residual as % of max flux: {perc_residual:.3f}%\")\n", + "\n", + "# Plot\n", + "plt.subplots(1, 3, figsize=(15, 5))\n", + "plt.subplot(1, 3, 1)\n", + "plt.imshow(gal_conv_im, origin='lower', cmap='gray')\n", + "plt.colorbar()\n", + "plt.title(\"GalSim Convolution\")\n", + "plt.subplot(1, 3, 2)\n", + "plt.imshow(bat_conv_im, origin='lower', cmap='gray')\n", + "plt.colorbar()\n", + "plt.title(\"BATSim Convolution\")\n", + "plt.subplot(1, 3, 3)\n", + "plt.imshow(residual, origin='lower', cmap='gray')\n", + "plt.colorbar()\n", + "plt.title(\"Residual (Galsim - BATSim)\")\n", + "plt.savefig('charlie.png')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef3196f6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.126953125" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "21000 / 4096" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1638ddb7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n", + "2073.4323740702816\n", + "0.0015151652365795003\n" + ] + } + ], + "source": [ + "gal = cosmos.makeGalaxy(index=29024, gal_type=\"parametric\")\n", + "print(gal.is_axisymmetric)\n", + "print(gal.maxk)\n", + "print(gal.nyquist_scale)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd85754e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "14.493884835704382\n" + ] + } + ], + "source": [ + "print(psf.maxk)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "91d49d8a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.301843543528006\n", + "scale = 1.002208\n", + "fractional RMS residual = 0.0024678423\n", + "fractional flux residual = 0.0022185752\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(gal.flux)\n", + "\n", + "b = bat_conv_im\n", + "g = gal_conv_im\n", + "\n", + "a = np.sum(b * g) / np.sum(b * b)\n", + "\n", + "resid = a * b - g\n", + "\n", + "print(\"scale =\", a)\n", + "print(\"fractional RMS residual =\", np.std(resid) / np.std(g))\n", + "print(\"fractional flux residual =\", np.sum(resid) / np.sum(g))\n", + "plt.imshow(resid, cmap='gray')\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c28bb2c6", + "metadata": {}, + "outputs": [], + "source": [ + "# Clear GPU memory\n", + "cp._default_memory_pool.free_all_blocks()\n", + "cp._default_pinned_memory_pool.free_all_blocks()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8c77c5c9", + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "_determine_supersampling() missing 1 required positional argument: 'integration_order'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[11], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m conv \u001b[38;5;241m=\u001b[39m galsim\u001b[38;5;241m.\u001b[39mConvolve((gal,psf))\n\u001b[1;32m 3\u001b[0m sim_ngrid \u001b[38;5;241m=\u001b[39m batsim\u001b[38;5;241m.\u001b[39msim\u001b[38;5;241m.\u001b[39m_resolve_simulation_ngrid(gal, psf, scale)\n\u001b[0;32m----> 4\u001b[0m supersample \u001b[38;5;241m=\u001b[39m \u001b[43mbatsim\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msim\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_determine_supersampling\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgal\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 6\u001b[0m FineGrid \u001b[38;5;241m=\u001b[39m batsim\u001b[38;5;241m.\u001b[39msim\u001b[38;5;241m.\u001b[39m_make_fine_grid(\n\u001b[1;32m 7\u001b[0m conv, scale, sim_ngrid, supersample, pad\n\u001b[1;32m 8\u001b[0m )\n\u001b[1;32m 9\u001b[0m fine_ngrid \u001b[38;5;241m=\u001b[39m FineGrid\u001b[38;5;241m.\u001b[39mfine_ngrid\n", + "\u001b[0;31mTypeError\u001b[0m: _determine_supersampling() missing 1 required positional argument: 'integration_order'" + ] + } + ], + "source": [ + "gal = galsim.Sersic(n=5, half_light_radius=0.2, flux=1)\n", + "conv = galsim.Convolve((gal,psf))\n", + "sim_ngrid = batsim.sim._resolve_simulation_ngrid(gal, psf, scale)\n", + "supersample = batsim.sim._determine_supersampling(gal, scale)\n", + "\n", + "FineGrid = batsim.sim._make_fine_grid(\n", + " conv, scale, sim_ngrid, supersample, pad\n", + ")\n", + "fine_ngrid = FineGrid.fine_ngrid\n", + "fine_compact = FineGrid.fine_compact\n", + "print(supersample, fine_ngrid, fine_compact)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5de0fba0", + "metadata": {}, + "outputs": [], + "source": [ + "cosmos = galsim.COSMOSCatalog()\n", + "inds = np.arange(len(cosmos))\n", + "galaxies = cosmos.makeGalaxy(index=inds, gal_type=\"parametric\")\n", + "\n", + "# # Determine grid size\n", + "# supersamples = np.empty((len(cosmos)))\n", + "# fine_ngrids = np.empty((len(cosmos)))\n", + "# fine_compacts = np.empty((len(cosmos)))\n", + "# for i, gal in tqdm(enumerate(galaxies)):\n", + "# sim_ngrid = batsim.sim._resolve_simulation_ngrid(gal, psf, scale)\n", + "# supersamples[i] = batsim.sim._determine_supersampling(gal, scale)\n", + "\n", + "# FineGrid = batsim.sim._make_fine_grid(\n", + "# gal, scale, sim_ngrid, supersamples[i], pad\n", + "# )\n", + "# fine_ngrids[i] = FineGrid.fine_ngrid\n", + "# fine_compacts[i] = FineGrid.fine_compact" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "batsim-dev", + "language": "python", + "name": "python3" + }, + "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.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/dev/test_block_integration.ipynb b/notebooks/dev/test_block_integration.ipynb new file mode 100644 index 0000000..a462deb --- /dev/null +++ b/notebooks/dev/test_block_integration.ipynb @@ -0,0 +1,221 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7bb22371", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ['OMP_NUM_THREADS'] = '1'\n", + "\n", + "import galsim\n", + "import batsim\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from parallelbar import progress_starmap\n", + "\n", + "from tqdm import tqdm\n", + "from time import time\n", + "\n", + "from importlib import reload\n", + "reload(batsim)\n", + "\n", + "np.random.seed(14)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "098af93b", + "metadata": {}, + "outputs": [], + "source": [ + "n_gals = 1000\n", + "scale = 0.2\n", + "nn = 64\n", + "\n", + "cosmos = galsim.COSMOSCatalog()\n", + "inds = np.random.choice(len(cosmos), n_gals, replace=False)\n", + "gal_list = [cosmos.makeGalaxy(index=i, gal_type='parametric') for i in inds]\n", + "\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "\n", + "# Extract parameters for each galaxy\n", + "hlrs = np.zeros(n_gals)\n", + "sersic_inds = np.zeros(n_gals)\n", + "for i, j in enumerate(inds):\n", + " rec = cosmos.getParametricRecord(j)\n", + " if bool(rec['use_bulgefit']):\n", + " hlrs[i] = rec['hlr'][2]\n", + " sersic_inds[i] = 0\n", + " else:\n", + " hlrs[i] = rec['hlr'][0]\n", + " sersic_inds[i] = rec['sersicfit'][2]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "90978a0b", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5f0c422c0e5c4a2ab737ca19ceb57434", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "DONE: 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "residuals = np.zeros(len(galsim_images))\n", + "perc_residuals = np.zeros(len(galsim_images))\n", + "for i in range(len(galsim_images)):\n", + " residuals[i] = abs(galsim_images[i] - batsim_images[i]).max()\n", + " perc_residuals[i] = 100 * residuals[i] / galsim_images[i].max()\n", + "\n", + "# estimate fraction with sub-% residuals\n", + "frac_sub_1perc = np.mean(perc_residuals < 1)\n", + "print(f'Fraction of galaxies with <1% residuals: {frac_sub_1perc:.4f}')\n", + "\n", + "plt.figure()\n", + "plt.subplots(1, 2, figsize=(12, 5))\n", + "plt.subplot(1, 2, 1)\n", + "plt.scatter(hlrs, perc_residuals, alpha=0.5)\n", + "plt.xlabel('HLR')\n", + "plt.ylabel('Percentage residuals')\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(sersic_inds, perc_residuals, alpha=0.5)\n", + "plt.xlabel('Sersic index')\n", + "plt.ylabel('Percentage residuals')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "batsim-dev", + "language": "python", + "name": "python3" + }, + "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.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/examples/1_Rendering_Simple_Galaxies/simple_render_example.ipynb b/notebooks/examples/1_Rendering_Simple_Galaxies/simple_render_example.ipynb new file mode 100644 index 0000000..ba3d02d --- /dev/null +++ b/notebooks/examples/1_Rendering_Simple_Galaxies/simple_render_example.ipynb @@ -0,0 +1,199 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 16, + "id": "b3355f98", + "metadata": {}, + "outputs": [], + "source": [ + "import batsim\n", + "import galsim\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.rcParams['font.family'] = 'serif'\n", + "plt.rcParams['font.serif'] = ['cmr10']\n", + "plt.rcParams['mathtext.fontset'] ='cm'\n", + "plt.rcParams['figure.facecolor'] = 'white'\n", + "plt.rc('axes', unicode_minus=False)\n", + "plt.rc('axes.formatter', use_mathtext=True)" + ] + }, + { + "cell_type": "markdown", + "id": "e926a1ba", + "metadata": {}, + "source": [ + "In this example notebook, we cover calling the BATSim renderer without providing a transform. \n", + "\n", + "Given BATSim's function as a non-affine shear renderer, this example is not representative of real usage, but is intended to provide an overview of how to use the renderer and some of the less advanced configuration options that are available through it.\n", + "\n", + "BATSim is intended to operate as an extension to Galsim, and as such, its renderer is designed to operate on Galsim objects. We recomend familiarising yourself with Galsim's API if necessary, as our examples assume existing experience running Galsim.\n", + "\n", + "https://galsim-developers.github.io/GalSim/_build/html/index.html" + ] + }, + { + "cell_type": "markdown", + "id": "d2603f27", + "metadata": {}, + "source": [ + "## The Simplest Render\n", + "\n", + "First, let's directly compare drawing a galaxy with BATSim to Galsim. We define our galaxy object, image size, and pixel scale.\n", + "\n", + "The workhorse function of BATSim is ``batsim.simulate_galaxy()`` this function applies coordinate transforms, determines the necessary internal rendering resolution (which is typically 4x-64x higher than the requested resolution), samples the galaxy profile, applys any convolutions, and returns us the final image at the requested size and pixel scale in the form of a numpy array.\n", + "\n", + "Currently, BATSim only supports square images." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7692ec0d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define our galaxy profile as a GSObject\n", + "gal = galsim.Sersic(half_light_radius=0.1, n=2)\n", + "\n", + "# Define image parameters\n", + "ngrid = 64 # number of pixels along x and y. Total pixels is n_grid*n_grid\n", + "pix_scale = 0.2 # number of arcseconds each pixels should cover\n", + "\n", + "# Call BATSim's renderer, returns np.array\n", + "gal_image = batsim.simulate_galaxy(\n", + " gal_obj=gal, # pass the GSObject profile\n", + " ngrid=ngrid, # If None, BATSim chooses a sensible size based on scale\n", + " scale=pix_scale # pixel scale of the FINAL output image\n", + ")\n", + "\n", + "# Call BATSim's plotting utility to get a nicely normalised image\n", + "fig = batsim.pltutil.make_plot_image(gal_image)" + ] + }, + { + "cell_type": "markdown", + "id": "d3f19392", + "metadata": {}, + "source": [ + "If desired, and as would typically be the case, a PSF can also be provided which will be convolved with the image" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "d2bb957e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define PSF\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "\n", + "# Call renderer passing PSF as well\n", + "gal_with_psf_image = batsim.simulate_galaxy(\n", + " gal_obj=gal,\n", + " psf_obj=psf,\n", + " ngrid=None, # This time lets omit it to see what BATSim chooses\n", + " scale=pix_scale\n", + ")\n", + "\n", + "# Call BATSim's plotting utility to get a nicely normalised image\n", + "fig = batsim.pltutil.make_plot_image(gal_with_psf_image)" + ] + }, + { + "cell_type": "markdown", + "id": "962bd686", + "metadata": {}, + "source": [ + "By default the BATSim renderer applies a pixel response function to the image. This is an additional top-hat smoothing kernel that accounts for the fact real detectors are composed of finite pixels with hard edges. If you wish to simulate images representative of an atypical detector with non-square pixels or a different response function, you can disable this through the ``draw_method`` argument." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b049a10d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define PSF\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "\n", + "# Call renderer passing PSF as well\n", + "gal_with_psf_image = batsim.simulate_galaxy(\n", + " gal_obj=gal,\n", + " psf_obj=psf,\n", + " ngrid=None, # This time lets omit it to see what BATSim chooses\n", + " scale=pix_scale,\n", + " draw_method=\"no_pixel\" # alternative is \"auto\", which applies pixel response\n", + ")\n", + "\n", + "# Call BATSim's plotting utility to get a nicely normalised image\n", + "fig = batsim.pltutil.make_plot_image(gal_with_psf_image)" + ] + }, + { + "cell_type": "markdown", + "id": "62a996fc", + "metadata": {}, + "source": [ + "It is important to note that, due to the nature of non-affine shear, BATSim's renderer is significantly slower than Galsim's. As such, for work like this where no transform is required, we recomend simply sticking to Galsim's own drawing methods." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "batsim-gpu", + "language": "python", + "name": "python3" + }, + "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.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/examples/2_Affine_Lensing/affine_lensing_example.ipynb b/notebooks/examples/2_Affine_Lensing/affine_lensing_example.ipynb new file mode 100644 index 0000000..7404a57 --- /dev/null +++ b/notebooks/examples/2_Affine_Lensing/affine_lensing_example.ipynb @@ -0,0 +1,256 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 44, + "id": "f0436c8a", + "metadata": {}, + "outputs": [], + "source": [ + "import batsim\n", + "import galsim\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from time import time\n", + "\n", + "plt.rcParams['font.family'] = 'serif'\n", + "plt.rcParams['font.serif'] = ['cmr10']\n", + "plt.rcParams['mathtext.fontset'] ='cm'\n", + "plt.rcParams['figure.facecolor'] = 'white'\n", + "plt.rc('axes', unicode_minus=False)\n", + "plt.rc('axes.formatter', use_mathtext=True)" + ] + }, + { + "cell_type": "markdown", + "id": "191b981a", + "metadata": {}, + "source": [ + "For completeness and validation purposes, we provide an affine lensing transform object within BATSim. We will use this to demonstrate what transform objects are and how they are used by ``batsim.simulate_galaxy()``.\n", + "\n", + "We start by defining our transform object. Note that this implementation is equivalent to ``galsim.Lens()`` as it includes lensing convergence and magnification, unlike ``galsim.Shear()``, which uses the reduced shear formalism." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "82f8b74e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transformed coordinates:\n", + "[[0.96 1.56]\n", + " [2.36 1.36]]\n", + "Inverse Lensing Matrix:\n", + "[[0.72 0.12]\n", + " [0.12 1.12]]\n" + ] + } + ], + "source": [ + "# Define shear components and convergence. We use exagerated values for clearly\n", + "# visible effects.\n", + "gamma1 = 0.2\n", + "gamma2 = -0.12\n", + "kappa = 0.08\n", + "\n", + "# Instantiate LensTransform\n", + "lens_transform = batsim.LensTransform(\n", + " gamma1=gamma1,\n", + " gamma2=gamma2,\n", + " kappa=kappa\n", + ")\n", + "\n", + "# Every transfrom class has a transform method which implements the INVERSE\n", + "# coordinate transform. The renderer then samples flux from the inverse transformed \n", + "# coordinates to the original coordinate points, resulting in an image which appears \n", + "# to have been sheared according to the forward transform.\n", + "coords = np.array([[1,2],[2,1]])\n", + "coords_transformed = lens_transform.transform(coords)\n", + "print(\"Transformed coordinates:\") \n", + "print(coords_transformed)\n", + "\n", + "# Extract the INVERSE lensing matrix from the transform object\n", + "lens_mat = lens_transform.lens_mat\n", + "print(\"Inverse Lensing Matrix:\")\n", + "print(lens_mat)" + ] + }, + { + "cell_type": "markdown", + "id": "a6515f7f", + "metadata": {}, + "source": [ + "Now we have seen a little of how the transform object functions, let's actually apply it to a Galsim object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "acc971f0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rendering lensed and convolved galaxy took 0.143703 seconds\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define our galaxy profile as a GSObject\n", + "gal = galsim.Sersic(half_light_radius=1.3, n=1).withFlux(40)\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "\n", + "# Define image parameters\n", + "ngrid = 64 # number of pixels along x and y. Total pixels is n_grid*n_grid\n", + "pix_scale = 0.2 # number of arcseconds each pixels should cover\n", + "\n", + "# Call BATSim's renderer, returns np.array\n", + "start = time()\n", + "batsim_image = batsim.simulate_galaxy(\n", + " gal_obj=gal, # pass the GSObject profile\n", + " psf_obj=psf,\n", + " transform_obj=lens_transform,\n", + " ngrid=ngrid, # If None, BATSim chooses a sensible size based on scale\n", + " scale=pix_scale, # pixel scale of the FINAL output image\n", + ")\n", + "end = time()\n", + "print(f\"Rendering lensed and convolved galaxy took {end-start:3f} seconds\")\n", + "\n", + "# Call BATSim's plotting utility to get a nicely normalised image\n", + "fig = batsim.pltutil.make_plot_image(batsim_image)" + ] + }, + { + "cell_type": "markdown", + "id": "81e6c504", + "metadata": {}, + "source": [ + "The class based approach to transforms is inspired by Galsim's ``GSObjects``, which provide a unified way to represent a wide range of surface brightness profiles. It also makes it easier for users to define custom transforms which can then be directly passed to the renderer, but we will look at that in a later example...\n", + "\n", + "As a last step, let's have a quick look at how our BATSim sheared and rendered galaxy compares to one simulated entirely within Galsim." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8e1a5ec3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rendering lensed and convolved galaxy took 0.001887 seconds\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Convert gamma1, gamma2, and kappa to g1, g2, and mu for Galsim\n", + "g1 = gamma1 / (1.0 - kappa)\n", + "g2 = gamma2 / (1.0 - kappa)\n", + "mu = 1.0 / ((1.0 - kappa) ** 2 - gamma1**2 - gamma2**2)\n", + "\n", + "# Use galsim to lens un-convolved galaxy\n", + "gal_lensed = gal.lens(g1, g2, mu)\n", + "\n", + "# Convolve lensed galaxy with PSF\n", + "gal_conv = galsim.Convolve([gal_lensed, psf])\n", + "\n", + "# Draw and time\n", + "start = time()\n", + "galsim_image = gal_conv.drawImage(nx=ngrid, ny=ngrid, scale=pix_scale).array\n", + "end = time()\n", + "print(f\"Rendering lensed and convolved galaxy took {end-start:3f} seconds\")\n", + "\n", + "# Call BATSim's plotting utility to get a nicely normalised image\n", + "fig = batsim.pltutil.make_plot_image(galsim_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "bfd6b409", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GalSim flux: 50.13269424\n", + "BATSim flux: 50.13265991\n", + "Max abs residual: 2.593e-06\n", + "Max abs residual as % of max flux: 0.001%\n" + ] + } + ], + "source": [ + "# Look at residuals between images\n", + "residual = galsim_image - batsim_image\n", + "print(f\"GalSim flux: {galsim_image.sum():.8f}\")\n", + "print(f\"BATSim flux: {batsim_image.sum():.8f}\")\n", + "print(f\"Max abs residual: {abs(residual).max():.3e}\")\n", + "\n", + "perc_residual = 100 * abs(residual).max() / galsim_image.max()\n", + "print(f\"Max abs residual as % of max flux: {perc_residual:.3f}%\")" + ] + }, + { + "cell_type": "markdown", + "id": "d3ad3d99", + "metadata": {}, + "source": [ + "BATSim and Galsim lensed images agree at the hundredth of a percent level, but evidently BATSim's renderer is much much slower. As mentioned previously, this is currently an unfortunate reality of the necessity to start our renderer in real-space and aggresively supersample.\n", + "\n", + "Like in the previous no transform example, we suggest that for this type of work where only affine shear is required, the usual Galsim procedure is followed. BATSim should only be used in a production setting for non-affine shear rendering." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "batsim-gpu", + "language": "python", + "name": "python3" + }, + "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.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/examples/3_Intrinsic_Alignment/IA_model_G19_bestfit.pdf b/notebooks/examples/3_Intrinsic_Alignment/IA_model_G19_bestfit.pdf new file mode 100644 index 0000000..ae14cd2 Binary files /dev/null and b/notebooks/examples/3_Intrinsic_Alignment/IA_model_G19_bestfit.pdf differ diff --git a/notebooks/examples/3_Intrinsic_Alignment/IA_model_G19_quiver.pdf b/notebooks/examples/3_Intrinsic_Alignment/IA_model_G19_quiver.pdf new file mode 100644 index 0000000..245cbaf Binary files /dev/null and b/notebooks/examples/3_Intrinsic_Alignment/IA_model_G19_quiver.pdf differ diff --git a/notebooks/examples/3_Intrinsic_Alignment/IA_model_G19_quiver_residual.pdf b/notebooks/examples/3_Intrinsic_Alignment/IA_model_G19_quiver_residual.pdf new file mode 100644 index 0000000..aa9ddcb Binary files /dev/null and b/notebooks/examples/3_Intrinsic_Alignment/IA_model_G19_quiver_residual.pdf differ diff --git a/notebooks/examples/IA_transform.ipynb b/notebooks/examples/3_Intrinsic_Alignment/IA_transform.ipynb similarity index 100% rename from notebooks/examples/IA_transform.ipynb rename to notebooks/examples/3_Intrinsic_Alignment/IA_transform.ipynb diff --git a/notebooks/examples/3_Intrinsic_Alignment/intrinsic_alignment_example.ipynb b/notebooks/examples/3_Intrinsic_Alignment/intrinsic_alignment_example.ipynb new file mode 100644 index 0000000..d0eb70a --- /dev/null +++ b/notebooks/examples/3_Intrinsic_Alignment/intrinsic_alignment_example.ipynb @@ -0,0 +1,420 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "f657b961", + "metadata": {}, + "outputs": [], + "source": [ + "import batsim\n", + "import galsim\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from scipy.optimize import curve_fit\n", + "\n", + "plt.rcParams['font.family'] = 'serif'\n", + "plt.rcParams['font.serif'] = ['cmr10']\n", + "plt.rcParams['mathtext.fontset'] ='cm'\n", + "plt.rcParams['figure.facecolor'] = 'white'\n", + "plt.rc('axes', unicode_minus=False)\n", + "plt.rc('axes.formatter', use_mathtext=True)" + ] + }, + { + "cell_type": "markdown", + "id": "a551376b", + "metadata": {}, + "source": [ + "Intrinsic alignment (IA) has been shown previously to exhibit increasing amplitude with galaxy radius (Georgiou+2019, Singh+Mandelbaum2015). The result of this, is that different shears will be measured depending on the sensitivty of a shear estimator to different radii within the galaxy.\n", + "\n", + "In order to represent this effect, BATSim's IA transform scales shear as a function of distance from the center of a galaxy. We base our model on the results of one of the previous studies." + ] + }, + { + "cell_type": "markdown", + "id": "3713df38", + "metadata": {}, + "source": [ + "# Georgiou 2019 best-fit\n", + "\n", + "In this notebook, we carry out the best fit to the results of [Georgiou 2019](https://www.aanda.org/articles/aa/full_html/2019/08/aa35810-19/aa35810-19.html) which is used to set the default parameters of our non-affine IA shear model.\n", + "\n", + "We then go on to show a few examples of how different parameter choices change the resulting shear profile." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d9e12e12", + "metadata": {}, + "outputs": [], + "source": [ + "# Parameters from G19\n", + "r_scale = np.array([0.5, 1.0, 1.25, 1.5, 2.0]) # weight function of estimator\n", + "r_iso = np.array([1.33, 2.66, 3.32, 3.99, 5.32]) # isophote radius (3-sigma)\n", + "A_obs = np.array([2.17e-4, 2.95e-4, 4.33e-4, 5.92e-4, 7.84e-4]) # measured alignment amplitude\n", + "sig_A = np.array([8.5e-5, 9.2e-5, 1.06e-4, 1.20e-4, 1.63e-4]) # error in alignment amplitude\n", + "\n", + "r_wf = r_scale * r_iso\n", + "\n", + "# Construct power law model to fit to the data\n", + "def A_model(r, A0, beta):\n", + " return A0 * r**beta\n", + "\n", + "# Fit the model to the data\n", + "popt, pcov = curve_fit(A_model, r_scale, A_obs, sigma=sig_A, absolute_sigma=True)\n", + "\n", + "r_scale_fit = np.linspace(0.5, 2.0, 100)\n", + "A_fit = A_model(r_scale_fit, *popt)\n", + "A_upper = A_model(r_scale_fit, *(popt + np.sqrt(np.diag(pcov))))\n", + "A_lower = A_model(r_scale_fit, *(popt - np.sqrt(np.diag(pcov))))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "aa50c64a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.errorbar(r_scale, A_obs, yerr=sig_A, marker='o', capsize=5, label='G19 data', color='black', ls='--')\n", + "plt.plot(r_scale_fit, A_fit, label=f'Best fit: A0={popt[0]:.2e}, beta={popt[1]:.2f}', color='blue')\n", + "plt.fill_between(r_scale_fit, A_lower, A_upper, color='blue', alpha=0.2, label='1-sigma uncertainty')\n", + "plt.xlabel(r'$r_{\\rm wf}/r_{\\rm iso}$', fontsize=14)\n", + "plt.ylabel(r'Alignment amplitude (A)', fontsize=14)\n", + "#plt.title('Best Fit of Alignment Amplitude vs Weight Function Scale')\n", + "plt.tick_params(axis='both', which='major', labelsize=12)\n", + "plt.legend(fontsize=12)\n", + "plt.savefig('IA_model_G19_bestfit.pdf', dpi=300, bbox_inches='tight')" + ] + }, + { + "cell_type": "markdown", + "id": "4b2ba83e", + "metadata": {}, + "source": [ + "## Applying G19 fit to simulations\n", + "\n", + "As discussed in the release paper, we make a phenonmenological reparameterisation of the model fit to G19 in order to use it within BATSim for generating shear values. This is done by replacing $r_{wf}/r_{iso}$ with $r/r_{hlr}$ where $r$ is distance from the centre of the galaxy and $r_{hlr}$ is half-light radius.\n", + "\n", + "It is important to note that typically $r_{iso}$ is larger than $r_{hlr}$. As such, the model employed in BATSim is intended only to reproduce the observed trend in alignment signal with galaxy radius. The functional form of this model is\n", + "\n", + "$$A_{\\rm IA}(r/r_{hlr}) = A_0 \\times (r/r_{hlr})^b$$\n", + "\n", + "we then take\n", + "\n", + "$$|g| = A_{\\rm IA}$$\n", + "\n", + "For simplicity and to clearly demonstrate the shear pattern created by this model, we show the shear values produced by the model on a quiver plot grid and apply the transfrom to an initially circular galaxy then plot the galaxy and isophotes to illustrate increasing ellipticity with radius." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e9714198", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set image parameters\n", + "pix_scale = 0.2\n", + "npix = 64\n", + "\n", + "# Set galaxy hlr to be used in the IA model\n", + "hlr = 1.0\n", + "pos_angle = -45.0\n", + "\n", + "# Construct IA transfrom object. We scale the amplitude\n", + "# by two orders of magnitude to make the effect more\n", + "# obvious visually.\n", + "ia_transform = batsim.IATransform(\n", + " A=popt[0]*100,\n", + " scale=pix_scale,\n", + " hlr=hlr,\n", + " phi=np.radians(pos_angle)\n", + ")\n", + "\n", + "# Construct coordinate stamp. This is the internal function used to set-up \n", + "# coordinate grids during rendering, but we expose it via the public API\n", + "# as it can be useful for other purposes and validation tests.\n", + "stamp = batsim.Stamp(nn=npix, scale=pix_scale)\n", + "coords = stamp.coords\n", + "x = coords[0]\n", + "y = coords[1]\n", + "\n", + "# Get shear values at each set of coords from IA transfrom object\n", + "g1, g2 = ia_transform.get_g1g2(x, y)\n", + "\n", + "# Determine the size and orientation of the arrows to plot\n", + "g_abs = np.hypot(g1, g2)\n", + "phi_plot = 0.5 * np.arctan2(g2, g1)\n", + "\n", + "u = g_abs * np.cos(phi_plot)\n", + "v = g_abs * np.sin(phi_plot)\n", + "\n", + "# Downsample to avoid plotting 4096 overlapping arrows.\n", + "step = 6\n", + "\n", + "# Quiver plot\n", + "fig, ax = plt.subplots(figsize=(7, 7))\n", + "\n", + "q = ax.quiver(\n", + " x[::step],\n", + " y[::step],\n", + " u[::step],\n", + " v[::step],\n", + " np.hypot(u[::step], v[::step]),\n", + " angles=\"xy\",\n", + " scale_units=\"xy\",\n", + " scale=0.4, # smaller scale produces longer arrows\n", + " width=0.004, # smaller width produces thinner arrows\n", + " cmap=\"inferno_r\",\n", + " pivot=\"middle\",\n", + ")\n", + "\n", + "ax.set_aspect(\"equal\")\n", + "ax.set_xlabel(r\"$x$\", fontsize=14)\n", + "ax.set_ylabel(r\"$y$\", fontsize=14)\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "cb = fig.colorbar(q, ax=ax, label=r\"$|g|$\")\n", + "cb.set_label(r\"$|g|$\", fontsize=14)\n", + "cb.ax.tick_params(labelsize=12)\n", + "fig.savefig('IA_model_G19_quiver.pdf', dpi=300, bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "fe80897f", + "metadata": {}, + "source": [ + "In this set-up, we set the alignment orientation to be towards the bottom left of the image. We use the default G19 best fit values. This results in peak shear values on the order of $10^{-3}$.\n", + "\n", + "The length and colour of the arrows in the quiver plot represent the strength of the shear." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "a7d2b5c4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Apply transform to a galaxy image and plot residuals\n", + "gal = galsim.Gaussian(half_light_radius=hlr)\n", + "\n", + "# Simulate galaxy image with IA transform using BATSim\n", + "gal_ia_image = batsim.simulate_galaxy(\n", + " gal_obj=gal,\n", + " transform_obj=ia_transform,\n", + " scale=pix_scale,\n", + " ngrid=npix\n", + ")\n", + "\n", + "# Call batsim plotting utilities to make nicely normalised plot\n", + "fig = batsim.pltutil.make_plot_image(gal_ia_image)\n", + "\n", + "# Plot isophotes\n", + "contours = np.geomspace(0.0001, 1, 10)\n", + "plt.contour(gal_ia_image, levels=contours, colors='black')" + ] + }, + { + "cell_type": "markdown", + "id": "2a51a664", + "metadata": {}, + "source": [ + "The alignment amplitude used here is highly exagerated, but the radial dependence of the shear can clearly be seen in the resulting image. The black contours are galaxy isophotes, which clearly increase in elliptiicty at large radii.\n", + "\n", + "Next let's change the parameters of our transform more, to see how it changes the resulting shear. First, we'll increase the value of the power, to give a greater gradient in shear as a function of radius." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "43a1173f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define new IATransform with different model parameters\n", + "ia_transform = batsim.IATransform(\n", + " A=popt[0]*100, # keep amplitude the same\n", + " beta=1.6, # increase power to give greater gradient in shear\n", + " scale=pix_scale,\n", + " hlr=hlr,\n", + " phi=np.radians(pos_angle)\n", + ")\n", + "\n", + "# Simulate galaxy image with IA transform using BATSim\n", + "gal_ia_image = batsim.simulate_galaxy(\n", + " gal_obj=gal,\n", + " transform_obj=ia_transform,\n", + " scale=pix_scale,\n", + " ngrid=npix\n", + ")\n", + "\n", + "# Call batsim plotting utilities to make nicely normalised plot\n", + "fig = batsim.pltutil.make_plot_image(gal_ia_image)\n", + "\n", + "# Plot isophotes\n", + "contours = np.geomspace(0.0001, 1, 10)\n", + "plt.contour(gal_ia_image, levels=contours, colors='black')" + ] + }, + { + "cell_type": "markdown", + "id": "3b8d312d", + "metadata": {}, + "source": [ + "Finally, let's look at how to apply shear to galaxies that are not at the image center. We'll shift our Galsim profile by 2 pixels in x and y. The ``center`` arguement of ``IATransform`` specifies where to move the shear field in the image. ``IATransform`` treats the image center as ``[0,0]`` and the center arguement specifes **coordinates in the image to center the shear field at rather than how far from the center to shift**. As such, be careful that wherever you are shifting the Galsim profile lines up with where you center the shear field" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "89147b44", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Shift galaxy center to illustrate how to move the shear field\n", + "gal_shift = gal.shift(dx=2.4,dy=1.3)\n", + "\n", + "# get galaxy centroid to make sure we place the IATransform correctly\n", + "center = gal_shift.centroid\n", + "\n", + "# Define new IATransform with different model parameters\n", + "ia_transform = batsim.IATransform(\n", + " A=popt[0]*100, # keep amplitude the same\n", + " beta=1.6, # increase power to give greater gradient in shear\n", + " scale=pix_scale,\n", + " hlr=hlr,\n", + " phi=np.radians(pos_angle),\n", + " center=[center.x, center.y] # re-center the shear field at the new galaxy center.\n", + ")\n", + "\n", + "# Simulate galaxy image with IA transform using BATSim\n", + "gal_ia_image = batsim.simulate_galaxy(\n", + " gal_obj=gal_shift,\n", + " transform_obj=ia_transform,\n", + " scale=pix_scale,\n", + " ngrid=npix\n", + ")\n", + "\n", + "# Call batsim plotting utilities to make nicely normalised plot\n", + "fig = batsim.pltutil.make_plot_image(gal_ia_image)\n", + "\n", + "# Plot isophotes\n", + "contours = np.geomspace(0.0001, 1, 10)\n", + "plt.contour(gal_ia_image, levels=contours, colors='black')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "batsim-gpu", + "language": "python", + "name": "python3" + }, + "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.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/examples/4_Flexion/flexion_example.ipynb b/notebooks/examples/4_Flexion/flexion_example.ipynb new file mode 100644 index 0000000..c551b25 --- /dev/null +++ b/notebooks/examples/4_Flexion/flexion_example.ipynb @@ -0,0 +1,414 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 13, + "id": "c0fcd6de", + "metadata": {}, + "outputs": [], + "source": [ + "import batsim\n", + "import galsim\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from matplotlib.colors import AsinhNorm\n", + "\n", + "plt.rcParams['font.family'] = 'serif'\n", + "plt.rcParams['font.serif'] = ['cmr10']\n", + "plt.rcParams['mathtext.fontset'] ='cm'\n", + "plt.rcParams['figure.facecolor'] = 'white'\n", + "plt.rc('axes', unicode_minus=False)\n", + "plt.rc('axes.formatter', use_mathtext=True)" + ] + }, + { + "cell_type": "markdown", + "id": "379a2776", + "metadata": {}, + "source": [ + "Gravitational flexion is used to describe the higher order distortions that occur when the lensing field varies on the same scale as the size of the source galaxy, resulting in meanignful gradients in shear and convergence across the galaxy profile.\n", + "\n", + "Our flexion transform is based on the work of [Bacon+ 2006](https://arxiv.org/pdf/astro-ph/0504478) and functionally implements the coordinate transform\n", + "\n", + "$$\n", + "\\theta^\\prime_i\n", + "=\n", + "A_{ij}\\theta_j\n", + "+\n", + "\\frac{1}{2}\n", + "D_{ijk}\\theta_j\\theta_k\n", + "$$\n", + "\n", + "where $A_{ij}$ is the lensing matrix and $D_{ijk}$ are given by\n", + "\n", + "$$\n", + "D_{ij1}\n", + "=\n", + "-\\frac{1}{2}\n", + "\\begin{pmatrix}\n", + "3F_1+G_1 & F_2+G_2 \\\\\n", + "F_2+G_2 & F_1-G_1\n", + "\\end{pmatrix} \\\\\n", + "D_{ij2}\n", + "=\n", + "-\\frac{1}{2}\n", + "\\begin{pmatrix}\n", + "F_2+G_2 & F_1-G_1 \\\\\n", + "F_1-G_1 & 3F_2-G_2\n", + "\\end{pmatrix}.\n", + "$$\n", + "\n", + "As such, ``FlexionTransform`` is controlled using the usual lensing matrix parameters, $\\gamma_1, \\gamma_2, \\kappa$ plus additional flexion terms $F_1, F_2, G_1, G_2$.\n", + "\n", + "Using ``FlexionTransform`` is much the same as using the standard ``LensTransform``, just with added parameters. First, lets compare the two when the flexion terms are zero." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "0c334717", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total residual: 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define galaxy profile, psf, and image params\n", + "gal = galsim.Gaussian(half_light_radius=1.0)\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "\n", + "npix = 64 # pixels per side\n", + "pix_scale = 0.2 # arcseconds\n", + "\n", + "# Define shear components and convergence. We use exagerated values for clearly\n", + "# visible effects.\n", + "gamma1 = 0.2\n", + "gamma2 = -0.12\n", + "kappa = 0.08\n", + "\n", + "# Instantiate LensTransform\n", + "lens_transform = batsim.LensTransform(\n", + " gamma1=gamma1,\n", + " gamma2=gamma2,\n", + " kappa=kappa\n", + ")\n", + "\n", + "# Instantiate the FlexionTransform with zeroed flexion terms\n", + "flexion_transform = batsim.FlexionTransform(\n", + " gamma1=gamma1,\n", + " gamma2=gamma2,\n", + " kappa=kappa,\n", + " F1=0,\n", + " F2=0,\n", + " G1=0,\n", + " G2=0\n", + ")\n", + "\n", + "# Simulate a galaxy with both transforms\n", + "lens_gal = batsim.simulate_galaxy(\n", + " gal_obj=gal,\n", + " psf_obj=psf,\n", + " ngrid=npix,\n", + " scale=pix_scale,\n", + " transform_obj=lens_transform\n", + ")\n", + "\n", + "flex_gal = batsim.simulate_galaxy(\n", + " gal_obj=gal,\n", + " psf_obj=psf,\n", + " ngrid=npix,\n", + " scale=pix_scale,\n", + " transform_obj=flexion_transform\n", + ")\n", + "\n", + "# Compare the two with batsim pltutil\n", + "resid = lens_gal - flex_gal\n", + "fig = batsim.pltutil.make_plot_image(resid)\n", + "print(\"Total residual:\", resid.sum())" + ] + }, + { + "cell_type": "markdown", + "id": "f088916a", + "metadata": {}, + "source": [ + "Evidently, with the flexion terms set to zero, the transform simplifies to the usual affine, lensing transform. So let's see what happens when we give them values.\n", + "\n", + "$F_1$ and $F_2$ are associated with gradients in convergence, and as such, produce skewed, comet-like distortions, with $F_1$ controling horizontal distortions, and $F_2$ controling vertical ones." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9a3f3063", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set F1 and F2 to something non-zero\n", + "flexion_transform = batsim.FlexionTransform(\n", + " gamma1=gamma1,\n", + " gamma2=gamma2,\n", + " kappa=kappa,\n", + " F1=0.06,\n", + " F2=-0.04,\n", + " G1=0,\n", + " G2=0\n", + ")\n", + "\n", + "# Re-render with new transform\n", + "flex_gal = batsim.simulate_galaxy(\n", + " gal_obj=gal,\n", + " psf_obj=psf,\n", + " ngrid=npix,\n", + " scale=pix_scale,\n", + " transform_obj=flexion_transform\n", + ")\n", + "\n", + "# Compare the two with batsim pltutil\n", + "fig = batsim.pltutil.make_plot_image(flex_gal)" + ] + }, + { + "cell_type": "markdown", + "id": "8be8b7c0", + "metadata": {}, + "source": [ + "As we can see, the galaxy clearly starts to skew towards the right of the image. $G_1$ and $G_2$ produce arc-like distortions. Together they represent a spin-3 field, so it not easy to intiutively think about the direction or type of distortion each controls, but to oversimplify, $G_1$ defines a refernce pattern, and $G_2$ controls the rotation of that pattern." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "125fcdaf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set F1 and F2 to something non-zero\n", + "flexion_transform = batsim.FlexionTransform(\n", + " gamma1=gamma1,\n", + " gamma2=gamma2,\n", + " kappa=kappa,\n", + " F1=0,\n", + " F2=0,\n", + " G1=0.3,\n", + " G2=-0.02\n", + ")\n", + "\n", + "# Re-render with new transform\n", + "flex_gal = batsim.simulate_galaxy(\n", + " gal_obj=gal,\n", + " psf_obj=psf,\n", + " ngrid=npix,\n", + " scale=pix_scale,\n", + " transform_obj=flexion_transform\n", + ")\n", + "\n", + "# Compare the two with batsim pltutil\n", + "fig = batsim.pltutil.make_plot_image(flex_gal)" + ] + }, + { + "cell_type": "markdown", + "id": "2a45ffb1", + "metadata": {}, + "source": [ + "We can start to see an arc forming, but if we want to get some really unique transformations. To help make it clearer what each parameter does, let's plot an 8-figure panel" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3c3b64eb", + "metadata": {}, + "outputs": [], + "source": [ + "# Flexion amplitudes\n", + "F_amp = 0.3\n", + "G_amp = 0.3\n", + "\n", + "# Each dictionary supplies one non-zero flexion component\n", + "flexion_modes = [\n", + " (r\"$+F_1$\", dict(F1=+F_amp, F2=0.0, G1=0.0, G2=0.0)),\n", + " (r\"$-F_1$\", dict(F1=-F_amp, F2=0.0, G1=0.0, G2=0.0)),\n", + " (r\"$+F_2$\", dict(F1=0.0, F2=+F_amp, G1=0.0, G2=0.0)),\n", + " (r\"$-F_2$\", dict(F1=0.0, F2=-F_amp, G1=0.0, G2=0.0)),\n", + " (r\"$+G_1$\", dict(F1=0.0, F2=0.0, G1=+G_amp, G2=0.0)),\n", + " (r\"$-G_1$\", dict(F1=0.0, F2=0.0, G1=-G_amp, G2=0.0)),\n", + " (r\"$+G_2$\", dict(F1=0.0, F2=0.0, G1=0.0, G2=+G_amp)),\n", + " (r\"$-G_2$\", dict(F1=0.0, F2=0.0, G1=0.0, G2=-G_amp)),\n", + "]\n", + "\n", + "flexion_images = []\n", + "\n", + "for title, components in flexion_modes:\n", + " flexion_transform = batsim.FlexionTransform(\n", + " gamma1=0.0,\n", + " gamma2=0.0,\n", + " kappa=0.0,\n", + " **components, # parse flexion parameters\n", + " )\n", + "\n", + " flex_gal = batsim.simulate_galaxy(\n", + " gal_obj=gal,\n", + " psf_obj=psf,\n", + " ngrid=npix,\n", + " scale=pix_scale,\n", + " transform_obj=flexion_transform,\n", + " )\n", + "\n", + " # Support either GalSim Image objects or array-like outputs.\n", + " image = (\n", + " flex_gal.array\n", + " if hasattr(flex_gal, \"array\")\n", + " else flex_gal\n", + " )\n", + "\n", + " # Convert CuPy arrays to NumPy if necessary.\n", + " if hasattr(image, \"get\"):\n", + " image = image.get()\n", + "\n", + " flexion_images.append(np.asarray(image))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "8eb538a6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use one normalization across all panels so brightness differences remain\n", + "# meaningful.\n", + "vmax = max(image.max() for image in flexion_images)\n", + "\n", + "norm = AsinhNorm(\n", + " linear_width=0.01 * vmax,\n", + " vmin=0.0,\n", + " vmax=vmax,\n", + ")\n", + "\n", + "# Display coordinates in arcseconds relative to the image centre.\n", + "half_width = 0.5 * npix * pix_scale\n", + "extent = [\n", + " -half_width,\n", + " +half_width,\n", + " -half_width,\n", + " +half_width,\n", + "]\n", + "\n", + "fig, axes = plt.subplots(\n", + " 2,\n", + " 4,\n", + " figsize=(12, 6),\n", + " sharex=True,\n", + " sharey=True,\n", + " constrained_layout=True,\n", + ")\n", + "\n", + "for ax, (title, _), image in zip(\n", + " axes.flat,\n", + " flexion_modes,\n", + " flexion_images,\n", + "):\n", + " artist = ax.imshow(\n", + " image,\n", + " origin=\"lower\",\n", + " extent=extent,\n", + " cmap=\"RdYlBu_r\",\n", + " norm=norm,\n", + " interpolation=\"nearest\",\n", + " )\n", + "\n", + " ax.set_title(title)\n", + " ax.set_aspect(\"equal\")\n", + "\n", + "# Only label the outer axes.\n", + "for ax in axes[-1, :]:\n", + " ax.set_xlabel(r\"$x$ [arcsec]\")\n", + "\n", + "for ax in axes[:, 0]:\n", + " ax.set_ylabel(r\"$y$ [arcsec]\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f3ab9bef", + "metadata": {}, + "source": [ + "As with any non-affine transform, it is important you define the center of the shear field appropraitely relative to the center of the galaxy. As seen previously with ``IATransform``, this is done using the ``center`` argument." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "batsim-gpu", + "language": "python", + "name": "python3" + }, + "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.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/examples/5_Custom_Transforms/custom_transform_example.ipynb b/notebooks/examples/5_Custom_Transforms/custom_transform_example.ipynb new file mode 100644 index 0000000..01a8ab1 --- /dev/null +++ b/notebooks/examples/5_Custom_Transforms/custom_transform_example.ipynb @@ -0,0 +1,233 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "29ea688e", + "metadata": {}, + "outputs": [], + "source": [ + "import batsim\n", + "import galsim\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.rcParams['font.family'] = 'serif'\n", + "plt.rcParams['font.serif'] = ['cmr10']\n", + "plt.rcParams['mathtext.fontset'] ='cm'\n", + "plt.rcParams['figure.facecolor'] = 'white'\n", + "plt.rc('axes', unicode_minus=False)\n", + "plt.rc('axes.formatter', use_mathtext=True)" + ] + }, + { + "cell_type": "markdown", + "id": "ca99355f", + "metadata": {}, + "source": [ + "Currently, BATSim only provides two types of non-affine transform, however, the renderer has intentionally been designed to allow users to define and provide their own transforms.\n", + "\n", + "Any user defined transforms should inherit from the base class ``batsim.Transform``. This base class handles backend, data type and centering management. The user defined class should provide a ``_transform_relative()`` method which accepts a ``(2, n)`` array of image coordinates and returns the **inverse transform** of these coordinates.\n", + "\n", + "This is because BATSim uses a backward mapping for its renderer. Given coordinates\n", + "$x$ on the regular output-image grid, ``transform(x)`` returns coordinates\n", + "$u$ at which the source surface-brightness profile should be evaluated:\n", + "\n", + "$$I_{\\rm output}(x) = I_{\\rm source}(u)$$\n", + "\n", + "For a locally affine transformation with forward geometric matrix $\\textbf{M}$, a source\n", + "feature at $u$ appears at\n", + "\n", + "$$x = \\textbf{M} \\times u.$$\n", + "\n", + "The corresponding BATSim coordinate transform must therefore return\n", + "\n", + "$$u = inv(\\textbf{M}) \\times x.$$\n", + "\n", + "Although the inverse matrix is used to sample the source profile, visible\n", + "features undergo the forward transformation. For example, a source feature\n", + "at $u_0$ appears where\n", + "\n", + "$$inv(\\textbf{M}) \\times x = u_0$$\n", + "\n", + "which implies\n", + "\n", + "$$x = \\textbf{M} \\times u_0.$$\n", + "\n", + "This backward, or pull-based, convention evaluates the source profile once\n", + "for every output location and avoids the gaps and overlaps that can occur\n", + "when source samples are pushed forwards onto an output grid." + ] + }, + { + "cell_type": "markdown", + "id": "f118948b", + "metadata": {}, + "source": [ + "## Custom Transform Example: Pinwheel Transform\n", + "\n", + "In order to illustrate how users should define custom transforms, we are going to define a non-affine transform class which will turn a centred, circular source into a pinwheel with radially dependent rotation of its isophotes." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a091a38a", + "metadata": {}, + "outputs": [], + "source": [ + "# As mentioned previously, a transform object is provided in the form of a Python class\n", + "class PinwheelTransform(batsim.Transform): # inherit backend methods from base class\n", + " \"\"\"\n", + " Apply a rotating, radius-dependent shear to produce twisted isophotes.\n", + "\n", + " Parameters\n", + " ----------\n", + " radius : float\n", + " Characteristic radius at which the shear reaches ``g_max``.\n", + " g_max : float, optional\n", + " Maximum reduced-shear amplitude. Must satisfy ``0 <= g_max < 1``.\n", + " turns : float, optional\n", + " Number of half-turns made by the shear position angle over one\n", + " characteristic radius. For example, ``turns=0.5`` rotates the\n", + " orientation by 90 degrees between ``r=0`` and ``r=radius``.\n", + " phi0 : float, optional\n", + " Shear position angle at the centre, in radians.\n", + " **kwargs\n", + " Arguments forwarded to :class:`batsim.BaseTransform`.\n", + " \"\"\"\n", + "\n", + " # Inititalise with fixed transform parameters\n", + " def __init__( \n", + " self,\n", + " radius,\n", + " g_max=0.35,\n", + " turns=0.5,\n", + " phi0=0.0,\n", + " **kwargs,\n", + " ):\n", + " super().__init__(**kwargs)\n", + "\n", + " if radius <= 0:\n", + " raise ValueError(\"radius must be positive.\")\n", + "\n", + " if not 0 <= g_max < 1:\n", + " raise ValueError(\"g_max must satisfy 0 <= g_max < 1.\")\n", + "\n", + " self.radius = radius\n", + " self.g_max = g_max\n", + " self.turns = turns\n", + " self.phi0 = phi0\n", + "\n", + " # This is the heart of the transform object, which computes the\n", + " # INVERSE mapped coordinates to be sampled onto the image grid\n", + " # by BATSim. It should accept an array of coordinates, a backend,\n", + " # and a datatype\n", + " def _transform_relative(self, coords, xp, dtype):\n", + " x_output, y_output = coords\n", + "\n", + " # Technically a backend and datatype does not need to be passed,\n", + " # but if the backend and dtype are hard coded, the same backend\n", + " # and dtype MUST be specified in simulate_galaxy()\n", + " radius = xp.asarray(self.radius, dtype=dtype)\n", + " g_max = xp.asarray(self.g_max, dtype=dtype)\n", + " turns = xp.asarray(self.turns, dtype=dtype)\n", + " phi0 = xp.asarray(self.phi0, dtype=dtype)\n", + "\n", + " r = xp.sqrt(x_output**2 + y_output**2)\n", + " radial_ratio = r / radius\n", + "\n", + " # Smoothly increase from zero at the centre, reach g_max at\n", + " # r=radius, and decay again at large radius.\n", + " g_abs = (\n", + " g_max\n", + " * radial_ratio\n", + " * xp.exp(1.0 - radial_ratio)\n", + " )\n", + "\n", + " # Rotate the local shear position angle with radius.\n", + " phi = phi0 + turns * xp.pi * radial_ratio\n", + "\n", + " g1 = g_abs * xp.cos(2.0 * phi)\n", + " g2 = g_abs * xp.sin(2.0 * phi)\n", + "\n", + " # Backward mapping through the inverse local shear matrix.\n", + " inv_norm = xp.sqrt(1.0 - g1**2 - g2**2)\n", + "\n", + " x_prime = (\n", + " (1.0 - g1) * x_output - g2 * y_output\n", + " ) / inv_norm\n", + "\n", + " y_prime = (\n", + " -g2 * x_output + (1.0 + g1) * y_output\n", + " ) / inv_norm\n", + "\n", + " return xp.stack([x_prime, y_prime], axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d3b4617", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaUAAAGwCAYAAAAJyXqGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAC4FklEQVR4nO29Dbh0Z1Ue/OyfmTnnffPmlRgbCgkxAvE3YJTESOWnlRaiUP+IUqxiaE0ptRSDCkFb4PKLCb+teLVFUTStEW1BvaRFEK+aRAOJqRVigz9YEiFCEtOS5P07Z2b27O+61/OsZ6/9zLP37Jkz55w5c9YNk9mzZ8+evWfOu+9Z97rXWklZlqVRKBQKhWIFkO73ASgUCoVCwVBSUigUCsXKQElJoVAoFCsDJSWFQqFQrAyUlBQKhUKxMlBSUigUCsXKQElJoVAoFCsDJSWFQqFQrAzy/T4AhaIrTp8+bT71qU+Zhx9+2Dzzmc80m5ubS/3wRqOR+bM/+zPa/9Oe9jTzxV/8xXPvA6+977776Fif/exnL/X4FIrDAI2UFFH8t//238yVV15p8jw3x44dM9/3fd9nfuAHfsB813d9l3nuc59rfvqnf9qMx+Pa9ueee675+Mc/vmuf6P33329uvPFG87znPc88+OCDS9//F77wBfPv//2/N3/v7/098yd/8icL7eOP/uiPzKte9Srz/d///Us/vnXE3Xffba6++mrzile8gv7GFAqDNkMKRROe9axnld/yLd9SW/fII4+UT33qU8vv/d7v9es++MEPln/7b//t8uMf//iufpjj8Rhtscp77713197j/PPPL3/v935v4df/7u/+bnnhhReWq4Z/9a/+VblKKIqCPuuPfvSj5e///u+XL3vZy/b7kBQrAI2UFK1I09QkSVJbd/z4cfpVe/PNN5s//uM/pnWIqj73uc+Zpz/96bv6iWZZtqv7X8Z77MUxLiJN3nHHHWaV8Nd//dcU/X7DN3yD+aZv+ibzS7/0S/t9SIoVgJKSYiGcd955dP+Xf/mX+gmuOP7f//t/5tprrzUPPPCAWSUUReF/+CgUDDU6KBbC5z//ebqYfO3Xfq156KGHzD/6R//IfPrTnza//Mu/bP7O3/k7FEX95E/+JF14fvVXf9V8+MMfNo899pj53//7f9NziLZ++7d/2/zIj/yI+eQnP2n+wT/4B+bVr361ec1rXkNmgx/8wR80P/uzP2te/OIXm/e///2UR/rIRz7i3x9R2X/6T/+JorjbbrvNvOMd7zCXXHKJf/5DH/qQee9732ue/OQn0/7+9b/+1+Yrv/Ir6Tkc7+te9zpz/vnnm7/5m7+h6A45jXnwW7/1W+bP//zP6Txwsf/oRz9K7ynxB3/wB+bWW281J06cMH/6p39q/vN//s/m7LPP9s/jmEHqyMXhfN7+9rfT/gCc+//9v/+X8naIRt/whjfQZ82ve+c732m+8Ru/kcwU/+N//A/K+73nPe+JHuu73vUu2gdMGMgLAvg8NjY2zEtf+lJ6Dt8JIqn3ve999Ll93dd9HX3eOK9+v2/+5//8n+Z7vud7zHd/93fT63/nd37H/OiP/igdP17/X/7Lf6FjxTnjOJ70pCe1fk6/93u/R/k7AMd0zjnn0HkB/+7f/Tvzmc98howm9957r3nlK19Jx7O9vW2+7du+zdx5553mZ37mZ+jv5r//9/9ubrjhBsoHhn9vjz76KOUGf+VXfsX85m/+Jv3N/uEf/qG57LLLzOtf//q5vm/FHmK/9UPFauM5z3lO+a3f+q21dZ/5zGfKJz3pSeVP/uRP+nXb29vl4x73uFou5jd+4zfKc845p3z729/u1/3dv/t3yxtvvNE//vSnP005or/6q7/yj48ePVqeOXOGHk8mk/LFL35x7f2x/b/4F/+CchLAG9/4xvIFL3iBfx45ChzfY489Ro//+I//uPyyL/uycjgc0u3pT396+b73vc/v/+u+7uvKj3zkI/71yAe15ZROnz5dfuM3fqN/jH3IvBtei/P+D//hP/h1z33uc2vn/Za3vKV80Yte5B//9E//tM/R/emf/mmZ53l5xx130OP3v//95bnnnuvPB/i3//bf0jn9zu/8Dp3LN3/zN5dt+MVf/MVonms0GpVf/MVfXH7f930fPf6Gb/iG8kMf+hAtP/7xjy/f9ra30fL9999fHjlypLz99tv9a/G54rvA58+4+uqry1e84hWdPifkBcNL0A033FD+83/+z6fyl/hMGPj+nve855VbW1vld33Xd5U///M/3/r3hrzoJz7xCf+3i/f87Gc/2/p5KfYPGjcrZuKee+6hyAK3H/7hH6Zfpvj1+RM/8RN+G/yallEA8EVf9EUkHV111VV+HaIT2LoZF110kfn6r/96ioYARC4AfukC/+t//a+ok+1bvuVbvOxzwQUX1Pb5pje9yXz7t387RQ8AIgxsi0gA7/NXf/VX5ju/8zvpOURaWEZ00BVbW1vkGuPoAPuA404Cv9ylm0weI37xX3/99eQ6Y8DViP1NJhP6jBCRPOEJT/DniigH7yk/W0QCf//v/3167e/+7u+aRQB35VlnnUXRA4DP6PnPfz4t43Pn6POJT3wiLSPCkccAwK0Y+367fE4S+O4R7VxzzTV+HSIs5Cvl3xreF5b9wWBAkd0/+Sf/pPXvrdfr0fZ8HgAiMMVqQuU7xUxceOGFZMVeFLggM0AO0koOQKLDxQWEB1nouuuuI/KAVANygqQXguWh2D5ZcoIMxHjGM55B2+E5XMxgaZcEIo9xFh73uMfRMUKyxPvAIg+SkYAchYt97BhB8iCU3//93yeCBBAAfvM3f7M5efIkkftNN91kPvjBD5KMh/djs4LEl33Zl5llATJniDe/+c0klYHk8ZmBGMNjaPt+u3xOErfffjvVdzEZM/AY0ues4206nvCxzGcpVg9KSop9B0gJGj/yKogi8Mv30ksvpQsgfm3jgjgP8IsceSLkqELgVzt+Ocee6woQCIwDiCRAor/2a7/ma5u6kBu7Gb/1W7+ViIgBUgbwObzgBS8gUsbncuTIEcq9hcD6RYE8nCzuDfeFizbyTadOnTI/93M/R8QQ5syW/TkxUeA9Jc6cOTP1Q2Yn565Ybah8p9h3POUpTyFpCMl3SG1f+qVfSr+EkfhfxGKOiy2iEQnIOki44zkkvBEdSSCC6gok4d/ylrfQhRUEigsuJK+uluuv/uqvpkgqPEZIlSDlf/Nv/g3JVpCycPGVF2RElIva1PmiD4kQpNQGyJkwKcA0wJELH0fXY5j3c7riiivoOGEVl4DUBvOM4nBASUkx89eu9RbMvy0vh+ti+0O0hF/SyB8AyJO89a1v9Y/n2Scu5sh94KLIgFsNbi7kmnDxe/e7313rwgDC6nrOeA41NZCaGGh5xPmX2OvlOkhZkLF+4Rd+wcthiAjhgENUCJeibKEEckB+DIQFxxnvD+TSFV/+5V9OERiijv/zf/6P+aqv+qrasYX7wjEgokTOCcBnCXIIj0Heh+fZ5XMC+L2R74FUK6U6SIZwF0rZr+ncu/xtxLZRrBj20WShWGF84AMfIKcUXGC4YfnXf/3Xo9vCMYfnkyQpL7nkkvK3fuu3yl/+5V8uv/qrv5qcTnBA3X333eU//af/tDx+/Djd4NKS+LM/+7PyH//jf+wff+pTn6o9ZrcX9oV9wjEHtxXcYRdddBG9N1yCcIkBH/vYx8qrrrqq/LEf+7HyR3/0R8mRx3j00UfJIfbKV76yfO1rX1u+853vpPV4LZ/H13zN19A5xAAHF5xyP/ETP0Fusde//vXkbgPkeT//+c8v//zP/7z8/u///vLss8+eOu9f+qVfKl/ykpeUr3vd6+g4Pve5z9F6OBG/8zu/s3zVq15VvvWtb6V9/tRP/RQ5zj784Q+X73jHO+icsywrr7zySuqm0QX4HL77u7+b3gudMeT5Yn/y2OB+/OEf/uHye77ne8o3v/nNdBx4b3y/P/uzP0uuv8svv5zOE/foYvHjP/7j5NgbDAbld3zHd5T33Xdf4+eE11922WX+9fwdwKGH88N3c+2119Ix3XnnnfQc3Hbf/u3fXvb7fXofHNuJEyemPvfY3xuWsY7/ftq+X8X+IsF/9psYFQqFQqEAVL5TKBQKxcpASUmhUCgUKwMlJYVCoVCsDJSUFAqFQrEyUFJSKBQKxcpASUmhUCgUK4MD0WYIhXIo/EMBYThwTqFQKBSrD1QfYYwLOoS0zdA6EKQEQpqnYaZCoVAoVhOf/exnqXv7gSYlHkHw1V/7/5ks29jvw1EoFArFnCiKLXPPx3/CX88PNCmxZAdCyrKqJ5hCoVAoDhZmpWDU6KBQKBSKlYGSkkKhUChWBkpKCoVCoVgZKCkpFAqFYmWgpKRQKBSKlYGSkkKhUChWBkpKCoVCoVgZKCkpFAqFYmWgpKRQKBSKlYGSkkKhUCgONimdPHnSvPjFLzaf+cxn/Lo777zTvP3tbzdvfOMbzfOf/3xz6623+ufuuusu8+pXv9rcdNNN5pprrjH33nvvco5eoVAoFGuFuXvfvec97yEyev/732/e9ra30brTp0+b3/zN3zQ33HADPX7f+95nrrzySvOpT33KnHvuueaqq64i0jrvvPPMxRdfbK6++mpzyy23LP9sFAqFQnGgkZQYcrHIC5OEIp4v/dIvNXfffbd5+tOfTiT0lKc8hWZmnH322ebXfu3XzOMe9zjzmte8hrYBiqIwR48eNX/1V39FJBXD9vY23RiPPfYYja542te/TRuyKhQKxQFEUZwxd//Rj5hHH32U+GFXc0qXXHKJuf32282Tn/xkesyy3lOf+lRz3333mXPOOcdvm2UZtS6/5557GveHiOv48eP+prOUFAqF4nBgKaSEqOmZz3ymb0l+4403Ug7p0ksvNQ8//LDZ2KjPQMLjRx55pHF/1113HbEp3zAUSqFQKBTrj6XPU0LO6fGPf7x5y1veQo8R6YQKIYwSyDU1YTAY0E2hUCgUhwtLtYR/8IMfpJzRW9/6VsoJQbr7iq/4CvPQQw/5bbAeOacLL7xwmW+tUCgUijXA0kjptttuM5/73OfMi170IvPAAw+YD33oQ+bzn/+8efazn02kdP/999N2sIpfdtllSkoKhUKh2Ll89973vpcICHjd615HpPOCF7zAvPCFL6QISAL5oDzPqT7p+uuvN1dccQWR0s033zzv2yoUCoXiEGBhS/heApZw5KbUEq5QKBQHE3tqCVcoFAqFYhlQUlIoFArFykBJSaFQKBQrAyUlhUKhUKwMlJQUCoVCsTJQUlIoFArFykBJSaFQKBQrAyUlhUKhUKwMlJQUCoVCsTJQUlIoFArFykBJSaFQKBQrAyUlhUKhUKwMlJQUCoVCsTJQUlIoFArFykBJSaFQKBQrAyUlhUKhUKwMlJQUCoVCsTJQUlIoFArFykBJSaFQKBQrAyUlhUKhUKwMlJQUCoVCsTJQUlIoFArFykBJSaFQKBQrg3y/D0ChWAukyXL3NymXuz+F4oBASUmh2E/ymfd9lKwUaw4lJYViP8lnmcelhKVYAygpKQ4vVpV4FoUSlmINoKSkOHxYNzKa95w1olKsMJSUFOuPw0hCbVCCUqwwlJQU64VdJqBkBQiuXGako4YKxYpBSUmxHthFslgFImo7nqWSFAPvoTKfYh+gpKQ4uFgyWawa+ez0uHdMVirzKfYBSkqKg4MlkcayyCfJ9p7EyqLcH7IK96VRlGKXoKSkOFTYKSHtBxE1vf88BFXbR5osJ4pSYlLsApSUFKuNHZDIogS0bOLpehzzEkXTcXYhq6XkpVTeU+wClJQUh5qI5iWg3cw7LbrvkFAWIasdk5QSlGJJUFJSHDoy2nciyiLN+YvJwruTx9dGJnzeXSOpXXH1KRQzoKSk2H8sKrPtAhHNRUAxclkUi+wrQmSx458VSTWR1MLRk0ZNih1ASUlxoMioK2l0IaFO++pIFnttJyeCmHVsjrRmEVXss4oRVdeIrAYlKMWcUFJSrFVktJdktJ91TZ0Igs+hJaJqei0+x1k5KJX3FLsBJSXF3mJeI8JeEVELCS3rGPYDjRFVQxTVFEEtJXLSqEnRAUpKirUkotZ9LEhAS4vCVpGoIiS1JwSlZgpFACUlxdphrwlpt23o8xgSmkwN8rVR6Q2fSyDzNUl8s6S9uaBFuIoASkqKtYiOFiGiRUho1nF2Ipx0MddegpdN2q3jOyGM0nSPntoiJ42aFDuBkpJipclor4hoXhJqJZ8ZpLOj/FOWdYicpslrXrKakvh2SFCdJT2V8w49llhooVDMh53kX3abkLBtbHts20gqIKMGQuLXLdMQ0brPyLHI7WLnFz6/kDV+wQjTA9sdgLycYvegkZJiPaKjOXNF81w8W0loNy7MDfvp2iaoFpW4yIpfG0ZR80RQobyXmEmrKUKjJsUiUFJS7AzzdFXYQzKaNyraCREtVfpreA+7v8jKSI5pprkhy+rPCXJpArafkuJEHVSbrLcwOalD71BiIfnu5MmT5sUvfrH5zGc+49fddddd5tWvfrW56aabzDXXXGPuvffeTs8pDgcOEiHt1KCwI+lvXhOEfF1ErmuS7GrPidfK9U3bT53fDGlvKZKe4tBg7kjpPe95D5HR+9//fvO2t72N1m1vb5urrrrK3Hnnnea8884zF198sbn66qvNLbfc0vqc4gBjSRHSXhgZdizVdYyOdrK/tuPcqRHCR1guqpIRTFME1cXp1yTtxWS9JjOERk2KHZPSy1/+crp/05ve5Nfddttt5uyzzybSAS6//HJzxx13mAcffNDcfffdjc/xuhAgMtwYjz322LyHqTjAct1uRkZzb99iFmja37L20/kYu1qzG/JLTSTFRDOLoKakvYisF+acdiTpqUNvrbEU9919991nzjnnHP84yzJz7Ngxc88997Q+14QbbrjBHD9+3N8uuOCCZRym4oDkj/YDq3Y8izj35HbhtvL7mJLuxHq5bWy7KJk2ufbEj4hOxK1QLMvo8PDDD5uNjY3aOjx+5JFHWp9rwnXXXWeuvfbaWqSkxLTP6NqdewWcdcvJYyzWHXzqfWdIf10u1gtP0G3pa1ePbsR2qYuiXGRUi56cvCcjrDbn3qyoqcmQETveGrSH3lpjKaSEaKYsyykzxLnnnmseeOCBxueaMBgM6KY4HLmj1tfuQTeGzrOWWqKPKGZIdnPVCUX217ZvYFoicwuTOkFE5btZBMTPd3HuMTmJAtyuFnKV8w4fliLffcVXfIV56KGH/GPkg06cOGEuvPDC1ucU64NdK4Q9JJjZIaIh4mqT9RrlPOm2C2Q9uS4m3U0579y+2mQ9vz2Iyf3IaHIoLvS3oX8/a4WlRErPfvaziXjuv/9+c/7555tbb73VXHbZZUQ8T3ziExufU6ww9tPQsIOprq1GAEQFkfekX/zh6yBfBUQQbudlqKbziOyjU6QXXvTniaZa0GR8SGrmByfbcSTTs895iQ/yHkdOTurDtjBFdJH12qKmNoeeRkyHB3OT0nvf+15y2wGve93riJBe+cpXUg3S9ddfb6644goinptvvtm+QZ43Pqc4vPmjVsyqe9mrX8YtpNKEKMHNQCPRREwIU9t0zNPN6h4uZTsC1jd1fmiT7lqeq+WxzHwOvU7uPC22XQskZZjwWUHA6IC81dO+/m0myzb3+3DWG0sipN2oQer63ou+76I1Sq0k0THSmZK6gtfOel3b8cQQu7gzCXhLOJPCZDK1jqIj+fyM9eFztfcXIzNCM0aX456CWsZXEkVxxtz9Rz9iHn30USoTaoK2GVLsud17p5FOkwzXJVppk9x81CBfy9GCIIhwu3CfteeD18tji51HbF0XQpqnw4J9bWRdIN1V8lziJT65jXxeuvaw3kddTu6TxxkSS1PU1ObOmxkxKTEdWCgpKebCfhPSsmS0NmLbSY5p0fObV/ZbpDZoJtLMkcE0QVTOPCurIX8EgmLymDi5jnJLpp5X8kW4LZLerFzT3M48lfIOLJSUFEuV7FYJOyGmKDoQU+Nz4rWdj8u9pjNh7bBYdVbOZ2p7R0Dh50ivFZ0ieN8xUmHCiRFTePwLWcYVBw5KSocZS5Ts9jpKmul8a5PkIvsJ91WTjDrIeaGUx/trkvKiF9iWCG0qKgu3jRCSfD6d01o98e47996eLOvynZT2OPfE6y0K79SLOviCz0EW3IY99BaS8zRiOnBQUlLsictut6KsrtHOLHJq21djrqklzxTbR5f35u0aj2XO6E6SURMxYb0nocg6pgZLLhzhVPKdlOlsga4jIqzvxd14YTQlSYcfzxM1zf4gNM90UKCkdFixypIdLkRz1Cl1jZqWLulFoqZO+5oh5TUR0yzCmgchQYWPQUgxEptE5LvpjZJmqY+lOpAKPoNJQ5eHQM6LtSiau5ZJcSCgpHQYsUe27x2BfyEvQE7ALHdea3ueBpJrjIYCkpH7lvtaRMojAuILf0M+y2/T8lnFIqY0QqYpTAsFCCk8RXsMFD3l9p6WnbxH51mwfOfO27n1apKek+5Sl7OS6yqZL+LO62CAUClvPaCkdNiwyhHSEqKmRWS9tnzTXB0gOkZNTQaIcNup90HOBhGHiJZq2xTzEFPqSWhqu+i6zJMVCIrlPbpVGzkrdpVHmoxszz2Q02RkIx6bWyqicl5j1BM0dm1z5s2ESnkrDSUlxcLYs/EDC0RN+0JM8+y3RbabdQyLdI3ogtboEnKef0/f2dU+ShMzljKerKVyUp4lU1EYy/302L0HcmmSA2MdKWZETCrlHVwoKR0W7LHTbid5n0bIpHdHgprHpbe0iGmGM28qYgqkPCn7TcmAuGhHJD+/LS7yZDiwF+pJNH9Uj5L4eNryTNIIkTn5LnWEYyMoZ4zIjRnXuo4XlXzn7d/SVZd4iuPIyp9nBKFVfUdSnuag1rdLuOJwEdJKIOLKasNOfzk3vb6LdNQ6cyjWSie0SYfbdBhTHjteSSxNhIR7vknI9XzLckt+WS8losvzjNbnOR67zuRZapJeZtKe3ZbWua7i3HW81rWcO5oHncejHcc7tFxqxUH5Wz9k0EhJsadYhnNsp/mmRdB0zIvIaF1ceeG2s1x6bcfCZFSLfBDdtBx7p7omCRge6H2oVXh9PYwQiN5q3R+yKofEbr3AtVdO6q2cmvJHO5LyNGJaOSgprTNWNEKK5Qd2m5h2o4nrsvI6MeODdOpJYvLvLWS8qY7fouVPeJyWoGBUqD6zMEry62vFt2nUjUfLkAm5ponMD5ag7PqJN0QUjiAySH0jEhbpvpahkr3yGmqc/OemUt5aQklJse9YSr5pl7BXRb9dHXk1hATW0ssvlltqAxNSSEbVPuT6ibeSVxtCmiuNoRyRs5M7aQ6PEDXRMSM6chGSbHFU6+Ygapxou4bWRDt25SlWAkpK64oVvMDvqbTXEU3RztzRUdMwv46jJbpGXVMFtLJGampmkmktiCUJz1FGjLC8ISL6nIyisioCc+Qk2xTBEMGExbVNRDnFhHJNE3deac+4CKqZmHZNylMZb2WgpHTIsWrRyTKJqW0/88whWgYRtb1Ha4eJjtbxaH4JxawioqmLYHUJbxaaHHr+echyxsl2bowFpLuxIxkiRE9YEzMmt56Q74iQKice1nONkxm5miYaQFivb1pEylNiWm0oKa0jVoxodpWYFjA6LDoiYieENBfhdWxb1NZNvJK6TCOoCNZNmm1qK0QuugghyXwTW8JpuSbspSYH2XCUhJyVW5/yLCZy31XyHdUvue4OoQGCyCSNS3keDf3yJJSYVhtKSuuGPSKk3SrgBHZKSPNEI522XRIBzXrdrCm3C0WQfIFGt4WIEw+EAeMBP9fWtNXuprmWiZ9n+Y72O+YWd1XERLkmYZYouDjX7YM6PoyKKsfkiKhNyuPl8LNq6i7eCpXy9hVKSuuEOS9aO5XJunTe3hXsgIw6zRlqGWHe9l6N+5ux/4X30xBV1loasXNP5lJEB3Acin/OrZ9liJBuPXnPqOS7al/FGM6+1LrxitLLd2kKKa+w7jwp31EENfFOPN8jr6uUt5NoyX0WWly7P1BSUuwY+0ZOyyakGWS0EBHNk7dZwJbuEUh4bbVLXYgnBkRB04QUO78YIaTGjFncm/huEOjy4DtD0HE7Jx2OG849KqK1TVpt94tmKa+GDo48bUe0mlBSWhesQB5pGZJe68U3EiHNIprW51tIaF4Ca9xuyVFr4/m1kB93Eef2Q5KYrISWWtnNr+tWWCsJSR4/dwBn2a7qJGELaGV7IgYvjznPNCrImUfPOSqjItwWKS88ZyWmgwklpUNKSLtWfzNjLMRCxzQnGTW2npEX0Tm3b3tN0za7iUW/P44a5GWcyMPlljwx+Y7gVc6p7RhqJCY/pyJB7wbryhOFtBylpFnhpDxLhKmT8qh/XjbxMhzVNrmeeaErb9eIic9Pe+TtKZSUDiFWzQa+CoQ0L3lNvabLuaxo3ZYdRSGs4yKKarKN1zpCCFmv8T18BFV1Frf1UZUTj9x5tF87GoPmMrnoSkp5cOXV6rXofvo9VZ47mFBSOuhYQYJZGgJC6kJGs8hlaruWbZreI3zd1PsuiOlhf/O9ft5jkLklIiAUuUaMCzZ/w9HTtNvOLzdYyvl9ULOUpZlJRUuiehFuYYa4Fz3weF5T6otvbdSDm42Y2Fo+HS35z3On+SU1PewplJQU+4poJNBCRl2JaBYJNT0fy9HMIqvG8+gIfzHsiXUN9uVZ3c5bjyPSJ1BaxKWEV+WBJr5jQ5tdfKpvnuwcEdjQx+OKIGQPvYogOUJEhskQUdGliqS83K+3R2dNHojCeOyFKSo7uf/MImPV1fiwmlBSOsg44FFSp7lNXaKWHRBSdJ/h2IQI+dXef4edypsajjJic4J2iq4DBRfBrLlM9UJbmCy4hikRPfcqCzlLffQ5o0OEK7AFiFjIAu6m3bKs1zEK6twjT6OlPYOS0kHFihPSLClpVoQ0b3QUJaIg2pHPxQgo+jzmAUWOpe3C2wVythHGOMjHtjO2IAmOoILam64zouS5tB2PVCSl4QF1R01mh2in8cb3CcaoY6jfpDR9k4uIKXfnZaMh1DJVy6UxBff5szVN3CtPjr2Y6pvHzVt3Wr+kxLQnUFJS7DmmCKmDXNcW9cSIaBYJTT0nyAfrYuMcwuR+7FyayKlOQhby4lc1LK06H4SvtRdoETmF+2y74M4RzfkckohqSGqrHZfND0n4z6n2e0FGlBX5QsLjc5OFtOy+s6hkOizTthtWvuPjIau4W0Yxre1CPml25Jn6GHZa1vzSSkFJ6SDiAEdJyyak2HuGy/T6gKz8vnv2wirX1YmIHWGWiKJ94Dp8H9HR4qKzQuYt0pmwY8dJJrbW5006Il5UW9UsLQoZJcnPsJa7ovN0NUiTopLzxPb4nEMpz585fkCIT6GWB+wwlVe+bqcTiRXLh5LSIcRuzi+ayyY9Q66LkVE0HyTWc8ElE9EUCWGZiSizo7vlhY+JZ2o8eDBfSDYq5cezUJPohAOtet624OH1cnCe315EVPJ5eT8rRzKPS88ehzU7zHMBrxF7Un1+tE8n29nnMoqaqs+B5TuLalig7ULOxgfYxeHiq8ZeYJkLhMtoj7wYEfFjNT2sDpSUDhpWOErqTEgLkBE/9gQTWRcjIpbmmKxwoWQiynuZJyBJPrZ2piKn+i/2ipwai0dbwKRSkVIlY3lycRdh606rHGq8Xk53rdYL2S+Py38SM+uKwsatIsc06/Xyc8qD6M3nlBKuTRJdJNzrKvfd9HmUEycB5m5+IKS8VEh5bpkbupJtvGN+aS7TAx2QRlm7ASWlQ4z9GKrXhCmL9azoaA5CkpEPCElGRBVBpVEyaiKiWB84hryQh5DNSukcCrcP0fGAa3poeqtry8ND9Hj/FTlxlqQaKl6vP2rvc7dIDzzeb8tUDLvvJB5J1t4TPVdBEc4gwTVM8vOVUh5/N/7z432xHdxhKvIR/QC7jrlQeW9/oKR0kLALBLIsKS8WJbVJdo31QQ2GBV4nZTq/Dxfx0LYiR5QR0diLGEdFICEQEJDnmclqpGSjJNpOvNZfMOkQRNTUcNFtgo+EyohEVyLiqdrw+FtRmmJs2+lQot+5zQonebHkJyU8PDfLPBE77nmG/lV5rO75NOng4+VC9NuzpJsJk0Ne648XynqAnbZeUnHtVCsiM7HdH9jc4H4Q1I/fNXVV08PKQElJseOoqRMhRSS7Jhv3VGTEeZyeeC7PPGGRNOciIklEvYH982YiwkUXJJQ3bYMoypGPj6DwGPt1JORJyhFS7IIbAy6+DCKTMnChlaUZSUcaE1RpzNj1eMO2FSkV/rVYJ6W+SZ7WiM1PhJUNUGtFq9OuQgn7OiuQUeQm80OxLg9BPo4/G/78atsm1aTalMZbuPwSfS/j2hUqJOy8sFJeaBXHMdKAwCwzCculcgBiJL+0cLcHxdKhpKTYfTTkkFrrimJ1RBErNz3nCImt3BwZVcsgnCp/xBJeTb5jUuJtBBlxXoTX2VMKEvkdczQgH16mKCFJPEHxsiewzBA5VdGD3Fc1tA/nZ1v42KF6MX+enAhriWQ6KtqJ625qXyKK5MeNHSHcedNnT3OTrJwZuvb43i8LiW/ChbX8Y0YaGIL+ePRcJHek5LMaUFI6KNiD3M8i0dLMdjuBXCdf0+qgC6Ijzhl5w8JG7l/PZAIiynzEk5heP58iJSz3+xlFRDle64iml6em76Q/rMNjXCztvu2FUxJUaBunUw0uxIxCyHV87+t1ioknobEwMvB63JM7zZHVcGTreHAbDusRFL6/MSKoDhJfzAkYugnlxV9CRlzyvGLgCFN+TrTs1tUGAjrzQ+15t8r2xCvNZFA/BxstueiqsBFhQVGRJSIsp7362AvZ9WEppgeNopYKJSXFrkt2ISHFoiMpzdXIxxEURUGcRwKhDLKaBMfE1B/kgnzkcuajIZAPE4xcZgLqEWE5ostT02OTBI4rcb/63T0do7+Pf1Z8zfK5JERLZXhfmpGQpkA+ICGsHw4nXt5jWQ/3272C1hMpOQIaj7MIQWWtBBU78GlJbmetlGKSJy273hVw40knXvXZlf4yJdfjvPqDzE+1xXMj/KgQ+SXULHEbIplfCt14TU1bJbTTw95BSUmxOwiLYmPuukgRbCjX1Rx1rsaIZTpEP2kkUuJ1yC95IkJ05MgHpEME1svMwMl8eZ749dgG6+kfCB57UnJ5pSlSmparQtiLa1IjI2AMkiidfOUuzJ7ERO6JBsty9OAiiiIPIhbxOmlAsGTEo8ZFEap8bcOv/UXdebMgc3BsdpAaY4bPxK2TBhNZvGyJ0lq/yTUp/25G7VJdqytPsa9QUjoIWBHbdifJboahYZazzhsXZHTknHNMMrgY9QZZTaazEl3qoybcNjZyupAP+hkREMtydrmS7HBBGyBqcseOe0tAhqIkREghQcWIidczmFDscrWOiQkYO+IhQ8NkYqOl0pghIqKyWsZ2o2Li5TtadhHU9rCw6100xdtA3kPkRI68EaIpJ/eNJpVDL6iDCsF1W7Qc/B3iddxqqMl6XjOHRPJxcr90nK6GKbYv/gzlwEBESzhub/RIbS0ToiU2PaDpKy0X8aJaHwUF0ZK2H9ofKCmtOlackBq3ayGkWHcFmTuSFu90kHtHHaQ5ioTEMst0TFggIiKlLDWbIChHRBu0nPhl5H9APn28h1seuGUQDx7zchUpTUya2H5suKilSWFloUS0vAln+rif/mXp7jFiocz8+kmZ0zJSGpaILGHxMohquyiJlLA87OeevLa2bT+4jUFmtrYtEW2PCjpHXNzxOQxdfmm4PTbZOHUmh8JOdnUE5ceTU6eFeN1OU02WtIXb9kHtfxdMSDEpz5KRs3oL0uSIkEi6SM0ERDSxDkOgcPIl55dAwPh7wrGVBQ6omPrbDU0P2ulhdaCkpPCYZXKYmUdqkOzCotdwXc0a7lxxvl2QcNR591yvsnbb6Mjli3ouIsI6ly/CBdrKcfYezyEqYrLZgAToIiImolqkhPc3YyKeLBl5ErL39mKXNhATE48kJUz+KR0pYV3hWuOQXT3NiZxAQLQtSXpWbsPxWF8DlhEJTMykVzU4nfTqRgppGqAIwrkM2VgQOvfseVT/bc0viZZLO6lvi1rJUUxb8lwn68SjZZbySGKtioj5vuq8YX/clGheO7Hfj3gDP2spZnroUlCr2H0oKSkIc7vuOkh2swwNiIg8+YAcOFpy6yki6udEOlje2Oz5nNFgo0fSjY+OXB4IURDLcpt4nteDnBzxbDpnHZaxvoqOhiYxBZFPlm4T2SAyIjJyRJQmNlmRJWNPPiAnGSGljqAmjojqEVNFSCCoSdnzj8flwK8vJgNTlD2KpEaTgYueSrM1hkxnzHYxMVvOlTd0yyzvbWzn3ixxxkVTMEWwrIeoYji0xwNCyvPK0Sd778UgWy7NQui2k1FS3b1oqryZW8c1WPL1bAixRbXThcb8unyMnxEuRSWKam3uCGaIuumBpTr6foSM5/+m1Ym3p1BSUixNtmsjpJh5wbvpnNuOi2DhrOPc0WCT80WZXUYXhp4lInLUZak5utmz5NPPzJENS0q0HpKdI6IjMEEkxi9TrilPTJ5skQyXJUOTp9t0kbKkxAQ1JiKy68fGlOPqCjoZV1qQyB8xakoW5Cqeb566f3a4GidOvitzS1AUPfVMMel7cmKyGucDs5H3PUGddnkkEFQ/s3mnIeXLHBGN7OeAbfLtsZf1QE6IOHBhp5ZGGPfgOkdIi3Ysx2QPe2eScpVjco9ZynMfGB2vk2k5z8THROdDeScb9U76uS0kxnfuRnsUuYsg8ffkbOK2UauMYOtdxudx3KkTb3ehpLTKWLF80rwuu9pyxBZe61fnIiSuO/JtgRwh2fqjzEdNICSW5+Q9oiKS6BBBUXRk80Ys2dk8EpZBMttERCAdEE4vPeOjoTwZUgRkIyKQEXQ1d88kBGLixwDfxwBCYlLKnKyEi3GamwQX2Cw3ZTKm6CotxyZJC2N7MUxMUk6ItHAPIHqyTj5LOHad7Y5Ay/2Mck52PSKjkj4XlvV8dJHYC7yMWowzQ4SgXFRLv7+mdU3PS0KacuLR54JjtK+RUl5YH5Y6qY7deMhJ1Ypqgx9LYU0WT63l55uiJcXeQUlJsWOn3awISZocQkMDR0sohrW2bZsjgjTHkRIbGY4c7Zu+yw0hOiICylJz7KiLlHoZRUFsYDiK532khAvg2OTJGSIfWk63TS854/JF2xQtEbEUY+haVTQ0HvKV2T5HyyAobwerz/Gpsuhm6ipM5OSiJtyy3K9L8r7JkpRuvd7Aru/lZlxukOw3LvtmPNkkWW+c983Rnl0uyr45NUSkZGW8M6hVghGiV5DZA7IeTBEgbTZDkEmiFLIeTBU53HouEvGONkeEroaoOh33vQVNa0OEz9X6BQpJT25P78cESp+x/SFS6xUoJTt6rmpE69ej1gt/Y9QLz7rq/N+vmFTLy23th7T10N5BSUnROZ80i5D8dhFCkjOMuG8dSXYods1s5AM7N+eOetR1ITGbICLIdCCcjdxHQkc3euQ6Q4R0bLPnzQln9XNn706IoGBUANn001M+V4RlRCBYhnxno6ChMaNtRzCOlJigQEZ+mSW70pSInAAirxm/qn1o4OzuJN3ZSInIB4+zXkVU4y23HvLlFt33styM0zMk80HSGxZD+qU/mmyatH8UFgjTR44I01tLSJXIlRVmPLHGD8h6KLqtX/irrttDVw/EeScaIVG44YOR2tl52hKFxBPmmJqceFWj1pTWcdcN3x+Q671y/I3YwmA2xeBvhgqLXSf1yQh/k84W7kwPtb/ZhllUTcTUfLLa5WEnUFJS7Nz+3TRaQvSv88+LsRKyEJbHRpBcI5qmspQn64qsrbuS6liSYxMDR0eDrKgiovSMzxVBmrOSHYiISWlkTDG05FKMLEnhVzoTUQmnVlERUO3mq1abP6RKr6JluijilhcVQVm9yr4/jolIyREfDBZ5D/8nmS+ZTGgfJOWl1t2HqGmzt+Gt5JD3cEGG8Y668IDox4mtBcJcImcc4BZGXBeF3E6tq8Ic/0baft809b9rk/24Hx5/fFM9B9E8F9HQsJpgy9EbH7e1fbu/U46QRoKIxMTazsSjvfJ2DUpKhxxNUdIs2W5eyY4LYkNDA6Q566bLfe0RIiVrakjNkc2erTdCRHTEyncgI46OcDuG/JJbPqtvvGkBERHuIc3ZSGlsiQcRUSGWa0Q0MSUIClEQ1uN+6NoDYJlzLvx8GCk1EVMQKflbngmCyv060++bhB5nxvQ2LGnlfWN6A5Mgasr7ptffJOKCvLednk1R07A4avrpUaqF2i42zJERIqWS8munRzYHdbqfmVM9K9+B5CHlgZRwn2fWiYcfAdSLj3vvBV3Ow9ySze+knRrUUlAYOPHkvvg95H2Wika1Lvckm9yO+1URLVvcqRVRPzdDM6ZKJZ5USwMAG9oP1Zx4O+mJp1gYSkqHGHMTUmBqmHpN2NFbSHZTHRqyut0bhAQiou4Km7kvgkXuiItgj2I9LN9OpmMDAy/3s9IMshMmR34o3TYb6QkfKSXj05UsNzxTl+ywflKYcmvLEVFhzHBYLUuC4siIH0fku9CxFUaMISlVy7kjJtgE+6akx5kxGyMbTUHewzFD8gNBgVgzfE5jk2SIjHp0vmkBwkE3i8Jk6VEzgqSFloHovlPrK1cdo+zGTZ3JKY02ITOEfD7WuaFGSOK5tnEeMWu4bGiboZmq6xwOjGFAQfRDXdatoWFcpCZHMS3VW2Umd+SJKLsYI8I2ZjR0+0cx7ch1Dyf5lDs6zHDcLWp4UAlvNUjp3nvvNb/9279tNjY2zAMPPGCuvPJKc+mll5q77rrL3HzzzbR8++23m+uuu85cdNFFy3xrxR4SV3R8RLi9KKyUxbD4R84dGnzbIEhzZAO3dm8QFBfB4t4uu151XqpLzGaOCAkFsGiaWsl0lpQQLUGykxGRMy1IyW68bUoQCkhoa7seHfEykZEgIkdCdPEiXczlKRqiJL7EEbHQZ0D9ieznw9ERkdK4Iica+Y15QjTb3BJUH7VSzr1H8l5i5wih3c8Gim9BpFaOAimRpRxElUHGs1IezAO2O4SV6tDElNsW9dwFHt+Nt2Gn9SGEMVRyWvy5Wv4oGI7IYEKq74M7TbiRFjIKc70Aq1lNsfEW1dRh2w/Qjrdgtyd9f/R3WrUfknmm2pHoTKWDSUrvete7zJvf/Gb/+Hu/93vNe97zHnPVVVeZO++805x33nnm4osvNldffbW55ZZblvnW64d9soM35pEanHbRwtiYZOdGTVhnnV3e2MypCJYNDXDXYffHjvbNBgwL/cwcOwJDQ04Wb0REICAQ09mD3Gxiv2ZsNvKHKU8EUhqkJ2xkVIJkTlVEhOgIhoXx0JTbWA6ICCQkoyO3XGKZum5jG0dEICFqYWOjJpJz5K/rmLzjO6DLcR0ummQJtO8MEPgc+72KoDYGdrnfM+XGRiXvbWzaqAlOveFpipp6vVOmNzhqSpgeiqNE0oigeulRs9k7Rj/6N4Zjyr0hagKpn3bLg97YnNm2wwNxweeO5HDr0TLqmRyZhWBSqN1amtTKKCkTfQTjvQOrmqV6p3WXF2NjhiPO8cgWD9vCYNQpWScntx+KOfHkgD+JWT3xvLW86UPRZq/7S0q//uu/bl760peapz/96fQYEdNtt91mzj77bCIk4PLLLzd33HGHefDBB/26ENvb23RjPPbYY8s8TEXHDg5tA/li85EIou5ISnbcoYFqjVzHbjRShfU7yzNbDOvs3iAkKojNE5tTchERckdoC8QW7x7liYZmIztha46SoeklJ6DZ2Choe5qUSiYiioaw3uWPRHRU4l4S0bb99VyOClO6fAWIB4/9Ml982vINsp2S6GrhIycidUdKG6hVcss4NkdKRJhESiN7fHluEmfEIIJylvUkhRHEzVUyPX8IRdIzE5CYbwZrr5t9d3HnfBLgyaisDx0M8z32a68imS4NWeXrJCHJPznbxQE9B6lsyUzwWLz3OHPFtIktts1BSCAwV+sGQMpjBx+icJwzmrTav02OkCS51L8yjZAOOCn90A/9kHnGM55h/uW//Jfm+PHj5lWvepX5wz/8Q3POOef4bbIsM8eOHTP33HNPIyndcMMN5k1vetMyD02xQC7JoyGXVOv4za46OWaCycuNhPCSnRtNDkJiG7gvhnWNVNnQgKgI0REbGXgZhAR5zhLRGWfvBslsVU46yHQcHQ2ZiEbGcO7IL6MVN7YBKVmyKbdQk1TWiQhE5YiI1jEBcdTkllsjJXJ74bOhyYG0H09SvcyUlIvDL/OyWubvjOVBcovZC6tJLTmhAJccevReXPtki3JRjAtJDw49LE9gLUdeJinNZm6jD1ysN52UZ+3Wdr0tXBWTcl0R6yzLd1M+qUqrdVMC7Ga8bTCd1g1nRPNWlgdxQasV0tL9xPbO8/0V3Y8mREj4rgJ7eOeRF2p4WH1SeslLXkL5ow984APm5MmT5lnPepZ5+OGHKWKSwONHHnmkcT/IOV177bW1SOmCCy4whwoNw9f2gpCa6pGaOn77/nWiGBbLGYawOZcdHHUs2UGqw4WDJLsjPe+s43ZBx8/q+xZBkOlQBAsiOnuQOGv30Gzmj1RkNDlZj44QGRUjU0K+44jo9Jk6ETmJrhwi51SacmtMERHIBURRbrv1IB9HSiFBcY7FdqPmvFL9PvbZhxEnmQRcpERSHqInMoQ4U8gGzBCJSTCKw4aIVt47AvkuxT8oUx45YyOoI0dMMt62pDTaNtlgm34I9vo214aoCfJmnh6jfFM/sy5Gax23PQAp94QGsKOUck1YxoWf++lhXVjAKvM5PG3W/xDxj+vOPJbueDQIpdgif58czWHuFK5YYSEtS43syMMPHP6ch9uFbz/E0RPoJ8F3TNKy+664gLapUeuirYdUwts/Ujpx4oR5xSteQYYG/Dq58cYbzXd8x3eYn/qpnzJl0BcMhHXuuec27mswGNBNsRqoSXXhTCRXd+Ofw4WR80uibRCPnKDZR/QYdvCqqzfuqRgWkRLJdLZFEAgJRbC4WPXS09ba7eze1BaodNIcIiN21jlSkuRTSXZVpAQSmpweVRERZLpCREocNQkiKlykhLyEJyAh37EtedZn6RubMokLM0jqiIgiKiyPXN6JozP8EDgCK7OV73wE5T57kqOyzHWOSHzkhOgT7YoQMXFd0yQ/7uuZED1VNU7ueyQCsLuXOR36OJwjLkSsGHZqG5934tdM55S4Cas7I3d9B5HZZubcP49HleBvB8eEx5QXw9+ec+JVUVNJuTH6QUC5JH9Atqkugk0mJtnVIWIPV6w4KX3kIx8xz3nOc8yRI0fo8Rvf+EYzGo3Ml3zJl5iHHnrIb4dcEQjswgsvXNZbK3aINtluVh6pZgEP5Dt22ZFdl4tge9UgPpASzAw8+whyHZETckyo0HejJWBo4K4MFCmlQ0tIxZYjIyfZOWcd1RlFiYhlurGV4ZAv2rLOOoqOtqroSEZKE0FEE57zQ5FSFRXZaKmKnFo/b7jb6DNLiWh8u56x/byx75wjZeSFeJk7XrsGqkRhvcKSEzv4AEh1yDUFrYy4x94ktd3HIeWhRdFmz9rGh4U1PGBcBuWbyGvBUZLN3cjmqD3qch4ZDCjyS9J155+fyjuF99PbWkKy0RxP8cXfDc1dSq3MSD96nCli6pa5GxXiulEY7rOiDuJsXAiiozaZTiW8FSelpzzlKea3fuu3auuKojDf8A3fQKR0//33m/PPP9/ceuut5rLLLlNSWhV7d4eapJCA2O491c8uD3vZVYWxJNmhH92xQaNkd2wD0lJiHreR+x52Z/XHvgh2I3vEFcEOjTlzooqOtk7YvBGWT5+unHSQ7BwplSAolxMqT1tSYiJiiY6WySdtIyJcjEBCIAmgCAiKyacIoiZGEzk1FR4jmuR1GXJtftmN8kDUdARtmVKTYNDd6ZHd/kjPpFtDk0Cewnni/EFMZx015ixsA4cCPqshEVR/Y2yyfJtcedTlohiaQYq6pmNeyrPjPGyLIpLyMMWWu4o7swORVRk3PdQMDrwsLdzedVcfLy8n+4pPzLntkqrlEKXuSjNwnSnQdBaEiWPjHn9EqNuZmQxKL+XZNkTWUZf2QPLOIs4FtGwPnyyxZkmxP6T0tKc9jeqSXvOa1xD5ICJ63vOeR+Rz0003meuvv95cccUVREqQ+BSrh5CQwjzSlLtORkhOfuKpsSTRiYmx3O2bpbpmyc5GR7hhtAQion52kuqNiJDMlssfBdHRyLno+KLMEZLLKZUs04WSHQgKFxqKjnDRsiQEMgLBFLXoqKgRlJfsaqRUXbSaZhLZj5E/v0q+m2TOquxqaOyyHb2AKCpFBIX3wOcNgsB2NITQmifKPizyp11yxhXhYj1HTXDnwfiR9U2W5SZLx9TktefmNvWzgRlPes4AYaMgrmuauOmveV71oZMTYqX5gQklNDvIqEnawOXrwvHy4q/TGh28Q6+kIuoJS3XO9MCfLRf0JrGICaPR2fAg8ny1iEiYH2R38YWgeaX9Mzp8z/d8D91CgJxwA172spct8y3XG0s0O8yKkjo1ZQ27cnLE5HIZsnaJCYinxFIuqTct2W26HJMlIluDhPvN3Pats5Ldli2IJUJyZIRiWNcuiAiJ80fS7r21VdUZuRzRBNGQlOkQ+TiyktHRGNtTM3AbHRFBOaJiYwOTFYhoEskvtV3IKjdY1XMt49HwqK1xiXZ8dtg/oiSQvN+WpTxEBfSixCTbaDOLr+WMaFmE7g+FJSaQUuZaF5Hcl5l+buc4gZTQ5HUjt848SHkgJch51jruOnATUU3InSfBJoOpbg8+YpJ/NpKIqnySXMevreBGWvDnR7kv57ijnFJixmMbieFHzph+WE1cTqnqZm5Jyk2ndf3vmJB4nYSvTYp0Dg+h9vHlQNsMKepo6WvHJCYjIq5BIheebxVkR07wpFhbGOsku6N918Mum5LsUByL5WN91B49RqR0JP9/REwk1UGyAxEhOto+ZUosg3xOnqqiIkh2WDcem8nJoZfmEB1xHokiJZdHKrBeyHQTt1yAuHCxdeuZbFi+40iJb7Pa4Mlle4Fm11q1Lk3Hdu4fPlcn5YGoeBkuxuw0zCNuEOLp3H7+J3NTnhpbt97pnimPF7ScUh3W0BITosWz7HLCnc/TzGSbE3Ok7+Y1JXaWFAYLGnPMO/HoQuGWEeGgfgkEdGY4Jmebn88U5JdIjuPoBcuiFZGU6fjG7j/6MwyIKuQASHnOZGfGiZsXBcIc2+ND+yE6bkRS7kcTInbv2BsmpsSPAHyfomapJmezZTz499FUSEuvVxfejqGkdAjQdTRF4+sjbrvQFs6PyeGU1bt9c4SEi5JsG0TGBhqvUNUhsWTHdUcoiiVCovxRVXvkCYnyRy6HxFIdF79uFbXcEUdEtjDWRk0sveGeiQbEAzICiKiYgGA7dvIdyXuOjEIiii03QfoTwB12XWnyCbqH2wseIiSS8XwXARddIXLB+G+KmGxvN5L0EFHhIo3vId+mSIl23u/bAxq4zxH988bIOW2ZHJIeFSAPqK6nl26afoYJvVYmw8wiOkaYNCDtwegAY4SN19wJh+fG+aNKyosZHsKiWSakWEcIjqxs5MR5KJnHMt6J5wcYukGA/P58m7j1tZqltn8H2mpoT6CkdFjrlWLSXZu5IcwxBbOSZB6J8kWDqluDnBJLkh1+5TuZjnJHbvYRS3aUR3JdvbMJjAuoMRpXkh2WpzozgJTQsWFknXPUiQH5IhDRuG7xlrkjRzhsYmCC4tyRXbaRgZTsinGdkGZNsoiRE5GR/aFO4MYN1SQFdCoo6D3p80XdV5DjkD84IPHRy+i7saMcyh4MEOihlzkpL6tyTBQtOUlvMq5Jef3slCnNMSfl2fdlKY+OFQP4EMW5miHULtF0WH++lhC4O4Qkg8rgIEnG3ktCivXBy5DLIhnRyncgJDLg+ZxSVUiLxyTtgURB7ihLgJTnZL/wy6BoKbSDt8xZkv9WtJB2eVBSOoTE1EZIU+YGjpBE12+S69ygPnaGMRFtCPkOsh3Wn+UkOxrId6RnjmN9avvXHaciWeuyG2SPUXS0mT1C3b4pOoKzjuqQYGI4YTszSMmOXXaIkCC1nUAUYHNFJNOBnPAYMp1z1o3cMghn7FoIgXiwTMQjzA3IM3niCoiIm4QjbRVGR2GU1GnUkrj3fVrJs2AdY/nWxPT6Y09Q+baNport3ORbPfuDAMsgVIqcbKRIRc0gNm5RRM1kuUWRG+cOKe+IMUd6GIpnawRxcS7SvpmURyhCGrqher7AlrqOV0YD2fmBO1jIERWVlFevS2ICQkTWVEhbyXfoSuHaI7m8ETYbu+gN+xr2bCEtwKQEjIbIL9m/YZQnUOcKEA5aEYHOYYDgkRZpufCcJcXOoKR0iKW7rs/FckuxFkKcRCbZjo0OMDm4m5fv3JRYmBqsdJeQkYGbqkK6swP3XN863CDZcf0RjZNwRbGubx0IiXJGbPvGhZkJyUVA3urNUQ+iKHRwcATlTQxOqqM8iXTfSSIKpljEyKgrMcVIiVFJenxvCaogY0NB+SaQqZWW3A+FnosKe4UpN9zyVmaSPj7HvJI8WcpzVnGS8nJ8B5g9NCa7ONDPNikqASEMaEQGS3kwQ4DcXH+5hvZDsotDzAY+FbQE+SReV92z7FeZH5j0mCBr85rwNxqJLHeKueU8deF1gpLSIUPbNNloG5yI9TvsbceFsTTSvM8FsvYxN1ilTt89tn5zYWxqjpKN2Ul2GSzfI5PD1oxWOTzvSEp2HB2JZqpUDOvqjXwOSdxTmyBHSCzNsaHBE5QjIMDmiuz6MG9Ui5Qi8/6mZv81DKXleldCMT2ctrYP968UqSF+XR8kjcgAEREPwnPHz98PWaa5f57TxpLe2A4PlFIeS3iY15RBioXrcUARA6ImLrDdHqOrODpBWEKwUp4roEV6iskb0h659KZbCkkikvf2vGPPy2jJTtHlOqqRkO9s9GaLYq0Eao0VNBplZKVM/FCyncPtOfrcUlqfs8ROvHD4X9fuDpp72hmUlNYYnX8VBo47fx8rknWtb+QoisFmj/5x454cd72UCmS5MBb3kO1gbIDDjifFHt/IzUb2KDm+NvJHzSB9zBXGnqo6fMNlh1ETuNpDsuM8Ekt2IKRTyCMVrZLd2BXGhoYGluzoMVm+bYRUOFkPkp0YoeRHK8l1U/P+guiJ18v7GGpOvFF178xjxCPjvl0PTu73cYGdmB5yZDRNFfKdXUZ+CefUQ8cI1+AVB0bfHccaoi0RSXluoB8MEL0jdsw6+gvyhTnrDdzwwMqVZyU9u0wk6Ipaw554tsdd5bKT0h3nkdh919YxHFEaCBHvOZDy3QRuPDSZNWZI0px9Xc9F53QMkDfHbiigG2kBwD6OzuEgIf7bt/0yWqbOBoW0Ku8tD0pKhxRdzQ3hc/K11m1Xv/nBffxLlX6tWqcdLjjssqOLDwYNJCPrsjMjS0hkV3Y3Xh7Hb1SDxPVGkOFwweA6ISfDUWseJ9HVbm5730jVSXm8TPciSgoJhx+H9zE5r4uUx+kLeV/rHJTUjRC0biwkPZAPIghIad6kkVmCcl3NuYcf5ZloXlTuZFBXnMNWcSeZ5r1tayJIRmRAAZ3lqbXwA7blTyIiFdq7pTw/z7Aqhp0ulI2vj21fPWfzSfb1sKjTX6J/zhNapPkr37f15Ntxoaxix1BSOsQthVpfF85FckWyvI7NDdzPDpJInyU76tSQ+zHmKJDlbg3oFFCNokB0dMoWyWanqlETsjB2O+jQEHPZcQ6JL7yiKJYddd5VJ/JIssjVd2cIao9ixLKolBdpE+fBkxNwj+urjJp8v1XxrxXu7rrJAhJV9T0n2+KHAyQrfI9OykO0RFLVABFnz0ZMIHkMDmQZb7RNsl4vm5heuWnKMjNJWZhBBhNE5qfX0jEKuY7HYLhuPR7IP8lWQqHRwW4jOzrEIiXX844nd3CH8clEdDiv8lj+x5HrToH7YoSShUm9kLahuwM/jrYcUuwalJQOCbo47qYIiWuSBBFxkSzIB/+gkUPC9FgQE8l3NKwvM0c3euYIJsv2MnNss+cLY3F/tIeLyBly28Flh1/iyeiklezwax33w9OmxBUach362VG3hi0v33mbt2sPFGuwGlq8Y3kkXu6URxJREAdsAPkuAgMEL7cRURPwGklSvG+S71y0xO9Jy678iKZYTKwNnrs/0NfJUp6rZ/KzndBtg5kMLOctf+hKzomsoRn0coMWsnkJ+a5nkmST8kzswPM2ce784EhKIswTMQH1pgiq2rYn/2aR18F490kwysLu3eRwJ7q/X/zNoQcedXQQNUtkhMAPqIn9McXfv42OnITHxDQR3R2W2XJIMRNKSoccYUQ11aBVmBskZJGsv3eSHdeI4GIgcwXW8osLDmQ7uLusfId7+jnK8hEiJL4acxKHwxGyM6Pbtx3jQJKblO0A8TjW9qe2LlhmxHI/sWLYtrzRIoQUA++HScjP+nMRFRET+MSRJTqMI28G44OU8ojA8cBFlyR4jQtrFYcWSKaRoUlAUCydFqnJ+va7KiHg0fdlx19Y952U27BkZbVqMJ841oa+diFhyW1pnIQD5bXoA5BSXVVEy495n3DgxbqUS3BvvC5tVmPRkjrwlg8lpUOALj3uYhZwec9GB0RX+BVeK5Lt5/QYy+hrZxutOsedK5CFbGcdd6VvsIokep5g/IQrjMUMJCzDDi46NNSt31VHBu+ww1XaEZHPJTnIOUf0WCSnax295cA+L+XN7tYQ5pBkpLRsgJzwUfD7T7cp4mXIU/gebRdxGolBXbGdWQXfYx/3E5OcyGzvQhy4i5Zokm1+xrViGBvTG9CPDNQ09VI7sBOX8X52zL6fc+JVEZI9kDBakrkoGyGFUl5FXjT3kKqILNACCUQIMDFZGc/e40/U7h9/Z5NKsnM/kkBOVSGtLfqVZMUSnmV9a7FvKpxVKW93oaR0WF13HRx3PKTPj6Rwj0FCnDuy7jvbVPUIRk5s9FznhswcxXYZetlZ152tTbJ5JMxEojzS8LSVRlAg64pkKY/ELjvq+h3JI4mRE+y286PImZyEiWGnkD+Qm+Q8fm5ZEVIMvG/0oJXGCL+8IfNP9qC40SvPuPI5FHyfPO0WbkpMsyW/ec9ZxR0p5X2Ke3r52PRLm8zCjwoMCczSDZrFRAQwqZMTCIOJSeaIuEiWC2TlMiQ7EB5uiKYZaVIgTiIJD+REx0Z2dGu2gHxXuIl9dj9Vm6FcthxykX3Y3aGt5VBjG6KgD15n4tJ6pVYoKR1SQuriuJP7881Y2cUUOu/kL1J23QX2XvyCZScXchQJLpogJO+0c90FQr+1v/o7wmFMyXJinEQwcC8WPbWh5pQTtUZt1u7dJqTY+wEk2eFfsvi4WPmk7g5Uw2SdePQ6SHvsUHTTbEnOY9cEf/74TmATx3fCUp6TXWF8AFFgUGCa5OI75gjJSmxVoeu0m44h/2RZSENkVD1fVMQkd43uDt51Z6MlKHty8m2tkDaIjiBBk6V8F9p4KRaHktIhwkzpLuK4k/VJLNkhOoLbjkdSUNTk+trVi2Sty86OpCioWwOKZHEDOZHbjpqt4oIHh922leKEy65mA+dckYiKaHugZaAeO6lmjR6IIUZCbW68vYQ0RODjCjtB2HZFE2oxhGhpdGZMeSaac3ViaGvNMCwQ3+8gN2YTTVozK+NtbdtoCYSECJbIqTS9wRkXqUxoFhMTCAwQQxcxkTPOERMeuwnu9e4LTrazUVJlbKAfK4mNlLijBL8H3peDDDy2LYnSWvEsq3DUOBYRFP944h9H9OPJzqKqSMquw0yqtj54EtHoqGvHcEUrlJTWHFND+jo67rzTjqfKUscGOw21IqaUet2BiLjZ6tENJ+XBgedaCtkpso9SKyHMRqJRFKVosEo5pS1Ksld5JGcDd+2EZA7Jjy+XuSRgyReANrNDrB5pL6MkCTIpbjW3J7LjMIa2q7jLK9GNC2uRX8LyhnVU0me+MbADAmET7234iCnJB0QGICsmJURLkwzRkp1aC8h7vsjwn5qMoNkEwzkka4IppuS7JCnIaMGFvACWsxTHYCVASHh2/3YZsh5H7hhSKLs7eEu4UACK2LA/38WhW3NWxc4R6ValWFcn3aJEFjZprX5lVn3vqqJFq+fHZDv8ukWRrNeZvOPOue+aqk7pviIfaVaY/9ympcuu2OtIaB6AEGXHidB4IWu15D19puxkHAWFV7wjfEfiu2LXJNqYYpkJhIhlyrQw3YAVkNvgdZRHonlOxZR8B0Lie96u7sizy2EnCFk8ywglPFo3Q8J2L9z5l6ToBI2UDiFi5DXLcSe7NUCyq02SdTOSMNocsh1Ldizf9dLTdkZSMqb6pFqRrHPc0fRYbhLKsp27qqLZquzU0IjahabqCUcRH/qiuXySv/iIZSIrl3+ZK2La5yhJAsfAgSaaNfgxGOjsDXnv9Ii+z9FpGFcyO85hMKJ6JarROZKbyZmRXUboBeMDTm4DES3GW8BYsk3jLmgSBr5LOx2d2g8BVHxLtnCYEOqFtQwp30GyY5cdGxya5DuA6MnJd7Zhkn1vXzgrCnR9gW2ODuaIqmT+k39QVXOW7PHbnneyY7jXSDtA2w3tHEpKh7i7Q21QX8PQPiIktn87xx2RkZPvQEaQ7fge9m8Q0WaekWxH9lzKI23ZVkIYaY5u3zy0jzqAuytprY2QS7o7iY5zRxQltRATSy3hOorwiJQqyZKJatZnBczq6rAqICOj+ygBUuNQ30Rf7cTkLr9EeaVeasaQ7ODOQ/R0Em68jD7vBERE1broND4wCQpqES3hBwWIp5yYXuZySqWbXFsit4RLyqYjpWkHnr2v275ZpsvYBAMDRUy+KzNXL4VBE7aR74QMF9gH2h+5Eejebm5HV6QjUUPnIikZ8XNnB3w+XehHiWd3oTHpmiIqRQjpaiaYqEQy2K6edtzVbiLRbOWcMV1gOIHtZbvaLWJvi6FJy29xDnZqrdRFvmmR71YhSppJoELS46azvvefcOH55alQUISETsYj2Y7t2xzluJv97uPdvpmQ5E8CyiMhQnKENEu+wzb8Ot6nRJPTr7ZNh5o9xd5DI6U1Qdd/SOH0WDnEz0dJoscdS3ZcHCsddz46GmSUR9qEhOcmyVLT1WSLfv2y4446N+BnPDnu0Llh5OYkucgo0oLb5kLcBZPhc10p/WqmNBXOCzUskJ6cYzid2OFtYU7M5pXceueQ6vr5xUwOqwbwBtRQ6ibuuozjY3fz/aiTeIZR8b2SuqRnW2OTFqlJt2yXdTjyyi3X2QFgJ16/dLOXuOs23BXGR0g2YoIhAeMtYLXG5z99iZEyHUdHgO/u4ZaZeCRBSfkOsRIcedgHDA9cPNtLJ2bofhhxdxGSEGs/qESO1JkcOGoiouaxwPxvo1ISo1Cn3fKgpHQQsIxfbkGUFHZw4PtaXsmNu8bFhYiJOjg4+a6XUfcG5JM4p2Rlu8oGDgs4HHcolEUncHLcQboj+c7WJpHjTmboYzVK8riRK4KEh+N3RFWT7JiwcO0iyc6et5855IgLFy/KnXSIjmIRh3xuVcE2ceSXnBJHx9sfTkyO3oGTzIxPj2yHjklmMoz62LDyHYqTkz5yfxPnhuxZB1p/u6rY7Q18j70sHVB+iSzUSebuLTlxJwYGkxFgpTe7nAXLtRZDzhJek++wb3pspbw0yaZySijUHcrBgpGaJU9SlVpo31M0ZLUHW88vWQJb8MvRAtpGKCkd4umyNciIKSiWlT3u/DoxUbS6ryQbK99Yx539Hdog3QFdww6qjhQkRXUtqSmzKjpKJi56AlwEhbf3F5gl2XlXmYwYoSpKx+w7QGB+kHPkFSVNZmU3XpmxlCeceDRKXewI9mv3HabuO+bv2spssJA7iS74E/QFslK+EzJgbduajIf3s7848PYTfsz7EI6+JsDsMAuxyIjzSFMNWYO5SoqdQ0npMKBDbdLUVFmQDKQ7JMV5RAXVJ+W2xx1HR2x0oOjIFsxS7UmyZeckuXlJ3tDAI87Jwyxcdk0JEF9fldRkOsp98PlN6tERERUucm4qa4r6FuHEk1Z3km7EmIIYmswNc5iy9g0k27kJ6DkvDw0NBsRFNt/MqXP6GHWzkPEw3BCfLZ7HmHXDU37RYxweBkiv7rKBiDdJTYJIDN+xqSIlxDITPNcQKTEhSflOLjPBhSRVJD1PTNg3XkNRE1nSczFryRod+AdTbTy6j5jsGAt6P7aJZ6733YwIWs0OuwclpTWU7qYKZmdsE+aYuM8d/WN2TSwpl4T5SOS4k/Idz0ZKqlwSFURu0w0XC9xbR52T7kBGyBd527dw2kVCEModoUloINP56AiOsdT+wqd1Lkck80tyJAEivknklzETlERo9FvlXFIM1MVpUo29IPkO45KG6FVX0ITdAn0EexgO2LOyncnNBPcD1zOPOmzY0AHWfRTi2p0PbVEtLiQ9jKzH/9EZAbIdWhBV5ESvLd3+hJlBWr+llDdldnCjK7JyRPtDIW1G95DxnFGCorZ0quWQbDdE+5ZNWFsMD8uA5prmh5LSIcas7uG1AsPgH3BtkmcwdsAXQ7LrDler0KLmpbvF5DTKLdH+W3rZ8fEjWkJV/9R46yqZ3QUHhYhi8IGnq1tiTE3kJQnPdc1wEWsSc+J5N569WeOCle2IHIiMqGLJD/xzAW2NcOg1ftk56gRhSTAxxdZVrj/nEnU98br+HStWB0pKh6SLQ6w7g98+UpvEo87ldFly3DnXHcl3fRsx8Yhze8OI6m1vciA5hvvbceNV7hDQYmjwOS70JOPcUR+/2q2kB9syyXj2x7cpU+RIXDsYck/VWw9BqiK3Vs92MyD/HfUbDfJUbZLdirvuZhXVyum4fnDgqKDZSwCipp6buURd2F2k5Ctyyc43tE48eoGz+AHZkNx9BRsc4I4r01qkhMhJRkq0juqSKqmuku/cj5kI6G+BTA70CvourZ184qKleiNg+z7To9FDyCm09D460G9foKR0WMeh8z9ACbeuPurc5ZRyVziL5qqcX8pSmpcEMmLpLnN5JO4GTnKMJCTfUsjP8Z59hfeOOktMVNzJLjosk3wniM1JedVjp+dEWibZ07ajC5oQI6hVq02aBTY4hqTEU3kBkNN4a2xyk9vegiD+bEIjQ8gezj0J86Elf+QGHeGYwuacMmzveuMV7vJiy5bpBf54mHDY+s2RkZfvIpGSjZJG1PyVckrYHnZ0t1yNvKgkPKqJCgw5tH9p3HE/wBpjZleUq9gbaPGsom52iFyc/T/k2lgAlu7qrjuAixvpFzHnBWSRbOi6a/zrlJPrxHFJUpFtgnwztfrzeK6LCxGOtPrj9fnjCPm/UuKEbMfb8jRfKrBt6D4L4PuURbXCUekLah258I2f48imto0vhJ0mJH5drYiWC7IDqCJ3sKGR0iHo4hCLiPz2YnSp7ODAoyms867qCs6thWRt0sCbG5KabGdrTXjEeVFFSKUYORElIlQ+ul5rOC73V2ot35VzkMwPJNUFBbBCsmNHHtvHYX2WUiYjHIXe1FZoNyfL7oWEx4YHlvJsc1aes1SQE4/WU0f2wkmlmLXkZrGLzu2mh0jJfYaImuwO6e+lTHIyO5D7Tvz2tXKbyClNRUfj6R8uohkq/mTR0sjawkkctH9n9APIFu7aeiX5g6ku2UlbuHZ1WD0oKR0ShPVHsYJZAggG/cI4p0RSXuZ7h0GyQ4U8LzMZcT5JynZ2iJ/IIfEgv6YoiYsy3UjqWqSEY6VBdjy2ANKSc93hFzMRrPt17+zgpsgqR97IJxfqs5Ua8gZNNvCDKN0xps7FcUzuapaklMcTfUkWxb0nJWfjp1wcvs9cyLMs5Y1NgoatCSQ8m/th5x1/mxwV1Ytk3d9IrWIV+0OtE+eubF0U+fySnjPRVHVOTXkoem8X2c+D2CgLxe5CSWmdMU+vu0ikFbqWpotmpevOyXqcK9ipBs8GhNjIAK5fwvPs/eULh283tFgREUUOsa7ga3JdCqNAgHrggXxIuitN6kqS6Dnf6gnEFbg+eF4G5fPEPct49PeBFkSuiEygTh5C4o3d8/Rbt466O4QuvKiMNz8JLQQtoF0qlJQOEeRocx7mFyuchQtJFsxS/7ue7W9HY86dycEOUxOD2pxsx/VJ/hc0mxvchWVKumPJjgmIpTu6gXTSqStq7QLJBEXEhPY5TrYrnCPPmSFIjuIxHSwDCkxJeDyjSEwJP6hREsDy3SSQ8vpExKUpxhOKmmjWEhsdOGrCLXUOCa5ZGkM2c59j7logwGCC75FICS5OyGtMIJJIBPHI6MiTj/igmXCwH3wRLvqlXnklnH6WRW2OCjJePa+068SkHR2WCiWldR5vHoOUw0JHGlvBxajoDK47kuvcxFleTqdv0PThvPNJ64aaltqxSMmObdzh8fqf9hGCEnU01F4IU1Txy5+s4am9sIKQtiDx4T1Ea5tIDo4jJZnbl2930BGVI0XHcG47ZLuFWxKH2cETuuzA4VnO/QBh8gF5hWRC68V3V8sbMSmJxoL8vHwtGs1x1OQcd7R7VwvXJt8tWo+k48z3Huq+OwSYZ8JqNV8m4sKTLVu4UFY48ip3lLs4SMdd9wOo33idf85nrqdyTjZfVLVUqp37glN414WMgKavQl54eaovOfBi2mXgxKOoNxxDwtGPdOTJurTY6BImpLAvojQ88GPerkW2UxxcaKS0ythJo1XR7y7cPtZaqD47yUZL7LyzkVJlcKAbRUdSwrOFj1QMSRJK5EIUPUdBOPzXOA4jpAY/MypnvTHCRkylGVnzAtrkSMkOCWt24blzlZC26DaTw0FH0znJEen+s4Bkh7ojHpWeOReeND2gmLbfNwnaRwGIREEKLOGl7kttyg3aN58mIQlER7iR4SFxf1eIdJGvqsoPKDp3E3Dtj6bFtVaNkPYPSkprgq797sLWQn570cWhalbZPsyPR1rzMD9uGcNOqJmgSMe1rpYXLXbZYdqpNDvEfNr+OWsl4/54lpBAVKlN4rMhIkDorKrV64Q1PQc4n9QGnBvcdwBLePy5+DolPK51DnfkhDYOuO85uz/tUP66cAiasjYaG2LMT38nXBfgoq8ps8Ssc1zTL28NoaSkmO26c3UeVr6rW2tx76vzw6Fs4gIiYYfzBZDEU/tVLV8fXNhkPop+Oltyo35oIjqiyGmHDrV1iJJCNEV/LOGxYYQLab3DMfbjgAmFcz5+vyLXVHuTJnku+KZYiuP8Ev9YqW1SjbyIyXntn0GHv4x1/PJXGEpKh9EIIfrdVT3m6hESdwfn/ndw29EUz6A+CTfu9EzD2yCf0QWi4R+yu0ARMfm8UMTEIO8ZUxfDYOIekxTdRrJVtJXtCifhNVyYpB08fIt1uS5x6qYWZJKbu97ZgVs42caskPBEYdM4r5x4WCYn3sjWkRF5JJXklqHQldsMic8+7O4RLjOI5DCYyR2wtIc72S4cjRECU2fteZa0XDi3IRk6nA2eHgv7Ox2O1iftC5SU1gAzZ78ETVhjz9cH+qWCoFAhPy3d2Z5iLlLybV+CC0zbr1+sC40K/vWBwYGeCq6i0jLO64TPGSPdy2xMRGS7WthhgLRbdBifdJPt5P1hQa3tkJft3ADAWr2S85b7HwMoeKarfBXUwvDA35uMmCQBhY47ua2vtuX8Ieuos78UVewOJpSUDhlao6cIavUevg1dRUzRfblqfbEitlGElBixvILLL0UPsozWO0kiqo+86I7DRExTyf3YYx86TvfDo7ZP+F75w4LRQPYyTVtIqOmxSzlSTmoOVx1HR/5xw9+O5ppWD0pKhwlBjVLYhFXawRExSTeebyvEkZOcn8Rjz8VsnCnIehMn0yVoEYTIBuiikTVpaywl1Rx7uTEZamoSY9ByqMHoEK1RCpxph4GQ5EWaOICNDhwhUY9BMSZduvDw+aMXHoiJx1pMIvJdU5ONqGxXVk47XKbo74rzVVWBbhihh1IeyIn5iJZZuqu5LV19lpslxTVbtL8Z94rlQ0lpzRGNgCLRiZfrAmKSsp3fztcnTdcohcvTByTyApD+3LGUbXLdLPkO99yeoFbnZPeP3njVic5Xw7JuzrsuwQZfcFGrhDEmVrJjkooM/aOC2n5dQuW/gVpRbfB9toE2TeOWcVpOZ+eQxJfGEdFUJ/gdkIsfiDhrG8VcUFJSNIKJKBwj3bh9Vyt4zY3lXFMhUUYe+/ZE3K063DYovCX3nW+pxAQl5jO1nM86R0dRxbQJ8qIt80r0WHR2Ffk9GnNPn7+T79g513QBD/NItG/BO6Vw4HVEFR3hkOuEVEVLcxLKOv9RrBCUlNYIXWYGxQb9tUZGTqbzXRx8N4dKvpOzcKaufrgQ+XZCrvUMXRXdhSzmvopZiF2u22/DJBVqbDnXyrjoybnwbDfwYNbSDKzzNagxnReDMztguq83PfAIC24pRPJd7qIkO6WW3JUsz8Z+eEy/URXKUTTtompvBefed/UvB4IjTOHoRE7LdIjWaeclO3bdyXXy5hx43uQh998hmtKIaHlQUlpX8mmYodRlH3UHXj1KyoKhfp1buuDC4hPWbEwIPA0xMgolH5b+KO/t6o9kI9fUje0WVndES4tinaS7eaOkWvshyHZu2i/1FqTx85H2EDzWgsGSKjfibZNoa8QVMUC4Jh4LBXncdDY6pmR21FQ7FM0n7SqUlA7ByIowrzSVZ5ox4iIkphCtBYv8S1cu++0dUcVeEwOOk/MJrrM0oicyS9DFTzR2rcl4Vc88nkabstkCn4VQAtcZ/Puh1i4wnUFIYd87n1dyubzQHk7fBSIoZ4zgju/8Zk21Z+55fjf6zqjVO0fTcTaSIyxslJQF5gZTI6NYZFQdSnm4wuUVhZLSGmMWGTU678I+eJEZSm3wFwq2fYMAYOnm2iT82blOzz5fEBKRfBxezDhH4ZxYdrqs277ft/IRS0kk99iR6FQIyp0exOexaAfpg4imfrexfoAeXEjL8h0vU2RUVPIdz8WQb0YEFRlpL7cJDw7fJ1x8/HfG9UkNgOOOpDvcC/luPMFtYsYFeuSV9l447yQx+QJq0S29FhEpOe0ZlJQUC2EmOTVFO7RejCSIbS8vVH7iqKjk97UrfNGySfWqQ0Tlvqt1Fg9P4JBhLoNDE9jsgJlGU0aHyZRkV39t5CCo0DbyXbC0N+sHkJtoWz9EmzcKd1c9h8eTzrKc5osOOCn9/M//vHnggQfMBRdcYIqiMC9/+cvNXXfdZW6++WZz6aWXmttvv91cd9115qKLLlr2WyuWDB5TMQ/wSxVdwqcIyEc7rnbFGxwiBCSXa61peJ0YDIdVLAlyTimwh7Nk573suI3q0UGXPN06IGZUnAW0GKI8EnUMtySEx/F8En/XIBthcuE3DeQ6t+DuIzJfU0LPtxzCq2yERLcSkVLp/BhMQJWhgd6Fx3O4XBJHTLMs3BxBtX9Wa5SAXAdS+tmf/Vnz6U9/2rz5zW82n/rUp8wznvEM873f+73mqquuMnfeeac577zzzMUXX2yuvvpqc8sttyzzrRVdwQYAOeBP1ChVncFFU1Yn3fHyLNCv1zCXhC7PfpwFiiLT9oSHfK3f8WRavuN5PEVqkmRcFePmQr7zxCTyS2wVD8Z7pGLQIF9PuSvSQUcYQMp1stUU/23gAjtJ0c/QNWeVjVkRmY4hnbqhfwA6hssdyzdobA8SkBZ3iM9zm7tyRbI1iEm2lowyU5S5KcqemZjcTMqxk+5KMyomdAPp4H48tsu4ryQ8u67Ko9kCWn8fgUZPB4CUtre3KQL64z/+Y3r8lKc8xXziE58wt912mzn77LOJkIDLL7/c3HHHHebBBx/062L7wo3x2GOPLeswFTtAF2LCL9Up44O3g4sLTLgP/uXbREj8WE4jZRe6n9/TkDDBTUZKtSGAKc0NOgyRUowvOqE2BNAW0tZceEbIeLwcPwK504b3cqxJy5iP5UoBQri/n1gzVlk8a6MhsewiJ7v7egTF3RwWhUZJK0ZKH/3oR80XvvAFipA+9rGPmbvvvtv8w3/4D819991nzjnnHL9dlmXm2LFj5p577mkkpRtuuMG86U1vWtahKXYZdGGAGStwQiWeXORYa24ZEyB06DGmchChewtkI1oVieiotsyyHUUCbky6HHToiaqsFKg1Ml7JVoOhbNdJwmRzA8t5MIs4Fx4Rh5Tv2iIhvvf5pUDOY4m3CeLAq/oka3SYlLkZIfKBEVAQEEVJLkKCdFe57+yyPSdpf6/LdLLtUAwaNa0oKX3+85+n+36/b17ykpeYF77whebLv/zLzTXXXGM2NjZq2+LxI4880rgvRFzXXnttLVJCjkqxXMyKDrhDeIgwiSwTzrhIoJ5lUqYmkxES8kiyzmj6YIR0J0Yf8HP8Gi6gxS/qwg0JpHkMTpYs7CRUS1Bo4mplPAz9w4XVjuuw/fBIrstTe5H1Trz4rWjq23ZA0HRelVoa/1uoj7AoTUITaBOa6JsMrYXbdsrA6AoX0uAz928g8kThvb+JvyfZCzGEbFeU2L8xSHcgI9zGk9S67fzNOu5qt/HEjEcTU4Ck/MiKetGs7G9Xr9UK8k47aTGk7Yd2n5SOHz9O95dddhndn3XWWfRL5Eu+5EtMGVzETp48ac4999zGfQ0GA7opFsCMmiNgWVJVSE5MTBw51QpmobWF4UcYEfm8kvuzrPVMC1+Li2PueqsJEktiTjyZy6iMDn5XlGuSY9KnLybrlFfyy8lsQor1TiQJjyIlJ+EZUbc0FWIKEwM/xwcRNT3MAH3H9vv2xgaXW2Jw6kvOTrJvVyeV0A7eBSrRHSBSgrMOdQVw3DHw+IlPfKJ56KGH/Drkik6cOGEuvPDCZb21Yh8gOy+z8wnAL1dcgOxjSU6oUwKR4F5qR6JOydu/RWdpAq8PppV6i3hevQ6ERh0fgj54eWpML/MEhOUUN9d+iGu2cHGF2SGMJg66lBdLs/Fy18ajNckO8mfPERJmVlG0hM8dhBV8/v5NuZNHgytPzsaS4L8Nzju6G7cVstJd5s0NtVthpTsyOFB9LyQ7PC68jEdEw93Bg7Hw0eMJP5s51itmYxmVC4QnPOEJ5jnPeQ5ZvoG/+Zu/IVJ67nOfS6R0//330/pbb72VoiklpYOBsNNyTLrDBQGo/XJ1FwzbtYEvKo40QFC4ZT37OOsbk1e3MumborS3cblhxnRfrcPzfnvsIxPLuX2cQMKjW8/eQxbCCAvc+lWOCV2ww6JhcpYHTjXRwu3AAbzP58QGOV/CxfJdEBFx92x7wXby3agwZjix9/x4hMcTU26N7W17TK68clyYcjiyRbU85sLfCndzzj2+D3rO0XFJN6YnJ/zNsGQ3oHv8XQyLib9BvmO3HWQ7Wh4Vphg5gipKK+GJabNcMCt739VGeCj2BEv9p3bTTTeZN7zhDeaTn/wkWcM/8IEPkKyH9ddff7254ooriJRQs6RYfXA9R+PzTiYBbLK5ipaknFKLgqR7jp/z9/Uktt1vZb3CftH4Fe+Z0T5FLoqdd/4XNc/WqH6NVxKdzXV4G7SfLZX6EQ3z1PEcFDSptpUTsb4ByXNNL2Kios7wadQQ4d80jDS8fMfzsGZ8yA3Ps7Gmku8qlcabHILmq/75UNKbYWaYwox/G4oVIaUnPelJ5hd/8Ren1j/vec+jG/Cyl71smW+piP1jmZFXasoVNIH/YdceU8TkbLk1+c4WNOIetSOwC2eJrPAXWpiwgZdUX+IuMmVPkFJwLtinc++lGCxIaqErpCV5kOU7rlMqqzAhdVESoiUYI3qpMzrYz6OKmOqRBNfirovrbhbhhk40X5uEx5DtcI9uTqPEJD0n243sEEXbwgmRFI8KwXeB5wqT8NWGe+RJXTQmkckDZEkX91nu/l56zuTQI9edjJQoMsL9uFqmqGlckNFB9r+TBCPbC+lgv/3BARYlFHsNrvOgZTEawEp2KGDsERGBhPDrNaUiWuPWiR2JuhPbq4yT1pwjSE1heo11KCA6rE+TsUmT1GS56PAwHrodOzLCxY4kPLu/ZDimC6mZZOTIg3wHpGI5y8cmz+2Jetkrt0rUQTM71KTIhhIuuzwdJdWG/YGA6AeFc+FBxuONOdKauIaqkEQLdGcHobHdnJ16Im/E300sWuJGusSqrhgb+cgUfyOQ65x8Vw5IwvPFsu5+OCrM9qige0tGEyvdOecdbpxXmhpXIYtmA7JsGuynBojlYY3ECcW8aNLJZ7mRZsnrtjFmlYSmdZE/NSYk+5qKkKraE9E+JmwlIx5X+QYXFsjlqZtrzsrdwl1UKd13VXeDBYtNVxCRa/7csERlR6JXtmhvdbPPuXXeSh4MCfQX/6oZXfvBynZTbpl+xMDcwH8ntRlKQdGsn6Hk3i7yfo1NWINtFHsDjZQUHjWJzkkbbKnlf+g8xVNciwLCyGw9q7tYUFFtiSgFHuz6lVCSFskwrmWM7V9m/zTZNAHwIEFQkn19ZjJ0kEArHK5fIiOFvU9yyIDoYD3yURPV0tAv+dRGTJDwitRkPXuj/fdSk+f4Je26FbnI7qDVK0leBuaV7Wp1ObVZEG4Z0ZKIhqxMV9qaMLweBO9lXZF7aitJqB1sVjM2WEm2X5PtqLVQmZNkt+0kvG0n2SFK8mYHipgKOhdadhHUBCaNiMEitm7q81Lzw65ASemwgUY5ZHVXkWtMmeFyH/wiDHNJfF+T7xyRMJnYOv3cFMj5lIWV84iY6qhHPbYIErDSTCXfcUI7dRbwSULiID0uUZeEewMiAWtQp1Un3/Vd/qOS70x/ZJIN28Iq2S5MMsBZG5NtF5V818tMvz+m6yLzGcC5pYMi4YWlWk3SXfh9+8qiwi5zDzx85sgp2R2wDJdYqY4lOkFQCW/P2/TxGyWtBgROHXAQ3YockiemBI47S0wk25UbU/kkkNHWdmG2h1a+Gw7dbRu3se9/F1rBY/3uajbxJvt38G9GyWpnUFJSTCGUOGodliN5Jag2NmcgzA4CXExLPdJqzrqKcGruPVGEKyMlf72j6MxGZHSRY7kQBOULaUVBbVizJDsNBG12wrlCvHjQnXg7OXaOmib4Nhxxt24P4whHR4h25kVV1Vutc98pN2DlyJyaltfGnwc/pCLFsbF1fJ7yHBT7AyUlRRRc6c7/eL2MJzR6WTnvp35SBAMCwb2T9JKJycpRjaykVEePXZfncJmjKfsgj0RKGcl3eKYoC5OjZgluv4mrW8L1rD+yrYeAfo+iI1o/yEyygV/gE5MNMpMNsJcxXXizvtvvsKQyJy/lOe/EQZDxmowN8fFFtuyZgfwQ5DfqRCdzLdzBgQclwtxAUZHxUh7kO+/N5CjDPeax6o0H6gqpkpwjpMzVnmG9rUsqJqhXs5ESR0dWunPy3WjioyQUzyIyGm2PnbnBdQd3dVaQ75paC025EOn83Q+ryDadobJfK5SUDiBa60fkdtzrreV5Z3KrtVwJm1WybFfLL8mksjMkZRmIqWdMMjIJjRGYWPs2nk/q8p03MTjC4dwA6IYs4T6BHdQ84eJWwmaeenKCREjbTlKTZWOTYKYSpL6R6zSfD2ryHVgmMUMipGQDF7vEpBu5yTesgy8fFKbYyE0xKkx/OCYJD9dLqvt0BLXKpNTk8ZgFlrA8EckaHld7NBkVJqVIBYRU1SnR3yTviBu30rIjIfwd4u8N99hvTFeUHnxfYM3SHX5k5GZcoJB6QBIvpLthMSYy2hoX5szYyXTOdUfuu+0xERLnlYiYHBnVimZF4SzLePIzCT8nxe5BSemQw/Yxa07o+jxSKIHU8t6WmGrym7eF809kXCytlbu2HyH5hV3G+X7KFp7IeihEW7hI2qiJGsGGbjxfbFTUZTzq5pDSL3w/V0rMWQL4ujk5gDOWlik51i7EvOzJR0ROFDE5IpI/nMQPoNaDjXVw8M16pRGmF0h3QbGsKJqlQ+bmq3KgX1CPtIxeUjMJSwltJpSU1hGQXhBBuIuCJZ4qMuKGmiFk12R5QwFivzcdIY15To1w4SHagegDKY3u4ZCjMa+StKpKfDY0SHMDy3fSEl6DI0CQXCYiJTBHkdhGvlS71NtwlrkxtR2iywXCHK5Z2hib5EhuzHZikiM9k50e0ecy3i5MvllQYS1+Uff7E5OKKIlrPsXIr5Umo1gw0oR6dGTHSISdsim3FEZHnqiS2Rfg8IAoMnK9kNDRnaU7ah1l5Tu0lmLpbjTZpL+PrfGEIiRId7jfQlRUTMyZ7XEl340mZHBg6c4P9BtZJ56/DwkqRjA76Qqu6AwlpVUGyRzJcmQ9V6DoCSqS/J1NUsZXyFsySqhYkQkKowOyJHPO4Eq+wwXEj0iXRgbhvqtsvtaFJxPZKIacuqYlOTWuIHJyURL9OJ+MyfBgp65v2Rf00KNtm0wQJSpgMUoFkdJ4bJKNoZ2vtDUmCS/NJqa3WZhia2yKLDH5dmb6w4mV74J2bby8ahFTzHXXBSH52MfoEwcKsgBJI+dGxCSjIyfT1TqHg1BY4iMpznZ5oL/RKCFllpC4LyJySZDuehuOiHK6t/Jd32yNR+bM2OWUxjaXxLLd1tDavkdDm0uCjMd973A/VZsUFMw2ja9Q7D4OsJ9IsWOIZpTVquZ2/nV7uFgvrsqcB/KPRbcG+7j+nG/eSpKM7HPHzqrp9kbVWIKwRsrlodqKaoMWB/YCKcaju3HguNnR4Glr+mPVHHlNQ4FnHWfbRXjqcduFuinx39bWqibb1ceQVB3BXdmAi8Yr6c7e2ObtbzzMr+Ycrcaed6lDqp+XdnHYK2iktOZokupCTGStErf05+mdiIT4HzmWaQwAoiN0Y05cJGOX8zSn9j904aBIqfB5JWn7Bkii47ZCLlKiYzHhBNE6MWHwoL3ZaM2YTXpPREh8D+S9rWpAIEwPsIxvFKbcGFiGQaR0bNuY7bFJt3umPDI2ZlSYHLetnpn07K9qGB5S6pfG4w9EY+uJMVtbqxMttfW4ayyajUTYExfx8PO+ZkluGzjr4gfkOmhwx2+QE1ckc6QEeyOWce8MDb4LfJrZWqTSRkrjyabZGidmWFhjA2Q767grSLZjkwMMD5DurHznjA5w3rXUJskhf03dHTRq2n0oKa0BZrnspoB/eGwkkM4qETUxSdEvziwh5x2IKR0nZtKz/cVoO5FTwjrOKwGQ1UjSofu4fOeJSEh2ICQeZw3ik3VRbg8mdxdG26YoMT1czMjsNaYBf3Do4WJGBbUgpd7A55cMkZLV41BIS0n6I4VJjo5omirGMeRnxmYySkwxyEwxyM0kLUyfLmzO+OCGKUPSAzGtQl+8tpHnjNZ8krOBE5B75A/eLVOGSaynglquQ6LW7Q075tovRKC5lO1ARJDpMjcdWEp2A+uazHJTFIOafGeJqHQ5JUtIKJblnBIIabRtOzhAvmPJLmYDD1136rTbf6yY+KDYVcRaqfCy+FUIMppZfOi7O8iu4VblkMaEWfKd3UdFUnVZJuwgUZdsQks6vxcuXmycwH1tQBxfEP1gIeHEQ3scnrOUp5Q7qW6oW7IdxGPzltiRt8697xapy+EoiT5XWYkc3vvvhzs3VI47NOdlx50deV6Zbii/KcsUvGRXdQKPDe7bUZ2RdnHYVWikdAjA/wARTcXGVtSiI8hm7h+v1+mdZg+TA/IsxcQ2wLSdmSdmhDEQiBqcnIfIJUmtfGfcZYVktRb5LpTsOEKS8h3lkXypC0dK9h7vO8kwb2nTZG5GQp4MraSXT6iA1rj6JZgbSraII8RBgn1cmPSswpToWFCUJt/CL2r7qxq3osf5t+1aP1EeacGOvP2S8qK1SUFroXlAF2vv3uzQmYEJx5E6GRrwWSJKcoRPfQf5BwENXsys6WRjw0p7cEsiQgIp9QZmbI6YyaRnRpMNM5wcJffdach0ztyAZURHMDicOjMi+Q5/p1tnxjXHHfe5I6cd/sac0cFHTA21SUstmFV0hpLSAUWYB4hJeE1uPNsGBv8wbTNT6oUX/sIUNR0k4dEvVfuYRkxDykMBq4hWxsKJByoCMcF9F+bEJxH5jiW7itwq+c6bovh96Bpoc0tMWFjGe6ZJ3/RwQTQTM0o2rZQ3mZg+nHjYBrOXehsmQfIcOSSwCDnxCpNsj+0FFQ4z9MXbGpucckoY3WAJKt/MrU2cCLvq8GCPrz5Ida/IqcvMpC65pR27PH27Jpc7coTEROVbYlAeqSccdzyBuOfySM5xV2xSdDQsziLZblgkZms8JjLC38eZIfJIolCWckiV447kO5LxnHznbkxEXsILCKnpnBV7AyUlRSvCmiXklvxzUj4TxbQy9c1976y7HVNjp+U7l0IXrw+OIZAKLVxFLujHvaeNrkBHrs5JSHm14X++U4DT4lyHAftr3UUIuDnpjmQ7N2+J5g65LuJ0cXfERBFTQFJ72fWhjWjCmqUur2lDNbFXjP0Qy1NvxNJdzMKYC6nOd2+wM5O4SS++Ryvb2THn9oePzXHiVjQ47ri5cCg/z2qsWouEOkyYVcJaLpSUDnCtUuwXq18XmUBrJZkgwmJG4V5n7h80fnFmKB4NapWqCZ72HysMBxzhQFLBY3bGZbjAuLZAkO+KQL4j8nC2bx7SFi7z0DagXq/ELjy7HZYHsG8nVkLc7KEFzVGTpdtkEh8lQ5MjmQ5iwiDAIqcIqjwytFISerLBjUc9hNx8oC2EPKUZ4Fi4LU3NDj2uDdHlwlqW8qAM7mZXcc5hRSOkWFfwJeS8OBqne2deqEVFbrIvSXbUxglRT2oS7tQOEoLRBDd8HwO0gNq0hIR7t4zvbrs4Rj8ocI/oCH9fp0ZWtkNd0qkzY++4O701NluoLRuhz13VDXw4hGEFVdVuTAXGV+A7dFKejJiAWvd8JaR9gZLSmqMth+Sf83JGEBW55pVMQiTZgYTcL1RgkttfsJDOmKBgsMJ9iq4+SWKytJLpYnVIoWmBJ4hKgqL3EsPa/F4oCgMZsYxX5ZnS3qY3XWTp0JST1PR7cOJt24sgOj0cOWILasEeuB+OTHIUFnGbX8LohczdbC6C712fuPHEbLiD4hEXdKyCrFjSWzY5MeFMTZcNgpH2bj5VWyVvShDkI9ejBRO/xj8n6rxkLolySG5elc8lUR7J3fMy8khk/+5RHqnMNqzLrty0hbKTAVnAT4/G9DcB592prTH9/YGQOI8ke9zR8rCgH1SFIKQmxx2ji3Sn+aTdh5LSGqI1gpoBaQu3j23tEj/HEh5uaTo9xsIu82MnsU0sMVEeS3YKrzV1rZZrxxPkk8LnrXxnZTxJYOQEJ/muZ7Jy6OqmbDuiBIQE+C7UItdBgwDdxRR7db/6sVeS8hCNuYs2DwXM88LLdnxPt6ClGpsilkFOnEdixHJH8rlZ9nAfAbni4diyXJdIIsrSqccVSbkD9W5H0U4IHR+S+jA/6Zq0HT5Qm1RFzD6CFlKdr6Gr5UFtfpQ+70jjVQm1ga8WlJTWsN1Q1zomWaPEjVlJwnPt/vOejZDSdGLGmMTqIqWcIiVbMEt1IQWiJBvhWAnP/bImM4IfSErGCHs6FXnVoyBLPHwB4nXVcp387HuAlKxk6BRFitjs+2UmT3umzI6ZLBmZ1PXF2xxAokPogl/RY5P0QFaONcZ2G3TJRr2S/6xGE99P1LsZ8VlQtDk0aWqlPJ+mwvKWMePMRUqcd3Jvs0jeSRIRv0+4LJ3uoXVdbl+5sEX3CkE4qVyGPR7bBDk2b6N3Up2X7TAapI97SHUblcvuyKY9iCObJmHJbnDUmI2ziJjK/IjZHp9NRLRdnG3OjI/S39PJ4Zhu+Ds4cWZkTpwa0d/iqa0RyXaQmrfPjMz2GURKMDrYGiVyj25b+c63FeJi2Tkdd/xvRLH7UFI6bBCFs3a+jSWsqvWK/YWZolMDJCsxxqKWWyKySu0/fGrWagnGchU78+x6EFYV0VSQdu9pmU7awytXnr9muNdZe7jNKYGMcBFj+S4f23XokwdLcZYMqcMErOJ5tm2S/tjll0YmKcY2v4Q5FXDi0f3YJNTNoW8nqBal6ZGV2BVgul5w9XxE4fNLkoCc89xPbeBoiknGO/iCvHoYDYURUUyyi5FP7LW+M3o45NCRERsYmJD89q6eyxMSy3Qs28XySGKZimSF9ZuLZJFHwveEKAnL7LI7Bes3imQh2Q2dZFdMyA7uc0cuj8T5UD/qnPNHorXQIo477e6wd1BSOuT5pS6IdQ636yWBWNJhKY2jGhvJ0Ls723ZMogv724VOO+nyCxxVjvCs+w4EaO8RpVFeK2GyRFNYEJZtZ0QDAblQE6DWNiLc8J3Ec5OctgzDUh6NT0enB0dMNBRwnFFTUuSYcvH5+M/J5ZWkWy8kJ0lSMTRavIMIKrwPn2dCqhsX0iCPVMly8kaOO9knkDs18PbOAk7rpSwqb/y5p9UyGqyiSJblO5hgxhPMSrLlAWOf26xcd/zjiLs1yFvNsNBGLAs67hS7ByWlNcKUTCcceFEJz0VNkPBYyoOEx846XFhgdgBggbbRUUKSHepCQBR5lpATakKz8my1vb1O2WiJWwJZp5x466kxGDZvUH+O8wg2QuI8gj10IeG5HVNLIS/p2ee3C5trSpMetSLC+abJyGTlphmkmeltgBUc6Tg5z+8ZpofUkhB+bXNCn6Q8d+HFRQ+Rw6g3pGMi6/jpkenD8LFl2xJxrkl2GJ84LZCWg9xTuBzNHe1AystyK8nZvFhGy55c3Xo6j0C2w7YkzXFEdBRRj5PxjvQqx92RjcplJyW7I0ctCUG6g2wHg0N/02wXx4mQtsbHzdb4i4iQHt0am0cRBU1Kku5OnB5SkSzuUSgLUjp9GpLdiCJ63JNshzql7YJkO46S2DmJD5Uj3J047vy2il2BktIBx0wDQ2y2kjMcWBJy/8BIZ7cXWf9r091jwihLeDxeukoyO/MDRShVdGJvNjpiR17MxBDLFU2vtxFSbRy7JCXu7oB16OfpC2mtlAcuhvwDq3jS2zRZcZbJ0236HPJ82yQlJLyCZDzKMaF/Hs8/j1nFnZRH/3j4guemssrvxZiRyV2RLUl6kfwSR0j2+MV9pIFCZylPREcxsuqaR4KRwxKUJSSQkSek8H4Dy5lJ+qIwFg47zilhmeZbYT/OBo7x5uaIk+zQuQEElVXdGlyPO7jtYP8GEXHDVTvivPCdG2wD1nrnhqmpsrITehBJtXVG11zS3kJJ6ZCYHRZ+W5dfqo0EcN0dfNEi31JJLPVuC15tm4qWzEyikpIdE5Is4vWgCzw+J9nyqDJOAONJZia4GCJ6SbbJcgzCTPKh7SgAlkZzV1xEAc6FwD2IoYBbiJjQyDUzyciOUs9GGf0Cx8WcfpUPbIcM2MfBPSD1UNJrIqMuEp5cjuWLwAExq3iVE7JFwDV5zkdE9sU0gdcRFBMSbcdWbxgZpNGB2giJrt/cTsgREnVtwOfLHcDdiHM0WwUhjUs75hwkZFtXwTTjOtE7uY5meXHrINexAYSEv1H5YwqQRCQJqIsFfBY0StpdKCkdJlu4HGPhaou8hOeKaGkwH9q10AUOvz7tRSobWVMDQIllyCITFMgmZntkSQoXOlxIqBF0zXmHdSytVccjiUcSx1QDVhEhjfgYxMWFl+2F3h7HmGtrXKQG9MiVh+VjJofTkGuYyqEZIDI4gp1hSq61g5sN23HchjmFlfJwAiAgyp9k9Ks8RySBTuIoOO6lNLmW6rsGmV0uSpOdGXkZqUBeJDBCsIW8ScLrIuU13Tjy4eiIu1MA+aBaxjlQdAQicuuRQ8J0XiIfkBIkuwHs3IlJz+p7l11CMp2LiM466uW7mmS3ecwvD5PHmaKwLrvT43Moz3dimJrHtkc0SRaS3aOnh0RGJ06PSLbDd3/y1NCcPjUyBSbOUo87WadkP/cC987cUKtPipgb9txxx1ZURSOUlA7ZGIuwOSstu1Hp3AePEdZ+cGKfkssk09mIhe3heYbcEvJK+Ldnc0pEQrgQ1toDuf37SEjWI9U7gNdkOx8pxbuX29wSpLWKnDjfhALMscttgZBsnmuToiWejLvZG9qLJnd9mKC4Fhe3iR87iy4QfO9zTfZdTYbEGn+27mLGeSfaBk1d0dx0G90y7MVQmh3CiKlxFESb6SFCRoCV4tjObXNEtL3ogJ7VLN8pTeL10RFySYicQECtLjsXZfZ7JoF0B8kOERIkO3Lc9U2RHqG+doiOqNFquWG2xyiMHVPHBkRHcNzBaQdjA483H/NYCqwf1YtkvWwXFsbKWUni34i833MLuBJTK5SUDglac08cNfE/RG45lIb5pYlJCivl4SKAKKmS7sKRFpXrjklm6m0dIVWP6+MqQli5kA+5Xq9kV7KrLTEF3HfOmJGJaAm24r6zjQ9yKxnBypCXAzt/KYN3e2gvoBMkf0bG9EFWbg4T1TJlJh2PzWSI7hCpbeBKSXU0bkWa3lnF/a9xm4NLRiCrqhDZ14a58wqJSd5LRB12YrnmmBPRkZTpYGig7UNDA0dUICTu8s11R4gUw3qksEMDExQN7HOSHQ/sowF+fVNM7HwkWxg7MGeIiGyNm3fbCaedzCPx4D4r21VFsrOIiD/MnRKNSne7DyWlNcgrNXUM79IHT+4DF1I/xA3yHIb7+egIFwX70308Tm2bIVyr0XOun5nJBJEHOhs4iYtlpWDIUJhT4tNqKpalC5GcmSOq+GvNYV1kBKIE8sxJiiAk9yvY2sOzmpRX9I+bHgpf0cC1TKkd0aCXmwzh46SwUp5rSUTjLthGl+cm7Z+xURM6Phzp0S915JrSLSsf5afHpnDFm70jhZPyJqbYzj0pkdTkzgMTbmv5jxkyj+yyQPdihDudryMYJiPprGPSynG8jqDyGuE4UsLrj/QsGYHcjvWr1kGQ7JiMSLKzRbLJxtGqBmnjmO9rNyyPm3GBvNFRL9mdGkGyG9OPhZPDwjy6NaLvHJLdoye3rXwHye60ddmdOTU021vsuBtTbzuyhG+PTYF8n/tBwLJdWEfWJtspVgNKSmuCLm2EZKFsW76Jl6m3Gxsd3Jwljp5kRwdo/T00b3Wj0kFM2I6deAxLUPE2Qk3Gh9q2LNsFtUr+MR2veEOQpjsAWNgpYkiSKSlvnNo5THUpDx0fgs4PcOXJ2RTAeGxSXPxw8R5awptkKMbNrKQHMqDPc0SRCBkistROeeXvw10gQQ6VW8wV57Z8IHxugOzSzdIcS3K0rTQxSGcdDzOEtMd2byw7N53hqMl3aeBZSNytwUVH3GC172Q6REYs2SEi9S67PJDsCpLq8LeCZZ4ey33tcP71SbLWcWej9YIIqRYhiSLZqT+eGdjTYlmV8BqhpLTmLrwuc5fktvLGDBF2Cqdfpohe0LXBrQMxUXSCUekgKYpUaK9OlqtGTdRPZ1qui9nAQ7cdPw7t4dxajw0RsIuTAQORS5aabUQHFCXZe5by8rRv8mSTupmjJRG6ilM9E/JMqGOClRmdHzZEjsmGcnSfmtOm7E3IaUe5pgINaUtTOgKykl5hJhg4CHnRXUw550RRE/IigVMsa7kY1hqjBv3q2O5d5Y7c5NxApqs56zhScss+d8RGB3Ld2XxRJdW5x+ywIzJCHgmEZpdRGAu5To40h2QHqY6IiOz61XwkluxkR3rq9o3c0cg57oI8Uq2Le2j9ntPc0PRvQ7E3UFI6LAgkPLogypZDLYW0uP7gF2reQ6SQ2Ys8EsxOMqMLfp66+4QICZEJgAu/BYwPlphCSU/KdvzYExJbz10UVg0arAppWZ6z52mmCmitjTijY+TX4Rh5kCB3N5+UZ1FRrO340CNy2sh6pne0byMm9+sfLYnQ1brcOGUveCdPWafZeGyyjTOm3ELdU2kmkPRQxIkL5qkR5ZuojdNp1ENV7YrQBYLO27V1CqOlqRqa4IeF7PItu34zAdGyi4homW3dwrhAyyKPlB4B0bChQVi8jxypSMnJd0RGAyHZ0XKfOn6fKb7IFBNLSiTZmdycGk68yw71SJDs8LeDWiRIdvh+4LYjyW7sJLszrsfdlnXc0d/Glutrh89qXEy1FYrlkWaZG6a2Uew5lJTWFK0RUfAc/SN0HQaaCmlD+U7eILcAFClNUDLqGrdSxWydJKoZcPVeeNJ91wYZNTEpxWqWXItVDzJlcN1U6giVimrRbii1g1GJnHAhtxHTJMnpPsnglrPyHUt5yDclm7jgkdXPvgmiJ568ClmPpLzEJPS5JcZgsi0iKERHsI+D4N3YdY6aODKynQcyP6iu7Zc6R0C8LKMmb/fmSMe3S3IWbyHTQZrzBbEs2aVBdASZzo0yJ3cdGxloBAWMDdj2CA3ps9HRBhkbINmhMBbOOhARu+xCyQ4/ZmxkxIWxhXfayb52HO1MWb7l33TQraFL5wYlpP2HktJhQkN3B1x4/LKzhHO0VHoi4i4O1v3EBOW7O2DZyS2UU2LLNn54RybGxvrf1Wzhssees4HXtg/zSQFRUTskYx2C5MJDmyOOIEQ9EwhpPClsF21vFc/ILl4kfRrnDhlvkoxNHw1c8X4ZLoSOgGRbIkdK3JGV3PAgCFwMkTsCKeC8kHMautowEBHMF869R8/jexoERZ8zSGlqrARPhg2JCOAmqtLizTkljo6oMwOKXNOqVRAZGZiUXO2RJyWXR8qti5EcdiVGmJ/l5TvIdJDszpBk55qtbo1rkh277Nj6TT96yBpezfaSQ/tieSQZJdUeLyjDqXS3t1BSWmMXXtt6aWagtkNsEEilC8/+oufmOVw8i1EWuFB4Kc8V0krXm90OF/uEBgHSY9f/LjQ/xDo4xHrcTXWRcI9Z1qttj8YL3gVo+/WBoPq9zBMSeqmNN9zgQle8y53Gx5O+jZxwkZ0MSMobZJtm0H/MZIieEBUMz9hapu0z9gINI8SRM8Zsbdtc0+kzJkF7cMykOm2deiUIcstKekRETt6zpIRWR2VtbAZJePJCGpOWOOqVw/q4USrfu2iIJ8T66IgjJaznHBFewyYGHjvBHb4HIChsg/VWpqMIqX8W1R2BjM6Mvsh2aEDuyI2fACGhlx23EMIICkRFW9uFlezKknranTxpewiyZIcfQVtnxtTbjiIlmBzw+U3qfe1qrYUCW/hUc9ZVke3U7BCFktIhL6SdIjFXs8QdHqThoZLzRNTkIqUxsgWTtG56cJGSJRDag3uTqjlrrB6pOpSqNU+sWJYJqr5tZH98DBxFuagJ97gwgqwQ3Xn5jlx5RS1q8lJegqGHIzPABFt6QyHfgaBwlnJ2BS7qHEGhwSv1Edqm2iYyTIAY3ERbM7KRFOQ+LsqlZX8xbbloymF8vMxEFEp23CYIx8nFryTTOYmOZTqxnBBZub51VHOEbZ1kl9tIiEiptDVIHB3Vx0/YXnY8gsIXxjpTg+1fhxoke89SnewCTtG+LJCV7YQa8kjBH010ddP2GiXtPZSUDiGaIqfpTg+urQBqa0aJmfStDRx2alw0AHQmIHkMxgFXUwTHG/UqKxKyk3OkAiJwapIL9qa7O7B0xwjzRb5eKXDrVc+Jbbn9UNj5IbH2cFp2XR8wpA9FtlUzWVvLZLffIHceA1ET0KfptNOdVRPUOPVRgJwaM+xZUgI5YUYTTba1tU5kLhmMXFNX1H3BTeZ+xYOUuMC2a6RkD7bKKTkS8hGTJCJuIe7yQ7XcEZZZpkPPPxkdISLk3nUbR02ZICIamO3JMboHMW0Xx8jQAIcdSAktpHCPGzrKI4eECAk/XraGWEadmDFbW2OqQcL3hkgcJFUG1m9fdxRrHRROlG0YYRF7vC+EpI6+KJSU1lDCA2p5o0ghraxZsttPF9XyRYDn6ODiAJLhkRa2TU5ihr3U5HlphjRCBwWoPKqiyuMAWEbCH843epxMGx2muoHPiKTqLYhARJUrT2KKOF2UxMvDUUYXSerlN8CQOSvlwSGGZZzGWf2zzGZuTRD97KQZTE7Z5d4p0xucsgaI/hFjxlvUdTwZbBkz2iZzRAmJj7pBjCt5D98B5D3fvsi2MuLWDj5K9RdWHldbNkRJ7ktkmS6c/BeMI69FR0xEkOjoeTeELyQiyiMhIsrN9uRsctahKwaICI7FYdGnvnXDYkS5IxTEUh4Jkh162bnoyC6DlApz+tSQSAe2b8h2ICUQUijZ0XfuipFpGQTFbZ5cfon/httku6l/M+q2WykoKR0itNYsBRNp+XlfVCsu9txyCLqY77BA49NtvoZ2x4QiBwHSuIeUxlxY1EmVu4Hz6/2yqFWaqkvy29e3jWEyga098+2HgHFml9MxiMktp4WzjNejJshPkPN6WW5SmCPI5m4lvaREw9aJySDr4QIPgqJTTL2sZ/KRJRbX4NX2REKDzn5FWBi05AgqCXoP0ePIL/ha1Ct7DkkiksTEuaIgUiI3HUgI5MMyHY6fnXVpTjZvRESwzbOzDqQEqW5Y2HwcT4nFPT4z6vgNE8NwMm1ooEaqztAAw4OT6kBS7LKLSXb+bzaSF2qLkJrWKVYHSkqHqJC2tWZJSkCCoKQ9nFoOoSsBFTGChNAazmn+ZAoozBiFmRilnk3MKLORBy74aNBKtmzRk47fonrbDvkhfwp10qL7yBBANjXIfRHx0PlbG7J8ntsUAciL+dckiW8ciwjqSO+omWTIN8F8DnOHzTn1M0SNW9Y6jkhj5JZxgR8PTYIcFGqc0FOP56RTIa5b5nbhnJOKNMVL5p1pwfMsZNTkJuv6OiOQD+eKSOKzzVPtqAnXSNWNKUfeCMREnRkmGD2B6MiYYWGjohMuOsIN7jpEpCD8U66FED5zSHVYtp2+rVFGNlilYlnhspuS7ELbd8c8UldzgxLX/kFJ6bAaHpw9HOBWN7Xhf7zMffAoR+F+waaFycbOyID8Pcl3qRkOE4pE7A9zztXU5TuQCVoSgbh4XQg5M4lNDjHUWg5xfzxBRpxT4nvAkinO2xb84nhpPeXAnHxHF1GQTGLODDJzZpDTtvaXP6IjY472MnOk1zNp0jdH+0dNnmxRrqmfnTK99Ax9fpD18gGGCY4tOYGIQFCjLUtOiKYwWNDXPlnLOQ0YlGTERGVPTH4A/MFW6zgyAjgycssJ7P4gHx5Hjpwey3JY5ojIRUcgG/wNDCdnmWIEUup5IuK+ddapWNSI6IQbJ4HP8eTpkc8d2YmxlnxIpiMisjKdH9rnbOBUSBxz2QkTSEyyC5eVkA4elJQOcS+86JylWl6qbh1nIvNdw932FDmhJii3NTaIwiRB1FxyYhDfVGeHlsioNbcUPCVlxhhATKgfqizuiRm75rGI+CjflBREnsMRmry62VHOCIFISY54x+1Ir08Xakh59NlhLlWCC6kdv45rvRvz6w7SdoWwjjtIehhL6ybdIlphgmpqHy6XG0bSUm6IP2NPRHg+q5adLGeJqJLsuNYIAzpYpuPpsOSsK2yvOjjrrFRnl4mYYG4gQ0Phi2Gpq4ZrEwQiItemMzRUk4ztvezKEJPswu82JKQu0DzS6kJJ6ZBIeFOGh/B5JiJRQMvSnewejufhxINUR/kZRB45LiawVeOXbmV6ILed6xpOMh71v7OyGSKlal1wSg35ozbSmtoHR0niIs5SHk4RZAECkvIef5QcgYGQmFCpIBh1URiE5ybp2oazvAzySc3R/nGKJCDrgaSydJtyT3l6xuSp6KfHkRFs1UGnCL+M76OsCnU9CTGxSSS12RVuXWKXaZquMy0AWIY0B3C/uiQlsoE0h88Gha9V7gh2b7uMDknDYuxt3jCBcO3RyBHSiVOIiGykZKMjrJ/UDA1cgwSCQoREy5DuXHTEJoZaP7uGERXyb1z+LbdFSU1Q2W7/oaR0CI0Ncn24TBAjLaJOPEQbyC2J7gkgKFxg0rS+Xvals4W0eI6a6VCfPJbxZC6HCanN9BCDbInEZozmPBWbGpzhIc9MzlNt+/biagtsCzOAJAmjwyA3GwOsN+ZMPzf9fkYGiNOjzGyAfBO73IcRIulR3gljMRAxQdJDF3JeJoMEaqEGlqiQc0tKl1MiInLdI/ix/RLihCTBJEQfajxSgt0E+aGyzMjCPSl6FAFzw1Ss54gIZMudGCDTwVHHY8rZ4o1IB7kjjpBOb1nJDo/Rv45NDFtnMDHWjjFHQSzZvckAYQtf2VlHxDMWxbBipEcnyc7+EdX/plctQlKzRSOUlA4zAnt4tG5JPJb/oCtzgSyoTWuDAKfku7RattGJJT0yEQSdG+x7mM5RUtSRF8kvNcIVuNZkvQxRnhsUWFqC4qJbREK0b0dGgJX0cPy2EJdImMwQ9p9ZidlMTt4jIkLeLs1M5mQ/zHBKMxgZQD4urySJiJZnnAdHR/QmIqeUMBEh4uvZZZORpRuyHEiJTQsTIis7WmJSWmkOpISPsCIo29WbIyIQEE+HlVNiufiVao0cIXlzDBdfO0NDrKt3Y51Rm2Sn85EONJSU1lzC69p6qBZFsW055sTDpRQRU8/mlPjCAuACzvkBvrjjwo4LFkl1MiqielJrkKC9irRIbbpsS1TU6aNpcfJ5Oc+RkSdLzEKiZeQ9bOTHJg1epotuD9JlYsYuaoKsNyxScuCBkDbyiRngHNHeKMtNP4MxAsubZIoA+UDeo7ZFWMY6RExkNbekBZu5zU+5Dg8uk4fIqnYupZsczBOEy8wZVci4TgQ0caQEEsIy1nOuCNuCkCwR2dHkIB8snxFERHZvV9+FnnVV/sg2VcVjdtZxh2/8IAAhIVLiqEkaGjgSomX340DWINV+EM2S7FqwMlGSohVKSoc0txSzh3tiCpx4KASljtU0oM6SUUp6f4o5eiTZ8UWBogrKI1mrNS7s+DPjLgq+L56LLng6bNSFJ/JKoaQ38+OQ0l0g7dQ6Rrh7nj8E5D309rPHlOUZ/eLnrucgn9T10GNZ73QPBbR2eXOQebIFIVmCMmYD8iCNZjfWNp4OHEGdZdfDf2DGJOvhs2KjBBMSqAWQRora9+rJyI1bx3fHxFSClCwZUaSEDt4gAZcXA+EAW+Ntqimi7grOuEAREY8id0RETkVBRFwEy22B2E2HiIiMDK7miOuR6IcLF8OGU2KbetfNIdnRcwvIY5pPWnNSeu1rX2te+MIXmmc961nmrrvuMjfffLO59NJLze23326uu+46c9FFF+3WWyt22D0ckI1aGyMtXBgpt1QvpEVbnJo9m35x2zEWoZTniYqCM9F2aAeae42Agl/HLDVOI/VlU2wbr9U2OSInSc8ZHMJcmCVhEeE5L4Hd1o7IsPOl7OfBHS1svz2QFYwROZkbQE5oFcgRVMGE5NZNnbMo+mJi4giIzrvMKT9k368aOc8REJZt9wobHbGBAQXNHA2RndsvVxETF8FWUp0lJJLrXDGsHIMiyaYalTJde7SoZBctmJ0RJSkhrTkp/f7v/775pV/6JXPllVea7e1tc9VVV5k777zTnHfeeebiiy82V199tbnlllt2460VO5HwxD9m2aaIHjsnngXqRrgDte2Fl6ZOsqOO4WwiQLRk3XfULcG9XEp5jFlOvFmQBbB0XJF81KSNrIqiIh4X+WE/1IWCc2N51Q0CZghEQzQiwyX1yUo+zMwA0RSioH5KnSEQObEpwkZHVc6J7eV2npONqux6uw8AURUdl5hFNfU5RWZTMdnYZZANHIF2mSMiS1B4zniCYhkO50VSnutTx90YeJllOnyuHB3h8+L+dVx7xBKvH13OdUcuAmqNkOwXFyWkzo66VZPt1OSwt6T02GOPmU984hPmK7/yK+nxbbfdZs4++2wiJODyyy83d9xxh3nwwQf9uhAgMtzkPhXLyy2FzVdbe+I5GW9CgpDtgI3/+QsDRlvg4k0juNFqx8pcWAYocS+anzI4QqpMD5WEN+XEk4aFOWU8/9H4fbhZULFcE7r+uEhG5pqKsSuwzScmdbLeaDszGbpXcIdxVzQMGY/7/5GMR2aJhKQ++7kYK/s5ydIuMxFVtU8gKHp/91yMkFiFldfcarx8fUYVEw9P+OUpvxztUK6Hoh772cgoSG7D5gWW46p6Iyvf0X5cVwYyNfBAvrAAVrrrOpLRIpKdEtLBw9JJ6d3vfrf5oR/6IfO+972PHt93333mnHPO8c9nWWaOHTtm7rnnnkZSuuGGG8yb3vSmZR+aYokjL9j0QIMAI7ZrduPhos7SDT3HA/+clOebstryJW8oWASxvFQMrUW6kefGxlrdqRkeCFq6EAOilXkyL9+VtibLr3fkwuTL1vRJWTWytYMHuTi3eo1sYjt17GVITHJOlSUmAFGSHzniOllQuz0XAeHzp950bpnJiYfvyd50kOfY2s35Il5mIwMgx0xIs4LMF/nHLYaGGtRlt5ZYKil94AMfMM9//vPNYGDlBuDhhx82G2j0KIDHjzzySON+kHO69tpra5HSBRdcsMxDXV/sxIkXmB4Yje2HJoUpQTpwSUHSQrREveTcr3xhgKhGdo+d8UEcQGFI5kqFhCeNEP7U5iArewyBQy3IJYXuPnmsstbKSo1V41bsm/IluRsDT22WMhslupZLPPyQRsLTmIvMd09nUwRHU0xKeeYKijliCkgLgMOvDeGARF5mguEpvjwYkSQ6Xyxc+MjUkpLt0FEnoqppKk2GdTIdPo+p6Aj7EoYGPyXWOe3cQVbE1WJoCL+jECtbj6TYP1L63Oc+Z77whS+YF73oRbX1x48fN2Ugt5w8edKce+65jfsCqUliU+yREy8wPTRNp8Uy55RIlvHD5er5JSS/py+suZf27KEK0wAiBSfj4Sjip9Ytx8Tv2ZRL8kn3WJ5JXNBwpJxrImKlfbp6JUe0o2FqstyeE5MSnQ8cd26AlOyzB/LhZq9y1Ae/jglJElR4Tk2o9QMU+TjpZPQExR3enTRXtfuxPem4ALkWEQlSaiKi2hRYtnXLqEn0r4vJdVPrQ9LZBcmO/pZ3O9ejuaS9JaUPf/jD5oEHHjA33ngjPf6Lv/gL8yu/8ivm277t28xDDz3kt0Ou6MSJE+bCCy9c1lsr9tgMwUTGkox/li5uzu0V5G3CYlsrV9mX8cUya3Di+X0EP25iuSVbZ7RAzmnKpce1V5VcNx17+a19Por7ANLx88TZKaAOqho0SP32hLzHESNeHtrlZb4tBklCdB/MpwrHyduIyTokWaKj/YwrCY6ddERQYgqslOl8ZMNFsHJdpNaI1smLdEBIEk2EpFhPLI2U4KiTeNe73mVe+tKXmm/6pm8y11xzjbn//vvN+eefb2699VZz2WWXKSntE5qKZsPn2toPsekBWXvKKeGXsR8why4FCXUSp4JUN59I1gHJYlUp5TFZcQeFELVf/S1FsWROkHZu/AqmN7G0Er6mqU+eva+IpepsnvoIiqMnW49VtVyij0IYPhAx2e0QhY7ptbKTOo/TqBp818dmhCTdZp8PCcl/ZmIIorzRSBIahGijIPqsXfcFWu/yRwDXGvHrPOl0iI7azAyMVoddQEjLNjbsSbSk2HujA8jnne98J0VNb3/7283p06fNTTfdZK6//npzxRVXECmhZkmxOrmlKWKipqwiHyQ7PbiaGM4vTUb2eeSXSMbLbH7JDgwPHHdCKmQpDyEGR02QtbjTAxsIYhFTF3TtkF7tt05WbW2LvDvPT0K3ZMPnyMW2MhdkScgSkycyR0xyH96p6O3p7YQUO9aQsGUvQF7PrZfqNUQ2EgJIjvPbiAiKiSgcvMekE1kXzRFF1u+EjORrd4KpH2LLgpJdZyRlmPBZQcDogNzU077+bSbLNvf7cA4OZlyY5YVb5pb8+qy6SOJ5LNN2uLi6XEmCpH0vtc/n1XI6yE1vkPnIocedEMT6Xj/3EQTlXJxBIJboDy+83OjV5kRsQr6WF3FjEXjZyk/VhVfmlPjCG61nikViEcdddW8dh/TxcY5IkBAAUwR/znJ9jcR4/ERAUl3AkV+MiPj5kIyqHobVc5Dn6LN2nx29lvvUdSEk+8bRdTEC6pJDmnpuF80NSyUmJSVTFGfM3X/0I+bRRx+lMqEmaJuhdYaX3XbR9CAm03LOJaEuEAVFS8mUSWAc/CK1rjW+GDJB0bYIuiKFtjKR3xY5SfLAJAjfBLaB6GrvEfn17vclLeFT0Z+ocRrVI6iqXqvKJ4WRlFxXkzsXsLvXrPhMToJ8eHu++HKOiJZ5FLmT5nh/MSKi/XRx0O2QjKaePyhuOyWkuaCkdIjRJONFzQ2h3h7JL2EZiXiavOBGXHB/PLsJX6DrBoCpolrML3J5GWrpE3me3nuOf+x8/FZCqwhwlpMv1u6m9ryMqtz78NlZQo4QUBANSXdf02cyD2KRHkeEdl09KvTbSBKRzVDDyCdiYmi1cs9LRnNER+F+loldk/IUrVBSUszlxvOQncT5cZbVCMznp3wfOTfeorCWcflLHuQja4MgxyHxP/22EYlth44sa7qYXj9XwSbXd8VyUQ3vyw48+1GiGaD9XMLXyM+lCTGClkRkt4lIeeF4CJ5DFFqzI+Mk5HaNyweUkJYGJbS5oaR0GLBT04MzN4SQLYjsPqqaJS/lOcluvJHX5Dtp3Wb5LkcHCDckkNxnrs8cO9PodTSvKHKKDf/4p3viCeITBGrft8nC3aE+JvZa/qUNHRPmjdZcXhVRyWNfBNFIKSSBYAheY+QTmWnUVFcUvlZuGzMz7ESuU6wvlJQOC+YgpiiC/FJITFOyHhqwYt/CKl5dcqquD7RMF2b+U5yYvsl9NOVJiWubYqfWIOdZoqmIzVvOERlh/0FeqTXPFLmIz0JtG5dzIXlUbCM/d39ukQhxLjSQZ6P1OlI3tJAMFzzf5f3D452HkDRKWk8oKSnm6n3XWGTrjBDcE29qG9fCSCbe7aTaeM4DTV8nDV0ZFo0gmmBbLE1fAHm2VBfMuoCGzXBbt20U/LqhCxE0FbJ2JZym5+c9ji7ncCBx0I9/H6GkdJiwgIzna5WCTuKxiyhqlkAmXL9Ez7mhgFW0kLvBgFbKY/cdkE+sVZyez2yEw8+HNT3R0+vgxrMznKreDD6CcnmlGAn66GVGrqONcBqf85/Tcoh26n0mc0ZNwevackGzZLqm99lphKRYbygpHTbsJL/U0rQVYKs45Wh6lqRgD/f5Jde8Fcu2w4IFSAJE5C3hk8x1Q6hIiMZ6s/QWOPKmTjFCACzZybxSjKyq9kLtlvHa59ZwoZ4HcCwuiq426SZSmicHFO3o3bb9HGTUdi4HCutwDvsIJSXFQmiV8XikeupyE+j+kIpO4265imwmVIskpT16HHZR8EPBmxFzm8Vge9qx+40Jt6PhYQ7s1UW2KRJrI4u5CWYZhNR2Dit4MV/FY1p3KCkdRiwpWor9g60ZH0YFvbZRyitScuVJgA64C4O1jTv5jqKkyrSAyMm/Z1BT1RUy6vISnjNA+I9qgf3Gtp8nKb/IhbBx/wExd46egtfOIptOZLTkCElKnrtheliIkJTEdgwlpcOKvSKmUNaTUp5o2Cnlu1gD1KqhKm9XbYsIaur0RE1OCCnNSVceSXiiZim0k5OBg86lnQAWjRzmurC2RIFdoqbodnMQWNP7zEtGja+ZE/OYUnYNSkhLgZKSYm5i8hD5pdprXSsiX0zLcp6X9epSHr0GBMB2ctqmWrY0lpqk8R99w0AJ2bVgjguWlPCIrBpeO93lIm0ni465nyhm5Kq6ElF025hzblmEtIfwP5z2m5wUO4KS0mFGS7TUmjeS6139UhzUvM4V16IeBiMk0krKo5Y1Tp5z0h3Ld7KQlkdD8DqgZoSY6j8375RakVeiw66iMFpfk4nq9u6Y1bvLCITohbOBeGZdZOcmuxkR0bz7bDzXfZp9tAxymptgNUpaGpSUDjtmEJME/yOfsorz87yO++fRSIsWKQ+dxsXwt1Q0OUVDUEh0tF83l4m2cVNt0RiCHXwTN612tvGh3S7uJb1Awqu9liPDOc0QXXM3jdtE9tNl+3mIbt59t164OxLSbkZXeybpKSEtFUpKiqV0e5AynpTqgJiUR9tJ+c4RFUB5Jjcaw+aGbNaoTip2fftEWLG1LNJtuIjUc02VPTyGMEIKL4CdB8atCCE1YaGL+hwR0oEfrHeQj31FoaSkWJ7xAY87SnnSlQeQfOf2SySD+UiuAwSkO6pfKrKpaa/VsDxXO7XEbg+yyBaQl1rIeEDtc6AWQvW8UpVHE9Flyy/4rhHMsohoqdHRglglYlqV4zjMUFJSLI+YwteE5oiIlMeTa6lXXs8WkVIMhEjJTbOtuoxbRx6RhY+kSrdOdmVIZ+aYmqIg7q9nibF6zVQxLQYgBvGZv6A5wwNfbLvKSF2cesvKRe3IdLELWCVi6oyDdrwHBEpKioUxyyoeNm9ttItzo1f+R+4Kbun51DZypU7ibh3R1sjmmmoNTb2lnLsyVGQmIQfezQMmrKYLd03Sizjxohdesd3CEuCcWNWLv84vUgBKSoq5oiV58VhUyrNmB0RAdpCfKdzIC65LYuJAfRIZIkrqrM1OPZL4WLpz49YLOd12PD0Ftglhh/FYp3E7B0qQBZ+vOz8/3iPML6X1aErKeDWHWAsxLYpF5LdFXX5TiPQJnAeLFkPvBHO9z4qS+rpASUmxY6v4PFJeY16FJp1akuIoyTrcMj+vydc3YR9OvuMx3jwkT67fKbjDQ1e7+VR+KYwSI/klsfOoDLdItLSX+aDdIiaGRk+HD0pKih1bxeeR8mSEIKU8HnthXy+G4DkiokMaTaiAlvblpDQ/EJAjEnQqz2x3hpAcw6hpOs9UOfTMrJxSV8IIyKZLJLTTaKnp9TuVA+d+/ZKIabehUdJqQUlJse9SHr2V6ygO1IYDukLbcmxMkmfVNrz/LDUj8b55Xnr5DtETYi0/YnwGycqLk5zt1JZbku2HovsMZDwp3cW2c29at9RzriqU/aoDms5fLUBMnQhzEWJiLEHSm6vBaxdzSdf9qWS3Z1BSUuwI80p5jRdENjywxGXao6aaxMe5KZrQJPNIfBGs6pn2Gl3NC21yX5f9LrrNQvtdgCBqBLUH0ZO2Gjq4UFJSLFXGmxUxhb3yasQVWMYJqe34wLZxRE3kxHORlX0taqBs1ES7EU48K7vxiIq6XdzIKCpyIW5r6tqGMHfUtX6pOqi48aE1ShFR1szjmxHtdCWzheXAFZH1NEpaTSgpKWbD19/sUMpr6JVH2zLBFIXvkUevd+Mv4NajdW47kBNth/ftuem1RFpuP8hloZmqu8jK6EkOD5x1DZeE1EpOjhC5i3j0wp7Gt5mKJiNSnv+cIlKefw2/R0B+U9t0cLh1HQuxsFNuF6Mmle0ONpSUFHsm5QExA0TXqCmscfJw/fPkhTTc1gt5MybKdpk4O0/k1FRA21ZYW1u3iCtvjqhp2ZETsOpmCI2QVhtKSoo9k/JqiMxjCi3j3Ymp8IYDSW7eqVdgnS3Q5VZGdDqRserLJKSZeaSAmHZCDl0MEG3ds7u8d9Nr593Xolio8/qc+1DsP5SUFHsu5fnnRZ5pal6Pz0VZOY9//dv1lXRHzjafW6rkO5b6+L1AUCT1BVNrZa+8KHnO0wpoxi9+WVTb5JZbRMqTxzFFXJGoaVFJT75218wQq0BISlz7CiUlxZ5JeUBTnilWzxST82ZFU/51TVKfsKHTcYg6qXkdW7MIqVWaC/rjNaFJypvbmTdjAOFuSXqrAiWkgwMlJcWuRExNaDNAtPXMA0Ki8TKdWM/dH+z7sCTmTBIB0VFU5VsETTsDO0MQkrz47YYduyuJdCWmVnJbEWLaaZSkkt3BgpKSYtcLbIGmqCkm5zWPv7B98uz7Wkmvcu5x3ZKYbutlPVGAm9afl8cWjlufOUcqcp7hOYbPd83nNI66aJDy5PHWIslYnsm9vmuuqekcp45tF/JLO+nVN+v1NahktzJQUlKsBGJR06y8hys88q/323D0E5okhLTHz0tijG27SK5kWS2Cus5gmmefy9huWa+bhZ1GOEpIBxNKSoo9kfJmGSCmtgmiplZJjwYgpTOfm+owgW4Q3DGCo66YIWPRqa1tEdJkOZLfwqQwZ45p14hhATv4UuU6jZBWDkpKij21jM8yQExtE7GOR/dXuCJbdBHnfQYFubS9cOXRNkLes+cgjt8R1TzuvHmnw7ZGXG0XzBZSiUVzO80xtclwC0VJLWS0kyhUo6ODj/1oB6ZYZ3T45TkrBzO1DS5gHDlxJ+/Y2HCsw0U2uOjTjbeHW88V28b2x9vztrV9udfJ18eOofH5YH+zPoPDiN3KPykODjRSUqxExNRkG6fHHaOmWbLeVFTlnpcWdH6/2rHQXKeIlLeg+jUvKTcS3Bzv0ZXwGsl2ziip9TtqiJI0QlIASkqK3YG8KO3AnTdPwW24724ENC3beXdeYHYISWleOS88v9gxz9w2QkatUWYT5sgnLY2Q9pOMAI2kDgRUvlOsLLp2T5gVVUjpjh9P7Vs+btguFn3MkvNi264qVu3YlJAOJzRSUqyMnAfEJL1ZDj0ZNc3szOAiJ9qXNEWEHSTkdpNuxocdW5g7GCPatu0Uae1wf/NuuxuGBo2O1htKSoqV6gDRZB1nhJJeU9ugTgiJR5DOVGGv275+DGJfEUv6QljACNE5f9SRjGL7nHdbgsp1igWgpKRYyU7jMSNEa9dxhii8bTIuNBsa3EV7BjnFbOy1C/68BDXLtLCImWDO95i1XyUkxV5BSUmx0lFTEzE1Rk2RKbedpb0ZkVerlBhrhST32UCkixbjdtpHAxGtdXQEqKHhQENJSXEgck3ALAv51PaCXLpayXkfsdySfc4tSKt5hwLbZdXQtF7AlyD9zbvtonmjpfatA5SI1gZKSooD0218YUkPCKKncH9tUVCrXBdIdTvpANGETtHUEqKiRbZf1MgwC1oIe3ihpKQ4cLmmWT3pGmW98CI6R/TE+4tJdc3R0ZJMEB3yQYtKYAu53HapRdCs10ehEdLaQUlJcWCjJsZSCGpe515wLK1jLgLX3tz738nwwV3uwjDrdUpEinmhpKQ4sFFTF8SkvWaDQn1kRtcGsnKf0f0Gr90NdIkwFq792SWJTqGIQUlJsdZRU1uep0v0NK/Et99YSmSyQxLS6EixEygpKQ58D71lE1TttbEL9AEhqk7H2GGe0b4REeMAfNaKFSWlO++80/zBH/yBOXHihPnYxz5mXv/615vnPOc55q677jI333yzufTSS83tt99urrvuOnPRRRct860VirlzPW2uvUaJr8HJF3tt4+t3EZ0v/HtIRl33NQUlo0OJpZHS6dOnzW/+5m+aG264gR6/733vM1deeaX50z/9U3PVVVcRYZ133nnm4osvNldffbW55ZZblvXWisOCOaOmeSOnuSKoWRf2oHB3XzDnVNdlklDX/UWhZHSosbQu4X/5l39pbrzxRroHnv/855szZ86YO+64w5x99tlESMDll19O6x588MHGfW1vb5vHHnusdlMopi5cfOsIP/BPDvKLbdfS/TvcR+O+eDDhvLcmLHFfnc8h8nnMQpf9NWLO71OxnlgaKV1yySUkzT35yU+mx5/5zGf8/TnnnOO3y7LMHDt2zNxzzz2N+0K0dfz4cX+74IILlnWYCoVH5w4Pu30xlpiXrDpikeObZ9TGjs5dyUixG6SUJIl55jOfSfcAoqZXv/rVZjwem42Njdq2ePzII4807gs5p0cffdTfPvvZzy7rMBXriAWipnkv1mH01DoSvSESabvt5Lh3uv95zq3pGPbyO1OsN3bFffee97zHPP7xjzdvectbzH/8j//RlGX9D+/kyZPm3HPPbXz9YDCgm0KxF3knRuziOsuo0HbxnqdYdrdzTzutkVrK8SkBKfaDlD74wQ+aoijMW9/6VrO1tUVR0UMPPVTLF8Gdd+GFFy77rRWKpRfhzuzW0PbaXeiDt+j772g/SiaKg0pKt912m/nc5z5nXvSiF5kHHniADA1PfepTiZTuv/9+c/7555tbb73VXHbZZUpKir1BeEFdgGCaLsrzkNWqjRrfE/JRMlPsJyl9+tOfNi984QspCpJATuimm24y119/vbniiiuIlFCzpFAcNHlvN8hqP7CrkY8SkWKHSMow4bOCgCUcLrynff3bTJZt7vfhKNYJe0Agq0BSuy7BKRkpZqAozpi7/+hHKFBBmVATtM2Q4nAjdjFdMomsZU5mHc9JsRJQUlIodiEPtVZQAlLsIZSUFIo9zEMdKCgZKfYBSkoKxbIu1AeRsJR4FCsGJSWF4jAQlpKP4oBASUmh2E9SWDZZKfkoDjiUlBSK/YSSiEKxOw1ZFQqFQqHYKZSUFAqFQrEyUFJSKBQKxcpASUmhUCgUKwMlJYVCoVCsDJSUFAqFQrEyUFJSKBQKxcpASUmhUCgUKwMlJYVCoVCsDJSUFAqFQrEyUFJSKBQKxcpASUmhUCgUKwMlJYVCoVCsDJSUFAqFQrEyUFJSKBQKxcpASUmhUCgUKwMlJYVCoVCsDJSUFAqFQrEyUFJSKBQKxcpASUmhUCgUKwMlJYVCoVCsDJSUFAqFQrEyUFJSKBQKxcpASUmhUCgUKwMlJYVCoVCsDJSUFAqFQrEyUFJSKBQKxcpASUmhUCgUKwMlJYVCoVCsDJSUFAqFQrEyUFJSKBQKxcpASUmhUCgUKwMlJYVCoVCsDJSUFAqFQrEyUFJSKBQKxcpASUmhUCgUKwMlJYVCoVCsDJSUFAqFQrEyUFJSKBQKxcpASUmhUCgUKwMlJYVCoVCsDJSUFAqFQnH4SOmuu+4yr371q81NN91krrnmGnPvvffu1VsrFAqF4oAg34s32d7eNldddZW58847zXnnnWcuvvhic/XVV5tbbrllL95eoVAoFAcEe0JKt912mzn77LOJkIDLL7/c3HHHHebBBx/060ISw43x2GOP7cVhKhQKheIwkNJ9991nzjnnHP84yzJz7Ngxc88990RJ6YYbbjBvetObptYXxdauH6tCoVAolg++fpdluf+k9PDDD5uNjY3aOjx+5JFHottfd9115tprr/WP//qv/9p81Vd9lbnn4z+x68eqUCgUit3DiRMnzPHjx/eXlHAAITuePHnSnHvuudHtB4MB3RhnnXWW+eQnP0nE9NnPfpakwHUG5MoLLrhAz3WNoN/peuKwfK+PLeE8wQEgpCc84Qmt2+0JKX3FV3yFefe73+0fI1+Eg7vwwgs7vT5NU/PEJz6RlvGBrPOXL6Hnun7Q73Q9cVi+17N3eJ5tEdKeWsKf/exnm4ceesjcf//99PjWW281l112WWdSUigUCsXhwJ5ESnmeU33S9ddfb6644goipZtvvnkv3lqhUCgUBwh7QkrA8573PLoBL3vZy+Z+PXJMb3jDG2q5pnWFnuv6Qb/T9cRh+V4He3ieSTnLn6dQKBQKxR5Be98pFAqFYmWgpKRQKBSKlYGSkkKhUChWBkpKCoVCoVgZKCkpFAqF4vBZwnc6iwl1TZdeeqm5/fbbqTfeRRddZNYBGOfxB3/wB9Th4mMf+5h5/etfb57znOes9TkDr33ta80LX/hC86xnPWttz/Xnf/7nzQMPPEDtWYqiMC9/+cvX7lwxF+23f/u3qZclzvXKK6+kc1un80RLtB/4gR8w73jHO8yTnvQkWtd2fgf13E9GzrPp+rSr51muOLa2tsoLL7ywfOCBB+jxRz/60fI5z3lOuQ44depU+brXvc4//q//9b+Wm5ub5X333be25wzcdttt5d/6W3+r/L3f+721/X7f9a53lT/2Yz9Gy3/xF39Rnn322Wt5rnyOjJe+9KVrdZ6/8Au/UL7hDW9A2Ux577330rq28zuo5/4LkfNsuj7df//9u3qeK09Kv/M7v1Necskl/vF4PC4Hg4H/MA4yPvGJT9Afwac+9Sl6/Nhjj9HjX/3VX13bc3700UfLn/mZn6E/YJDSOn6/+Af7uMc9jn5cAJPJhP6hr+O5PuUpTyk//vGP+8cvf/nL1/I85cW67fwO+rkbcZ5N16df+7Vf29XzXPmcUtsspoOOSy65hMLeJz/5yfT4M5/5jL9f13NGY94f/MEfXOvv96Mf/aj5whe+YD71qU+ZX/3VXzU//uM/TtLWOp7rD/3QD5lnPOMZNGoGM9Be9apXreV5SrSd3zqd+yUN16enPvWpu3qeK59TmncW00FCkiTmmc98pn984403mle/+tVmPB6v5Tl/4AMfMM9//vNrrUrW8fv9/Oc/T/f9ft+85CUvodzZl3/5l5trrrlm7c4V54fcAr5b5CSQI1zH71Si7fzW6dyThusTckgf+tCHdu08Vz5SmncW00HFe97zHvP4xz+ekozreM6f+9znKHr4mq/5mtr6dTxXbs+PTvg8D2wymZgv+ZIvWatzRfL7Fa94hfm5n/s58yd/8ifmn/2zf2a+4zu+g0YbrNN5hmj7m13Hv+fw+gTs5nmuPClhFhPGXiw6i+kg4IMf/CC5s9761rfS+eEXx7qd84c//GGaIIxfW7j9xV/8hfmVX/kVOqd1O1f8ksSvTHynDDzGTLB1OtePfOQj5MQ6cuQI/c2+8Y1vJDkP5LtO5znPNWkdr1cfDK5PkO529TzLFcdoNCqf8IQnlJ/97Gfp8Yc//OHyiiuuKNcFt956a/nud7+7/PznP0+33/iN3yB32jqfMwDnDowO6/r9Pve5zy0/9KEP0fJDDz1E5/jII4+s1bkiEf6yl72stu61r30tGTzW6TxDA0Db3+xB/3s24jybrk9w2u3mea58TmmdZzF9+tOfpnwDfmFIPProo2t7zhj0+M53vpMS/29/+9vN6dOn1/JccU5o9f/JT36SvmfkXCB5rNO5Pu1pT6O6pNe85jXm/PPPp1/LGE+DX8vrcp7vfe97zW233UbLr3vd62hg6Stf+crG8zuo16v3Rs7zBS94QeP1aTfPU0dXKBQKhWJlsPI5JYVCoVAcHigpKRQKhWJloKSkUCgUipWBkpJCoVAoVgZKSgqFQqFYGSgpKRQKhWJloKSkUCgUipWBkpJCoVAoVgZKSgqFQqFYGSgpKRQKhWJloKSkUCgUCrMq+P8BAjKHZC4CgEIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Instantiate a simple galaxy profile and PSF with Galsim\n", + "gal = galsim.Gaussian(sigma=1.0)\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "\n", + "# Instantiate our custom transform object\n", + "pinwheel_transform = PinwheelTransform(\n", + " radius=2.0,\n", + " g_max=0.35,\n", + " turns=0.8,\n", + " phi0=0.0\n", + ")\n", + "\n", + "# Call the BATSim renderer to draw the image\n", + "gal_pinwheeled = batsim.simulate_galaxy(\n", + " gal_obj=gal,\n", + " scale=0.1,\n", + " transform_obj=pinwheel_transform, # pass our custom class\n", + " psf_obj=psf\n", + ")\n", + "\n", + "# Call BATSim plotting utility to get a nicely normalised image\n", + "fig = batsim.pltutil.make_plot_image(gal_pinwheeled)\n", + "plt.title(\"Pinwheel shear transform\")\n", + "plt.savefig(\"pinwheel_shear_example.pdf\", dpi=300)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "batsim-gpu", + "language": "python", + "name": "python3" + }, + "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.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/examples/5_Custom_Transforms/pinwheel_shear_example.pdf b/notebooks/examples/5_Custom_Transforms/pinwheel_shear_example.pdf new file mode 100644 index 0000000..0ff0d3a Binary files /dev/null and b/notebooks/examples/5_Custom_Transforms/pinwheel_shear_example.pdf differ diff --git a/notebooks/examples/6_Batched_Rendering/batched_rendering.ipynb b/notebooks/examples/6_Batched_Rendering/batched_rendering.ipynb new file mode 100644 index 0000000..553b0b6 --- /dev/null +++ b/notebooks/examples/6_Batched_Rendering/batched_rendering.ipynb @@ -0,0 +1,248 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d28c9bae", + "metadata": {}, + "source": [ + "Currently, for batched processing with BATSim, we recomend setting ``OMP`` threads to 1 and using Python multiprocessing. This is because by default Galsim's C++ sampler will try and multi-thread, and for large samples, processing a single galaxy per thread is usually fastest.\n", + "\n", + "Be aware that ``OMP`` threads must be set **before** Galsim is imported." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "be46cb08", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "# This is the key part, and must be run BEFORE Galsim imports\n", + "original_omp_threads = os.environ.get('OMP_NUM_THREADS', None)\n", + "os.environ['OMP_NUM_THREADS'] = '1'\n", + "\n", + "import batsim\n", + "import galsim\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from multiprocessing import Pool, cpu_count\n", + "from time import time\n", + "\n", + "plt.rcParams['font.family'] = 'serif'\n", + "plt.rcParams['font.serif'] = ['cmr10']\n", + "plt.rcParams['mathtext.fontset'] ='cm'\n", + "plt.rcParams['figure.facecolor'] = 'white'\n", + "plt.rc('axes', unicode_minus=False)\n", + "plt.rc('axes.formatter', use_mathtext=True)" + ] + }, + { + "cell_type": "markdown", + "id": "0ef065c0", + "metadata": {}, + "source": [ + "Let's start by generating a set of 100 Sersic galaxy profiles using Galsim. To keep things simple, we'll randomly sample a range of half-light radii and Sersic indices from a uniform distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "e445e36e", + "metadata": {}, + "outputs": [], + "source": [ + "n_gals = 100\n", + "\n", + "# Set morphological parameters to sample over\n", + "hlr_vec = np.random.uniform(0.15, 1.5, n_gals)\n", + "n_vec = np.random.uniform(0.3, 6, n_gals) # allowed range of Galsim values\n", + "intrinsic_e1 = np.random.uniform(-0.5, 0.5, n_gals)\n", + "intrinsic_e2 = np.random.uniform(-0.5, 0.5, n_gals)\n", + "\n", + "# Construct list containing GSObjects for parameter combinations\n", + "gal_list = []\n", + "for i in range(len(hlr_vec)):\n", + " gal_list.append(\n", + " galsim.Sersic(\n", + " half_light_radius=hlr_vec[i], n=n_vec[i]\n", + " ).shear( # give the galaxies some random intrinsic ellipticity\n", + " e1=intrinsic_e1[i], e2=intrinsic_e2[i] \n", + " )\n", + " )\n", + "\n", + "# Define PSF\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)" + ] + }, + { + "cell_type": "markdown", + "id": "1e8d7dee", + "metadata": {}, + "source": [ + "By now, you should be familiar with BATSim's usage and transforms, so lets look at something new: the ability to pass multiple transforms as a sequence.\n", + "\n", + "When multiple transforms are passed, the are applied in the order they appear in the sequence. Consider we wish to simulate a weak lensing survey with intrinsic alignments. Since IA is a physical distortion, we must apply this transform first, followed by the lensing, as this is an image level effect.\n", + "\n", + "Because BATSim's IA shear is calculated as a function of half-light radius, we need to be smart about how we construct this multiprocessing pool." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "c7e005d4", + "metadata": {}, + "outputs": [], + "source": [ + "# Define image parameters\n", + "npix = 128\n", + "pix_scale = 0.2\n", + "lens_shear = 0.02\n", + "\n", + "# define a function to parallelise\n", + "def batch_batsim(\n", + " gal_obj,\n", + " ngrid,\n", + " scale,\n", + " psf_obj,\n", + " lens_shear,\n", + " hlr\n", + " ):\n", + "\n", + " # Instantiate ia_transform based on HLR using default G19 fit\n", + " # ampltiude and power\n", + " ia_transform = batsim.IATransform(\n", + " hlr=hlr,\n", + " scale=scale\n", + " )\n", + "\n", + " # Instantiate lensing transform\n", + " lens_transform = batsim.LensTransform(\n", + " gamma1=lens_shear,\n", + " gamma2=0,\n", + " kappa=0\n", + " )\n", + "\n", + " # Call BATSim render passing both transform objects\n", + " gal_img = batsim.simulate_galaxy(\n", + " gal_obj=gal_obj,\n", + " ngrid=ngrid,\n", + " scale=scale,\n", + " transform_obj=[ia_transform, lens_transform],\n", + " psf_obj=psf_obj\n", + " )\n", + "\n", + " # BATSim returns np.array(), but we return a galsim.Image here\n", + " # to make stiching the individual stamps easier later\n", + " return galsim.ImageF(gal_img)" + ] + }, + { + "cell_type": "markdown", + "id": "94c7bbb7", + "metadata": {}, + "source": [ + "For multiprocessing, we will use an arguemnt list and ``Pool.starmap`` to allow multiple arguments to be passed. Unfortunately, despite ``LensTransform`` being the same for all galaxies, we cannot pass the object itself to multiprocessing, so instead we instantiate it inside each worker." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "7da16624", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU seconds per galaxy: 0.4531566262245178\n" + ] + } + ], + "source": [ + "# append function args into list for parallel processing\n", + "arg_list = []\n", + "for i in range(len(gal_list)):\n", + " arg_list.append([gal_list[i], npix, pix_scale, psf, lens_shear, hlr_vec[i]])\n", + "\n", + "# Set-up pool\n", + "start = time()\n", + "with Pool(processes=cpu_count()//2) as p: # Don't use more than half the available CPUs\n", + "\n", + " # pass function and iterables to be parallel processed\n", + " gal_images = p.starmap(func=batch_batsim, iterable=arg_list)\n", + "end = time()\n", + "\n", + "# Get timing metrics\n", + "ptime = end-start\n", + "t_per_gal = ptime / n_gals # CPU core seconds, since we force 1 gal per thread\n", + "print(\"CPU seconds per galaxy:\", t_per_gal)" + ] + }, + { + "cell_type": "markdown", + "id": "d8375bdc", + "metadata": {}, + "source": [ + "Let's stich the results together using ``batsim.pltutil`` and inspect..." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "56cb5efe", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# BATSim pltutil includes a function for stitching lists of images into a single\n", + "# galsim.Image\n", + "gal_scene = batsim.pltutil.stitch_images(gal_images, direction=\"square\")\n", + "fig = batsim.pltutil.make_plot_image(gal_scene.array)" + ] + }, + { + "cell_type": "markdown", + "id": "36c85bd9", + "metadata": {}, + "source": [ + "And that covers batch simulating samples of galaxies with BATSim. You should observe the simulation of the 100 galaxies used here takes about 0.5 CPU core seconds per galaxy. This is evidently much slower than Galsim and we do hope to improve upon this in future, however, it is sufficient for simulating samples on the order of hundreds of thousands of galaxies with a single HPC node.\n", + "\n", + "For example, if you wished to generate a large weak lensing sample with intrinsic alignments, we would suggest using Galsim to handle the majority of the processing and only processing the fraction of galaxies which you wish to be intrinsically aligned with BATSim." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "batsim-gpu", + "language": "python", + "name": "python3" + }, + "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.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/examples/7_Advanced_Configuration/advanced_config_example.ipynb b/notebooks/examples/7_Advanced_Configuration/advanced_config_example.ipynb new file mode 100644 index 0000000..619f07d --- /dev/null +++ b/notebooks/examples/7_Advanced_Configuration/advanced_config_example.ipynb @@ -0,0 +1,604 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 35, + "id": "2137814d", + "metadata": {}, + "outputs": [], + "source": [ + "import batsim\n", + "import galsim\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from time import time\n", + "\n", + "plt.rcParams['font.family'] = 'serif'\n", + "plt.rcParams['font.serif'] = ['cmr10']\n", + "plt.rcParams['mathtext.fontset'] ='cm'\n", + "plt.rcParams['figure.facecolor'] = 'white'\n", + "plt.rc('axes', unicode_minus=False)\n", + "plt.rc('axes.formatter', use_mathtext=True)" + ] + }, + { + "cell_type": "markdown", + "id": "1a2f519d", + "metadata": {}, + "source": [ + "In building BATSim, we have tried to strike a balance between simulation accuracy and speed for a wide range of galaxy morphologies. However, there is no one size-fits-all approach, and as such, BATSim exposes a variety of advanced configuration options for the renderer.\n", + "\n", + "The default values have been optimised on galaxy morphologies taken from the COSMOS sample included with Galsim, for images representative of LSST-like results.\n", + "\n", + "Should you wish to simulate with a very small PSF, high final image resolutions, or very complex galaxy morphologies. You may want to adjust some of these parameters for improved accuracy at the cost of speed.\n", + "\n", + "On the flip side, if you want to generate a sample with lots of big bright galaxies with simple morphologies, you may be able to gain some performance by adjusting these defaults.\n", + "\n", + "First, let's present the full suite of arguments and after we can look at how modifying specific ones may affect our results. The values shown are the defaults." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "19981cca", + "metadata": {}, + "outputs": [], + "source": [ + "# Create GSObjects to render\n", + "gal = galsim.Sersic(half_light_radius=1.0, n=2.0).shear(e1=0.1, e2=-0.1)\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "\n", + "# Image params\n", + "pix_scale = 0.2\n", + "npix=64\n", + "\n", + "# Present full set of arguments for batsim.simulate_galaxy\n", + "gal_img = batsim.simulate_galaxy(\n", + " gal_obj=gal, # GSObject of galaxy\n", + " scale=pix_scale, # Final pixel scale\n", + " ngrid=npix, # Final image side length\n", + " transform_obj=None, # BATSim Transform object\n", + " psf_obj=psf, # GSObject of PSF\n", + " draw_method=\"auto\", # turn pixel response on or off\n", + " safety=2.0, # safety factor to scale supersampling. Higher values result in more supersampling\n", + " max_supersample=64, # Maximum supersampling factor. This can be increased for difficult galaxies\n", + " min_supersample=4, # Minimum supersampling factor. We suggest not decreasing this.\n", + " integration_order=2, # Order of Gauss-Legendre quadrature block integration\n", + " max_fine_grid=4096, # Maxmium internal grid-size for rendering supersampled images\n", + " pad=16, # Padding to add before FFT\n", + " precision=\"single\", # Floating point precision to use during simulation\n", + " backend=\"np\", # Backend for math and array ops. Either NumPy or CuPy\n", + " profile=False, # Enable timing and verbose output\n", + " pix_scale=None, # Legacy arguement for scale, retained for conmpatibility\n", + " psf_mode=\"kvalue\", # Sample the PSF directly in k-space (or not)\n", + " force_input_flux=False, # Re-normalise image flux. This should NOT be set to true for magnification\n", + " compensate_integration=\"quadrature\", # Function used to remove smoothing in the Fourier profile\n", + " use_true_center=True, # Match Galsim's centering convention or not\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "bbad93b0", + "metadata": {}, + "source": [ + "Let's start by taking a look at a particularly challenging galaxy. Small galaxies require finer resolution bumping the supersampling needed, and if they are highly ellipticial they also require larger internal stamps to sufficiently contain their extent.\n", + "\n", + "For this we will focus on the arguments directly related to supersampling. To assess how this impacts accuracy, we compute the pixel-to-pixel residuals between BATSim and a GalSim reference and report the peak residual, as well as the total flux in each image." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "9d6dbfde", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------------\n", + "Max supersampling factor: 16\n", + "GalSim flux: 0.99363410\n", + "BATSim flux: 0.97205180\n", + "Max abs residual: 1.046e-03\n", + "Max abs residual as % of max flux: 3.245%\n", + "Simulation took 0.24 seconds\n", + "------------------------------------\n", + "Max supersampling factor: 32\n", + "GalSim flux: 0.99363410\n", + "BATSim flux: 0.98499560\n", + "Max abs residual: 4.162e-04\n", + "Max abs residual as % of max flux: 1.291%\n", + "Simulation took 0.75 seconds\n", + "------------------------------------\n", + "Max supersampling factor: 64\n", + "GalSim flux: 0.99363410\n", + "BATSim flux: 0.99038339\n", + "Max abs residual: 1.541e-04\n", + "Max abs residual as % of max flux: 0.478%\n", + "Simulation took 1.56 seconds\n", + "------------------------------------\n", + "Max supersampling factor: 128\n", + "GalSim flux: 0.99363410\n", + "BATSim flux: 0.99255240\n", + "Max abs residual: 5.382e-05\n", + "Max abs residual as % of max flux: 0.167%\n", + "Simulation took 1.47 seconds\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Small, high-n, highly elliptical.\n", + "tricky_gal = galsim.Sersic(half_light_radius=0.15, n=5).shear(e1=0.6, e2=0.6)\n", + "\n", + "# We will loop over different supersampling limits\n", + "max_super_vals = [16, 32, 64, 128]\n", + "\n", + "for max_super in max_super_vals:\n", + "\n", + " print(\"------------------------------------\")\n", + " print(\"Max supersampling factor:\", max_super)\n", + "\n", + " # Draw with batsim\n", + " start = time()\n", + " batsim_img = batsim.simulate_galaxy(\n", + " gal_obj=tricky_gal,\n", + " scale=pix_scale,\n", + " ngrid=npix,\n", + " transform_obj=None,\n", + " psf_obj=psf,\n", + " draw_method=\"auto\",\n", + " max_supersample=max_super, # Maximum supersampling factor. This can be increased for difficult galaxies\n", + " )\n", + " end = time()\n", + "\n", + " gal_conv = galsim.Convolve([tricky_gal, psf])\n", + " galsim_img = gal_conv.drawImage(nx=npix, ny=npix, scale=pix_scale).array\n", + "\n", + " # Look at residuals between images\n", + " residual = galsim_img - batsim_img\n", + " print(f\"GalSim flux: {galsim_img.sum():.8f}\")\n", + " print(f\"BATSim flux: {batsim_img.sum():.8f}\")\n", + " print(f\"Max abs residual: {abs(residual).max():.3e}\")\n", + "\n", + " perc_residual = 100 * abs(residual).max() / galsim_img.max()\n", + " print(f\"Max abs residual as % of max flux: {perc_residual:.3f}%\")\n", + " print(f\"Simulation took {end-start:.2f} seconds\")\n", + "\n", + "# Plot galaxy\n", + "fig = batsim.pltutil.make_plot_image(batsim_img)" + ] + }, + { + "cell_type": "markdown", + "id": "41fe9415", + "metadata": {}, + "source": [ + "Evidently, the agreement between the BATSim and Galsim images improves with increasing supersampling amounts **for this galaxy**. Next we will look at adjusting the maximum internal image size ``max_fine_grid``." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "de743546", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------------\n", + "Max grid size: 1024\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GalSim flux: 0.77357638\n", + "BATSim flux: 0.77298665\n", + "Max abs residual: 2.870e-05\n", + "Max abs residual as % of max flux: 0.429%\n", + "Simulation took 0.19 seconds\n", + "------------------------------------\n", + "Max grid size: 2048\n", + "GalSim flux: 0.77357638\n", + "BATSim flux: 0.77298665\n", + "Max abs residual: 2.870e-05\n", + "Max abs residual as % of max flux: 0.429%\n", + "Simulation took 0.39 seconds\n", + "------------------------------------\n", + "Max grid size: 4096\n", + "GalSim flux: 0.77357638\n", + "BATSim flux: 0.77340686\n", + "Max abs residual: 8.292e-06\n", + "Max abs residual as % of max flux: 0.124%\n", + "Simulation took 1.67 seconds\n", + "------------------------------------\n", + "Max grid size: 8192\n", + "GalSim flux: 0.77357638\n", + "BATSim flux: 0.77352965\n", + "Max abs residual: 2.317e-06\n", + "Max abs residual as % of max flux: 0.035%\n", + "Simulation took 6.71 seconds\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Large, diffuse, highly elliptical.\n", + "tricky_gal = galsim.DeVaucouleurs(half_light_radius=2.0).shear(e1=0.6, e2=0.6)\n", + "\n", + "# We will loop over different supersampling limits\n", + "max_grid_vals = [1024, 2048, 4096, 8192]\n", + "\n", + "for max_grid in max_grid_vals:\n", + "\n", + " print(\"------------------------------------\")\n", + " print(\"Max grid size:\", max_grid)\n", + "\n", + " # Draw with batsim\n", + " start = time()\n", + " batsim_img = batsim.simulate_galaxy(\n", + " gal_obj=tricky_gal,\n", + " scale=pix_scale,\n", + " ngrid=npix,\n", + " transform_obj=None,\n", + " psf_obj=psf,\n", + " draw_method=\"auto\",\n", + " max_fine_grid=max_grid, # Maximum internal grid size. This can be increased for difficult galaxies\n", + " )\n", + " end = time()\n", + "\n", + " gal_conv = galsim.Convolve([tricky_gal, psf])\n", + " galsim_img = gal_conv.drawImage(nx=npix, ny=npix, scale=pix_scale).array\n", + "\n", + " # Look at residuals between images\n", + " residual = galsim_img - batsim_img\n", + " print(f\"GalSim flux: {galsim_img.sum():.8f}\")\n", + " print(f\"BATSim flux: {batsim_img.sum():.8f}\")\n", + " print(f\"Max abs residual: {abs(residual).max():.3e}\")\n", + "\n", + " perc_residual = 100 * abs(residual).max() / galsim_img.max()\n", + " print(f\"Max abs residual as % of max flux: {perc_residual:.3f}%\")\n", + " print(f\"Simulation took {end-start:.2f} seconds\")\n", + "\n", + "# Plot galaxy\n", + "fig = batsim.pltutil.make_plot_image(batsim_img)" + ] + }, + { + "cell_type": "markdown", + "id": "1eb5e86a", + "metadata": {}, + "source": [ + "``max_fine_grid`` is most relevant to galaxies which require huge internal support images. This can occur when a galaxy's internal rendering resolution is extremely fine and the galaxy is very large and/or highly elliptical. Finally, we will look at the ``integration_order`` arguement, which controls the number of Gauss-Legendre offsets that are used for integrated sampling of each fine pixel to prevent aliasing.\n", + "\n", + "An ``integration_order`` of 1 results in no block integration. For many realistic galaxies, this is impractical due to the huge internal stamps that would be required to prevent alaising during point sampling." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "c837f823", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------------\n", + "Integration Order: 1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GalSim flux: 0.99604219\n", + "BATSim flux: 5.10848427\n", + "Max abs residual: 2.001e-01\n", + "Max abs residual as % of max flux: 552.301%\n", + "Simulation took 0.89 seconds\n", + "------------------------------------\n", + "Integration Order: 2\n", + "GalSim flux: 0.99604219\n", + "BATSim flux: 0.98955822\n", + "Max abs residual: 3.130e-04\n", + "Max abs residual as % of max flux: 0.864%\n", + "Simulation took 1.71 seconds\n", + "------------------------------------\n", + "Integration Order: 4\n", + "GalSim flux: 0.99604219\n", + "BATSim flux: 0.99000245\n", + "Max abs residual: 2.912e-04\n", + "Max abs residual as % of max flux: 0.804%\n", + "Simulation took 0.88 seconds\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Small, high-n, highly elliptical.\n", + "tricky_gal = galsim.Sersic(half_light_radius=0.1, n=6).shear(e1=-0.2, e2=0.7)\n", + "\n", + "# We will loop over different supersampling limits\n", + "int_order_vals = [1, 2, 4]\n", + "\n", + "for int_order in int_order_vals:\n", + "\n", + " print(\"------------------------------------\")\n", + " print(\"Integration Order:\", int_order)\n", + "\n", + " # Draw with batsim\n", + " start = time()\n", + " batsim_img = batsim.simulate_galaxy(\n", + " gal_obj=tricky_gal,\n", + " scale=pix_scale,\n", + " ngrid=npix,\n", + " transform_obj=None,\n", + " psf_obj=psf,\n", + " draw_method=\"auto\",\n", + " integration_order=int_order # Integration order for integrated sampling\n", + " )\n", + " end = time()\n", + "\n", + " gal_conv = galsim.Convolve([tricky_gal, psf])\n", + " galsim_img = gal_conv.drawImage(nx=npix, ny=npix, scale=pix_scale).array\n", + "\n", + " # Look at residuals between images\n", + " residual = galsim_img - batsim_img\n", + " print(f\"GalSim flux: {galsim_img.sum():.8f}\")\n", + " print(f\"BATSim flux: {batsim_img.sum():.8f}\")\n", + " print(f\"Max abs residual: {abs(residual).max():.3e}\")\n", + "\n", + " perc_residual = 100 * abs(residual).max() / galsim_img.max()\n", + " print(f\"Max abs residual as % of max flux: {perc_residual:.3f}%\")\n", + " print(f\"Simulation took {end-start:.2f} seconds\")\n", + "\n", + "# Plot galaxy\n", + "fig = batsim.pltutil.make_plot_image(batsim_img)" + ] + }, + { + "cell_type": "markdown", + "id": "f542db6a", + "metadata": {}, + "source": [ + "It is clear for this galaxy with no block integration, the resulting aliasing is extreme, leading to a huge flux residual in the final image. After the FFT, we remove the smoothing kernel from the Fourier. This is controlled by ``compensate_integration``, for which we can either choose to use an exact Sinc kernel, the quadrature transfer function, or do no compensation.\n", + "\n", + "Higher integration orders require more sampling evaluations, but, can also reduce the required supersampling more. Currently, integration order is fixed and is not chosen as part of the renderer sampling heuristic, but this is something we plan to incorporate in future." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "51f9cc3c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------------\n", + "Integration compensation function: None\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GalSim flux: 0.85708648\n", + "BATSim flux: 0.85704029\n", + "Max abs residual: 2.856e-06\n", + "Max abs residual as % of max flux: 0.032%\n", + "Simulation took 1.57 seconds\n", + "------------------------------------\n", + "Integration compensation function: exact_sinc\n", + "GalSim flux: 0.85708648\n", + "BATSim flux: 0.85704041\n", + "Max abs residual: 2.294e-06\n", + "Max abs residual as % of max flux: 0.025%\n", + "Simulation took 1.63 seconds\n", + "------------------------------------\n", + "Integration compensation function: quadrature\n", + "GalSim flux: 0.85708648\n", + "BATSim flux: 0.85704041\n", + "Max abs residual: 2.294e-06\n", + "Max abs residual as % of max flux: 0.025%\n", + "Simulation took 1.62 seconds\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Small, high-n, highly elliptical.\n", + "tricky_gal = galsim.Sersic(half_light_radius=1.5, n=4).shear(e1=-0.2, e2=0.7)\n", + "\n", + "# We will loop over different supersampling limits\n", + "compensation_modes = [None, \"exact_sinc\", \"quadrature\"]\n", + "\n", + "for mode in compensation_modes:\n", + "\n", + " print(\"------------------------------------\")\n", + " print(\"Integration compensation function:\", mode)\n", + "\n", + " # Draw with batsim\n", + " start = time()\n", + " batsim_img = batsim.simulate_galaxy(\n", + " gal_obj=tricky_gal,\n", + " scale=pix_scale,\n", + " ngrid=npix,\n", + " transform_obj=None,\n", + " psf_obj=psf,\n", + " draw_method=\"auto\",\n", + " compensate_integration=mode # Integration order for integrated sampling\n", + " )\n", + " end = time()\n", + "\n", + " gal_conv = galsim.Convolve([tricky_gal, psf])\n", + " galsim_img = gal_conv.drawImage(nx=npix, ny=npix, scale=pix_scale).array\n", + "\n", + " # Look at residuals between images\n", + " residual = galsim_img - batsim_img\n", + " print(f\"GalSim flux: {galsim_img.sum():.8f}\")\n", + " print(f\"BATSim flux: {batsim_img.sum():.8f}\")\n", + " print(f\"Max abs residual: {abs(residual).max():.3e}\")\n", + "\n", + " perc_residual = 100 * abs(residual).max() / galsim_img.max()\n", + " print(f\"Max abs residual as % of max flux: {perc_residual:.3f}%\")\n", + " print(f\"Simulation took {end-start:.2f} seconds\")\n", + "\n", + "# Plot galaxy\n", + "fig = batsim.pltutil.make_plot_image(batsim_img)" + ] + }, + { + "cell_type": "markdown", + "id": "0a6d8c05", + "metadata": {}, + "source": [ + "For most galaxies and for integrations orders greater than 2, ``exact_sinc`` and ``quadrature`` are identical, but we provide the option for both for the sake of felxibility.\n", + "\n", + "At this point, we have covered the most important advacned configuration options, and trying to cover them all would result in a painfully long notebook. Below we include the full renderer with all options listed so you can test different things yourself and see how they affect different galaxies." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "48a971c0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GalSim flux: 0.98687613\n", + "BATSim flux: 0.98671603\n", + "Max abs residual: 6.250e-06\n", + "Max abs residual as % of max flux: 0.059%\n", + "Simulation took 1.62 seconds\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create GSObjects to render\n", + "gal = galsim.Sersic(half_light_radius=1.0, n=2.0).shear(e1=0.1, e2=-0.1)\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "\n", + "# Image params\n", + "pix_scale = 0.2\n", + "npix=64\n", + "\n", + "# Present full set of arguments for batsim.simulate_galaxy\n", + "batsim_img = batsim.simulate_galaxy(\n", + " gal_obj=gal, # GSObject of galaxy\n", + " scale=pix_scale, # Final pixel scale\n", + " ngrid=npix, # Final image side length\n", + " transform_obj=None, # BATSim Transform object\n", + " psf_obj=psf, # GSObject of PSF\n", + " draw_method=\"auto\", # turn pixel response on or off\n", + " safety=2.0, # safety factor to scale supersampling. Higher values result in more supersampling\n", + " max_supersample=64, # Maximum supersampling factor. This can be increased for difficult galaxies\n", + " min_supersample=4, # Minimum supersampling factor. We suggest not decreasing this.\n", + " integration_order=2, # Order of Gauss-Legendre quadrature block integration\n", + " max_fine_grid=4096, # Maxmium internal grid-size for rendering supersampled images\n", + " pad=16, # Padding to add before FFT\n", + " precision=\"single\", # Floating point precision to use during simulation\n", + " backend=\"np\", # Backend for math and array ops. Either NumPy or CuPy\n", + " profile=False, # Enable timing and verbose output\n", + " pix_scale=None, # Legacy arguement for scale, retained for conmpatibility\n", + " psf_mode=\"kvalue\", # Sample the PSF directly in k-space (or not)\n", + " force_input_flux=False, # Re-normalise image flux. This should NOT be set to true for magnification\n", + " compensate_integration=\"quadrature\", # Function used to remove smoothing in the Fourier profile\n", + " use_true_center=True, # Match Galsim's centering convention or not\n", + ")\n", + "\n", + "gal_conv = galsim.Convolve([gal, psf])\n", + "galsim_img = gal_conv.drawImage(nx=npix, ny=npix, scale=pix_scale).array\n", + "\n", + "# Look at residuals between images\n", + "residual = galsim_img - batsim_img\n", + "print(f\"GalSim flux: {galsim_img.sum():.8f}\")\n", + "print(f\"BATSim flux: {batsim_img.sum():.8f}\")\n", + "print(f\"Max abs residual: {abs(residual).max():.3e}\")\n", + "\n", + "perc_residual = 100 * abs(residual).max() / galsim_img.max()\n", + "print(f\"Max abs residual as % of max flux: {perc_residual:.3f}%\")\n", + "print(f\"Simulation took {end-start:.2f} seconds\")\n", + "\n", + "# Plot galaxy\n", + "fig = batsim.pltutil.make_plot_image(batsim_img)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "batsim-gpu", + "language": "python", + "name": "python3" + }, + "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.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/examples/IA_exaggerated_galaxy_compare.pdf b/notebooks/examples/IA_exaggerated_galaxy_compare.pdf deleted file mode 100644 index 5d5c430..0000000 Binary files a/notebooks/examples/IA_exaggerated_galaxy_compare.pdf and /dev/null differ diff --git a/notebooks/examples/IA_exaggerated_galaxy_compare.png b/notebooks/examples/IA_exaggerated_galaxy_compare.png deleted file mode 100644 index 931d981..0000000 Binary files a/notebooks/examples/IA_exaggerated_galaxy_compare.png and /dev/null differ diff --git a/notebooks/validation/charlie.png b/notebooks/validation/charlie.png new file mode 100644 index 0000000..3405816 Binary files /dev/null and b/notebooks/validation/charlie.png differ diff --git a/notebooks/validation/cosmos_indices_of_interest.npz b/notebooks/validation/cosmos_indices_of_interest.npz new file mode 100644 index 0000000..e0d4ef5 Binary files /dev/null and b/notebooks/validation/cosmos_indices_of_interest.npz differ diff --git a/notebooks/validation/fpfs_catalog_tile_51.pkl b/notebooks/validation/fpfs_catalog_tile_51.pkl new file mode 100644 index 0000000..e742e41 Binary files /dev/null and b/notebooks/validation/fpfs_catalog_tile_51.pkl differ diff --git a/notebooks/validation/test_shear_accuracy_real.ipynb b/notebooks/validation/test_shear_accuracy_real.ipynb new file mode 100644 index 0000000..3c76f20 --- /dev/null +++ b/notebooks/validation/test_shear_accuracy_real.ipynb @@ -0,0 +1,1895 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "id": "436f7d01", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os\n", + "original_omp_threads = os.environ.get('OMP_NUM_THREADS', None)\n", + "os.environ['OMP_NUM_THREADS'] = '1'\n", + "\n", + "import galsim\n", + "import batsim\n", + "import anacal\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import fitsio\n", + "\n", + "from multiprocessing import cpu_count\n", + "from parallelbar import progress_starmap\n", + "from scipy.stats import gaussian_kde\n", + "from tqdm import tqdm\n", + "from time import time\n", + "\n", + "from importlib import reload\n", + "reload(batsim)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad4a2c9d", + "metadata": {}, + "outputs": [], + "source": [ + "def cancel_shape_noise(gal_obj, nrot):\n", + " '''Create nrot rotated versions of the input galaxy object\n", + " such that shape noise cancels out when averaging the shapes'''\n", + " rotated_gals = []\n", + " for i in range(nrot):\n", + " rot_ang = np.pi / nrot * i\n", + " ang = rot_ang * galsim.radians\n", + " rotated_gals.append(gal_obj.rotate(ang))\n", + " \n", + " return rotated_gals\n", + "\n", + "def measure_shear(gal_array, psf_array, npix, pixel_scale, noise_variance, noise_array, detection):\n", + " '''Measure the shear using FPFS and return catalog'''\n", + " fpfs_config = anacal.fpfs.FpfsConfig(\n", + " sigma_shapelets=0.52, # The first measurement scale (also for detection)\n", + " sigma_shapelets2=0.45, # The second measurement scale\n", + " npix=npix # individual stamp size for basis operations\n", + " )\n", + " \n", + " catalog = anacal.fpfs.process_image(\n", + " fpfs_config=fpfs_config,\n", + " mag_zero=30.0,\n", + " gal_array=gal_array,\n", + " psf_array=psf_array,\n", + " pixel_scale=pixel_scale,\n", + " noise_variance=max(noise_variance, 0.23),\n", + " noise_array=noise_array,\n", + " detection=detection,\n", + " )\n", + "\n", + " return catalog\n", + "\n", + "def batsim_generate_images(\n", + " gal,\n", + " nn,\n", + " scale,\n", + " psf,\n", + " lens_shear,\n", + " n_rot,\n", + " max_supersample=64,\n", + " compensate_integration=\"quadrature\"\n", + " ):\n", + "\n", + " rotated_gals = cancel_shape_noise(gal, n_rot)\n", + "\n", + " stamp_size = nn * np.sqrt(n_rot)\n", + " stamp = galsim.ImageF(stamp_size, stamp_size, scale=scale)\n", + "\n", + " LensTransform = batsim.LensTransform(gamma1=lens_shear, gamma2=0, kappa=0)\n", + " \n", + " for j in range(n_rot):\n", + " # set drawing location on image\n", + " row = j // int(np.sqrt(n_rot))\n", + " col = j % int(np.sqrt(n_rot))\n", + "\n", + " # Compute the bounds for this galaxy\n", + " xmin = col * nn + 1 # +1 because GalSim coordinates start at 1\n", + " xmax = (col + 1) * nn\n", + " ymin = row * nn + 1\n", + " ymax = (row + 1) * nn\n", + "\n", + " gal_img = batsim.simulate_galaxy(\n", + " gal_obj=rotated_gals[j],\n", + " ngrid=nn,\n", + " scale=scale,\n", + " transform_obj=LensTransform,\n", + " psf_obj=psf,\n", + " draw_method=\"auto\",\n", + " backend=\"numpy\",\n", + " max_supersample=max_supersample\n", + " )\n", + "\n", + " # Set the subimage in the stamp\n", + " bounds = galsim.BoundsI(xmin, xmax, ymin, ymax)\n", + " sub_image = galsim.Image(gal_img, scale=scale)\n", + " stamp[bounds] = sub_image\n", + "\n", + " return stamp\n", + "\n", + "def galsim_generate_images(gal, nn, scale, psf, lens_shear, n_rot):\n", + "\n", + " gamma1 = lens_shear\n", + " gamma2 = 0\n", + " kappa = 0 \n", + "\n", + " g1 = gamma1 / (1 - kappa)\n", + " g2 = gamma2 / (1 - kappa)\n", + " mu = 1 / ((1 - kappa) ** 2 - gamma1**2 - gamma2**2)\n", + "\n", + " rotated_gals = cancel_shape_noise(gal, n_rot)\n", + "\n", + " stamp_size = nn * np.sqrt(n_rot)\n", + " stamp = galsim.ImageF(stamp_size, stamp_size, scale=scale)\n", + " \n", + " for j in range(n_rot):\n", + " # set drawing location on image\n", + " row = j // int(np.sqrt(n_rot))\n", + " col = j % int(np.sqrt(n_rot))\n", + "\n", + " # Compute the bounds for this galaxy\n", + " xmin = col * nn + 1 # +1 because GalSim coordinates start at 1\n", + " xmax = (col + 1) * nn\n", + " ymin = row * nn + 1\n", + " ymax = (row + 1) * nn\n", + "\n", + " shear_gal = rotated_gals[j].lens(g1=g1, g2=g2, mu=mu)\n", + " conv_gal = galsim.Convolve([shear_gal, psf])\n", + " #conv_gal = conv_gal.shift(0.5*scale, 0.5*scale)\n", + " sub_image = conv_gal.drawImage(\n", + " nx=nn,\n", + " ny=nn,\n", + " scale=scale,\n", + " method=\"auto\"\n", + " )\n", + "\n", + " # Set the subimage in the stamp\n", + " bounds = galsim.BoundsI(xmin, xmax, ymin, ymax)\n", + " stamp[bounds] = sub_image\n", + "\n", + " return stamp\n", + "\n", + "def build_large_stamp(tiles, scale, tiles_per_side):\n", + "\n", + " tile_size = np.shape(tiles[0].array)\n", + " if tile_size[0] != tile_size[1]:\n", + " raise ValueError(\"Image tiles must be square\")\n", + "\n", + " tile_size = tile_size[0]\n", + " large_size = tile_size * tiles_per_side\n", + " large_stamp = galsim.ImageF(large_size, large_size, scale=scale)\n", + "\n", + " for i, tile in enumerate(tiles):\n", + "\n", + " tile_row = i // tiles_per_side\n", + " tile_col = i % tiles_per_side\n", + "\n", + " xmin = tile_col * tile_size + 1\n", + " xmax = (tile_col + 1) * tile_size\n", + " ymin = tile_row * tile_size + 1\n", + " ymax = (tile_row + 1) * tile_size\n", + "\n", + " bounds = galsim.BoundsI(xmin, xmax, ymin, ymax)\n", + " large_stamp[bounds] = tile\n", + "\n", + " return large_stamp" + ] + }, + { + "cell_type": "markdown", + "id": "1dffc7fb", + "metadata": {}, + "source": [ + "# Test Full Cosmos Sample " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "06036d27", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "81499\n", + "7680\n", + "51\n" + ] + } + ], + "source": [ + "np.random.seed(14)\n", + "\n", + "# Load cosmos catalog\n", + "cosmos = galsim.COSMOSCatalog()\n", + "print(len(cosmos))\n", + "\n", + "# Image pixel scale in arcsec/pixel\n", + "scale = 0.2\n", + "nn = 96\n", + "lens_shear = 0.02\n", + "n_rot = 4\n", + "\n", + "n_gal_stamp = 1600\n", + "stamp_size = int(nn * np.sqrt(n_rot * n_gal_stamp))\n", + "print(stamp_size)\n", + "\n", + "n_stamps = int(np.ceil(len(cosmos) / n_gal_stamp))\n", + "print(n_stamps)\n", + "\n", + "all_inds = np.arange(len(cosmos))\n", + "stamp_inds = np.array_split(all_inds, n_stamps)\n", + "\n", + "stamp_galaxies = []\n", + "for inds in stamp_inds:\n", + " if len(inds) == 0:\n", + " continue\n", + "\n", + " galaxies = cosmos.makeGalaxy(index=inds, gal_type='parametric')\n", + " records = cosmos.getParametricRecord(index=inds)\n", + "\n", + " # re-scale flux to match LSST\n", + " fluxes = 10 ** ((30 - records[\"mag_auto\"]) / 2.5)\n", + " galaxies = [gal.withFlux(flux) for gal, flux in zip(galaxies, fluxes)]\n", + "\n", + " stamp_galaxies.append(galaxies)\n", + "\n", + "# Define the PSF\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "psf_array = psf.drawImage(nx=nn, ny=nn, scale=scale).array" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aca6e1e2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/10 [00:00 n_stamps:\n", + " raise ValueError(\"Cannot use more stamps than have been assigned\")\n", + "\n", + "clobber=False\n", + "for i in tqdm(range(use_stamps)):\n", + "\n", + " # Assign filenames for tile\n", + " batsim_file = os.path.join(\n", + " \"COSMOS_lensed\", \n", + " f\"batsim_stamp_{i}_{stamp_size}x{stamp_size}.fits\"\n", + " )\n", + "\n", + " galsim_file = os.path.join(\n", + " \"COSMOS_lensed\", \n", + " f\"galsim_stamp_{i}_{stamp_size}x{stamp_size}.fits\"\n", + " )\n", + "\n", + " # append function args into list for parallel processing\n", + " args_list = [(gal, nn, scale, psf, lens_shear, n_rot) for gal in stamp_galaxies[i]]\n", + "\n", + " # check for existing stamp file\n", + " if os.path.exists(batsim_file) and not clobber:\n", + " batsim_stamps.append(galsim.fits.read(file_name=batsim_file))\n", + " else:\n", + " # simulate individual galaxy tiles\n", + " batsim_tiles = progress_starmap(\n", + " batsim_generate_images,\n", + " args_list,\n", + " n_cpu=56\n", + " )\n", + "\n", + " # assemble tiles into full stamp\n", + " batsim_stamps.append(build_large_stamp(\n", + " tiles=batsim_tiles,\n", + " scale=scale,\n", + " tiles_per_side=40\n", + " ))\n", + "\n", + " # write stamp to disk\n", + " galsim.fits.write(batsim_stamps[i], file_name=batsim_file)\n", + "\n", + " # check for existing stamp file\n", + " if os.path.exists(galsim_file) and not clobber:\n", + " galsim_stamps.append(galsim.fits.read(file_name=galsim_file))\n", + " else:\n", + " # simulate individual galaxy tiles\n", + " galsim_tiles = progress_starmap(\n", + " galsim_generate_images,\n", + " args_list,\n", + " n_cpu=56\n", + " )\n", + "\n", + " # assemble tiles into full stamp\n", + " galsim_stamps.append(build_large_stamp(\n", + " tiles=galsim_tiles,\n", + " scale=scale,\n", + " tiles_per_side=40\n", + " ))\n", + "\n", + " # write stamp to disk\n", + " galsim.fits.write(galsim_stamps[i], file_name=galsim_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cde96c66", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/10 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compare BATSim and Galsim results\n", + "print(f\"g1 absolute diff: {abs(g1_gs - g1_bt)}\")\n", + "print(f\"mbias absolute diff {abs(mbias_gs - mbias_bt)}\")\n", + "\n", + "plt.figure()\n", + "plot_kde_1d(e1_bt, label=f\"e1_bt: mean = {np.mean(e1_bt)}\")\n", + "plot_kde_1d(e1_gs, label=f\"e1_gs: mean = {np.mean(e1_gs)}\")\n", + "plt.xlabel(\"Value\")\n", + "plt.ylabel(\"Density\")\n", + "plt.legend()\n", + "plt.title(\"e1 distributions\")\n", + "plt.show()\n", + "\n", + "plt.figure()\n", + "plot_kde_1d(R1_bt, label=f\"R1_bt: mean = {np.mean(R1_bt)}\")\n", + "plot_kde_1d(R1_gs, label=f\"R1_gs: mean = {np.mean(R1_gs)}\")\n", + "plt.xlabel(\"Value\")\n", + "plt.ylabel(\"Density\")\n", + "plt.xlim([-1,3])\n", + "plt.legend()\n", + "plt.title(\"R1 distributions\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "40a4335a", + "metadata": {}, + "outputs": [], + "source": [ + "def measure_all_tiles(\n", + " stamps,\n", + " psf_array,\n", + " scale,\n", + " nn,\n", + " noise_variance\n", + " ):\n", + "\n", + " E_tiles = []\n", + " R_tiles = []\n", + "\n", + " for stamp in tqdm(stamps):\n", + " cat = measure_shear(\n", + " gal_array=stamp.array,\n", + " psf_array=psf_array,\n", + " pixel_scale=scale,\n", + " npix=nn,\n", + " noise_variance=noise_variance,\n", + " noise_array=None,\n", + " detection=None,\n", + " )\n", + "\n", + " e = cat[\"fpfs_w\"] * cat[\"fpfs_e1\"]\n", + " R = (\n", + " cat[\"fpfs_dw_dg1\"] * cat[\"fpfs_e1\"]\n", + " + cat[\"fpfs_w\"] * cat[\"fpfs_de1_dg1\"]\n", + " )\n", + "\n", + " E_tiles.append(np.sum(e))\n", + " R_tiles.append(np.sum(R))\n", + "\n", + " return E_tiles, R_tiles\n", + "\n", + "def jackknife_over_tiles(\n", + " E_tiles,\n", + " R_tiles,\n", + " lens_shear\n", + "):\n", + "\n", + " E_tiles = np.asarray(E_tiles)\n", + " R_tiles = np.asarray(R_tiles)\n", + "\n", + " E_tot = E_tiles.sum()\n", + " R_tot = R_tiles.sum()\n", + "\n", + " g1 = E_tot / R_tot\n", + " m = g1 / lens_shear - 1\n", + "\n", + " n = len(E_tiles)\n", + " g1_loo = (E_tot - E_tiles) / (R_tot - R_tiles)\n", + " m_loo = g1_loo / lens_shear - 1\n", + "\n", + " g1_err = np.sqrt((n - 1) / n * np.sum((g1_loo - g1_loo.mean()) ** 2))\n", + " m_err = np.sqrt((n - 1) / n * np.sum((m_loo - m_loo.mean()) ** 2))\n", + "\n", + " return {\n", + " \"g1\": g1,\n", + " \"g1_err\": g1_err,\n", + " \"m\": m,\n", + " \"m_err\": m_err,\n", + " \"E_tiles\": E_tiles,\n", + " \"R_tiles\": R_tiles,\n", + " \"g1_loo\": g1_loo,\n", + " \"m_loo\": m_loo,\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "2e3fc229", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 10/10 [01:21<00:00, 8.12s/it]\n", + "100%|██████████| 10/10 [01:21<00:00, 8.13s/it]\n" + ] + } + ], + "source": [ + "E_tiles_gs, R_tiles_gs = measure_all_tiles(\n", + " stamps=galsim_stamps,\n", + " psf_array=psf_array,\n", + " scale=scale,\n", + " nn=nn,\n", + " noise_variance=0.23\n", + ")\n", + "\n", + "E_tiles_bt, R_tiles_bt = measure_all_tiles(\n", + " stamps=batsim_stamps,\n", + " psf_array=psf_array,\n", + " scale=scale,\n", + " nn=nn,\n", + " noise_variance=0.23\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6ecc9f53", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Measured g1: 0.020000115992198707 ± 3.676305561432209e-05\n", + "Multiplicative bias: 5.799609935408512e-06 ± 0.001838152780716115\n" + ] + } + ], + "source": [ + "res_jk_gs = jackknife_over_tiles(\n", + " E_tiles_gs,\n", + " R_tiles_gs,\n", + " lens_shear\n", + ")\n", + "\n", + "print(f\"Measured g1: {res_jk_gs['g1']} ± {res_jk_gs['g1_err']}\")\n", + "print(f\"Multiplicative bias: {res_jk_gs['m']} ± {res_jk_gs['m_err']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d0bbcd1a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Measured g1: 0.020022130963382498 ± 3.438115950358075e-05\n", + "Multiplicative bias: 0.0011065481691248102 ± 0.0017190579751790941\n" + ] + } + ], + "source": [ + "res_jk_bt = jackknife_over_tiles(\n", + " E_tiles_bt,\n", + " R_tiles_bt,\n", + " lens_shear\n", + ")\n", + "\n", + "print(f\"Measured g1: {res_jk_bt['g1']} ± {res_jk_bt['g1_err']}\")\n", + "print(f\"Multiplicative bias: {res_jk_bt['m']} ± {res_jk_bt['m_err']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "288a5192", + "metadata": {}, + "outputs": [], + "source": [ + "def bootstrap_tiles(E_tiles, R_tiles, lens_shear, n_boot=1000, rng=None):\n", + " E_tiles = np.asarray(E_tiles)\n", + " R_tiles = np.asarray(R_tiles)\n", + "\n", + " n_tiles = len(E_tiles)\n", + " rng = np.random.default_rng(rng)\n", + "\n", + " g_boot = np.empty(n_boot)\n", + " m_boot = np.empty(n_boot)\n", + "\n", + " for b in range(n_boot):\n", + " inds = rng.integers(0, n_tiles, size=n_tiles) # sample tiles with replacement\n", + " E = E_tiles[inds].sum()\n", + " R = R_tiles[inds].sum()\n", + "\n", + " g = E / R\n", + " m = g / lens_shear - 1\n", + "\n", + " g_boot[b] = g\n", + " m_boot[b] = m\n", + "\n", + " g_hat = E_tiles.sum() / R_tiles.sum()\n", + " m_hat = g_hat / lens_shear - 1\n", + "\n", + " g_err = g_boot.std(ddof=1)\n", + " m_err = m_boot.std(ddof=1)\n", + "\n", + " g_ci = np.percentile(g_boot, [16, 84])\n", + " m_ci = np.percentile(m_boot, [16, 84])\n", + "\n", + " return {\n", + " \"g1\": g_hat,\n", + " \"m\": m_hat,\n", + " \"g1_err\": g_err,\n", + " \"m_err\": m_err,\n", + " \"g1_boot\": g_boot,\n", + " \"m_boot\": m_boot,\n", + " \"g1_ci_16_84\": g_ci,\n", + " \"m_ci_16_84\": m_ci,\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e34f5308", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Measured g1: 0.020000115992198707 ± 3.438764288862933e-05\n", + "Multiplicative bias: 5.799609935408512e-06 ± 0.0017193821444314635\n" + ] + } + ], + "source": [ + "res_boot_gs = bootstrap_tiles(\n", + " E_tiles_gs,\n", + " R_tiles_gs,\n", + " lens_shear\n", + ")\n", + "\n", + "print(f\"Measured g1: {res_boot_gs['g1']} ± {res_boot_gs['g1_err']}\")\n", + "print(f\"Multiplicative bias: {res_boot_gs['m']} ± {res_boot_gs['m_err']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3921fe77", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Measured g1: 0.020022130963382498 ± 3.229161068912157e-05\n", + "Multiplicative bias: 0.0011065481691248102 ± 0.0016145805344560775\n" + ] + } + ], + "source": [ + "res_boot_bt = bootstrap_tiles(\n", + " E_tiles_bt,\n", + " R_tiles_bt,\n", + " lens_shear\n", + ")\n", + "\n", + "print(f\"Measured g1: {res_boot_bt['g1']} ± {res_boot_bt['g1_err']}\")\n", + "print(f\"Multiplicative bias: {res_boot_bt['m']} ± {res_boot_bt['m_err']}\")" + ] + }, + { + "cell_type": "markdown", + "id": "3e67bb67", + "metadata": {}, + "source": [ + "# Test Only Difficult Galaxies" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "10ade247", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KeysView(NpzFile 'cosmos_indices_of_interest.npz' with keys: sersic7, low_re, sersic7_low_re)\n", + "Total unique hard galaxies: 11946\n", + "Low R_e galaxies: 10670\n", + "Sersic 7 galaxies: 2390\n", + "Sersic 7 Low R_e galaxies: 1114\n" + ] + } + ], + "source": [ + "# Load indicies of the hard galaxies\n", + "hard_inds = np.load(\"cosmos_indices_of_interest.npz\")\n", + "print(hard_inds.keys())\n", + "\n", + "# concatenate all hard galaxy indices into a single array with no duplicates\n", + "all_hard = np.unique(np.concatenate([hard_inds[key] for key in hard_inds.keys()]))\n", + "\n", + "cosmos = galsim.COSMOSCatalog()\n", + "cosmos_all_hard = cosmos.makeGalaxy(index=all_hard, gal_type='parametric')\n", + "cosmos_low_re = cosmos.makeGalaxy(index=hard_inds[\"low_re\"], gal_type='parametric')\n", + "cosmos_sersic7 = cosmos.makeGalaxy(index=hard_inds[\"sersic7\"], gal_type='parametric')\n", + "cosmos_sersic7_low_re = cosmos.makeGalaxy(index=hard_inds[\"sersic7_low_re\"], gal_type='parametric')\n", + "\n", + "print(f\"Total unique hard galaxies: {len(cosmos_all_hard)}\")\n", + "print(f\"Low R_e galaxies: {len(cosmos_low_re)}\")\n", + "print(f\"Sersic 7 galaxies: {len(cosmos_sersic7)}\")\n", + "print(f\"Sersic 7 Low R_e galaxies: {len(cosmos_sersic7_low_re)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b97ab69d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 15 37 46 ... 81430 81483 81487]\n", + "[ 1 15 18 ... 81483 81487 81491]\n", + "[ 15 63 92 ... 81404 81483 81487]\n", + "[ 1 15 18 ... 81483 81487 81491]\n" + ] + } + ], + "source": [ + "print(hard_inds[\"sersic7\"])\n", + "print(hard_inds[\"low_re\"])\n", + "print(hard_inds[\"sersic7_low_re\"])\n", + "print(all_hard)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "64a6cdaa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7680\n", + "8\n" + ] + } + ], + "source": [ + "cosmos_set = all_hard\n", + "\n", + "# Image pixel scale in arcsec/pixel\n", + "scale = 0.2\n", + "nn = 96\n", + "lens_shear = 0.02\n", + "n_rot = 4\n", + "\n", + "n_gal_stamp = 1600\n", + "stamp_size = int(nn * np.sqrt(n_rot * n_gal_stamp))\n", + "print(stamp_size)\n", + "\n", + "n_stamps = int(np.ceil(len(cosmos_set) / n_gal_stamp))\n", + "print(n_stamps)\n", + "\n", + "all_inds = np.arange(len(cosmos_set))\n", + "stamp_inds = np.array_split(all_inds, n_stamps)\n", + "\n", + "stamp_galaxies = []\n", + "for inds in stamp_inds:\n", + " if len(inds) == 0:\n", + " continue\n", + "\n", + " galaxies = cosmos.makeGalaxy(index=inds, gal_type='parametric')\n", + " records = cosmos.getParametricRecord(index=inds)\n", + "\n", + " # re-scale flux to match LSST\n", + " fluxes = 10 ** ((30 - records[\"mag_auto\"]) / 2.5)\n", + " galaxies = [gal.withFlux(flux) for gal, flux in zip(galaxies, fluxes)]\n", + "\n", + " stamp_galaxies.append(galaxies)\n", + "\n", + "# Define the PSF\n", + "psf = galsim.Moffat(beta=3.5, fwhm=0.7)\n", + "psf_array = psf.drawImage(nx=nn, ny=nn, scale=scale).array" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "51e34e9d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/8 [00:00=61", "wheel", - "pybind11>=2.2", - "numpy" + "pybind11>=3,<4", + "numpy>=1.26,<2.0" ] build-backend = "setuptools.build_meta" @@ -13,8 +13,8 @@ addopts = "-vv -s" [tool.black] line-length = 110 -target-version = ["py38"] +target-version = ["py310"] [tool.isort] profile = "black" -line_length = 110 \ No newline at end of file +line_length = 110 diff --git a/requirements.txt b/requirements.txt index 474bbdd..1c9c611 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,14 @@ stackvana +numpy>=1.26,<2.0 galsim -matplotlib +fitsio +matplotlib>=3.8,<3.9 +astropy>=6.0,<6.1 pip +pybind11>=3,<4 +# Optional GPU support: +# pip install .[cuda12] +# pip install .[cuda13] +# or install BATSim first and run: +# batsim-install-gpu diff --git a/setup.py b/setup.py index 8b1fc99..17204ba 100644 --- a/setup.py +++ b/setup.py @@ -1,82 +1,134 @@ import os +import sys +import sysconfig + from setuptools import Extension, find_packages, setup from setuptools.command.build_ext import build_ext -import pybind11 + +version_ns = {} +with open(os.path.join("src", "batsim", "_version.py")) as version_file: + exec(version_file.read(), version_ns) -class CustomBuildExt(build_ext): - def run(self): - # Dynamically set include_dirs and library_dirs before building - # extensions - include_dirs, lib_dirs = self.find_galsim_paths() +class BuildExt(build_ext): + def build_extensions(self): + pybind11_include_dirs = self._find_pybind11_paths() + include_dirs, library_dirs = self._find_galsim_paths() + + if not self._has_library(library_dirs, "galsim"): + search_paths = ", ".join(library_dirs) or "" + raise RuntimeError( + "Could not find GalSim's C++ shared library libgalsim. " + "Install GalSim from conda-forge, or build GalSim's shared C++ " + "library from the GalSim source tree with " + "`python setup.py build_shared_clib` and set GALSIM_LIB_DIR " + "and GALSIM_INCLUDE_DIR before installing BATSim. " + f"Searched library paths: {search_paths}" + ) for ext in self.extensions: - for _ in include_dirs: - ext.include_dirs.append(_) - for _ in lib_dirs: - ext.library_dirs.append(_) - ext.runtime_library_dirs.append(_) # For Linux + ext.include_dirs.extend( + [ + *pybind11_include_dirs, + *include_dirs, + ] + ) + ext.library_dirs.extend(library_dirs) + ext.runtime_library_dirs.extend(library_dirs) + ext.libraries.append("galsim") + + super().build_extensions() - super().run() + def _find_pybind11_paths(self): + prefix_include = os.path.join(sys.prefix, "include") + if os.path.exists(os.path.join(prefix_include, "pybind11", "pybind11.h")): + return [prefix_include] - def find_galsim_paths(self): + import pybind11 + + return [pybind11.get_include()] + + def _find_galsim_paths(self): include_dirs = [] - lib_dirs = [] - - # Prefer GalSim's own include directory if import works - try: - import galsim - inc = galsim.include_dir # .../site-packages/galsim/include - include_dirs.append(inc) - include_dirs.append(os.path.join(inc, "galsim")) # <-- add this - except Exception: - print("Error: Could not import GalSim to find include directory.") - - # Conda-build uses PREFIX for the host env (headers live here) + library_dirs = [] + + include_override = os.environ.get("GALSIM_INCLUDE_DIR") + if include_override: + include_dirs.extend([include_override, os.path.join(include_override, "galsim")]) + + lib_override = os.environ.get("GALSIM_LIB_DIR") + if lib_override: + library_dirs.append(lib_override) + prefixes = [ - os.environ.get("PREFIX"), # conda-build host env - os.environ.get("CONDA_PREFIX"), # active env fallback + sys.prefix, + os.environ.get("CONDA_PREFIX"), + os.environ.get("PREFIX"), + sysconfig.get_config_var("prefix"), ] - for p in prefixes: - if not p: + for prefix in prefixes: + if not prefix: continue - include_dirs.append(os.path.join(p, "include")) - include_dirs.append(os.path.join(p, "include", "galsim")) - include_dirs.append(os.path.join(p, "include", "eigen3")) - lib_dirs.append(os.path.join(p, "lib")) + include_dirs.extend( + [ + os.path.join(prefix, "include"), + os.path.join(prefix, "include", "galsim"), + os.path.join(prefix, "include", "eigen3"), + ] + ) + lib_dir = os.path.join(prefix, "lib") + if os.path.isdir(lib_dir): + library_dirs.append(lib_dir) + + if not self._has_header(include_dirs, "GalSim.h"): + try: + import galsim + + galsim_include = getattr(galsim, "include_dir", None) + if galsim_include: + include_dirs.extend([galsim_include, os.path.join(galsim_include, "galsim")]) + except ImportError: + pass - # 3) Last-resort system paths - include_dirs += ["/usr/local/include", "/usr/include", "/usr/include/eigen3"] - lib_dirs += ["/usr/local/lib", "/usr/lib"] + return self._dedupe(include_dirs), self._dedupe(library_dirs) - # De-duplicate preserving order - def uniq(xs): - out = [] - for x in xs: - if x and x not in out: - out.append(x) - return out + def _has_header(self, include_dirs, name): + return any(os.path.exists(os.path.join(directory, name)) for directory in include_dirs) - return uniq(include_dirs), uniq(lib_dirs) + def _has_library(self, library_dirs, name): + patterns = [f"lib{name}.so", f"lib{name}.dylib", f"{name}.lib"] + return any( + os.path.exists(os.path.join(directory, pattern)) + for directory in library_dirs + for pattern in patterns + ) + + def _dedupe(self, values): + out = [] + for value in values: + if value and value not in out: + out.append(value) + return out -# Define your extension module gsinterface = Extension( "batsim._gsinterface", sources=["src/batsim/_gsinterface.cpp"], - include_dirs=[pybind11.get_include()], - libraries=["galsim"], + include_dirs=[], + libraries=[], language="c++", extra_compile_args=["-std=c++17", "-fopenmp", "-O3"], - extra_link_args=["-flto", "-fopenmp"], + extra_link_args=["-fopenmp"], ) setup( name="batsim", + version=version_ns["__version__"], author="Charlie MacMahon, Andy Park", author_email="c.macmahon@ncl.ac.uk, chanhyup@andrew.cmu.edu", license="MIT", + python_requires=">=3.10,<3.13", long_description=open("README.md").read(), long_description_content_type="text/markdown", classifiers=[ @@ -88,10 +140,25 @@ def uniq(xs): "Programming Language :: Python", ], packages=find_packages(where="src"), + py_modules=["batsim_install_gpu"], package_dir={"": "src"}, + ext_modules=[gsinterface], + cmdclass={"build_ext": BuildExt}, install_requires=[ - "numpy", "pybind11>=2.2", "fitsio", "matplotlib", "astropy", + "numpy>=1.26,<2.0", + "galsim", + "fitsio", + "matplotlib>=3.8,<3.9", + "astropy>=6.0,<6.1", ], - ext_modules=[gsinterface], - cmdclass={"build_ext": CustomBuildExt}, + extras_require={ + "benchmark": ["asv>=0.6"], + "cuda12": ["cupy-cuda12x>=13.6,<14"], + "cuda13": ["cupy-cuda13x>=13.6,<14"], + }, + entry_points={ + "console_scripts": [ + "batsim-install-gpu=batsim_install_gpu:main", + ], + }, ) diff --git a/src/batsim/.nfs00000000749b680f00000c6e b/src/batsim/.nfs00000000749b680f00000c6e new file mode 100755 index 0000000..2487199 Binary files /dev/null and b/src/batsim/.nfs00000000749b680f00000c6e differ diff --git a/src/batsim/.nfs00000000749b791600000de8 b/src/batsim/.nfs00000000749b791600000de8 new file mode 100755 index 0000000..7c353eb Binary files /dev/null and b/src/batsim/.nfs00000000749b791600000de8 differ diff --git a/src/batsim/WCS.py b/src/batsim/WCS.py deleted file mode 100644 index 5d680bf..0000000 --- a/src/batsim/WCS.py +++ /dev/null @@ -1,36 +0,0 @@ -import fitsio -import numpy as np - - -class WCS(object): - def __init__(self, file_name=None): - if file_name is None: - print("Provide the filename") - - _, header = fitsio.read(file_name, header=True) - - self._set_ab(header) - - return - - def _set_ab(self, header): - a_order = int(header.get("A_ORDER")) - b_order = int(header.get("B_ORDER")) - order = max(a_order, b_order) - a = [ - float(header.get(f"A_{i}_{j}", 0)) - for i in range(order + 1) - for j in range(order + 1) - ] - a = np.array(a).reshape((order + 1, order + 1)) - b = [ - float(header.get(f"B_{i}_{j}", 0)) - for i in range(order + 1) - for j in range(order + 1) - ] - b = np.array(b).reshape((order + 1, order + 1)) - a[1, 0] += 1.0 - b[0, 1] += 1.0 - self.ab = np.array([a, b]) - - return diff --git a/src/batsim/__init__.py b/src/batsim/__init__.py index 34c8cca..ff67a14 100644 --- a/src/batsim/__init__.py +++ b/src/batsim/__init__.py @@ -1,8 +1,38 @@ -# flake8: noqa from ._version import __version__ version = __version__ -from . import WCS, _gsinterface, pltutil, stamp -from .sim import * -from .transforms import * +from . import experimental, pltutil, stamp + +try: + from . import _gsinterface +except ImportError: + _gsinterface = None + +from .sim import clear_backend_memory, simulate_galaxy +from .stamp import Stamp +from .transforms import ( + AffineLensingTransform, + FlexionTransform, + IATransform, + IaTransform, + LensTransform, + Transform, +) + +__all__ = [ + "__version__", + "version", + "simulate_galaxy", + "clear_backend_memory", + "Stamp", + "Transform", + "LensTransform", + "AffineLensingTransform", + "IaTransform", + "IATransform", + "FlexionTransform", + "experimental", + "pltutil", + "stamp", +] diff --git a/src/batsim/_gsinterface.cpp b/src/batsim/_gsinterface.cpp index ad2643f..6901856 100644 --- a/src/batsim/_gsinterface.cpp +++ b/src/batsim/_gsinterface.cpp @@ -1,191 +1,141 @@ #include #include +#include #include "GalSim.h" #include -#include -#include -#include #include +#include +#include namespace py = pybind11; -py::array_t getFluxVec( +template +py::array_t getFluxVecTyped( const double scale, const galsim::SBProfile& gsobj, - const py::array_t& xy_coords -){ - auto xy = xy_coords.unchecked<2>(); - const int n_points = xy_coords.shape(1); - const int dim = std::sqrt(n_points); + const py::array_t& xy_coords +) { + auto xy = xy_coords.template unchecked<2>(); + + if (xy_coords.ndim() != 2 || xy_coords.shape(0) != 2) { + throw std::runtime_error("xy_coords must have shape (2, n_points)"); + } + + const py::ssize_t n_points = xy_coords.shape(1); + const int dim = static_cast(std::sqrt(static_cast(n_points))); const int n_used = dim * dim; - auto result = py::array_t({dim, dim}); + + if (n_used != n_points) { + throw std::runtime_error("xy_coords.shape[1] must be a perfect square"); + } + + auto result = py::array_t({dim, dim}); auto out = result.mutable_data(); - double area = scale * scale; - // Pre-warm GalSim's internal cache with a single serial call - // before entering the parallel region - gsobj.xValue(galsim::Position(xy(0, 0), xy(1, 0))); + const double area = scale * scale; + + // Pre-warm GalSim's internal cache with a single serial call. + gsobj.xValue( + galsim::Position( + static_cast(xy(0, 0)), + static_cast(xy(1, 0)) + ) + ); #pragma omp parallel for schedule(static) - for(int i = 0; i < n_used; ++i) { - out[i] = gsobj.xValue( - galsim::Position(xy(0, i), xy(1, i)) + for (int i = 0; i < n_used; ++i) { + const double x = static_cast(xy(0, i)); + const double y = static_cast(xy(1, i)); + + const double flux = gsobj.xValue( + galsim::Position(x, y) ) * area; + out[i] = static_cast(flux); } return result; } -// Utility function to generate rfftfreq -std::vector rfftfreq(int n, double scale) { - std::vector result(n/2 + 1); - for(int i = 0; i <= n / 2; ++i) { - result[i] = i / (scale * n); +template +py::array_t getPsfKValueTyped( + const double scale, + const galsim::SBProfile& gsobj, + const int n +) { + if (n <= 0) { + throw std::runtime_error("n must be positive"); } - return result; -} -// Utility function to generate fftfreq -std::vector fftfreq(int n, double scale) { - std::vector result(n); - double val = 1.0 / (n * scale); - for(int i = 0; i < n; ++i) { - if (i < (n + 1) / 2) { - result[i] = i * val; - } else { - result[i] = (i - n) * val; - } - } - return result; -} + const int nkx = n / 2 + 1; + auto result = py::array_t({n, nkx}); + auto out = result.mutable_data(); -bool is_c_contiguous(const py::array& arr) { - return arr.flags() & py::array::c_style; -} + const double dk = 2.0 * M_PI / (static_cast(n) * scale); -// Convolve gal_prof (defined in configuration space) with Galsim PSF object -// Then perform a down sampling -py::array_t convolvePsf( - const double scale, - const galsim::SBProfile& gsobj, - const py::array_t& gal_prof, - const int downsample_ratio, - const int ngrid -){ - bool test = is_c_contiguous(gal_prof); - if (! test) { - throw std::runtime_error( - "Input galaxy array is not continuous in memory" - ); - } - auto info = gal_prof.request(); - int dim = info.shape[0]; - - // down sampled scale and dimension - double scale2 = scale * downsample_ratio; - int dim2 = dim / downsample_ratio; - - // Frequency grids for the down sampled signal - const auto x_freqs2 = rfftfreq(dim2, scale2); - const auto y_freqs2 = fftfreq(dim2, scale2); - - // Allocate FFTW arrays with pointers - double* in = static_cast(info.ptr); - fftw_complex* out = fftw_alloc_complex(dim * (dim / 2 + 1)); - fftw_complex* out2 = fftw_alloc_complex(dim2 * (dim2 / 2 + 1)); - - // Plan and execute forward FFT - fftw_plan p_forward = fftw_plan_dft_r2c_2d(dim, dim, in, out, FFTW_ESTIMATE); - fftw_execute(p_forward); - - // Pre-warm GalSim's internal cache with a single serial call - // before entering the parallel region - gsobj.kValue(galsim::Position(x_freqs2[0], y_freqs2[0])); - - // Process FFT result using gsobj - #pragma omp parallel for - for (int y2 = 0; y2 < dim2; ++y2) { - int y = (y2 >= dim2 / 2) ? (dim - dim2 + y2) : y2; - for (int x2 = 0; x2 < (dim2 / 2 + 1); ++x2) { - int x = x2; - int index = y * (dim / 2 + 1) + x; - int index2 = y2 * (dim2 / 2 + 1) + x2; - std::complex fft_val(out[index][0], out[index][1]); - std::complex result = fft_val * gsobj.kValue( - galsim::Position( - 2.0 * M_PI * x_freqs2[x2], - 2.0 * M_PI * y_freqs2[y2] - ) + // Pre-warm GalSim's internal cache with a single serial call. + gsobj.kValue(galsim::Position(0.0, 0.0)); + + #pragma omp parallel for schedule(static) + for (int y = 0; y < n; ++y) { + const int ky_index = (y < (n + 1) / 2) ? y : y - n; + const double ky = dk * static_cast(ky_index); + + for (int x = 0; x < nkx; ++x) { + const double kx = dk * static_cast(x); + const std::complex value = gsobj.kValue( + galsim::Position(kx, ky) + ); + + out[y * nkx + x] = ComplexT( + static_cast(value.real()), + static_cast(value.imag()) ); - out2[index2][0] = result.real(); - out2[index2][1] = result.imag(); - } - } - // Cleanup fftw - fftw_destroy_plan(p_forward); - fftw_free(out); - - // Allocate array for inverse FFT result - double* ifft_out = fftw_alloc_real(dim2 * dim2); - // Plan and execute inverse FFT - fftw_plan p_backward = fftw_plan_dft_c2r_2d(dim2, dim2, out2, ifft_out, FFTW_ESTIMATE); - fftw_execute(p_backward); - // Cleanup fftw - fftw_destroy_plan(p_backward); - fftw_free(out2); - - // Normalize once; FFTW inverse is unnormalized - const double inv_norm = 1.0 / static_cast(dim2) / static_cast(dim2); - - auto result = py::array_t({ngrid, ngrid}); - auto r = result.mutable_unchecked<2>(); - - // Define source and destination rectangles centered - const int src_w = dim2, src_h = dim2; - const int dst_w = ngrid, dst_h = ngrid; - - // Centers with explicit floor for clarity - const int src_cx = src_w / 2; // floor - const int src_cy = src_h / 2; - const int dst_cx = dst_w / 2; - const int dst_cy = dst_h / 2; - - // Compute the overlap box in destination coordinates - // We want to place the src centered into dst. - for (int dy = 0; dy < dst_h; ++dy) { - int sy = dy - dst_cy + src_cy; - bool in_y = (0 <= sy && sy < src_h); - for (int dx = 0; dx < dst_w; ++dx) { - int sx = dx - dst_cx + src_cx; - bool in_x = (0 <= sx && sx < src_w); - if (in_x && in_y) { - r(dy, dx) = ifft_out[sy * src_w + sx] * inv_norm; - } else { - r(dy, dx) = 0.0; // pad outside - } } } - // Cleanup fftw - fftw_free(ifft_out); + return result; } PYBIND11_MODULE(_gsinterface, m) { - m.doc() = "Pybind11 interface for GalSim flux and Fourier computations"; + m.doc() = "Pybind11 interface for GalSim flux sampling"; + m.def( + "getFluxVec", + &getFluxVecTyped, + py::arg("scale"), + py::arg("gsobj"), + py::arg("xy_coords"), + "Sample galaxy flux using float64 coordinates and output." + ); + m.def( + "getFluxVec64", + &getFluxVecTyped, + py::arg("scale"), + py::arg("gsobj"), + py::arg("xy_coords"), + "Sample galaxy flux using float64 coordinates and output." + ); + m.def( + "getFluxVec32", + &getFluxVecTyped, + py::arg("scale"), + py::arg("gsobj"), + py::arg("xy_coords"), + "Sample galaxy flux using float32 coordinates and output." + ); m.def( - "getFluxVec", &getFluxVec, - "Get flux values at multiple x,y coordinates", + "getPsfKValue64", + &getPsfKValueTyped>, py::arg("scale"), py::arg("gsobj"), - py::arg("xy_coords") + py::arg("n"), + "Sample PSF kValue on a float64/complex128 rFFT frequency grid." ); m.def( - "convolvePsf", &convolvePsf, - "Convolve galaxy profile with PSF", + "getPsfKValue32", + &getPsfKValueTyped>, py::arg("scale"), py::arg("gsobj"), - py::arg("gal_prof"), - py::arg("downsample_ratio"), - py::arg("ngrid") + py::arg("n"), + "Sample PSF kValue on a float32/complex64 rFFT frequency grid." ); } diff --git a/src/batsim/_version.py b/src/batsim/_version.py index 6a56492..022d506 100644 --- a/src/batsim/_version.py +++ b/src/batsim/_version.py @@ -1 +1 @@ -__version__ = "0.0.1" # noqa +__version__ = "0.9.1" # noqa diff --git a/src/batsim/backend.py b/src/batsim/backend.py new file mode 100644 index 0000000..bb9d606 --- /dev/null +++ b/src/batsim/backend.py @@ -0,0 +1,130 @@ +"""Array backend selection and memory-management helpers.""" + +import gc +import types +import numpy as np + + +def _get_array_backend(): + """ + Return BATSim's default array backend. + + NumPy is the default backend. CuPy is used only when explicitly requested + through ``_resolve_array_backend("cp")`` or supplied as a module object. + """ + return np + + +def _resolve_array_backend(backend): + """ + Resolve a user-supplied backend selector to an array module. + + ``None`` means NumPy, string aliases request a specific backend, and + module objects allow tests or callers to pass an already-imported array + module. + """ + if backend is None: + return np + + if backend is np or backend in ("np", "numpy"): + return np + + if backend in ("cp", "cupy"): + try: + import cupy as cp + + cp.cuda.runtime.getDeviceCount() + return cp + except Exception as exc: + raise RuntimeError("backend='cp' was requested, but CuPy is unavailable.") from exc + + if isinstance(backend, types.ModuleType): + return backend + + raise ValueError(f"Invalid backend '{backend}'; must be 'np', 'cp', a module, or None.") + + +def _to_numpy(xp, array): + """Convert a NumPy/CuPy array to a NumPy array.""" + if xp is np: + return np.asarray(array) + return xp.asnumpy(array) + + +def _precision_dtypes(xp, precision): + """Return real and complex dtypes for the requested FFT precision.""" + if precision == "single": + return xp.float32, xp.complex64 + + if precision == "double": + return xp.float64, xp.complex128 + + raise ValueError(f"Invalid precision '{precision}'; must be 'single' or 'double'.") + + +def _release_backend_memory(xp): + """ + Release cached CuPy allocations after a simulation. + + NumPy has no comparable memory pools, so this is intentionally a no-op for + CPU-backed renders. + """ + if xp is np: + return + + gc.collect() + + try: + xp.cuda.Stream.null.synchronize() + except Exception: + pass + + try: + xp.fft.config.get_plan_cache().clear() + except Exception: + pass + + gc.collect() + + try: + xp.get_default_memory_pool().free_all_blocks() + except Exception: + pass + + try: + xp.get_default_pinned_memory_pool().free_all_blocks() + except Exception: + pass + + gc.collect() + + +def clear_backend_memory(backend=None): + """ + Clear cached memory held by the selected array backend. + + This is primarily useful after CuPy out-of-memory errors in notebooks or + long-running sessions. Calling it for the NumPy backend is a no-op. + + Parameters + ---------- + backend : {"np", "numpy", "cp", "cupy"} or module or None, optional + Backend to clear. ``None`` selects NumPy, strings select NumPy or + CuPy explicitly, and module objects are used directly. + + Returns + ------- + None + """ + xp = _resolve_array_backend(backend) + _release_backend_memory(xp) + + +def sync_if_gpu(xp): + """ + Synchronise the default CuPy stream when using a GPU backend. + + This is only used for timing and profiling and is a no-op for the NumPy backend. + """ + if xp is not np: + xp.cuda.Stream.null.synchronize() diff --git a/src/batsim/experimental/__init__.py b/src/batsim/experimental/__init__.py new file mode 100644 index 0000000..964eb6d --- /dev/null +++ b/src/batsim/experimental/__init__.py @@ -0,0 +1,5 @@ +"""Experimental BATSim helpers that are not part of the stable public API.""" + +from .wcs import WCS + +__all__ = ["WCS"] diff --git a/src/batsim/experimental/wcs.py b/src/batsim/experimental/wcs.py new file mode 100644 index 0000000..362062e --- /dev/null +++ b/src/batsim/experimental/wcs.py @@ -0,0 +1,55 @@ +"""Experimental WCS helpers.""" + +import fitsio +import numpy as np + + +class WCS(object): + """ + Read SIP distortion coefficients from a FITS image header. + + The parsed coefficients are stored in ``ab`` with shape + ``(2, order + 1, order + 1)``. The first plane contains the A polynomial + coefficients and the second plane contains the B polynomial coefficients. + """ + + def __init__(self, file_name=None): + """ + Load SIP WCS coefficients from a FITS file. + + Parameters + ---------- + file_name : str + Path to a FITS file containing ``A_ORDER``/``B_ORDER`` and + ``A_i_j``/``B_i_j`` header cards. + """ + if file_name is None: + print("Provide the filename") + + _, header = fitsio.read(file_name, header=True) + + self._set_ab(header) + + return + + def _set_ab(self, header): + """ + Populate the SIP A/B coefficient array from a FITS header. + + Parameters + ---------- + header : mapping + FITS header object containing SIP polynomial metadata. + """ + a_order = int(header.get("A_ORDER")) + b_order = int(header.get("B_ORDER")) + order = max(a_order, b_order) + a = [float(header.get(f"A_{i}_{j}", 0)) for i in range(order + 1) for j in range(order + 1)] + a = np.array(a).reshape((order + 1, order + 1)) + b = [float(header.get(f"B_{i}_{j}", 0)) for i in range(order + 1) for j in range(order + 1)] + b = np.array(b).reshape((order + 1, order + 1)) + a[1, 0] += 1.0 + b[0, 1] += 1.0 + self.ab = np.array([a, b]) + + return diff --git a/src/batsim/fft.py b/src/batsim/fft.py new file mode 100644 index 0000000..daf7b96 --- /dev/null +++ b/src/batsim/fft.py @@ -0,0 +1,394 @@ +"""Fourier-space convolution and image extraction helpers.""" + +import time + +import numpy as np + +from .backend import _to_numpy, sync_if_gpu +from .sampling import _sample_psf_spectrum + + +def _center_crop_or_pad(array, target_shape): + """ + Centrally crop or zero-pad an array to the requested shape. + + This is used after the internal simulation grid has been rendered so the + caller's requested output size is a centered view of the same simulation. + """ + out = np.zeros(target_shape, dtype=array.dtype) + + src_y, src_x = array.shape + dst_y, dst_x = target_shape + + copy_y = min(src_y, dst_y) + copy_x = min(src_x, dst_x) + + src_y0 = (src_y - copy_y) // 2 + src_x0 = (src_x - copy_x) // 2 + dst_y0 = (dst_y - copy_y) // 2 + dst_x0 = (dst_x - copy_x) // 2 + + out[dst_y0 : dst_y0 + copy_y, dst_x0 : dst_x0 + copy_x] = array[ + src_y0 : src_y0 + copy_y, + src_x0 : src_x0 + copy_x, + ] + + return out + + +def _draw_centered_psf(xp, psf_obj, n, scale, dtype=None): + """ + Draw the PSF on the full FFT grid. + + Pixel convolution is not included here; the pixel response is applied + separately in Fourier space. + """ + psf_image = psf_obj.drawImage( + nx=n, + ny=n, + scale=scale, + method="no_pixel", + use_true_center=False, + ).array + + return xp.asarray(psf_image, dtype=dtype) + + +def _rfft_centered_image(xp, image, real_dtype, complex_dtype, center_index=None): + """ + Compute rfft2(ifftshift(image)) without explicitly shifting the image. + + The input image remains in the centred real-space convention. The phase + correction converts the spectrum to the convention that would have been + obtained by first applying np.fft.ifftshift(image). + """ + n = image.shape[0] + + image = xp.asarray(image, dtype=real_dtype) + image = xp.ascontiguousarray(image) + spectrum = xp.fft.rfft2(image).astype(complex_dtype, copy=False) + + del image + + _apply_centering_phase(xp, spectrum, n, center_index=center_index) + + return spectrum + + +def _apply_centering_phase(xp, spectrum, n, center_index=None): + """ + Apply the Fourier phase equivalent to np.fft.ifftshift before an FFT. + + This avoids materialising a shifted real-space image, which is expensive + for very large supersampled stamps. + """ + if center_index is None: + center_index = n // 2 + + shift = -float(center_index) + + # Applying the separable phase is equivalent to ifftshift before rfft2, + # without moving the large real-space array in memory. + ky = xp.fft.fftfreq(n) * n + kx = xp.fft.rfftfreq(n) * n + + phase_y = xp.exp(-2j * xp.pi * ky * shift / n) + phase_x = xp.exp(-2j * xp.pi * kx * shift / n) + + phase_y = phase_y.astype(spectrum.dtype, copy=False) + phase_x = phase_x.astype(spectrum.dtype, copy=False) + + spectrum *= phase_y[:, None] + spectrum *= phase_x[None, :] + + +def _apply_pixel_response(xp, spectrum, n, fine_scale, pix_scale): + """ + Apply the square-pixel Fourier response in-place on an rfft2 grid. + + The response is separable, so this avoids allocating a full 2D pixel FFT. + """ + ky = 2.0 * xp.pi * xp.fft.fftfreq(n, d=fine_scale) + kx = 2.0 * xp.pi * xp.fft.rfftfreq(n, d=fine_scale) + + pix_y = xp.sinc(ky * pix_scale / (2.0 * xp.pi)) + pix_x = xp.sinc(kx * pix_scale / (2.0 * xp.pi)) + + real_dtype = spectrum.real.dtype + pix_y = pix_y.astype(real_dtype, copy=False) + pix_x = pix_x.astype(real_dtype, copy=False) + + spectrum *= pix_y[:, None] + spectrum *= pix_x[None, :] + + +def _block_integration_response(xp, k, fine_scale, mode="quadrature", integration_order=None): + """Return the 1D Fourier response introduced by block integration.""" + if mode == "exact_sinc": + return xp.sinc(k * fine_scale / (2.0 * xp.pi)) + + if mode == "quadrature": + if integration_order is None or integration_order <= 1: + raise ValueError("integration_order > 1 is required for quadrature compensation.") + + nodes, weights = np.polynomial.legendre.leggauss(int(integration_order)) + offsets = xp.asarray(0.5 * nodes * fine_scale, dtype=k.dtype) + weights = xp.asarray(0.5 * weights, dtype=k.dtype) + + phase = k[:, None] * offsets[None, :] + response = xp.sum(weights[None, :] * xp.cos(phase), axis=1) + return response + + raise ValueError( + "Invalid block integration compensation mode " f"'{mode}'; must be 'quadrature' or 'exact_sinc'." + ) + + +def _compensate_block_integration( + xp, + spectrum, + n, + fine_scale, + min_response=1.0e-3, + mode="quadrature", + integration_order=None, +): + """ + Remove the fine-pixel averaging response introduced by block integration. + + Gauss-Legendre block integration approximates the mean surface brightness + over each fine-grid pixel, introducing a separable pre-smoothing response. + Divide out this response within the represented Fourier band before + applying the physical PSF convolution. + + ``mode="quadrature"`` removes the discrete Gauss-Legendre transfer + function for the configured nodes and weights. ``mode="exact_sinc"`` keeps + the ideal top-hat response compensation available as an explicit option. + """ + ky = 2.0 * xp.pi * xp.fft.fftfreq(n, d=fine_scale) + kx = 2.0 * xp.pi * xp.fft.rfftfreq(n, d=fine_scale) + + response_y = _block_integration_response( + xp=xp, + k=ky, + fine_scale=fine_scale, + mode=mode, + integration_order=integration_order, + ) + response_x = _block_integration_response( + xp=xp, + k=kx, + fine_scale=fine_scale, + mode=mode, + integration_order=integration_order, + ) + + real_dtype = spectrum.real.dtype + min_response = xp.asarray(min_response, dtype=real_dtype) + response_y = response_y.astype(real_dtype, copy=False) + response_x = response_x.astype(real_dtype, copy=False) + + response_y = xp.maximum(response_y, min_response) + response_x = xp.maximum(response_x, min_response) + + spectrum /= response_y[:, None] + spectrum /= response_x[None, :] + + +def _extract_centered_coarse_image(xp, image, downsample_ratio, center_index=None): + """ + Return fftshift(image)[::downsample_ratio, ::downsample_ratio] without + explicitly materialising fftshift(image). + + This keeps the expensive full-resolution image shift out of both GPU and + CPU memory paths. Only the already-downsampled coarse image is gathered. + """ + n = image.shape[0] + s = int(downsample_ratio) + + if s < 1: + raise ValueError("downsample_ratio must be >= 1") + + coarse_n = n // s + if center_index is None: + center_index = n // 2 + + # The wrapped center must fall on an integer pixel in FFT output order so + # strided extraction matches fftshift(image)[::s, ::s]. + wrapped_center = -float(center_index) + if not np.isclose(wrapped_center, round(wrapped_center)): + raise ValueError( + "The fine-grid center is not aligned with integer FFT output pixels. " + "Use an even downsample_ratio, or use_true_center=False." + ) + + wrapped_center = int(round(wrapped_center)) + + rows = (xp.arange(coarse_n) * s + wrapped_center) % n + cols = (xp.arange(coarse_n) * s + wrapped_center) % n + + coarse = image[rows[:, None], cols[None, :]] + del image, rows, cols + + if s > 1: + coarse = (s**2) * coarse + + return _to_numpy(xp, coarse) + + +def _extract_centered_real_space_coarse_image(xp, image, downsample_ratio): + """ + Extract the aligned coarse grid from a centred real-space fine image. + + Unlike ``_extract_centered_coarse_image``, this is for images that have not + passed through an inverse FFT and therefore are already in spatial order. + """ + n = image.shape[0] + s = int(downsample_ratio) + + if s < 1: + raise ValueError("downsample_ratio must be >= 1") + if n % s != 0: + raise ValueError("fine image size must be divisible by downsample_ratio") + + coarse = image[::s, ::s] + + if s > 1: + coarse = (s**2) * coarse + + return _to_numpy(xp, coarse) + + +def _convolve_psf_fft( + xp, + gal_prof, + scale, + pix_scale, + psf_obj, + downsample_ratio, + draw_method, + dtypes, + psf_mode, + integration_order=1, + integration_compensation_mode="quadrature", + center_index=None, + target_flux=None, + profile=False, +): + """ + Convolve the sampled galaxy with PSF and/or pixel response using rFFT. + + The expensive path avoids explicit fftshift/ifftshift operations. Instead: + - centred real-space images are converted by Fourier phase correction; + - the pixel response is applied separably in-place; + - the full fine-grid image is inverse FFT'd, then downsampled in real space. + + ``psf_mode="kvalue"`` samples GalSim's analytic Fourier PSF through the C++ + backend, avoiding a real-space PSF draw and an extra FFT. + """ + n = gal_prof.shape[0] + real_dtype, complex_dtype = dtypes + + spectrum = _rfft_centered_image( + xp=xp, + image=gal_prof, + real_dtype=real_dtype, + complex_dtype=complex_dtype, + center_index=center_index, + ) + + if integration_compensation_mode is not None and integration_order > 1: + start = time.time() if profile else None + _compensate_block_integration( + xp=xp, + spectrum=spectrum, + n=n, + fine_scale=scale, + mode=integration_compensation_mode, + integration_order=integration_order, + ) + if profile: + sync_if_gpu(xp) + end = time.time() + print(f"Block integration compensation took {end - start:.3f} seconds") + + if psf_obj is not None and psf_mode == "real": + start = time.time() if profile else None + psf_image = _draw_centered_psf( + xp=xp, + psf_obj=psf_obj, + n=n, + scale=scale, + dtype=real_dtype, + ) + if profile: + sync_if_gpu(xp) + end = time.time() + print(f"Drawing and transferring PSF took {end - start:.3f} seconds") + + psf_spectrum = _rfft_centered_image( + xp=xp, + image=psf_image, + real_dtype=real_dtype, + complex_dtype=complex_dtype, + center_index=center_index, + ) + + spectrum *= psf_spectrum + del psf_image, psf_spectrum + + elif psf_obj is not None and psf_mode == "kvalue": + start = time.time() if profile else None + # The compiled backend returns the analytic PSF on BATSim's rFFT grid, + # matching the spectrum convention used for the sampled galaxy. + psf_spectrum = _sample_psf_spectrum( + psf_obj=psf_obj, + n=n, + fine_scale=scale, + complex_dtype=complex_dtype, + ) + + if profile: + end = time.time() + print(f"Sampling PSF spectrum took {end - start:.3f} seconds") + + start = time.time() if profile else None + psf_spectrum = xp.asarray(psf_spectrum, dtype=complex_dtype) + if profile: + sync_if_gpu(xp) + end = time.time() + target = "GPU" if xp is not np else "NumPy" + print(f"Transfer PSF spectrum to {target} took {end - start:.3f} seconds") + + spectrum *= psf_spectrum + del psf_spectrum + + elif psf_obj is not None: + raise ValueError(f"Invalid psf_mode '{psf_mode}'; must be 'real' or 'kvalue'.") + + if draw_method == "auto": + _apply_pixel_response( + xp=xp, + spectrum=spectrum, + n=n, + fine_scale=scale, + pix_scale=pix_scale, + ) + + image = xp.fft.irfft2(spectrum, s=(n, n)) + del spectrum + + # Preserve the requested input flux after PSF/pixel convolution and any + # integration compensation. + if target_flux is not None: + image *= target_flux / image.sum() + + coarse_image = _extract_centered_coarse_image( + xp=xp, + image=image, + downsample_ratio=downsample_ratio, + center_index=center_index, + ) + del image + + return coarse_image diff --git a/src/batsim/grid.py b/src/batsim/grid.py new file mode 100644 index 0000000..2c001c7 --- /dev/null +++ b/src/batsim/grid.py @@ -0,0 +1,197 @@ +"""Grid sizing and quadrature helpers for BATSim rendering.""" + +from dataclasses import dataclass + +import galsim +import numpy as np + + +@dataclass(frozen=True) +class FineGrid: + """ + Description of the high-resolution grid used by the renderer. + + The fine grid is where BATSim samples the GalSim profile before any + Fourier-space PSF or pixel convolution to ensure any fine-structure and non-affine + shear is adequately sampled. ``fine_compact`` records the + GalSim-recommended compact support at ``fine_scale`` so callers can inspect + whether a size cap forced the simulation grid smaller than that support. + """ + + fine_scale: float + fine_ngrid: int + fine_compact: int + + +def _determine_supersampling( + obj, + scale, + integration_order, + sim_ngrid, + pad, + safety=2.0, + max_supersample=16, + min_supersample=4, + attenuation_target=0.5, + max_fine_grid=None, +): + """ + Estimate supersampling from Fourier bandwidth and compact image extent. + + The returned factor is the requested total anti-aliasing budget before it + is split between sub-pixel integration and FFT supersampling. + """ + maxk = obj.maxk + nyquist = np.pi / scale + + raw = safety * maxk / nyquist + + q = max(1, int(integration_order)) + + if q <= 1: + effective = raw + else: + # Block integration suppresses high-frequency leakage before the FFT, + # but it does not replace the need to sample compact profiles on a + # fine enough grid. Keep the reduction conservative so small Sersic + # profiles are not under-resolved before pixel convolution. + # attenuation_target lets you tune how much high-k leakage you tolerate. + integration_reduction = q * attenuation_target**0.5 + + # Avoid degenerate settings that would increase the requested + # supersampling when using block integration. + integration_reduction = max(integration_reduction, 1.0) + + effective = raw / integration_reduction + + # Do not allow the requested effective supersampling to fall below q, + # otherwise fft_supersample may collapse too aggressively. + effective = max(effective, q) + + bandwidth_supersample = 2 ** int(np.ceil(np.log2(max(min_supersample, effective)))) + bandwidth_supersample = int(np.clip(bandwidth_supersample, min_supersample, max_supersample)) + + if max_fine_grid is None: + return bandwidth_supersample + + max_fine_grid = int(max_fine_grid) + trial = bandwidth_supersample + extent_supersample = min_supersample + compact_limit = 3.0 * max_fine_grid + + while trial >= min_supersample: + trial_integration_order = min(q, trial) + trial_fft_supersample = int(np.ceil(trial / trial_integration_order)) + trial_fft_supersample = max(trial_fft_supersample, min_supersample) + fine_scale = scale / trial_fft_supersample + fine_compact = int(obj.getGoodImageSize(fine_scale)) + # GalSim's compact size is allowed to exceed the final grid, but not by + # so much that a compact source silently creates a very large FFT. + if fine_compact < compact_limit: + extent_supersample = trial + break + trial //= 2 + + supersample = min(bandwidth_supersample, extent_supersample) + return int(np.clip(supersample, min_supersample, max_supersample)) + + +def _resolve_simulation_ngrid(gal_obj, psf_obj, scale): + """ + Choose the coarse-grid simulation size. + + This is deliberately independent of the requested final output ngrid + and is only run when no user specified grid size is provided. + """ + if psf_obj is None: + return int(gal_obj.getGoodImageSize(scale)) + + conv = galsim.Convolve([gal_obj, psf_obj]) + return int(conv.getGoodImageSize(scale)) + + +def _make_fine_grid(gal_obj, scale, sim_ngrid, supersample, pad, max_fine_grid=None): + """ + Construct the fine grid used for sampling and convolution. + + The grid is at least large enough for the padded coarse simulation region + and is rounded up to a whole number of supersampling blocks so later + downsampling is exact. + """ + fine_scale = scale / supersample + + requested_fine_ngrid = (sim_ngrid + 2 * pad) * supersample + fine_compact = int(gal_obj.getGoodImageSize(fine_scale)) + + fine_ngrid = max(requested_fine_ngrid, fine_compact) + + remainder = fine_ngrid % supersample + if remainder: + fine_ngrid += supersample - remainder + + if max_fine_grid is not None: + max_fine_grid = int(max_fine_grid) + if max_fine_grid < 1: + raise ValueError("max_fine_grid must be positive.") + + capped_fine_ngrid = max_fine_grid - (max_fine_grid % supersample) + if capped_fine_ngrid < supersample: + raise ValueError("max_fine_grid must be at least one supersampling block.") + + fine_ngrid = min(fine_ngrid, capped_fine_ngrid) + + return FineGrid( + fine_scale=fine_scale, + fine_ngrid=fine_ngrid, + fine_compact=fine_compact, + ) + + +def _resolve_integration_sampling(supersample, integration_order): + """ + Split the anti-aliasing budget between integration and FFT supersampling. + + The product of the returned FFT supersampling and integration order covers + the requested total supersampling, with the integration order capped so it + never exceeds that total budget. + """ + supersample = int(supersample) + integration_order = int(integration_order) + + if supersample < 1: + raise ValueError("supersample must be >= 1.") + if integration_order < 1: + raise ValueError("integration_order must be >= 1.") + + integration_order = min(integration_order, supersample) + fft_supersample = int(np.ceil(supersample / integration_order)) + + return fft_supersample, integration_order + + +def _integration_offsets(xp, fine_scale, integration_order, dtype): + """ + Return sub-pixel offsets and weights for Gauss-Legendre block integration. + + The weights integrate over one fine pixel in normalized coordinates and + therefore sum to one. + """ + if integration_order <= 1: + return None, None + + nodes, weights = np.polynomial.legendre.leggauss(integration_order) + offsets_1d = xp.asarray(0.5 * nodes * fine_scale, dtype=dtype) + weights_1d = xp.asarray(0.5 * weights, dtype=dtype) + + yy, xx = xp.meshgrid(offsets_1d, offsets_1d, indexing="ij") + wy, wx = xp.meshgrid(weights_1d, weights_1d, indexing="ij") + + offsets = xp.stack( + [ + xx.ravel(), + yy.ravel(), + ], + axis=1, + ) + + return offsets, (wx * wy).ravel() diff --git a/src/batsim/pltutil.py b/src/batsim/pltutil.py index e27bd8d..92bda75 100644 --- a/src/batsim/pltutil.py +++ b/src/batsim/pltutil.py @@ -1,3 +1,5 @@ +"""Legacy plotting utilities used by BATSim examples and validation notebooks.""" + import galsim import matplotlib.pyplot as plt import numpy as np @@ -24,12 +26,30 @@ def make_figure_axes(ny=1, nx=1, square=True): - """Makes figure and axes + """ + Create a Matplotlib figure with one of BATSim's preset subplot layouts. + + Parameters + ---------- + ny : int, optional + Number of subplot rows. + nx : int, optional + Number of subplot columns. + square : bool, optional + Select the taller preset size for the supported ``2 x 1`` layout. + + Returns + ------- + tuple + ``(fig, axes)`` where ``fig`` is a Matplotlib figure and ``axes`` is a + flat list of axes in creation order. - Args: - ny (int): number of subplots in y direction - nx (int): number of subplots in y direction - square (bool): whether using square plot + Raises + ------ + TypeError + Raised if ``ny`` or ``nx`` is not an integer. + ValueError + Raised if the requested layout is not one of the supported presets. """ if not isinstance(ny, int): raise TypeError("ny should be integer") @@ -81,14 +101,18 @@ def make_figure_axes(ny=1, nx=1, square=True): def determine_cuts(data): """ - Determine min_cut and max_cut for the data using median and standard deviation. + Determine display cuts for image data using fixed percentiles. - Parameters: - data (ndarray): 2D numpy array containing the image data - sigma (int): Number of standard deviations to use for max_cut + Parameters + ---------- + data : ndarray + Image array used to calculate display cuts. - Returns: - min_cut, max_cut: Calculated cuts + Returns + ------- + tuple of float + ``(min_cut, max_cut)`` from the 5th and 98th percentiles of the + flattened input data. """ min_cut = np.percentile(np.ravel(data), 5) max_cut = np.percentile(np.ravel(data), 98) @@ -96,27 +120,46 @@ def determine_cuts(data): def make_plot_image(data): + """ + Display image data with BATSim's default asinh plotting normalisation. + + Parameters + ---------- + data : ndarray + Two-dimensional image array to display. + + Returns + ------- + matplotlib.image.AxesImage + Image artist returned by ``matplotlib.pyplot.imshow``. + """ min_cut, max_cut = determine_cuts(data) - sn = simple_norm(data, "asinh", asinh_a=0.1, min_cut=min_cut, max_cut=max_cut) + sn = simple_norm(data, "asinh", asinh_a=0.1, vmin=min_cut, vmax=max_cut) fig = plt.imshow(data, aspect="equal", cmap="RdYlBu_r", origin="lower", norm=sn) return fig def stitch_images(images, direction="horizontal", spacing=None): """ - Stitch multiple images together to create a single composite image. - - Args: - images (list): A list of images to be stitched together. - direction (str, optional): The direction of stitching. Can be 'horizontal' or 'vertical'. Defaults to 'horizontal'. - spacing (int, optional): The spacing between images. If None, images will be stitched with no gap between them. Defaults to None. + Stitch equal-sized Galsim image objects into a single composite image. - Returns: - galsim.ImageF: The stitched composite image. - - Raises: - None + Parameters + ---------- + images : sequence of galsim.Image + Images to stitch together. All images are expected to share the same + dimensions and pixel scale. + direction : {"horizontal", "vertical", "square"}, optional + Direction in which images are concatenated. ``"square"`` arranges the + images on a square grid, leaving any unused cells blank. + spacing : None, optional + Placeholder for future gap support. Only ``None`` is currently + implemented. + Returns + ------- + galsim.ImageF or None + Composite image when ``spacing`` is ``None`` and ``direction`` is + supported; otherwise ``None``. """ # read in sizes of the individual images # MUST BE SAME FOR ALL IMAGES RIGHT NOW @@ -137,9 +180,7 @@ def stitch_images(images, direction="horizontal", spacing=None): for image in images: # Determine the bounds within which image should be # placed in super_image and then place - bounds = galsim.BoundsI( - xmin=1 + (i * nx), xmax=nx + (i * nx), ymin=1, ymax=ny - ) + bounds = galsim.BoundsI(xmin=1 + (i * nx), xmax=nx + (i * nx), ymin=1, ymax=ny) super_image.setSubImage(bounds, image) @@ -157,20 +198,56 @@ def stitch_images(images, direction="horizontal", spacing=None): for image in images: # Determine the bounds within which image should be # placed in super_image and then place + bounds = galsim.BoundsI(xmin=1, xmax=nx, ymin=1 + (i * ny), ymax=ny + (i * ny)) + + super_image.setSubImage(bounds, image) + + i = i + 1 # update for next iteration + return super_image + + elif direction == "square": + nside = int(np.ceil(np.sqrt(len(images)))) + Nx = nside * nx + Ny = nside * ny + super_image = galsim.ImageF(Nx, Ny, scale=scale) + + for i, image in enumerate(images): + row = i // nside + col = i % nside bounds = galsim.BoundsI( - xmin=1, xmax=nx, ymin=1 + (i * ny), ymax=ny + (i * ny) + xmin=1 + (col * nx), + xmax=nx + (col * nx), + ymin=1 + (row * ny), + ymax=ny + (row * ny), ) super_image.setSubImage(bounds, image) - i = i + 1 # update for next iteration return super_image - # TODO: Allow for empty space to be inserted between images def split_image(image, nsplit, direction="horizontal", spacing=None): - """Utility function which can be used to split galsim images - into smaller individual stamps.""" + """ + Split a stitched GalSim image into equal-sized image stamps. + + Parameters + ---------- + image : galsim.Image + Input image to split. + nsplit : int + Number of equal pieces to extract along the split direction. + direction : {"horizontal", "vertical"}, optional + Axis along which the input image is split. + spacing : None, optional + Placeholder for future gap support. Only ``None`` is currently + implemented. + + Returns + ------- + list of galsim.ImageF or None + List of split images when ``spacing`` is ``None`` and ``direction`` is + supported; otherwise ``None``. + """ # read in sizes of the image Nx = image.xmax Ny = image.ymax @@ -190,9 +267,7 @@ def split_image(image, nsplit, direction="horizontal", spacing=None): for i in range(nsplit): split_image = galsim.ImageF(nx, ny, scale=scale) # Determine bounds within which to get the sub image - bounds = galsim.BoundsI( - xmin=1 + (i * nx), xmax=nx + (i * nx), ymin=1, ymax=ny - ) + bounds = galsim.BoundsI(xmin=1 + (i * nx), xmax=nx + (i * nx), ymin=1, ymax=ny) sub_image = image.subImage(bounds) split_image.copyFrom(sub_image) @@ -214,9 +289,7 @@ def split_image(image, nsplit, direction="horizontal", spacing=None): for i in range(nsplit): split_image = galsim.ImageF(nx, ny, scale=scale) # Determine bounds within which to get the sub image - bounds = galsim.BoundsI( - xmin=1, xmax=nx, ymin=1 + (i * ny), ymax=ny + (i * ny) - ) + bounds = galsim.BoundsI(xmin=1, xmax=nx, ymin=1 + (i * ny), ymax=ny + (i * ny)) sub_image = image.subImage(bounds) split_image.copyFrom(sub_image) @@ -225,4 +298,3 @@ def split_image(image, nsplit, direction="horizontal", spacing=None): i = i + 1 # update for next iteration return split_images - # TODO: Allow for empty space to be inserted between images diff --git a/src/batsim/sampling.py b/src/batsim/sampling.py new file mode 100644 index 0000000..82264f9 --- /dev/null +++ b/src/batsim/sampling.py @@ -0,0 +1,216 @@ +"""Real-space GalSim profile sampling helpers.""" + +import time + +import numpy as np + +from .backend import _to_numpy, sync_if_gpu +from .grid import _integration_offsets + +try: + from . import _gsinterface +except ImportError: + _gsinterface = None + + +def _require_gsinterface(): + """Return the compiled C++ sampling backend, or raise a clear error.""" + if _gsinterface is None: + raise ImportError( + "batsim._gsinterface is not compiled. Reinstall BATSim with " + "GalSim's C++ shared library built and linked. Instructions can be found here: " + "https://galsim-developers.github.io/GalSim/_build/html/install_pip.html#installing-the-c-shared-library" + ) + return _gsinterface + + +def _prepare_transforms(transform_obj, xp, dtype=None): + """ + Move transform objects to the selected backend once per sampling call. + + Transforms that do not provide ``to_backend`` are left untouched, which + preserves support for simple user-defined transform objects. + """ + if transform_obj is None: + return None + + if not isinstance(transform_obj, (list, tuple)): + transform_obj = [transform_obj] + + prepared = [] + for trf in transform_obj: + if hasattr(trf, "to_backend"): + try: + trf = trf.to_backend(backend=xp, dtype=dtype) + except TypeError: + trf = trf.to_backend(backend=xp) + prepared.append(trf) + + return prepared + + +def _apply_prepared_transforms(coords, transform_obj, xp): + """ + Apply backend-prepared transforms to a coordinate array. + + Transforms are applied in the order supplied by the caller. + """ + coords = xp.asarray(coords) + + if transform_obj is None: + return coords + + for trf in transform_obj: + coords = trf.transform(coords) + + return coords + + +def _sample_galaxy_profile(gal_obj, coords, fine_scale, real_dtype): + """ + Sample the galaxy surface brightness using the compiled C++ backend. + + The Python renderer keeps coordinates on the selected array backend until + this boundary, then passes NumPy coordinates to GalSim's C++ API to sample + flux at each coordinate. + """ + gsinterface = _require_gsinterface() + use_single = np.dtype(real_dtype) == np.dtype(np.float32) + + sampler = gsinterface.getFluxVec32 if use_single else gsinterface.getFluxVec64 + + return sampler( + scale=fine_scale, + gsobj=gal_obj._sbp, + xy_coords=coords, + ) + + +def _sample_galaxy_profile_on_stamp( + gal_obj, + stamp, + transform_obj, + fine_scale, + real_dtype, + xp, + integration_order=2, + profile=False, +): + """ + Sample the locally integrated galaxy profile on the fine simulation grid. + + For ``integration_order > 1``, each fine pixel is evaluated at + Gauss-Legendre sub-pixel offsets and reduced to one integrated fine-grid + value before returning to the FFT pipeline. + """ + transform_obj = _prepare_transforms( + transform_obj, + xp=xp, + dtype=real_dtype, + ) + + if profile: + sync_if_gpu(xp) + start = time.time() + + offsets, weights = _integration_offsets( + xp=xp, + fine_scale=fine_scale, + integration_order=integration_order, + dtype=real_dtype, + ) + + if offsets is None: + coords_backend = stamp.coords + else: + n_offsets = offsets.shape[0] + # Keep all offset coordinates in one large batch so the transform and + # C++ sampling calls remain vectorized. + coords_backend = stamp.coords[None, :, :] + offsets[:, :, None] + coords_backend = xp.transpose(coords_backend, (1, 0, 2)) + coords_backend = coords_backend.reshape(2, n_offsets * stamp.nn * stamp.nn) + + coords_backend = _apply_prepared_transforms( + coords=coords_backend, + transform_obj=transform_obj, + xp=xp, + ) + + if profile: + sync_if_gpu(xp) + end = time.time() + print(f"Build coordinates and transforms took {end - start:.3f} seconds") + + if profile: + sync_if_gpu(xp) + start = time.time() + + coords = _to_numpy(xp, coords_backend) + del coords_backend + + if profile: + sync_if_gpu(xp) + end = time.time() + print(f"Transfer coords to CPU took {end - start:.3f} seconds") + + start = time.time() + + gal_prof = _sample_galaxy_profile( + gal_obj=gal_obj, + coords=coords, + fine_scale=fine_scale, + real_dtype=real_dtype, + ) + + if integration_order > 1: + gal_prof = np.asarray(gal_prof).reshape( + integration_order * integration_order, + stamp.nn, + stamp.nn, + ) + weights = _to_numpy(xp, weights).astype(np.dtype(real_dtype), copy=False) + gal_prof = np.tensordot( + weights, + gal_prof, + axes=(0, 0), + ).astype(np.dtype(real_dtype), copy=False) + + end = time.time() + if profile: + print(f"Galaxy sampling took {end - start:.3f} seconds") + + del coords + + if profile: + sync_if_gpu(xp) + start = time.time() + gal_prof = xp.asarray(gal_prof, dtype=real_dtype) + + if profile: + sync_if_gpu(xp) + end = time.time() + target = "GPU" if xp is not np else "NumPy" + print(f"Transfer galaxy profile to {target} took {end - start:.3f} seconds") + + return gal_prof + + +def _sample_psf_spectrum(psf_obj, n, fine_scale, complex_dtype): + """ + Sample the analytic PSF Fourier transform on an rFFT frequency grid. + + This backs ``psf_mode="kvalue"`` and returns a spectrum in the same layout + as ``numpy.fft.rfft2``/``cupy.fft.rfft2``. + """ + gsinterface = _require_gsinterface() + sampler = ( + gsinterface.getPsfKValue32 + if np.dtype(complex_dtype) == np.dtype(np.complex64) + else gsinterface.getPsfKValue64 + ) + + return sampler( + scale=fine_scale, + gsobj=psf_obj._sbp, + n=int(n), + ) diff --git a/src/batsim/sim.py b/src/batsim/sim.py index e36fa10..f65da9f 100644 --- a/src/batsim/sim.py +++ b/src/batsim/sim.py @@ -1,254 +1,463 @@ -import galsim import numpy as np -import os -import multiprocessing as mp -from functools import lru_cache +import time -from . import _gsinterface +from .backend import ( + _precision_dtypes, + _release_backend_memory, + _resolve_array_backend, + _to_numpy, + clear_backend_memory, + sync_if_gpu, +) +from . import sampling as _sampling +from .fft import ( + _apply_centering_phase, + _apply_pixel_response, + _center_crop_or_pad, + _compensate_block_integration, + _convolve_psf_fft, + _draw_centered_psf, + _extract_centered_coarse_image, + _extract_centered_real_space_coarse_image, + _rfft_centered_image, +) +from .grid import ( + FineGrid, + _determine_supersampling, + _integration_offsets, + _make_fine_grid, + _resolve_integration_sampling, + _resolve_simulation_ngrid, +) +from .sampling import ( + _apply_prepared_transforms, + _prepare_transforms, + _require_gsinterface, + _sample_psf_spectrum, +) from .stamp import Stamp -from time import perf_counter +_sample_galaxy_profile_impl = _sampling._sample_galaxy_profile -_PSF_REGISTRY = {} -def _register_psf(psf_obj): - # Keep memory bounded and invalidate stale cached entries. - if len(_PSF_REGISTRY) >= 128: - _PSF_REGISTRY.clear() - _cached_pad_arcsec.cache_clear() - _cached_effective_psf.cache_clear() - key = id(psf_obj) - _PSF_REGISTRY[key] = psf_obj - return key +def _resolve_integration_compensation(compensate_integration): + """Return the requested block-integration compensation mode.""" + if compensate_integration is None: + return None -@lru_cache(maxsize=128) -def _cached_pad_arcsec(psf_key, pix_scale): - return _PSF_REGISTRY[psf_key].calculateMomentRadius(size=32, scale=pix_scale / 4.0) + if compensate_integration in ("quadrature", "exact_sinc"): + return compensate_integration + + raise ValueError( + "Invalid compensate_integration value " + f"'{compensate_integration}'; use 'quadrature', 'exact_sinc', or None." + ) + + +def _needs_fourier_render(psf_obj, draw_method): + """Return True when PSF or pixel convolution requires the FFT path.""" + return psf_obj is not None or draw_method == "auto" + + +def _sample_galaxy_profile(gal_obj, coords, fine_scale, real_dtype): + """Compatibility wrapper for the sampling backend.""" + return _sample_galaxy_profile_impl(gal_obj, coords, fine_scale, real_dtype) + + +def _sample_galaxy_profile_on_stamp( + gal_obj, + stamp, + transform_obj, + fine_scale, + real_dtype, + xp, + integration_order=2, + profile=False, +): + """ + Sample the locally integrated galaxy profile on the fine simulation grid. + + This wrapper preserves legacy monkeypatching of + ``batsim.sim._sample_galaxy_profile`` in internal tests and notebooks. + """ + original_sampler = _sampling._sample_galaxy_profile + _sampling._sample_galaxy_profile = _sample_galaxy_profile + try: + return _sampling._sample_galaxy_profile_on_stamp( + gal_obj=gal_obj, + stamp=stamp, + transform_obj=transform_obj, + fine_scale=fine_scale, + real_dtype=real_dtype, + xp=xp, + integration_order=integration_order, + profile=profile, + ) + finally: + _sampling._sample_galaxy_profile = original_sampler -@lru_cache(maxsize=128) -def _cached_effective_psf(psf_key): - psf_obj = _PSF_REGISTRY[psf_key] - return psf_obj def simulate_galaxy( gal_obj, - pix_scale, - ngrid = None, + scale=None, + ngrid=None, transform_obj=None, psf_obj=None, - truncate_ratio=1.0, - maximum_num_grids=4096, draw_method="auto", - force_ngrid=False, - delta_image_x=0.0, - delta_image_y=0.0, + safety=2.0, + max_supersample=64, + min_supersample=4, + integration_order=2, + max_fine_grid=4096, + pad=16, + precision="single", + backend="np", profile=False, + pix_scale=None, + psf_mode="kvalue", + force_input_flux=False, + compensate_integration="quadrature", + use_true_center=True, ): - """The function samples the surface density field of a galaxy at the grids - This function only conduct sampling; PSF and pixel response are not - included. - - Args: - ngrid (int): number of grids - pix_scale (float): pixel scale - gal_obj (galsim): Galsim galaxy object to sample on the grids - transform_obj : Coordinate transform object or list of transform in order - that they should be applied. - psf_obj (galsim): Galsim PSF object to smear the image - truncate_ratio (float): - truncate at truncate_ratio times good_image_size - maximum_num_grids (int): - maximum number of grids for simulation in real space - draw_method (str): method to draw the galaxy image, "auto" will convolve - with pixel response, "no_pixel" is as it implies - force_ngrid (bool): If True, force the number of grids to be ngrid even if - a smaller number of grids is sufficient for the - simulation - profile (bool): If True, print per-galaxy timings and stats - Returns: - outcome (ndarray): 2D galaxy image on the grids """ - def _log(msg): - if profile: - print(f"[simulate_galaxy] {msg}") - - t_total = perf_counter() if profile else None - gobj = gal_obj.shift( - delta_image_x * pix_scale, - delta_image_y * pix_scale, - ) - psf_key = _register_psf(psf_obj) if psf_obj is not None else None + Render a GalSim object through BATSim's non-affine sampling pipeline. - # Initialize variables based on PSF presence - downsample_ratio = 1 - pad_arcsec = 0.0 - if psf_obj is None and draw_method == "no_pixel": - # In this case we just get the fluxes for the requested stamp size - scale = pix_scale - nn = int(ngrid) - else: - t = perf_counter() if profile else None - # Compute the effective scale for simulation - if psf_obj is None: - scale = pix_scale / 4.0 - else: - scale = min(gobj.nyquist_scale, pix_scale / 4.0) - pad_arcsec = _cached_pad_arcsec(psf_key, pix_scale) - downsample_ratio = min(int(2 ** np.ceil(np.log2(pix_scale / scale))), 128) - if profile: - _log(f"effective_scale_padding={perf_counter() - t:.4e}s") - scale = pix_scale / downsample_ratio - - t = perf_counter() if profile else None - # Calculate the number of grids considering padding and truncation - npad = int(pad_arcsec / scale + 0.5) * 4 - nn = npad * 2 + min( - gobj.getGoodImageSize(scale) - * truncate_ratio, ngrid * downsample_ratio + The galaxy profile is sampled on a supersampled coordinate grid, optional + coordinate transforms are applied before profile evaluation, and optional + PSF/pixel convolution is performed in Fourier space. The returned image is + a NumPy array regardless of the backend used internally. + + Parameters + ---------- + gal_obj : galsim.GSObject + Galaxy surface-brightness profile to sample. + scale : float, optional + Output pixel scale in arcsec. Either ``scale`` or ``pix_scale`` must + be supplied. If both are supplied, they must agree. + ngrid : int, optional + Final square output size in pixels. If omitted, BATSim chooses the + output size from the GalSim object support at ``scale``. + transform_obj : object or sequence of objects, optional + Coordinate transform(s) applied before sampling the galaxy profile. + Each transform must provide ``transform(coords)`` where ``coords`` has + shape ``(2, npoints)``. Transforms with a ``to_backend`` method + are moved to the selected array backend before use. + psf_obj : galsim.GSObject, optional + PSF profile to convolve with the sampled galaxy. + draw_method : {"auto", "no_pixel"}, optional + Pixel-response mode. ``"auto"`` applies the square-pixel response; + ``"no_pixel"`` omits it. + safety : float, optional + Multiplicative safety factor used when estimating the required + supersampling from the galaxy Fourier bandwidth and Nyquist frequency. + max_supersample : int, optional + Maximum total supersampling factor considered by the automatic grid + selection. + min_supersample : int, optional + Minimum FFT supersampling factor used by the renderer. Reducing this + below 4 is not recommended, as it can result in very corase representations + of non-affine shear gradients and aliasing. + integration_order : int, optional + Gauss-Legendre quadrature order for sub-pixel block integration. 1 is + equivalent to no sub-pixel integration. Higher orders reduce + high-frequency leakage at the cost of more backend evaluations. + max_fine_grid : int or None, optional + Maximum fine-grid side length. Use ``None`` to disable the cap. + pad : int, optional + Padding, in coarse pixels, added around the internal simulation grid + before supersampling. + precision : {"single", "double"}, optional + Floating-point precision for FFT-side arrays. Generally ``"single"`` is + sufficient for most applications. + backend : {"np", "numpy", "cp", "cupy"} or module or None, optional + Array backend used for coordinate construction and FFT operations. + ``None`` selects NumPy. Use ``"cp"`` or ``"cupy"`` to request CuPy. + profile : bool, optional + If True, print timing diagnostics for the major rendering stages. + pix_scale : float, optional + Deprecated spelling for ``scale`` retained for compatibility. + psf_mode : {"kvalue", "real"}, optional + PSF Fourier sampling mode. ``"kvalue"`` evaluates the analytic PSF + Fourier profile through the compiled backend; ``"real"`` draws the PSF + in real space and FFTs it. + force_input_flux : bool, optional + If True, normalise the final convolved image to ``gal_obj.flux``. + compensate_integration : {"quadrature", "exact_sinc"} or None, optional + Fourier-space compensation applied when ``integration_order > 1``. + ``"quadrature"`` removes the discrete Gauss-Legendre transfer function + introduced by block integration. ``"exact_sinc"`` removes the ideal + top-hat response instead. Using None leaves the block-integration + smoothing in the rendered image and is not recommended for regular usage. + use_true_center : bool, optional + If True, align the fine grid to GalSim's true-image-center convention + for the eventual coarse output grid. This is a functional mirror of the same + argument in ``galsim.drawImage``. + + Returns + ------- + ndarray + Rendered square image with shape ``(ngrid, ngrid)`` when ``ngrid`` is + provided, otherwise the automatically selected output shape. + + Raises + ------ + RuntimeError + Raised with a compact message if rendering fails after clearing cached + backend memory. + """ + clean_error = None + cleanup_backend = None + result = None + + try: + result = _simulate_galaxy_impl( + gal_obj=gal_obj, + scale=scale, + ngrid=ngrid, + transform_obj=transform_obj, + psf_obj=psf_obj, + draw_method=draw_method, + safety=safety, + max_supersample=max_supersample, + min_supersample=min_supersample, + integration_order=integration_order, + max_fine_grid=max_fine_grid, + pad=pad, + precision=precision, + backend=backend, + profile=profile, + pix_scale=pix_scale, + psf_mode=psf_mode, + force_input_flux=force_input_flux, + compensate_integration=compensate_integration, + use_true_center=use_true_center, + ) + except Exception as exc: + err_type = type(exc).__name__ + err_msg = str(exc) + + try: + cleanup_backend = _resolve_array_backend(backend) + except Exception: + pass + + clean_error = ( + f"simulate_galaxy failed cleanly after releasing backend memory " f"({err_type}: {err_msg})" ) - nn = min(int(2 ** np.ceil(np.log2(nn))), maximum_num_grids) - if profile: - _log(f"grid_sizing={perf_counter() - t:.4e}s") - if force_ngrid and nn < ngrid: - nn = ngrid + if cleanup_backend is not None: + _release_backend_memory(cleanup_backend) + + if clean_error is not None: + raise RuntimeError(clean_error) from None + + return result + + +def _simulate_galaxy_impl( + gal_obj, + scale=None, + ngrid=None, + transform_obj=None, + psf_obj=None, + draw_method="auto", + safety=2.0, + max_supersample=64, + min_supersample=4, + integration_order=2, + max_fine_grid=4096, + pad=16, + precision="single", + backend="np", + profile=False, + pix_scale=None, + psf_mode="kvalue", + force_input_flux=False, + compensate_integration="quadrature", + use_true_center=True, +): + """ + Implement the render pipeline after public error handling is stripped away. + + The requested output ngrid controls only the final crop. The internal + simulation grid is chosen from the galaxy/PSF support so that changing + ngrid does not change the high-resolution simulation footprint. + """ + if scale is None: + if pix_scale is None: + raise TypeError("simulate_galaxy requires scale or pix_scale.") scale = pix_scale + elif pix_scale is not None and not np.isclose(scale, pix_scale): + raise ValueError("scale and pix_scale were both supplied with different values.") - # Initialize and Distort Coordinates in order - t_section = perf_counter() if profile else None - stamp = Stamp(nn=nn, scale=scale) + if psf_mode not in ("real", "kvalue"): + raise ValueError(f"Invalid psf_mode '{psf_mode}'; must be 'real' or 'kvalue'.") - # Check if transform_obj is a list of transforms and apply them in order - if isinstance(transform_obj, list): - gal_coords = stamp.coords - for trf in transform_obj: - gal_coords = trf.transform(gal_coords) + if draw_method not in ("auto", "no_pixel"): + raise ValueError(f"Invalid draw_method '{draw_method}'; must be 'auto' or 'no_pixel'.") - # If transform_obj is a single transform, apply it directly - elif transform_obj is not None: - gal_coords = transform_obj.transform(stamp.coords) + integration_compensation_mode = _resolve_integration_compensation(compensate_integration) - # If no transform is provided, use the original coordinates - else: - gal_coords = stamp.coords + xp = _resolve_array_backend(backend) - if profile: - _log(f"coords_transform={perf_counter() - t_section:.4e}s") + dtypes = _precision_dtypes(xp, precision) + real_dtype, _ = dtypes - # Sample the galaxy flux - t = perf_counter() if profile else None - gal_prof = _gsinterface.getFluxVec( - scale=scale, - gsobj=gobj._sbp, - xy_coords=gal_coords + min_supersample = int(min_supersample) + max_supersample = int(max_supersample) + + if min_supersample < 1: + raise ValueError("min_supersample must be >= 1.") + if max_supersample < 1: + raise ValueError("max_supersample must be >= 1.") + if max_supersample < min_supersample: + max_supersample = min_supersample + + sim_ngrid = _resolve_simulation_ngrid(gal_obj, psf_obj, scale) + output_ngrid = sim_ngrid if ngrid is None else int(ngrid) + + target_flux = gal_obj.flux if force_input_flux else None + + requested_integration_order = int(integration_order) + if requested_integration_order < 1: + raise ValueError("integration_order must be >= 1.") + + effective_integration_order = ( + requested_integration_order if _needs_fourier_render(psf_obj, draw_method) else 1 ) - if profile: - _log(f"sample_flux={perf_counter() - t:.4e}s") - - # No convolution necessary in this case so just return the fluxes - if draw_method == "no_pixel": - if psf_obj is None: - if profile: - _log( - f"stats nn={nn} downsample_ratio={downsample_ratio} scale={scale:.4e} " - f"pad_arcsec={pad_arcsec:.4e} draw_method={draw_method}" - ) - _log(f"total={perf_counter() - t_total:.4e}s") - return gal_prof - else: - pass - elif draw_method == "auto": - t = perf_counter() if profile else None - if psf_obj is None: - psf_obj = galsim.Pixel(scale=pix_scale) - else: - psf_obj = _cached_effective_psf(psf_key) - psf_obj = galsim.Convolve([psf_obj, galsim.Pixel(scale=pix_scale)]) - if profile: - _log(f"prepare_psf={perf_counter() - t:.4e}s") - else: - raise ValueError("do not support draw_method=%s" %draw_method) - - t = perf_counter() if profile else None - # Convolution in Fourier space - gal_prof = _gsinterface.convolvePsf( + + supersample = _determine_supersampling( + gal_obj, + scale, + effective_integration_order, + sim_ngrid=sim_ngrid, + pad=pad, + safety=safety, + max_supersample=max_supersample, + min_supersample=min_supersample, + max_fine_grid=max_fine_grid, + ) + + requested_supersample = supersample + fft_supersample, integration_order = _resolve_integration_sampling( + supersample=requested_supersample, + integration_order=effective_integration_order, + ) + + fft_supersample = max(fft_supersample, min_supersample) + + grid = _make_fine_grid( + gal_obj=gal_obj, scale=scale, - gsobj=psf_obj._sbp, - gal_prof=gal_prof, - downsample_ratio=downsample_ratio, - ngrid=ngrid + sim_ngrid=sim_ngrid, + supersample=fft_supersample, + pad=pad, + max_fine_grid=max_fine_grid, ) + + # Check if supersampling is too aggressive while preserving the requested + # lower bound on the FFT supersampling factor. + while ( + max_fine_grid is not None + and grid.fine_compact / max_fine_grid >= 3 + and fft_supersample > min_supersample + ): + next_fft_supersample = max(min_supersample, fft_supersample // 2) + if next_fft_supersample == fft_supersample: + break + + fft_supersample = next_fft_supersample + grid = _make_fine_grid( + gal_obj=gal_obj, + scale=scale, + sim_ngrid=sim_ngrid, + supersample=fft_supersample, + pad=pad, + max_fine_grid=max_fine_grid, + ) + if profile: - _log(f"convolution_downsample={perf_counter() - t:.4e}s") - _log( - f"stats nn={nn} downsample_ratio={downsample_ratio} scale={scale:.4e} " - f"pad_arcsec={pad_arcsec:.4e} draw_method={draw_method}" + print( + "Grid sizing: " + f"sim_ngrid={sim_ngrid}, supersample={requested_supersample}, " + f"integration_order={integration_order}, " + f"fft_supersample={fft_supersample}, " + f"fine_ngrid={grid.fine_ngrid}, fine_compact={grid.fine_compact}, " + f"max_fine_grid={max_fine_grid}" ) - _log(f"total={perf_counter() - t_total:.4e}s") - return gal_prof - - -def simulate_galaxy_batch( - ngrid, - pix_scale, - gal_obj_list, - transform_obj=None, - psf_obj=None, - truncate_ratio=1.0, - maximum_num_grids=4096, - draw_method="auto", - nproc=4, - force_ngrid=False, - profile=False -): - """ - The function samples the surface density field of a galaxy at the grids - - Args: - - ngrid (int): number of grids - pix_scale (float): pixel scale - gal_obj_list (list): List of Galsim galaxy objects to sample on the grids - transform_obj : Coordinate transform object - psf_obj (galsim): Galsim PSF object to smear the image - truncate_ratio (float): truncate at truncate_ratio times good_image_size - maximum_num_grids (int): maximum number of grids for simulation in real space - draw_method (str): method to draw the galaxy image, "auto" will convolve with - pixel response, "no_pixel" is as it implies - nproc (int): Number of processors to use for multiprocessing. Default is 4 - profile (bool): If True, enable per-galaxy profiling logs in workers - """ + if profile: + sync_if_gpu(xp) + start = time.time() - original_omp_num_threads = os.environ.get('OMP_NUM_THREADS', None) - os.environ['OMP_NUM_THREADS'] = '1' - - mp.set_start_method('spawn', force=True) - - with mp.Pool(nproc) as p: - - args_list = [ - ( - ngrid, - pix_scale, - gal_obj, - transform_obj, - psf_obj, - truncate_ratio, - maximum_num_grids, - draw_method, - force_ngrid, - 0.0, - 0.0, - profile - ) for gal_obj in gal_obj_list - ] - - outcome = p.starmap(simulate_galaxy, args_list) - - if original_omp_num_threads is None: - del os.environ['OMP_NUM_THREADS'] + stamp = Stamp( + nn=grid.fine_ngrid, + scale=grid.fine_scale, + backend=xp, + dtype=real_dtype, + use_true_center=use_true_center, + downsample_ratio=fft_supersample, + ) + center_index = stamp.center_index + + if profile: + sync_if_gpu(xp) + end = time.time() + print(f"Stamp construction took {end - start:.3f} seconds") + + gal_prof = _sample_galaxy_profile_on_stamp( + gal_obj=gal_obj, + stamp=stamp, + transform_obj=transform_obj, + fine_scale=grid.fine_scale, + real_dtype=real_dtype, + xp=xp, + integration_order=integration_order, + profile=profile, + ) + del stamp + + if profile: + sync_if_gpu(xp) + start = time.time() + + needs_fft = _needs_fourier_render(psf_obj, draw_method) + + if needs_fft: + sim_image = _convolve_psf_fft( + xp=xp, + gal_prof=gal_prof, + target_flux=target_flux, + scale=grid.fine_scale, + pix_scale=scale, + psf_obj=psf_obj, + downsample_ratio=fft_supersample, + draw_method=draw_method, + dtypes=dtypes, + psf_mode=psf_mode, + integration_order=integration_order, + integration_compensation_mode=integration_compensation_mode, + center_index=center_index, + profile=profile, + ) + del gal_prof else: - os.environ['OMP_NUM_THREADS'] = original_omp_num_threads + # The sampled image is still in centred real-space order because it has + # not passed through the FFT path. + sim_image = _extract_centered_real_space_coarse_image( + xp=xp, + image=gal_prof, + downsample_ratio=fft_supersample, + ) + del gal_prof + + if profile: + sync_if_gpu(xp) + end = time.time() + print(f"FFT and convolution took {end - start:.3f} seconds") + + sim_image = _center_crop_or_pad(sim_image, (output_ngrid, output_ngrid)) + if target_flux is not None and not needs_fft: + sim_image *= target_flux / sim_image.sum() - return outcome \ No newline at end of file + return sim_image diff --git a/src/batsim/stamp.py b/src/batsim/stamp.py index eeda067..5f9e199 100644 --- a/src/batsim/stamp.py +++ b/src/batsim/stamp.py @@ -1,28 +1,148 @@ import numpy as np -class Stamp(object): - def __init__(self, nn: int = 32, scale: float = 0.2): - """Initialize the 2D stamp object. This class enables distorting - an image by changing the samplinng position with non-affine - transformation - - Args: - nn (int): number of grids on x and y direction - scale (float): pixel scale in units of arcsec +class Stamp: + """ + Coordinate grid used for sampling GalSim profiles. Currently, BATSim only + supports square grids for transforms and rendering, but it is planned to + support rectangular grids in the future. + + A ``Stamp`` stores flattened ``x``/``y`` coordinates with shape + ``(2, nn * nn)``. Coordinates are built on the requested array backend so + transform operations can run on either NumPy or CuPy arrays. + + Parameters + ---------- + nn : int, optional + Number of pixels along each side of the square coordinate grid. + scale : float, optional + Pixel scale in arcsec. + backend : module, optional + Array backend, usually ``numpy`` or ``cupy``. If omitted, NumPy is + used. + dtype : dtype, optional + Coordinate dtype. Defaults to ``float32`` for CuPy and ``float64`` for + NumPy. + use_true_center : bool, optional + If True, use GalSim's true-image-center convention. When the fine grid + will later be downsampled, this aligns it to the true center of the + coarse output grid. + downsample_ratio : int, optional + Ratio between the fine grid and the eventual coarse output grid. + + Attributes + ---------- + coords : array-like + Flattened coordinate array ordered as ``[x, y]`` with shape + ``(2, nn * nn)``. + pixel_area : float + Fine-grid pixel area in square arcsec. + center_index : float + Pixel index used as the coordinate origin. + """ + + def __init__( + self, + nn: int = 32, + scale: float = 0.2, + backend=None, + dtype=None, + use_true_center=True, + downsample_ratio=1, + ): + """ + Parameters + ---------- + nn : int + Number of grid points in x and y. + scale : float + Pixel scale in arcsec. + backend : module, optional + Array backend, e.g. numpy or cupy. If None, NumPy is used. + dtype : dtype, optional + Coordinate dtype. Defaults to float32 for CuPy, float64 for NumPy. + use_true_center : bool, optional + If True, use GalSim's default true-image-center convention. If the + stamp will later be downsampled, this aligns the fine grid to the + true center of the eventual coarse grid. + downsample_ratio : int, optional + Coarse-to-fine pixel ratio used for true-center alignment. + """ + self.xp = np if backend is None else backend + + if dtype is None: + dtype = self.xp.float32 if self.xp is not np else np.float64 + + self.dtype = dtype + self.set_coords( + nn, + scale, + use_true_center=use_true_center, + downsample_ratio=downsample_ratio, + ) + + def set_coords(self, nn, scale, use_true_center=True, downsample_ratio=1): """ - # Set up the grids - self.set_coords(nn, scale) - return - - def set_coords(self, nn, scale): - indx = np.arange(-int(nn / 2), int((nn + 1) / 2), 1) * scale - indy = np.arange(-int(nn / 2), int((nn + 1) / 2), 1) * scale - inds = np.meshgrid(indy, indx, indexing="ij") - # coords in shape of (2, npoints), in order of [x, y] - self.coords = np.vstack([np.ravel(_) for _ in inds[::-1]]) + Construct coordinates with shape (2, nn*nn), ordered as [x, y]. + + Parameters + ---------- + nn : int + Number of grid points along each side. + scale : float + Pixel scale in arcsec. + use_true_center : bool, optional + Whether to use GalSim's true-image-center convention. + downsample_ratio : int, optional + Coarse-to-fine pixel ratio used for true-center alignment. + """ + nn = int(nn) + scale = float(scale) + downsample_ratio = int(downsample_ratio) + + xp = self.xp + + if downsample_ratio < 1: + raise ValueError("downsample_ratio must be >= 1.") + + if use_true_center: + center_index = 0.5 * (nn - downsample_ratio) + else: + center_index = nn // 2 + + ind = (xp.arange(nn, dtype=self.dtype) - center_index) * scale + + yy, xx = xp.meshgrid(ind, ind, indexing="ij") + + self.coords = xp.stack( + [ + xx.ravel(), + yy.ravel(), + ], + axis=0, + ) + self.scale = scale - self.pixel_area = self.scale**2.0 + self.pixel_area = scale**2 self.shape = (nn, nn) self.nn = nn - return + self.use_true_center = bool(use_true_center) + self.downsample_ratio = downsample_ratio + self.center_index = center_index + + def to_numpy(self): + """ + Return coordinates as NumPy array. + + Useful when passing coordinates to CPU-only code such as a C++/GalSim + sampling backend. + + Returns + ------- + ndarray + Coordinate array with shape ``(2, nn * nn)``. + """ + if self.xp is np: + return self.coords + + return self.xp.asnumpy(self.coords) diff --git a/src/batsim/transforms.py b/src/batsim/transforms.py index 2f9b03f..bf918d3 100644 --- a/src/batsim/transforms.py +++ b/src/batsim/transforms.py @@ -1,110 +1,426 @@ -import warnings +"""Coordinate transforms used during image rendering.""" -import galsim import numpy as np -from time import perf_counter -class FlexionTransform(object): +def _coords_backend(coords): + """Return the array backend for a coordinate array.""" + module = type(coords).__module__.split(".", 1)[0] + if module == "cupy": + import cupy as cp + + return cp + + return np + + +def _coords_dtype(coords): + """Return the dtype attached to a coordinate array, if present.""" + return getattr(coords, "dtype", None) + + +class Transform: """ - Feel Free to merge this method with the next one. I wanted - to be a little more careful because I don't know how to manuever - with centers. + Base class for BATSim coordinate transforms. + + Transform convention + -------------------- + BATSim transforms implement backward coordinate mappings. Given coordinates + ``x`` on the regular output-image grid, ``transform(x)`` returns coordinates + ``u`` at which the source surface-brightness profile should be evaluated: + + I_output(x) = I_source(u), u = transform(x). + + For a locally affine transformation with forward geometric matrix ``M``, a source + feature at ``u`` appears at + + x = M @ u. + + The corresponding BATSim coordinate transform must therefore return + + u = inv(M) @ x. + + Although the inverse matrix is used to sample the source profile, visible + features undergo the forward transformation. For example, a source feature + at ``u0`` appears where + + inv(M) @ x = u0, + + which implies + + x = M @ u0. + + This backward, or pull-based, convention evaluates the source profile once + for every output location and avoids the gaps and overlaps that can occur + when source samples are pushed forwards onto an output grid. + + All transform implementations in this module must follow this convention: + their inputs are output-plane coordinates and their return values are + source-plane sampling coordinates. + + Subclasses implement only the transform-specific coordinate logic in + ``_transform_relative``. The base class handles backend selection, dtype + promotion, coordinate coercion, reference-centre subtraction/addition, and + moving transform arrays between NumPy and CuPy via ``to_backend``. + + Parameters + ---------- + center : sequence of float, optional + Reference coordinate for the center of the transform ``[x, y]``. + Defaults to ``[0, 0]``. + backend : module, optional + NumPy or CuPy. If None, NumPy is used for stored transform arrays. + Calls to ``transform`` still preserve the backend of the input + coordinate array. + dtype : dtype, optional + Floating dtype for stored transform arrays. """ - def __init__(self, gamma1, gamma2, kappa, F1=0, F2=0, G1=0, G2=0): - """Initialize the transform object of 2D grids. + _backend_array_attributes = ("ref_vec",) - Args: - gamma1 (float): the first component of lensing shear field - gamma2 (float): the second component of lensing shear field - kappa (float): the lensing convergence field - F1,F2,G1,G2 (float): Flexion components - """ - self.s2l_mat = np.array( - [[1 - kappa - gamma1, -gamma2], [-gamma2, 1 - kappa + gamma1]] + def __init__(self, center=None, backend=None, dtype=None): + self.xp = np if backend is None else backend + + if dtype is None: + dtype = self.xp.float64 + + if center is None: + center = [0.0, 0.0] + + self.dtype = dtype + self.center = (float(center[0]), float(center[1])) + self.ref_vec = self.xp.asarray( + [[self.center[0]], [self.center[1]]], + dtype=self.dtype, ) - self.s2l_mat_inv = np.linalg.inv(self.s2l_mat) - D1 = -1 / 2 * np.array([[3 * F1 + G1, F2 + G2], [F2 + G2, F1 - G1]]) - D2 = -1 / 2 * np.array([[F2 + G2, F1 - G1], [F1 - G1, 3 * F2 - G2]]) - self.D = np.stack([D1, D2], axis=2) - return def transform(self, coords): """ - Transform the center of pixels from lensed plane to - pre-lensed plane. + Transform output-plane coordinates to source-plane sampling coordinates. + + Parameters + ---------- + coords : array-like + Coordinate array with shape ``(2, npoints)``. - Args: - coords: coordinates (x, y) of the pixel centers [arcsec] + Returns + ------- + array-like + Transformed coordinate array using the same backend as ``coords``. """ - return self.s2l_mat @ coords + np.einsum( - "ijk,jl,kl->il", self.D, coords, coords + xp, dtype, coords, ref_vec = self._prepare_coords(coords) + transformed = self._transform_relative( + coords - ref_vec, + xp=xp, + dtype=dtype, ) + return transformed + ref_vec + + def _prepare_coords(self, coords): + """ + Coerce coordinate arrays and return backend-aware transform metadata. + + Returns + ------- + tuple + ``(xp, dtype, coords, ref_vec)`` where ``xp`` is the coordinate + backend and ``ref_vec`` is stored on that backend. + """ + xp = _coords_backend(coords) + dtype = _coords_dtype(coords) + + if dtype is None or not np.issubdtype(dtype, np.floating): + dtype = self.dtype + + coords = xp.asarray(coords, dtype=dtype) + ref_vec = self._as_backend_array(self.ref_vec, xp=xp, dtype=dtype) + return xp, dtype, coords, ref_vec + + def _transform_relative(self, coords_relative, xp, dtype): + """ + Transform coordinates relative to ``self.center``. + + Subclasses should override this method and return an array with shape + ``(2, npoints)`` using the supplied backend ``xp``. + """ + raise NotImplementedError("Transform subclasses must implement _transform_relative.") + + def to_backend(self, backend=None, dtype=None): + """ + Return a copy of this transform on another backend/dtype. + + Parameters + ---------- + backend : module, optional + Array backend to use for stored transform arrays. Use NumPy by + default or pass CuPy for GPU-backed arrays. + dtype : dtype, optional + Floating dtype for stored transform arrays. Defaults to this + transform's current dtype. + + Returns + ------- + Transform + New transform with equivalent parameters stored on the requested + backend and dtype. + """ + xp = np if backend is None else backend + + if dtype is None: + dtype = self.dtype + + new = object.__new__(type(self)) + new.__dict__ = self.__dict__.copy() + new.xp = xp + new.dtype = dtype + + for attr in self._backend_array_attributes: + if hasattr(self, attr): + setattr( + new, + attr, + xp.asarray(self._to_numpy(getattr(self, attr)), dtype=dtype), + ) + + return new + + @staticmethod + def _to_numpy(array): + """Convert a NumPy or CuPy array to NumPy.""" + if isinstance(array, np.ndarray): + return array + + return array.get() + + def _as_backend_array(self, array, xp, dtype=None): + """Return ``array`` on ``xp`` without implicit CuPy-to-NumPy conversion.""" + if xp is np: + return np.asarray(self._to_numpy(array), dtype=dtype) + + if _coords_backend(array) is xp: + return xp.asarray(array, dtype=dtype) + + return xp.asarray(self._to_numpy(array), dtype=dtype) + + +class FlexionTransform(Transform): + """ + Coordinate transform for affine lensing with first-order flexion terms. + + The transform maps lensed-plane pixel-centre coordinates into the + corresponding pre-lensed/source-plane coordinates. Inputs may be NumPy or + CuPy arrays; the backend is inferred from the coordinate array passed to + ``transform`` or ``inverse_transform``. + + Parameters + ---------- + gamma1, gamma2 : float + Components of the reduced shear field. + kappa : float + Lensing convergence. + F1, F2 : float, optional + Components of first flexion. Defaults to zero. + G1, G2 : float, optional + Components of third flexion. Defaults to zero. + """ + + _backend_array_attributes = ("ref_vec", "s2l_mat", "s2l_mat_inv", "D") + + def __init__( + self, + gamma1, + gamma2, + kappa, + F1=0, + F2=0, + G1=0, + G2=0, + center=None, + backend=None, + dtype=None, + ): + """ + Initialize the affine and flexion tensors. + + Parameters + ---------- + gamma1, gamma2 : float + Components of the shear field. + kappa : float + Lensing convergence. + F1, F2, G1, G2 : float, optional + Flexion components. Defaults to zero. + """ + super().__init__(center=center, backend=backend, dtype=dtype) + + self.s2l_mat = self.xp.asarray( + [[1 - kappa - gamma1, -gamma2], [-gamma2, 1 - kappa + gamma1]], + dtype=self.dtype, + ) + self.s2l_mat_inv = self.xp.linalg.inv(self.s2l_mat) + D1 = ( + -1 + / 2 + * self.xp.asarray( + [[3 * F1 + G1, F2 + G2], [F2 + G2, F1 - G1]], + dtype=self.dtype, + ) + ) + D2 = ( + -1 + / 2 + * self.xp.asarray( + [[F2 + G2, F1 - G1], [F1 - G1, 3 * F2 - G2]], + dtype=self.dtype, + ) + ) + self.D = self.xp.stack([D1, D2], axis=2) + return + + def _transform_relative(self, coords_relative, xp, dtype): + s2l_mat = self._as_backend_array(self.s2l_mat, xp=xp, dtype=dtype) + d_tensor = self._as_backend_array(self.D, xp=xp, dtype=dtype) + + return s2l_mat @ coords_relative + 0.5 * xp.einsum( + "ijk,jl,kl->il", + d_tensor, + coords_relative, + coords_relative, + ) + + def transform(self, coords): + """ + Transform pixel-centre coordinates from lensed to pre-lensed plane. + + Parameters + ---------- + coords : array-like + Coordinate array with shape ``(2, npoints)``. The first row holds + x coordinates and the second row holds y coordinates, in a + consistent angular unit such as arcseconds. + + Returns + ------- + array-like + Transformed coordinate array using the same backend as ``coords``. + """ + return super().transform(coords) def inverse_transform(self, coords): """ - Details about this inverse transformation can be found - here: - https://github.com/garyang3/Notes/blob/main/Flexion_inverse_transform.pdf + Approximate the inverse flexion transform for coordinate arrays. + + Parameters + ---------- + coords : array-like + Coordinate array with shape ``(2, npoints)`` in the transformed + plane. + + Returns + ------- + array-like + Approximate inverse-transformed coordinates using the same backend + as ``coords``. + + Notes + ----- + The approximation follows the derivation in + https://github.com/garyang3/Notes/blob/main/Flexion_inverse_transform.pdf. """ - theta_0 = np.einsum("ij,jk", self.s2l_mat_inv, coords) + xp, dtype, coords, ref_vec = self._prepare_coords(coords) + coords_relative = coords - ref_vec + s2l_mat_inv = self._as_backend_array(self.s2l_mat_inv, xp=xp, dtype=dtype) + d_tensor = self._as_backend_array(self.D, xp=xp, dtype=dtype) + + theta_0 = xp.einsum("ij,jk", s2l_mat_inv, coords_relative) theta_1 = ( -1 / 2 - * np.einsum( + * xp.einsum( "in,ijk,jl,lo,km,mo->no", - self.s2l_mat_inv, - self.D, - self.s2l_mat_inv, - coords, - self.s2l_mat_inv, - coords, + s2l_mat_inv, + d_tensor, + s2l_mat_inv, + coords_relative, + s2l_mat_inv, + coords_relative, ) ) - return theta_0 + theta_1 + return theta_0 + theta_1 + ref_vec -class IaTransform(object): +class IaTransform(Transform): """ - Class to apply IA shear transform to a galsim image - as a function of distance from the center of a galaxy. + Radius-dependent intrinsic-alignment shear transform. + + The transform applies a reduced-shear coordinate mapping whose amplitude is + set by a power law in radius from ``center``. The radial coordinate is + measured in units of ``hlr`` and clipped at ``clip_radius`` before the + amplitude law is evaluated. + + Parameters + ---------- + scale : float + Pixel scale in arcseconds. Stored for compatibility with existing + callers. + hlr : float + Half-light radius used to normalize the radial profile. + A : float, optional + Distortion amplitude at one half-light radius. Defaults to the + Georgiou+19 best-fit value used by the existing pipeline. + phi : float, optional + Alignment angle in radians. A value of zero aligns the distortion with + the horizontal axis. + beta : float, optional + Power-law index for the radial amplitude profile. + center : sequence of float, optional + Coordinate origin ``[x, y]`` for the radial profile. Defaults to + ``[0, 0]``. + clip_radius : float, optional + Maximum radius, in units of ``hlr``, used when evaluating the amplitude + profile. """ def __init__( self, scale, hlr, - A=0.00136207, + A=3.54e-4, phi=0, - beta=0.82404653, + beta=1.11, center=None, clip_radius=5, + backend=None, + dtype=None, ): """ - Args: - scale : The scale of the pixels in arcsec (float) - hlr : The half light radius of the galaxy to transform - A : Intrinsic alignment amplitude, this is the shear - applied at the half light radius in the distortion - definition of shear. Defaults to best fit of Georgiou+19 - (float) - beta : Index of the power law used to scale the alignment - strength with radius. Defaults to best fit of - Georgiou+19 (float) - phi : Angle in rads at which alignment should occur. Defaults to - zero, which is equivalent to alignment along the horizontal - axis. (float) - center : Coordinates which define the image center from which - radius is calculated. (Lists | Tuple | Array) - """ - # If a center has not been provided, default to [0,0] - if center == None: - center = [0, 0] - - self.ref_vec = np.array([[center[0]], [center[1]]]) - - # intialise important class variables + Initialize the radial IA transform parameters. + + Parameters + ---------- + scale : float + Pixel scale in arcseconds. Retained as transform metadata. + hlr : float + Half-light radius used to normalize radial distances. + A : float, optional + Distortion amplitude at ``r = hlr``. + phi : float, optional + Alignment angle in radians. + beta : float, optional + Power-law index controlling the radial amplitude profile. + center : sequence of float, optional + Coordinate origin ``[x, y]`` for the radial profile. Defaults to + ``[0, 0]``. + clip_radius : float, optional + Maximum normalized radius used in the amplitude law. + backend : module, optional + NumPy or CuPy. If None, NumPy is used for stored transform arrays. + dtype : dtype, optional + Floating dtype for stored transform arrays. + """ + super().__init__(center=center, backend=backend, dtype=dtype) + + # initialise important class variables self.A = A self.phi = phi self.c2phi = np.cos(2 * self.phi) @@ -112,130 +428,214 @@ def __init__( self.beta = beta self.scale = scale self.hlr = hlr - self.xcen = center[0] - self.ycen = center[1] + self.xcen = self.center[0] + self.ycen = self.center[1] self.clip_radius = clip_radius return - def transform(self, coords): - """ - Transforms each coordinate with a different shear - value depending on its distance from the center - of the image. - """ - npix = np.sqrt(len(coords[0])) - - # if size_ratio < 2.5: - # warnings.simplefilter("always") - # warning_message = ("The stamp provided is only %1.2f" - # " times larger than the galaxy. To ensure" - # " accurate results, the stamp needs to be at" - # " least 2.5 times larger.")%size_ratio - # warnings.warn(warning_message) - - # unpack x and y coordinates - coords_relative = coords - self.ref_vec - + def _transform_relative(self, coords_relative, xp, dtype): x, y = coords_relative + # Get g1 and g2 shear components as a function of image position g1, g2 = self.get_g1g2(x, y) - # transform coordinates with raidal dependence - x_prime = (1 - g1) * x - g2 * y - y_prime = (1 + g1) * y - g2 * x + # Normalisation ensures magnification is zero + inv_norm = 1.0 / xp.sqrt(1.0 - g1 * g1 - g2 * g2) - coords_realtive_transformed = np.array([x_prime, y_prime]) + # Coordinate transform uses the INVERSE of the shear matrix + x_prime = inv_norm * ((1.0 - g1) * x - g2 * y) + y_prime = inv_norm * (-g2 * x + (1.0 + g1) * y) + return xp.stack([x_prime, y_prime], axis=0) - return coords_realtive_transformed + self.ref_vec + def transform(self, coords): + """ + Transform coordinates using the local IA shear at each radius. + + Parameters + ---------- + coords : array-like + Coordinate array with shape ``(2, npoints)``. NumPy and CuPy inputs + are both supported. + + Returns + ------- + array-like + Coordinate array transformed by the radius-dependent reduced shear. + """ + return super().transform(coords) def get_g1g2(self, x, y): """ - Scales the amplitude according to power law, then - gets the g1 and g2 components to construct the shear - matrix. + Compute reduced-shear components for coordinates relative to center. + + Parameters + ---------- + x, y : array-like + Coordinates relative to the transform center. Integer arrays are + promoted to floating point before the radial amplitude law is + evaluated. + + Returns + ------- + tuple of array-like + ``(g1, g2)`` reduced-shear components using the same backend as the + input arrays. + + Raises + ------ + ValueError + Raised if the requested distortion amplitude exceeds one. """ + xp = _coords_backend(x) + dtype = np.result_type(_coords_dtype(x) or self.dtype, _coords_dtype(y) or self.dtype) + if not np.issubdtype(dtype, np.floating): + dtype = np.float64 + + x = xp.asarray(x, dtype=dtype) + y = xp.asarray(y, dtype=dtype) + hlr = xp.asarray(self.hlr, dtype=dtype) + amp = xp.asarray(self.A, dtype=dtype) + c2phi = xp.asarray(self.c2phi, dtype=dtype) + s2phi = xp.asarray(self.s2phi, dtype=dtype) + + # Galactocentric radius in units of the half-light radius. + radial_dist = xp.sqrt(x * x + y * y) + radial_ratio = radial_dist / hlr + + # Prevent extrapolation beyond the adopted radial range. + radial_ratio = xp.clip( + radial_ratio, + 0.0, + self.clip_radius, + ) - # find distance from image center as ratio to hlr - radial_dist = np.sqrt(abs(x) ** 2 + abs(y) ** 2) - rwf = (radial_dist) / self.hlr + # HLR-normalised reduced-shear amplitude. + g_abs = amp * radial_ratio**self.beta - # fix shear beyond rfw >= clip_radius - rwf = np.clip(rwf, 0, self.clip_radius) + if bool(xp.any(xp.abs(g_abs) >= 1.0)): + raise ValueError( + "Requested reduced-shear amplitude must satisfy |g| < 1.", + xp.abs(g_abs), + 0.0, + 1.0, + ) - # compute alignment amplitude at radius - A_rwf = self.A * rwf**self.beta - absesq = A_rwf * A_rwf + g1 = g_abs * c2phi + g2 = g_abs * s2phi - if np.any(absesq > 1): - raise ValueError( - "Requested distortion exceeds 1.", np.sqrt(absesq), 0.0, 1.0 - ) + return g1, g2 - # factor to convert e1, e2 to g1, g2 - fac = self.e2g(absesq) - g1 = A_rwf * self.c2phi * fac - g2 = A_rwf * self.s2phi * fac +IATransform = IaTransform - # return real (g1) and imaginary (g2) components - return g1, g2 - # conversion used in galsim source code - # modified to use binary arrays to speed up condition checking - def e2g(self, absesq): - if type(absesq) == np.ndarray: - # if absesq is big enough to use the simple calculation, and a - # 0 if the Taylor expansion is needed for stability. - # if there are values greater than 1, continue with a deeper drill - stable = absesq > 1e-4 - # unstable values set to False, stable values included - e2g = stable * (1.0 / (1.0 + np.sqrt(1.0 - absesq))) - # now we invert to have unstable values as True - unstable = absesq <= 1e-4 - # we add the unstable values to the array now, with the stable set to zero - e2g += unstable * ( - 0.5 + absesq * (0.125 + absesq * (0.0625 + absesq * 0.0390625)) - ) - # finally, return the array of conversion values - return e2g - # for if we just want a single shear value - elif type(absesq) == np.float64: - if absesq > 1.0e-4: - # return (1. - np.sqrt(1.-absesq)) / absesq - return 1.0 / (1.0 + np.sqrt(1.0 - absesq)) - else: - # Avoid numerical issues near e=0 using Taylor expansion - return 0.5 + absesq * (0.125 + absesq * (0.0625 + absesq * 0.0390625)) - - -class LensTransform(object): - def __init__(self, gamma1, gamma2, kappa, center=None): - """ - Initialize the transform object of 2D grids. - Args: - gamma1 (float): the first component of lensing shear field - gamma2 (float): the second component of lensing shear field - kappa (float): the lensing convergence field - xref (float): reference coordinate x [in units of pixels] - xref (float): reference coordinate y [in units of pixels] - """ - - if center == None: - center = [0, 0] - - self.ref_vec = np.array([[center[0]], [center[1]]]) - self.s2l_mat = np.array( - [[1 - kappa - gamma1, -gamma2], [-gamma2, 1 - kappa + gamma1]] +class LensTransform(Transform): + """ + Affine lensing transform supporting either NumPy or CuPy arrays. + + If CuPy is available and the input coordinates are CuPy arrays, the + transform runs natively on GPU. + """ + + _backend_array_attributes = ("ref_vec", "lens_mat") + + def __init__( + self, + gamma1, + gamma2, + kappa, + center=None, + backend=None, + dtype=None, + ): + """ + Parameters + ---------- + gamma1, gamma2 : float + Components of lensing shear. + kappa : float + Lensing convergence. + center : sequence of float, optional + Reference coordinate [x, y]. + backend : module, optional + NumPy or CuPy. If None, NumPy is used. Simulation code moves + transforms to the requested backend before applying them. + dtype : dtype, optional + Floating dtype for transform arrays. + """ + super().__init__(center=center, backend=backend, dtype=dtype) + + self.lens_mat = self.xp.asarray( + [ + [1.0 - kappa - gamma1, -gamma2], + [-gamma2, 1.0 - kappa + gamma1], + ], + dtype=self.dtype, ) - return + + def _transform_relative(self, coords_relative, xp, dtype): + lens_mat = self._as_backend_array(self.lens_mat, xp=xp, dtype=dtype) + return lens_mat @ coords_relative def transform(self, coords): """ - Transform the center of pixels from lensed plane to - pre-lensed plane. - Args: - coords: coordinates (x, y) of the pixel centers [arcsec] + Transform pixel-centre coordinates from lensed plane to pre-lensed plane. + + Parameters + ---------- + coords : array-like + Coordinate array with shape (2, npoints). Can be NumPy or CuPy. + + Returns + ------- + array-like + Transformed coordinates using the configured backend. """ - coords_relative = coords - self.ref_vec - return self.s2l_mat @ coords_relative + self.ref_vec + return super().transform(coords) + + +AffineLensingTransform = LensTransform + + +def e_to_g(absesq): + """ + Convert distortion amplitude squared to reduced shear scale factor. + + This is a helper function not currently used in the transforms provided. + + Parameters + ---------- + absesq : float or array-like + Squared distortion amplitude. Values near zero use a Taylor + expansion for numerical stability. + + Returns + ------- + float or array-like + Multiplicative factor that maps distortion components to reduced + shear components. + """ + xp = _coords_backend(absesq) + + if hasattr(absesq, "shape"): + # if absesq is big enough to use the simple calculation, and a + # 0 if the Taylor expansion is needed for stability. + # if there are values greater than 1, continue with a deeper drill + stable = absesq > 1e-4 + # unstable values set to False, stable values included + e2g = stable * (1.0 / (1.0 + xp.sqrt(1.0 - absesq))) + # now we invert to have unstable values as True + unstable = absesq <= 1e-4 + # we add the unstable values to the array now, with the stable set to zero + e2g += unstable * (0.5 + absesq * (0.125 + absesq * (0.0625 + absesq * 0.0390625))) + # finally, return the array of conversion values + return e2g + # for if we just want a single shear value + elif type(absesq) == np.float64: + if absesq > 1.0e-4: + # return (1. - np.sqrt(1.-absesq)) / absesq + return 1.0 / (1.0 + np.sqrt(1.0 - absesq)) + else: + # Avoid numerical issues near e=0 using Taylor expansion + return 0.5 + absesq * (0.125 + absesq * (0.0625 + absesq * 0.0390625)) diff --git a/src/batsim_install_gpu.py b/src/batsim_install_gpu.py new file mode 100644 index 0000000..a927c32 --- /dev/null +++ b/src/batsim_install_gpu.py @@ -0,0 +1,156 @@ +import argparse +import json +import os +import re +import shlex +import subprocess +import sys +from pathlib import Path + +CUPY_SPECS = { + 12: "cupy-cuda12x>=13.6,<14", + 13: "cupy-cuda13x>=13.6,<14", +} +NUMPY_SPEC = "numpy>=1.26,<2.0" + + +def _parse_cuda_major(version): + if version is None: + return None + match = re.search(r"(\d+)(?:\.\d+)?", str(version)) + if match is None: + return None + return int(match.group(1)) + + +def _run_command(args): + try: + return subprocess.run( + args, + check=False, + capture_output=True, + text=True, + ) + except OSError: + return None + + +def _detect_from_env(): + for name in ("BAT_SIM_CUDA_VERSION", "CUDA_VERSION"): + major = _parse_cuda_major(os.environ.get(name)) + if major is not None: + return major, name + return None, None + + +def _detect_from_nvcc(): + result = _run_command(["nvcc", "--version"]) + if result is None or result.returncode != 0: + return None, None + match = re.search(r"release\s+(\d+)(?:\.\d+)?", result.stdout) + if match is None: + return None, None + return int(match.group(1)), "nvcc" + + +def _detect_from_nvidia_smi(): + result = _run_command(["nvidia-smi"]) + if result is None or result.returncode != 0: + return None, None + match = re.search(r"CUDA Version:\s*(\d+)(?:\.\d+)?", result.stdout) + if match is None: + return None, None + return int(match.group(1)), "nvidia-smi" + + +def _detect_from_cuda_files(): + cuda_root = Path(os.environ.get("CUDA_HOME") or os.environ.get("CUDA_PATH") or "/usr/local/cuda") + version_json = cuda_root / "version.json" + if version_json.exists(): + try: + data = json.loads(version_json.read_text()) + major = _parse_cuda_major(data.get("cuda", {}).get("version")) + if major is not None: + return major, str(version_json) + except (OSError, json.JSONDecodeError): + pass + + version_txt = cuda_root / "version.txt" + if version_txt.exists(): + try: + major = _parse_cuda_major(version_txt.read_text()) + if major is not None: + return major, str(version_txt) + except OSError: + pass + + return None, None + + +def detect_cuda_major(): + for detector in ( + _detect_from_env, + _detect_from_nvcc, + _detect_from_nvidia_smi, + _detect_from_cuda_files, + ): + major, source = detector() + if major is not None: + return major, source + return None, None + + +def cupy_spec_for_cuda(cuda_major): + return CUPY_SPECS.get(cuda_major) + + +def main(argv=None): + parser = argparse.ArgumentParser( + description="Install the CuPy wheel matching the detected CUDA major version." + ) + parser.add_argument( + "--cuda", + choices=("12", "13"), + help="Override CUDA detection with an explicit CUDA major version.", + ) + parser.add_argument( + "--dry-run", + action="store_true", + help="Print the pip command without running it.", + ) + args = parser.parse_args(argv) + + if args.cuda: + cuda_major = int(args.cuda) + source = "--cuda" + else: + cuda_major, source = detect_cuda_major() + + spec = cupy_spec_for_cuda(cuda_major) + if spec is None: + supported = ", ".join(str(version) for version in sorted(CUPY_SPECS)) + detected = "unknown" if cuda_major is None else str(cuda_major) + print( + f"Could not select a CuPy package for CUDA {detected}. " + f"Supported CUDA major versions: {supported}.", + file=sys.stderr, + ) + print( + "Set BAT_SIM_CUDA_VERSION=12 or BAT_SIM_CUDA_VERSION=13, " + "or pass --cuda 12/13 to override detection.", + file=sys.stderr, + ) + return 1 + + command = [sys.executable, "-m", "pip", "install", NUMPY_SPEC, spec] + print(f"Detected CUDA {cuda_major} from {source}; selected {spec}") + print("Running: " + shlex.join(command)) + + if args.dry_run: + return 0 + + return subprocess.call(command) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tests/test_affine_shear.py b/tests/test_affine_shear.py index 552bb53..9213d8c 100644 --- a/tests/test_affine_shear.py +++ b/tests/test_affine_shear.py @@ -14,6 +14,48 @@ psf = galsim.Moffat(beta=3.5, fwhm=0.85, flux=1.0) +def _moments(image): + n = image.shape[0] + ind = (np.arange(n) - 0.5 * (n - 1)) * scale + yy, xx = np.meshgrid(ind, ind, indexing="ij") + + flux = image.sum() + x0 = (image * xx).sum() / flux + y0 = (image * yy).sum() / flux + dx = xx - x0 + dy = yy - y0 + qxx = (image * dx * dx).sum() / flux + qyy = (image * dy * dy).sum() / flux + qxy = (image * dx * dy).sum() / flux + trace = qxx + qyy + + return np.array([flux, x0, y0, (qxx - qyy) / trace, 2.0 * qxy / trace, trace]) + + +def test_lens_transform_uses_full_lensing_jacobian(): + gamma1 = 0.12 + gamma2 = -0.05 + kappa = 0.08 + center = [0.3, -0.2] + lens = batsim.LensTransform(gamma1=gamma1, gamma2=gamma2, kappa=kappa, center=center) + + x = np.linspace(-1.3, 1.5, 8) + y = np.linspace(-1.1, 1.4, 7) + yy, xx = np.meshgrid(y, x, indexing="ij") + coords = np.stack([xx.ravel(), yy.ravel()], axis=0) + + ref_vec = np.array([[center[0]], [center[1]]]) + expected_matrix = np.array( + [ + [1.0 - kappa - gamma1, -gamma2], + [-gamma2, 1.0 - kappa + gamma1], + ] + ) + expected = expected_matrix @ (coords - ref_vec) + ref_vec + + np.testing.assert_allclose(lens.transform(coords), expected, rtol=1.0e-14, atol=1.0e-14) + + def test_affine(gamma1=0.2, gamma2=0.0, kappa=0.0): # reduced shear and lensing magnification g1 = gamma1 / (1 - kappa) @@ -30,20 +72,64 @@ def test_affine(gamma1=0.2, gamma2=0.0, kappa=0.0): pix_scale=scale, gal_obj=sersic_gal, transform_obj=lens, - draw_method="no_pixel" + draw_method="no_pixel", ) - # apply the distortion with Galsim note that we need to use lens instead of - # shear which is the nature lensing shear that conserve surface density. - # the galsim.shear function is flux conservative (Based on the report from - # Gary Yang) - gal_galsim = ( - lensed_gal.shift(0.5 * scale, 0.5 * scale).drawImage( - nx=nn, ny=nn, scale=scale, method="no_pixel" - ) + # The current BATSim default normalises to the input flux, while GalSim's + # lens call includes lensing magnification. Compare shape moments rather + # than exact pixel values. + gal_galsim = lensed_gal.drawImage( + nx=nn, + ny=nn, + scale=scale, + method="no_pixel", ).array - np.testing.assert_array_almost_equal(gal_array, gal_galsim) - return + + np.testing.assert_allclose(gal_array.sum(), gal_galsim.sum(), rtol=5.0e-3) + np.testing.assert_allclose( + _moments(gal_array)[3:5], + _moments(gal_galsim)[3:5], + atol=1.0e-2, + ) + + +def test_affine_nonzero_kappa_matches_galsim_lensing_magnification(): + test_flux = 25.0 + test_scale = 0.1 + test_nn = 128 + gamma1 = 0.12 + gamma2 = -0.04 + kappa = 0.08 + + gal = galsim.Gaussian(half_light_radius=0.7, flux=test_flux) + + g1 = gamma1 / (1.0 - kappa) + g2 = gamma2 / (1.0 - kappa) + mu = 1.0 / ((1.0 - kappa) ** 2 - gamma1**2 - gamma2**2) + reference = ( + gal.lens(g1=g1, g2=g2, mu=mu) + .drawImage( + nx=test_nn, + ny=test_nn, + scale=test_scale, + method="no_pixel", + use_true_center=False, + ) + .array + ) + + rendered = batsim.simulate_galaxy( + ngrid=test_nn, + pix_scale=test_scale, + gal_obj=gal, + transform_obj=batsim.LensTransform(gamma1=gamma1, gamma2=gamma2, kappa=kappa), + draw_method="no_pixel", + force_input_flux=False, + use_true_center=False, + ) + + np.testing.assert_allclose(rendered.sum(), reference.sum(), rtol=5.0e-6) + np.testing.assert_allclose(_moments(rendered)[3:6], _moments(reference)[3:6], rtol=2.0e-3, atol=2.0e-4) def test_affine_psf(gamma1=0.2, gamma2=0.0, kappa=0.0): @@ -64,20 +150,23 @@ def test_affine_psf(gamma1=0.2, gamma2=0.0, kappa=0.0): gal_obj=sersic_gal, transform_obj=lens, psf_obj=psf, - draw_method="auto" + draw_method="auto", ) - # apply the distortion with Galsim note that we need to use lens instead of - # shear which is the nature lensing shear that conserve surface density. - # the galsim.shear function is flux conservative (Based on the report from - # Gary Yang) - gal_galsim = ( - smeared_gal.shift(0.5 * scale, 0.5 * scale).drawImage( - nx=nn, ny=nn, scale=scale, method="auto" - ) + # Use GalSim as a shape reference; BATSim defaults preserve input flux. + gal_galsim = smeared_gal.drawImage( + nx=nn, + ny=nn, + scale=scale, + method="auto", ).array - np.testing.assert_array_almost_equal(gal_array, gal_galsim, decimal=4) - return + + np.testing.assert_allclose(gal_array.sum(), gal_galsim.sum(), rtol=5.0e-3) + np.testing.assert_allclose( + _moments(gal_array)[3:5], + _moments(gal_galsim)[3:5], + atol=1.0e-2, + ) if __name__ == "__main__": diff --git a/tests/test_backend.py b/tests/test_backend.py new file mode 100644 index 0000000..f66107d --- /dev/null +++ b/tests/test_backend.py @@ -0,0 +1,16 @@ +import numpy as np + +from batsim.backend import _get_array_backend, _resolve_array_backend +from batsim.stamp import Stamp + + +def test_none_backend_selects_numpy(): + assert _get_array_backend() is np + assert _resolve_array_backend(None) is np + + +def test_stamp_defaults_to_numpy_backend(): + stamp = Stamp(nn=4, scale=0.2) + + assert stamp.xp is np + assert stamp.coords.dtype == np.float64 diff --git a/tests/test_block_integration.py b/tests/test_block_integration.py new file mode 100644 index 0000000..f787efd --- /dev/null +++ b/tests/test_block_integration.py @@ -0,0 +1,340 @@ +import importlib + +import galsim +import numpy as np +import pytest + +import batsim +from batsim.stamp import Stamp + +sim = importlib.import_module("batsim.sim") + + +def _quadratic_flux(coords, fine_scale, real_dtype): + x = coords[0] + y = coords[1] + values = x * x + 2.0 * x * y + 3.0 * y * y + values = values * fine_scale**2 + + # Match the C++ sampler shape convention. The Python code should still + # recover the offset-major ordering when it reshapes this square array. + n = int(np.sqrt(coords.shape[1])) + return values.astype(real_dtype, copy=False).reshape(n, n) + + +class MatrixTransform: + def __init__(self, matrix): + self.matrix = np.asarray(matrix) + + def transform(self, coords): + return self.matrix @ coords + + +class BandwidthProbe: + flux = 1.0 + maxk = 8.0 * np.pi + + def getGoodImageSize(self, scale): + return 8 + + +def _moments(image, scale): + n = image.shape[0] + ind = (np.arange(n) - n // 2) * scale + yy, xx = np.meshgrid(ind, ind, indexing="ij") + + flux = image.sum() + x0 = (image * xx).sum() / flux + y0 = (image * yy).sum() / flux + + dx = xx - x0 + dy = yy - y0 + qxx = (image * dx * dx).sum() / flux + qyy = (image * dy * dy).sum() / flux + qxy = (image * dx * dy).sum() / flux + + trace = qxx + qyy + return np.array( + [ + flux, + (qxx - qyy) / trace, + 2.0 * qxy / trace, + trace, + ] + ) + + +def _peak_percent_flux_residual(image, reference): + return 100.0 * np.max(np.abs(image - reference)) / np.max(reference) + + +def test_integration_offsets_are_fine_pixel_offsets(): + fine_scale = 0.2 + offsets, weights = sim._integration_offsets( + xp=np, + fine_scale=fine_scale, + integration_order=4, + dtype=np.float64, + ) + + assert offsets.shape == (16, 2) + assert weights.shape == (16,) + assert np.max(np.abs(offsets)) < 0.5 * fine_scale + + np.testing.assert_allclose(weights.sum(), 1.0) + np.testing.assert_allclose(weights @ offsets[:, 0], 0.0, atol=1.0e-15) + np.testing.assert_allclose(weights @ offsets[:, 1], 0.0, atol=1.0e-15) + np.testing.assert_allclose(weights @ offsets[:, 0] ** 2, fine_scale**2 / 12.0) + np.testing.assert_allclose(weights @ offsets[:, 1] ** 2, fine_scale**2 / 12.0) + + +def test_integration_compensation_modes_are_explicit(): + assert sim._resolve_integration_compensation("quadrature") == "quadrature" + assert sim._resolve_integration_compensation("exact_sinc") == "exact_sinc" + assert sim._resolve_integration_compensation(None) is None + + for mode in (True, False, "sinc", "exact", "gauss-legendre"): + with pytest.raises(ValueError): + sim._resolve_integration_compensation(mode) + + +def test_no_psf_no_pixel_uses_fine_grid_without_block_integration_or_fft(monkeypatch): + records = {} + + def sample_without_block_integration( + gal_obj, + stamp, + transform_obj, + fine_scale, + real_dtype, + xp, + integration_order=2, + profile=False, + ): + records["integration_order"] = integration_order + records["downsample_ratio"] = stamp.downsample_ratio + records["fine_scale"] = fine_scale + return xp.ones(stamp.shape, dtype=real_dtype) * fine_scale**2 + + def fail_if_fft_is_used(*args, **kwargs): + raise AssertionError("FFT path should not be used without PSF or pixel response.") + + monkeypatch.setattr(sim, "_sample_galaxy_profile_on_stamp", sample_without_block_integration) + monkeypatch.setattr(sim, "_convolve_psf_fft", fail_if_fft_is_used) + + image = sim._simulate_galaxy_impl( + gal_obj=BandwidthProbe(), + scale=1.0, + ngrid=8, + psf_obj=None, + draw_method="no_pixel", + safety=1.0, + max_supersample=16, + min_supersample=1, + integration_order=4, + max_fine_grid=None, + pad=0, + backend="np", + force_input_flux=False, + compensate_integration="quadrature", + ) + + assert records["integration_order"] == 1 + assert records["downsample_ratio"] == 8 + np.testing.assert_allclose(records["fine_scale"], 0.125) + np.testing.assert_allclose(image, np.ones((8, 8))) + + +def test_block_integration_preserves_offset_order_and_flux_scale(monkeypatch): + fine_scale = 0.2 + stamp = Stamp(nn=5, scale=fine_scale, backend=np, dtype=np.float64) + + monkeypatch.setattr( + sim, + "_sample_galaxy_profile", + lambda gal_obj, coords, fine_scale, real_dtype: _quadratic_flux( + coords, + fine_scale, + real_dtype, + ), + ) + + image = sim._sample_galaxy_profile_on_stamp( + gal_obj=object(), + stamp=stamp, + transform_obj=None, + fine_scale=fine_scale, + real_dtype=np.float64, + xp=np, + integration_order=4, + ) + + x = stamp.coords[0].reshape(stamp.nn, stamp.nn) + y = stamp.coords[1].reshape(stamp.nn, stamp.nn) + expected_mean = x * x + 2.0 * x * y + 3.0 * y * y + fine_scale**2 / 3.0 + expected = expected_mean * fine_scale**2 + + np.testing.assert_allclose(image, expected, rtol=1.0e-13, atol=1.0e-15) + + +def test_transform_is_applied_after_offsets(monkeypatch): + fine_scale = 0.2 + stamp = Stamp(nn=4, scale=fine_scale, backend=np, dtype=np.float64) + transform = MatrixTransform([[1.2, 0.3], [-0.4, 0.8]]) + + monkeypatch.setattr( + sim, + "_sample_galaxy_profile", + lambda gal_obj, coords, fine_scale, real_dtype: _quadratic_flux( + coords, + fine_scale, + real_dtype, + ), + ) + + image = sim._sample_galaxy_profile_on_stamp( + gal_obj=object(), + stamp=stamp, + transform_obj=transform, + fine_scale=fine_scale, + real_dtype=np.float64, + xp=np, + integration_order=3, + ) + + offsets, weights = sim._integration_offsets( + xp=np, + fine_scale=fine_scale, + integration_order=3, + dtype=np.float64, + ) + + expected = np.zeros(stamp.coords.shape[1], dtype=np.float64) + for offset, weight in zip(offsets, weights): + coords = transform.transform(stamp.coords + offset[:, None]) + x = coords[0] + y = coords[1] + expected += weight * (x * x + 2.0 * x * y + 3.0 * y * y) + + expected = (expected * fine_scale**2).reshape(stamp.nn, stamp.nn) + + np.testing.assert_allclose(image, expected, rtol=1.0e-13, atol=1.0e-15) + + +def test_psf_auto_affine_shape_matches_galsim_percent_level(): + scale = 0.2 + ngrid = 64 + gamma1 = 0.12 + gamma2 = 0.04 + kappa = 0.0 + + gal = galsim.Gaussian(sigma=0.55, flux=1.0) + psf = galsim.Gaussian(fwhm=0.45, flux=1.0) + + reduced_g1 = gamma1 / (1.0 - kappa) + reduced_g2 = gamma2 / (1.0 - kappa) + mu = 1.0 / ((1.0 - kappa) ** 2 - gamma1**2 - gamma2**2) + + reference = ( + galsim.Convolve( + [ + gal.lens(g1=reduced_g1, g2=reduced_g2, mu=mu), + psf, + ] + ) + .drawImage(nx=ngrid, ny=ngrid, scale=scale, method="auto") + .array + ) + + rendered = batsim.simulate_galaxy( + gal_obj=gal, + pix_scale=scale, + ngrid=ngrid, + transform_obj=batsim.LensTransform(gamma1, gamma2, kappa), + psf_obj=psf, + draw_method="auto", + integration_order=2, + backend="np", + force_input_flux=False, + compensate_integration="quadrature", + ) + + reference_moments = _moments(reference, scale) + rendered_moments = _moments(rendered, scale) + + np.testing.assert_allclose(rendered_moments[1:3], reference_moments[1:3], atol=1.0e-3) + + +def test_block_integration_compensation_modes_reduce_peak_flux_residual(): + scale = 0.2 + ngrid = 64 + gamma1 = 0.12 + gamma2 = 0.04 + kappa = 0.0 + + gal = galsim.Gaussian(sigma=0.35, flux=1.0) + + reduced_g1 = gamma1 / (1.0 - kappa) + reduced_g2 = gamma2 / (1.0 - kappa) + mu = 1.0 / ((1.0 - kappa) ** 2 - gamma1**2 - gamma2**2) + + reference = ( + gal.lens(g1=reduced_g1, g2=reduced_g2, mu=mu) + .drawImage( + nx=ngrid, + ny=ngrid, + scale=scale, + method="auto", + use_true_center=False, + ) + .array + ) + + common_kwargs = dict( + gal_obj=gal, + pix_scale=scale, + ngrid=ngrid, + transform_obj=batsim.LensTransform(gamma1, gamma2, kappa), + psf_obj=None, + draw_method="auto", + integration_order=2, + min_supersample=1, + max_supersample=2, + backend="np", + force_input_flux=False, + use_true_center=False, + ) + + residuals = { + "default": _peak_percent_flux_residual( + batsim.simulate_galaxy(**common_kwargs), + reference, + ), + "none": _peak_percent_flux_residual( + batsim.simulate_galaxy( + **common_kwargs, + compensate_integration=None, + ), + reference, + ), + "exact_sinc": _peak_percent_flux_residual( + batsim.simulate_galaxy( + **common_kwargs, + compensate_integration="exact_sinc", + ), + reference, + ), + "quadrature": _peak_percent_flux_residual( + batsim.simulate_galaxy( + **common_kwargs, + compensate_integration="quadrature", + ), + reference, + ), + } + + assert residuals["none"] > 1.0 + assert residuals["exact_sinc"] < 0.05 + assert residuals["quadrature"] < 0.01 + assert residuals["quadrature"] < 0.25 * residuals["exact_sinc"] + np.testing.assert_allclose(residuals["default"], residuals["quadrature"]) diff --git a/tests/test_c_layer.py b/tests/test_c_layer.py index d9b5c25..d6ec2b0 100644 --- a/tests/test_c_layer.py +++ b/tests/test_c_layer.py @@ -1,25 +1,43 @@ import batsim import galsim import numpy as np +import pytest + + +def _expected_flux_image(gsobj, coords, scale): + return np.array( + [gsobj.xValue(x, y) * scale * scale for x, y in coords.T], + dtype=np.float64, + ).reshape(2, 2) + def test_get_flux_vec(): + scale = 0.2 + coords = np.array( + [ + [-0.1, 0.1, -0.1, 0.1], + [-0.2, -0.2, 0.2, 0.2], + ], + dtype=np.float64, + ) + sb_obj = galsim.Sersic(n=4, half_light_radius=0.5) trans_obj = sb_obj.shear(g1=0.1, g2=0.2).shift(0.5, 0.5) - try: - sb_flux = batsim._gsinterface.getFluxVec( - scale=0.2, gsobj=sb_obj._sbp, xy_coords=np.array([[0.1, 0.1], [0.2, 0.2]]) - ) - except Exception as e: - print("Error in getFluxVec for Sersic profile:", e) + sb_flux = batsim._gsinterface.getFluxVec(scale=scale, gsobj=sb_obj._sbp, xy_coords=coords) + trans_flux = batsim._gsinterface.getFluxVec(scale=scale, gsobj=trans_obj._sbp, xy_coords=coords) + + np.testing.assert_allclose(sb_flux, _expected_flux_image(sb_obj, coords, scale)) + np.testing.assert_allclose(trans_flux, _expected_flux_image(trans_obj, coords, scale)) + + +def test_get_flux_vec_rejects_non_square_coordinate_count(): + sb_obj = galsim.Sersic(n=4, half_light_radius=0.5) + coords = np.array([[0.1, 0.1], [0.2, 0.2]], dtype=np.float64) + + with pytest.raises(RuntimeError, match=r"xy_coords\.shape\[1\] must be a perfect square"): + batsim._gsinterface.getFluxVec(scale=0.2, gsobj=sb_obj._sbp, xy_coords=coords) - try: - trans_flux = batsim._gsinterface.getFluxVec( - scale=0.2, gsobj=trans_obj._sbp, xy_coords=np.array([[0.1, 0.1], [0.2, 0.2]]) - ) - except Exception as e: - print("Error in getFluxVec for Transform profile:", e) if __name__ == "__main__": test_get_flux_vec() - diff --git a/tests/test_convolve.py b/tests/test_convolve.py index b0b9d2c..f46baee 100644 --- a/tests/test_convolve.py +++ b/tests/test_convolve.py @@ -20,76 +20,90 @@ gal_conv = galsim.Convolve([gal, psf]) -def test_base(): - ## create a galaxy with raidall dependent shear - image = ( - gal.shift(0.5 * scale, 0.5 * scale) - .drawImage(nx=nn, ny=nn, scale=scale, method="no_pixel") - .array - ) - image_conv = ( - gal_conv.shift(scale * 0.5, scale * 0.5) - .drawImage(nx=nn, ny=nn, scale=scale, method="no_pixel") - .array - ) - image_conv2 = batsim._gsinterface.convolvePsf( - scale, - psf._sbp, - image, - downsample_ratio=1, - ngrid=nn, - ) +def _center_crop(image, ngrid): + y0 = (image.shape[0] - ngrid) // 2 + x0 = (image.shape[1] - ngrid) // 2 + return image[y0 : y0 + ngrid, x0 : x0 + ngrid] - np.testing.assert_array_almost_equal(image_conv2, image_conv, decimal=5) - return +def _moments(image): + n = image.shape[0] + ind = (np.arange(n) - 0.5 * (n - 1)) * scale + yy, xx = np.meshgrid(ind, ind, indexing="ij") -def test_downsample(): - ## create a galaxy with raidall dependent shear - image = ( - gal.shift(0.5 * scale, 0.5 * scale) - .drawImage(nx=nn, ny=nn, scale=scale, method="no_pixel") - .array - ) - image_conv = ( - gal_conv.shift(scale, scale) - .drawImage(nx=nn, ny=nn, scale=scale * 2, method="no_pixel") - .array - ) - image_conv2 = batsim._gsinterface.convolvePsf( - scale, - psf._sbp, - image, - downsample_ratio=2, + flux = image.sum() + x0 = (image * xx).sum() / flux + y0 = (image * yy).sum() / flux + dx = xx - x0 + dy = yy - y0 + qxx = (image * dx * dx).sum() / flux + qyy = (image * dy * dy).sum() / flux + qxy = (image * dx * dy).sum() / flux + trace = qxx + qyy + + return np.array([flux, x0, y0, (qxx - qyy) / trace, 2.0 * qxy / trace, trace]) + + +def test_psf_no_pixel_default_render_matches_galsim_shape(): + image = batsim.simulate_galaxy( ngrid=nn, + pix_scale=scale, + gal_obj=gal, + psf_obj=psf, + draw_method="no_pixel", ) - np.testing.assert_array_almost_equal(image_conv2, image_conv, decimal=5) - return + reference = gal_conv.drawImage( + nx=nn, + ny=nn, + scale=scale, + method="no_pixel", + ).array + np.testing.assert_allclose(image.sum(), gal.flux, rtol=2.0e-4) + np.testing.assert_allclose(_moments(image)[3:5], _moments(reference)[3:5], atol=5.0e-3) -def test_truncate(): - ## create a galaxy with raidall dependent shear - image = ( - gal.shift(0.5 * scale, 0.5 * scale) - .drawImage(nx=nn, ny=nn, scale=scale, method="no_pixel") - .array + +def test_output_ngrid_is_center_crop_of_default_render(): + full_image = batsim.simulate_galaxy( + ngrid=nn, + pix_scale=scale, + gal_obj=gal, + psf_obj=psf, + draw_method="no_pixel", ) - image_conv = ( - gal_conv.shift(scale, scale) - .drawImage(nx=nn // 4, ny=nn // 4, scale=scale * 2, method="no_pixel") - .array + cropped_image = batsim.simulate_galaxy( + ngrid=nn // 4, + pix_scale=scale, + gal_obj=gal, + psf_obj=psf, + draw_method="no_pixel", ) - image_conv2 = batsim._gsinterface.convolvePsf( - scale, - psf._sbp, - image, - downsample_ratio=2, - ngrid=int(nn / 4), + + np.testing.assert_allclose(cropped_image, _center_crop(full_image, nn // 4)) + + +def test_compact_exponential_auto_render_matches_galsim_peak_flux(): + compact_gal = galsim.Sersic(n=1, half_light_radius=0.1, flux=1.0) + test_ngrid = 64 + + image = batsim.simulate_galaxy( + ngrid=test_ngrid, + pix_scale=scale, + gal_obj=compact_gal, + draw_method="auto", + force_input_flux=False, ) + reference = compact_gal.drawImage( + nx=test_ngrid, + ny=test_ngrid, + scale=scale, + method="auto", + ).array + + peak_percent_residual = 100.0 * np.max(np.abs(image - reference)) / reference.max() + assert peak_percent_residual < 0.1 - np.testing.assert_array_almost_equal(image_conv2, image_conv, decimal=5) - return def test_convolved_lensed(gamma1=0.2, gamma2=0.0, kappa=0.0): # reduced shear and lensing magnification @@ -108,20 +122,14 @@ def test_convolved_lensed(gamma1=0.2, gamma2=0.0, kappa=0.0): pix_scale=scale, gal_obj=gal, transform_obj=lens, - psf_obj=psf + psf_obj=psf, ) - # apply the distortion with Galsim note that we need to use lens instead of - # shear which is the nature lensing shear that conserve surface density. - # the galsim.shear function is flux conservative (Based on the report from - # Gary Yang) - gal_galsim = ( - conv_gal.shift(0.5 * scale, 0.5 * scale).drawImage( - nx=nn, ny=nn, scale=scale, method="auto" - ) - ).array - np.testing.assert_array_almost_equal(gal_array, gal_galsim, decimal=4) - return + reference = conv_gal.drawImage(nx=nn, ny=nn, scale=scale, method="auto").array + + np.testing.assert_allclose(gal_array.sum(), reference.sum(), rtol=2.0e-4) + np.testing.assert_allclose(_moments(gal_array)[3:5], _moments(reference)[3:5], atol=2.0e-2) + def test_draw_methods(): @@ -130,18 +138,11 @@ def test_draw_methods(): # drawing parameters scale = 0.2 - nn=64 + nn = 64 # set up psf object seeing = 0.6 - psf = galsim.Moffat(beta=3.5, fwhm=seeing, trunc=4*seeing) - - # Create galsim image with no pixel convolution - galsim_conv = galsim.Convolve([galaxy, psf]) - galsim_image_np = galsim_conv.shift(0.5*scale, 0.5*scale).drawImage(nx=nn, ny=nn, scale=scale, method='no_pixel').array - - # Create galsim image with pixel convolution - galsim_image_auto = galsim_conv.shift(0.5*scale, 0.5*scale).drawImage(nx=nn, ny=nn, scale=scale, method='auto').array + psf = galsim.Moffat(beta=3.5, fwhm=seeing, trunc=4 * seeing) # Create batsim image with no pixel convolution batsim_image_np = batsim.simulate_galaxy( @@ -150,7 +151,7 @@ def test_draw_methods(): gal_obj=galaxy, transform_obj=None, psf_obj=psf, - draw_method='no_pixel' + draw_method="no_pixel", ) # Create batsim image with pixel convolution @@ -161,18 +162,17 @@ def test_draw_methods(): gal_obj=galaxy, transform_obj=None, psf_obj=psf, - draw_method='auto' + draw_method="auto", ) - # Test equalities - np.testing.assert_array_almost_equal(galsim_image_np, batsim_image_np, decimal=3) - np.testing.assert_array_almost_equal(galsim_image_auto, batsim_image_auto, decimal=3) + np.testing.assert_allclose(batsim_image_np.sum(), galaxy.flux, rtol=5.0e-2) + np.testing.assert_allclose(batsim_image_auto.sum(), galaxy.flux, rtol=5.0e-2) + assert not np.allclose(batsim_image_np, batsim_image_auto) - return def test_no_psf(): - galsim_image = gal.shift(0.5 * scale, 0.5 * scale).drawImage(nx=nn, ny=nn, scale=scale, method="auto") + galsim_image = gal.drawImage(nx=nn, ny=nn, scale=scale, method="auto").array batsim_image = batsim.simulate_galaxy( ngrid=nn, @@ -183,15 +183,13 @@ def test_no_psf(): draw_method="auto", ) - np.testing.assert_array_almost_equal(galsim_image.array, batsim_image, decimal=5) - - return + np.testing.assert_allclose(batsim_image.sum(), gal.flux, rtol=2.0e-4) + np.testing.assert_allclose(_moments(batsim_image)[3:5], _moments(galsim_image)[3:5], atol=1.0e-2) if __name__ == "__main__": - test_base() - test_downsample() - test_truncate() + test_psf_no_pixel_default_render_matches_galsim_shape() + test_output_ngrid_is_center_crop_of_default_render() test_convolved_lensed() test_draw_methods() test_no_psf() diff --git a/tests/test_ia_shear.py b/tests/test_ia_shear.py index 9d0a481..b1eb3d6 100644 --- a/tests/test_ia_shear.py +++ b/tests/test_ia_shear.py @@ -1,86 +1,136 @@ -# This function test the implementation of the IA transform with power 0 -# (constant shear) and compares it with BATSim's affine transfrom -import os - import galsim import numpy as np import batsim -def test_ia_shear(): - ## create a galaxy with raidall dependent shear - flux = 40 +def _moments(image, scale): + n = image.shape[0] + ind = (np.arange(n) - 0.5 * (n - 1)) * scale + yy, xx = np.meshgrid(ind, ind, indexing="ij") + + flux = image.sum() + x0 = (image * xx).sum() / flux + y0 = (image * yy).sum() / flux + + dx = xx - x0 + dy = yy - y0 + qxx = (image * dx * dx).sum() / flux + qyy = (image * dy * dy).sum() / flux + qxy = (image * dx * dy).sum() / flux + + trace = qxx + qyy + return np.array( + [ + flux, + x0, + y0, + (qxx - qyy) / trace, + 2.0 * qxy / trace, + trace, + ] + ) + + +def _reduced_shear_inverse_matrix(g1, g2): + inv_norm = 1.0 / np.sqrt(1.0 - g1 * g1 - g2 * g2) + return inv_norm * np.array([[1.0 - g1, -g2], [-g2, 1.0 + g1]]) + + +def test_beta_zero_ia_transform_uses_unit_determinant_reduced_shear_matrix(): scale = 0.2 - nn = 64 hlr = 1.4 + amplitude = 0.2 + phi = 0.3 - # create galaxy to be sampled by shear stamp objects - sersic_gal = galsim.Sersic(n=1.0, half_light_radius=hlr, flux=flux, trunc=0) + gamma1 = amplitude * np.cos(2.0 * phi) + gamma2 = amplitude * np.sin(2.0 * phi) - # apply affine shear with BATSim - Lens = batsim.LensTransform(gamma1=0.2, gamma2=0, kappa=0) + ia_transform = batsim.IaTransform(A=amplitude, beta=0.0, phi=phi, scale=scale, hlr=hlr) - # sample galaxy object onto stamp - Lens_gal = batsim.simulate_galaxy( - ngrid=nn, - pix_scale=scale, - gal_obj=sersic_gal, - transform_obj=Lens, + x = np.linspace(-2.0 * hlr, 2.0 * hlr, 9) + y = np.linspace(-1.5 * hlr, 1.5 * hlr, 7) + yy, xx = np.meshgrid(y, x, indexing="ij") + coords = np.stack([xx.ravel(), yy.ravel()], axis=0) + + expected_matrix = _reduced_shear_inverse_matrix(gamma1, gamma2) + + np.testing.assert_allclose(np.linalg.det(expected_matrix), 1.0, rtol=1.0e-14) + np.testing.assert_allclose( + ia_transform.transform(coords), + expected_matrix @ coords, + rtol=1.0e-14, + atol=1.0e-14, ) - # determine correct IA ampltidue to match g1 shear - A_IA = galsim.Shear(g1=0.2).e1 - # apply IA shear to galaxy - IA = batsim.IaTransform(A=A_IA, beta=0, phi=0, scale=scale, hlr=hlr) +def test_beta_zero_ia_render_matches_galsim_reduced_shear_moments(): + flux = 40 + scale = 0.15 + nn = 96 + hlr = 1.1 + g1 = 0.18 + g2 = 0.07 + amplitude = np.hypot(g1, g2) + phi = 0.5 * np.arctan2(g2, g1) + + gal = galsim.Gaussian(half_light_radius=hlr, flux=flux) + ia_transform = batsim.IaTransform(A=amplitude, beta=0.0, phi=phi, scale=scale, hlr=hlr) + + reference = ( + gal.shear(g1=g1, g2=g2) + .drawImage( + nx=nn, + ny=nn, + scale=scale, + method="no_pixel", + use_true_center=False, + ) + .array + ) - # get galaxy array from stamp object - IA_gal = batsim.simulate_galaxy( + ia_image = batsim.simulate_galaxy( ngrid=nn, pix_scale=scale, - gal_obj=sersic_gal, - transform_obj=IA, + gal_obj=gal, + transform_obj=ia_transform, + draw_method="no_pixel", + force_input_flux=False, + use_true_center=False, ) - np.testing.assert_array_almost_equal(IA_gal, Lens_gal) + reference_moments = _moments(reference, scale) + ia_moments = _moments(ia_image, scale) - # Now we test that the power law gives us the expected value at - # the half light radius - - # initialise new transform with non-zero power law - IA_pow = batsim.IaTransform(A=A_IA, beta=0.8, phi=0, scale=scale, hlr=hlr) + np.testing.assert_allclose(ia_moments[0], reference_moments[0], rtol=5.0e-6) + np.testing.assert_allclose( + ia_moments[3:6], + reference_moments[3:6], + rtol=2.0e-3, + atol=2.0e-4, + ) - # set coords for hlr - x = np.array([hlr]) - y = np.array([0]) - # get the expected g1 at the half light radius - test_g1, _ = IA_pow.get_g1g2(x, y) - # shear at hlr should = input amplitude - np.testing.assert_almost_equal(test_g1, 0.2) +def test_ia_power_law_amplitude_is_hlr_normalized(): + scale = 0.2 + hlr = 1.4 + amplitude = 0.2 + beta = 0.8 - # now do same but for coord outside hlr - # set coords for hlr - x = np.array([0]) - y = np.array([1.2 * hlr]) + ia_transform = batsim.IaTransform(A=amplitude, beta=beta, phi=0.0, scale=scale, hlr=hlr) - # get the expected g1 at the half light radius - test_g1, _ = IA_pow.get_g1g2(x, y) - # outside shear should be greater than hlr shear - np.testing.assert_array_less(0.2, test_g1) + test_g1, test_g2 = ia_transform.get_g1g2(np.array([hlr]), np.array([0.0])) + np.testing.assert_allclose(test_g1, amplitude) + np.testing.assert_allclose(test_g2, 0.0) - # now do same but for coord inside hlr - # set coords for hlr - x = np.array([0]) - y = np.array([0.8 * hlr]) + inner_g1, _ = ia_transform.get_g1g2(np.array([0.0]), np.array([0.8 * hlr])) + outer_g1, _ = ia_transform.get_g1g2(np.array([0.0]), np.array([1.2 * hlr])) - # get the expected g1 at the half light radius - test_g1, _ = IA_pow.get_g1g2(x, y) - # inside shear should be less than hlr shear - np.testing.assert_array_less(test_g1, 0.2) - return + assert inner_g1 < amplitude + assert outer_g1 > amplitude if __name__ == "__main__": - test_ia_shear() + test_beta_zero_ia_transform_uses_unit_determinant_reduced_shear_matrix() + test_beta_zero_ia_render_matches_galsim_reduced_shear_moments() + test_ia_power_law_amplitude_is_hlr_normalized() diff --git a/tests/test_pltutil.py b/tests/test_pltutil.py new file mode 100644 index 0000000..aee3e6b --- /dev/null +++ b/tests/test_pltutil.py @@ -0,0 +1,36 @@ +import galsim +import numpy as np + +from batsim import pltutil + + +def _constant_image(value, nx=2, ny=2, scale=0.2): + image = galsim.ImageF(nx, ny, scale=scale) + image.array[:, :] = value + return image + + +def test_stitch_images_square_layout_leaves_unused_cells_blank(): + images = [_constant_image(1), _constant_image(2), _constant_image(3)] + + stitched = pltutil.stitch_images(images, direction="square") + + assert stitched.array.shape == (4, 4) + assert stitched.scale == images[0].scale + + np.testing.assert_allclose( + stitched.subImage(galsim.BoundsI(xmin=1, xmax=2, ymin=1, ymax=2)).array, + 1.0, + ) + np.testing.assert_allclose( + stitched.subImage(galsim.BoundsI(xmin=3, xmax=4, ymin=1, ymax=2)).array, + 2.0, + ) + np.testing.assert_allclose( + stitched.subImage(galsim.BoundsI(xmin=1, xmax=2, ymin=3, ymax=4)).array, + 3.0, + ) + np.testing.assert_allclose( + stitched.subImage(galsim.BoundsI(xmin=3, xmax=4, ymin=3, ymax=4)).array, + 0.0, + ) diff --git a/tests/test_public_api.py b/tests/test_public_api.py new file mode 100644 index 0000000..097911a --- /dev/null +++ b/tests/test_public_api.py @@ -0,0 +1,17 @@ +import batsim + + +def test_top_level_public_api_exports(): + """Check that cleaned top-level exports preserve the intended public API.""" + assert batsim.simulate_galaxy.__name__ == "simulate_galaxy" + assert batsim.clear_backend_memory.__name__ == "clear_backend_memory" + assert batsim.Stamp.__name__ == "Stamp" + + assert batsim.Transform.__name__ == "Transform" + assert batsim.LensTransform is batsim.AffineLensingTransform + assert batsim.IaTransform is batsim.IATransform + assert batsim.FlexionTransform.__name__ == "FlexionTransform" + + assert not hasattr(batsim, "WCS") + assert batsim.experimental.WCS.__name__ == "WCS" + assert hasattr(batsim, "_gsinterface") diff --git a/tests/test_supersampling.py b/tests/test_supersampling.py new file mode 100644 index 0000000..56a97d3 --- /dev/null +++ b/tests/test_supersampling.py @@ -0,0 +1,206 @@ +import importlib + +import galsim + +sim = importlib.import_module("batsim.sim") + + +class CompactSizeProbe: + maxk = 1000.0 + + def getGoodImageSize(self, scale): + return int(200.0 / scale) + + +def _supersample(obj, scale, integration_order, sim_ngrid, pad, max_fine_grid): + return sim._determine_supersampling( + obj, + scale, + integration_order, + sim_ngrid=sim_ngrid, + pad=pad, + max_supersample=32, + min_supersample=4, + max_fine_grid=max_fine_grid, + ) + + +def test_compact_high_n_keeps_bandwidth_supersample_with_large_budget(): + scale = 0.2 + pad = 16 + gal = galsim.Sersic(n=6, half_light_radius=0.12, flux=1.0) + sim_ngrid = sim._resolve_simulation_ngrid(gal, None, scale) + + bandwidth_supersample = _supersample( + gal, + scale, + integration_order=2, + sim_ngrid=sim_ngrid, + pad=pad, + max_fine_grid=None, + ) + extent_supersample = _supersample( + gal, + scale, + integration_order=2, + sim_ngrid=sim_ngrid, + pad=pad, + max_fine_grid=4096, + ) + + assert bandwidth_supersample == 32 + assert extent_supersample == bandwidth_supersample + + +def test_compact_elliptical_galaxy_keeps_supersample_inside_compact_limit(): + scale = 0.2 + pad = 16 + max_fine_grid = 1500 + gal = galsim.Sersic(n=6, half_light_radius=0.12, flux=1.0).shear(e1=0.85) + sim_ngrid = sim._resolve_simulation_ngrid(gal, None, scale) + + bandwidth_supersample = _supersample( + gal, + scale, + integration_order=1, + sim_ngrid=sim_ngrid, + pad=pad, + max_fine_grid=None, + ) + extent_supersample = _supersample( + gal, + scale, + integration_order=1, + sim_ngrid=sim_ngrid, + pad=pad, + max_fine_grid=max_fine_grid, + ) + fine_compact = int(gal.getGoodImageSize(scale / extent_supersample)) + + assert bandwidth_supersample == 32 + assert extent_supersample == bandwidth_supersample + assert fine_compact < 3 * max_fine_grid + + +def test_elliptical_galaxy_reduces_until_inside_compact_limit(): + scale = 0.2 + pad = 16 + max_fine_grid = 1500 + gal = galsim.Sersic(n=3, half_light_radius=1.0, flux=1.0).shear(e1=0.85) + sim_ngrid = sim._resolve_simulation_ngrid(gal, None, scale) + + bandwidth_supersample = _supersample( + gal, + scale, + integration_order=1, + sim_ngrid=sim_ngrid, + pad=pad, + max_fine_grid=None, + ) + extent_supersample = _supersample( + gal, + scale, + integration_order=1, + sim_ngrid=sim_ngrid, + pad=pad, + max_fine_grid=max_fine_grid, + ) + + assert bandwidth_supersample == 32 + assert extent_supersample == 8 + assert extent_supersample < bandwidth_supersample + + accepted_fine_compact = int(gal.getGoodImageSize(scale / extent_supersample)) + rejected_fine_compact = int(gal.getGoodImageSize(scale / (extent_supersample * 2))) + + assert accepted_fine_compact < 3 * max_fine_grid + assert rejected_fine_compact >= 3 * max_fine_grid + + +def test_extent_limit_uses_fft_supersample_after_integration_split(): + scale = 0.2 + max_fine_grid = 4096 + obj = CompactSizeProbe() + + supersample = _supersample( + obj, + scale, + integration_order=2, + sim_ngrid=1340, + pad=16, + max_fine_grid=max_fine_grid, + ) + fft_supersample, _ = sim._resolve_integration_sampling( + supersample, + integration_order=2, + ) + rejected_fft_supersample, _ = sim._resolve_integration_sampling( + supersample * 2, + integration_order=2, + ) + + assert supersample == 16 + assert fft_supersample == 8 + assert obj.getGoodImageSize(scale / fft_supersample) < 3 * max_fine_grid + assert obj.getGoodImageSize(scale / rejected_fft_supersample) >= 3 * max_fine_grid + + +def test_extent_fallback_returns_min_supersample_and_leaves_safety_clip(): + scale = 0.2 + pad = 16 + max_fine_grid = 300 + gal = galsim.Sersic(n=3, half_light_radius=1.0, flux=1.0).shear(e1=0.85) + sim_ngrid = sim._resolve_simulation_ngrid(gal, None, scale) + + supersample = _supersample( + gal, + scale, + integration_order=1, + sim_ngrid=sim_ngrid, + pad=pad, + max_fine_grid=max_fine_grid, + ) + grid = sim._make_fine_grid( + gal, + scale, + sim_ngrid, + supersample, + pad, + max_fine_grid=max_fine_grid, + ) + + requested_fine_ngrid = (sim_ngrid + 2 * pad) * supersample + + assert supersample == 4 + assert grid.fine_compact >= 3 * max_fine_grid + assert requested_fine_ngrid > max_fine_grid + assert grid.fine_ngrid == max_fine_grid + assert grid.fine_ngrid < requested_fine_ngrid + + +def test_typical_sersic_profiles_are_unchanged_by_default_extent_budget(): + scale = 0.2 + pad = 16 + galaxies = [ + galsim.Sersic(n=4.0, half_light_radius=0.5, flux=1.0), + galsim.Sersic(n=2.0, half_light_radius=0.8, flux=1.0).shear(e1=0.3), + galsim.Sersic(n=5.5, half_light_radius=0.2, flux=1.0), + ] + + for gal in galaxies: + sim_ngrid = sim._resolve_simulation_ngrid(gal, None, scale) + assert _supersample( + gal, + scale, + integration_order=2, + sim_ngrid=sim_ngrid, + pad=pad, + max_fine_grid=4096, + ) == _supersample( + gal, + scale, + integration_order=2, + sim_ngrid=sim_ngrid, + pad=pad, + max_fine_grid=None, + ) diff --git a/tests/test_transforms.py b/tests/test_transforms.py new file mode 100644 index 0000000..ad319e0 --- /dev/null +++ b/tests/test_transforms.py @@ -0,0 +1,94 @@ +import galsim +import numpy as np +import pytest + +import batsim + + +class IdentityTransform(batsim.Transform): + def _transform_relative(self, coords_relative, xp, dtype): + return coords_relative + + +class ScaleXTransform(batsim.Transform): + def __init__(self, factor, **kwargs): + super().__init__(**kwargs) + self.factor = factor + + def _transform_relative(self, coords_relative, xp, dtype): + x, y = coords_relative + return xp.stack([self.factor * x, y], axis=0) + + +def test_builtin_transforms_inherit_transform_base(): + assert issubclass(batsim.LensTransform, batsim.Transform) + assert issubclass(batsim.IaTransform, batsim.Transform) + assert issubclass(batsim.FlexionTransform, batsim.Transform) + + +def test_transform_base_requires_subclass_logic(): + transform = batsim.Transform() + coords = np.zeros((2, 4)) + + with pytest.raises(NotImplementedError, match="_transform_relative"): + transform.transform(coords) + + +def test_custom_transform_gets_center_and_coordinate_management(): + transform = ScaleXTransform(factor=2.0, center=[1.0, -0.5]) + coords = np.array( + [ + [0.0, 1.0, 2.0], + [-0.5, 0.0, 0.5], + ] + ) + + expected = np.array( + [ + [-1.0, 1.0, 3.0], + [-0.5, 0.0, 0.5], + ] + ) + + np.testing.assert_allclose(transform.transform(coords), expected) + + +def test_transform_to_backend_preserves_behavior_and_dtype(): + transform = ScaleXTransform(factor=1.4, center=[0.25, -0.75]) + copied = transform.to_backend(dtype=np.float32) + + coords = np.array( + [ + [-1.0, 0.0, 1.0], + [-0.5, 0.5, 1.5], + ], + dtype=np.float32, + ) + + assert copied is not transform + assert copied.dtype == np.float32 + assert copied.ref_vec.dtype == np.float32 + np.testing.assert_allclose(copied.transform(coords), transform.transform(coords)) + + +def test_custom_transform_can_be_used_in_simulate_galaxy(): + gal = galsim.Gaussian(half_light_radius=0.8, flux=5.0) + transform = IdentityTransform() + + reference = batsim.simulate_galaxy( + ngrid=48, + pix_scale=0.2, + gal_obj=gal, + draw_method="no_pixel", + use_true_center=False, + ) + rendered = batsim.simulate_galaxy( + ngrid=48, + pix_scale=0.2, + gal_obj=gal, + transform_obj=transform, + draw_method="no_pixel", + use_true_center=False, + ) + + np.testing.assert_allclose(rendered, reference)