From 8112c6076d273c8553244148436cf596102eba80 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 30 Aug 2023 16:54:22 -0700 Subject: [PATCH 001/129] add a line about JAX --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index de82065..01768ef 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,8 @@ Overall, this makes CROISSANT a very fast visibility simulator. CROISSANT can th ## Installation For the latest release, do `pip install croissant-sim` (see https://pypi.org/project/croissant-sim). Git clone this repository for the newest changes (this is under activate development, do so at your own risk!). +To access the JAX features, JAX must also be installed. See the [installation guide](https://github.com/google/jax#installation). + ## Demo Jupyter Notebook: https://nbviewer.org/github/christianhbye/croissant/blob/main/notebooks/example_sim.ipynb From 611b28daafba99cfabd21012b7718531136ed362 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 31 Aug 2023 14:45:36 -0700 Subject: [PATCH 002/129] enable double for jax --- croissant/__init__.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/croissant/__init__.py b/croissant/__init__.py index c424027..894d484 100644 --- a/croissant/__init__.py +++ b/croissant/__init__.py @@ -1,5 +1,5 @@ __author__ = "Christian Hellum Bye" -__version__ = "3.0.0" +__version__ = "3.1.0" from . import constants, dpss, sphtransform from .healpix import Alm, HealpixMap @@ -7,3 +7,7 @@ from .rotations import Rotator from .simulator import Simulator from .sky import Sky + +# enable double precision +from jax import config +config.update("jax_enable_x64", True) From c0ffdbccd6b7981d1b4c0f8a31500b0b50d6665a Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 31 Aug 2023 16:47:27 -0700 Subject: [PATCH 003/129] jax functions --- croissant/sphtransform.py | 144 +++++++++++++++++++++++++++++++++----- 1 file changed, 127 insertions(+), 17 deletions(-) diff --git a/croissant/sphtransform.py b/croissant/sphtransform.py index 275b5d5..4227217 100644 --- a/croissant/sphtransform.py +++ b/croissant/sphtransform.py @@ -1,28 +1,94 @@ -import healpy as hp import numpy as np - +import jax +import healpy as hp from .constants import PIX_WEIGHTS_NSIDE -def alm2map(alm, nside, lmax=None): +def alm2map(alm, nside, lmax=None, method="numpy"): + """ + Compute the healpix map from the spherical harmonics coefficients. + + Parameters + ---------- + alm : array-like + The spherical harmonics coefficients in the healpy convention. Shape + ([nfreq], hp.Alm.getsize(lmax)). + Note if method="jax": must be a jnp array with 2 dimensions, i.e., + must have a frequency axis even if nfreq=1. + nside : int + The nside of the output map(s). + lmax : int + The lmax of the spherical harmonics transform. Defaults to 3*nside-1. + method : "numpy" or "jax" + + Returns + ------- + map : np.ndarray or jnp.ndarray + The healpix map. Shape ([nfreq], hp.nside2npix(nside)). + + Raises + ------ + ValueError : + If method is not "numpy" or "jax". + """ + if method == "numpy": + return alm2map_numpy(alm, nside, lmax=lmax) + elif method == "jax": + return alm2map_jax(alm, nside, lmax=lmax) + else: + raise ValueError("method must be ``numpy'' or ``jax''.") + + +def alm2map_numpy(alm, nside, lmax=None): alm = np.array(alm, copy=True) if alm.ndim == 1: - alm.shape = (1, -1) - nfreqs = alm.shape[0] - npix = hp.nside2npix(nside) - hp_map = np.empty((nfreqs, npix)) - for i in range(nfreqs): - map_i = hp.alm2map(alm[i], nside, lmax=lmax) - hp_map[i] = map_i - return np.squeeze(hp_map) + return hp.alm2map(alm, nside, lmax=lmax) + else: + npix = hp.nside2npix(nside) + nfreqs = alm.shape[0] + hp_map = np.empty((nfreqs, npix)) + for i in range(nfreqs): + map_i = hp.alm2map(alm[i], nside, lmax=lmax) + hp_map[i] = map_i + return hp_map + +@jax.jit +def alm2map_jax(alm, nside, lmax=None): + return jax.vmap( + hp.alm2map, + in_axes=( + 0, + None, + ), + )(alm, nside, lmax=lmax) -def map2alm(data, lmax=None): + +def map2alm(data, lmax=None, method="numpy"): """ Compute the spherical harmonics coefficents of a healpix map. - """ - data = np.array(data) + Parameters + ---------- + data : np.ndarray or jnp.ndarray + The healpix map(s). Shape ([nfreq], hp.nside2npix(nside)). Note if + method="jax": must be a jnp array with 2 dimensions, i.e., must have a + frequency axis even if nfreq=1. + lmax : int + The lmax of the spherical harmonics transform. Defaults to 3*nside-1. + method : "numpy" or "jax" + + Returns + ------- + alm : np.ndarray or jnp.ndarray + The spherical harmonics coefficients in the healpy convention. Shape + ([nfreq], hp.Alm.getsize(lmax)). + + Raises + ------ + ValueError : + If method is not "numpy" or "jax". + """ npix = data.shape[-1] nside = hp.npix2nside(npix) use_pix_weights = nside in PIX_WEIGHTS_NSIDE @@ -33,15 +99,59 @@ def map2alm(data, lmax=None): "use_weights": use_ring_weights, "use_pixel_weights": use_pix_weights, } + if method == "numpy": + return map2alm_numpy(data, **kwargs) + elif method == "jax": + return map2alm_jax(data, lmax=lmax) + else: + raise ValueError("method must be ``numpy'' or ``jax''.") + + +def map2alm_numpy(data, **kwargs): + """ + Compute the spherical harmonics coefficents of a healpix map. + + Parameters + ---------- + data : np.ndarray + The healpix map(s). Shape ([nfreq], hp.nside2npix(nside)). + + kwargs are passed to hp.map2alm. + + Returns + ------- + alm : np.ndarray + The spherical harmonics coefficients in the healpy convention. Shape + ([nfreq], hp.Alm.getsize(lmax)). + """ if data.ndim == 1: alm = hp.map2alm(data, **kwargs) - elif data.ndim == 2: + else: # compute the alms of the first map to determine the size of the array alm0 = hp.map2alm(data[0], **kwargs) alm = np.empty((len(data), alm0.size), dtype=alm0.dtype) alm[0] = alm0 for i in range(1, len(data)): alm[i] = hp.map2alm(data[i], **kwargs) - else: - raise ValueError("Input data must be a map or list of maps.") return alm + + +@jax.jit +def map2alm_jax(data, **kwargs): + """ + Compute the spherical harmonics coefficents of a healpix map. + + Parameters + ---------- + data : jnp.ndarray + The healpix map(s). Shape (nfreq, hp.nside2npix(nside)). + + kwargs are passed to hp.map2alm. + + Returns + ------- + alm : jnp.ndarray + The spherical harmonics coefficients in the healpy convention. Shape + (nfreq, hp.Alm.getsize(lmax)). + """ + return jax.vmap(hp.map2alm, in_axes=(0,))(data, **kwargs) From 6cec68bbf12c68e840ae3268549fe88b1a7737ff Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 13:22:19 -0700 Subject: [PATCH 004/129] move jax functionality to separate module --- croissant/sphtransform.py | 94 +++------------------------------------ 1 file changed, 7 insertions(+), 87 deletions(-) diff --git a/croissant/sphtransform.py b/croissant/sphtransform.py index 4227217..2558d1b 100644 --- a/croissant/sphtransform.py +++ b/croissant/sphtransform.py @@ -1,10 +1,9 @@ import numpy as np -import jax import healpy as hp from .constants import PIX_WEIGHTS_NSIDE -def alm2map(alm, nside, lmax=None, method="numpy"): +def alm2map(alm, nside, lmax=None): """ Compute the healpix map from the spherical harmonics coefficients. @@ -13,33 +12,17 @@ def alm2map(alm, nside, lmax=None, method="numpy"): alm : array-like The spherical harmonics coefficients in the healpy convention. Shape ([nfreq], hp.Alm.getsize(lmax)). - Note if method="jax": must be a jnp array with 2 dimensions, i.e., - must have a frequency axis even if nfreq=1. nside : int The nside of the output map(s). lmax : int The lmax of the spherical harmonics transform. Defaults to 3*nside-1. - method : "numpy" or "jax" Returns ------- - map : np.ndarray or jnp.ndarray + map : np.ndarray The healpix map. Shape ([nfreq], hp.nside2npix(nside)). - Raises - ------ - ValueError : - If method is not "numpy" or "jax". """ - if method == "numpy": - return alm2map_numpy(alm, nside, lmax=lmax) - elif method == "jax": - return alm2map_jax(alm, nside, lmax=lmax) - else: - raise ValueError("method must be ``numpy'' or ``jax''.") - - -def alm2map_numpy(alm, nside, lmax=None): alm = np.array(alm, copy=True) if alm.ndim == 1: return hp.alm2map(alm, nside, lmax=lmax) @@ -53,42 +36,25 @@ def alm2map_numpy(alm, nside, lmax=None): return hp_map -@jax.jit -def alm2map_jax(alm, nside, lmax=None): - return jax.vmap( - hp.alm2map, - in_axes=( - 0, - None, - ), - )(alm, nside, lmax=lmax) - - -def map2alm(data, lmax=None, method="numpy"): +def map2alm(data, lmax=None): """ Compute the spherical harmonics coefficents of a healpix map. Parameters ---------- - data : np.ndarray or jnp.ndarray - The healpix map(s). Shape ([nfreq], hp.nside2npix(nside)). Note if - method="jax": must be a jnp array with 2 dimensions, i.e., must have a - frequency axis even if nfreq=1. + data : array-like + The healpix map(s). Shape ([nfreq], hp.nside2npix(nside)). lmax : int The lmax of the spherical harmonics transform. Defaults to 3*nside-1. - method : "numpy" or "jax" Returns ------- - alm : np.ndarray or jnp.ndarray + alm : np.ndarray The spherical harmonics coefficients in the healpy convention. Shape ([nfreq], hp.Alm.getsize(lmax)). - Raises - ------ - ValueError : - If method is not "numpy" or "jax". """ + data = np.array(data, copy=True) npix = data.shape[-1] nside = hp.npix2nside(npix) use_pix_weights = nside in PIX_WEIGHTS_NSIDE @@ -99,31 +65,6 @@ def map2alm(data, lmax=None, method="numpy"): "use_weights": use_ring_weights, "use_pixel_weights": use_pix_weights, } - if method == "numpy": - return map2alm_numpy(data, **kwargs) - elif method == "jax": - return map2alm_jax(data, lmax=lmax) - else: - raise ValueError("method must be ``numpy'' or ``jax''.") - - -def map2alm_numpy(data, **kwargs): - """ - Compute the spherical harmonics coefficents of a healpix map. - - Parameters - ---------- - data : np.ndarray - The healpix map(s). Shape ([nfreq], hp.nside2npix(nside)). - - kwargs are passed to hp.map2alm. - - Returns - ------- - alm : np.ndarray - The spherical harmonics coefficients in the healpy convention. Shape - ([nfreq], hp.Alm.getsize(lmax)). - """ if data.ndim == 1: alm = hp.map2alm(data, **kwargs) else: @@ -134,24 +75,3 @@ def map2alm_numpy(data, **kwargs): for i in range(1, len(data)): alm[i] = hp.map2alm(data[i], **kwargs) return alm - - -@jax.jit -def map2alm_jax(data, **kwargs): - """ - Compute the spherical harmonics coefficents of a healpix map. - - Parameters - ---------- - data : jnp.ndarray - The healpix map(s). Shape (nfreq, hp.nside2npix(nside)). - - kwargs are passed to hp.map2alm. - - Returns - ------- - alm : jnp.ndarray - The spherical harmonics coefficients in the healpy convention. Shape - (nfreq, hp.Alm.getsize(lmax)). - """ - return jax.vmap(hp.map2alm, in_axes=(0,))(data, **kwargs) From d6c20a2496fb7d4ef8dc344f7c34b5ff59a00354 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 14:57:51 -0700 Subject: [PATCH 005/129] add new level to filedir --- croissant/__init__.py | 13 ++++--------- croissant/core/__init__.py | 6 ++++++ croissant/{ => core}/beam.py | 2 +- croissant/{ => core}/dpss.py | 0 croissant/{ => core}/healpix.py | 2 +- croissant/{ => core}/rotations.py | 0 croissant/{ => core}/simulator.py | 0 croissant/{ => core}/sky.py | 0 croissant/{ => core}/sphtransform.py | 2 +- {tests => croissant/core/tests}/__init__.py | 0 {tests => croissant/core/tests}/test_beam.py | 0 {tests => croissant/core/tests}/test_dpss.py | 0 {tests => croissant/core/tests}/test_healpix.py | 0 {tests => croissant/core/tests}/test_rotations.py | 0 {tests => croissant/core/tests}/test_simulator.py | 0 .../core/tests}/test_sphtransform.py | 0 16 files changed, 13 insertions(+), 12 deletions(-) create mode 100644 croissant/core/__init__.py rename croissant/{ => core}/beam.py (98%) rename croissant/{ => core}/dpss.py (100%) rename croissant/{ => core}/healpix.py (99%) rename croissant/{ => core}/rotations.py (100%) rename croissant/{ => core}/simulator.py (100%) rename croissant/{ => core}/sky.py (100%) rename croissant/{ => core}/sphtransform.py (98%) rename {tests => croissant/core/tests}/__init__.py (100%) rename {tests => croissant/core/tests}/test_beam.py (100%) rename {tests => croissant/core/tests}/test_dpss.py (100%) rename {tests => croissant/core/tests}/test_healpix.py (100%) rename {tests => croissant/core/tests}/test_rotations.py (100%) rename {tests => croissant/core/tests}/test_simulator.py (100%) rename {tests => croissant/core/tests}/test_sphtransform.py (100%) diff --git a/croissant/__init__.py b/croissant/__init__.py index 894d484..54be546 100644 --- a/croissant/__init__.py +++ b/croissant/__init__.py @@ -1,13 +1,8 @@ __author__ = "Christian Hellum Bye" __version__ = "3.1.0" -from . import constants, dpss, sphtransform -from .healpix import Alm, HealpixMap -from .beam import Beam -from .rotations import Rotator -from .simulator import Simulator -from .sky import Sky +from . import constants +from . import core +from . import crojax -# enable double precision -from jax import config -config.update("jax_enable_x64", True) +from .core import * diff --git a/croissant/core/__init__.py b/croissant/core/__init__.py new file mode 100644 index 0000000..e3b59ed --- /dev/null +++ b/croissant/core/__init__.py @@ -0,0 +1,6 @@ +from . import dpss, sphtransform +from .healpix import Alm, HealpixMap +from .beam import Beam +from .rotations import Rotator +from .simulator import Simulator +from .sky import Sky diff --git a/croissant/beam.py b/croissant/core/beam.py similarity index 98% rename from croissant/beam.py rename to croissant/core/beam.py index b4bc326..4bdc72e 100644 --- a/croissant/beam.py +++ b/croissant/core/beam.py @@ -1,7 +1,7 @@ from healpy import npix2nside, pix2ang import numpy as np -from .constants import Y00 +from ..constants import Y00 from .healpix import Alm from .sphtransform import map2alm diff --git a/croissant/dpss.py b/croissant/core/dpss.py similarity index 100% rename from croissant/dpss.py rename to croissant/core/dpss.py diff --git a/croissant/healpix.py b/croissant/core/healpix.py similarity index 99% rename from croissant/healpix.py rename to croissant/core/healpix.py index 487a116..7fcd3dc 100644 --- a/croissant/healpix.py +++ b/croissant/core/healpix.py @@ -3,7 +3,7 @@ from scipy.interpolate import RectSphereBivariateSpline import warnings -from . import constants +from .. import constants from .rotations import Rotator from .sphtransform import alm2map, map2alm diff --git a/croissant/rotations.py b/croissant/core/rotations.py similarity index 100% rename from croissant/rotations.py rename to croissant/core/rotations.py diff --git a/croissant/simulator.py b/croissant/core/simulator.py similarity index 100% rename from croissant/simulator.py rename to croissant/core/simulator.py diff --git a/croissant/sky.py b/croissant/core/sky.py similarity index 100% rename from croissant/sky.py rename to croissant/core/sky.py diff --git a/croissant/sphtransform.py b/croissant/core/sphtransform.py similarity index 98% rename from croissant/sphtransform.py rename to croissant/core/sphtransform.py index 2558d1b..613e4b5 100644 --- a/croissant/sphtransform.py +++ b/croissant/core/sphtransform.py @@ -1,6 +1,6 @@ import numpy as np import healpy as hp -from .constants import PIX_WEIGHTS_NSIDE +from ..constants import PIX_WEIGHTS_NSIDE def alm2map(alm, nside, lmax=None): diff --git a/tests/__init__.py b/croissant/core/tests/__init__.py similarity index 100% rename from tests/__init__.py rename to croissant/core/tests/__init__.py diff --git a/tests/test_beam.py b/croissant/core/tests/test_beam.py similarity index 100% rename from tests/test_beam.py rename to croissant/core/tests/test_beam.py diff --git a/tests/test_dpss.py b/croissant/core/tests/test_dpss.py similarity index 100% rename from tests/test_dpss.py rename to croissant/core/tests/test_dpss.py diff --git a/tests/test_healpix.py b/croissant/core/tests/test_healpix.py similarity index 100% rename from tests/test_healpix.py rename to croissant/core/tests/test_healpix.py diff --git a/tests/test_rotations.py b/croissant/core/tests/test_rotations.py similarity index 100% rename from tests/test_rotations.py rename to croissant/core/tests/test_rotations.py diff --git a/tests/test_simulator.py b/croissant/core/tests/test_simulator.py similarity index 100% rename from tests/test_simulator.py rename to croissant/core/tests/test_simulator.py diff --git a/tests/test_sphtransform.py b/croissant/core/tests/test_sphtransform.py similarity index 100% rename from tests/test_sphtransform.py rename to croissant/core/tests/test_sphtransform.py From f1319f24f95f97ed7c2912998f7e6e324c9efd8f Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 14:58:09 -0700 Subject: [PATCH 006/129] bump version --- setup.cfg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.cfg b/setup.cfg index bc61012..c8e1b9b 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,6 +1,6 @@ [metadata] name = croissant-sim -version = 3.0.0 +version = 3.1.0 description = CROISSANT: Rapid spherical harmonics-based simulator of visibilities long_description = file: README.md author = Christian Hellum Bye From 128e21e293d3a1f42b1c018454cbca132ee0d1db Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 15:04:02 -0700 Subject: [PATCH 007/129] add noqa to allow * import --- croissant/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/croissant/__init__.py b/croissant/__init__.py index 54be546..5a7d700 100644 --- a/croissant/__init__.py +++ b/croissant/__init__.py @@ -5,4 +5,4 @@ from . import core from . import crojax -from .core import * +from .core import * # noqa F403 From c8c86a400c2f8ad1fd4ee8c8ff620e40d28eed0f Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 15:55:47 -0700 Subject: [PATCH 008/129] add s2fft as requirement --- setup.cfg | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.cfg b/setup.cfg index c8e1b9b..e616c8a 100644 --- a/setup.cfg +++ b/setup.cfg @@ -27,6 +27,7 @@ install_requires = numpy <= 1.23 pygdsm scipy + s2fft @ git+https://github.com/astro-informatics/s2fft.git [options.extras_require] dev = From e4928145028b77d6c3876c7efaa2eb08ccb4a131 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 16:01:42 -0700 Subject: [PATCH 009/129] fix compatibility issue flake8/importlib-metadata --- .github/workflows/push.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index db21ee1..bd18fa9 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -19,6 +19,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip + python -m pip install importlib-metadata<5 python -m pip install .[dev] - name: Lint with flake8 run: | From 78dab887d5c214738ea6562ffe1ddbd697083316 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 16:04:16 -0700 Subject: [PATCH 010/129] try again flake8/implib --- .github/workflows/push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index bd18fa9..22fd1ef 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -19,7 +19,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - python -m pip install importlib-metadata<5 + python -m pip install importlib-metadata==4.13.0 python -m pip install .[dev] - name: Lint with flake8 run: | From e02f85db4d345a178f00180fcbba506d4369bf00 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 16:25:33 -0700 Subject: [PATCH 011/129] update path to tests --- .github/workflows/push.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index 22fd1ef..5d4834b 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -30,6 +30,7 @@ jobs: #mypy ./croissant/ - name: Test with pytest run: | - pytest --cov=croissant --cov-report=xml tests/ + pytest --cov=croissant --cov-report=xml core/tests + #pytest --cov=croissant --cov-report=xml core/tests crojax/tests - name: Upload coverage to Codecov uses: codecov/codecov-action@v3 From 8ccb6bee59da55c3054fd3950e812f041f429a5e Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 16:31:56 -0700 Subject: [PATCH 012/129] fix imports --- croissant/core/tests/test_simulator.py | 2 +- croissant/core/tests/test_sphtransform.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/croissant/core/tests/test_simulator.py b/croissant/core/tests/test_simulator.py index 2741fbe..692e7ab 100644 --- a/croissant/core/tests/test_simulator.py +++ b/croissant/core/tests/test_simulator.py @@ -8,7 +8,7 @@ from croissant import Beam, dpss, Rotator, Simulator, Sky from croissant.constants import sidereal_day_earth -from croissant.simulator import time_array +from croissant.core.simulator import time_array # define default params for simulator diff --git a/croissant/core/tests/test_sphtransform.py b/croissant/core/tests/test_sphtransform.py index 744dcc2..73b5fb2 100644 --- a/croissant/core/tests/test_sphtransform.py +++ b/croissant/core/tests/test_sphtransform.py @@ -2,7 +2,7 @@ import numpy as np from croissant.constants import Y00 -from croissant.sphtransform import alm2map, map2alm +from croissant.core.sphtransform import alm2map, map2alm def test_alm2map(): From 73fe0c2a603b8de28afbfa3d1098f4726ac4ee67 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 16:32:16 -0700 Subject: [PATCH 013/129] update test path --- .github/workflows/push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index 5d4834b..3be0afa 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -30,7 +30,7 @@ jobs: #mypy ./croissant/ - name: Test with pytest run: | - pytest --cov=croissant --cov-report=xml core/tests + pytest --cov=croissant --cov-report=xml croissant/core/tests #pytest --cov=croissant --cov-report=xml core/tests crojax/tests - name: Upload coverage to Codecov uses: codecov/codecov-action@v3 From 341f9937d09a5a721dd5990e6140a5427e78a60e Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 16:37:12 -0700 Subject: [PATCH 014/129] manually force install numpy --- .github/workflows/push.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index 3be0afa..d82b29f 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -20,6 +20,7 @@ jobs: run: | python -m pip install --upgrade pip python -m pip install importlib-metadata==4.13.0 + python -m pip install numpy python -m pip install .[dev] - name: Lint with flake8 run: | From 3aa0a3187509fcde155e8d8155ceeb31a8adc196 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 16:40:23 -0700 Subject: [PATCH 015/129] drop python3.7 support --- .github/workflows/push.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index d82b29f..35e56c7 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -8,7 +8,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.7", "3.8", "3.9", "3.10"] + python-version: ["3.8", "3.9", "3.10"] steps: - uses: actions/checkout@v3 @@ -20,7 +20,6 @@ jobs: run: | python -m pip install --upgrade pip python -m pip install importlib-metadata==4.13.0 - python -m pip install numpy python -m pip install .[dev] - name: Lint with flake8 run: | From b987476c9a5f76369b93b0c85db79b7660527ec9 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 16:40:48 -0700 Subject: [PATCH 016/129] drop python3.7 support --- setup.cfg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.cfg b/setup.cfg index e616c8a..ae71c1a 100644 --- a/setup.cfg +++ b/setup.cfg @@ -15,7 +15,7 @@ classifiers = [options] -python_requires = >= 3.7 +python_requires = >= 3.8 packages=find: install_requires = astropy From 5b4cb37416caec38b1893f45f930aa3b500f1bc9 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 1 Sep 2023 16:44:51 -0700 Subject: [PATCH 017/129] dont import crojax yet --- croissant/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/croissant/__init__.py b/croissant/__init__.py index 5a7d700..c1a111e 100644 --- a/croissant/__init__.py +++ b/croissant/__init__.py @@ -3,6 +3,6 @@ from . import constants from . import core -from . import crojax +#from . import crojax from .core import * # noqa F403 From 1d1731e9dfd70d87b185f023d23f7cbf1d23d527 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 4 Sep 2023 18:59:40 -0700 Subject: [PATCH 018/129] move coord_rep() to separate utils module --- croissant/core/healpix.py | 33 +++++---------------------------- croissant/utils.py | 21 +++++++++++++++++++++ 2 files changed, 26 insertions(+), 28 deletions(-) create mode 100644 croissant/utils.py diff --git a/croissant/core/healpix.py b/croissant/core/healpix.py index 7fcd3dc..75f132f 100644 --- a/croissant/core/healpix.py +++ b/croissant/core/healpix.py @@ -3,34 +3,11 @@ from scipy.interpolate import RectSphereBivariateSpline import warnings -from .. import constants +from .. import constants, utils from .rotations import Rotator from .sphtransform import alm2map, map2alm -def coord_rep(coord): - """ - Shorthand notation for coordinate systems. - - Parameters - ---------- - coord : str - The name of the coordinate system. - - Returns - ------- - rep : str - The one-letter shorthand notation for the coordinate system. - - """ - coord = coord.upper() - if coord[0] == "E" and coord[1] == "Q": - rep = "C" - else: - rep = coord[0] - return rep - - def healpix2lonlat(nside, pix=None): """ Compute the longtitudes and latitudes of the pixel centers of a healpix @@ -191,7 +168,7 @@ def __init__( if coord is None: self.coord = None else: - self.coord = coord_rep(coord) + self.coord = utils.coord_rep(coord) data = np.array(data, copy=True, dtype=np.float64) if frequencies is not None: @@ -306,7 +283,7 @@ def switch_coords( string is given, it must be able to instantiate a Time object. """ - to_coord = coord_rep(to_coord) + to_coord = utils.coord_rep(to_coord) rot = Rotator(coord=[self.coord, to_coord], loc=loc, time=time) if rot_pixel: self.data = rot.rotate_map_pixel(self.data) @@ -366,7 +343,7 @@ def __init__(self, alm, lmax=None, frequencies=None, coord=None): if coord is None: self.coord = None else: - self.coord = coord_rep(coord) + self.coord = utils.coord_rep(coord) def __setitem__(self, key, value): """ @@ -471,7 +448,7 @@ def from_grid( return obj def switch_coords(self, to_coord, loc=None, time=None): - to_coord = coord_rep(to_coord) + to_coord = utils.coord_rep(to_coord) rot = Rotator(coord=[self.coord, to_coord], loc=loc, time=time) rot.rotate_alm(self.alm, lmax=self.lmax, inplace=True) self.coord = to_coord diff --git a/croissant/utils.py b/croissant/utils.py new file mode 100644 index 0000000..a2fdd53 --- /dev/null +++ b/croissant/utils.py @@ -0,0 +1,21 @@ +def coord_rep(coord): + """ + Shorthand notation for coordinate systems. + + Parameters + ---------- + coord : str + The name of the coordinate system. + + Returns + ------- + rep : str + The one-letter shorthand notation for the coordinate system. + + """ + coord = coord.upper() + if coord[0] == "E" and coord[1] == "Q": + rep = "C" + else: + rep = coord[0] + return rep From e484272e5dc76f978650cce264e4ccb3ebf8b47a Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 4 Sep 2023 19:00:00 -0700 Subject: [PATCH 019/129] initial commit --- croissant/crojax/README.md | 0 croissant/crojax/__init__.py | 3 + croissant/crojax/healpix.py | 247 +++++++++++++++++++++++++++++++++++ 3 files changed, 250 insertions(+) create mode 100644 croissant/crojax/README.md create mode 100644 croissant/crojax/__init__.py create mode 100644 croissant/crojax/healpix.py diff --git a/croissant/crojax/README.md b/croissant/crojax/README.md new file mode 100644 index 0000000..e69de29 diff --git a/croissant/crojax/__init__.py b/croissant/crojax/__init__.py new file mode 100644 index 0000000..4ea3473 --- /dev/null +++ b/croissant/crojax/__init__.py @@ -0,0 +1,3 @@ +# enable double precision +from jax import config +config.update("jax_enable_x64", True) diff --git a/croissant/crojax/healpix.py b/croissant/crojax/healpix.py new file mode 100644 index 0000000..f0df3ad --- /dev/null +++ b/croissant/crojax/healpix.py @@ -0,0 +1,247 @@ +from functools import partial +import warnings +import jax +import jax.numpy as jnp +import s2fft +from .. import constants, utils + + +def alm_shape(lmax, nfreq=1): + """ + Get the shape of the alm array for a given lmax and number of frequencies. + """ + return (nfreq, lmax + 1, 2 * lmax + 1) + + +def lmax_from_shape(shape): + """ + Get the lmax from the shape of the alm array. + """ + return shape[1] - 1 + + +class Alm: + def __init__(self, alm, frequencies=None, coord=None): + """ + Base class for spherical harmonics coefficients. + + Alm can be indexed with [freq_index, ell, emm] to get the + coeffiecient corresponding to the given frequency index, and values of + ell and emm. The frequencies can be indexed in the usual numpy way and + may be 0 if the alms are specified for only one frequency. + + Parameters + ---------- + alm : jnp.ndarray + The spherical harmonics coefficients. Must have shape + (nfreq, lmax+1, 2*lmax+1). + frequencies : jnp.ndarray + The frequencies corresponding to the coefficients. Must have shape + (nfreq,). If None, then the coefficients are assumed to be for a + single frequency and nfreq is set to 1. + coord : str + The coordinate system of the coefficients. + + + """ + self.alm = alm + self.frequencies = frequencies + self.lmax = lmax_from_shape(alm.shape) + if coord is None: + self.coord = None + else: + self.coord = utils.coord_rep(coord) + + def __setitem__(self, key, value): + """ + Set the value of the spherical harmonics coefficient. The frequency + axis is indexed in the usual numpy way, while the other two indices + correspond to the values of l and m. + """ + fix, ell, emm = key + lmix = self.getidx(ell, emm) + self.alm.at[fix, lmix].set(value) + + def __getitem__(self, key): + fix, ell, emm = key + lmix = self.getidx(ell, emm) + return self.alm[fix, lmix] + + @classmethod + def zeros(cls, lmax, frequencies=None, coord=None): + """ + Construct an Alm object with all zero coefficients. + """ + alm = jnp.zeros(alm_shape(lmax, frequencies=frequencies)) + obj = cls( + alm=alm, + frequencies=frequencies, + coord=coord, + ) + return obj + + @property + def is_real(self): + """ + Check if the coefficients correspond to a real-valued signal. + Mathematically, this means that alm(l, m) = (-1)^m * conj(alm(l, -m)). + """ + emm = jnp.arange(-self.lmax, self.lmax + 1)[None, None, :] + neg_m = self.alm[:, :, : self.lmax] # alms for m < 0 + pos_m = self.alm[:, :, self.lmax + 1 :] # alms for m > 0 + return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)) + + def reduce_lmax(self, new_lmax): + """ + Reduce the maximum l value of the alm. + + Parameters + ---------- + new_lmax : int + The new maximum l value. + + Raises + ------ + ValueError + If new_lmax is greater than the current lmax. + """ + d = self.lmax - new_lmax # number of ell values to remove + if d < 0: + raise ValueError( + "new_lmax must be less than or equal to the current lmax" + ) + elif d > 0: + self.alm = self.alm[:, :-d, d:-d] + self.lmax = new_lmax + + def switch_coords(self, to_coord, loc=None, time=None): + raise NotImplementedError + + def getlm(self, ix): + """ + Get the l and m corresponding to the index of the alm array. + + Parameters + ---------- + ix : tuple + The index of the alm array. + + Returns + ------- + ell : int + The value of l. + emm : int + The value of m. + """ + ell = ix[0] + emm = ix[1] - self.lmax + return ell, emm + + def getidx(self, ell, emm): + """ + Get the index of the alm array for a given l and m. + + Parameters + ---------- + ell : int + The value of l. + emm : int + The value of m. + + Returns + ------- + ix : tuple + The index of the alm array corresponding to the given l and m. + + Raises + ------ + IndexError + If l,m don't satisfy abs(m) <= l <= lmax. + """ + if not ((jnp.abs(emm) <= ell) & (ell <= self.lmax)).all(): + raise IndexError("l,m must satsify abs(m) <= l <= lmax.") + ix = (ell, self.lmax + emm) + return ix + + def hp_map(self, nside, frequencies=None): + """ + Construct a Healpix map from the Alm for the given frequencies. + + Parameters + ---------- + nside : int + The nside of the Healpix map to construct. + frequencies : array_like + The frequencies to construct the map for. If None, the map will + be constructed for all frequencies. + + Returns + ------- + m : np.ndarray + The Healpix map(s) (shape = (Nfreq, 12 * nside ** 2)). + + """ + if frequencies is None: + alm = self.alm + else: + indices = jnp.isin( + self.frequencies, frequencies, assume_unique=True + ).nonzero()[0] + if indices.size < jnp.size(frequencies): + warnings.warn( + "Some of the frequencies specified are not in" + "alm.frequencies.", + UserWarning, + ) + alm = self.alm[indices] + alm2map = partial( + s2fft.inverse_jax, + L=self.lmax + 1, + spin=0, + nside=nside, + reality=self.is_real, + precomps=None, + spmd=False, + L_lower=None, + ) + m = jax.vamp(alm2map(alm)) + return m + + def rot_alm_z(self, phi=None, times=None, world="moon"): + """ + Get the coefficients that rotate the alms around the z-axis by phi + (measured counterclockwise) or in time. + + Parameters + ---------- + phi : jnp.ndarray + The angle(s) to rotate the azimuth by in radians. + times : jnp.ndarray + The times to rotate the azimuth by in seconds. If given, phi will + be ignored and the rotation angle will be calculated from the + times and the sidereal day of the world. + world : str + The world to use for the sidereal day. Must be 'moon' or 'earth'. + + Returns + ------- + phase : np.ndarray + The coefficients (shape = (phi.size, alm.size) that rotate the + alms by phi. + + """ + if times is not None: + if world.lower() == "moon": + sidereal_day = constants.sidereal_day_moon + elif world.lower() == "earth": + sidereal_day = constants.sidereal_day_earth + else: + raise ValueError( + f"World must be 'moon' or 'earth', not {world}." + ) + phi = 2 * jnp.pi * times / sidereal_day + return self.rot_alm_z(phi=phi, times=None) + + emms = jnp.arange(-self.lmax, self.lmax + 1) + phase = jnp.exp(-1j * emms[None, :] * phi[:, None]) + return phase From b1821e07c4460041d31c22c2b556199e9dc97db5 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 4 Sep 2023 19:00:15 -0700 Subject: [PATCH 020/129] import crojax with croissant --- croissant/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/croissant/__init__.py b/croissant/__init__.py index c1a111e..5a7d700 100644 --- a/croissant/__init__.py +++ b/croissant/__init__.py @@ -3,6 +3,6 @@ from . import constants from . import core -#from . import crojax +from . import crojax from .core import * # noqa F403 From 64e4a418833c596cc7b1a82f49a4d7ec324254bf Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 4 Sep 2023 19:15:17 -0700 Subject: [PATCH 021/129] import Alm class from healpix --- croissant/crojax/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/croissant/crojax/__init__.py b/croissant/crojax/__init__.py index 4ea3473..b535df6 100644 --- a/croissant/crojax/__init__.py +++ b/croissant/crojax/__init__.py @@ -1,3 +1,5 @@ # enable double precision from jax import config config.update("jax_enable_x64", True) + +from .healpix import Alm From 5689852299127f503897882345d98ae84ba64fbc Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 4 Sep 2023 19:49:58 -0700 Subject: [PATCH 022/129] initial commit --- notebooks/jax_example.ipynb | 296 ++++++++++++++++++++++++++++++++++++ 1 file changed, 296 insertions(+) create mode 100644 notebooks/jax_example.ipynb diff --git a/notebooks/jax_example.ipynb b/notebooks/jax_example.ipynb new file mode 100644 index 0000000..6a49168 --- /dev/null +++ b/notebooks/jax_example.ipynb @@ -0,0 +1,296 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6a05778f", + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "jax.config.update(\"jax_enable_x64\", True)\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib notebook\n", + "import s2fft\n", + "from croissant import crojax" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2348797a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" + ] + } + ], + "source": [ + "# simple beam in topocentric coordinates\n", + "lmax = 8\n", + "freq = jnp.linspace(40, 80, 41)\n", + "beam_alm = crojax.Alm.zeros(lmax, frequencies=freq, coord=\"T\")\n", + "\n", + "# set (l=0, m=0) and (l=1, m=0) mode\n", + "beam_alm[:, 0, 0] = 30 * (freq/freq[0]) ** 2\n", + "beam_alm[:, 1, 0] = 10 * (freq/freq[0])**2\n", + "\n", + "# visualize with healpix\n", + "#nside = 64\n", + "#hp.mollview(beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "00c86d9d-6b31-44c2-a48c-6998d4f0d350", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0.], dtype=float64)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "beam_alm.alm[:, 0, 0 # WHYYYYYYYYYYYYYYYYYYYyy" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3be26219", + "metadata": {}, + "outputs": [], + "source": [ + "# we can impose a horizon like this, note that the sharp edge creates ripples since we don't have an inifinite lmax\n", + "beam.horizon_cut()\n", + "hp.mollview(beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")" + ] + }, + { + "cell_type": "markdown", + "id": "a5f791e5", + "metadata": {}, + "source": [ + "We use the Global Sky Model (Zheng et al 2016) at 25 MHz as the sky model. It has a built-in interface in the sky module of croissant." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d25d25a", + "metadata": {}, + "outputs": [], + "source": [ + "sky = cro.Sky.gsm(beam.frequencies, lmax=beam.lmax)\n", + "hp.mollview(sky.hp_map(nside)[0], title=f\"Sky at {freq[0]:.0f} MHz\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9a5e0c5e", + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "plt.plot(sky.frequencies, np.real(sky[:, 0, 0]), label=\"Sky monopole spectrum\")\n", + "plt.xlabel(\"Frequency [MHz]\")\n", + "plt.ylabel(\"Temperature [K]\")\n", + "plt.xlim(sky.frequencies.min(), sky.frequencies.max())\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10ca4c8e", + "metadata": {}, + "outputs": [], + "source": [ + "# let's do a full sidereal day on the moon\n", + "loc = (20., -10.)\n", + "t_start = Time(\"2022-06-02 15:43:43\")\n", + "t_end = t_start + cro.constants.sidereal_day_moon * seconds\n", + "sim = cro.Simulator(beam, sky, loc, t_start, world=\"moon\", t_end=t_end, N_times=300, lmax=lmax)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a077a8e9", + "metadata": {}, + "outputs": [], + "source": [ + "# the simulator view of the beam and sky after moving to MCMF coordinates\n", + "hp.mollview(sim.beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")\n", + "hp.mollview(sim.sky.hp_map(nside)[0], title=f\"Sky at {freq[0]:.0f} MHz\")" + ] + }, + { + "cell_type": "markdown", + "id": "d991be35", + "metadata": {}, + "source": [ + "Run the simulator!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "394a8fe8", + "metadata": {}, + "outputs": [], + "source": [ + "# dpss mode\n", + "sim.run(dpss=True, nterms=40)\n", + "sim.plot(power=2.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9e0b5493", + "metadata": {}, + "outputs": [], + "source": [ + "sim.run(dpss=False)\n", + "sim.plot(power=2.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79fb8cac", + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "plt.plot(sim.frequencies, sim.waterfall[::10].T, ls=\"--\")\n", + "plt.xlim(sim.frequencies.min(), sim.frequencies.max())\n", + "plt.xlabel(\"$\\\\nu$ [MHz]\")\n", + "plt.ylabel(\"Temperature [K]\")\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65f0df23", + "metadata": {}, + "outputs": [], + "source": [ + "# Temp vs time\n", + "fig, axs = plt.subplots(figsize=(13,5), ncols=5, sharex=True, sharey=True)\n", + "for i, f in enumerate(sim.frequencies[::10]):\n", + " ax = axs.ravel()[i]\n", + " fidx = np.argwhere(sim.frequencies == f)[0, 0]\n", + " ax.plot(sim.waterfall[:, fidx] * f**2.5)\n", + " ax.set_title(f\"{f} MHz\")\n", + " ax.grid()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ada1730d", + "metadata": {}, + "source": [ + "# On Earth" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e2b917b", + "metadata": {}, + "outputs": [], + "source": [ + "loc = (20., -10.)\n", + "t_start = Time(\"2022-06-02 15:43:43\")\n", + "t_end = t_start + cro.constants.sidereal_day_earth * seconds\n", + "sim = cro.Simulator(beam, sky, loc, t_start, world=\"earth\", t_end=t_end, N_times=300, lmax=lmax)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef176681", + "metadata": {}, + "outputs": [], + "source": [ + "# the simulator view of the beam and sky after moving to equatorial coordinates\n", + "hp.mollview(sim.beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")\n", + "hp.mollview(sim.sky.hp_map(nside)[0], title=f\"Sky at {freq[0]:.0f} MHz\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d521d17d", + "metadata": {}, + "outputs": [], + "source": [ + "# dpss mode\n", + "sim.run(dpss=True, nterms=40)\n", + "sim.plot(power=2.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f08c3db8", + "metadata": {}, + "outputs": [], + "source": [ + "# Temp vs time\n", + "fig, axs = plt.subplots(figsize=(13,5), ncols=5, sharex=True, sharey=True)\n", + "for i, f in enumerate(sim.frequencies[::10]):\n", + " ax = axs.ravel()[i]\n", + " fidx = np.argwhere(sim.frequencies == f)[0, 0]\n", + " ax.plot(sim.waterfall[:, fidx] * f**2.5)\n", + " ax.set_title(f\"{f} MHz\")\n", + " ax.grid()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 550cb32e6ae4abac2e39693b5591cb10dd9b4a5f Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 4 Sep 2023 19:50:22 -0700 Subject: [PATCH 023/129] fix initial bugs --- croissant/crojax/healpix.py | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/croissant/crojax/healpix.py b/croissant/crojax/healpix.py index f0df3ad..7b139bd 100644 --- a/croissant/crojax/healpix.py +++ b/croissant/crojax/healpix.py @@ -58,21 +58,21 @@ def __setitem__(self, key, value): axis is indexed in the usual numpy way, while the other two indices correspond to the values of l and m. """ - fix, ell, emm = key - lmix = self.getidx(ell, emm) - self.alm.at[fix, lmix].set(value) + lix, mix = self.getidx(*key[1:]) + new_key = (key[0], lix, mix) + self.alm = self.alm.at[new_key].set(value) def __getitem__(self, key): - fix, ell, emm = key - lmix = self.getidx(ell, emm) - return self.alm[fix, lmix] + lix, mix = self.getidx(*key[1:]) + new_key = (key[0], lix, mix) + return self.alm[new_key] @classmethod def zeros(cls, lmax, frequencies=None, coord=None): """ Construct an Alm object with all zero coefficients. """ - alm = jnp.zeros(alm_shape(lmax, frequencies=frequencies)) + alm = jnp.zeros(alm_shape(lmax, nfreq=jnp.size(frequencies))) obj = cls( alm=alm, frequencies=frequencies, @@ -150,9 +150,11 @@ def getidx(self, ell, emm): Returns ------- - ix : tuple - The index of the alm array corresponding to the given l and m. - + l_ix : int + The l index (which is the same as the input ell). + m_ix : int + The m index. + Raises ------ IndexError @@ -160,8 +162,9 @@ def getidx(self, ell, emm): """ if not ((jnp.abs(emm) <= ell) & (ell <= self.lmax)).all(): raise IndexError("l,m must satsify abs(m) <= l <= lmax.") - ix = (ell, self.lmax + emm) - return ix + l_ix = ell + m_ix = emm + self.lmax + return l_ix, m_ix def hp_map(self, nside, frequencies=None): """ From 1c725a88fbfb4aaf395feced9f01ac7a769af5af Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 4 Sep 2023 19:52:51 -0700 Subject: [PATCH 024/129] install jax in workflow --- .github/workflows/push.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index 35e56c7..fa57a3b 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -20,6 +20,7 @@ jobs: run: | python -m pip install --upgrade pip python -m pip install importlib-metadata==4.13.0 + python -m pip install --upgrade "jax[cpu]" python -m pip install .[dev] - name: Lint with flake8 run: | From bda85d14bef6f90b7aee2a23396cc2887bc53041 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 5 Sep 2023 14:33:34 -0700 Subject: [PATCH 025/129] move coord_rep to new module --- croissant/core/tests/test_healpix.py | 10 ++-------- croissant/core/tests/test_utils.py | 8 ++++++++ 2 files changed, 10 insertions(+), 8 deletions(-) create mode 100644 croissant/core/tests/test_utils.py diff --git a/croissant/core/tests/test_healpix.py b/croissant/core/tests/test_healpix.py index 776143a..a177231 100644 --- a/croissant/core/tests/test_healpix.py +++ b/croissant/core/tests/test_healpix.py @@ -4,13 +4,7 @@ import pytest from croissant import healpix as hp, sphtransform as spht from croissant.constants import sidereal_day_earth, sidereal_day_moon, Y00 - - -def test_coord_rep(): - coords = ["galactic", "equatorial", "ecliptic", "mcmf", "topocentric"] - short = ["G", "C", "E", "M", "T"] - for i in range(len(coords)): - assert hp.coord_rep(coords[i]) == short[i] +from croissant.utils import coord_rep def test_healpix2lonlat(): @@ -301,7 +295,7 @@ def test_from_healpix(): alm = hp.Alm.from_healpix(hp_map, lmax=lmax) assert alm.lmax == lmax assert np.allclose(alm.frequencies, freqs) - assert alm.coord == hp.coord_rep(coord) + assert alm.coord == coord_rep(coord) assert np.allclose(alm.alm, spht.map2alm(data, lmax=lmax)) diff --git a/croissant/core/tests/test_utils.py b/croissant/core/tests/test_utils.py new file mode 100644 index 0000000..e450a5c --- /dev/null +++ b/croissant/core/tests/test_utils.py @@ -0,0 +1,8 @@ +from croissant.utils import coord_rep + + +def test_coord_rep(): + coords = ["galactic", "equatorial", "ecliptic", "mcmf", "topocentric"] + short = ["G", "C", "E", "M", "T"] + for i in range(len(coords)): + assert coord_rep(coords[i]) == short[i] From 29c2d3c876763e9c3aeb95af13cd228aadcfbd31 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 5 Sep 2023 14:33:58 -0700 Subject: [PATCH 026/129] blacken --- croissant/core/tests/test_dpss.py | 1 - croissant/core/tests/test_simulator.py | 2 -- 2 files changed, 3 deletions(-) diff --git a/croissant/core/tests/test_dpss.py b/croissant/core/tests/test_dpss.py index 661f540..e4759e6 100644 --- a/croissant/core/tests/test_dpss.py +++ b/croissant/core/tests/test_dpss.py @@ -4,7 +4,6 @@ def test_dpss_op(): - x = np.linspace(1, 50, 50) # target frequencies with pytest.raises(ValueError): # didn't specify any kwargs _ = dpss.dpss_op(x) diff --git a/croissant/core/tests/test_simulator.py b/croissant/core/tests/test_simulator.py index 692e7ab..8617e94 100644 --- a/croissant/core/tests/test_simulator.py +++ b/croissant/core/tests/test_simulator.py @@ -32,7 +32,6 @@ def test_time_array(): - # check that the times are set consistently regardless of # which parameters that specify it delta_t, step = np.linspace(0, sidereal_day_earth, N_times, retstep=True) @@ -57,7 +56,6 @@ def test_time_array(): def test_simulator_init(): - sim = Simulator(*args, **kwargs) # check that the simulation attributes are set properly assert sim.sim_coord == "M" # mcmf From cd5ed595c9bd426b23a7eab765dd27c1f7e4f7c1 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 6 Sep 2023 15:53:06 -0700 Subject: [PATCH 027/129] initial commit --- croissant/crojax/beam.py | 67 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 croissant/crojax/beam.py diff --git a/croissant/crojax/beam.py b/croissant/crojax/beam.py new file mode 100644 index 0000000..0d25fae --- /dev/null +++ b/croissant/crojax/beam.py @@ -0,0 +1,67 @@ +import jax.numpy as jnp +from s2fft.sampling import s2_samples +from healpy import get_nside + +from ..constants import Y00 +from .healpix import Alm + + +class Beam(Alm): + def compute_total_power(self): + """ + Compute the total integrated power in the beam at each frequency. This + is a necessary normalization constant for computing the visibilities. + It should be computed before applying the horizon cut in order to + account for ground loss. + """ + a00 = self[:, 0, 0] + power = a00.real * Y00 * 4 * jnp.pi + self.total_power = power + + def horizon_cut(self, horizon=None, sampling="mw", nside=None): + """ + horizon : jnp.ndarray + A mask 0s and 1s indicating the horizon, with 1s corresponding to + above the horizon. If None, the horizon is assumed to be flat at + theta = pi/2. The shape must match the sampling scheme given by + ``sampling'' and the lmax of the beam given in self.lmax. See + s2fft.sampling.s2_samples.f_shape for details. + sampling : str + Sampling scheme of the horizon mask. Must be in + {"mw", "mwss", "dh", "healpix"}. Gets passed to s2fft.forward. + nside : int + The nside of the horizon mask for the intermediate step. Required + if sampling == "healpix" and horizon is None. + + Raises + ------ + ValueError + If horizon is not None and has elements outside of [0, 1]. + """ + if horizon is not None: + if horizon.min() < 0 or horizon.max() > 1: + raise ValueError("Horizon elements must be in [0, 1].") + if sampling.lower() == "healpix": + nside = get_nside(horizon) + + # invoke horizon mask in pixel space + m = self.alm2map(sampling=sampling, nside=nside) + if horizon is None: + horizon = jnp.ones_like(m) + theta = s2_samples.thetas( + L=self.lmax+1, sampling=sampling, nside=nside + ) + horizon.at[..., theta > jnp.pi / 2].set(0.) + + m = m * horizon + self.alm = jax.vmap( + partial( + s2fft.forward_jax, + L=self.lmax+1, + spin=0, + nside=nside, + reality=self.is_real, + precomps=None, + spmd=False, + L_lower=0 + )(m) From 28af2ad974879545c5d025440f46a328854ac5b6 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 6 Sep 2023 15:55:04 -0700 Subject: [PATCH 028/129] fix syntax and blacken --- croissant/crojax/__init__.py | 1 + croissant/crojax/beam.py | 11 +++++---- croissant/crojax/healpix.py | 48 +++++++++++++++++++++--------------- 3 files changed, 35 insertions(+), 25 deletions(-) diff --git a/croissant/crojax/__init__.py b/croissant/crojax/__init__.py index b535df6..663cb04 100644 --- a/croissant/crojax/__init__.py +++ b/croissant/crojax/__init__.py @@ -1,5 +1,6 @@ # enable double precision from jax import config + config.update("jax_enable_x64", True) from .healpix import Alm diff --git a/croissant/crojax/beam.py b/croissant/crojax/beam.py index 0d25fae..41b9e25 100644 --- a/croissant/crojax/beam.py +++ b/croissant/crojax/beam.py @@ -49,19 +49,20 @@ def horizon_cut(self, horizon=None, sampling="mw", nside=None): if horizon is None: horizon = jnp.ones_like(m) theta = s2_samples.thetas( - L=self.lmax+1, sampling=sampling, nside=nside + L=self.lmax + 1, sampling=sampling, nside=nside ) - horizon.at[..., theta > jnp.pi / 2].set(0.) + horizon.at[..., theta > jnp.pi / 2].set(0.0) m = m * horizon self.alm = jax.vmap( partial( s2fft.forward_jax, - L=self.lmax+1, + L=self.lmax + 1, spin=0, nside=nside, reality=self.is_real, precomps=None, spmd=False, - L_lower=0 - )(m) + L_lower=0, + ) + )(m) diff --git a/croissant/crojax/healpix.py b/croissant/crojax/healpix.py index 7b139bd..44692ce 100644 --- a/croissant/crojax/healpix.py +++ b/croissant/crojax/healpix.py @@ -72,7 +72,9 @@ def zeros(cls, lmax, frequencies=None, coord=None): """ Construct an Alm object with all zero coefficients. """ - alm = jnp.zeros(alm_shape(lmax, nfreq=jnp.size(frequencies))) + alm = jnp.zeros( + alm_shape(lmax, nfreq=jnp.size(frequencies)), dtype=jnp.complex128 + ) obj = cls( alm=alm, frequencies=frequencies, @@ -86,10 +88,10 @@ def is_real(self): Check if the coefficients correspond to a real-valued signal. Mathematically, this means that alm(l, m) = (-1)^m * conj(alm(l, -m)). """ - emm = jnp.arange(-self.lmax, self.lmax + 1)[None, None, :] + emm = jnp.arange(1, self.lmax + 1)[None, None, :] # positive ms neg_m = self.alm[:, :, : self.lmax] # alms for m < 0 pos_m = self.alm[:, :, self.lmax + 1 :] # alms for m > 0 - return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)) + return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)).item() def reduce_lmax(self, new_lmax): """ @@ -154,7 +156,7 @@ def getidx(self, ell, emm): The l index (which is the same as the input ell). m_ix : int The m index. - + Raises ------ IndexError @@ -166,22 +168,26 @@ def getidx(self, ell, emm): m_ix = emm + self.lmax return l_ix, m_ix - def hp_map(self, nside, frequencies=None): + def alm2map(self, sampling="healpix", nside=None, frequencies=None): """ Construct a Healpix map from the Alm for the given frequencies. Parameters ---------- + sampling : str + Sampling scheme on the sphere. Must be in + {"mw", "mwss", "dh", "healpix"}. Gets passed to s2fft.inverse. nside : int - The nside of the Healpix map to construct. - frequencies : array_like + The nside of the Healpix map to construct. Required if sampling + is "healpix". + frequencies : jnp.ndarray The frequencies to construct the map for. If None, the map will be constructed for all frequencies. Returns ------- - m : np.ndarray - The Healpix map(s) (shape = (Nfreq, 12 * nside ** 2)). + m : jnp.ndarray + The map(s) corresponding to the alm. """ if frequencies is None: @@ -197,17 +203,19 @@ def hp_map(self, nside, frequencies=None): UserWarning, ) alm = self.alm[indices] - alm2map = partial( - s2fft.inverse_jax, - L=self.lmax + 1, - spin=0, - nside=nside, - reality=self.is_real, - precomps=None, - spmd=False, - L_lower=None, - ) - m = jax.vamp(alm2map(alm)) + m = jax.vmap( + partial( + s2fft.inverse_jax, + L=self.lmax + 1, + spin=0, + nside=nside, + sampling=sampling, + reality=self.is_real, + precomps=None, + spmd=False, + L_lower=0, + ) + )(alm) return m def rot_alm_z(self, phi=None, times=None, world="moon"): From aa8ac5b1ac369fb13c456fa934dbeb739400ca07 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 6 Sep 2023 15:57:43 -0700 Subject: [PATCH 029/129] import beam in init --- croissant/crojax/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/croissant/crojax/__init__.py b/croissant/crojax/__init__.py index 663cb04..1b16e76 100644 --- a/croissant/crojax/__init__.py +++ b/croissant/crojax/__init__.py @@ -3,4 +3,5 @@ config.update("jax_enable_x64", True) +from .beam import Beam from .healpix import Alm From 25f341cb8d6a3605a4ef1720bfc00f257d596a36 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 6 Sep 2023 16:23:30 -0700 Subject: [PATCH 030/129] fix imports and axis order in horizon --- croissant/crojax/beam.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/croissant/crojax/beam.py b/croissant/crojax/beam.py index 41b9e25..a763320 100644 --- a/croissant/crojax/beam.py +++ b/croissant/crojax/beam.py @@ -1,5 +1,7 @@ +from functools import partial +import jax import jax.numpy as jnp -from s2fft.sampling import s2_samples +import s2fft from healpy import get_nside from ..constants import Y00 @@ -48,10 +50,10 @@ def horizon_cut(self, horizon=None, sampling="mw", nside=None): m = self.alm2map(sampling=sampling, nside=nside) if horizon is None: horizon = jnp.ones_like(m) - theta = s2_samples.thetas( + theta = s2fft.sampling.s2_samples.thetas( L=self.lmax + 1, sampling=sampling, nside=nside ) - horizon.at[..., theta > jnp.pi / 2].set(0.0) + horizon.at[:, theta > jnp.pi / 2].set(0.0) m = m * horizon self.alm = jax.vmap( From 4f83999ddcf78b22369fc2474e2e744b0b31946b Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 6 Sep 2023 16:23:44 -0700 Subject: [PATCH 031/129] update flake8 config --- setup.cfg | 2 ++ 1 file changed, 2 insertions(+) diff --git a/setup.cfg b/setup.cfg index ae71c1a..a6b801d 100644 --- a/setup.cfg +++ b/setup.cfg @@ -46,4 +46,6 @@ hera_sim = ignore = E203, W503 per-file-ignores = __init__.py:F401 + croissant/core/__init__.py:F401 + croissant/crojax/__init__.py:E402, F401 max-line-length = 79 From ba82e5a3e4f2998d3939212a24dc24283d8441a2 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 6 Sep 2023 17:59:39 -0700 Subject: [PATCH 032/129] syntax error --- croissant/crojax/beam.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/croissant/crojax/beam.py b/croissant/crojax/beam.py index a763320..c33d731 100644 --- a/croissant/crojax/beam.py +++ b/croissant/crojax/beam.py @@ -53,7 +53,7 @@ def horizon_cut(self, horizon=None, sampling="mw", nside=None): theta = s2fft.sampling.s2_samples.thetas( L=self.lmax + 1, sampling=sampling, nside=nside ) - horizon.at[:, theta > jnp.pi / 2].set(0.0) + horizon = horizon.at[:, theta > jnp.pi / 2].set(0.0) m = m * horizon self.alm = jax.vmap( From 9421833f372fa10734b6e5e12692d599f4812884 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 6 Sep 2023 17:59:59 -0700 Subject: [PATCH 033/129] remove almshape since s2fft has the same function --- croissant/crojax/healpix.py | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/croissant/crojax/healpix.py b/croissant/crojax/healpix.py index 44692ce..3384404 100644 --- a/croissant/crojax/healpix.py +++ b/croissant/crojax/healpix.py @@ -6,13 +6,6 @@ from .. import constants, utils -def alm_shape(lmax, nfreq=1): - """ - Get the shape of the alm array for a given lmax and number of frequencies. - """ - return (nfreq, lmax + 1, 2 * lmax + 1) - - def lmax_from_shape(shape): """ Get the lmax from the shape of the alm array. @@ -72,9 +65,9 @@ def zeros(cls, lmax, frequencies=None, coord=None): """ Construct an Alm object with all zero coefficients. """ - alm = jnp.zeros( - alm_shape(lmax, nfreq=jnp.size(frequencies)), dtype=jnp.complex128 - ) + s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) + shape = (jnp.size(frequencies), s1, s2) + alm = jnp.zeros(shape, dtype=jnp.complex128) obj = cls( alm=alm, frequencies=frequencies, From 436bccb49639607bbed6a8d74b0cc94fa2dd4deb Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 6 Sep 2023 18:02:52 -0700 Subject: [PATCH 034/129] initial commit --- croissant/crojax/tests/test_beam.py | 67 +++++++++ croissant/crojax/tests/test_healpix.py | 195 +++++++++++++++++++++++++ 2 files changed, 262 insertions(+) create mode 100644 croissant/crojax/tests/test_beam.py create mode 100644 croissant/crojax/tests/test_healpix.py diff --git a/croissant/crojax/tests/test_beam.py b/croissant/crojax/tests/test_beam.py new file mode 100644 index 0000000..149348b --- /dev/null +++ b/croissant/crojax/tests/test_beam.py @@ -0,0 +1,67 @@ +from copy import deepcopy +import pytest +import jax.numpy as jnp +from s2fft.sampling import s2_samples +from croissant.constants import Y00 +from croissant.crojax import Beam + +frequencies = jnp.linspace(1, 50, 50) +lmax = 32 + + +def test_compute_total_power(): + # make a beam that is 1 everywhere so total power is 4pi: + beam = Beam.zeros(lmax) + beam[0, 0, 0] = 1 / Y00 + beam.compute_total_power() + assert jnp.allclose(beam.total_power, 4 * jnp.pi) + + # beam(theta) = cos(theta)**2 * freq**2 + beam = Beam.zeros(lmax, frequencies=frequencies) + beam[:, 0, 0] = 1 / (3 * Y00) * frequencies**2 + beam[:, 2, 0] = 4 * jnp.sqrt(jnp.pi / 5) * 1 / 3 * frequencies**2 + beam.compute_total_power() + power = beam.total_power + expected_power = 4 * jnp.pi / 3 * frequencies**2 + assert jnp.allclose(power, expected_power.ravel()) + + +def test_horizon_cut(): + # make a beam that is 1 everywhere + beam_base = Beam.zeros(lmax) + beam_base[0, 0, 0] = 1 / Y00 + + # default horizon (1 frequency) + beam = deepcopy(beam_base) + beam.horizon_cut() # doesn't throw error + + # default horizon (multiple frequencies) + beam_nf = Beam.zeros(lmax, frequencies=frequencies) + beam[:, 0, 0] = 1 / Y00 + beam_nf.horizon_cut() # doesn't throw error + assert jnp.allclose(beam_nf.alm, beam.alm) + + # try custom horizon + beam = deepcopy(beam_base) + ntheta, nphi = s2_samples.f_shape(lmax + 1, sampling="mw") + horizon = jnp.ones((1, ntheta, nphi)) # no horizon + beam_map = beam.alm2map(sampling="mw") # before horizon cut + beam.horizon_cut(horizon=horizon, sampling="mw") + # should be the same before and after since the horizon is all 1s + assert jnp.allclose(beam_map, beam.alm2map(sampling="mw")) + + beam = deepcopy(beam_base) + horizon = jnp.zeros((1, ntheta, nphi)) # full horizon + beam.horizon_cut(horizon=horizon, sampling="mw") + # should be all zeros since the horizon is all 0s + assert jnp.allclose(beam.alm2map(sampling="mw"), 0) + + # try horizon with invalid values + horizon = jnp.ones((1, ntheta, nphi)) + horizon = horizon.at[0, 0, 0].set(2.0) # invalid value + with pytest.raises(ValueError): + beam.horizon_cut(horizon=horizon, sampling="mw") + horizon = jnp.ones((1, ntheta, nphi)) + horizon = horizon.at[0, 0, 0].set(-1.0) # invalid value + with pytest.raises(ValueError): + beam.horizon_cut(horizon=horizon, sampling="mw") diff --git a/croissant/crojax/tests/test_healpix.py b/croissant/crojax/tests/test_healpix.py new file mode 100644 index 0000000..6ed5261 --- /dev/null +++ b/croissant/crojax/tests/test_healpix.py @@ -0,0 +1,195 @@ +from copy import deepcopy +import pytest +from np.random import default_rng +import jax.numpy as jnp +import s2fft +from croissant.crojax import healpix as hp +from croissant.constants import sidereal_day_earth, sidereal_day_moon, Y00 + +pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) +rng = default_rng(1913) +freqs = jnp.linspace(1, 50, 50) +nfreqs = freqs.size + + +def test_lmax_from_shape(lmax): + shape = s2fft.sampling.s2_samples.flm_shape(lmax + 1) + _lmax = hp.lmax_from_shape(shape) + assert _lmax == lmax + + +def test_alm_indexing(lmax): + # initialize all alms to 0 + alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) + # set a00 = 1 for first half of frequencies + alm[: nfreqs // 2, 0, 0] = 1.0 + # check __setitem__ acted correctly on alm.alm + assert jnp.allclose(alm.alm[: nfreqs // 2, 0], 1) + assert jnp.allclose(alm.alm[nfreqs // 2 :, 0], 0) + assert jnp.allclose(alm.alm[:, 1:], 0) + # check that __getitem__ agrees: + assert jnp.allclose(alm[: nfreqs // 2, 0, 0], 1) + assert jnp.allclose(alm[nfreqs // 2 :, 0, 0], 0) + # __getitem__ can't get multiple l-modes or m-modes at once... + for ell in range(1, lmax + 1): + for emm in range(-ell, ell + 1): + assert jnp.allclose(alm[:, ell, emm], 0) + + # set everything back to 0 + alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) + # negative indexing + val = 3.0 + 2.3j + alm[-1, 10, 7] = val + assert alm[-1, 10, 7] == val + l_ix, m_ix = alm.getidx(10, 7) + assert alm[-1, 10, 7] == alm.alm[-1, l_ix, m_ix] + + # frequency index not specified + with pytest.raises(IndexError): + alm[3, 2] = 5 + alm[7, -1] + + +def test_zeros(lmax): + alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) + assert alm.lmax == lmax + assert alm.frequencies is freqs + assert alm.alm.shape == s2fft.sampling.s2_samples.flm_shape(lmax + 1) + assert jnp.allclose(alm.alm, 0) + + +def test_is_real(lmax): + alm = hp.Alm.zeros(lmax=lmax) + assert alm.is_real + val = 1.0 + 2.0j + alm[0, 2, 1] = val # set l=2, m=1 mode but not m=-1 mode + assert not alm.is_real + alm[0, 2, -1] = -1 * val.conj() # set m=-1 mode to complex conjugate + assert alm.is_real + + # generate a real signal and check that alm.is_real is True + alm = hp.Alm( + s2fft.utils.signal_generator.generate_flm(rng, lmax, reality=True) + ) + assert alm.is_real + # complex + alm = hp.Alm( + s2fft.utils.signal_generator.generate_flm(rng, lmax, reality=False) + ) + assert not alm.is_real + + +def test_reduce_lmax(lmax): + alm = hp.Alm(s2fft.utils.signal_generator.generate_flm(rng, lmax)) + old_alm = deepcopy(alm) + # reduce to same lmax, should do nothing + alm.reduce_lmax(lmax) + assert alm.lmax == lmax + assert jnp.allclose(alm.alm, old_alm.alm) + # reduce to new lmax + new_lmax = 5 + alm.reduce_lmax(new_lmax) + assert alm.lmax == new_lmax + assert alm.alm.shape == s2fft.sampling.s2_samples.flm_shape(new_lmax + 1) + for ell in range(new_lmax + 1): + for emm in range(-ell, ell + 1): + assert alm[:, ell, emm] == old_alm[:, ell, emm] + with pytest.raises(IndexError): + alm[:, 7, 0] # asking for ell > new_lmax should raise error + # try to reduce to greater lmax + new_lmax = 200 + with pytest.raises(ValueError): + alm.reduce_lmax(new_lmax) + + +@pytest.mark.skip(reason="not implemented") +def test_getidx(lmax): + alm = hp.Alm.zeros(lmax=lmax) + ell = 3 + emm = 2 + bad_ell = 2 * lmax # bigger than lmax + bad_emm = 4 # bigger than ell + with pytest.raises(IndexError): + alm.getidx(bad_ell, emm) + alm.getidx(ell, bad_emm) + alm.getidx(-ell, emm) # should fail since l < 0 + + # try convert back and forth ell, emm <-> index + ix = alm.getidx(ell, emm) + ell_, emm_ = alm.getlm(i=ix) + assert ell == ell_ + assert emm == emm_ + + +@pytest.mark.skip(reason="not implemented") +def test_alm2map(): + # make constant map + lmax = 10 + alm = hp.Alm.zeros(lmax=lmax) + a00 = 5 + alm[0, 0, 0] = a00 + hp_map = alm.alm2map() # use different samplings i guess ... + assert jnp.allclose(hp_map, a00 * Y00) + + # make many maps + frequencies = jnp.linspace(1, 50, 50) + alm = hp.Alm.zeros(lmax=lmax, frequencies=frequencies) + alm[:, 0, 0] = a00 * frequencies + hp_map = alm.alm2map() # XXX + assert jnp.allclose(hp_map, a00 * Y00) + + # use subset of frequencies and compare to full set + alm = hp.Alm.zeros(lmax=lmax, frequencies=frequencies) + # some random map + alm[:, 0, 0] = a00 * frequencies + alm[:, 1, 1] = 2 * a00 * frequencies + alm[::2, 8, 3] = -3 * a00 * frequencies[::2] + hp_map = alm.alm2map() # XXX + freq_indices = [10, 20, 35] # indices of frequencies to use + freqs = frequencies[freq_indices] # frequencies to use + hp_map_select = alm.alm2map(frequencies=freqs) # XXX + assert jnp.allclose(hp_map_select, hp_map[freq_indices]) + + # use some frequencies that are not in alm.frequencies + with pytest.warns(UserWarning): + alm.alm2map(frequencies=[0, 30, 100]) # XXX + + +@pytest.mark.skip(reason="not implemented") +def test_rot_alm_z(lmax): + alm = hp.Alm.zeros(lmax=lmax) + + # rotate a single angle + phi = jnp.pi / 2 + phase = alm.rot_alm_z(phi=phi) + for ell in range(lmax + 1): + for emm in range(ell + 1): + ix = alm.getidx(ell, emm) + assert jnp.isclose(phase[ix], jnp.exp(-1j * emm * phi)) + + # rotate a set of angles + phi = jnp.linspace(0, 2 * jnp.pi, num=361) # 1 deg spacing + phase = alm.rot_alm_z(phi=phi) + for ell in range(lmax + 1): + for emm in range(ell + 1): + ix = alm.getidx(ell, emm) + assert jnp.allclose(phase[:, ix], jnp.exp(-1j * emm * phi)) + + # check that phi = 0 and phi = 2pi give the same answer + assert jnp.allclose(phase[0], phase[-1]) + + # rotate in time + alm = hp.Alm.zeros(lmax=lmax) + div = [1, 2, 4, 8] + for d in div: + dphi = 2 * jnp.pi / d + # earth + dt = sidereal_day_earth / d + assert jnp.allclose( + alm.rot_alm_z(times=dt, world="earth"), alm.rot_alm_z(phi=dphi) + ) + # moon + dt = sidereal_day_moon / d + assert jnp.allclose( + alm.rot_alm_z(times=dt, world="moon"), alm.rot_alm_z(phi=dphi) + ) From 667c53f6e8b3ba694990f9d2f1d422d50211b8f2 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 6 Sep 2023 18:03:13 -0700 Subject: [PATCH 035/129] update jax nb --- notebooks/jax_example.ipynb | 88 +++++++++++++++++++++++++------------ 1 file changed, 60 insertions(+), 28 deletions(-) diff --git a/notebooks/jax_example.ipynb b/notebooks/jax_example.ipynb index 6a49168..3ec6b11 100644 --- a/notebooks/jax_example.ipynb +++ b/notebooks/jax_example.ipynb @@ -11,7 +11,7 @@ "import jax.numpy as jnp\n", "jax.config.update(\"jax_enable_x64\", True)\n", "import matplotlib.pyplot as plt\n", - "%matplotlib notebook\n", + "%matplotlib inline\n", "import s2fft\n", "from croissant import crojax" ] @@ -28,56 +28,88 @@ "text": [ "No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "(41, 129, 257)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgsAAAGhCAYAAADvMPfbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAx7klEQVR4nO3de3DV5Z3H8c8JkoQiSQxILhowWrYoIKhoGnFdXDJCihQKVnGz0xQdaBEUjKuYjlykaJR2bYZLoTo7qDOg1emC1l3pYBAYNAYSTOsVwWaBVU5oxXAgNBfO79k/gLM9EM7h8Dv55fc7eb9mnhnzuz7nIfH5nufqM8YYAQAAnENSV2cAAAC4G8ECAACIiGABAABERLAAAAAiIlgAAAARESwAAICICBYAAEBEBAsAACAiggUAABARwQIAAIioS4OFlStX6oorrlBqaqoKCgq0Y8eOrswOAADoQJcFC7/97W9VVlamhQsXateuXRo+fLjGjh2rQ4cOdVWWAABAB3xdtZFUQUGBbrzxRq1YsUKSZFmW8vLy9MADD+ixxx6LeK9lWfrqq6/Up08f+Xw+J7ILAPAoY4yOHj2q3NxcJSV13nfklpYWtbW12X5OcnKyUlNT45Cj+LmoK17a1tamuro6lZeXh44lJSWpqKhI1dXVZ13f2tqq1tbW0M9ffvmlrrnmGkfyCgBIDAcOHNDll1/eKc9uaWlR/sCL5T8UtP2s7OxsNTQ0uCpg6JJg4a9//auCwaCysrLCjmdlZemzzz476/qKigo98cQTZx3ft+sKpV3MGE0AwLkFjlkaeP3/qE+fPp32jra2NvkPBdVQN1BpfS68XgoctZR/wz61tbURLMSqvLxcZWVloZ8DgYDy8vKUdnGSrX8UAED34US3dVqfxKyXuiRY6Nevn3r06KHGxsaw442NjcrOzj7r+pSUFKWkpDiVPQAALkjQWAraGAkYNFb8MhNHXRL+JCcn64YbblBVVVXomGVZqqqqUmFhYVdkCQAA2ywZ28mNuqwboqysTKWlpRo5cqRuuukmVVZWqrm5WdOmTeuqLAEAYIslS3baBuzd3Xm6LFi4++679Ze//EULFiyQ3+/XiBEjtHHjxrMGPQIAgK7VpQMcZ8+erdmzZ3dlFgAAiJugMQraWL7Izr2dyROzIQAA8AK74w7cOmYh8eZ3AACAuKJlAQCAOLFkFEzAlgWCBQAA4oRuCAAA0C3RsgAAQJwwG8KF7C6rCQBIfE4uoWydSnbudyO6IQAAQESeblkAAMBNgjZnQ9i5tzMRLAAAECdBI5u7TsYvL/FEsAAAQJwwZgEAAHRLnm5ZcPPe3wAAd3CynrDkU1A+W/e7kaeDBQAA3MQyJ5Od+92IbggAABARLQsAAMRJ0GY3hJ17OxPBAgAAcUKw4EKWLNdOMwEAuAM1hX2eDhYAAHATy/hkGRuzIWzc25kIFgAAiBO6IVzI7lagAIDERz1hn6eDBQAA3CSoJAVtrEoQjGNe4olgAQCAODE2xywYxiwAAJDYGLPgQkydBABEQ01hn6eDBQAA3CRokhQ0NsYsuHQsJsECAABxYskny8YAR7fupOzpYCEoo6BLCxYA4A7UE/Z5OlgAAMBNGOAIAAAisj9mwZ2tIJ4OFowxslxasAAAdzDUE7Z5OlgAAMBNTg5wtLGRFN0QAAAkNsvmcs/MhugEzIYAAERDPWGfp4MFAADchAGOLmSdSgAAnIuT9YSlJBZlAgAA5xY0PgVt7Bxp597O5OlgIWiMa5tsAADuQD1hn6eDBQAA3CRoczaEWwdjXvgnAgAAYSyTZDvFYtu2bZowYYJyc3Pl8/m0YcOG0Ln29nbNmzdPw4YNU+/evZWbm6sf/ehH+uqrr2L+XJ5uWQieSgAAnEsi1xPNzc0aPny47r33Xk2ePDns3PHjx7Vr1y7Nnz9fw4cP1zfffKM5c+bo+9//vmpra2N6j6eDBQAA3MTpboji4mIVFxd3eC49PV2bNm0KO7ZixQrddNNN2r9/vwYMGHDe7/F0sMDUSQBANM5OnbQ3o+F0XgOBQNjxlJQUpaSkXHjGTjly5Ih8Pp8yMjJiuo8xCwAAuExeXp7S09NDqaKiwvYzW1paNG/ePN1zzz1KS0uL6V5PtywAAOAm9hdlOnnvgQMHwip0u60K7e3tuuuuu2SM0apVq2K+39PBQtCcTAAAnIuT9YT95Z5P3puWlhbzt/9zOR0o7Nu3T5s3b76g58a9G6KiokI33nij+vTpo/79+2vSpEnavXt32DUtLS2aNWuW+vbtq4svvlhTpkxRY2NjzO8y+v9xCyQSiUQidZS683fK04HCnj179Pbbb6tv374X9Jy4Bwtbt27VrFmz9P7772vTpk1qb2/X7bffrubm5tA1Dz30kH7/+9/rtdde09atW/XVV1+dNeUDAACvseSznWJx7Ngx1dfXq76+XpLU0NCg+vp67d+/X+3t7brzzjtVW1urtWvXKhgMyu/3y+/3q62tLab3+Izp3HUw//KXv6h///7aunWrbr31Vh05ckSXXnqp1q1bpzvvvFOS9Nlnn+nqq69WdXW1vvvd70Z9ZiAQUHp6unZ+nKWL+zBGEwBwbseOWrpxSKOOHDkSt6b9M52ul35Ve7N6XXzhPfx/O3ZCD41877zzumXLFt12221nHS8tLdWiRYuUn5/f4X3vvPOORo8efd756vQxC0eOHJEkZWZmSpLq6urU3t6uoqKi0DWDBw/WgAEDzhkstLa2qrW1NfTzmVNKAABwA/vrLMR27+jRoxXpO3+82gM69Wu5ZVmaO3euRo0apaFDh0qS/H6/kpOTz5rjmZWVJb/f3+FzKioqwqaQ5OXldWa2AQDA3+nUloVZs2bpo48+0vbt2209p7y8XGVlZaGfA4GA8vLybG8FCgBIfE7WE5bxybKzKJNL67ROCxZmz56tN998U9u2bdPll18eOp6dna22tjY1NTWFtS40NjYqOzu7w2eda+WqCxkMAgDoXpysJyyb3RB21mjoTHHPlTFGs2fP1vr167V58+azBlfccMMN6tmzp6qqqkLHdu/erf3796uwsDDe2QEAADbFvWVh1qxZWrdunV5//XX16dMnNA4hPT1dvXr1Unp6uu677z6VlZUpMzNTaWlpeuCBB1RYWHheMyH+XlA+BWlZAABE4GQ9cSHbTJ95vxvFPVg4vYzkmVMy1qxZox//+MeSpF/96ldKSkrSlClT1NraqrFjx+rXv/51vLMCAICj7H6JdesX4LgHC+czTSM1NVUrV67UypUrbb3L7kASAEDio56wz9t7Q9ANAQCIgm4I+zwdLAAA4CZB2QtOgvHLSlx5OliwaFkAAETBFHv7PB0sAADgJnRDuJDdfxQAQOKzHNyjOmiSFLRRL9m5tzN5OlgAAMBNjM2VhY1Lu0w8HSwwGwIAEA31hH0eDxbsrcENAEh8Ts4woBsCAABExK6TLnTyH8WdURgAwB2s81hZGJF5OlhgzAIAIBon6wm73eNu7Vr3dLAAAICb0A3hQnYHkgAAEl+QbgjbPB0sGCXJcmmTDQDAHYycCxYsm/WSW+s0TwcLjFkAAETj6JgF41PQRleCnXs7kztDGAAA4BrebllgzAIAIAonxywwwNGF7PYNAQASn+XgmAVjc4ND49IvwJ4OFgAAcBO7Y+ncOg7P08EC3RAAgGiYOmmft4MFZkMAAKJwsp6wjL1xB5ZL4xpPBwsAALiJZXPMglv3O/J0sGDJ3j8KACDxOTnAMVF5PFjwuXbTDQCAO1iyHHyXT5aNbg8793YmTwcLdlfKAgAkPifrCVZwBAAA3ZKnWxbazUW6yHj6IwAAOlm7g0MWGOAIAAAismRzuWfGLMRfUEkMcAQAREQ9YZ+ngwW7G3YAABKfk/WEsTkbwtCyAABAYmPXSReiGwIAEI2T9QQDHF3I7lagAIDE59Ztn73E08ECG0kBAKJxdiMpuiFcx25zDwAg8TlZT7DcswvRsgAAiIZ6wj5PBwsAALgJ3RAudPIfhW4IAMC5OVkBEyy4UNAkKUiwAACIgHrCPk8HC3YHkgAAEp+T9QQtCy5k0bIAAIjC0dkQBAvuQ8sCACAa6gn7PB0sAADgJkb2ghMTv6zElaeDhXarh5KsHl2dDQCAi7VblmPvohsCAABERLDgQuw6CQCIhnrCPk8HC3YjOABA4mNRJvs6PVh4+umnVV5erjlz5qiyslKS1NLSoocfflivvPKKWltbNXbsWP36179WVlZWTM8mWAAAREOwYF+nBgs7d+7Ub37zG1177bVhxx966CH913/9l1577TWlp6dr9uzZmjx5st59992Ynm/RDQEAiMKinrCt04KFY8eOqaSkRM8//7yWLFkSOn7kyBH9x3/8h9atW6d//ud/liStWbNGV199td5//31997vfPe930LIAAIjGyXrCGJ+MjffZubczdVq4NWvWLI0fP15FRUVhx+vq6tTe3h52fPDgwRowYICqq6s7fFZra6sCgUBYAgDAbU4vFmgnuVGntCy88sor2rVrl3bu3HnWOb/fr+TkZGVkZIQdz8rKkt/v7/B5FRUVeuKJJ846bpkkdp0EAEREPWFf3IOFAwcOaM6cOdq0aZNSU1Pj8szy8nKVlZWFfg4EAsrLy1O78cnHLwEAIIJ2BjjaFvdgoa6uTocOHdL1118fOhYMBrVt2zatWLFCf/jDH9TW1qampqaw1oXGxkZlZ2d3+MyUlBSlpKTEO6sAAMRVoo5ZiHuwMGbMGH344Ydhx6ZNm6bBgwdr3rx5ysvLU8+ePVVVVaUpU6ZIknbv3q39+/ersLAwpnfRDQEAiIZ6wr64Bwt9+vTR0KFDw4717t1bffv2DR2/7777VFZWpszMTKWlpemBBx5QYWFhTDMhJGZDAACiY50F+7pkBcdf/epXSkpK0pQpU8IWZYqVm0eOAgDcwcl6gm4IG7Zs2RL2c2pqqlauXKmVK1faeq4ln4IuLVgAgDs4HSzYaR2INVjYtm2bfvGLX6iurk4HDx7U+vXrNWnSpL97ntHChQv1/PPPq6mpSaNGjdKqVas0aNCgmN7j8b0hGLMAAIgskeuJ5uZmDR8+XPfee68mT5581vmlS5dq2bJlevHFF5Wfn6/58+dr7Nix+uSTT2KasejxYIExCwCAyBxdwVGSMfbuj0VxcbGKi4s7fpYxqqys1OOPP66JEydKkl566SVlZWVpw4YNmjp16nm/x9vBAmMWAABROFlPWPLJZ+N9p/N65krFF7KEQENDg/x+f9iKyenp6SooKFB1dXU3ChZoWQAAROHFeiIvLy/s54ULF2rRokUxPeP0qshn7ugcacXkcyFYAAAkNC9uJHXgwAGlpaWFjnf1woQECwCAhOb0Ogu+OKyzkJaWFhYsXIjTqyI3NjYqJycndLyxsVEjRoyI6VkeDxaYDQEAiKy71hP5+fnKzs5WVVVVKDgIBAKqqanRzJkzY3qWt4MFBjgCAKJwdp0Fm7MhYrz32LFj2rt3b+jnhoYG1dfXKzMzUwMGDNDcuXO1ZMkSDRo0KDR1Mjc3N2wthvPh7WCBbggAQBReHLNwvmpra3XbbbeFfj69Q3NpaaleeOEFPfroo2pubtaMGTPU1NSkW265RRs3box5V2hPBwvGeHOUKwDAOXa+6bvd6NGjZSJ8QJ/Pp8WLF2vx4sW23uPpYIGWBQBANIncsuAUTwcLdv9RAACJz8l6Il6zIdzG08ECAxwBANEk8gBHp3g7WKAbAgAQBfWEfQQLAICE5uyYBXvdHrQsdALGLAAAonGynmCAowvRsgAAiIZ6wj6CBQBAQnO0G+JUsnO/G3k6WLD7jwIASHxO1hN0Q7iQoWUBABCFWytgL/F8sMAvAQAgEkfriQTth/B0sGDJ3kpZAIDE5+jifXa/xLq0TvN0sEDLAgAgGmenTrKCo+tYRvK5tGABAO5gUU/Y5ulggZYFAEA0LMpkH8ECACChOTvA0Wdv3IFL6zRPBwt2twIFACQ+ptjb5+lggUWZAADROLsoEwMcXceykuSzkro6GwAAF7OcrCcSdJ0FaloAABCRp1sW7Db3AAASn5P1BLMhXMiyfHRDAAAisiyHK+AE/BJLTQsAACLydMsC3RAAgGjohrDP28GC5XO+eQkA4CnGyXoiQWdDeDpYAADAXXynkp373cfTwYKxkmQY4AgAiIB6wj5vBwtybYsNAMAlHK0n6IZwIbsbdgAAEp+jG0mJYMFtmA0BAIiGesI+TwcL9EMAAKJydCcptqh2HSN781kBAInPODjDgF0n3YiWBQBANNQTtnk8WGCAIwAgCgY42ubpYIEBjgCAaBytJxiz4EKW72QCAOBcqCds65Rlrb788kv967/+q/r27atevXpp2LBhqq2tDZ03xmjBggXKyclRr169VFRUpD179sT+IkMikUgk0nkkh/iM/eRGcQ8WvvnmG40aNUo9e/bUW2+9pU8++UT//u//rksuuSR0zdKlS7Vs2TKtXr1aNTU16t27t8aOHauWlpZ4ZwcAAOd4KLCJRdy7IZ555hnl5eVpzZo1oWP5+fmh/zbGqLKyUo8//rgmTpwoSXrppZeUlZWlDRs2aOrUqef/MrohAADROLrrZGKOWYh7y8Ibb7yhkSNH6oc//KH69++v6667Ts8//3zofENDg/x+v4qKikLH0tPTVVBQoOrq6g6f2draqkAgEJYkdX2zFolEIpG8kWBL3FsW/vznP2vVqlUqKyvTz372M+3cuVMPPvigkpOTVVpaKr/fL0nKysoKuy8rKyt07kwVFRV64oknzj7B1EkAQDRMnbQt7i0LlmXp+uuv11NPPaXrrrtOM2bM0PTp07V69eoLfmZ5ebmOHDkSSgcOHIhjjgEAiJMEbQWJe8tCTk6OrrnmmrBjV199tX73u99JkrKzsyVJjY2NysnJCV3T2NioESNGdPjMlJQUpaSknH3CxQULAHAJ6gnb4h4sjBo1Srt37w479vnnn2vgwIGSTg52zM7OVlVVVSg4CAQCqqmp0cyZM2N7GcECACAaJ+uJBO2GiHuw8NBDD+nmm2/WU089pbvuuks7duzQc889p+eee06S5PP5NHfuXC1ZskSDBg1Sfn6+5s+fr9zcXE2aNCmmd/ksn3zMhgAAROBoPZGgsyHiHizceOONWr9+vcrLy7V48WLl5+ersrJSJSUloWseffRRNTc3a8aMGWpqatItt9yijRs3KjU1Nd7ZAQAANnXKcs933HGH7rjjjnOe9/l8Wrx4sRYvXmzvRXRDAACicbCesLsKo1tXcGRvCABAYnO0G0IJOWahU/aGAAAAicPTLQs+I/msrs4FAMDN3Nq07yWeDhYYswAAiMrJMQuyOWYhbjmJL08HC27ezhMA4A6O1hNMnXQhWhYAANFQT9jm8WCBjaQAAFGwkZRtng4W6IYAAETjbDeECBZch24IAEA01BO2ESwAABIbKzja5ulgwSf3TjMBALiDo/UE3RAuZJ1KAACcC/WEbZ4OFhjgCACIhgGO9nk6WAAAwE0Ys+BGdEMAAKKhnrDN28EC3RAAgGhY7tk2jwcLrOAIAIiCFRxt83SwwABHAEA0TtYTiTpmIamrM2CLIZFIJBLpPFKCCgaDmj9/vvLz89WrVy9dddVV+vnPfy5j4vuhPd2yICmhfwkAAB5jNziJ8d5nnnlGq1at0osvvqghQ4aotrZW06ZNU3p6uh588EEbGQnn6WDBZ51MAACci6P1hLHZlRDjve+9954mTpyo8ePHS5KuuOIKvfzyy9qxY4eNTJzN290QAAAkoEAgEJZaW1s7vO7mm29WVVWVPv/8c0nSH//4R23fvl3FxcVxzY+nWxYSvS8KABAHTtYTceqGyMvLCzu8cOFCLVq06KzLH3vsMQUCAQ0ePFg9evRQMBjUk08+qZKSEhuZOJungwW6IQAA0TjdDRGPYOHAgQNKS0sLHU5JSenw8ldffVVr167VunXrNGTIENXX12vu3LnKzc1VaWmpjYyE83SwAABAIkpLSwsLFs7lkUce0WOPPaapU6dKkoYNG6Z9+/apoqKCYOE01lkAAESTyOssHD9+XElJ4cMPe/ToIcuKb3OKp4MFxiwAAKJK4HpiwoQJevLJJzVgwAANGTJEH3zwgZ599lnde++9cX2Pt4MFAAC6seXLl2v+/Pm6//77dejQIeXm5uonP/mJFixYENf3eDpYYIAjACAaLw5wPF99+vRRZWWlKisrbbw0Ok8HC3RDAACiSuAxC07xdLDAAEcAQDSO1xMJWC95OligZQEAEBX1hG2eDhZoWQAARONoPeHwmAWneDpYoGUBABAVYxZsI1gAACQ26gnbPB0s0A0BAIiGbgj7PB0s0LIAAIiKbgjbPB0s+AyLMgEAInNrBewlng4WAABwFbohXIhuCABANIxZsM3TwYLPMvJZLi1ZAIArUE/Y5+lgAQAAN2GAowsxdRIAEA1TJ+3zdrDAFtUAgCgSeYtqpyR1dQYAAIC7ebplQdapBADAuThYTyTqmIW4tywEg0HNnz9f+fn56tWrl6666ir9/Oc/lzH/XwLGGC1YsEA5OTnq1auXioqKtGfPnpjfdfofhUQikUikSMkxJg7JheIeLDzzzDNatWqVVqxYoU8//VTPPPOMli5dquXLl4euWbp0qZYtW6bVq1erpqZGvXv31tixY9XS0hLv7AAAAJvi3g3x3nvvaeLEiRo/frwk6YorrtDLL7+sHTt2SDrZqlBZWanHH39cEydOlCS99NJLysrK0oYNGzR16tTzfhcDHAEA0ThZT9htyXC0FSQGcW9ZuPnmm1VVVaXPP/9ckvTHP/5R27dvV3FxsSSpoaFBfr9fRUVFoXvS09NVUFCg6urqDp/Z2tqqQCAQliTFp7mHRCKRSImfnOKlvMYg7i0Ljz32mAKBgAYPHqwePXooGAzqySefVElJiSTJ7/dLkrKyssLuy8rKCp07U0VFhZ544ol4ZxUAAJyHuAcLr776qtauXat169ZpyJAhqq+v19y5c5Wbm6vS0tILemZ5ebnKyspCPwcCAeXl5dENAQCIinUW7It7sPDII4/oscceC409GDZsmPbt26eKigqVlpYqOztbktTY2KicnJzQfY2NjRoxYkSHz0xJSVFKSspZx33GyGdcWrIAAFdwsp7wnUp27nejuI9ZOH78uJKSwh/bo0cPWdbJ0C4/P1/Z2dmqqqoKnQ8EAqqpqVFhYWG8swMAAGyKe8vChAkT9OSTT2rAgAEaMmSIPvjgAz377LO69957JUk+n09z587VkiVLNGjQIOXn52v+/PnKzc3VpEmTYnqXz9ANAQCIrEvWWbBzvwvFPVhYvny55s+fr/vvv1+HDh1Sbm6ufvKTn2jBggWhax599FE1NzdrxowZampq0i233KKNGzcqNTU1tpe5eOQoAMAlHKwnEnXqZNyDhT59+qiyslKVlZXnvMbn82nx4sVavHhxvF8PAEDXoWXBhZgNAQCIhnrCNk8HC46v+Q0A8BzH64kErJc8HSwAAOAmjFlwIZ9l5LNcWrIAAFegnrDP08ECAACuwgBHF2LqJAAgGqZO2ubpYIG9IQAA0VBP2OfpYAEAAFehG8J92EgKABCNoxtJ0Q3hQoxZAABEQz1hm6eDBcYsAACicbSeoBvChWhZAABEw66Ttnk6WGDMAgAgGsYs2OfpYIGWBQBAVNQTthEsAAASG90Qtnk6WGDXSQBANE7WE3a7x93atZ7U1RkAAADu5vGWBXadBABE5ui3dbohXMgyJxMAAOfiYD2RqLMh6IYAAAARebplgQGOAIBoHK0n6IZwIaZOAgCicXQ2RGJ2Q3g6WGAFRwBANNQT9nk6WKBlAQAQFd0Qtnk6WKBlAQAQDXtD2OfpYAEAAFehZcGFgkyHAABEEaSesMvbwQIAAC6TiN9hPR0ssM4CACAaZ9dZMCeTnftdyNPBgu1/FABA4qOesM3jwYJcOxgEAOASLMpkm7eDBQAA3ITZEO7jC1ry+ayuzgYAwMV8QeoJuzwdLAAA4CY+62Syc78beTpY8Mm9/TsAAHfwOfkyuiFciNkQAIBoqCds83awAACAizAbwo2MiBgBAJEl+KJMX375pebNm6e33npLx48f17e//W2tWbNGI0eOvPB8nMHbwYIlhzujAACe4+CgQadbFr755huNGjVKt912m9566y1deuml2rNnjy655JILz0QHPB0ssEU1ACCaRK4nnnnmGeXl5WnNmjWhY/n5+XF/j6eDBQY4AgCicrKeiNNsiEAgEHY4JSVFKSkpZ13+xhtvaOzYsfrhD3+orVu36rLLLtP999+v6dOn28jE2ZLi+jQAALqx090QdpIk5eXlKT09PZQqKio6fN+f//xnrVq1SoMGDdIf/vAHzZw5Uw8++KBefPHFuH4uWhYAAInNg/XEgQMHlJaWFvq5o1YFSbIsSyNHjtRTTz0lSbruuuv00UcfafXq1SotLY1bfrwdLDDAEQAQjZOrIsZpNkRaWlpYsHAuOTk5uuaaa8KOXX311frd73534XnogKeDBQY4AgCicbKecHo2xKhRo7R79+6wY59//rkGDhx44ZnoAGMWAADwqIceekjvv/++nnrqKe3du1fr1q3Tc889p1mzZsX1PZ5uWWDMAgAgKg/OhjhfN954o9avX6/y8nItXrxY+fn5qqysVElJiY1MnC3mloVt27ZpwoQJys3Nlc/n04YNG8LOG2O0YMEC5eTkqFevXioqKtKePXvCrjl8+LBKSkqUlpamjIwM3XfffTp27FjsuT8dLJBIJBKJFCk5JF6zIWJxxx136MMPP1RLS4s+/fTTuE+blC4gWGhubtbw4cO1cuXKDs8vXbpUy5Yt0+rVq1VTU6PevXtr7NixamlpCV1TUlKijz/+WJs2bdKbb76pbdu2acaMGRf+KQAAQKeJuRuiuLhYxcXFHZ4zxqiyslKPP/64Jk6cKEl66aWXlJWVpQ0bNmjq1Kn69NNPtXHjRu3cuTO0bvXy5cv1ve99T7/85S+Vm5t7/pmxLjAMAwB0H5aD9YRl7L3PybzGIK5jFhoaGuT3+1VUVBQ6lp6eroKCAlVXV2vq1Kmqrq5WRkZG2AYXRUVFSkpKUk1NjX7wgx+c9dzW1la1traGfg6tbOVw8xIAwIOcrCfMqWTnfheK62wIv98vScrKygo7npWVFTrn9/vVv3//sPMXXXSRMjMzQ9ecqaKiImwlq7y8vHhmGwCAuPDJ5piFrv4A5+CJ2RDl5eUqKysL/RwIBE4GDLQsAACioZ6wLa7BQnZ2tiSpsbFROTk5oeONjY0aMWJE6JpDhw6F3XfixAkdPnw4dP+ZzrWBBsECACAqR7shbNZLLq3T4hos5OfnKzs7W1VVVaHgIBAIqKamRjNnzpQkFRYWqqmpSXV1dbrhhhskSZs3b5ZlWSooKIjpfT5j5HPpYBAAgDsk8gqOTok5WDh27Jj27t0b+rmhoUH19fXKzMzUgAEDNHfuXC1ZskSDBg1Sfn6+5s+fr9zcXE2aNEnSyTWrx40bp+nTp2v16tVqb2/X7NmzNXXq1NhmQgAAAEfEHCzU1tbqtttuC/18eixBaWmpXnjhBT366KNqbm7WjBkz1NTUpFtuuUUbN25Uampq6J61a9dq9uzZGjNmjJKSkjRlyhQtW7Ys9tzTDQEAiIbZELbFHCyMHj1aJkLB+3w+LV68WIsXLz7nNZmZmVq3bl2srz4bwQIAIBpHuyHsbXDo1s0R2UgKAABE5Impk+dEywIAIBon6wnrVLJzvwt5O1gAAMBFErUbwtvBgmV3JAkAIOExxd42bwcLAAC4CbMhXIgxCwCAaFjB0TaCBQBAYmMFR9uYOgkAACLydsuCZeTaeSYAAHdwcoAj3RAAACASn3Uy2bnfjbwdLDBmAQAQDfWEbZ4OFowxEfepAADA0XqCbggAABAR6yy4ECs4AgCiYQVH27wdLAAA4CLsDeFGxjqZAAA4FyfriQQds8CiTAAAICKPtywwdRIAEIWjsyFkb61Al1Zp3g4WAABwEcYsuJExjHIFAETmdMuCrTELcctJXDFmAQAAROTtlgUAANwkQWdDeDtYMJbYdRIAEJGTUyctST6b97uQt4MFy0g+d0ZhAACXcOm3dS/xdrAAAICLMBsCAABExpgF9zHGyLh1ngkAwBUc3aI6QXk6WAAAwFVoWXAhy5J8Lh06CgBwBzaSso1FmQAAQETeblkAAMBNWGfBhYyRaxfSBgC4g4NN+0ydBAAAkTFmAQAAdEfebllgNgQAIBpH94awuQ2B5c6WBW8HCwAAuAndEAAAoDvydMuCMWK5ZwBARM5+WbfZsuDSOs3TwQIAAK5CNwQAAOiOvN2yYHfUKQAg8Tn5bd2yuVggsyEAAEhwxrI3VdPJaZ4xoBsCAABE5O2WBWPJtbtuAADcgS2qbfN2sAAAgJswZgEAAESUoC0LMY9Z2LZtmyZMmKDc3Fz5fD5t2LAhdK69vV3z5s3TsGHD1Lt3b+Xm5upHP/qRvvrqq7BnHD58WCUlJUpLS1NGRobuu+8+HTt2zPaHAQAA8Rdzy0Jzc7OGDx+ue++9V5MnTw47d/z4ce3atUvz58/X8OHD9c0332jOnDn6/ve/r9ra2tB1JSUlOnjwoDZt2qT29nZNmzZNM2bM0Lp162LKi7GMDFMnAQARGCe/rRvZbFmIW07iKuZgobi4WMXFxR2eS09P16ZNm8KOrVixQjfddJP279+vAQMG6NNPP9XGjRu1c+dOjRw5UpK0fPlyfe9739Mvf/lL5ebmXsDHAADABeiGuDBHjhyRz+dTRkaGJKm6uloZGRmhQEGSioqKlJSUpJqamg6f0draqkAgEJYAAIAzOjVYaGlp0bx583TPPfcoLS1NkuT3+9W/f/+w6y666CJlZmbK7/d3+JyKigqlp6eHUl5eXmdmGwCAC2NZ9pMLdVqw0N7errvuukvGGK1atcrWs8rLy3XkyJFQOnDgQJxyCQBAHJ3uhrCTXKhTpk6eDhT27dunzZs3h1oVJCk7O1uHDh0Ku/7EiRM6fPiwsrOzO3xeSkqKUlJSzj7BokwAgGhcuoSyl8S9ZeF0oLBnzx69/fbb6tu3b9j5wsJCNTU1qa6uLnRs8+bNsixLBQUF8c4OAADOSdCWhZiDhWPHjqm+vl719fWSpIaGBtXX12v//v1qb2/XnXfeqdraWq1du1bBYFB+v19+v19tbW2SpKuvvlrjxo3T9OnTtWPHDr377ruaPXu2pk6dykwIAIC3WcZ+suHpp5+Wz+fT3Llz4/N5Tom5G6K2tla33XZb6OeysjJJUmlpqRYtWqQ33nhDkjRixIiw+9555x2NHj1akrR27VrNnj1bY8aMUVJSkqZMmaJly5Zd4EcAAAA7d+7Ub37zG1177bVxf3bMwcLo0aMjLnBxPotfZGZmxrwAEwAAbmeMJWNjjMSF3nvs2DGVlJTo+eef15IlSy74/efCFtUAAMSLsdkFceoL95lrC7W2tkZ87axZszR+/HgVFRV1ysfy9kZSxubuXgCAxOfocs8266VTeT1zPaGFCxdq0aJFHd7yyiuvaNeuXdq5c+eFvzcKbwcLAAAkoAMHDoQtO9Dh8gGnrpszZ442bdqk1NTUTssPwQIAAPFiWZLPxroOp8YspKWlhQUL51JXV6dDhw7p+uuvDx0LBoPatm2bVqxYodbWVvXo0ePC83MKwQIAAPESp26I8zVmzBh9+OGHYcemTZumwYMHa968eXEJFCSCBQAAPKtPnz4aOnRo2LHevXurb9++Zx23g2ABAIA4MZYlY6Mbws60y85EsAAAQLw43A3RkS1btth+xplYZwEAAEREywIAAPFiGcnXtS0LnYFgAQCAeDFGkp2pk+4MFuiGAAAAEdGyAABAnBjLyNjohjifzRi7AsECAADxYizZ64Zg6iQAAAktUVsWGLMAAAAi8mTLwunI64Ta2aEaABDRCbVLcuZb+wnTaqsr4XRe3caTwcLRo0clSdv1312cEwCAVxw9elTp6emd8uzk5GRlZ2dru99+vZSdna3k5OQ45Cp+fMatHSQRWJal3bt365prrjlrz2+cWyAQUF5eHmUWA8osdpTZhaHcYne+ZWaM0dGjR5Wbm6ukpM7rfW9paVFbW5vt5yQnJys1NTUOOYofT7YsJCUl6bLLLpN0/nt+4/9RZrGjzGJHmV0Yyi1251NmndWi8PdSU1NdV8nHCwMcAQBARAQLAAAgIs8GCykpKVq4cKFSUlK6OiueQZnFjjKLHWV2YSi32FFmzvHkAEcAAOAcz7YsAAAAZxAsAACAiAgWAABARAQLAAAgIk8GCytXrtQVV1yh1NRUFRQUaMeOHV2dJddYtGiRfD5fWBo8eHDofEtLi2bNmqW+ffvq4osv1pQpU9TY2NiFOe4a27Zt04QJE5Sbmyufz6cNGzaEnTfGaMGCBcrJyVGvXr1UVFSkPXv2hF1z+PBhlZSUKC0tTRkZGbrvvvt07NgxBz+Fs6KV2Y9//OOzfvfGjRsXdk13K7OKigrdeOON6tOnj/r3769JkyZp9+7dYdecz9/k/v37NX78eH3rW99S//799cgjj+jEiRNOfhTHnE+ZjR49+qzftZ/+9Kdh13SnMnOC54KF3/72tyorK9PChQu1a9cuDR8+XGPHjtWhQ4e6OmuuMWTIEB08eDCUtm/fHjr30EMP6fe//71ee+01bd26VV999ZUmT57chbntGs3NzRo+fLhWrlzZ4fmlS5dq2bJlWr16tWpqatS7d2+NHTtWLS0toWtKSkr08ccfa9OmTXrzzTe1bds2zZgxw6mP4LhoZSZJ48aNC/vde/nll8POd7cy27p1q2bNmqX3339fmzZtUnt7u26//XY1NzeHron2NxkMBjV+/Hi1tbXpvffe04svvqgXXnhBCxYs6IqP1OnOp8wkafr06WG/a0uXLg2d625l5gjjMTfddJOZNWtW6OdgMGhyc3NNRUVFF+bKPRYuXGiGDx/e4bmmpibTs2dP89prr4WOffrpp0aSqa6udiiH7iPJrF+/PvSzZVkmOzvb/OIXvwgda2pqMikpKebll182xhjzySefGElm586doWveeust4/P5zJdffulY3rvKmWVmjDGlpaVm4sSJ57ynu5eZMcYcOnTISDJbt241xpzf3+R///d/m6SkJOP3+0PXrFq1yqSlpZnW1lZnP0AXOLPMjDHmn/7pn8ycOXPOeU93L7PO4KmWhba2NtXV1amoqCh0LCkpSUVFRaquru7CnLnLnj17lJubqyuvvFIlJSXav3+/JKmurk7t7e1h5Td48GANGDCA8vs7DQ0N8vv9YeWUnp6ugoKCUDlVV1crIyNDI0eODF1TVFSkpKQk1dTUOJ5nt9iyZYv69++v73znO5o5c6a+/vrr0DnKTDpy5IgkKTMzU9L5/U1WV1dr2LBhysrKCl0zduxYBQIBffzxxw7mvmucWWanrV27Vv369dPQoUNVXl6u48ePh8519zLrDJ7aSOqvf/2rgsFg2C+AJGVlZemzzz7roly5S0FBgV544QV95zvf0cGDB/XEE0/oH//xH/XRRx/J7/crOTlZGRkZYfdkZWXJ7/d3TYZd6HRZdPR7dvqc3+9X//79w85fdNFFyszM7LZlOW7cOE2ePFn5+fn64osv9LOf/UzFxcWqrq5Wjx49un2ZWZaluXPnatSoURo6dKgkndffpN/v7/B38fS5RNZRmUnSv/zLv2jgwIHKzc3Vn/70J82bN0+7d+/Wf/7nf0rq3mXWWTwVLCC64uLi0H9fe+21Kigo0MCBA/Xqq6+qV69eXZgzJLqpU6eG/nvYsGG69tprddVVV2nLli0aM2ZMF+bMHWbNmqWPPvoobAwRIjtXmf39OJdhw4YpJydHY8aM0RdffKGrrrrK6Wx2C57qhujXr5969Ohx1kjhxsZGZWdnd1Gu3C0jI0P/8A//oL179yo7O1ttbW1qamoKu4byC3e6LCL9nmVnZ581qPbEiRM6fPgwZXnKlVdeqX79+mnv3r2SuneZzZ49W2+++abeeecdXX755aHj5/M3mZ2d3eHv4ulziepcZdaRgoICSQr7XeuOZdaZPBUsJCcn64YbblBVVVXomGVZqqqqUmFhYRfmzL2OHTumL774Qjk5ObrhhhvUs2fPsPLbvXu39u/fT/n9nfz8fGVnZ4eVUyAQUE1NTaicCgsL1dTUpLq6utA1mzdvlmVZof9xdXf/+7//q6+//lo5OTmSumeZGWM0e/ZsrV+/Xps3b1Z+fn7Y+fP5mywsLNSHH34YFmht2rRJaWlpuuaaa5z5IA6KVmYdqa+vl6Sw37XuVGaO6OoRlrF65ZVXTEpKinnhhRfMJ598YmbMmGEyMjLCRr12Zw8//LDZsmWLaWhoMO+++64pKioy/fr1M4cOHTLGGPPTn/7UDBgwwGzevNnU1taawsJCU1hY2MW5dt7Ro0fNBx98YD744AMjyTz77LPmgw8+MPv27TPGGPP000+bjIwM8/rrr5s//elPZuLEiSY/P9/87W9/Cz1j3Lhx5rrrrjM1NTVm+/btZtCgQeaee+7pqo/U6SKV2dGjR82//du/merqatPQ0GDefvttc/3115tBgwaZlpaW0DO6W5nNnDnTpKenmy1btpiDBw+G0vHjx0PXRPubPHHihBk6dKi5/fbbTX19vdm4caO59NJLTXl5eVd8pE4Xrcz27t1rFi9ebGpra01DQ4N5/fXXzZVXXmluvfXW0DO6W5k5wXPBgjHGLF++3AwYMMAkJyebm266ybz//vtdnSXXuPvuu01OTo5JTk42l112mbn77rvN3r17Q+f/9re/mfvvv99ccskl5lvf+pb5wQ9+YA4ePNiFOe4a77zzjpF0ViotLTXGnJw+OX/+fJOVlWVSUlLMmDFjzO7du8Oe8fXXX5t77rnHXHzxxSYtLc1MmzbNHD16tAs+jTMildnx48fN7bffbi699FLTs2dPM3DgQDN9+vSzgvjuVmYdlZcks2bNmtA15/M3+T//8z+muLjY9OrVy/Tr1888/PDDpr293eFP44xoZbZ//35z6623mszMTJOSkmK+/e1vm0ceecQcOXIk7DndqcycwBbVAAAgIk+NWQAAAM4jWAAAABERLAAAgIgIFgAAQEQECwAAICKCBQAAEBHBAgAAiIhgAQAARESwAAAAIiJYAAAAEREsAACAiAgWAABARP8HEvc/GKgYbEQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "# simple beam in topocentric coordinates\n", - "lmax = 8\n", + "lmax = 128\n", "freq = jnp.linspace(40, 80, 41)\n", - "beam_alm = crojax.Alm.zeros(lmax, frequencies=freq, coord=\"T\")\n", + "beam = crojax.Beam.zeros(lmax, frequencies=freq, coord=\"T\")\n", "\n", "# set (l=0, m=0) and (l=1, m=0) mode\n", - "beam_alm[:, 0, 0] = 30 * (freq/freq[0]) ** 2\n", - "beam_alm[:, 1, 0] = 10 * (freq/freq[0])**2\n", + "beam[:, 0, 0] = 30 * (freq/freq[0]) ** 2\n", + "beam[:, 1, 0] = 10 * (freq/freq[0])**2\n", + "print(beam.is_real)\n", "\n", - "# visualize with healpix\n", - "#nside = 64\n", - "#hp.mollview(beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")" + "# visualize\n", + "nside = None\n", + "sampling = \"mw\" # mw, mwss, dh, healpix\n", + "if sampling == \"healpix\":\n", + " nside = 2 * lmax\n", + "hpm = beam.alm2map(sampling=sampling, nside=nside, frequencies=freq)\n", + "print(hpm.shape)\n", + "if sampling == \"healpix\":\n", + " import healpy\n", + " healpy.mollview(hpm[0])\n", + "else:\n", + " plt.figure()\n", + " plt.imshow(hpm[0], aspect=\"auto\")\n", + " plt.colorbar()\n", + " plt.show()" ] }, { "cell_type": "code", - "execution_count": 4, - "id": "00c86d9d-6b31-44c2-a48c-6998d4f0d350", + "execution_count": 3, + "id": "bd23f9db-6922-4364-a6bc-83aa23cb5232", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", - " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", - " 0., 0., 0., 0., 0., 0., 0.], dtype=float64)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "beam_alm.alm[:, 0, 0 # WHYYYYYYYYYYYYYYYYYYYyy" + "# plotting functions\n", + "# precompute ..." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "3be26219", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'partial' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[4], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# we can impose a horizon like this, note that the sharp edge creates ripples since we don't have an inifinite lmax\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43mbeam\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhorizon_cut\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m#hp.mollview(beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/projects/croissant/.venv/lib/python3.10/site-packages/croissant/crojax/beam.py:59\u001b[0m, in \u001b[0;36mBeam.horizon_cut\u001b[0;34m(self, horizon, sampling, nside)\u001b[0m\n\u001b[1;32m 55\u001b[0m horizon\u001b[38;5;241m.\u001b[39mat[:, theta \u001b[38;5;241m>\u001b[39m jnp\u001b[38;5;241m.\u001b[39mpi \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m]\u001b[38;5;241m.\u001b[39mset(\u001b[38;5;241m0.0\u001b[39m)\n\u001b[1;32m 57\u001b[0m m \u001b[38;5;241m=\u001b[39m m \u001b[38;5;241m*\u001b[39m horizon\n\u001b[1;32m 58\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39malm \u001b[38;5;241m=\u001b[39m jax\u001b[38;5;241m.\u001b[39mvmap(\n\u001b[0;32m---> 59\u001b[0m \u001b[43mpartial\u001b[49m(\n\u001b[1;32m 60\u001b[0m s2fft\u001b[38;5;241m.\u001b[39mforward_jax,\n\u001b[1;32m 61\u001b[0m L\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlmax \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m,\n\u001b[1;32m 62\u001b[0m spin\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m,\n\u001b[1;32m 63\u001b[0m nside\u001b[38;5;241m=\u001b[39mnside,\n\u001b[1;32m 64\u001b[0m reality\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mis_real,\n\u001b[1;32m 65\u001b[0m precomps\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 66\u001b[0m spmd\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m 67\u001b[0m L_lower\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m,\n\u001b[1;32m 68\u001b[0m )\n\u001b[1;32m 69\u001b[0m )(m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'partial' is not defined" + ] + } + ], "source": [ "# we can impose a horizon like this, note that the sharp edge creates ripples since we don't have an inifinite lmax\n", "beam.horizon_cut()\n", - "hp.mollview(beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")" + "#hp.mollview(beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")" ] }, { From 33bb10bf0630a3c70374fb3cc807219a54475aac Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 6 Sep 2023 18:04:27 -0700 Subject: [PATCH 036/129] add jax tests to workflow --- .github/workflows/push.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index fa57a3b..ed3faa5 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -31,7 +31,6 @@ jobs: #mypy ./croissant/ - name: Test with pytest run: | - pytest --cov=croissant --cov-report=xml croissant/core/tests - #pytest --cov=croissant --cov-report=xml core/tests crojax/tests + pytest --cov=croissant --cov-report=xml core/tests crojax/tests - name: Upload coverage to Codecov uses: codecov/codecov-action@v3 From e67ffcb0d60edc9966f312a50ce6eb688b6e69f3 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 7 Sep 2023 15:00:52 -0700 Subject: [PATCH 037/129] fix path to tests --- .github/workflows/push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index ed3faa5..b94b8cd 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -31,6 +31,6 @@ jobs: #mypy ./croissant/ - name: Test with pytest run: | - pytest --cov=croissant --cov-report=xml core/tests crojax/tests + pytest --cov=croissant --cov-report=xml croissant/core/tests croissant/crojax/tests - name: Upload coverage to Codecov uses: codecov/codecov-action@v3 From 77897c5783e40c3ba5410bc75b5e7d8dee22032d Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 7 Sep 2023 16:35:14 -0700 Subject: [PATCH 038/129] catch bugs from test --- croissant/crojax/healpix.py | 6 +++-- croissant/crojax/tests/test_healpix.py | 37 +++++++++++++++----------- 2 files changed, 25 insertions(+), 18 deletions(-) diff --git a/croissant/crojax/healpix.py b/croissant/crojax/healpix.py index 3384404..6cbb6fe 100644 --- a/croissant/crojax/healpix.py +++ b/croissant/crojax/healpix.py @@ -82,8 +82,10 @@ def is_real(self): Mathematically, this means that alm(l, m) = (-1)^m * conj(alm(l, -m)). """ emm = jnp.arange(1, self.lmax + 1)[None, None, :] # positive ms - neg_m = self.alm[:, :, : self.lmax] # alms for m < 0 - pos_m = self.alm[:, :, self.lmax + 1 :] # alms for m > 0 + # get alms for negative m, in reverse order (i.e., increasing abs(m)) + neg_m = self.alm[:, :, :self.lmax][:, :, ::-1] + # get alms for positive m + pos_m = self.alm[:, :, self.lmax + 1 :] return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)).item() def reduce_lmax(self, new_lmax): diff --git a/croissant/crojax/tests/test_healpix.py b/croissant/crojax/tests/test_healpix.py index 6ed5261..c941b1c 100644 --- a/croissant/crojax/tests/test_healpix.py +++ b/croissant/crojax/tests/test_healpix.py @@ -1,6 +1,6 @@ from copy import deepcopy import pytest -from np.random import default_rng +from numpy.random import default_rng import jax.numpy as jnp import s2fft from croissant.crojax import healpix as hp @@ -13,7 +13,8 @@ def test_lmax_from_shape(lmax): - shape = s2fft.sampling.s2_samples.flm_shape(lmax + 1) + s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) + shape = (1, s1, s2) # add frequency axis _lmax = hp.lmax_from_shape(shape) assert _lmax == lmax @@ -24,9 +25,13 @@ def test_alm_indexing(lmax): # set a00 = 1 for first half of frequencies alm[: nfreqs // 2, 0, 0] = 1.0 # check __setitem__ acted correctly on alm.alm - assert jnp.allclose(alm.alm[: nfreqs // 2, 0], 1) - assert jnp.allclose(alm.alm[nfreqs // 2 :, 0], 0) - assert jnp.allclose(alm.alm[:, 1:], 0) + l_ix, m_ix = alm.getidx(0, 0) + mask = jnp.zeros_like(alm.alm, dtype=bool) + mask = mask.at[:nfreqs//2, l_ix, m_ix].set(True) + # first half frequencies of a00, which should be 1 + assert jnp.allclose(alm.alm[mask], 1) + # all other alm should be 0 + assert jnp.allclose(alm.alm[~mask], 0) # check that __getitem__ agrees: assert jnp.allclose(alm[: nfreqs // 2, 0, 0], 1) assert jnp.allclose(alm[nfreqs // 2 :, 0, 0], 0) @@ -39,13 +44,13 @@ def test_alm_indexing(lmax): alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) # negative indexing val = 3.0 + 2.3j - alm[-1, 10, 7] = val - assert alm[-1, 10, 7] == val - l_ix, m_ix = alm.getidx(10, 7) - assert alm[-1, 10, 7] == alm.alm[-1, l_ix, m_ix] + alm[-1, 6, 3] = val + assert alm[-1, 6, 3] == val + l_ix, m_ix = alm.getidx(6, 3) + assert alm[-1, 6, 3] == alm.alm[-1, l_ix, m_ix] # frequency index not specified - with pytest.raises(IndexError): + with pytest.raises(TypeError): alm[3, 2] = 5 alm[7, -1] @@ -54,7 +59,8 @@ def test_zeros(lmax): alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) assert alm.lmax == lmax assert alm.frequencies is freqs - assert alm.alm.shape == s2fft.sampling.s2_samples.flm_shape(lmax + 1) + s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) + assert alm.alm.shape == (nfreqs, s1, s2) assert jnp.allclose(alm.alm, 0) @@ -64,18 +70,18 @@ def test_is_real(lmax): val = 1.0 + 2.0j alm[0, 2, 1] = val # set l=2, m=1 mode but not m=-1 mode assert not alm.is_real - alm[0, 2, -1] = -1 * val.conj() # set m=-1 mode to complex conjugate + alm[0, 2, -1] = -1 * val.conjugate() # set m=-1 mode to complex conjugate assert alm.is_real # generate a real signal and check that alm.is_real is True alm = hp.Alm( s2fft.utils.signal_generator.generate_flm(rng, lmax, reality=True) - ) + )[None] # add freq axis assert alm.is_real # complex alm = hp.Alm( s2fft.utils.signal_generator.generate_flm(rng, lmax, reality=False) - ) + )[None] assert not alm.is_real @@ -122,9 +128,8 @@ def test_getidx(lmax): @pytest.mark.skip(reason="not implemented") -def test_alm2map(): +def test_alm2map(lmax): # make constant map - lmax = 10 alm = hp.Alm.zeros(lmax=lmax) a00 = 5 alm[0, 0, 0] = a00 From caf69e068cfb3b0393e7ccc20931ef56afc877e7 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Sat, 9 Sep 2023 19:04:53 -0700 Subject: [PATCH 039/129] move test_utils to new dir for consistent file structure --- .github/workflows/push.yml | 2 +- croissant/{core => }/tests/test_utils.py | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename croissant/{core => }/tests/test_utils.py (100%) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index b94b8cd..c0dff58 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -31,6 +31,6 @@ jobs: #mypy ./croissant/ - name: Test with pytest run: | - pytest --cov=croissant --cov-report=xml croissant/core/tests croissant/crojax/tests + pytest --cov=croissant --cov-report=xml croissant/tests croissant/core/tests croissant/crojax/tests - name: Upload coverage to Codecov uses: codecov/codecov-action@v3 diff --git a/croissant/core/tests/test_utils.py b/croissant/tests/test_utils.py similarity index 100% rename from croissant/core/tests/test_utils.py rename to croissant/tests/test_utils.py From 7e93057a9d86a69e821b06b49d9c02e694d267c3 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Sat, 9 Sep 2023 19:09:08 -0700 Subject: [PATCH 040/129] fix syntax error --- croissant/crojax/tests/test_healpix.py | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/croissant/crojax/tests/test_healpix.py b/croissant/crojax/tests/test_healpix.py index c941b1c..ccba2fc 100644 --- a/croissant/crojax/tests/test_healpix.py +++ b/croissant/crojax/tests/test_healpix.py @@ -27,7 +27,7 @@ def test_alm_indexing(lmax): # check __setitem__ acted correctly on alm.alm l_ix, m_ix = alm.getidx(0, 0) mask = jnp.zeros_like(alm.alm, dtype=bool) - mask = mask.at[:nfreqs//2, l_ix, m_ix].set(True) + mask = mask.at[: nfreqs // 2, l_ix, m_ix].set(True) # first half frequencies of a00, which should be 1 assert jnp.allclose(alm.alm[mask], 1) # all other alm should be 0 @@ -59,7 +59,7 @@ def test_zeros(lmax): alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) assert alm.lmax == lmax assert alm.frequencies is freqs - s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) + s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) assert alm.alm.shape == (nfreqs, s1, s2) assert jnp.allclose(alm.alm, 0) @@ -74,14 +74,12 @@ def test_is_real(lmax): assert alm.is_real # generate a real signal and check that alm.is_real is True - alm = hp.Alm( - s2fft.utils.signal_generator.generate_flm(rng, lmax, reality=True) - )[None] # add freq axis + sig = s2fft.utils.signal_generator.generate_flm(rng, lmax, reality=True) + alm = hp.Alm(sig[None]) assert alm.is_real # complex - alm = hp.Alm( - s2fft.utils.signal_generator.generate_flm(rng, lmax, reality=False) - )[None] + sig = s2fft.utils.signal_generator.generate_flm(rng, lmax, reality=False) + alm = hp.Alm(sig[None]) assert not alm.is_real From 3d45577c74edf48668e5c2c495bf5c18574cc3b6 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Sat, 9 Sep 2023 19:26:30 -0700 Subject: [PATCH 041/129] update tests --- croissant/crojax/tests/test_healpix.py | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/croissant/crojax/tests/test_healpix.py b/croissant/crojax/tests/test_healpix.py index ccba2fc..e62ec14 100644 --- a/croissant/crojax/tests/test_healpix.py +++ b/croissant/crojax/tests/test_healpix.py @@ -74,17 +74,18 @@ def test_is_real(lmax): assert alm.is_real # generate a real signal and check that alm.is_real is True - sig = s2fft.utils.signal_generator.generate_flm(rng, lmax, reality=True) + sig = s2fft.utils.signal_generator.generate_flm(rng, lmax+1, reality=True) alm = hp.Alm(sig[None]) assert alm.is_real # complex - sig = s2fft.utils.signal_generator.generate_flm(rng, lmax, reality=False) + sig = s2fft.utils.signal_generator.generate_flm(rng, lmax+1, reality=False) alm = hp.Alm(sig[None]) assert not alm.is_real def test_reduce_lmax(lmax): - alm = hp.Alm(s2fft.utils.signal_generator.generate_flm(rng, lmax)) + sig = s2fft.utils.signal_generator.generate_flm(rng, lmax+1) + alm = hp.Alm(sig[None]) old_alm = deepcopy(alm) # reduce to same lmax, should do nothing alm.reduce_lmax(lmax) @@ -94,7 +95,8 @@ def test_reduce_lmax(lmax): new_lmax = 5 alm.reduce_lmax(new_lmax) assert alm.lmax == new_lmax - assert alm.alm.shape == s2fft.sampling.s2_samples.flm_shape(new_lmax + 1) + s1, s2 = s2fft.sampling.s2_samples.flm_shape(new_lmax + 1) + assert alm.alm.shape == (1, s1, s2) for ell in range(new_lmax + 1): for emm in range(-ell, ell + 1): assert alm[:, ell, emm] == old_alm[:, ell, emm] @@ -105,8 +107,10 @@ def test_reduce_lmax(lmax): with pytest.raises(ValueError): alm.reduce_lmax(new_lmax) - @pytest.mark.skip(reason="not implemented") +def test_getlm(lmax): + pass + def test_getidx(lmax): alm = hp.Alm.zeros(lmax=lmax) ell = 3 @@ -119,10 +123,12 @@ def test_getidx(lmax): alm.getidx(-ell, emm) # should fail since l < 0 # try convert back and forth ell, emm <-> index - ix = alm.getidx(ell, emm) - ell_, emm_ = alm.getlm(i=ix) - assert ell == ell_ - assert emm == emm_ + for ell in lmax // jnp.arange(1, 10): + for emm in range(-ell, ell + 1): + ix = alm.getidx(ell, emm) + ell_, emm_ = alm.getlm(ix) + assert ell == ell_ + assert emm == emm_ @pytest.mark.skip(reason="not implemented") From 6826fa0f0512658a34125eb9c7189ea522ef31f5 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 11 Sep 2023 13:57:02 -0700 Subject: [PATCH 042/129] update requirements.txt --- requirements.txt | 245 ++++++++++++++++++++++++++--------------------- 1 file changed, 138 insertions(+), 107 deletions(-) diff --git a/requirements.txt b/requirements.txt index 737196b..48291da 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,124 +1,155 @@ -argon2-cffi==21.3.0 -argon2-cffi-bindings==21.2.0 -astropy==5.1 -asttokens==2.0.7 -attrs==22.1.0 +appdirs==1.4.4 +apturl==0.5.2 +argon2-cffi==21.1.0 +attrs==21.2.0 +Babel==2.8.0 backcall==0.2.0 -beautifulsoup4==4.11.1 -black==22.6.0 -bleach==5.0.1 -build==0.8.0 -certifi==2023.7.22 -cffi==1.15.1 -charset-normalizer==2.1.0 -click==8.1.3 -commonmark==0.9.1 -coverage==6.4.3 -croissant-sim==3.0.0 -cryptography==41.0.3 +bcrypt==3.2.0 +beautifulsoup4==4.10.0 +beniget==0.4.1 +bleach==4.1.0 +blinker==1.4 +Brlapi==0.8.3 +Brotli==1.0.9 +certifi==2020.6.20 +chardet==4.0.0 +click==8.0.3 +click-plugins==1.1.1 +colorama==0.4.4 +command-not-found==0.3 +cryptography==3.4.8 +cupshelpers==1.0 cycler==0.11.0 -debugpy==1.6.2 -decorator==5.1.1 +dbus-python==1.2.18 +decorator==4.4.2 +defer==1.0.6 defusedxml==0.7.1 -docutils==0.19 +distro==1.7.0 +distro-info==1.1+ubuntu0.1 +dnspython==2.1.0 entrypoints==0.4 -ephem==4.1.3 -executing==0.9.1 -fastjsonschema==2.16.1 -flake8==5.0.4 -fonttools==4.34.4 -h5py==3.7.0 -healpy==1.16.1 +flake8==4.0.1 +fonttools==4.29.1 +fs==2.4.12 +gast==0.5.2 +gpg==1.16.0 +greenlet==1.1.2 hera-filters==0.1.1 +html5lib==1.1 +httplib2==0.20.2 idna==3.3 -importlib-metadata==4.12.0 -iniconfig==1.1.1 -ipykernel==6.15.1 -ipython==8.10.0 -ipython-genutils==0.2.0 -ipywidgets==7.7.1 -jedi==0.18.1 -jeepney==0.8.0 -Jinja2==3.1.2 -jplephem==2.17 -jsonschema==4.9.1 -jupyter==1.0.0 -jupyter-client==7.3.4 -jupyter-console==6.4.4 -jupyter_core==4.11.2 -jupyterlab-pygments==0.2.2 -jupyterlab-widgets==1.1.1 -keyring==23.8.2 -kiwisolver==1.4.4 -lunarsky==0.1.2 -lxml==4.9.1 -MarkupSafe==2.1.1 -matplotlib==3.5.2 +importlib-metadata==4.6.4 +iotop==0.6 +ipykernel==6.7.0 +ipython==7.31.1 +ipython_genutils==0.2.0 +ipywidgets==6.0.0 +jedi==0.18.0 +jeepney==0.7.1 +Jinja2==3.0.3 +jsonschema==3.2.0 +jupyter-client==7.1.2 +jupyter-core==4.9.1 +jupyterlab-pygments==0.1.2 +keyring==23.5.0 +kiwisolver==1.3.2 +language-selector==0.1 +launchpadlib==1.10.16 +lazr.restfulclient==0.14.4 +lazr.uri==1.0.6 +louis==3.20.0 +lxml==4.8.0 +lz4==3.1.3+dfsg +macaroonbakery==1.3.1 +Mako==1.1.3 +MarkupSafe==2.0.1 +matplotlib==3.5.1 matplotlib-inline==0.1.3 -mccabe==0.7.0 -mistune==2.0.3 -mypy==0.971 -mypy-extensions==0.4.3 -nbclient==0.6.6 -nbconvert==7.2.8 -nbformat==5.4.0 -nest-asyncio==1.5.5 -notebook==6.4.12 -numpy==1.23.1 +mccabe==0.6.1 +more-itertools==8.10.0 +mpmath==0.0.0 +msgpack==1.0.3 +nbclient==0.5.6 +nbconvert==6.4.0 +nbformat==5.1.3 +nest-asyncio==1.5.4 +netifaces==0.11.0 +networkx==2.4 +notebook==6.4.8 +numpy==1.21.5 +oauthlib==3.2.0 +olefile==0.46 packaging==21.3 pandocfilters==1.5.0 -parso==0.8.3 -pathspec==0.9.0 -pep517==0.13.0 +parso==0.8.1 pexpect==4.8.0 pickleshare==0.7.5 -Pillow==9.3.0 -pkginfo==1.8.3 -platformdirs==2.5.2 -pluggy==1.0.0 -prometheus-client==0.14.1 -prompt-toolkit==3.0.30 -psutil==5.9.1 +Pillow==9.0.1 +ply==3.11 +prometheus-client==0.9.0 +prompt-toolkit==3.0.28 +protobuf==3.12.4 +proton-client==0.7.1 +protonvpn-cli==3.13.0 +protonvpn-nm-lib==3.16.0 ptyprocess==0.7.0 -pure-eval==0.2.2 -py==1.11.0 -pycodestyle==2.9.1 -pycparser==2.21 -pyephem==9.99 -pyerfa==2.0.0.1 -pyflakes==2.5.0 -pygdsm==1.3.0 -Pygments==2.15.0 -pyparsing==3.0.9 +py==1.10.0 +pycairo==1.20.1 +pycodestyle==2.8.0 +pycups==2.0.1 +pyflakes==2.4.0 +pygccxml==2.2.1 +Pygments==2.11.2 +PyGObject==3.42.1 +PyJWT==2.3.0 +pymacaroons==0.13.0 +PyNaCl==1.5.0 +pynvim==0.4.2 +PyOpenGL==3.1.5 +pyOpenSSL==21.0.0 +pyparsing==2.4.7 +PyQt-Qwt==1.2.2 +PyQt5==5.15.6 +PyQt5-sip==12.9.1 +pyqtgraph==0.12.4 +pyRFC3339==1.1 pyrsistent==0.18.1 -pytest==7.1.2 -pytest-cov==3.0.0 -python-dateutil==2.8.2 -PyYAML==6.0 -pyzmq==23.2.0 -qtconsole==5.3.1 -QtPy==2.1.0 -readme-renderer==36.0 -requests==2.31.0 +python-apt==2.4.0+ubuntu2 +python-dateutil==2.8.1 +python-debian==0.1.43+ubuntu1.1 +python-gnupg==0.4.8 +pythondialog==3.5.1 +pythran==0.10.0 +pytz==2022.1 +pyxdg==0.27 +PyYAML==5.4.1 +pyzmq==22.3.0 +reportlab==3.6.8 +requests==2.25.1 requests-toolbelt==0.9.1 -rfc3986==2.0.0 -rich==12.5.1 -scipy==1.10.0 -SecretStorage==3.3.2 -Send2Trash==1.8.0 +scipy==1.8.0 +SecretStorage==3.3.1 +Send2Trash==1.8.1b0 six==1.16.0 -soupsieve==2.3.2.post1 -spiceypy==5.1.1 -stack-data==0.3.0 -terminado==0.15.0 -tinycss2==1.1.1 -tomli==2.0.1 -tornado==6.3.3 -traitlets==5.3.0 -twine==4.0.1 -typing_extensions==4.3.0 -urllib3==1.26.11 +soupsieve==2.3.1 +sympy==1.9 +systemd-python==234 +terminado==0.13.1 +testpath==0.5.0 +thrift==0.16.0 +tornado==6.1 +traitlets==5.1.1 +ubuntu-advantage-tools==8001 +ubuntu-drivers-common==0.0.0 +ufoLib2==0.13.1 +ufw==0.36.1 +unattended-upgrades==0.1 +unicodedata2==14.0.0 +urllib3==1.26.5 +wadllib==1.3.6 wcwidth==0.2.5 webencodings==0.5.1 -widgetsnbextension==3.6.1 -zipp==3.8.1 +widgetsnbextension==2.0.0 +xdg==5 +xkit==0.0.0 +zipp==1.0.0 From 13ce87b935d8a22cc82d47070bd53d9a9596d353 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 11 Sep 2023 13:57:17 -0700 Subject: [PATCH 043/129] cache dependencies --- .github/workflows/push.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index c0dff58..549bcd9 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -16,10 +16,11 @@ jobs: uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} + cache: 'pip' - name: Install dependencies run: | python -m pip install --upgrade pip - python -m pip install importlib-metadata==4.13.0 + python -m pip install -r requirements.txt python -m pip install --upgrade "jax[cpu]" python -m pip install .[dev] - name: Lint with flake8 From 760f2e3d2c67c4d6e5331cf4a54393aa4d917f78 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 11 Sep 2023 13:58:51 -0700 Subject: [PATCH 044/129] remove apturl --- requirements.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 48291da..dad1748 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,4 @@ appdirs==1.4.4 -apturl==0.5.2 argon2-cffi==21.1.0 attrs==21.2.0 Babel==2.8.0 From 7d08fe10982b0603dbb7a8a06e354f1a9d6a03a8 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 11 Sep 2023 14:01:08 -0700 Subject: [PATCH 045/129] fix requirements.txt file --- requirements.txt | 301 ++++++++++++++++++++++++----------------------- 1 file changed, 157 insertions(+), 144 deletions(-) diff --git a/requirements.txt b/requirements.txt index dad1748..8ae516d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,154 +1,167 @@ -appdirs==1.4.4 -argon2-cffi==21.1.0 -attrs==21.2.0 -Babel==2.8.0 +anyio==4.0.0 +argon2-cffi==23.1.0 +argon2-cffi-bindings==21.2.0 +arrow==1.2.3 +astropy==5.3.2 +asttokens==2.2.1 +async-lru==2.0.4 +attrs==23.1.0 +Babel==2.12.1 backcall==0.2.0 -bcrypt==3.2.0 -beautifulsoup4==4.10.0 -beniget==0.4.1 -bleach==4.1.0 -blinker==1.4 -Brlapi==0.8.3 -Brotli==1.0.9 -certifi==2020.6.20 -chardet==4.0.0 -click==8.0.3 -click-plugins==1.1.1 -colorama==0.4.4 -command-not-found==0.3 -cryptography==3.4.8 -cupshelpers==1.0 +beautifulsoup4==4.12.2 +black==23.7.0 +bleach==6.0.0 +build==1.0.0 +certifi==2023.7.22 +cffi==1.15.1 +charset-normalizer==3.2.0 +click==8.1.7 +colorlog==6.7.0 +comm==0.1.4 +contourpy==1.1.0 +coverage==7.3.0 +cryptography==41.0.3 cycler==0.11.0 -dbus-python==1.2.18 -decorator==4.4.2 -defer==1.0.6 +debugpy==1.6.7.post1 +decorator==5.1.1 defusedxml==0.7.1 -distro==1.7.0 -distro-info==1.1+ubuntu0.1 -dnspython==2.1.0 -entrypoints==0.4 -flake8==4.0.1 -fonttools==4.29.1 -fs==2.4.12 -gast==0.5.2 -gpg==1.16.0 -greenlet==1.1.2 +docutils==0.20.1 +ephem==4.1.4 +exceptiongroup==1.1.3 +executing==1.2.0 +fastjsonschema==2.18.0 +flake8==6.1.0 +fonttools==4.42.1 +fqdn==1.5.1 +h5py==3.9.0 +healpy==1.16.5 hera-filters==0.1.1 -html5lib==1.1 -httplib2==0.20.2 -idna==3.3 -importlib-metadata==4.6.4 -iotop==0.6 -ipykernel==6.7.0 -ipython==7.31.1 -ipython_genutils==0.2.0 -ipywidgets==6.0.0 -jedi==0.18.0 -jeepney==0.7.1 -Jinja2==3.0.3 -jsonschema==3.2.0 -jupyter-client==7.1.2 -jupyter-core==4.9.1 -jupyterlab-pygments==0.1.2 -keyring==23.5.0 -kiwisolver==1.3.2 -language-selector==0.1 -launchpadlib==1.10.16 -lazr.restfulclient==0.14.4 -lazr.uri==1.0.6 -louis==3.20.0 -lxml==4.8.0 -lz4==3.1.3+dfsg -macaroonbakery==1.3.1 -Mako==1.1.3 -MarkupSafe==2.0.1 -matplotlib==3.5.1 -matplotlib-inline==0.1.3 -mccabe==0.6.1 -more-itertools==8.10.0 -mpmath==0.0.0 -msgpack==1.0.3 -nbclient==0.5.6 -nbconvert==6.4.0 -nbformat==5.1.3 -nest-asyncio==1.5.4 -netifaces==0.11.0 -networkx==2.4 -notebook==6.4.8 -numpy==1.21.5 -oauthlib==3.2.0 -olefile==0.46 -packaging==21.3 +idna==3.4 +importlib-metadata==4.13.0 +iniconfig==2.0.0 +ipykernel==6.25.1 +ipython==8.15.0 +ipython-genutils==0.2.0 +ipywidgets==8.1.0 +isoduration==20.11.0 +jaraco.classes==3.3.0 +jax==0.4.14 +jaxlib==0.4.14+cuda12.cudnn89 +jedi==0.19.0 +jeepney==0.8.0 +Jinja2==3.1.2 +jplephem==2.18 +json5==0.9.14 +jsonpointer==2.4 +jsonschema==4.19.0 +jsonschema-specifications==2023.7.1 +jupyter==1.0.0 +jupyter-console==6.6.3 +jupyter-events==0.7.0 +jupyter-lsp==2.2.0 +jupyter_client==8.3.1 +jupyter_core==5.3.1 +jupyter_server==2.7.3 +jupyter_server_terminals==0.4.4 +jupyterlab==4.0.5 +jupyterlab-pygments==0.2.2 +jupyterlab-widgets==3.0.8 +jupyterlab_server==2.24.0 +keyring==24.2.0 +kiwisolver==1.4.5 +lunarsky==0.2.1 +markdown-it-py==3.0.0 +MarkupSafe==2.1.3 +matplotlib==3.7.2 +matplotlib-inline==0.1.6 +mccabe==0.7.0 +mdurl==0.1.2 +mistune==3.0.1 +ml-dtypes==0.2.0 +more-itertools==10.1.0 +mypy==1.5.1 +mypy-extensions==1.0.0 +nbclient==0.8.0 +nbconvert==7.8.0 +nbformat==5.9.2 +nest-asyncio==1.5.7 +notebook==7.0.3 +notebook_shim==0.2.3 +numpy==1.23.0 +nvidia-cublas-cu12==12.2.5.6 +nvidia-cuda-cupti-cu12==12.2.142 +nvidia-cuda-nvcc-cu12==12.2.140 +nvidia-cuda-nvrtc-cu12==12.2.140 +nvidia-cuda-runtime-cu12==12.2.140 +nvidia-cudnn-cu12==8.9.4.25 +nvidia-cufft-cu12==11.0.8.103 +nvidia-cusolver-cu12==11.5.2.141 +nvidia-cusparse-cu12==12.1.2.141 +nvidia-nvjitlink-cu12==12.2.140 +opt-einsum==3.3.0 +overrides==7.4.0 +packaging==23.1 pandocfilters==1.5.0 -parso==0.8.1 +parso==0.8.3 +pathspec==0.11.2 pexpect==4.8.0 pickleshare==0.7.5 -Pillow==9.0.1 -ply==3.11 -prometheus-client==0.9.0 -prompt-toolkit==3.0.28 -protobuf==3.12.4 -proton-client==0.7.1 -protonvpn-cli==3.13.0 -protonvpn-nm-lib==3.16.0 +Pillow==10.0.0 +pkginfo==1.9.6 +platformdirs==3.10.0 +pluggy==1.3.0 +prometheus-client==0.17.1 +prompt-toolkit==3.0.39 +psutil==5.9.5 ptyprocess==0.7.0 -py==1.10.0 -pycairo==1.20.1 -pycodestyle==2.8.0 -pycups==2.0.1 -pyflakes==2.4.0 -pygccxml==2.2.1 -Pygments==2.11.2 -PyGObject==3.42.1 -PyJWT==2.3.0 -pymacaroons==0.13.0 -PyNaCl==1.5.0 -pynvim==0.4.2 -PyOpenGL==3.1.5 -pyOpenSSL==21.0.0 -pyparsing==2.4.7 -PyQt-Qwt==1.2.2 -PyQt5==5.15.6 -PyQt5-sip==12.9.1 -pyqtgraph==0.12.4 -pyRFC3339==1.1 -pyrsistent==0.18.1 -python-apt==2.4.0+ubuntu2 -python-dateutil==2.8.1 -python-debian==0.1.43+ubuntu1.1 -python-gnupg==0.4.8 -pythondialog==3.5.1 -pythran==0.10.0 -pytz==2022.1 -pyxdg==0.27 -PyYAML==5.4.1 -pyzmq==22.3.0 -reportlab==3.6.8 -requests==2.25.1 -requests-toolbelt==0.9.1 -scipy==1.8.0 -SecretStorage==3.3.1 -Send2Trash==1.8.1b0 +pure-eval==0.2.2 +pycodestyle==2.11.0 +pycparser==2.21 +pyephem==9.99 +pyerfa==2.0.0.3 +pyflakes==3.1.0 +pygdsm==1.3.0 +Pygments==2.16.1 +pyparsing==3.0.9 +pyproject_hooks==1.0.0 +pytest==7.4.0 +pytest-cov==4.1.0 +python-dateutil==2.8.2 +python-json-logger==2.0.7 +PyYAML==6.0.1 +pyzmq==25.1.1 +qtconsole==5.4.4 +QtPy==2.4.0 +readme-renderer==41.0 +referencing==0.30.2 +requests==2.31.0 +requests-toolbelt==1.0.0 +rfc3339-validator==0.1.4 +rfc3986==2.0.0 +rfc3986-validator==0.1.1 +rich==13.5.2 +rpds-py==0.10.0 +s2fft==0.0.1 +scipy==1.11.2 +SecretStorage==3.3.3 +Send2Trash==1.8.2 six==1.16.0 -soupsieve==2.3.1 -sympy==1.9 -systemd-python==234 -terminado==0.13.1 -testpath==0.5.0 -thrift==0.16.0 -tornado==6.1 -traitlets==5.1.1 -ubuntu-advantage-tools==8001 -ubuntu-drivers-common==0.0.0 -ufoLib2==0.13.1 -ufw==0.36.1 -unattended-upgrades==0.1 -unicodedata2==14.0.0 -urllib3==1.26.5 -wadllib==1.3.6 -wcwidth==0.2.5 +sniffio==1.3.0 +soupsieve==2.4.1 +spiceypy==6.0.0 +stack-data==0.6.2 +terminado==0.17.1 +tinycss2==1.2.1 +tomli==2.0.1 +tornado==6.3.3 +traitlets==5.9.0 +twine==4.0.2 +typing_extensions==4.7.1 +uri-template==1.3.0 +urllib3==2.0.4 +wcwidth==0.2.6 +webcolors==1.13 webencodings==0.5.1 -widgetsnbextension==2.0.0 -xdg==5 -xkit==0.0.0 -zipp==1.0.0 +websocket-client==1.6.2 +widgetsnbextension==4.0.8 +zipp==3.16.2 From 935cb24f6e6739e421436788d12ef2ae226f54a6 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 11 Sep 2023 14:04:21 -0700 Subject: [PATCH 046/129] downgrade astropy and jax for python 3.8 --- requirements.txt | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/requirements.txt b/requirements.txt index 8ae516d..7fa4f28 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,7 +2,7 @@ anyio==4.0.0 argon2-cffi==23.1.0 argon2-cffi-bindings==21.2.0 arrow==1.2.3 -astropy==5.3.2 +astropy==5.2.2 asttokens==2.2.1 async-lru==2.0.4 attrs==23.1.0 @@ -45,8 +45,7 @@ ipython-genutils==0.2.0 ipywidgets==8.1.0 isoduration==20.11.0 jaraco.classes==3.3.0 -jax==0.4.14 -jaxlib==0.4.14+cuda12.cudnn89 +jax==0.4.13 jedi==0.19.0 jeepney==0.8.0 Jinja2==3.1.2 From 984e5f0d031bfceb031edd94ea4937f3c91adb76 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 11 Sep 2023 14:07:03 -0700 Subject: [PATCH 047/129] downgrade ipython --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 7fa4f28..d4d06e9 100644 --- a/requirements.txt +++ b/requirements.txt @@ -40,7 +40,7 @@ idna==3.4 importlib-metadata==4.13.0 iniconfig==2.0.0 ipykernel==6.25.1 -ipython==8.15.0 +ipython==8.12.2 ipython-genutils==0.2.0 ipywidgets==8.1.0 isoduration==20.11.0 From c58e6a31c19378779a4f0aa692722099aff947e4 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 11 Sep 2023 14:09:37 -0700 Subject: [PATCH 048/129] add github path for s2fft --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index d4d06e9..76a08de 100644 --- a/requirements.txt +++ b/requirements.txt @@ -140,7 +140,7 @@ rfc3986==2.0.0 rfc3986-validator==0.1.1 rich==13.5.2 rpds-py==0.10.0 -s2fft==0.0.1 +s2fft @ git+https://github.com/astro-informatics/s2fft.git scipy==1.11.2 SecretStorage==3.3.3 Send2Trash==1.8.2 From d4ca33ffc83fd265b851577e8702d0a7836b0b47 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 11 Sep 2023 14:12:06 -0700 Subject: [PATCH 049/129] downgrade scipy --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 76a08de..25567bd 100644 --- a/requirements.txt +++ b/requirements.txt @@ -141,7 +141,7 @@ rfc3986-validator==0.1.1 rich==13.5.2 rpds-py==0.10.0 s2fft @ git+https://github.com/astro-informatics/s2fft.git -scipy==1.11.2 +scipy==1.10.1 SecretStorage==3.3.3 Send2Trash==1.8.2 six==1.16.0 From 91b3a88accbf7e59dd342fb5977b47a096f9996d Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 11 Sep 2023 19:52:48 -0700 Subject: [PATCH 050/129] =?UTF-8?q?modularize=20healpix.py=C3=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- croissant/crojax/healpix.py | 175 ++++++++++++++++--------- croissant/crojax/tests/test_healpix.py | 135 ++++++++++++------- 2 files changed, 201 insertions(+), 109 deletions(-) diff --git a/croissant/crojax/healpix.py b/croissant/crojax/healpix.py index 6cbb6fe..6c273c9 100644 --- a/croissant/crojax/healpix.py +++ b/croissant/crojax/healpix.py @@ -6,6 +6,7 @@ from .. import constants, utils +@jax.jit def lmax_from_shape(shape): """ Get the lmax from the shape of the alm array. @@ -13,6 +14,71 @@ def lmax_from_shape(shape): return shape[1] - 1 +@jax.jit +def _getlm(ix, lmax): + ell = ix[0] + emm = ix[1] - lmax + return ell, emm + + +@jax.jit +def _getidx(ell, emm, lmax): + l_ix = ell + m_ix = emm + lmax + return l_ix, m_ix + + +def _is_real(alm): + """ + Check if the alm coefficients correspond to a real-valued signal. + + Parameters + ---------- + alm : jnp.ndarray + The spherical harmonics coefficients. Must have shape + (nfreq, lmax+1, 2*lmax+1) corresponding to the frequencies, ell, and + emm indices. + + Returns + ------- + is_real : bool + True if the coefficients correspond to a real-valued signal. + + """ + lmax = lmax_from_shape(alm.shape) + emm = jnp.arange(1, lmax + 1)[None, None, :] # positive ms + # get alms for negative m, in reverse order (i.e., increasing abs(m)) + neg_m = alm[:, :, :lmax][:, :, ::-1] + # get alms for positive m + pos_m = alm[:, :, lmax + 1 :] + return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)).item() + + +def _rot_alm_z(lmax, phi): + """ + Get the coefficients that rotate the alms around the z-axis by phi + (measured counterclockwise). + + Parameters + ---------- + lmax : int + The maximum l value. + phi : jnp.ndarray + The angle(s) to rotate the azimuth by in radians. Must have shape + (n, 1). + + Returns + ------- + phase : np.ndarray + The coefficients that rotate the alms by phi. Has shape (n, 2*lmax+1), + where n is the number of phi values and 2*lmax+1 is the number of + m values given lmax. + """ + emms = jnp.arange(-lmax, lmax + 1)[None] + phase = jnp.exp(-1j * emms * phi) + return phase + + class Alm: def __init__(self, alm, frequencies=None, coord=None): """ @@ -60,6 +126,53 @@ def __getitem__(self, key): new_key = (key[0], lix, mix) return self.alm[new_key] + def getlm(self, ix): + """ + Get the l and m corresponding to the index of the alm array. + + Parameters + ---------- + ix : jnp.ndarray + The indices of the alm array. The first row corresponds to the l + index, and the second row corresponds to the m index. Multiple + indices can be passed in as an array with shape (2, n). + + Returns + ------- + ell : jnp.ndarray + The value of l. Has shape (n,). + emm : jnp.ndarray + The value of m. Has shape (n,). + """ + return _getlm(ix, self.lmax) + + def getidx(self, ell, emm): + """ + Get the index of the alm array for a given l and m. + + Parameters + ---------- + ell : int or jnp.ndarray + The value of l. + emm : int or jnp.ndarray + The value of m. + + Returns + ------- + l_ix : int or jnp.ndarray + The l index (which is the same as the input ell). + m_ix : int or jnp.ndarray + The m index. + + Raises + ------ + IndexError + If l,m don't satisfy abs(m) <= l <= lmax. + """ + if not ((jnp.abs(emm) <= ell) & (ell <= self.lmax)).all(): + raise IndexError("l,m must satsify abs(m) <= l <= lmax.") + return _getidx(ell, emm, self.lmax) + @classmethod def zeros(cls, lmax, frequencies=None, coord=None): """ @@ -81,12 +194,7 @@ def is_real(self): Check if the coefficients correspond to a real-valued signal. Mathematically, this means that alm(l, m) = (-1)^m * conj(alm(l, -m)). """ - emm = jnp.arange(1, self.lmax + 1)[None, None, :] # positive ms - # get alms for negative m, in reverse order (i.e., increasing abs(m)) - neg_m = self.alm[:, :, :self.lmax][:, :, ::-1] - # get alms for positive m - pos_m = self.alm[:, :, self.lmax + 1 :] - return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)).item() + return _is_real(self.alm) def reduce_lmax(self, new_lmax): """ @@ -114,55 +222,6 @@ def reduce_lmax(self, new_lmax): def switch_coords(self, to_coord, loc=None, time=None): raise NotImplementedError - def getlm(self, ix): - """ - Get the l and m corresponding to the index of the alm array. - - Parameters - ---------- - ix : tuple - The index of the alm array. - - Returns - ------- - ell : int - The value of l. - emm : int - The value of m. - """ - ell = ix[0] - emm = ix[1] - self.lmax - return ell, emm - - def getidx(self, ell, emm): - """ - Get the index of the alm array for a given l and m. - - Parameters - ---------- - ell : int - The value of l. - emm : int - The value of m. - - Returns - ------- - l_ix : int - The l index (which is the same as the input ell). - m_ix : int - The m index. - - Raises - ------ - IndexError - If l,m don't satisfy abs(m) <= l <= lmax. - """ - if not ((jnp.abs(emm) <= ell) & (ell <= self.lmax)).all(): - raise IndexError("l,m must satsify abs(m) <= l <= lmax.") - l_ix = ell - m_ix = emm + self.lmax - return l_ix, m_ix - def alm2map(self, sampling="healpix", nside=None, frequencies=None): """ Construct a Healpix map from the Alm for the given frequencies. @@ -247,7 +306,5 @@ def rot_alm_z(self, phi=None, times=None, world="moon"): ) phi = 2 * jnp.pi * times / sidereal_day return self.rot_alm_z(phi=phi, times=None) - - emms = jnp.arange(-self.lmax, self.lmax + 1) - phase = jnp.exp(-1j * emms[None, :] * phi[:, None]) - return phase + phi = phi[:, None] # add axis for broadcasting + return _rot_alm_z(self.lmax, phi) diff --git a/croissant/crojax/tests/test_healpix.py b/croissant/crojax/tests/test_healpix.py index e62ec14..0394968 100644 --- a/croissant/crojax/tests/test_healpix.py +++ b/croissant/crojax/tests/test_healpix.py @@ -11,7 +11,7 @@ freqs = jnp.linspace(1, 50, 50) nfreqs = freqs.size - +@pytest.mark.skip() def test_lmax_from_shape(lmax): s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) shape = (1, s1, s2) # add frequency axis @@ -19,6 +19,7 @@ def test_lmax_from_shape(lmax): assert _lmax == lmax +@pytest.mark.skip() def test_alm_indexing(lmax): # initialize all alms to 0 alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) @@ -55,6 +56,55 @@ def test_alm_indexing(lmax): alm[7, -1] +@pytest.mark.skip() +def test_getlm(lmax): + alm = hp.Alm.zeros(lmax=lmax) + nrows, ncols = alm.alm.shape[1:] + # l correspond to rows, m correspond to columns + ls = jnp.arange(nrows) + ms = jnp.arange(ncols) - lmax + for i in range(nrows): + for j in range(ncols): + ix = (i, j) + ell, emm = alm.getlm(ix) + assert ell == ls[i] + assert emm == ms[j] + +@pytest.mark.skip() +def test_getidx(lmax): + # using ints + ell = 3 + emm = 2 + ix = hp._getidx(ell, emm, lmax) + ell_, emm_ = hp._getlm(ix, lmax) + assert ell == ell_ + assert emm == emm_ + + # using arrays + ls = lmax // jnp.arange(1, 10) + ms = jnp.arange(-lmax, lmax + 1) + ixs = hp._getidx(ls, ms, lmax) + ls_, ms_ = hp._getlm(ixs, lmax) + assert jnp.allclose(ls, ls_) + assert jnp.allclose(ms, ms_) + + # using ell > lmax should raise error in class method + alm = hp.Alm.zeros(lmax=lmax) + ell = 3 + emm = 2 + bad_ell = 2 * lmax # bigger than lmax + bad_emm = 4 # bigger than ell + with pytest.raises(IndexError): + alm.getidx(bad_ell, emm) + alm.getidx(ell, bad_emm) + alm.getidx(-ell, emm) # should fail since l < 0 + + # check that error is raised if array contains bad ell + bad_ells = lmax + jnp.arange(-2, 2) + with pytest.raises(IndexError): + alm.getidx(bad_ells, emm) + +@pytest.mark.skip() def test_zeros(lmax): alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) assert alm.lmax == lmax @@ -74,13 +124,15 @@ def test_is_real(lmax): assert alm.is_real # generate a real signal and check that alm.is_real is True - sig = s2fft.utils.signal_generator.generate_flm(rng, lmax+1, reality=True) - alm = hp.Alm(sig[None]) - assert alm.is_real + alm = s2fft.utils.signal_generator.generate_flm(rng, lmax+1, reality=True) + alm = alm[None] # add frequency dimension + assert hp._is_real(alm) + assert hp.Alm(alm).is_real # complex - sig = s2fft.utils.signal_generator.generate_flm(rng, lmax+1, reality=False) - alm = hp.Alm(sig[None]) - assert not alm.is_real + alm = s2fft.utils.signal_generator.generate_flm(rng, lmax+1, reality=False) + alm = alm[None] # add frequency dimension + assert not hp._is_real(alm) + assert not hp.Alm(alm).is_real def test_reduce_lmax(lmax): @@ -107,45 +159,29 @@ def test_reduce_lmax(lmax): with pytest.raises(ValueError): alm.reduce_lmax(new_lmax) -@pytest.mark.skip(reason="not implemented") -def test_getlm(lmax): - pass - -def test_getidx(lmax): - alm = hp.Alm.zeros(lmax=lmax) - ell = 3 - emm = 2 - bad_ell = 2 * lmax # bigger than lmax - bad_emm = 4 # bigger than ell - with pytest.raises(IndexError): - alm.getidx(bad_ell, emm) - alm.getidx(ell, bad_emm) - alm.getidx(-ell, emm) # should fail since l < 0 - - # try convert back and forth ell, emm <-> index - for ell in lmax // jnp.arange(1, 10): - for emm in range(-ell, ell + 1): - ix = alm.getidx(ell, emm) - ell_, emm_ = alm.getlm(ix) - assert ell == ell_ - assert emm == emm_ - -@pytest.mark.skip(reason="not implemented") -def test_alm2map(lmax): +@pytest.mark.parametrize("sampling", ["mw", "healpix"]) +def test_alm2map(lmax, sampling): + if sampling == "healpix": + nside = lmax // 2 + else: + nside = None # make constant map alm = hp.Alm.zeros(lmax=lmax) a00 = 5 alm[0, 0, 0] = a00 - hp_map = alm.alm2map() # use different samplings i guess ... - assert jnp.allclose(hp_map, a00 * Y00) + m = alm.alm2map(sampling=sampling, nside=nside) + assert jnp.allclose(m, a00 * Y00) # make many maps frequencies = jnp.linspace(1, 50, 50) alm = hp.Alm.zeros(lmax=lmax, frequencies=frequencies) alm[:, 0, 0] = a00 * frequencies - hp_map = alm.alm2map() # XXX - assert jnp.allclose(hp_map, a00 * Y00) + m = alm.alm2map(sampling=sampling, nside=nside, frequencies=frequencies) + m_ = a00 * frequencies * Y00 + for i in range(m.ndim-1): + m_ = m_[:, None] # match dimensions of m + assert jnp.allclose(m, m_) # use subset of frequencies and compare to full set alm = hp.Alm.zeros(lmax=lmax, frequencies=frequencies) @@ -153,36 +189,35 @@ def test_alm2map(lmax): alm[:, 0, 0] = a00 * frequencies alm[:, 1, 1] = 2 * a00 * frequencies alm[::2, 8, 3] = -3 * a00 * frequencies[::2] - hp_map = alm.alm2map() # XXX - freq_indices = [10, 20, 35] # indices of frequencies to use + m = alm.alm2map(sampling=sampling, nside=nside, frequencies=frequencies) + freq_indices = jnp.array([10, 20, 35]) # indices of frequencies to use freqs = frequencies[freq_indices] # frequencies to use - hp_map_select = alm.alm2map(frequencies=freqs) # XXX - assert jnp.allclose(hp_map_select, hp_map[freq_indices]) + m_select = alm.alm2map(sampling=sampling, nside=nside, frequencies=freqs) + assert jnp.allclose(m_select, m[freq_indices]) # use some frequencies that are not in alm.frequencies + f = jnp.array([0, 30, 100]) with pytest.warns(UserWarning): - alm.alm2map(frequencies=[0, 30, 100]) # XXX + alm.alm2map(sampling=sampling, nside=nside, frequencies=f) -@pytest.mark.skip(reason="not implemented") def test_rot_alm_z(lmax): alm = hp.Alm.zeros(lmax=lmax) # rotate a single angle phi = jnp.pi / 2 phase = alm.rot_alm_z(phi=phi) - for ell in range(lmax + 1): - for emm in range(ell + 1): - ix = alm.getidx(ell, emm) - assert jnp.isclose(phase[ix], jnp.exp(-1j * emm * phi)) + ls = jnp.arange(lmax + 1) + ms = jnp.arange(-lmax, lmax + 1) + assert phase.shape == (1, ms.size) + assert jnp.allclose(phase, jnp.exp(-1j * ms * phi)) # rotate a set of angles phi = jnp.linspace(0, 2 * jnp.pi, num=361) # 1 deg spacing phase = alm.rot_alm_z(phi=phi) - for ell in range(lmax + 1): - for emm in range(ell + 1): - ix = alm.getidx(ell, emm) - assert jnp.allclose(phase[:, ix], jnp.exp(-1j * emm * phi)) + assert phase.shape == (phi.size, ms.size) + assert jnp.allclose(phase[0], jnp.exp(-1j * ms * phi[0])) + assert jnp.allclose(phase, jnp.exp(-1j * ms[None] * phi[:, None])) # check that phi = 0 and phi = 2pi give the same answer assert jnp.allclose(phase[0], phase[-1]) From 32fb9296b3e461c583d36102f4ccb3d14f33a0fd Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 14:57:01 -0700 Subject: [PATCH 051/129] fix vmap in alm2map --- croissant/crojax/healpix.py | 32 +++++++++++++++----------------- 1 file changed, 15 insertions(+), 17 deletions(-) diff --git a/croissant/crojax/healpix.py b/croissant/crojax/healpix.py index 6c273c9..d735640 100644 --- a/croissant/crojax/healpix.py +++ b/croissant/crojax/healpix.py @@ -64,8 +64,7 @@ def _rot_alm_z(lmax, phi): lmax : int The maximum l value. phi : jnp.ndarray - The angle(s) to rotate the azimuth by in radians. Must have shape - (n, 1). + The angle(s) to rotate the azimuth by in radians. Returns ------- @@ -74,6 +73,7 @@ def _rot_alm_z(lmax, phi): where n is the number of phi values and 2*lmax+1 is the number of m values given lmax. """ + phi = jnp.atleast_1d(phi)[:, None] emms = jnp.arange(-lmax, lmax + 1)[None] phase = jnp.exp(-1j * emms * phi) return phase @@ -257,19 +257,18 @@ def alm2map(self, sampling="healpix", nside=None, frequencies=None): UserWarning, ) alm = self.alm[indices] - m = jax.vmap( - partial( - s2fft.inverse_jax, - L=self.lmax + 1, - spin=0, - nside=nside, - sampling=sampling, - reality=self.is_real, - precomps=None, - spmd=False, - L_lower=0, - ) - )(alm) + inverse = partial( + s2fft.inverse_jax, + spin=0, + nside=nside, + sampling=sampling, + reality=self.is_real, + precomps=None, # XXX + spmd=True, # XXX + L_lower=0, + ) + L = self.lmax.item() + 1 + m = jax.vmap(inverse, in_axes=[0, None])(alm, L) return m def rot_alm_z(self, phi=None, times=None, world="moon"): @@ -290,7 +289,7 @@ def rot_alm_z(self, phi=None, times=None, world="moon"): Returns ------- - phase : np.ndarray + phase : jnp.ndarray The coefficients (shape = (phi.size, alm.size) that rotate the alms by phi. @@ -306,5 +305,4 @@ def rot_alm_z(self, phi=None, times=None, world="moon"): ) phi = 2 * jnp.pi * times / sidereal_day return self.rot_alm_z(phi=phi, times=None) - phi = phi[:, None] # add axis for broadcasting return _rot_alm_z(self.lmax, phi) From c58db8682f602d18041c014ee9bb917166aa5840 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 14:58:06 -0700 Subject: [PATCH 052/129] update and unskip tests --- croissant/crojax/tests/test_healpix.py | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/croissant/crojax/tests/test_healpix.py b/croissant/crojax/tests/test_healpix.py index 0394968..4c193f7 100644 --- a/croissant/crojax/tests/test_healpix.py +++ b/croissant/crojax/tests/test_healpix.py @@ -11,7 +11,7 @@ freqs = jnp.linspace(1, 50, 50) nfreqs = freqs.size -@pytest.mark.skip() + def test_lmax_from_shape(lmax): s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) shape = (1, s1, s2) # add frequency axis @@ -19,7 +19,6 @@ def test_lmax_from_shape(lmax): assert _lmax == lmax -@pytest.mark.skip() def test_alm_indexing(lmax): # initialize all alms to 0 alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) @@ -56,7 +55,6 @@ def test_alm_indexing(lmax): alm[7, -1] -@pytest.mark.skip() def test_getlm(lmax): alm = hp.Alm.zeros(lmax=lmax) nrows, ncols = alm.alm.shape[1:] @@ -70,7 +68,7 @@ def test_getlm(lmax): assert ell == ls[i] assert emm == ms[j] -@pytest.mark.skip() + def test_getidx(lmax): # using ints ell = 3 @@ -104,7 +102,7 @@ def test_getidx(lmax): with pytest.raises(IndexError): alm.getidx(bad_ells, emm) -@pytest.mark.skip() + def test_zeros(lmax): alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) assert alm.lmax == lmax @@ -124,19 +122,23 @@ def test_is_real(lmax): assert alm.is_real # generate a real signal and check that alm.is_real is True - alm = s2fft.utils.signal_generator.generate_flm(rng, lmax+1, reality=True) + alm = s2fft.utils.signal_generator.generate_flm( + rng, lmax + 1, reality=True + ) alm = alm[None] # add frequency dimension assert hp._is_real(alm) assert hp.Alm(alm).is_real # complex - alm = s2fft.utils.signal_generator.generate_flm(rng, lmax+1, reality=False) + alm = s2fft.utils.signal_generator.generate_flm( + rng, lmax + 1, reality=False + ) alm = alm[None] # add frequency dimension assert not hp._is_real(alm) assert not hp.Alm(alm).is_real def test_reduce_lmax(lmax): - sig = s2fft.utils.signal_generator.generate_flm(rng, lmax+1) + sig = s2fft.utils.signal_generator.generate_flm(rng, lmax + 1) alm = hp.Alm(sig[None]) old_alm = deepcopy(alm) # reduce to same lmax, should do nothing @@ -179,7 +181,7 @@ def test_alm2map(lmax, sampling): alm[:, 0, 0] = a00 * frequencies m = alm.alm2map(sampling=sampling, nside=nside, frequencies=frequencies) m_ = a00 * frequencies * Y00 - for i in range(m.ndim-1): + for i in range(m.ndim - 1): m_ = m_[:, None] # match dimensions of m assert jnp.allclose(m, m_) @@ -205,7 +207,7 @@ def test_rot_alm_z(lmax): alm = hp.Alm.zeros(lmax=lmax) # rotate a single angle - phi = jnp.pi / 2 + phi = jnp.array([jnp.pi / 2]) phase = alm.rot_alm_z(phi=phi) ls = jnp.arange(lmax + 1) ms = jnp.arange(-lmax, lmax + 1) @@ -224,9 +226,9 @@ def test_rot_alm_z(lmax): # rotate in time alm = hp.Alm.zeros(lmax=lmax) - div = [1, 2, 4, 8] + div = jnp.array([1, 2, 4, 8]) for d in div: - dphi = 2 * jnp.pi / d + dphi = jnp.array([2 * jnp.pi / d]) # earth dt = sidereal_day_earth / d assert jnp.allclose( From 8e04cd24b4848e0c4a22e448af56f25362c4f874 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 15:12:21 -0700 Subject: [PATCH 053/129] fix vmap --- croissant/crojax/beam.py | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/croissant/crojax/beam.py b/croissant/crojax/beam.py index c33d731..7e06396 100644 --- a/croissant/crojax/beam.py +++ b/croissant/crojax/beam.py @@ -56,15 +56,14 @@ def horizon_cut(self, horizon=None, sampling="mw", nside=None): horizon = horizon.at[:, theta > jnp.pi / 2].set(0.0) m = m * horizon - self.alm = jax.vmap( - partial( - s2fft.forward_jax, - L=self.lmax + 1, - spin=0, - nside=nside, - reality=self.is_real, - precomps=None, - spmd=False, - L_lower=0, - ) - )(m) + forward = partial( + s2fft.forward_jax, + spin=0, + nside=nside, + reality=self.is_real, + precomps=None, + spmd=True, + L_lower=0, + ) + L = self.lmax.item() + 1 + self.alm = jax.vmap(forward, in_axes=(0, None))(m, L) From 8ef3de40a2ecba71f70b789e64113aeaa9c395f3 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 15:12:38 -0700 Subject: [PATCH 054/129] fix syntax error in test --- croissant/crojax/tests/test_beam.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/croissant/crojax/tests/test_beam.py b/croissant/crojax/tests/test_beam.py index 149348b..e0b5186 100644 --- a/croissant/crojax/tests/test_beam.py +++ b/croissant/crojax/tests/test_beam.py @@ -5,11 +5,11 @@ from croissant.constants import Y00 from croissant.crojax import Beam +pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) frequencies = jnp.linspace(1, 50, 50) -lmax = 32 -def test_compute_total_power(): +def test_compute_total_power(lmax): # make a beam that is 1 everywhere so total power is 4pi: beam = Beam.zeros(lmax) beam[0, 0, 0] = 1 / Y00 @@ -26,7 +26,7 @@ def test_compute_total_power(): assert jnp.allclose(power, expected_power.ravel()) -def test_horizon_cut(): +def test_horizon_cut(lmax): # make a beam that is 1 everywhere beam_base = Beam.zeros(lmax) beam_base[0, 0, 0] = 1 / Y00 @@ -37,7 +37,7 @@ def test_horizon_cut(): # default horizon (multiple frequencies) beam_nf = Beam.zeros(lmax, frequencies=frequencies) - beam[:, 0, 0] = 1 / Y00 + beam_nf[:, 0, 0] = 1 / Y00 beam_nf.horizon_cut() # doesn't throw error assert jnp.allclose(beam_nf.alm, beam.alm) From 6bfbb4a872c06a12501fdd90049018caa98e5750 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 15:14:11 -0700 Subject: [PATCH 055/129] remove unused variable --- croissant/crojax/tests/test_healpix.py | 1 - 1 file changed, 1 deletion(-) diff --git a/croissant/crojax/tests/test_healpix.py b/croissant/crojax/tests/test_healpix.py index 4c193f7..4567b3e 100644 --- a/croissant/crojax/tests/test_healpix.py +++ b/croissant/crojax/tests/test_healpix.py @@ -209,7 +209,6 @@ def test_rot_alm_z(lmax): # rotate a single angle phi = jnp.array([jnp.pi / 2]) phase = alm.rot_alm_z(phi=phi) - ls = jnp.arange(lmax + 1) ms = jnp.arange(-lmax, lmax + 1) assert phase.shape == (1, ms.size) assert jnp.allclose(phase, jnp.exp(-1j * ms * phi)) From a35b02dd8ad23fc852b8e6d85135d7206db15be7 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 15:19:14 -0700 Subject: [PATCH 056/129] initial commit --- croissant/crojax/tests/__init__.py | 0 croissant/tests/__init__.py | 0 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 croissant/crojax/tests/__init__.py create mode 100644 croissant/tests/__init__.py diff --git a/croissant/crojax/tests/__init__.py b/croissant/crojax/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/croissant/tests/__init__.py b/croissant/tests/__init__.py new file mode 100644 index 0000000..e69de29 From 70c944edee96019d2f0f06a6cfdbdfe8be9060ab Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 16:06:53 -0700 Subject: [PATCH 057/129] initial commit --- croissant/crojax/sky.py | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 croissant/crojax/sky.py diff --git a/croissant/crojax/sky.py b/croissant/crojax/sky.py new file mode 100644 index 0000000..147173e --- /dev/null +++ b/croissant/crojax/sky.py @@ -0,0 +1,35 @@ +from functools import partial +import jax +import s2fft +from pygdsm import GlobalSkyModel2016 as GSM16 +from .healpix import Alm + + +class Sky(Alm): + @classmethod + def gsm(cls, freq, lmax): + """ + Construct a sky object with pygdsm. + + Parameters + ---------- + freq : jnp.ndarray + Frequencies to make map at in MHz. + lmax : int + Maximum multipole to compute alm up to. + """ + gsm = GSM16(freq_unit="MHz", data_unit="TRJ", resolution="lo") + sky_map = gsm.generate(freq) + forward = partial( + s2fft.forward_jax, + spin=0, + nside=gsm.nside, + reality=True, + precomps=None, + spmd=True, + L_lower=0, + ) + L = lmax + 1 + sky_alm = jax.vmap(forward, in_axes=[0, None])(sky_map, L) + obj = cls(sky_alm, frequencies=freq, coord="G") + return obj From adc0af4b0ad6f3f5b672377eb4b14adc71a73752 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 16:07:06 -0700 Subject: [PATCH 058/129] import Sky class --- croissant/crojax/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/croissant/crojax/__init__.py b/croissant/crojax/__init__.py index 1b16e76..5956e9a 100644 --- a/croissant/crojax/__init__.py +++ b/croissant/crojax/__init__.py @@ -5,3 +5,4 @@ from .beam import Beam from .healpix import Alm +from .sky import Sky From d49dad16b7f20819d44747ddc9fee8043ff75101 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 16:27:38 -0700 Subject: [PATCH 059/129] add sampling kwarg --- croissant/crojax/beam.py | 1 + croissant/crojax/sky.py | 3 +++ 2 files changed, 4 insertions(+) diff --git a/croissant/crojax/beam.py b/croissant/crojax/beam.py index 7e06396..c918485 100644 --- a/croissant/crojax/beam.py +++ b/croissant/crojax/beam.py @@ -60,6 +60,7 @@ def horizon_cut(self, horizon=None, sampling="mw", nside=None): s2fft.forward_jax, spin=0, nside=nside, + sampling=sampling, reality=self.is_real, precomps=None, spmd=True, diff --git a/croissant/crojax/sky.py b/croissant/crojax/sky.py index 147173e..28c8cbf 100644 --- a/croissant/crojax/sky.py +++ b/croissant/crojax/sky.py @@ -1,5 +1,6 @@ from functools import partial import jax +import jax.numpy as jnp import s2fft from pygdsm import GlobalSkyModel2016 as GSM16 from .healpix import Alm @@ -20,10 +21,12 @@ def gsm(cls, freq, lmax): """ gsm = GSM16(freq_unit="MHz", data_unit="TRJ", resolution="lo") sky_map = gsm.generate(freq) + sky_map = jnp.atleast_2d(sky_map) forward = partial( s2fft.forward_jax, spin=0, nside=gsm.nside, + sampling="healpix", reality=True, precomps=None, spmd=True, From 70f1e54db11697eb494e73ca96109a93d55f3afd Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 16:28:10 -0700 Subject: [PATCH 060/129] update example nb down to sky --- notebooks/jax_example.ipynb | 75 ++++++++++++++++++++++++------------- 1 file changed, 50 insertions(+), 25 deletions(-) diff --git a/notebooks/jax_example.ipynb b/notebooks/jax_example.ipynb index 3ec6b11..4973c97 100644 --- a/notebooks/jax_example.ipynb +++ b/notebooks/jax_example.ipynb @@ -13,6 +13,7 @@ "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "import s2fft\n", + "from healpy import mollview\n", "from croissant import crojax" ] }, @@ -64,14 +65,13 @@ "sampling = \"mw\" # mw, mwss, dh, healpix\n", "if sampling == \"healpix\":\n", " nside = 2 * lmax\n", - "hpm = beam.alm2map(sampling=sampling, nside=nside, frequencies=freq)\n", - "print(hpm.shape)\n", + "m = beam.alm2map(sampling=sampling, nside=nside, frequencies=freq)\n", + "print(m.shape)\n", "if sampling == \"healpix\":\n", - " import healpy\n", - " healpy.mollview(hpm[0])\n", + " mollview(m[0])\n", "else:\n", " plt.figure()\n", - " plt.imshow(hpm[0], aspect=\"auto\")\n", + " plt.imshow(m[0], aspect=\"auto\")\n", " plt.colorbar()\n", " plt.show()" ] @@ -83,7 +83,6 @@ "metadata": {}, "outputs": [], "source": [ - "# plotting functions\n", "# precompute ..." ] }, @@ -94,22 +93,25 @@ "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'partial' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[4], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# we can impose a horizon like this, note that the sharp edge creates ripples since we don't have an inifinite lmax\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43mbeam\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhorizon_cut\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m#hp.mollview(beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/projects/croissant/.venv/lib/python3.10/site-packages/croissant/crojax/beam.py:59\u001b[0m, in \u001b[0;36mBeam.horizon_cut\u001b[0;34m(self, horizon, sampling, nside)\u001b[0m\n\u001b[1;32m 55\u001b[0m horizon\u001b[38;5;241m.\u001b[39mat[:, theta \u001b[38;5;241m>\u001b[39m jnp\u001b[38;5;241m.\u001b[39mpi \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m]\u001b[38;5;241m.\u001b[39mset(\u001b[38;5;241m0.0\u001b[39m)\n\u001b[1;32m 57\u001b[0m m \u001b[38;5;241m=\u001b[39m m \u001b[38;5;241m*\u001b[39m horizon\n\u001b[1;32m 58\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39malm \u001b[38;5;241m=\u001b[39m jax\u001b[38;5;241m.\u001b[39mvmap(\n\u001b[0;32m---> 59\u001b[0m \u001b[43mpartial\u001b[49m(\n\u001b[1;32m 60\u001b[0m s2fft\u001b[38;5;241m.\u001b[39mforward_jax,\n\u001b[1;32m 61\u001b[0m L\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlmax \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m,\n\u001b[1;32m 62\u001b[0m spin\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m,\n\u001b[1;32m 63\u001b[0m nside\u001b[38;5;241m=\u001b[39mnside,\n\u001b[1;32m 64\u001b[0m reality\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mis_real,\n\u001b[1;32m 65\u001b[0m precomps\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 66\u001b[0m spmd\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m 67\u001b[0m L_lower\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m,\n\u001b[1;32m 68\u001b[0m )\n\u001b[1;32m 69\u001b[0m )(m)\n", - "\u001b[0;31mNameError\u001b[0m: name 'partial' is not defined" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# we can impose a horizon like this, note that the sharp edge creates ripples since we don't have an inifinite lmax\n", + "# we can impose a horizon like this, ripples are due to finite lmax (a sharp edge requires infinite ell)\n", "beam.horizon_cut()\n", - "#hp.mollview(beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")" + "m = beam.alm2map(sampling=sampling, nside=nside, frequencies=freq[0])\n", + "plt.figure()\n", + "plt.imshow(m[0], aspect=\"auto\")\n", + "plt.colorbar()\n", + "plt.show()\n", + "#mollview(m[0], title=f\"Beam at {freq[0]:.0f} MHz\")" ] }, { @@ -122,24 +124,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "6d25d25a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "sky = cro.Sky.gsm(beam.frequencies, lmax=beam.lmax)\n", - "hp.mollview(sky.hp_map(nside)[0], title=f\"Sky at {freq[0]:.0f} MHz\")" + "sky = crojax.Sky.gsm(beam.frequencies, lmax=beam.lmax.item())\n", + "m = sky.alm2map(sampling=\"healpix\", nside=64, frequencies=freq[0])\n", + "mollview(m[0], title=f\"Sky at {freq[0]:.0f} MHz\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "9a5e0c5e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", - "plt.plot(sky.frequencies, np.real(sky[:, 0, 0]), label=\"Sky monopole spectrum\")\n", + "plt.plot(sky.frequencies, jnp.real(sky[:, 0, 0]), label=\"Sky monopole spectrum\")\n", "plt.xlabel(\"Frequency [MHz]\")\n", "plt.ylabel(\"Temperature [K]\")\n", "plt.xlim(sky.frequencies.min(), sky.frequencies.max())\n", From b3dfab359d0e9267c25da6cb2d6a7badeb72a181 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 17:40:56 -0700 Subject: [PATCH 061/129] move sim and dpss up one level, make new simualtor subclasses --- croissant/__init__.py | 2 + croissant/core/__init__.py | 2 +- croissant/core/simulator.py | 206 +---------------------- croissant/core/tests/test_simulator.py | 116 +------------ croissant/{core => }/dpss.py | 0 croissant/simulatorbase.py | 208 ++++++++++++++++++++++++ croissant/{core => }/tests/test_dpss.py | 0 croissant/tests/test_simulator.py | 117 +++++++++++++ 8 files changed, 335 insertions(+), 316 deletions(-) rename croissant/{core => }/dpss.py (100%) create mode 100644 croissant/simulatorbase.py rename croissant/{core => }/tests/test_dpss.py (100%) create mode 100644 croissant/tests/test_simulator.py diff --git a/croissant/__init__.py b/croissant/__init__.py index 5a7d700..04b713f 100644 --- a/croissant/__init__.py +++ b/croissant/__init__.py @@ -4,5 +4,7 @@ from . import constants from . import core from . import crojax +from . import dpss +from . import utils from .core import * # noqa F403 diff --git a/croissant/core/__init__.py b/croissant/core/__init__.py index e3b59ed..c89a908 100644 --- a/croissant/core/__init__.py +++ b/croissant/core/__init__.py @@ -1,4 +1,4 @@ -from . import dpss, sphtransform +from . import sphtransform from .healpix import Alm, HealpixMap from .beam import Beam from .rotations import Rotator diff --git a/croissant/core/simulator.py b/croissant/core/simulator.py index 53ecfc2..dfab9eb 100644 --- a/croissant/core/simulator.py +++ b/croissant/core/simulator.py @@ -1,168 +1,8 @@ -from astropy import units -from astropy.coordinates import EarthLocation -from copy import deepcopy -from lunarsky import MoonLocation, Time -import matplotlib.pyplot as plt import numpy as np -import warnings +from ..simulator import SimulatorBase -from . import dpss - - -def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): - """ - Generate an array of evenly sampled times to run the simulation at. - - Parameters - ---------- - t_start : str or astropy.time.Time - The start time of the simulation. - t_end : str or astropy.time.Time - The end time of the simulation. - N_times : int - The number of times to run the simulation at. - delta_t : float or astropy.units.Quantity - The time step between each time in the simulation. - - Returns - ------- - times : astropy.time.Time or astropy.units.Quantity - The evenly sampled times to run the simulation at. - - """ - - if t_start is not None: - t_start = Time(t_start, scale="utc") - - try: - dt = np.arange(N_times) * delta_t - except TypeError: - t_end = Time(t_end, scale="utc") - total_time = (t_end - t_start).sec - if N_times is None: - try: - delta_t = delta_t.to_value("s") - except AttributeError: - warnings.warn( - "delta_t is not an astropy.units.Quantity. Assuming " - "units of seconds.", - UserWarning, - ) - dt = np.arange(0, total_time + delta_t, delta_t) - else: - dt = np.linspace(0, total_time, N_times) - dt = dt * units.s - - if t_start is None: - times = dt - else: - times = t_start + dt - - return times - - -class Simulator: - def __init__( - self, - beam, - sky, - lmax=None, - frequencies=None, - world="moon", - location=None, - times=None, - ): - """ - Simulator class. Prepares and runs simulations. - """ - self.world = world.lower() - # set up frequencies to run the simulation at - if frequencies is None: - frequencies = sky.frequencies - self.frequencies = frequencies - if self.world == "moon": - Location = MoonLocation - self.sim_coord = "M" # mcmf - elif self.world == "earth": - Location = EarthLocation - self.sim_coord = "C" # equatorial - else: - raise KeyError('Keyword ``world\'\' must be "earth" or "moon".') - - try: - self.location = Location(*location) - except TypeError: # location is None or already Location - self.location = location - if isinstance(location, EarthLocation) and self.world == "moon": - raise TypeError( - "location is an EarthLocation but world is 'moon'." - ) - if isinstance(location, MoonLocation) and self.world == "earth": - raise TypeError( - "location is a MoonLocation but world is 'earth'." - ) - - if lmax is None: - lmax = np.min([beam.lmax, sky.lmax]) - else: - lmax = np.min([lmax, beam.lmax, sky.lmax]) - self.lmax = lmax - - if times is None: - self.times = np.array([0]) - t_start = None - elif isinstance(times, Time): - self.times = times - t_start = times[0] - else: - self.times = times - t_start = None - - dt = self.times - self.times[0] - try: - self.dt = dt.sec - except AttributeError: - self.dt = dt - self.N_times = self.dt.size - - # initialize beam and sky - self.beam = deepcopy(beam) - if not hasattr(self.beam, "total_power"): - self.beam.compute_total_power() - if self.beam.coord != self.sim_coord: - self.beam.switch_coords( - self.sim_coord, loc=self.location, time=t_start - ) - if self.beam.lmax > self.lmax: - self.beam.reduce_lmax(self.lmax) - self.sky = deepcopy(sky) - if self.sky.coord != self.sim_coord: - self.sky.switch_coords( - self.sim_coord, loc=self.location, time=t_start - ) - if self.sky.lmax > self.lmax: - self.sky.reduce_lmax(self.lmax) - - def compute_dpss(self, **kwargs): - # generate the set of target frequencies (subset of all freqs) - x = np.unique( - np.concatenate( - ( - self.beam.frequencies, - self.frequencies, - ), - axis=None, - ) - ) - - self.design_matrix = dpss.dpss_op(x, **kwargs) - self.beam.coeffs = dpss.freq2dpss( - self.beam.alm, - self.beam.frequencies, - self.frequencies, - self.design_matrix, - ) +class Simulator(SimulatorBase): def run(self, dpss=True, **dpss_kwargs): """ Compute the convolution for a range of times. @@ -212,45 +52,3 @@ def run(self, dpss=True, **dpss_kwargs): ) self.waterfall = np.squeeze(waterfall) / self.beam.total_power - - def plot( - self, - figsize=None, - extent=None, - interpolation="none", - aspect="auto", - power=0, - ): - """ - Plot the result of the simulation. - """ - if self.times[0] == 0: - time_label = "Time [hours]" - else: - t_start = self.times[0].to_value("iso", subfmt="date_hm") - time_label = f"Hours since {t_start}" - temp_label = "Temperature [K]" - plt.figure(figsize=figsize) - if self.waterfall.ndim == 1: # no frequency axis - plt.plot(self.dt / 3600, self.waterfall) - plt.xlabel(time_label) - plt.ylabel(temp_label) - else: - if extent is None: - extent = [ - self.frequencies.min(), - self.frequencies.max(), - self.dt[-1] / 3600, - 0, - ] - weight = self.frequencies**power - plt.imshow( - self.waterfall * weight.reshape(1, -1), - extent=extent, - aspect=aspect, - interpolation=interpolation, - ) - plt.colorbar(label=temp_label) - plt.xlabel("Frequency [MHz]") - plt.ylabel(time_label) - plt.show() diff --git a/croissant/core/tests/test_simulator.py b/croissant/core/tests/test_simulator.py index 8617e94..014c7ed 100644 --- a/croissant/core/tests/test_simulator.py +++ b/croissant/core/tests/test_simulator.py @@ -1,121 +1,15 @@ +import numpy as np from astropy import units -from astropy.coordinates import EarthLocation -from copy import deepcopy import healpy as hp -from lunarsky import MoonLocation, Time -import numpy as np -import pytest - -from croissant import Beam, dpss, Rotator, Simulator, Sky -from croissant.constants import sidereal_day_earth -from croissant.core.simulator import time_array +from croissant import Beam, Simulator, Sky +from croissant.simulatorbase import time_array - -# define default params for simulator -lmax = 32 -frequencies = np.linspace(10, 50, 10) -theta = np.linspace(0, np.pi, 181) -phi = np.linspace(0, 2 * np.pi, 360, endpoint=False) -power = frequencies[:, None, None] ** 2 * np.cos(theta[None, :, None]) ** 2 -power = np.repeat(power, phi.size, axis=2) -beam = Beam.from_grid( - power, theta, phi, lmax, frequencies=frequencies, coord="T" -) -sky = Sky.gsm(frequencies, lmax=lmax) -loc = (137.0, 40.0) # (lon, lat) in degrees +loc = (137.0, 40.0) t_start = "2022-06-10 12:59:00" N_times = 150 delta_t = 3600 * units.s times = time_array(t_start=t_start, N_times=N_times, delta_t=delta_t) -args = (beam, sky) -kwargs = {"lmax": lmax, "world": "moon", "location": loc, "times": times} - - -def test_time_array(): - # check that the times are set consistently regardless of - # which parameters that specify it - delta_t, step = np.linspace(0, sidereal_day_earth, N_times, retstep=True) - delta_t = delta_t * units.s - step = step * units.s - t_end = Time(t_start) + delta_t[-1] - # specify end, ntimes: - times = time_array(t_start, t_end=t_end, N_times=N_times) - assert np.allclose(delta_t.value, (times - times[0]).sec) - # specify end, delta t - times = time_array(t_start, t_end=t_end, delta_t=step) - assert np.allclose(delta_t.value, (times - times[0]).sec) - # specify ntimes, delta t - times = time_array(t_start, N_times=N_times, delta_t=step) - assert np.allclose(delta_t.value, (times - times[0]).sec) - times = time_array(N_times=N_times, delta_t=step) - assert np.allclose(times, np.arange(N_times) * step) - # check that we get a UserWarning if delta t does not have units - delta_t = 2 - with pytest.warns(UserWarning): - time_array(t_start, t_end=t_end, delta_t=delta_t) - - -def test_simulator_init(): - sim = Simulator(*args, **kwargs) - # check that the simulation attributes are set properly - assert sim.sim_coord == "M" # mcmf - assert sim.location == MoonLocation(*loc) - # check sky is in the desired simulation coords - assert sim.sky.coord == sim.sim_coord - rot = Rotator(coord="gm") - sky_alm = rot.rotate_alm(sky.alm, lmax=sky.lmax) - assert np.allclose(sim.sky.alm, sky_alm) - - # test lmax - beam_lmax = 10 # smaller than sky lmax - beam2 = deepcopy(beam) - beam2.reduce_lmax(beam_lmax) - sim = Simulator(beam2, sky, **kwargs) - assert sim.lmax == np.min([sky.lmax, beam2.lmax]) == beam_lmax - assert sim.beam.lmax == sim.sky.lmax == sim.lmax - kwargs["lmax"] = None - sim = Simulator(beam2, sky, **kwargs) - assert sim.lmax == np.min([sky.lmax, beam2.lmax]) == beam_lmax - assert sim.beam.lmax == sim.sky.lmax == sim.lmax - kwargs["lmax"] = lmax - - # use a Location object instead of a tuple - earth_loc = EarthLocation(*loc) - kwargs["location"] = earth_loc - with pytest.raises(TypeError): - Simulator(*args, **kwargs) # loc is EarthLocation, world is moon - moon_loc = MoonLocation(*loc) - kwargs["location"] = moon_loc - sim = Simulator(*args, **kwargs) - assert sim.location == moon_loc - - # check that init works correctly on earth - kwargs["world"] = "earth" - with pytest.raises(TypeError): - Simulator(*args, **kwargs) # loc is MoonLocation, world is earth - kwargs["location"] = earth_loc - sim = Simulator(*args, **kwargs) - assert sim.sim_coord == "C" - assert sim.location == earth_loc - kwargs["location"] = loc - - # check that we get a KeyError if world is not "earth" or "moon" - kwargs["world"] = "mars" - with pytest.raises(KeyError): - Simulator(*args, **kwargs) - - kwargs["world"] = "moon" - - -def test_compute_dpss(): - sim = Simulator(*args, **kwargs) - sim.compute_dpss(nterms=10) - design_matrix = dpss.dpss_op(frequencies, nterms=10) - assert np.allclose(design_matrix, sim.design_matrix) - beam_coeff = dpss.freq2dpss( - sim.beam.alm, frequencies, frequencies, design_matrix - ) - assert np.allclose(beam_coeff, sim.beam.coeffs) +kwargs = {"world": "moon", "location": loc, "times": times} def test_run(): diff --git a/croissant/core/dpss.py b/croissant/dpss.py similarity index 100% rename from croissant/core/dpss.py rename to croissant/dpss.py diff --git a/croissant/simulatorbase.py b/croissant/simulatorbase.py new file mode 100644 index 0000000..48dd88a --- /dev/null +++ b/croissant/simulatorbase.py @@ -0,0 +1,208 @@ +from astropy import units +from astropy.coordinates import EarthLocation +from copy import deepcopy +from lunarsky import MoonLocation, Time +import matplotlib.pyplot as plt +import numpy as np +import warnings + +from . import dpss + + +def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): + """ + Generate an array of evenly sampled times to run the simulation at. + + Parameters + ---------- + t_start : str or astropy.time.Time + The start time of the simulation. + t_end : str or astropy.time.Time + The end time of the simulation. + N_times : int + The number of times to run the simulation at. + delta_t : float or astropy.units.Quantity + The time step between each time in the simulation. + + Returns + ------- + times : astropy.time.Time or astropy.units.Quantity + The evenly sampled times to run the simulation at. + + """ + + if t_start is not None: + t_start = Time(t_start, scale="utc") + + try: + dt = np.arange(N_times) * delta_t + except TypeError: + t_end = Time(t_end, scale="utc") + total_time = (t_end - t_start).sec + if N_times is None: + try: + delta_t = delta_t.to_value("s") + except AttributeError: + warnings.warn( + "delta_t is not an astropy.units.Quantity. Assuming " + "units of seconds.", + UserWarning, + ) + dt = np.arange(0, total_time + delta_t, delta_t) + else: + dt = np.linspace(0, total_time, N_times) + dt = dt * units.s + + if t_start is None: + times = dt + else: + times = t_start + dt + + return times + + +class SimulatorBase: + def __init__( + self, + beam, + sky, + lmax=None, + frequencies=None, + world="moon", + location=None, + times=None, + ): + """ + BaseSimulator class. Prepares simulations. End users should use the + subclasses in core/simulator.py and crojax/simulator.py to + instantiate this class and run simulations. + """ + self.world = world.lower() + # set up frequencies to run the simulation at + if frequencies is None: + frequencies = sky.frequencies + self.frequencies = frequencies + if self.world == "moon": + Location = MoonLocation + self.sim_coord = "M" # mcmf + elif self.world == "earth": + Location = EarthLocation + self.sim_coord = "C" # equatorial + else: + raise KeyError('Keyword ``world\'\' must be "earth" or "moon".') + + try: + self.location = Location(*location) + except TypeError: # location is None or already Location + self.location = location + if isinstance(location, EarthLocation) and self.world == "moon": + raise TypeError( + "location is an EarthLocation but world is 'moon'." + ) + if isinstance(location, MoonLocation) and self.world == "earth": + raise TypeError( + "location is a MoonLocation but world is 'earth'." + ) + + if lmax is None: + lmax = np.min([beam.lmax, sky.lmax]) + else: + lmax = np.min([lmax, beam.lmax, sky.lmax]) + self.lmax = lmax + + if times is None: + self.times = np.array([0]) + t_start = None + elif isinstance(times, Time): + self.times = times + t_start = times[0] + else: + self.times = times + t_start = None + + dt = self.times - self.times[0] + try: + self.dt = dt.sec + except AttributeError: + self.dt = dt + self.N_times = self.dt.size + + # initialize beam and sky + self.beam = deepcopy(beam) + if not hasattr(self.beam, "total_power"): + self.beam.compute_total_power() + if self.beam.coord != self.sim_coord: + self.beam.switch_coords( + self.sim_coord, loc=self.location, time=t_start + ) + if self.beam.lmax > self.lmax: + self.beam.reduce_lmax(self.lmax) + self.sky = deepcopy(sky) + if self.sky.coord != self.sim_coord: + self.sky.switch_coords( + self.sim_coord, loc=self.location, time=t_start + ) + if self.sky.lmax > self.lmax: + self.sky.reduce_lmax(self.lmax) + + def compute_dpss(self, **kwargs): + # generate the set of target frequencies (subset of all freqs) + x = np.unique( + np.concatenate( + ( + self.beam.frequencies, + self.frequencies, + ), + axis=None, + ) + ) + + self.design_matrix = dpss.dpss_op(x, **kwargs) + self.beam.coeffs = dpss.freq2dpss( + self.beam.alm, + self.beam.frequencies, + self.frequencies, + self.design_matrix, + ) + + def plot( + self, + figsize=None, + extent=None, + interpolation="none", + aspect="auto", + power=0, + ): + """ + Plot the result of the simulation. + """ + if self.times[0] == 0: + time_label = "Time [hours]" + else: + t_start = self.times[0].to_value("iso", subfmt="date_hm") + time_label = f"Hours since {t_start}" + temp_label = "Temperature [K]" + plt.figure(figsize=figsize) + if self.waterfall.ndim == 1: # no frequency axis + plt.plot(self.dt / 3600, self.waterfall) + plt.xlabel(time_label) + plt.ylabel(temp_label) + else: + if extent is None: + extent = [ + self.frequencies.min(), + self.frequencies.max(), + self.dt[-1] / 3600, + 0, + ] + weight = self.frequencies**power + plt.imshow( + self.waterfall * weight.reshape(1, -1), + extent=extent, + aspect=aspect, + interpolation=interpolation, + ) + plt.colorbar(label=temp_label) + plt.xlabel("Frequency [MHz]") + plt.ylabel(time_label) + plt.show() diff --git a/croissant/core/tests/test_dpss.py b/croissant/tests/test_dpss.py similarity index 100% rename from croissant/core/tests/test_dpss.py rename to croissant/tests/test_dpss.py diff --git a/croissant/tests/test_simulator.py b/croissant/tests/test_simulator.py new file mode 100644 index 0000000..2d898ca --- /dev/null +++ b/croissant/tests/test_simulator.py @@ -0,0 +1,117 @@ +from astropy import units +from astropy.coordinates import EarthLocation +from copy import deepcopy +from lunarsky import MoonLocation, Time +import numpy as np +import pytest + +from croissant import Beam, dpss, Rotator, Sky +from croissant.constants import sidereal_day_earth +from croissant.simulatorbase import SimulatorBase, time_array + + +# define default params for simulator +lmax = 32 +frequencies = np.linspace(10, 50, 10) +theta = np.linspace(0, np.pi, 181) +phi = np.linspace(0, 2 * np.pi, 360, endpoint=False) +power = frequencies[:, None, None] ** 2 * np.cos(theta[None, :, None]) ** 2 +power = np.repeat(power, phi.size, axis=2) +beam = Beam.from_grid( + power, theta, phi, lmax, frequencies=frequencies, coord="T" +) +sky = Sky.gsm(frequencies, lmax=lmax) +loc = (137.0, 40.0) # (lon, lat) in degrees +t_start = "2022-06-10 12:59:00" +N_times = 150 +delta_t = 3600 * units.s +times = time_array(t_start=t_start, N_times=N_times, delta_t=delta_t) +args = (beam, sky) +kwargs = {"lmax": lmax, "world": "moon", "location": loc, "times": times} + + +def test_time_array(): + # check that the times are set consistently regardless of + # which parameters that specify it + delta_t, step = np.linspace(0, sidereal_day_earth, N_times, retstep=True) + delta_t = delta_t * units.s + step = step * units.s + t_end = Time(t_start) + delta_t[-1] + # specify end, ntimes: + times = time_array(t_start, t_end=t_end, N_times=N_times) + assert np.allclose(delta_t.value, (times - times[0]).sec) + # specify end, delta t + times = time_array(t_start, t_end=t_end, delta_t=step) + assert np.allclose(delta_t.value, (times - times[0]).sec) + # specify ntimes, delta t + times = time_array(t_start, N_times=N_times, delta_t=step) + assert np.allclose(delta_t.value, (times - times[0]).sec) + times = time_array(N_times=N_times, delta_t=step) + assert np.allclose(times, np.arange(N_times) * step) + # check that we get a UserWarning if delta t does not have units + delta_t = 2 + with pytest.warns(UserWarning): + time_array(t_start, t_end=t_end, delta_t=delta_t) + + +def test_simulator_init(): + sim = SimulatorBase(*args, **kwargs) + # check that the simulation attributes are set properly + assert sim.sim_coord == "M" # mcmf + assert sim.location == MoonLocation(*loc) + # check sky is in the desired simulation coords + assert sim.sky.coord == sim.sim_coord + rot = Rotator(coord="gm") + sky_alm = rot.rotate_alm(sky.alm, lmax=sky.lmax) + assert np.allclose(sim.sky.alm, sky_alm) + + # test lmax + beam_lmax = 10 # smaller than sky lmax + beam2 = deepcopy(beam) + beam2.reduce_lmax(beam_lmax) + sim = SimulatorBase(beam2, sky, **kwargs) + assert sim.lmax == np.min([sky.lmax, beam2.lmax]) == beam_lmax + assert sim.beam.lmax == sim.sky.lmax == sim.lmax + kwargs["lmax"] = None + sim = SimulatorBase(beam2, sky, **kwargs) + assert sim.lmax == np.min([sky.lmax, beam2.lmax]) == beam_lmax + assert sim.beam.lmax == sim.sky.lmax == sim.lmax + kwargs["lmax"] = lmax + + # use a Location object instead of a tuple + earth_loc = EarthLocation(*loc) + kwargs["location"] = earth_loc + with pytest.raises(TypeError): + SimulatorBase(*args, **kwargs) # loc is EarthLocation, world is moon + moon_loc = MoonLocation(*loc) + kwargs["location"] = moon_loc + sim = SimulatorBase(*args, **kwargs) + assert sim.location == moon_loc + + # check that init works correctly on earth + kwargs["world"] = "earth" + with pytest.raises(TypeError): + SimulatorBase(*args, **kwargs) # loc is MoonLocation, world is earth + kwargs["location"] = earth_loc + sim = SimulatorBase(*args, **kwargs) + assert sim.sim_coord == "C" + assert sim.location == earth_loc + kwargs["location"] = loc + + # check that we get a KeyError if world is not "earth" or "moon" + kwargs["world"] = "mars" + with pytest.raises(KeyError): + SimulatorBase(*args, **kwargs) + + kwargs["world"] = "moon" + + +def test_compute_dpss(): + sim = SimulatorBase(*args, **kwargs) + sim.compute_dpss(nterms=10) + design_matrix = dpss.dpss_op(frequencies, nterms=10) + assert np.allclose(design_matrix, sim.design_matrix) + beam_coeff = dpss.freq2dpss( + sim.beam.alm, frequencies, frequencies, design_matrix + ) + assert np.allclose(beam_coeff, sim.beam.coeffs) From 3f27a5cc4ae8e13fa71156d522b821ce4a12122e Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 12 Sep 2023 17:43:41 -0700 Subject: [PATCH 062/129] fix import path of simulatorbase --- croissant/core/simulator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/croissant/core/simulator.py b/croissant/core/simulator.py index dfab9eb..8f0fdea 100644 --- a/croissant/core/simulator.py +++ b/croissant/core/simulator.py @@ -1,5 +1,5 @@ import numpy as np -from ..simulator import SimulatorBase +from ..simulatorbase import SimulatorBase class Simulator(SimulatorBase): From 83dcc88d052dd167426abbb4433ba535cef4809d Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 18 Sep 2023 16:50:14 -0700 Subject: [PATCH 063/129] initial commit --- croissant/crojax/simulator.py | 56 +++++++++++++++ croissant/crojax/tests/test_simulator.py | 91 ++++++++++++++++++++++++ 2 files changed, 147 insertions(+) create mode 100644 croissant/crojax/simulator.py create mode 100644 croissant/crojax/tests/test_simulator.py diff --git a/croissant/crojax/simulator.py b/croissant/crojax/simulator.py new file mode 100644 index 0000000..a0711b1 --- /dev/null +++ b/croissant/crojax/simulator.py @@ -0,0 +1,56 @@ +import jax +import jax.numpy as jnp +from ..simulatorbase import SimulatorBase + +@jax.jit +def convolve(sky_alm, beam_alm, phases): + """ + Compute the convolution for a range of times in jax. The convolution is + a dot product in l,m space. Axes are in the order: time, freq, ell, emm. + + Parameters + ---------- + sky_alm : jnp.ndarray + The sky alms. Shape (N_freqs, lmax+1, 2*lmax+1). + beam_alm : jnp.ndarray + The beam alms. Shape (N_freqs, lmax+1, 2*lmax+1). + phases : jnp.ndarray + The phases that roate the sky, of the form exp(-i*m*phi(t)). + Shape (N_times, 2*lmax+1). + + Returns + ------- + res : jnp.ndarray + The convolution. Shape (N_times, N_freqs). + """ + s = sky_alm[None, :, :, :] # add time axis + p = phases[:, None, None, :] # add freq and ell axes + b = beam_alm.conjugate()[None, :, :, :] # add time axis and conjugate + res = jnp.sum(s * p * b, axes=(2, 3)) # dot product in l,m space + return res + +def convolve_dpss(): + raise NotImplementedError + +class Simulator(SimulatorBase): + def run(self, dpss=True, **dpss_kwargs): + """ + Compute the convolution for a range of times in jax. + + Parameters + ---------- + dpss : bool + Whether to use a dpss basis or not. + dpss_kwargs : dict + Passed to SimulatorBase().compute_dpss. + + """ + if dpss: + res = convolve_dpss() + else: + res = convolve( + self.sky.alm, + self.beam.alm, + self.sky.rot_alm_z(self.dt, self.world) + ) + self.waterfall = res / self.beam.total_power diff --git a/croissant/crojax/tests/test_simulator.py b/croissant/crojax/tests/test_simulator.py new file mode 100644 index 0000000..014c7ed --- /dev/null +++ b/croissant/crojax/tests/test_simulator.py @@ -0,0 +1,91 @@ +import numpy as np +from astropy import units +import healpy as hp +from croissant import Beam, Simulator, Sky +from croissant.simulatorbase import time_array + +loc = (137.0, 40.0) +t_start = "2022-06-10 12:59:00" +N_times = 150 +delta_t = 3600 * units.s +times = time_array(t_start=t_start, N_times=N_times, delta_t=delta_t) +kwargs = {"world": "moon", "location": loc, "times": times} + + +def test_run(): + # retrieve constant temperature sky + freq = np.linspace(1, 50, 50) # MHz + lmax = 16 + kwargs["lmax"] = lmax + sky_alm = np.zeros((freq.size, hp.Alm.getsize(lmax)), dtype=np.complex128) + sky_alm[:, 0] = 10 * freq ** (-2.5) + # sky is constant in space, varies like power law spectrally + sky = Sky(sky_alm, lmax=lmax, frequencies=freq, coord="G") + beam_alm = np.zeros_like(sky_alm) + beam_alm[:, 0] = 1.0 * freq**2 + # make a constant beam with spectral power law + beam = Beam(beam_alm, lmax=lmax, frequencies=freq, coord="T") + # beam is no longer constant after horizon cut + beam.horizon_cut() + sim = Simulator(beam, sky, **kwargs) + sim.run(dpss=False) + beam_a00 = sim.beam[0, 0, 0] # a00 @ freq = 1 MHz + sky_a00 = sim.sky[0, 0, 0] # a00 @ freq = 1 MHz + # total spectrum should go like f ** (2 - 2.5) + expected_vis = beam_a00 * sky_a00 * np.squeeze(freq) ** (-0.5) + expected_vis /= sim.beam.total_power + expected_vis.shape = (1, -1) # add time axis + assert np.allclose(sim.waterfall, np.repeat(expected_vis, N_times, axis=0)) + # with dpss + sim.run(dpss=True, nterms=50) + assert np.allclose(sim.waterfall, np.repeat(expected_vis, N_times, axis=0)) + + # test with nonzero m-modes + kwargs["times"] = None + sky_alm = np.zeros_like(sky_alm[0]) # remove the frequency axis + sky = Sky(sky_alm, lmax=lmax, coord="M") + sky[0, 0] = 1e7 + sky[2, 0] = 1e4 + sky[3, 1] = -20.2 + 20.4j + sky[6, 6] = 1.0 - 3.0j + + beam_alm = np.zeros_like(sky_alm) + beam = Beam(beam_alm, lmax=lmax, coord="M") + beam[0, 0] = 10 + beam[2, 0] = 5 + beam[3, 1] = 1 + 2j + beam[6, 6] = -1 - 1.34j + + sim = Simulator(beam, sky, **kwargs) + + sim.run(dpss=False) + expected_vis = ( + sky[0, 0] * beam[0, 0] + + sky[2, 0] * beam[2, 0] + + 2 * np.real(sky[3, 1] * np.conj(beam[3, 1])) + + 2 * np.real(sky[6, 6] * np.conj(beam[6, 6])) + ) + expected_vis /= sim.beam.total_power + assert np.isclose(sim.waterfall, expected_vis) + + # test the einsum computation in dpss mode + frequencies = np.linspace(1, 50, 50).reshape(-1, 1) + beam_alm = beam.alm.reshape(1, -1) * frequencies**2 + beam = Beam(beam_alm, lmax=lmax, frequencies=frequencies, coord="M") + sky_alm = sky.alm.reshape(1, -1) * frequencies ** (-2.5) + sky = Sky(sky_alm, lmax=lmax, frequencies=frequencies, coord="M") + sim = Simulator(beam, sky, **kwargs) + sim.run(dpss=True, nterms=10) + # expected output is dot product of alms in frequency space: + sky_alm = sim.sky.alm + beam_alm = sim.design_matrix @ sim.beam.coeffs + temp_vector = np.empty(frequencies.size) + for i in range(frequencies.size): + t = sky_alm[i, : lmax + 1].real.dot(beam_alm[i, : lmax + 1].real) + t += 2 * np.real( + sky_alm[i, lmax + 1 :].dot(beam_alm[i, lmax + 1 :].conj()) + ) + temp_vector[i] = t + # output of simulator + wfall = sim.waterfall * sim.beam.total_power + assert np.allclose(temp_vector, wfall) From a920afa0fa4ecb4072a3508e6ee2f920aaf98cbe Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 18 Sep 2023 16:50:35 -0700 Subject: [PATCH 064/129] import simulator in init --- croissant/crojax/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/croissant/crojax/__init__.py b/croissant/crojax/__init__.py index 5956e9a..63211f6 100644 --- a/croissant/crojax/__init__.py +++ b/croissant/crojax/__init__.py @@ -5,4 +5,5 @@ from .beam import Beam from .healpix import Alm +from .simulator import Simulator from .sky import Sky From 499efe7d060ed3a1cd517e24a1d7878d4065262e Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 18 Sep 2023 16:50:52 -0700 Subject: [PATCH 065/129] fix mistake in documentation --- croissant/crojax/healpix.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/croissant/crojax/healpix.py b/croissant/crojax/healpix.py index d735640..70a7365 100644 --- a/croissant/crojax/healpix.py +++ b/croissant/crojax/healpix.py @@ -290,7 +290,7 @@ def rot_alm_z(self, phi=None, times=None, world="moon"): Returns ------- phase : jnp.ndarray - The coefficients (shape = (phi.size, alm.size) that rotate the + The coefficients (shape = (phi.size, 2*lmax+1) that rotate the alms by phi. """ @@ -304,5 +304,5 @@ def rot_alm_z(self, phi=None, times=None, world="moon"): f"World must be 'moon' or 'earth', not {world}." ) phi = 2 * jnp.pi * times / sidereal_day - return self.rot_alm_z(phi=phi, times=None) + return _rot_alm_z(self.lmax, phi) return _rot_alm_z(self.lmax, phi) From 768f005da53c32b282dbfa33fea9281273b66eae Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 1 Feb 2024 14:29:34 -0800 Subject: [PATCH 066/129] update notebooks --- notebooks/example_sim.ipynb | 201 +++++++++++++++++++++++++++++------- notebooks/jax_example.ipynb | 111 ++++++++++++++++++-- 2 files changed, 269 insertions(+), 43 deletions(-) diff --git a/notebooks/example_sim.ipynb b/notebooks/example_sim.ipynb index 062505d..82fc103 100644 --- a/notebooks/example_sim.ipynb +++ b/notebooks/example_sim.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "6a05778f", "metadata": {}, "outputs": [], @@ -18,12 +18,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "2348797a", - "metadata": { - "scrolled": false - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# simple beam in topocentric coordinates\n", "lmax = 32\n", @@ -42,10 +51,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "3be26219", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# we can impose a horizon like this, note that the sharp edge creates ripples since we don't have an inifinite lmax\n", "beam.horizon_cut()\n", @@ -62,10 +82,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "6d25d25a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0QAAAIECAYAAAA5Nu72AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9efBtzVUXDq/ufc53uPc+U2YSEkgYBQuR6QcIokgmQBlkCJFJC1CQQX+COPCC8lMQhBcxKIn1vhIxJGAqBFDAEAuqhIISygLEEuVlCCETISR58jzPvff7PWfvfv84p7vXWnutHvbe5zs8tz9Vt25/9+nd3Xten/6stdo45xw0NDQ0NDQ0NDQ0NDTcg7CXPYCGhoaGhoaGhoaGhobLQiNEDQ0NDQ0NDQ0NDQ33LBohamhoaGhoaGhoaGi4Z9EIUUNDQ0NDQ0NDQ0PDPYtGiBoaGhoaGhoaGhoa7lk0QtTQ0NDQ0NDQ0NDQcM+iEaKGhoaGhoaGhoaGhnsWjRA1NDQ0NDQ0NDQ0NNyzaISooaGhoaGhoaGhoeGeRSNEDQ0NDY8DGGPgq7/6qy97GA0NDQ0NDdcOjRA1NDQ0XGH8xm/8BnzO53wOvM/7vA+cnJzAM57xDHjuc58LL3nJSy57aCJ+6qd+Cv7RP/pHk/bdbDbwIR/yIWCMge/6ru8a/T4MA3znd34nPPvZz4aTkxP4sA/7MHjVq15V1PY/+kf/CIwxYK2FP/iDPxj9/p73vAdOT09HxPINb3iDOh7c7jve8Y7Co2xoaGhouGpohKihoaHhiuIXf/EX4aM+6qPg13/91+HLv/zL4fu+7/vgy77sy8BaC9/7vd972cMT8VM/9VPwj//xP56070te8hJ44xvfqP7+D//hP4Rv/MZvDITwWc96Frz4xS+GH/7hHy7u4/j4WCRRP/qjPzppzA0NDQ0N1x+ryx5AQ0NDQ4OMf/pP/yk88MAD8Cu/8ivw4IMPkt/e/va3X86gDoS3v/3t8K3f+q3wjd/4jfDN3/zNo9/f/OY3w3d/93fD3/ybfxO+7/u+DwAAvuzLvgw+6ZM+Cb7hG74BPvdzPxe6rsv286mf+qnwqle9Cv7u3/27ZPsrX/lK+LRP+zR4zWtes8wBNTQ0NDRcGzSFqKGhoeGK4nd+53fgQz/0Q0dkCADgKU95Snb/f/JP/glYa+ElL3kJfMmXfAk86UlPgs1mM6r3vOc9Dz7ogz4o2dbP//zPw+d+7ufCs571LDg+PoZnPvOZ8Lf/9t+GO3fuhDpf+qVfCv/qX/0rANjFNPl/Jfh7f+/vwQd90AfBF37hF4q///iP/zhsNhv4qq/6qrDNGANf+ZVfCW9605vgl37pl4r6efGLXwy/9mu/Bv/7f//vsO1tb3sb/OzP/iy8+MUvLmojhZe//OXk2PG/P/fn/tzs9hsaGhoalkdTiBoaGhquKN7nfd4HfumXfgn+5//8n/An/+SfrNr3m77pm+Dbvu3b4GUvexl8+Zd/OfyX//Jf4Ad/8Afhda97HXz6p396qOfJwLd8y7ck23v1q18Nt2/fhq/8yq+EJz7xifDLv/zL8JKXvATe9KY3watf/WoAAPjrf/2vw1ve8hZ4/etfD//+3//74rH+8i//Mvy7f/fv4Bd+4RdUAvWrv/qrcPPmTfgTf+JPkO0f8zEfE37/hE/4hGxff/bP/ll47/d+b3jlK18J3/qt3woAAD/yIz8Ct27dgk/7tE9T97t9+7YYJ3T79u1R+/zYf//3fx++6Zu+qYjENjQ0NDRcPBohamhoaLii+Pqv/3p44QtfCB/+4R8OH/MxHwOf+ImfCH/hL/wF+PN//s/Der1O7vc93/M98AM/8APwJV/yJQAA8Mmf/Mnw3u/93vCKV7yCEKJXvepVMAyDqsx4fMd3fAecnp6Gv7/iK74C3v/93x/+wT/4B/DGN74RnvWsZ8HHfdzHwQd+4AfC61//+mx7Hs45+Jqv+Rr4/M//fPi4j/s4eMMb3iDWe+tb3wpPfepTR4Tpvd7rvQAA4C1veUtRf8YYeNGLXgSvetWrAiH6oR/6Ifjsz/5sOD4+Vvf7lm/5lixpBAB4znOeA895znPC33fv3oVP+IRPgKc//enwL//lvywaY0NDQ0PDxaK5zDU0NDRcUTz3uc+FX/qlX4K/9Jf+Evz6r/86fOd3fic8//nPh2c84xnwEz/xE6P6zjn46q/+avje7/1eeMUrXhHIEACAtRb+yl/5K/ATP/ET8Mgjj4TtP/RDPwQf//EfD89+9rOTY8Fk6LHHHoN3vOMd8PEf//HgnINf/dVfnXyML3/5y+E3fuM34Du+4zuS9e7cuSMSlpOTk/B7KV784hfDb//2b8Ov/MqvhP9z7nJf8RVfAa9//etH/77oi74oud9XfdVXwW/8xm/Aa17zGnja055WPMaGhoaGhotDU4gaGhoarjA++qM/Gn70R38Uzs/P4dd//dfhta99LXzP93wPfM7nfA782q/9GnzIh3xIqPuDP/iD8Oijj8L3f//3wxd8wReM2vriL/5i+I7v+A547WtfC1/8xV8M/+f//B/47//9v8NLX/rS7Dje+MY3wjd/8zfDT/zET8C73vUu8tvDDz886dje8573wN//+38fvuEbvgGe+cxnJuuenp7C2dnZaPvdu3fD76X403/6T8MHf/AHwytf+Up48MEH4WlPexp88id/cnKfD/iAD4BP+ZRPGW3/hV/4BXWfl73sZfADP/AD8LKXvQw+9mM/tnh8DQ0NDQ0Xi6YQNTQ0NFwDHB0dwUd/9EfDt33bt8H3f//3w2azCbE7Hn/mz/wZeOpTnwrf933fB+985ztHbXzIh3wIfORHfiS84hWvAACAV7ziFXB0dASf93mfl+y773t47nOfCz/5kz8J3/iN3wg/9mM/Bq9//evh5S9/OQDs1geagu/6ru+C8/Nz+PzP/3x4wxveAG94wxvgTW96EwAAvOtd74I3vOENcH5+DgA717i3ve1t4Jwjbbz1rW8FAICnP/3pVX2/+MUvhh/5kR+BV77ylfD5n//5YO2yn8Nf/uVfhq/7uq+DL/uyL4Ov+IqvWLTthoaGhoZl0QhRQ0NDwzXDR33URwFAJAMe7//+7w8/8zM/A295y1vgBS94AXGN8/jiL/5i+Nmf/Vl461vfGlJNP/TQQ8n+fuM3fgN+67d+C777u78bvvEbvxE+4zM+Az7lUz5FJCGlWeUAdqrTu971LvjQD/1QePaznw3Pfvaz4RM/8RMBAODbvu3b4NnPfjb8r//1vwAA4MM//MPh9u3b8Ju/+Zukjf/23/5b+L0GL37xi+Gtb30r/NZv/dYi2eUw/uiP/gg+53M+Bz78wz88ZN1raGhoaLi6aISooaGh4Yri537u50aKCMBu8VMAEFNlf9iHfRj81E/9FPzmb/4m/MW/+BdHsTVf8AVfAMYY+Lqv+zr43d/93aLkB359HzwW55y4OOzNmzcBAODd7353tt2v/dqvhde+9rXk38te9jIA2KXwfu1rXxtimz7jMz4D1us1/Ot//a/JGF760pfCM57xDPj4j//4bH8Y7/d+7wf/4l/8C/j2b//2kKluCfR9Dy960Yvg/PwcXvOa18DR0dFibTc0NDQ0HAYthqihoaHhiuJrvuZr4Pbt2/BZn/VZ8MEf/MFwfn4Ov/iLvwg/8iM/Au/7vu8Lf/Wv/lVxv4/92I+FH//xH4dP/dRPhc/5nM+BH/uxHwtZ6Z785CfDC17wAnj1q18NDz74YDLVtMcHf/AHw/u93/vB13/918Ob3/xmuP/+++E1r3nNKJYIAOAjP/IjAWBHdp7//OdD13Xwohe9SGz3Iz7iI+AjPuIjyDafZe5DP/RD4TM/8zPD9vd+7/eGv/W3/hb883/+z2Gz2cBHf/RHw4/92I/Bz//8z8MP/dAPFS3KyvF1X/d11fvk8NKXvhR+9md/Fv7G3/gb8HM/93Pkt6c+9anw3Oc+d/E+GxoaGhrmoRGihoaGhiuK7/qu74JXv/rV8FM/9VPwb/7Nv4Hz83N41rOeBV/1VV8F3/RN3yQu2OrxyZ/8yfAf/sN/gL/8l/8yfNEXfRG88pWvDHEyX/zFXwz/6T/9J/i8z/u8ZKppj/V6Df/xP/5H+Nqv/Vr49m//djg5OYHP+qzPgq/+6q+GP/Wn/hSp+9mf/dnwNV/zNfDDP/zD8IpXvAKccyohqsU/+2f/DB566CF42cteBi9/+cvhAz7gA+AVr3jF4i5vc/BHf/RHALAjRjxZxSd90ic1QtTQ0NBwBWGc5I/R0NDQ0PC4xY//+I/DZ37mZ8J//a//NcTsNDQ0NDQ03KtohKihoaHhHsOnf/qnw2/+5m/Cb//2b1clQWhoaGhoaHg8ornMNTQ0NNwj+OEf/mH4H//jf8BP/uRPwvd+7/c2MtTQ0NDQ0ABNIWpoaGi4Z2CMgVu3bsHnf/7nw0tf+lJYrdqcWENDQ0NDQ/saNjQ0NNwjaPNfDQ0NDQ0NY7R1iBoaGhoaGhoaGhoa7lk0QtTQ0NDQ0NDQ0NDQcM+iEaKGhoaGhoaGhoaGhnsWjRA1NDQ0NDQ0NDQ0NNyzaISooaGhoaGhoaGhoeGeRSNEDQ0NDQ0NDQ0NDQ33LFra7YaGhobHMZ7/wF8L5dRCrD4ld1usVcZ/fvf/97KH0NDQ0NBwILSFWRsaGhquMDChWQLXjfCkPlHGGPX3yzpObTyve/jfXvBIGhoaGhpK0QhRQ0NDwwXh+fd9KYBVPJWHYVqjWnsJzCILNrPvsOwn5bI+UUsRqsnjHwZ43SMvX2QMDQ0NDQ1pNELU0NDQMAPPv+9L9R/965Ub1/i1i3/TtmNgAoRJlEKMJhv2OeKTwsKkCODyiFEOc4hT9TElSHMjTw0NDQ3T0QhRQ0NDg4Ln3/oSusEbv4d4bdYa1gXK0CRjfQ4R8jgAIdKgxT5dlU/bVMJUNf5CdbGRpoaGhgYZjRA1NDTcsxgRnouGMWNyVaIMZZutJVcHiLcZ3LhdT5RK3e6k/bU2C3CVPnc11+gQ5EhCI0wNDQ33KhohamhoeFzi0slODSTj2FrZuBWIURUBOgT5OQSMQADdMN7uhHMkESe/nTfpnHj+LvLTeGFud1PIEmv/dY/+u/o2GhoaGq44GiFqaGi4trhWpIej1AguVIZEo/qqkh+J7GC4AaDrprff9zJx4tv6vpg4AVyPBA+zxlhDmIR+GllqaGi4rmiEqKGh4UrjWpMejosgQaO2LpAUlZAQgDKXuY635eTkFCXb+qHc1U5TnHi1a0COOIrHPMPtTkNzx2toaLjKaISooaHhSmCUre26vpomZ3VbMEnCIUhQTtXRII2FHwdve+gBLFOIJNWo7/NKkqQWDb1MmqTxSvv3/agbyfXuoj+vF6IkDcP4Xm1xSw0NDdccjRA1NDRcKJJpqj34LP9Vfk3NWtPnipAgbPB7heQiCZCg3hikELk9WSHbnAPDzp8bBpGU4G1OIj4S6QHYEafRNnYvenKE27sCitKFZLcrwUSy1IhSQ0PDRaIRooaGhoOhiPzkoJGjyyBMSyzWuRQJKiVAnOxMJTo148gRIKDkBtd3ewParFbxd64EeRKCt3nDG5/fvs/eO04z2Dmp8eQIt9cL+3KXuytAjjAudN2kFLjSJF0/dm0aSWpoaDgUGiFqaGiYjec/8NfiHweIP1BxCHK0BOkBqEqTvet2IRK0NOEpGUMtAeL7SEawJzv+eqaM55Qx7fsJSo5ucHtwpcmVEJ9rSI4A5hEkD2ktqIMdl3CtX/fwvz1MXw0NDfcMGiFqaGioAiE/HBdJhjhqX2VLER+PSgK0G8I1JUHSuNkYkgTIw5Me/5u/f1ZYDfIEyZMfR//GRMSPk69jhOvwvjhh4mD3VTU5skr7CXLk74uiz7NGDvG2CixBkDRcpLnRSFJDQ0MNGiFqaGhQkSQ/GFedCB3QyLs0InRIEjRBBRoRIGkfKQFCZ3f1MInwhIgb95Kxz68//lta+BZgTEa0e4iTmBQ50ogPbxv/7s8h3mbNNCWp5hk8hHo5AxdlhjSS1NDQoKERooaGBgCoID8Yl0WESl9bhzLkpCxbGSPz2pGgpVWg8LewDycu1uavsUR2Su4LXkdKvy21kyNHE/YZE7N8yu8q1agGS6Z6XwD4OI0xo+Pm23J/a2gkqaGhAaARooaGexbVBOiqkx+MCzLaFkmQcFkucYeIBQLIEyCxn/Tfzhow2rpBodIEMjRFPXJu/CzkyFGOGIn9puOPDkaMJCxB9q8IcuetEaSGhnsTjRA1NNwDuDbqz1VJiFCLKQbjSJE5cByQ1CdAEQnC+xmv6GCUqECkPZYuuzJluBkc2WdElg5JjnA96RmZS44OoRod4lkW7vnLIEYlylHN/hIaSWpoePyjEaKGhscZishPKjbjorDkq+e6ECGRkFQSocx6N8n6EjRCxPbja/4sSoJ4lsDc3wkUk6O5atGIyFwD1ehQz3niObgMF7scprrXYTSS1NDw+EIjRA0N1xwjAlSwnseF41Cvmct21VEMwSwRypEgLVsaB/89V58OcryNkZxwHP5/f7yj7exvj5wSxNvhadRz943ye5YU1cQelcQYHZocXRdiBHCh5GhSVr4DoRGkhobrjUaIGhquGZ5/35deLbIj4SJeK0uToZwyIYEZf7MVoUrXsWpoiRK4SxwGV4JGSpFN/j4iQTxhQul1TN1T3G1qSULkUaI83QvEqOS5wDiwa91VNWEaQWpouF5ohKih4Yrj+fd96fSdpYVLl8ZFv0KWOJaSDGYpTCFCZAdOIg54faYkSjgECVoSGUJzaYQo9XuCHF1bYoRR+cxwzCVJVaYMzwpZ8jfArPu4EaSGhquNRogaGq4YFiFAHkuTB21dl0Nh7vjnjFVMhFDhDpRzk7toNSjT/yhGaLWif+dIEP7dubzxqF3bnPJiDDXgjQGD1gMaZaQ7BBmq2f+QqtF1JEYYuYmFGajOwjclljJ3jyfaf90jL6/rq6Gh4aBohKih4ZKRJUBaXEWOnPDfc3EapXEbh8Qcg+gikjSUuP+Uxgtdhiok9KkmS/BtYKKTIkFiv8o9lkMFiUmqQZg8+b7533MJUWqcqd8O6U530cRo7kTMRRIjrvYs6XKMSU9l+40gNTRcLhohami4YDz/1pfsCtggq8ii9bjDVSFBHqnxIMNtscQJh4BEiPb9jRIlAMgZ4/DvLNW2s+jv3JpCJeDPwDCof3s1yLvlBXUIE55UW1kyoCSqKEVtyu+rTIyk8eUwJT4M4KCxRiop0neQ75nSSaUF0AhSQ8PFohGihoYLQCBBDRFXjQhhZLKlEUPtqhChjIvcKE5ojkuc8Dvwc1JDJGoUoT5DcFJ/D26ctpxfj1oClOq7tj421K+7K91UHDDWyKWI6Ljy5H4AoO79lklU0chRQ8Ph0QhRQ8MB0AiQgKVmTw/5yppDhEjF9OKmi6KGCGElSHKJAyDHXEWCAMqPsSLpAY4PGtUV4omShi7ul5O2qYpQCebEGS1NjBLHd6WIkcdMgpRcb+jQpAgj5eIsuTcn/n7do/9uuXE1NDQAQCNEDQ2LoZEghkOkxT4UMkQoVpuRVntpQpQiQpp7nD8uy+rWqEFTSRCAToS4yxGK8zHbXv1N/NsTKEx4LPstF493WVkZD02MvFIkkKKkKXDIuJtSzCBGs4he6b783CydWVFBI0cNDcugEaKGhhloJAjhIozIQ2S5I6pPhdF1WWSIxPZUZI7rOhY3xBZZBUaEpFTb2JDubJpQJGNbBMMfjcP0Q4wR2vbpmKB+oIQntZbUlHtHi/WbiynEyNoR8UkSoxxpQtfkSqpDEiqeUeccFC/aWkuKcGruknOD65am/M7VZWjkqKFhOhohamioQCNACIckQBoOmUmuNKV2zRpDl0CE1KxxHiv6t1tVrDlUGxeBkSNECCRzXCbpQLLdQ+IiXEBTvy1FjEriia4KGfI4lPpS60J32eclcx4aQWpoKEcjRA0NGTz/xhfFPy7IDeJKYqoBmJr9LMWc11Ruhn/O2kKk8kLqUGq8KSLEs8JhIsRJjbSQKnavS6XTLlVcJOLiZPIyWkcIu7Zh490Y6hKH44ukeKISBUtSs2ru9SWJkZYKPKV09VRBc/gcSG50Wha6wZW5zV0VNFI0Bk/7jdc9uv3vL2lQDQ3XA40QNTQIICTIQ/MRl4z82t+kvy8bSxAgDTUxCZLhKhmOtSlwa4gQwOHJUGq8pUQIgLrGhdghFEPkXYg46fG/W4X8SONLXQ9fDvEripLj3HgtIewWx++NXvhN6n+J5+0yiBFGyfn1YOcpSYwwkWQZ6BxPYqG0Xw3pPZiKv6npb+n35nUmRQVo5KihYYxGiBoa9hBJ0EXiKpCjQ5IgCVMNiTkz+gD1ZCjsN420JLEkEQr1eIrt+Jvjawzx+gl1yBkDplQVSmWHS7nI8d9H7l6J37Q2crjqxIijkBi5EZlExGh0fdB+Eilayui/iHfFEu/OA5EiHNd0FdDIUUPDDldoOrqhoaGhoaGhoaGhoeFi0RSihnsal64KeXAXkYtSh5aYqbwMdahk3BnFTctGJbd1AHe5i1CGUCY5l4kjyilDYbNz4e+RWuTc2FVO+o3tZ3gsUI9SbePfeNxQKhvb1PsrdT/XKkWl7ptTkFi7abL7nPD7yEQodW8txaHfH7Xt19xDFefGn0e+FlJTixoargYaIWq453BlSJCGiyBDS32E5xgzqdiqA4+r2AiZQoSy+y1EhDCp4TFDQvpsJ8QRkT6MGY3NFZwnkzDESSIFwYAPrnI4FkiKGeK/hTWH+nhMPVuvqCT2LEmCC4hRLQGYul8KiTWcRuSmlBjx34ARI+kZlUyJq0SMeD9LvYMmkCINhyRHEiHjKcnxbz9z5xUHG0tDw1VEI0QN9wSed/qFV2omTsV1IUOHiHfiCplmWEhqWsFiiNnrjxfy9H+rjU0gQ0sSIY9USm10LkZxQ6mFV4ERIQsACfswSYg0NQeTIawc+X3wOSxRhKTfalCagCN3r2vt5FTNIsWT3Z+p3xJptjEpMsaA225RPeFC432nnv/iCYgLVpuXwoKkyOMQ36up5l4jRw33Ahohanjc4nmnXxjKjQztsRQZOqR7XynBSixgWOUOBzBtvaCaJApa/0sRIbzIKidCeP/UwqsgECGPFCGqSYCgpNpWkzGUushJv03F0sa7lPJ7St/a/TU4+ptGjPqejhkTHUyKAOrc6KZcgxkZIFVcBikqOd4FyBHAMt+wJcy9Ro4aHq9ohKjhcQNMgDg0N4GUy0Dpb4uQrYskQ0u661ylNOF7FMUCeaOxOBPc/jh9Ji5JIZLaImmrE22wfUdrCoV6goscdoVDv5G1hfxvfL2hPVQi5CHYdEEZyqXaLokbIm5eiex0F0GIwgALY4BKXLCktlP9qn0V3q9S/JZU5kTHEyNjAThJYvWTLnRLESOAunfMVSVFAFdONVrK9GsEqeHxgkaIGq49UkToIrAIObpoYoHJ0ZQxXxEiJJFUEVMUoNBJ4bFq6/ek2qglQtLfzB3OcRUokCIaI+RGbcpDBIARITKage0cNcYVwmL4Iq24XqkxP9EIn/WcTnWJ01zu8D68jaWJEVeplHgiMeU2catbWC3y4ymB9t6R1piqBT7/uevJf7+mpKimX6JEChNKjRg1XHc0QtRwLXHZJMij2CBP4SLJRY37joYrRIYAZmaIS3YwgQjtBlbWhuYex4/FWrnM3OFGREipN0qc0JUa16gZTlKIUawbyEYz0A9IiHhGr0UyfHH1qOSZSrmaptQotb0KUqS51CXWKRoRo5Fb3cJqkcch3HpLwa+jloyDg98DKRSM6yLJURUh8uDEiOFnzn5o5qgaGi4ejRA1XBs87/iv7Ar4ZazNWEl/S7+V1ktg0kfpKpCKKSpR5binuCqWtKmPT7iORY0WuMTx9vHfu4GN20u1AZk4IY0IAYxigUIGOewOl0ickHWRk6ARosLMcqZ0odYDEiINi6dC1txT+bNWmqBBGk9JzJp27KmFcLkCJBEj3/dmG8YyqjfXnfEi4z65OnQRqFjItQQXQo60pB4JNHLUcF3QCFHDlUcgQnPghvIZf4yE0XFtiRDHwmRoynlJzeIXt33RSlDY/4DucVzRUVQgx8mPlm1ONKzl4Y5QSoiUJAiXRYh2P037zJXcy5Nd8OYSo9IkHprqAaCrRVLabRLz1at1nRQbxsdRg4siRpdpCi1Ijg5OjCaQIoBGjBquPhohariSmESCHPuoGEtn/HOz/xyNDEUcmAzl9kvWqU2MUItSw3Ouexw/x1LiBF5Pc5WrjRcqmR3nhEgN1Jczy5mUKqEZ6fy3mfEqS3zuuOpZonIm7+8SYpRUEiuIkXSdU9cFQHejG/g6Rlq9mS50AIclRZrr40Vigntf6l4+KCmaSIgwGjlquIpohKjhSuF5R19A3ZckVyZObDgRyiFnGD9eXeQwao5hqUVODwFVtSl0gdPay7lLHjJOSFOEWD2ythBWktg+hAzhn1IJAjhSZAjvk0iWcFBClBo7+fnAn7uMq6Ya95a6H2gDiX0KFUyMErUIIKMCyWpRkQtdDQmZ8p6RSGBNbNBlYEFyNPfdPNuFTvpWo/LPnL9q1vgaGpZEI0QNl47nHX3BrP3d4MAsoRIUtHGtydCCY78S6zrlyNBS7Y3aLyBDU7PH1brH8f2Rq1w1EQo7YsMY7aaRIAB9rSBm3BnN6NYM81SfmuF4ANe5YpQu7ItQfG9IdUb7FKpFGKWkCKBMLSp1oUuNQ4OmeKVwFUycqYtXV5KjQ6pGk93oCicsGzlquGw0QtRwaZhChNz+xWusIeViFBqwo91qPyZXgQQdiLxdOhlKGn0T3CFLEzAskTSBtwOgxwzxNYOIC5yRM8mhes6YOiIUGq8gRFgZkrazfYyScGESIQr1612yZn32tKQsmlEoJW9hKE6uwX/TtpWqRTOTLoxVIF0tCuoYXiA2RWqlRBScBKWywl2kKxxed6qkPLX9CixNjiarRZUeHI0YNVwWGiFquFBwEoTVnVQ5hSJCNFEZujJEKPWxBxj/XYMDxgctjimqUIFBKrcpnOdUX0LbWUKkZZLjWeNSrnJ8YVaYQYYAVEIEAHQx1hJlgRMiTUkqJUTatkOSolTa6qkoIUapRBvyzkV9qIQCQ3JbJIpgvQsdbnN07ucuqHoZZoy0EG8t5pCjitTiOZe6msQgh1aKMBo5arhINELUcCHAREgjOFj1KUWWDE1UhAAqCMAhSZCEUleRFK4TCfKoJUNTVCCAhMFZT6onrS+E2+qQC5zmKsfUIpJJrnSNIYyRsRqLpsTN7dCESNzngO5zSxAgCXPVotS9VdCPCul41QQalS50rO3k+kW1uCxStBTmfkcuaX2j6uQLjRg1XFE0QtRwUDx39SIAmEZ2SpAkRNyAneLTn0PNRyznArIk0dFWbj+US1zKZWguprjILaEEzeynarYfKz24jp/Bxe5ziqucuLaQplDlXvtMJSLKkFhHUY7228yQ2f+CCVHVZ+9Q97VHabxZqJ9Qi7R7eYpKmktu4c852l6ahU5Vi6RYmxrSUWvO8PfilFifJUmRxwHJUa3Jl8qkmF0/bgYpktzjX7/94cJRNzTUoxGihsXhSdChsTQZOoh73JIKy5I+6QyTSZDHdSRDKfKDP9iV/Uya4S9NoCBkkkum1E4Z19qrXyND/LeSpApQqAodihAl2rh0hQijdLHeUL8grii1HffJF6PmmRY9+PnCBEcjRW7QXe1SLnQaSshHSVul7m6l79ZDkKLaMUhQxnWhZt8CpEhCI0cNS6MRoobFcBFESCVBF5U9rvTjtBQR0vqbmrUIYTYJCmNJGFFzcKBrvWtjQtsFfVTFDPG/McnBC6viesboZKiUCIWdMwavz5hbS4jYbwchRKqbzuPUdS7lbqnVKf0NjyOVJEK6Xux8O21x10JShGNaspibsW4KiSlJmnAoHEg1ujATcAIxKvEqacSoYSk0QtQwG1eGCPGP+EUQoRJ3q1JUqj4lC0Ti46sJnKXjqnSxWcJ9bk68UApJozHRdqG7UXZ2vySjnLU7FzlehyVTCC5yeNi+/RL3yxQh0rLLaWUAVSW6UEIEcDj3uatEiADS76TU9iluurnkFsh9zmnkJ5AoR41g5byWLHg76r9k3CX7XXUcQDUCuAByVEmKatzsGzFqmItGiBom49BEqNglrjZoGAqJUK3BMQWVH7YLS3Iw4ZwGXEUyNIUIlbZNuqmIGwKgrnJaAgUAsr4QdalLqE85zCVE/O+rQIiuo+vcVEIEsOw7KrVPyXXACRY0UsTd6TwKz+0s5WjKPXPVcd1UowlZ6GpjjxsxapiKRogaqnFpRGgmCQK4ACIkBedq5YJxSkrPwTCHBHnMdZ+7KmSoQl1Ur1GNOoRc4og65LfzTHIFRMgrSKP1g0KFCYSI13scEKL48yUSo1RihbhR2TfxPuEKdk7NlupI14kn5tAUopBMA8USketbT4riUGaqhBfp7pZBjdKv4rrEGh1QJcJoxKihFo0QNRTjQokQDmy/DmrQQqm31bFq/v0l5Vy9qgFa9cM1Qu14U31KuGAyVG2gaAoRjxvCbnB4TSG8/wqrR+VkCKCCEPFttW5zF0mIUr9NdZ8K1UpUiIU+m4lnQL3HcsSoNL5wigtdwTkncUQkHbuefvtCidEoVu5qKEQl993BiRHAYchR6UTZwqQIoBGjhnI0QtSQxIXHB3kj1Q1XkwgdmviQvma6rWnr8NSsyeMhXZcJ60lM6pPj0PFCYlNRDVqUDPm6vn2mFqlptREpGmWZyw2tVPG56oQoV+ciiBHpb4YiqjyTk0hRTfbJlIKEj5//jaGsO5WNJQJYTC0S+9TGyMeg1blgTEmHLWKpdfGWJkY1MaZziZGSJbSRo4YUGiFqEPHc7vN2hZKsW4XwxAevL4B+lHeaE8ORwuOVCM2Fpsxx4DpS+VB9z1GFtFTszBidsnp7sm+s9khJFDAhwooRKhPSo5EhC5HE4DIf4qEJkTHEmPKEyFlTvzAr/03DVSNFc1XRPbL3X+mkTy4zWipjWmk9jQxhtzleVyNE/LdKFBGjKxhTNMUcU99XByZGvs/0voXKkNh4JSnKfYfQ9tf3/6FuLA33BBohaiAIRAhgMTJUnSq7kaCLxVKkdy4ZyuEQZGi0+4zroO2LkiWo6w3hpAnEPQ7vmyBCEi6aEBH3qBlqkWrwXCNitBCq1cjLRI4QAdB3hJZgAaORosm4MuRojnvpVFJUiEaMGjAaIWoAAEaEPGYayocmQqG5nEFwgUSoWl14PBAhDO5SV1NOYSkyVLuGUClS9xJWgoR02kQVsjbWsTa6ydWSIYARISqKJSolRH5carzIAQiRVLe0Ts7ALWgzF/h+KByMFOVc5WraFM5BkhQdWCESx0DavrqkaOn7aVFiNFctKkGBx8FShMijEaMGgEaI7nmIRAhglrF8UUQIIGMsHJAIVQfYk34mxO8s5aJ2CBJ0aFw1MlRiNObihvbbxSQK2FWuo6514tpDmkGbyhSHUUuIMC6DEPH6JXVKjNuZn8JDk6QqYpRLjuDrlHWcr6O0pZIiLcHCAnFEyTFgXHdSpMWFlsSjXeY6RhPjh2iVZQmRRyNG9zYaIbpH8bgmQqF9luY4VyfTF19J/UKIEEBaXUntN2VsJR/Zuam1p4ylBPx6FJChorVePLCRmTI4C8kQAKSTKHhVCKtJxozJkDQ2jxK3Nw6FUIlpvIch9ovJDt7O44kkdUkaV8l9ph232mahwTTxs8jfEUujmBRpyRGmd5xXlBiybnMHTK6A+08S1BwpuuqucxPj1A5NjtKZ/0omMy6PFAE0YnSv4hpOFzfMheoeN5EMGWtkMqS1aU2Voetf3saY8E+FtfHfbifZcMV1hL5wf9pvxag83tF5k8pS8oEp15CPrbY8db+p/Wg4FBnSSLVmUGj17Xhf16F7sLOBDDlrIxlCypHrEBni9/Uh4kjQoZBU3xjis6U8c9qzyI8DJ57AbUr3hrav1r52rXJjksribmXvj6nAhqZqdJYS34L2w98F5aKxYajPR5mqq4Er97OI6VKxNxXIeh5IRGBQyOXgxPrk2g7DdOLHv7d7FH2rJ2BO+m31uRDK6oRxw+MaTSG6h7B0nNAhFaF69YX1WakIzVJ+cqglQzmUxt0sMZ6LwpRU4B4T3OWqyFDKWJDuJ9zenCQKK1S/KzfKF1OIOKS2cN1+iOdZUYuKXOZyYylVjmq21xqEMz6bl6YcZXBwU0BTgQ6gFGXVodokGxeoFB10HaxDK0YAZarRRJWoiBBpClHN/Y3OR1OL7h00QnQPIDnbMcGwvnQipK21MSGeaHHyM+q3sv3StNelffPFWZN9K+5XS7ndHBKFCtHoenNDQFvDBS92yRe+1NzoNDJUmkSBxwxJJE5yGcPuTH28bksTouBC5wkPNoRqUnD7+ytHYlKuWhpJqiJaE4zeEpe90S6HeZamxDUe2sWPILUY60xSNCl+a0rmwQMSo+pjmOuufMFxRjIxTb2HJiRUSLmTT7m/0bP9+uHV9fs3XCs0QvQ4RpHsW2F0XwkiJO9ctc/BSVDoe0Y/U8nQlD5LzsfSMQlLg5CFiWTIb5s4k0iQIkN+m98XK0RYFVLWHlL71Ma9J0VLEiKMUUwRQFmCBY241N5fOUOrVi0CkA1fvu5ObZuhysU8P7n33IV/+iVDdiFSNH2x0KtJioqwVPzmIVSj2tii3L1BNicIUQ4L3PONGD1+0QjR4xD3NBFKvLgvjAh5THYBm5EUIdmuomTkwOtLCtLUcg4li1jWkCF+3Dmlp6Ts93WOEiHUp5MIkjFqEgWRDKH+nN+ET6F2biWVaCohsqjM2wRYhhDhbSlVqGjMM4iRpgoukLHuIknRZaULF9FIkdJVhVInJU9YAim34lCHTQpo39slCBFAndvcBREij0aMHn9ohOhxhKtOhKpdOnJEKOXixPq9cFwEGVKvDzMiryqWIEQZMpSMFSp1t0xBDQxH5AXHC+E+JWUIu81hNzmBDAEwQoQhESILYHqFIOB7pui64DEo5Mdfu6mEKAWNJC2hFpWohAul8Z70+Z0TbzcHNf2m6l4VUlRCci8opqj6PqghQrXrvqVUdXWf8omDKte5JVSiCW6tNWjE6PGDRogeB1iaCO2qCy/Cihcp2W1ugoTYEP2dx3LM7fcQmJpqe0qbUxWgy0TJbOhVIkPaOVbIkJheG6tCfptFdY1Rs8m5xFBHapFH70J7IiFKGQuF8URxu0KIfB84nkg0jCuMF63uVLWo5HyM2swYgEuRooqUygcDv16pVM+5MR6QFMUmCq8fwFj5qNl3IRw0bkhbxy6FqcQoc14uxW3uwGZuI0WPDzRCdI1xYUSopJ2pZKhE5eFESOhj8iKph0bNmjpTzrF2vHzR1tyCrlMWeV0CU18/EhnSPuApX3jp/GluWtq5lsiQlkSBL8zKkijs6gtt4K414xMQKVIIgidEzpjxYquHIkTK754QOWtkcqT1X+o6V6oW5RSh0noAk9yvZhnCE0nRJJe5uZnNirIDTiRFivtYFSmiO6br17hPZpB1l1ti3bfUu30CMZrzvb0Ut7kLNHMbObq+aIToGqI4R/4S7nG5tuYQIYC0ylNAhADoB+VKoWY2t9YNMUWEAMpcIzCuKxnyQOmqq8nQnHtHWg9HSqKA44VQHWdMiBHCCRWSZAhANZJElYgRInGBVVYvu72GEOE2GCFyXs2bbOhlSFzVbHSGFJUqR5WkaBFlYIG4zYOney7dt5YUZcZ2MFIEUJZoowAHixuqea9XfIPmEqODqURXgBB5NGJ0/dAI0TXCtSVCpSoQn4m/rFTZS6NEJdIWsB3Vm+DKWAJPoGqJkd+HE7FDBrjyc2Bi6uqDkyFvkGRc5ABgnEgBL1jqkyh4w8Ja0U1OIkNY3XEGpa+2BilAIMfoaEQG1+EoJUTOJQxYN/4dYTIh0saXO7ZcfzlVqEQ1qjCyJxnEE93nUu/PC0n3XIJSUsTTLE8lRZecWGGR867FCi1BigCK7rGSeyupTh5KJbpEM7cRo+uDRoiuCS4sYUKuvVoilO2jfL9rR4Q45iSpOBQR4pjy8dTUqFxbS7rLAYCRMrwB0KxuWjs5lCh1WnptDzQ+kl7bq1soiYLD/aGyE8Zs8IKoWC3SYma85+RShEiLvZAyzR2CEEl950hSbX8l8UwSKgzti/gUl7xDrxUpkupeFCm66BiimkVJ57hAT3SPJ01MVSEfJ25zHI0UXQ80QnTFoRIhPjNfgSpVSJgRV13VckqQGpCe3u/SssTlZmWntMmRIp05tzg8Hs2VihvKqfHnZhWnLBqbU4xKXz+SgsjOg5haew4Z0tQgKaYIJ0/wv+HxYDKE1SAfR4TUoSIyZAAAnbpAbiRCZAxzZaOHmU3FPVJX2L4aERnQb4k+FiFDmT7E7bXPdIkqJJLHIV8n/LT853iKa/EixvkSSJEi/m4rJEVpheJySdGuqwn36VSFX8ISmU59U+zeSypD2vVMHNdVd5sjMAZe3/+Hyx1DQxKNEF1RJInQRFQTIf6zGlSeGVPFfpeeICF3jpYkQwDxnOfUIK1uLabOMi7lliduz4wpp45hso7vKYkMlRKh0nGgfiiRQePA6bX9dqIQIdLTjY/LWRPJDx6CRIgAwjUm8UQlhAigQFkR9tP27wVjFsczLW1U1xIijqVUoxwpKvjkLvlZnvoerXZrOhQ0UuSxdBa6qfFEC8MJz7ReeeEx1L7vp3yTapNsiD9X7HfZpi56Dhsxupo4gM9Nw1yIZMjYapc4T4BwedQmb9uacjJkbVoJYimDc/t5MmSMuRgyhI9VOe6DwJ/vkuuJ617UGPm4lnLNS7XDFZVUjE9u8VUObrCnPoxFKb79PWPzZAgnVcAZ5XwMUCfsh67zSC2SzosXXo1BaxgZ2rZ0HCWoMSKwSoUzzJWQIaXeouPLwZ93/E7Av3Fo77fcOc7d3xDv5anvwiXen2rfuXeQG6JBSsjMAi5cufFI74aabxqA/k1L1c9NCuI6Ja7kqfFh+HO9tPs0voaHwowU8ioRumpQ7pviePCGC0VTiK4QllKFJiVKYIZlUqXha7hILkS4biahwoUrQVNJxRLqUC4uS3EHS6E4he4Sbn9zMfcjW0KGpKQcJS5zNWQIlbNkCMcWreRyIFZYLRLuC2ei8kMSJyhqkZhkoafXXlWIErFDo30Elz0pbqgqvTZAPN/czTa131SFqBQ1GerCeZkfT1f6qa56n6bc/3J9T5zVn2y8T1WKpN9xsyVujnQH/bfUvtL3r2bNnqnney5Kr9dUlSgFdGxucMG2yRKiy3Sby9lEDE0tujpoCtEVQSBDWDnIqAhc+VGVoFghaZD7GcGRSiPNbvmZD2+opMhQQhG6UDK0hMJSsz/vj597/7vB/9JqHT5n2vUSz6l3T7hMMgQwzRjCz4PHVDKk3qsZMqTsJ5EWUpckWkDKEH+O/O+JdnHGOZJ9zvj7CACEwxAXc7XoXwkG0MlQqFOoCvHfU0aK1FduHw1LvWtKsz/i7SVuxZnxSarRJCWJ95VT9FE/BNJ5KMouidSjUmN+tG5ahVIk/U6aykz6jXfQf/P7lipCvG5qbBfpxYBReo2wMlwK7XgE5ctYcz2UIW3yRkFTi64OmkJ0yXju6kXxhZMxFvELoShLHN15978iU09Sgrj6k0mMcGmxQSWKWc0s25Q1QTTFxwgf8Rr3DgVZ//+pxGiJBBO5hA18uzQG/3OODOHtqXOYM3IlMiRltdNih9Biq9GtLe5HlCMhqYZIakxc0BQrQESFKcg6Z3p5e1Q3UJcaQcFkJ/Q9JPsdbePnuNKwSPZRW4e/76oUkoyCVKoW5dSbmt8rZ621drNK0SEym9XM9o9cMYf076Ep7X15CUqD0OfBznspDhlTNHftIb5fLt34Ia4dVrLx35VoatHlohGiS8RzVy8qqodl4qp02dy3OGdoS4ulai4r3OhkC6xeiUVTS10HD0mGSrPI1cbFJKCufF4SxJoDP75cVjt1kILfu7aOhtJ/ERnCv/Gy0q5Yj/1NFlwNbcixQ4EA7UmPllUutknbHalB6Fk0gwu/U+Kx34YSG0wmRADlrnJM/RH7TBn82rYalH7S8Dst5ZLHjR2MOaQIv29T/ebGi9vVfl+QWGbduJZwiy1NH83HOJEQ7ZoquG8qk2PMQgkxyh3vkjgUKVoi1Tbfp/a+mQv8fE193vZopOjy0AjRJSBHhLJKUOqDUegqIBKh3Q95JUho61Izw2GUvoTxeapZu4G/kFOBoZKLXPgtrwyNzmVqxld4jPGjTeKM+HhzxzQl8PUQ8Uo5MgSwDCGS6mCCIpEh7G4kkSG8CCsiRL4tKbvcri7E/f2taSGWJZc0Q8+5J0UppSaQolJCpMUNoe2BjGlt8m25d8cUgrA0csprrm6pEoHfuTXjWvL9W6oSHYIUlaKWnE3NPEfauEBSxPuDSzz/U9ydU9+M3ARabart2gnOJa9d7XOXI/3Gwuu3P7zM2BqK0QjRBaOEDGUqlHcmGJDi2kG7CrCvkDcw8XAumwBh1KhnHjUvUr4mTWk/c13kcrO+ChnCbSQfc03lkX6figXTlatkCEB3lxs3Mu6jpK5/jiR3OWNiWz5JgjE7MrP/fawWyWSIJmrY/z+wsocnIAO6JxYmRKKKVOIqp7nYAeQVIo2YznEjWwJzSZG2nansYVvNuJZ6HyfOYXGChUORIun+qUk4sDQp4uM6FFCfl+ZCtyQpmpgYIbn2UK37+1LXbAohAhjbH+z8NlJ0sWiE6IIgEaGqmKCSF1EuPgjPOnbdYZUgSWWYqBYUud0tcf6W+ojkyFCNG2PuuKeqRBMxuQ1NceL3hXAPq/eddG5yhEjcJ0GIJDLkE2Hw34UU2w4rQ35sHf0dp8oG2KtCYdt4SM6YSFAsxKxxJsYUSYQIAJEmZtCphAcAYADZVU5zh/OucikyJM0O1yQruAooJgYVpEiCFqeZUpVqFaaKsRWvT1RrmDJ3ULFcRUaV/g9FiHY75/edg+tKigDk53sCKapajLUEl6EUVZ7DRowuBo0QXQA0MgQAelxQaSxFYvY+qQSN2pMJEEAhIeHjwpgYu1JFvjSUvngOtcL33Hih0vNe8BgvQYZ8O2KMUilyihP6Xb32JWSI16t1lxNID0l4kCFFOJFC2H81/h2rQaR9/woQxm16J6pFWULkN5cSIil2yO8rpdjG/Un74P2kCZJctr+rhlJSpNWt+T20LyhJJb9PccFTfy4gJnNcl2qUvgXVoTikq68SxS7xc3aBSh3AfMVoKUKk1C3GIWOKyPaJZBIaKboINEJ0QGjucUVxQRx4Nl1BSMHcdbLSIyhBpusI8ShWY6bGmBR8kPgtOZkQ1bx8llwfByDvJsfqiPFCNeAzqMyg4ORSuuZ8G/9d71rffwqySmQFqc8SoilkyG/HpAggkiHYq0EWSB2qFhkAa2QyBBDc7AgZMgBhvSED+4QKhpAZknWud7t62wmECJGh3X5UAdq1IWzT1KGU0Sa5el20WqQZ4IlnKqCWFKWM/dRzjBWUqc9XCSmaOrkyVSGaO6kS7kPF/TnjnYDfX9UTPZdBioR+LzWua45idAi3uTnIPes1EL9d0wmRRyNGh0MjRAdCShViG9MNZUjGyGBMZYpDv0uG5iKuaSlcJBkCuDh1qCReiNctSRBQC+5iUrxbGeGp/X3KqyWrSmbvB2ECILW/qOAVkCHeFydDADF2CJgy5NVhKdU22m9Ehjj8t1vJEhfScGNCVJJpjqg5+98Z6dn9hsmRoBDhuhoh4m67GBdJinLt5p6tGleu3D5Sn1P213CoRWKnGKlz3G9L+sokd1lkEueySBHr+9Jiu+YY+RNJ0cEI0ajNGdfxQIQIoJGiQ6ERooWBiZAYI1SqBPkygzh7LsVN+Mvq1SIhJXay31yg/RRM8N1OEqLrRIZqFhWdC22WS/PHz81CT5wtW0SF4mNOoTZ+aA4ZwuoQiykKWeSCGmSje5u1uxghrA4ZE+OGJDc5E7fRWB5URUiKsFNq/O+JxAo8RogRIkKGyH4uqj/+WmKSlCJDmhqDkXOfq7lvS36vQS0pShl+c5631LGmMCEGhj/D4zYTRCWVuKbkWGsykgnnm6s/S8RT0vFdYVIEcHhilHPxn4vLJEUA066l9k5Z8Pw0YrQsGiFaEJwMjVCxxoqEohW1NZKk7Z/rdyky5NtKoJgQTckmN+psYRc5gKp4ofCzYIAvBo1ElMw8a/tNHsrE9ahK96l1l5tLhjy0RAp+/26/OCtWg3DsEHahY7/v2t1vQ31G9zVUTSJE2JVOIkQ9vZ6hXaL2CAQGK0De9VZShXBbiQx3dBDo2HMKUem9UUKmpyDl9qYhOxueUaJy+5SOA6DKiM+aCaWxoVMXyyxVERIqEMbihMjjKsYVkboXSCIugxgdMl6q9jrm3jlNLbpyOMAde2/CkyFjTd41jrtN7eMJACgB8GVjzFgN6rrdv10FNmM9dosz0jonqF8VF0CGnHP16pDWnrHybKQvu6H+pcmvnRQvlLvmuWxyKfhrjo1+vE36fdeB3F72RT3zd3GXwn2mGLw1ZAhfq7lkSBifk363+PfxUEUyZEAkQ1n4d8ZUG6zEjau0nSmGoLaPpMxpv6f2yVxztY42ptKxeOD7j6RWz9xfqTZzz7k6EXYJn/8pRqBmxON3Ov9ZdB8bAnlwfU+34/95uQa5d9EhgL8BoUtkM+QgfdOWwEWtRYVxiOMIbSvvEQ0XpDXklnJpKEdTiGaiWBXCKMkKN9pHiI3gM4OSW1wu69tFoXDmDuOg8UwlmBLfJalDueu9lMEyJ81uLQ7x2phiOGjnSDq3uQQKqFxMhojKg2OK9tuIMhTvhxBHhGOPMBny24RzIrnNSYkVkqm3AcYKkb9/crFFQnY5I6hGpK1ShQiAnlu+bSrJ56hVjeYQxZpnpVhpWYhsFiwyupg6RBqtUFJKVQ3mIjf+fcL7cSppvCIudLFrwW1VwnVQiy7bfW7UT8F1FScylidvTS2ah6YQzUCSDGmzLopSoCZHwGWuAhkDpuvCv1FbGkGzho5PUq+0banfNUz5YF42liJDUtO52Tthxq8KXD3KKUzafiWY6wY3xWVQU8R8OykyxGf1BRVhijJE+4J9OzZmasOpt6V+/M8aGUoJFc7F/UnMGPo91EX1bOzXiAYkKmcMzHAsOZevUjJUsi2h6mnZ+0QiWuSCW0jIcuPPKV2SepTqLzWm1D5TfscY3Lz3uvR+VCeGEuPKjUEjJlJ8W+oe9+rSnEmnQytFHoq7fNIuCBXZN34po11T9A6dEvyQilHox+jfnYu65ns0tWgemkI0EfzGI0kTJJS6TOUkd5RFzpOgkr4O+mI4wAJ4l6YOHYIIpdJr8/0vw41l7rolNa+QOR+I3LnRPkSSOxL+WzCotd/FdjHZ8coQfjaRSjTsyyROSFqPSCJDmOugOKJQFlQiQ1QiQe1JbA8Z5vC2fhjXI4qS5H4kGJ8ScmpextAoIjawOydSXVNj4GtkL0UGa9rymDumXL0CJaM4e9kU1MQUSbEiOc+DUqXGmLi95B2VexctkMlvEcxRi8hOCydgkNqbmQhJXZ8osc9BUKM+H8gua0rRNDRCVAmVCMUN9G8WG6QGl5cSIdRWcqV3/9K5iBmSygXwSm65SWshTSFJM7P+jY1s+frH6opRHupfIdHWE6XSj7s3KrhL59RMXgCx/wORIa8UmMHtynysJe36tozZqy42/o3XHup8BjpfH2hqbovaCX2y4/TD44TIXyLndirQ6Pc9QfK/EaMIYia54OK274cTH772ECZDPMNcrbtcylUOlxmBDdfOt8/vudw96cbkMbTr39+iS06BG11Bv9nscLWkSGtHGzt/vi+SEIVOCogLXm9IGIeYPY7fvyXnBmB83SRcB1JUknAhk5qc7jzohGYJ8MRT+Nucy1YIGVKU2C85Hj6GQ6ARoyuBRogqUBUvJCRJEJGLgdDSZaspaS/BoC4kRDW32qSMZLWEaOYaUEm/4IuKG7ooXGR8kscUt71Soxqo21SxqxNumxjm+7ZwzJBQJq5aq0oyBEBVIk9ypPghgEiCpPghAKYoDent+NmVsswJcUXU6M6QohyJFcqimjcVJZM0U0jRlH6XIiBTSdF+e/J9fQg36BwpKiBEI0j34hSk7q/Ue+qySVFNBrqwT+WYLiN5QgaLESPNRrhGxKiRonJcUevr6qE4XmifRUiNE5HiNPjH3hjy+8j/V4oB4mPAdfE2Xp6LwhfDFN49iat73/bUCzHnW5zLvif5/2faJNdQuy9SKqHko5zzWy7xbZaO5bIwN4ZpCTJUowzx37s4++yMCcSCxLU4uo38XkOG8LOB4odCFjvy+35yxqGx8mcLb+dxRQXEhsQQ8TbRGMQ+c/X28ZIAynVDv2fv8ZL7vuZ5yE1wTNlfGuMk9TtDGBUPBL9d/YbVGMzSd6ckK2dln1k3OdKWkAAExwel4o5qkzXk3mWHfv/OzUBXgsuYhM1AzfYbK5Q1pNk3NTHUl4wWV1SOphAVoCheKBcnUpOOU0ibPXKHE/ereMmlPjAl0rnHlGw/FZj84p6qoM1RhZR2souvXkaqVo6s286BZwGnKGMTyBAxqLU2tN8zykVQgXBM0RopQ54zCCpRUQIF7i4HSLUYQHT9klQkfi3Db7m4IkkFAtSvthaR5DonQbt23gWxJEvgFGjvKGF7Ns4oF58iQXKf09qdq8zkFCklNmxS3AlA/n2ayw4mul2OFaKquKGad1nOg6Okbmm/V0ktmnqfPV7UopwrfW17NWjuc5eGRogSuBZEaMrMIV/1m5dzq4ID6A89q3+lCZF0Dmjnu/81P/IMMZ2cQOEyFBse78CB43iWJke1ahC/HkuSIa2PkSpMZ3ZH8UL7v0lWM4OMemN2iRUM2h8AaJY5oOsJcYXIIXK0J0Qkixz5ff+bRnoA/ebtgFFcETPatRgiiQyFPtjfUoyevx+cowkrtN85mffXuR92ZU/U/O/8Psf78zELcSdFsUX8PiqNaZL252MqeT+nkG1fjimqJkWl36appEibeONucvz81r6/Sr/hpe8xrf+LMsVKidFS6dQnwg0OjDWB0CQVn0w7hRXjNx3HME0lKFPPRaY/fx6Kj4uhESMdjRApUF3khBiRYiK0q5ysK6bGnEqEcjOTJZiwBkSotsCttSghyiyUOjJckgM7ABm6Kq5rWR/zhT56NapQqXqDt2suckodfaIi/cwGMqPEDw3rbj+GsZoEgElSbB4v4CqRIjF7HCZEwhpEOOlBjgzt6gvZ5RTD0mCylFM7UklKAERXYpqiXHA1Jvuja5tSVqyh8VAYpbE9kFaNfHKGot9z6tDSs/m8fVxOJFpwuXOau74SppAitLhqkhCN+prw/ipZ9LrmfXaZ6xQp/S+iFi1MiCRMIUZTycNsNFJ0rXC1nR8vCZ4MET9UHyOC/J/V9YNS66PwdWF4nBD2rxZik0IZt8n78OVDkCGpzoHIUDUsO38Y0nkkv1eQoSmQyJAU23Cv4LLIkHbOtfYy90ogQzh+CJfRMxvISmeCcpMjQxKMcyCtMRQbYL/zYxiAuugJCugouxxvA+2jGvype5pfszARNL4vRDLE25JiJaX+pOdfiuPI3XMCcKyYGCOW+Z3clyn1koMfOz8fuThSUW3VCcBo0o6f0ykz+VP3kSagpPerh0KG/PfKOacnZ8gtYjt3okga7wVCj3uuGNPMtX/c4LJGvv8d183tl40pOhRq1nXKxSELx4C31RxjiyuS0RQihueuXjRNEQKgL2LJuFYWTIu/IyLEt9GdtOFT5OJCcsjN2h2YCFWpQzUucrSTukFJ7Qrti3FDQuDyaCyl12zu7ylMUYhy6bnx75dJhnLlihiyECtk43ai/HQofsgbwyiz3ODHVkCGoitcJEFSxjiccpuoSFs0ay6l1EZtkN/wvSDFCDknKxwptzlyYPlrMnKV43UlRYgTPv47Bn+P5cY+973qIbjiqX3h8pQ+tXeLlCTDGDnxAOv7IKaDFCukueoJaxFllaIMIcLIfud3ldK/a7iC8US0+4LnJIeJ6shcNQerJxJBuDS1iGPCWkw1pA67GmrH3JQiiqYQNTQ0NDQ0NDQ0NDTcs2iECOF5R18wdpEDSLvIAUTXNy95e3cSrAykUl9yNzm+je5Yd1DSeKZK83hG7qq5yUk4hDqkydqSOqS5AuVUD2n/nKtX6vdDuGJw10++PfV7KUrclvh9yI49zLrn3JEAqtSheF3p7yE2x1owjipUzpqgzjhrRu5uOVc5nFQBHHJ7G/Z9K7+bXnCJ4+8E54Ck2+bqh5ZBjjSqnFf/d+r9k1OHtLolz3XueZBc6LSxJ8aaRMn9B2N3uirXOanP3Lix21unPKfKu2vR1M0cOXVhyVgV5X5W3edopWlqTs1C04dAzdIGF4y57m3efU5TRqa6mS2OUle6yc2bcA6kYzTWwPOOvmDxfq8zruYTcQkIN0btmkLaWkL89/BTgghx9zzpQ04aK3ypTvmAc9cE5p7gmOvEePXraR+s2W5y0ppMJTEDU8HaF9caSvm087o1v+eu79RjzO2nGUtifMeCZEgci0aGCwxJze0q1UbJ2HyaaJxEAe1CDV4Y1c0RMxL/U/OYFRhuYkyStqhqqSFYcx41MqTFDvH9VLKbSWKikaKp90Du/hNIhhhXVNJWzftDeh5xX5wUSZMamBRpC4cL27Lv9pwrU42r0yGXCahZ5yiFy16jyI9B7PqSSAIeQw1REQhyLr4It3/ppIiXF+0iTf4aKYq452OICBHyyMULTfQhzmaQ0z6CYmP7/abOlKUu+5wVwSfGivhz45zLv4xLFCFcD8+Cz33RZ1Qngz9iNarQRaDmUZdS814EagxNzSCWjOpUlqjUfcLvGX+fhmtM+/bExvnMcmgbkDIKsvfbEunwcQwRAIyzzPG4IRxrhH5XY4icS689xGfCpdiXisxsBNL5Lbi2IomV2s3dy6PJHHQ80n5qIovMe2bCeEyOjM7pl49Bi9XBv/V9fJb6Pl6vYRi9t/G7nJdFTIkfQtvVtYhCvFR5/BDGQWOJPEpiig71Pk70PXn9KYBFVLziNYQq1g3KkZ8rE2OEkIuLGqUL9+UEpLZ+5vxVs8d6nXFPK0TPO/oC0NSEbAY5afaGZY3zGKlCAGq/WSWoRF6dM+vAyRByj0tm4JHKhcjOIuYyGEnnMjfjPwU1ZIj+kN4mHdPcrE0plJyHVJ1DEbmp6qBiUI+yd/nygZQhJ15nPGZUl5OhRNlI32elXXlc6A+8xhCMt+92KHAT8sPIGQ9TlJSS/ae4N5bUxW3X3AcFLmbZtgT1R1WKpvSbU3bxPjxNvf+762K9rovdCX1r7/XshFeNIV21SOwBzZ1DZJ3DmKpUzu72gN+hkv6lPqX7g6RozxOBXJ9LK0aay1qunG2Hk58SW3G/zVgzqn+vq0X3rEIUyBCArghl3Sz2v6NFK/XZJPwSE1wV1FnOxEucLxqmLSImvkByrjGDPPNG6mde+JkPUJEsXzobwusu/aHQ1KfQnWBEIYOBVRbbAABdJeB1pmDqLKM28zz31VFzjXLKECqLmeXECQzhmlWMlSg/OOPcvjys965z1uzScsNeMRIyznnSYhwth+57gYQgFYhkiCPl8RpEMDBCtI3PMckuJ6kT0tpDGNo9kYs7ypEAzViforyWjFFdkHqiOlQDQbERz/Uw5PstUT15v7hdgF38mL8mUiwZV2MK3zGq+iCtP4Tr5DwXJqbH1r5zRQpRrJz+XcNc8rSEGVdzXlLfoAXju2KTyv2Rg2I/lRIerKLMUY4khUdVe5S+i5WhHKQFaNnv96pSdE8qRM87/cLdTaApQlJsEDaouO8vJ0N8dj8XJ2TQ7x61SpD0N0D5y6OEDAU3muFilKDUCwCXcwrbXKTWBsD3TQmZTpEhvj330rbK/aYPNt3e1P2k41cJfgUJKe1fq5var9TdSqlDYn6EusNKNtqJse+fMbSJxJHg7Z0wTrypVgWRqtSSmSn9XMTs9lTXPQztmcopLxnFp2qmH983PDkH71cZQ1Qi0f5SW3g7n8hZob+lxAu4Pi7PvdYV7lrqpN3Me2xWLE3NN3KuekXsiInn/brEE9V4vSj2Tym54cpNrXIkrRuk/Zbrm/04/lt7Z3E7AddVFKTnnX5hcmyPV9xzCtHzTr+QzLyripA0m1bywsgZ8eLs5yGl/IKV2IXZF4dnAqfOXmUCbmldE8eSO4fSfod8aZfEl0n3kfr7gT8wpTNZh370cftLkjHNQLWy0UcMhSJVVnj2EWgChL0KZExQgYZ1NArxukReMQIAcH6CTiNWPv4npxIBgNlGRSHUR79bpAB5NciwmCCzVZ53Ze0haRyjerXQiKP0Xq6KtzT1iqgE7VglRURTYErVqwJySmK3pPtUctMZXNiOy7wOAMT7wLc9yMqMGNukfTNQXVEhyqlDuE5u/SGl30XWIgLIK0SpehoOmQyi5hkQxlEcT3QAhWjXrPT8zVOLprrG1RKqnBpUDUnhybVf63FiDfzMnVdMH+M1xD2lED3v9At3LzhOhrTYIJ9K25eBKgJqxjiPkjihTArnItavqSkSsCGE02cLmeRUJSj3YmWxVEk1iI9dmrmQzqEWJ3SZyGYdVMacK9fMKvt+8P8plMwsSippCaaqQTX7+XuxViGZOGvvtN/998ma4KaGzz+JD8qRIdLfvjC4WMaPHy4LpNtIxqrUjx8LNq41o9d3p31Il1T/NDIjjY0nfuC/zx2T9FzVzMaXTIpIk2/Ks0gW/t0jl52O1F3Jak5od9Xt/vl98Jg6pSyNf8m03UsY20spIaXk5SKVohRq3uO5cdTYHAthNqHANk7YNG3yRkrdjf+W6hc0mi5LXkNY7VGOBduoqi2m2Az3mlJ0zyhEz7/xRfIPkgFb88JUP2yCqkA+UBnFowalszU1/th9L7RVMOOfU4Vyx1d7Xi6CDJUoRJKriGYAzR3zlFigJTPnHOqVUXJepPtAcxfKGXKlffr2yPVG/awEwxSpRFgZGlbeMC24H7BK5FcdR4/rKNMc226QuoMVIKIGAQSDjWSj0xTimoQKuftEI4G5GKKsIr/QOyE3/qnPlOA2WTSGGpfGEiXKPxeF7Yb7SRuTFl+EY22F/YgJ4r87S2SXw5gYS1QW55qJabsqCpGE7D0ex5M0FafG+EzA5HgiDPRNn0u0FlN/cp5CWpxQzvVOe89WfMfvFaXonlCIAhmSFpAEoLNaJUpQaMN/rBFzT6lCqd8vcsYlQYZc3+fJkAQWV1VMhvi5E9tWjJ4lDB/p485nmoWXrrj4qqZu5MhQTqXhv5e6ahwaU5UjvP8UFUkaAwPJMOevpTW6iuD3MyYQH14OQKc/JlOwwV3NrWzogyROEOKAnDVB+XEGSDmOCdcXjlE7FjRzGMrOUTVIU1RQ/Wry7ZG7p1NjlsYklXMuezn1KIXc/Z1S7KWyhNz7v+Z9kFOV8DsaZ4tL7ZebYCCTBOh7muvHt8mvZc4oDN4LC6h+mYnPqxA7c3CUKEU5b49Rm4c1K0fxRDP7U1UiyaYT+ptNhkrHj9Ug5X0hxWmnkoVI97pUVgWFxxke9wrR8298kT5DI6hCRVniSBuI3AxuXFdThZYkP7UKESY8NaoQRkZRK0rXmXsRHFIVKrnthWtntAxXkkJUE6/Ct+XGp80KazOMSypE+F7PjQkDH9fUa1jgrlStDEmkR+0/Fp2/5l00HEmcEFGGBJWo4B0gqUBFKpGgDmmK0ehvvAZRJiYkqxJVQD0fmjokPWclmPP+uIjP5dxnK1WHAz/LKTVKUga1bG65+CL0nVHjUoZ+vE36Po3aKFjPR8ICcbIlXhNZXLRChDFHLZob31OJQ8QT7TYr9po8iPL+JoxFhEKC/PWoW9jeVt9vr7v976vqXzc8rhUiQoa0mXxl7aAAdeaOKT0+YE2LE5JUocsAnmHLrS808eMvkqHMLEuom5pRnaMK4RniqUaNNfJ5kj54JXEGOWWpVjmS9kuNK4eamW4+rpLx14L3za8F7w+Tr8GN66CxqGTIQnxL4sscZsAxETPBWHSdDWv7DJ0FH+sTFm4l98f+Hy/zemGb/DtRfgQEojggZWtfP7mvErS/JBlSwftNxRPhmEhc1jCH3Gj3+BKTNalYpVR/qeevS8wuj7wYzNjQxwlLQjtIcSLeF+Xvu/CtkMhQAv49XEWGNCxFQqaokByHjCHKoeLeHalFj4N4ogmDqCMzJfvmlGYBZYvZs2fVkyG+LVN+vCtFj1tC9PxbXyK7xPkXcdflpWBszHukXN5CnStChLg6JLgbqGs3THixq0kmcgvFah9o2nj1eALELEgZtxsO1eWlkAxphkyGLDkb67ou3r9aQHSSCJWQGn4MuevCUXhc2X6n9J0aj9S3RIYI6dHKdrSNpshGahBJdyyQIa0PAVJihlF73lDERAmnAOeGrhnvOyKQuP4EkLEo17FELRvvpKkLBS51UydHKp7dUbkGqe8KL0sJDrS6VtmPkyIAagz5v/cQswCWkCIMTopScGN14nHr3HLZpGgqMaq0cbDKMyW5wSJxO0uoPDUubyXb2HcvmxTBN8V/E20T4Xnm2wR7mZCiW1+ijuG643FJiJ5/35fuClwJgh0RMl0XWLX4MOeMeVUJwuVy97hi39waSK5yaFaEqEK5heww+DmV1DVJFdKQe6ktpQph5Awmfh3FF1mC9AxON5yUNpw15J/fhn+XyrPOj7+PpX8l++I2pkIjaiUEWTi/o3PD44fwb1BIhsh4dz9QcoLKnUUqEVKM9m5yQ6f0Z1g5pwIJMM5Rxcrv5/bjcqwuBlaNtBgigNG9xu9XqZz7O0mGJBVQ+j01iePVoprFVjWUKkJLqUUAZbPGvIx/RxMpqqok7SfWUUiR8E1QSZGWRt2a3fdJUo14exylKo848cmIXw1K1uS7TDe4qZDul8R5Kv3+u8GpRGjOwqdaf7NQoyL5vnNxRyUTwlLz6PyKse2kPUW5jQ2kJ2qdYr+gbcHGfpzhcUeInn/fl46ZrWC0q0qG9DBbQ8u7BpjRrOyXuNG1Gzq7gGkOEhkqWbOhxgddUtc0IimhxJCeY1CkjCOpXANpBkWbhdX29wY5NhSxYa8tnijcf+qaLamP/BKza1PaKCE9SyhDWp/4vGlkSMsAh9ccEn5XEy+shGPQCI+mHgnAKhEhVHj80i3OSVWJmiD2L49bWwRU/F3ro+bZ12JfcpMhWhslqFGEliBGmrKTTX9d8G6Qxp8iRakJiFw7OQTDseD7MBXa9VhKmanIaHelob4XKkgRALEF8Lo8HrxcQ4xElWgGKZpNynj/paoQgKoAkfggbMsKZbldm38v1bzDHsek6HGVVOH5D/w1cbv4oOJFqnLZzfiCVkZ+2Ef7KeMo8vlEyF4i/hBjQoRToe6DUqsJkfIyVGeFJGjnMtdfLUqIkISC60sSKviAej7jKrme1BgTeEYe7yccl+mHuMhij2dWB9oexqEe9zluh1MhzFxhF0NybZhhTmJoCLEQroNzMhkiiRLiJIgnQM6Y6CbXIUUEeTtKsUtEvSlIoGClBVt7ukirb5Ok397QWI3wW25hVl4mjSjnTyuXtiH9XgLV+E20IT2v2lg0LBiTqY6jZExTr4EWNK+4G5J4MumbMrD9hDp0MXB0bwpJgMZB/RMIx5IJFnKZP2vJ1lUmUIm4rexiu7hu5pthrAl1cu5xo7aWXLD1wFnz8LtIshGJvZi7j3BcEMcSEzMCXvfIyw/S7mXgcaMQeTJUvHBqyoBX62JjS5Fn7bhvrgRNUX2mKUXYgBFeECUv3SVUoZoZ/6kPLXeZWUQJqvSJryFDxH8fzYpKLz7lw4rjiJyW/W4J5GaPAORrXHLdc+eqZhZLA1EybJ4MAYiz6eo6RLiMOawdb3cWgmozSqwQ6uJxjNszLh6T0W5to7SNXOHcysb4IsGdsKhM3okV+9W2MRU1EyR8ckN7dpXyqK2lUDJTP2GGV60rbdfcVvcoUoqkvg45H5tTy9V32ePGLCpHzTHzezC33MZEQlHjTjciTDV9CrZRkVIkualKv+X2FVClAJF2Wb3ce0h7RnJldN01IeI64nGhEGEyBMAZtfbCLzDeSf1yo/9Q6xeol4o/vCWzaxIZ0oyinCoEkCSHxZhDhjzmSN7khdaNthuSxllJaqARE39vlhAXaTue+VFm6MgsbUoZqo2ZkLDEa2Pq7LvUhjGiOyEQ962O7quRIWFcuUVZAVhq7SOvIIK4GKsaCyTF+TCVyJMgaTFWAACzxUqSkH4bz9YDEKWIpN/OqUNzrhtua4riUYsSIs/rCPtoBGgUkwWwnDo7VyUrQWps+LfM4qxGu2e0hX5xCm5fJ/P92jWdcUvTDMgFFm5NomAiqwoXoRThsdX2p3yL1HTqODnGxG+1phYtnYo79FNrK2Jox5jxItrV2febUn1yyL1b59yXbN/XPfxvp7V1hXDtp0Ke/8BfGykWIhnKLZxKlA72kZTIkLDfQZIj5KBJxUoQcRH/rVWFliBDNZACqZNB04NcxpCMaQTxRVXSBiqrZEgjVPge82qQNawOUpeWxkUpTbnU+DXj432EtcEsNVrxJVSMGK8kqWTIxvZJXMwKkzDBqGbZ4nwskBoTpBC3mCobjdGBnEIbPxrsvAWiyNNxC/E/BNJ5066hpgLl4lq0/WohvfcWfEcVrWE1BQXtagsJ5xYY1mLhYgVBdc89nzniiQ0z5NpLvktkXOP3ofoNK0mOUBJHNRXXiQxp56o0BtUD3we5JEsA5HpOzRJXlYihJtECsg0WyWAHoNuYCEUps6e+X2Mn4zYLIcfe29H2x4NSdK0Vohc84cuQwaPcVDXsXp2xV1ynyK4XQ4QcJgBhI3tx9jIB8DNwxpi4CKu18ou3RhVChuEsIyM3mzElPkgiQCWucCWxQ2Fb/iObJUOdrZtBVmZi1RnaWoUodz/PCUIv7SPVj3AOSfwQvg7EtbDswxCMRQtRodEyy61j+3hh1uEIq0d4jL4NsevEwqvC9sGF+lQlQh93HG+EFSC+OCtWivw7QbufamDMfEVxiTZ8Ox6VbpwlpMfgyRoJCz83VUQM38u4udL3hKRAI9KUjSMCEGNaAQAcWQxYuvfG37HFoC4wW9nPREKEF9ZUx7U0DhHTNFEtWiSRQQlyapFG1uYoRAVQbUcxG6Nir9ViIiHKt2vgP7/z/zNhQFcD11shShnhpUqQxKpzahLu5jJUoRlQlQ5MgPZGv+lsJANdh8gAOy+hjQXOQ60hkVKFcmQI7y9d/6J7xdA2hHGKrly4zAmV4KdbPSMbOndpI0dCyf1cc8+XKDnazHNqBgxtUzPtIaKZIkNk5tzXw7cKyzzn3dZ2C7C6MAZPPnBfg7D+0EgNQs2H35jyEysIkyKofZx+m8YbsQVYO4PqKfeFROTnzFLWtpG6d0rramPi7w7t3oNy4uFSx88Nw5JFZBPP6yjWzGbKAOIXX1WK+PnAKg8GegaljJlREWLukcgFmHyXCr65U5BMU8zHyreXoIJYFcUV16QD5+/5HKaSvdSYlHNX5WaPgb/hS60XJKW/rhnHQihKmZ0jSpqtcMjx5XBR5PZAuJYK0Que8GXpCjlFp0QJwqh5KWOjeKlZTYSiLC7KzJrkg41npwwy7opeXDUEqCS7HIZRPr64PQmpF5fm2heMGPm+qYodYoaASob4fnw7Br6f/IfMGNkv3zmkHrBzsRQZKm0v9Yzk6lS0PSJDYTYNEaYVu/YSGeKuafi8C/3imCESS4SUod6XLXJtWgHgxAqejDgT1y0S1SAAGje0LxsX2zMooxwMaF90XxiuDAmqkeEGlr/XsBo8FUu0kYJ03VJj8eD1/fWqNAyKFJea2IISklZrC9UoRfhvFn+mZpyTlLJMHNEuthV900if4+9YjenCv9dZRebASpFmP+hxwpkxaC6HOcw1oktisiS1CNsiPc12GX9Q2j501jcA3WWuYn3J0a7Y1sqRnV2l9O8p5O4XoZ2i8ZVgf16uo1J07RSiERnSFsBSZpfkWUTFz7R2hqrE0DsEJi5IRmaoxFXLC1S2Ekw1fpYiQyVxThoZwoaxtWNjIBV7lisLZMj7++N/yTYw+NgUA28RHJIM4d88keT//DA0ZYhllgsGIJtJU8lQpuw6RGS6eI+4VSQ1gy/715NzOzIkjJ0b3SQ1d5iZh1GmuZBlzgBzWcKNUUMcZ5oDSTWSjr2zZc+89p6ozcI0B6X3eWVChaKu55Ah6bdDkCFhn5FCiNtP/VYyMQgwdr0MqtFA2yhwYeYxu1pG19Qsd3J2fg4ZKkDK2CwylHOoVYvmYI5a5LdZU7ee0MJqzUViEtHw92XNPTBRRap1j0vZhFnh4griWhGicIL5qsDWyIY7f3FLSkBG/eCydvhba5v/dhmQgqHZByUcR9dFMoQXpu3GWdZG5Rw0V5ASgiTO4KVcSypnk7RYKClBhjGyjF1r9IdzbqmiJM1Eo2HTIH10XfB1rnWL01Cy78JkSFqcE8cDaYt3qql+VaOKkY5wPbR25Nk64nqH7UbsJidklhtWchv6AqdosHjoklFR8EylguirDGztfTCnvHR72YQQM8nQIb+cWrbIpY1c/Pqo/WZpRGOi8lWW7Cc9O6+5oImTfayONq5ZCsrEdopc+64SNEMb20UFY68mRRlihNtbLElCJUQCyLfNTXCglUvSaGf6GKHmnQ3XjxRd0SdsjBc88St2Bf6AaBeDzzD7fSU1ibenkKFR27x8leCPo+v0Dwlx/xLcwmqVIAztwzhVLZqyX0718/eGG/QP5cSy62xMpIA/GIqLnGqQ5owWPxuIVQ/ex9L3a4myk9qukCEfgxAWMGVlDJUMaQkuWPzQiAxp54krUhqRwS5znSGubeAQGUIqD4kdwsSKHSuevSfrDg2OrHsEBtW1yDg1JrrodTa24e9LTU3y+0rlOYoxR0o9KlGcckpU6Tj5PeA383Ni2f8IyXgcPKYcUin0+ZjmTJiXkKLCyYZsUgVrmGqkuEoB6N+sqS5Lyv11EFK0kKpUFVc0VXlYEjm1iKgV+DscbbFq4lJAinybqhJVCin+uMAuKVJd+LnLqIiaIlrV51RUnsNgu18DXAtCNCJD/mGSXnLKRy1rHGvqAKCba45xKRI0VpbaXerGtgZgvffX6bpYxupaZ+UsajXjSb0klshEp4ET3VzSB2JEd2hz5ljJrFfeyC8xJojioJSpIb4/NmVWNakWLKEAzcmURY47qmROUMyKFCXV6MSGk9/PUjdErgxJ/SKQRVcLCR7A3r3Oh3hpi7hqj4RRymRg8f8wrgGoa5w/NO66pMQeOE01y5HG2vcbyeColKf2oygDatye4mqUVM9qSFENUgrW0tBIkXZeaxVbsTKaxMFJFWonvnJqYQHRLiZFtQRCcL3TXeLkcVa50BW8wwgOkcWuRAlSv4mRFBVleZsITTnCxGlpFBGUrpv9vlA9mkrHkGg7uY17XbFrdl1I0bUgRAGpGb4UEcrFj9TOGNWghvRoH/m50FQh/NHQDNKa8dSu7rw0NPWQ3zcCGRq5yEmzWiXkhhihqCxsd8ZEwxNl/Co61/5jyxQRogpgGLOMy00tWRLuc6KeVTwTrrMJsrlvb+Bq2X5f/qEuMfjxYfnNg2Nr/uw/4n2MxTEupt/WFmP17TmDytgwtYhEWRMVHqz84Dp43Iri48mQM3Q7oHgo6dztdi4wlJciTjWEqnbtopL32QLPyYhYlMYQTWl/ia94SinSSJGQPMgp2wGAxhGFdmLH4rfXmPQSE34smlqYgzQJmgpsX4AUJccijL06rqjGbhiG5YlRYaxKcr1IgIOTIkk5unDXuqXUPgDVPtZUpCXaph0xW3tibPtl4sqP9gVP/uu7AjeE1I+vHZcL3CZUv90liclUCCx/NMsivTxKDA3b7f75/XIuhWw8AYdOt1j7opIUQ3ysKI24qgrxDyN2/ZDqVxiBxbPIguGjpkiWtvtZ7xojr3Q8qd+149bc+UqJuGS08DTbsDPmY/pstCgrJp7seAg5YeVQp5MJg0PxQSR+yKFtiNQQVzncPrrGIYYIJ1PAyg/OPie5VZE0x4i8OXrcJLECQJ4ULf0+nEOOeDupcmo/Zd8i4iHZNKkEJ3Nc5sTYynxzRVBIkTMmTijgc5Vbf40kT2ATRB54LSIycYQOSnGvqkLq2yaRj6XSGLPviRgrpd0PCa8V3OZsHCI2iZMs5bsqLvauQbv2itvcha1vpGBepraC+y913/j/CwjS5HFWPofBlr/CuNKE6AVP/uu7B0lzh7NIYkxlmwv15QtfRYQmBqpVIzH7E25mlvnJrFaUDKF9xLJVYoikGz1181/mi0dyg8D3S/gNJyMocJFTU6dmDHVeFjDHpUaayScztKk03iV9TX45Ks8LNqxqiGRqLNg4k8iQdh35LczIULYskSHnAhkyg4uxQmQ/VMZGJ3GDRMMiBjDajr/7Ye0jVN8AjV2SkDA6iu7LJUhRwfXGip6TnsVa4lTYJ+m3hAyV/s77zbl61WIpUsQUTdFVFyA+VyUK9Yz3HYGmGNQYZtp+JYpMKTK2QPVKJ7mxLbwGzSLIKR8l6xRpuEqk6NCKUgkpkmLBFfdQjEXc6RKTC9LfV50UXbGnKCKQIQ/DXoYVyREwithxzhDTyjg9ovQP18mVJSjjGh0Hfki8EiL983UzMwqLyZ5LvzxShgS/X4R6IhniLnIVhlZp7BAOfBdnfFNki2PJF37pS7GUaJWSoRLDFj8b/DqgrH2i0QZM6eBj0w4bPQ+OxaOExAQdSrO9T6YQXOeGmGabKD5AzwfvfwhkK5IpM7ioHqE1vcwQDXec4hucnnABpwmPnaIy+2107kKbM0mRsj9XJ3A5rOVUUCZjrHimRm2Uvv4UhUWfkCokRcL+aqKHJTBawDgWVVK0XwA5PCdYHcqsP7Srzl1tMxNSozo2/U9Dzbch1JtwsksIQK2KlehjyrgWR0nmuX2dYMMMjhx70XpAU6Gd79p76MAIqeX9BLhkp1VkTj44+PiuESm6soRI/IikbsxKJagofXZoj83ATFWGStqQ2sNGIJstHb24kcQuuYRp6Ui11KTybExlrJCm2lQrAwUGBDGk0f2iuR/wF3TNeCaQIYC9sWSFugkjMfRTkCJ6NJY55zyHgv20tNlk31xAPQAiReiYsGqjXL/ROdPIkHJPUdVNHv8gkIZhjX7HKbetvB+PIcqBZJwj5ZyLlR7npSaLWIoU5e5vjQxpsVhqjBY+r/I9oqpBJVBJTixm1RWAsqQSNahVipR3CPCFjJVFiKVvlxojiKGRodo41KUM42wdo5+rpTFHxbqkjHiLQbi2yXWKpl5/7RwvSHyqlUABVcpNSfxOiWuir1faV851z5fnTKBdEIxb4qotjBc85W/QDambtMRwyBm00iKWof0rwhmHIY6l79Wxu2EIx+tQ9h5c1qB+mJyQQnU0PrQdxzhIRIEnHNDKNRipFpUzfyVkSHGXI+m1PRT/emJ4aeQGQzBuTY9igvjsq6+jrSh/EZDODd4+Mi6E+4XfO7l+yLlH2zXjDRQyxPqlBCH2GwiLBRiCOhWTKQxHiPSs8ThlMoYzA1qUjdieo+1bVN74bApxX+McAHKZw23SlMhuvA2A7Ss/86pLXtE6MvL1DAqXczoxqXkNL2njaf3WvLPQeNSFW0ugEVcPi/oqPV/SxGAK6L4g98IW3bSI7JjNFm3396wrI0S5785S6jjuB7UZxsVJQ0miBPI+Uly0a4ldbpwYtUTnUHaONg7lHMZzLt8HtS5wB1WYAObZn6nkHX6zth4kqZQ5Fi01ec2aYak+S5Undoz/+e0vLdvvAnFFrP2IFzzlbxTNkIh/+138B5YrKLGCbPRqLmx834soE6XDUD/R4O5mWdY4u4sj2u+DVRBVEVsa0iy7dr6NBZLQAcf5SGMsKhe6GuTIEFGO0KwKd9nCZZxdSeoHY8aTR0mVoorwcy+5AWqYc1/UXi8rHIsxZVkPUXvEDXEPTTEC0JUhEickkSG2r6RiuM6A2dt7OJnC0BmaUS4QLFmB0QgNKSvr0ajqEemAE1PUpnS9BsUQx3W0bRkyxMvaWlxFsOj/kjII2/lvc97p+J6USHzqHvcTWtYSt0ARQ0EZo+CaAHAVLr6jyWTDar8dpdM2PZrEw0kVhiEe15xJuKVcgObEEpUQiTkqjEaahHGOMuVd1mRuyfEq318xyQJzoTtoJrgSLxQcYrAUlHtc1Stq4+Yqlp2pbie5j97mSPi4ArhSCtELnvpV8g+FN17RC6yErdfue1EovVS1L2AnzYpVfpw0qAaUcr4zC62l+zqgKpSo77RsSxpZqUz5TLMy+dl9dJ7w7CyeweUzQCWz03gMS683BEDd3qT9aqGcV0cmEASiGMajGOSkj1jUFmPtj727UFSP+uNYF7vMaesJ4Rn3boPUoJxKBABmKxMmLRPdSOnRZv6DEqmQMAxlTSMNi6hBtcATFzX7TEXBAqrq+cTN5BShEhQQvGTsFCbc+H7Zoh+QIkTUIfyO2sbtzrcz53tzaKWILyCrKoE4M97YZVCd7S8JA9DOj3LsrkTFIn0t9NDNsD1EpQhgllqUVYisOez6iJCwS0tixTFZJPaEQnBy52Qp+4r3q+6TP6dXSSm6cgoRAOjMnKFKCdJmxktmUkpm1Uv2TcxwF5dTx0RUDUXtKp05UoNXM+MgY+jivriNTlCCMEpmIlJZBeeQIYD4kuZGu6AAjdbdCO2Xzb6G/SrvL6J+rKhKSMbG++Fl7Z4sqVNQFhdcnZtgQRgLTxtN0mz7OjPJEBkrapek2fbb1nQxVq/YOAtEJZKyzhkX2zQ92o5SbpveoVTcLqo7PF2zP1XMwCAKWVFMIKqeU4lqyZCm2Ey5H0ruaz5eqVyyb0m/2DCW1hyzVFnUyqK6BVD3BZdsIf4M+fZWdvzd8BMAnQG3jgt4hzJAXPDbOXBYNfLvAeT67ZaKX1nCkE25o/HvZc7AVb6vzrl8XIk2U59TilLfvalJnC4apYknQjF93Yvd5S4q2UAt+PnIrccFkFd8SpdWyY5Naz9xLiXPr0tMViHhyozmBU/9qiIJL2TcQGRIRMnM+xKqUMlHVavX2bqyFpjL+1oiAUQKomFtadmiLHZe7l6tYqIHdRX5glTgGrli98skMiS1pRn7khudMI5Q39eZE/isBWpPQckzUkPKUdlZIwdWF51XW1dW1tA5BBkyLrZrHE6zjQ3LuBtNlBDLg1pHGXPBN3tEhvx2dbYVxZlp5BJPBNSQIoYi17gS5XRquZZEJY6FoOS+xW5mmDzgRAVruQ5xS8Pnp1POYQ4D5I+Lt6ckW9DGjCdonJYcYo6rnITSYPGp4BOJJTaF9s1R+8h8Q7gbWTf+xmZJUao8FyUEN+elkCJFBS50k93pFrx3ZqWzztWvIUW8TPrJqE2lkL7n/j0qLevCCZk1umfYJeBKEKJAhjIodonLvvBnqELa7GHth7TGV1UaAx+Pto3/C23LL+7kmgDajEJJVpwu8aLT+qtofxIZAhi/lP158j7v/CF3u5l5QoakfmrJxlys4oxt+FAaQzI+jUhKyiiU7pkUJKLIY1G07HGKsVxUTi0oioz9EFPDDKdaZchZEwjt0NmdarM3Es0QEyjs1iTyOzmRAJFYJAugrTlUEksEPVJ92DpGlIDQYxGzI/JYIWJAoaYL7w01JTZXg/z/c56LWuKj3fu5eujYiu5ThSwlZ+0rxlGVGlwiwavYn+ssW3+LKVer+A5RSZFXigCiUuSPC/zuC77/QvsT2yyNIyohRSUoMWw15CYQ0Ttu1sKbh8KcKI0CtShJiqYkA5iAonN+URn+SmKFcmnrp563ErJ1hUjRlSBE+OH14OVZShDpSznkEmNWK3foRYTLoU9WzhEgo9y0Fn0Mcbn0WOZAU26kZA/ACBD6IBqrbJcUIzzzhftVziFXD5MkMLSpnKsCJaP2PBfFXqg74/tNNrSI6xxzS3SYMHnDxybKuTFohMYq57tk30oClCRDUl/suLSkCZoaIyVTcCg2aFDKdMwF/Vi5vrpeUgE0UrQbR/56aMZ3dbpq6fU7591bdE/WKY7F+2gpv5UU1SUqkNpOUbwjpCERUN4nGtewtiFrIgDAcNRly2pWx5L7ZE6s6hIoNfpKjkvZPksx0J5h7ducInYXCelalsRhaaglRZUKSMoOzZW1dlTMIUW1JKVk8rlkXzKGgnZKXBSviNvipSdVeMF7/c3dQLyBUZAeepKRX0KEavs4xEXE/dYGlJaksNaCLaXECr59f5xSau3R8CvJmNYvRm2/qb4PnUgBk1ppP2OiYTLjXKkpkvuEUVGZ8neUlCE3vBIypCWaKHretO0KGdK28/580aEyhkHZ4VbYQIzlHpdxMgWyFpE8fKwGWRSH3p3HH+yZk7ejgHacWIGrRKFOKrFCyf2lZrVTgrslg30A1ThX319SuQDVhK0U2r04p785absLkjfQ2CPh2TBI/RkcudfNEBddNf0Q49e2+B5FCRXubmL5PJYBld0Wp+RGiQvmmCRzEizUpLUO9ZRnQ7oPrAXVO0JweSPtFKV3zydeOJi5V5Jee0Y7RbaBprT5c+uGIhKRW7akdjmTJApcLItStc+xRWvX/sJIHXsuCYOwtMZ/fuu/yo/lgLhUhegF7/U3R+rPYmSoxE+2lgxNcWcrLXM1A/+eq+MVkwKXJFUxEa5BWB0Z9wMAprO0ji9jN4+u011BJJTcA6UkrIQMlUAjNdp5xpDcUnjdDEEZuRgRYoHalTLb8fuB7y/dU+zceaMHu1alygFzyBAx2pSycg+XkKHxOQWljPfx44/pvXeptXflAZXdCsD67STlNoQyHoMzJi7O6mJs0c7lbv9c9VGJItuHmFgh5TKHwdU2VU3TFmLNoDpWSJtwKJm4KBgDgUX/p8q5ep3yzChubqXPD1nPTEtmsC87Y2jabsWtUQS7B0JZUbMAAAasHB0rStcRcpM7vqIuc26IhjMvK+2o4+TGO772WvdS7JRmOKa+4VJfBcbylXOfK0SRTaDFqfDf+X5KP3PUoUkoybhXi5J3Z23IhtpX4sWDvX58dcGO9ALJZeFSCVEV+UkZuhglGdVKyAdp09ALKvpgKh/J0rKE2pt5QagysBILZIhRLn8ARVKEzoOx9AGJ+ynnnNdL3R/SfZB60QjtqjE4tSiJPZ3zoi29JwrOnRbkrwb/L0GGNEMU78uMwFIyRKCdJsGQpecqFokbm1ImSRMEwjmqQ8pyvzx+KO6gk6GpUMkJO67qWCErP0vZ9XZSY82NoYRwl9ZLGax7ECKxzrucDYhUDIRgFCRdyJEi/N5xTnWV4+84EoPoMyquI/lz6y5mUTxahXvQHa+CYedWXUy9bW1QhIwxy6lDHiXvP+Kelw9OL47FKSHsWkIJrR3VqB+7QWvJBw4aV3RgdcijihTx8nUBTnQzDPH5KclQyFEw6SneNyl7V33nMTKqZEKUruHBCOYEXNod88Knf3W6QuWsIACUKQAl5IO0mahfQmjmkKTcTSwZ5bXKlWTs+Hb3/4y14d+o366LBAiXNWJKXt4KYSXDphkFxVTrc8gJPm4A9eEXg88L9y3qVyMJwIw8KYuaBRLoPFoLqRN+S91rJXWksmo4m7xixg1NrX3hmVPJkIFgcCTJELvfw77CseD7gMQJqfFDsRmV3JCMcGg7dpXCLmy9C6qSGZyeTc+g/9FmbeFNZ9j+mgqpEY2cmoKuH1loNJFiOo5NJly8TMZVoujwd5SmameSHTiL3CqZ8kYW+8VlJdZoUMp0IdT8ZID6dXdudz0H2CXQ6Gx8TtD4fAxRuAYrpGgZI8cXOReUItM7gKP1vjzERAvDEL4TrmduTLn3Zsm7XiMZtckLhHay6aw1pFyg/LhSRK4k46r6LTqwWlRy/BjI0CflAqhkLjFpKtZV2j44Kr1l1NTbc93lptjXU+uPdk/vn+UGB8SlEKLFydCcrHFaH2SmhY1HMwy1vnJkpoT8lIx5LvDHXnM5xOrPaqWU5RSstIzqa657ykekOk4J4OIyunBo6Y+16gpJcJpxqhlM/HnQrkNl4oMqYg2gE8wUGapoP0mGAPYZs/w9bQg5IIkkCGGQx0PdwXAdEOsUKUYFypBTzg/pSyNFCgnjiTOI4V1CiiRizsvEaFeSCGj3r5awQFH86H0Qi5p7HiEmzD1MVEt4GV8fjcys5T5KkhP0x0odkpihkhThR0gi4QOanWbACw6TSQEl6QJ2n/OkCABI9jl9iYWCd/pFGK9q19q5zpeTWVzFzhTyU3LuZiQWmI2SpAlauQBFatEc968S8Gtcci+ktpVicFCyOG8WtTYr3zcVI5Q531eVFF0KIRrNyAoztMWYowp58IdXMuK0GyZFZkrGM4epL4nKF7vqFqetLzRHPZlTZ8r+h74+yi1bFEuDUXqOCghK9f2dmgyQ+iJkhRnQvB3lneDVAGcMnYVHHyNnKBkajWXfXpzpRvVRmR9L6MtBVGf66HZkehrzE+N8IqExzpGU276voTOAY428MjSsUJwSXuh1ZWMdfIycFInXBwgh3CkbZnS+kqQIT5po9wNSGV24NviaoXZL7ius+PDnwQp1Rscd2yTXni2ESv4W7otRORwPci0z2NUS4r1nUftaLNFILYvXxl+nYWXFezxJisj7ZPeHcS6QVuMQsXOOEB3ctrO7mLdhtfsHZpdcZDiyu/2Ouh0x6h0MR6ud29+2B7degVuvdu5xq273r++jC7aWYU67H6S/w/EJ22vVIa2d0LXWd8YQTkFZR0yF6iqmve8vx9w7FK4cKeJ/z7kXGEQinSJFU22Vku89AIxc5PjYfLlWkZzKAxbChWeZe+Ezvma5xlKSo+Cio6LEYNTqp/rVyiWQ9k1tx78BJNwGMm1pZWvjLI61cTtyt4DO5tvhY/NtGhN9yXFfqXFOQUoRscLDT4wb/lLIvGxZ3ahUsDrI4M9OUaAMXSRLGDpfRosp4X+n7hE/1tJyWIkeldkq75qigdtxyFjz9Q2OdxjQvrz9UAdlyHJArs0odXXu2HC7AMiIjQaks7HOzlCM+wUCZIEY4jiznZ+hN70LZbuFECdkNw6MfzS2Lmw3Wxdm+s3gYowIm/33x2wGdowY2AZFmQrJPtuB3Hvh+gxDvG7DENdl6tF16KPxDcMQM5ahxBC8HPodBvna9E4mQPi+cKhNx+6Rbnyv8b9Nj8aqlVEf5H5zjh7nKo47nKPtoJbDAsDbmDDD9C7cOzjDG7lm/L0gnRcA4mYblC0TladIwOL5i6Q/9mF7F+4fe97H+/OsB+Njhc62MW5os43ZMLfbGBvBY4lq3vH8fi7JPubrlBjKiVn4UhNKdfXSDMrwDbJxu5CZa7S972ObQ0/reKBzvYgJyBUeqc0DeWn48Rtjqo4F1y8y1rkNdAjwcUjqYoE7pG6j2vg8aGV1bKy+hCmTCAm77qff/JL0mBbG9Zsy4L7eGClGKwHX4S5y0r4l20sZdg61Y5iCkrFqvvQ4NoXHqUy+Bgtd1ylYKnZIgb4AKG4n28zFPLHacWplolLIs2JZMgRA13hRCInuAoXqr+SPhEqGEmWJDPE+cB2cWrsoOYJTyngBVmwnWq0snyO6ppGiAAHQ81QSt1Kyvg4uExcwnDhASTqgLfipuItqs7GaOxu9flwNqTs2td21cr5L1iwiZeV+VI5BVYq0d1AiRTt2reOLtXoMuHwkX3OSdW6tuFoTN7DKd/ycb0Jp2uFDxJ6U9I0NVe1bQ+4v/Lx02ToHiZ25wFl+Nba4ct8i1MZLzcXcxAoSeBY+Te3J7bskLvB+SeFCCdFsdSh1I855gfKXjHTTcYMJG+gZFKddFcpqH7kx5pIrlJChDs1McQKESUyOPBlDy1pqaDJ+oR2tXANNeRpQGW030na8L4D8UWP3C4kfGlAdn5HJGDn7XIIMFi9MmiNy+GOvffi1OgWEkQTKa2SIE0NcX7jXeBB7aMfScqhj2XlgwftSmZ5HiCm3V/G+cF0kL8PagO3jvtGtzQRD07FbNvyNXfEGoO53a7+9QN2TFBNWThLDexUJglhS1rMu7rehhARDZ4u+Ad4d0lkTyVWHysYk4p2Ea8+fyXA/W3Rv2/AeGlYWhpWNGeRYm5Rs+vvVBTJrtkNMsLDpQ/yQ2fYxjrHvY6zo4OoMMm6c+eNLrcfjf+PPT2kchvKezBnkSfcuKakCeVdR8pJNMsTbkkiRG+rcmaRECPhvCUoa6YtA7hxVk8BDKkI5W1JLrACQv3dIX4XHkEtfrmGqOpTAoh5lBbgeClHK+C1VIbT6Ba5OqjqBjDOPkUFW8NFUP6Ya5s4SzJn1VxckVcozVJVD+eMS1L4Ya0gR72pq2sxEmRIJxSBKtVVp+BWpQdo4NDJUFJRfMOuvBr3jslXVHTr7TsmQWEbgREeso+1rlDI5hrh9UGbnyZhVFU5/P4WkE7A/xyiuJdZBEyCdif3gMpsACa6FXXTNcl28Dm5lY/xNF8vDCmc4s/J7mE+8SPeVLYjv8cdfS4SUbHIk2cBavl9xNkK8yC9Z8FdLWqAkbNBIkaa+au8C/h0qUkq1/QveYzRRjp1eLsGcxVsB1Huheq2a3KQlADk2bZkLtUzez4pSVEOKAMbE5rKSFRXgQtYOWgq1Y+KkqDb+DEO6H7CbJi5r9ZfGRapwCBcWQzSZ6c1VhXwdzSeZX9ASsoBQRGByY/Pjk6poN3rqsh16IS/FwFKblGKGAOg4e+TrrsUMpDLXhFnGzAtaImsGGUKMAMvr0BSQixSBsWi7J9V4O99fgosxI0aZiSOxBH4fqayB+6tr14TEa+CPMIz3ZWV1YVBN0bDsXIrbUf3UOkQaVNKDDFhkkPbHcXt/hOug7Wt8bLjRWLRbHJcBQWGym+i6ZM9RvMZmQPWRi92AY2Bo4odwTXpHzg2JU0HxO6YfQlt2O8S2toMa+4NjiPx5MihmZxe/I+zLx4rGQ8bgt+P4KFb2xIPH95B+hTgm8Xgy5V0MnX93oT6cCyrPaBz42dDeodhtEntN4XghdM+YTfStxDFF6rpnmJyRbHf0m9ujv8l5wvfueeyku7uN5cfOY/3bZ7F8N26HzSa2388wsN0Q32splUjDnG+50q5zrowQ4fWCJEJkmQKkvYv992QYQn1yTnFMUS/HF41Mwimk5xAxRNVJKmb0d5mTrso4VAWwNI4oF/eDv/dzygKqFSJmz11ULNHF0bApLk5TVKFKQlO7b7WaUzueQ81eFBn0eZVHS0M7+1yHGV9KSFS3O1yHZ7yrcbFLjXsKgaipX3sPK9BmfMdr71ReI+3lqsVrqOl+C9SjAsKkKkCVs9ejeiM3u70hYVAZk6GVCdfXdZHIOGvAbmM7PvZnQO5zI7KF/qbHgbcrdbBBS1SjvFLhWBYx7TctjXTJgqMkdTSuo6WUxjEnBamstfV6yLFo6/4o52XUB25LWXdKi/fRz51+j0oZ8MDGBVHBxHb5WkDq4qo4s5+vjlzmdoOihBpjNLHi+8D3Lj4fyphIym2c+r/LqxfVs9K15EZVa6z+dyq7lq9SQ4Z2O4jbSTsFS18YXNaUIrJuoJHPwVRScRVUmNrMuVeFBCkoWtBXQ8G9uliZdz2VDPnyBapFF6IQvfCZXxf/KHnAUkRIQ+0NWCnpVytBXP3JKVUcTvlATVGJ5pBB3GSJn6oyhqJjqM2SV7I9BS1duEIAiwKUyUtCcVOxid80kqCeJ1QdP1vMiDEl51xDyb3Bjy+UE+cg07625oy6no6qPCnjLAXaRVuMFc+iY5UIlzGxIXBsth3N+nfnqHyGFKQNerZwtrGC1+vIddMpv/Xa86s1jKqUXBetGSVLYu0Y1Pc3JpuF94Pm7lpyX9L7WB7fSH3CzeLrwxbo9cBqIVGKtPcu6psksFDc9Xb15O8yVie7s9h391hUfuxtpBTdiUoRnCN1aBuVpSJoKhC5h5UsaxilZEhDLotdqj/eRycTLkJqSpJPKOegRC2idWaqOkvFEV2SC9UkLEmGlONWCbJq1yqE6AIwixAh/PQffO9CI9Jx8LuMkKESXCcyxJUKXJbGl1I5DjGjkupDmfHXZ+ELiEGiHHz4kT+/uo8xNPGCH4dF2/mx8fMqnU++T0gpbkAkCaYwqYIHv69wwgQPlCQAKxCjtUIqoRIejoXIEFFPeNKEcEwFZKg0UYL/EymIDif3QGNwq1ifKD6+Hd9WQdlZIGMKAebWoOBzmmTBG4i4DIaSFW1hV0JOBrmskgGidAEp4/TfXk0K6xCF2B9ACgUKmh89v/G64xifUGdtA7F3axuI47BGyQT4mj94nRuf9rmTx7B73tE7AZele2mF7o0u3g9ScgMxsQ06L/63bBldU32h37iZxBOtaJvhehn2G1YFNaVI+tbhMeCECp0JJHjodmtdhbWvOjNSjgB2ZC0QuS1yEdwMQf0zmz6OabMF59WhYYhK0TCE+JdJiQO8wccn1UoMwbkxRSUpiDUFhtcP355KMqR9D9k+olqEz9PAXPzmEBH+fZna1nUiQ3PBvVoEjJ4BySW0kgyVPHM15cnJKxKo5hITcPF3WkquzKVcrvlN7V828CaRoVy5tn7JGFJ9aS8yXvZGw6oLv7lVRwObrRlth66jDys2fHNlfhwatA9e5XVLtqv1UYJaQoGhPW3a9oL2eWpcbR9XQuhGjSv3Iy6XpMROkSFfp8QFDm8nrkyKi5OSfGC3j6kra8pdAQxRORDBwkazBYiLs6IMdStUXptYh7tsheeVr33E+ghl/u5AvynXnQT14yQAx4o7HCr3xzZbJskEyHbZxU5NU624DGrKUJU7JSJMg0QSFQLjMKkyzDVOuF67NaxkkqSRIuq2Jp8n7ZkrVVG1NPF0bTl1dzQm7PaFDHYlZkINik+pLdL2UlKUUoek75KWjpgTIW28ynaVDGneDbi8kl3rVBc6zUVvSUJyKLe0pcpLjklDiZte7XkqjZPLoOSZK01WkSRD2m+XTH4vr/eSm2IuEfIvI/wPgxuIqN1RBqbavvmMzSHBx6S9zIghKxsQRaQKH5dWltrj/ft9PBn2//B237eWtltSj3w9vA/ejscpzqjoxlIVNCJQsj0MwKlERnQtMoa60e0Jk+GumiX3pNBvidubs7ZSPULddBakuB01a5wSO0P3BVJfVCaUMn9vhNlwF4/fbnFigEi+8PpBQUGy1JAMx+7iOI1zcT0jRxMyDDhpAzK2ieqDsrppx0eMar4/VoxWcZ8AdR2d2EaIc8EEwcb4md0CtrEclaZI6AacqnodM84RpUm5RyQCTxShzgBRARlxDH8bIH2RfvH+vtzF+wVnxiOL9HZAFStFlQI0Bg5OinBK+LB93YljwYQMtIQYiTgio9hb9DlD94UQR2T6IRr4uLwfX/hfKkOCFGkppj1q3dg0G4KXpX1TWGItl5LJwxJSpKwFNZsUpYze0vZytuEMG+RgpKgEkm1VcE6KEytgu8ENwNOsq23e4zgoIXrhs/6W0utMMqRBeyloqH0gSh8s6bfa+qysqkT8/GkB7yS4uBPLmsyuzkZp57tWhUu56Ukuhtaij5GNL31jdmX/tzUseFc5jpL7YE7cUwlqCcqgbMeEaRQrMkPd4kiQoVAuUY+0pAlKWQtyH5QEA06ZWd+NVX6+itJgY0VHcZnbbYAsRkpROA5UJimaUXmtlJU0zkSFObIs9gnVU1NCKwkRjuRrRNph6p2oqiBCB6CTX6e0W5QcQlEBh7XRz2dBogX1WDV1Rzu2gvKoP/WcKc8jfkcrMUocRYsIJ5IzxB+U9y3+5mhlTIrIt26GcTtn0kvs3+bL2r6I0BWpQ4rSppcVUqT0NSJFtcQoNYF86OQGF6kazT3OKcdca29UJ2K4YCJZwAVUTrEQDppU4YXP+lv1htdcIpRJ/ye2V0tCpjwsORQY3OoHJtUsOgaS+palSy46vtoPR20yiJLU41r9lPGvIXXMgkqh1RmVCcHDHxqZOEBXeX9oiRQ09YjvP8ddLrG+0ZyU22oKbcVlTg1gx8PTtvMxYWjnhhxn3Kwa0EwRiCqAMBbfBU6tjBMrbOTtJLFCScIBDO4hNMj3DlEDtHbxtVASCGjuWaaPCoXtx+mvxTHNSPBQfH/gpqpJLb6XcR35HKj94vTpyrkAYPcETrCBU3Ir6ayJ66Dierr7TX4m8bi01Nv2TryBzR2UXAElVIAtklNTyysIcANTgLAihI9bU4pK3NhKUfuNnkOGtEk9Mh7lXLAEFiShBa6Hky3MTZCwlKl5aEWjZKkPjqR9ugzBU5WcGUkVihIeaEnBuN045fqWqJBsjD/9xn9R308hDqYQTWJyJRdHkq4xci+xlMSKjOBZZEirr0nuuJ4xVBVBZRLYzNwsRLcOHHRubVSDrI0PEe6js7o7WqXqQ5BSt6RjZdulRRtJcgZ+zqS/pXJu3MCNr4IHXjtWjQyVPIGVZAgGGMcB5F7weBV3Xg+7y4X00YYcX1nKbYUMTdge3aCM6q4U3K2wW9JemRDjNgzIz5FFfWAD18bU2rgMUE8kyGY2Ez/gRVmZorE7JuaKtqbHOipjtzgAAAvU3Q0lNRiQy1ysg84ZcncbVvE84XPu+winw+JjkBUqLd7JdWh8Vjk+1De+P6hrHnO701R7o7xbrVHvr+BKhxI4kMQgAEBTqctlnlwBnwOMGqWIJENh36bwrrNA1joCIxNSQoY2Qzg+uxlCf2bTRze8TU/VihLjXlOQlFij3QY86ecvBjPgc+5u/D2ufUc4cvZHynYpQel32P+NU2tj74nVSk3TXa0WlSpHc4hMyb4l8ekl4068C7K2RGpMCkbJQmqxUPyQel/zZ1AKRcB/8+cl1Z9HhafYIVWigxGigNILXUqGMGpfKFNUoRpjmryIrD52bdyV40sGA2tZ4Upk9ZRrGSJYajn0i17+jJypmepKYp5KyWrBx7SEGBWTIju+VwxetBEU4lCaFa6QDFWDBETXK0nhmCzIZAgblUYhPWg7CUAHnSQR1zgl45bmosR/K3JlUox0qnjE32wf99kpIfuyQ/tgI9lGMoQz2qWADejtCSIXuEwSFBhSpu53uJ5MVDT3u5QyFM6nBUrKGEkF8HFDgMomjK2ELKvjVlzeeCyO5qKm3SsaadGTVAC4lW8/Xr9RGamLUvtJUkTco0veoSDCDE5X6bbKiwYft7IGFKw6MF4Rsja+Z7RvDTfwBYN2kkFZSoYwaicAS/oGKFOHJFdwY+JEJy4DUHd4qR2AeaQIoN7ta8p10oioFoejEZ45rmu1k8ATkLqHs+tZpUhRiTqklWuTPqSel2uAg7jMjRhcSlqbQoRKgWfFp5ChVDklHc7xSS5dr0frm7vC4TJaKT6U+yGWS6VRbTtG7XpBeBy4vO3jMQxDLPdxu9n2cUbSf2j9uPA+wzD5mEbJFTRShT9Iqaxr+H0iPRvG6GQoBEu6fB3eLt8uzSgljlU9JmU7ADOQ/XVyTif3vq0BGXQO9eHQ9sGF7cahhAYOERgHiHzS/vD6L35ccVAggiZ4wMdpolFrTYgBcoQIoPOBTzP24EFKk93GNWm6DaByJFh268Jx2208H3bjgqG82y73BwBiAghejyhX24EE4IfzPjh0beJ1MkMci+njeTPbaPSbPp4T0ztUjsdt+3g+8LGanpZJvBh+x+NzXviaNgMitkoZ358G3ZO7ezUeRzgHzon3oO4mh8eTcJ9DbpRY5cHucym30HBvW0rkRkQxqEkmtG2cA7NfD8k4AHvuVyYewtpIZjsE9ziz7eNYuGuX9h3CQH9Tly+8vo7iMjc69kJCJEEbI3bf5678uH4NGQJg713lO4RgtHWFsJsiOn/V7nMc/JsrIWVfaDh0BrKScddAGe+iSQxypN6YekJE2hdsL4xDnrPMeTqE69zh7rCSk70kGdKUGvybth0qyRAva4kGatvRoB2bMePZDXUmqKBcMmtCzhkz8oVy0cyDtchVD5WNiaubd5audI7KjpX536GszZ7NuR4YnXw+RsTB/8nvRzVZA+p67vxF7cu44LrqxE8mQwCQJ0PAZ7eV7VoyBeKGRNuhahI+JrSPMj46Sw+UWOD9CwxvNZkCus1xhrn+KG7fHhtUltWg7QnaF9UfpSBnxxRc7ixXTNAYseqkJnPAY9dVKrkdZTs+H/i4FWVoNH4bt5eq7VRFAnm7lvRCWaRXVZxUFUweGyXzbByVqnoyjgqTMBLHlo9Z0hbapS6VmAgo5cT3myRYqI0DKiFDPK22sUo9xXZR3cYVMjQF6vtZ+ZZrChIpK0pRZ8l41Yx0mmKDbRfJjpHKCkrTQGdxqOQHh0KJwqnUV8mQdqxdJ99f3DvoUOfnQKrcqJulFaIXvs/fjn/MDrIqPPAppGKPaiLEUeL+VoKSbGUFAd+jMZUcx4TZmpIV3mcZ7yUKU8K9i6hG/TBWeHy9Ap/bonsEky3y0VFUFI0IcWhkaAp5KsmOpxyrmhxCW+NEIUK7dtFvGhlSSYiyHV9e1F0qkB2TEKNNbmm3IVZbTBwLXvgUAGBYx2rU8JXbJSoMVoqwuxJRC+R9abZBvF3ed/c3NnRxKnFXNHU2ysInbFdVGaJE5ZURUI6JAHc7oGs2sGexEHhc2n2lEpcCgqwvyps4Hy6WqYKnkBblfUfGlyLM2ODE14n0FwdpUXIFc4aSKGzQdk3B4KqK9r7HygVWPYZerENQSoY0aKpT6p2utD1LHdIMUfIsKed5o6lDitLW92O7B12bA+bpGqGE9BxsPClF5NDqkEaGRr/h76vi+qgRIoxSpRSjVjFKqUOKffrTv/89dX3khrBoaxyaMqPVnTI7fwgyhFkvJ2g4IFIyshOzWNVl3od0PjtL6/FYHeMNNbS+i6GBtd7YHZUVdUBfaFMuq8HdfBzSmKylZf9QWxs/FB0rdxbc8TrUwyqRrnbly7sNyKXNo7Nh+4g4+O0aGZL+BtgRm/37pHTxVQL2ZI/UHR7rhf/n/Zi4zglYoMeKkyyE5AuoCTLDC7PIkBpkbmO7WiA7jsvwf+M4HjGWwyrbGZmhzwbrw48dkyS8v4V4rXB/BilFJh77LukBIl8oHsWXhw5IMoSw3g9OkrDfV0vYoMUdaddjWEd3QRz7M1rvB5ctKqNzPqD3QzwOWbkaq1gF946i+PhrHLbh+9XE9nbJGXxbsf6wVpI5kJggJUmDEe5P6ZgKlKLd2kL7YTsHUoY4rN5SsmZGcYiBRLlYJmQMK0PbQV+4ucDrYKQU4W+e5B7G3MIDqXDI7W5wMqmZ4yYntUG2s/Yke6LrQr+LkSHeF95H8wbBC+MqaxKRhEtdByPFTFAfcLKA2sQBqX1rSQXfNze+4rFy5Qv/nRnHuC0jl7U6Je1w4i2R1qXIkFRvKWXtgtQhgEMTIoB6EpBqhxOCQ5EhcTszgDPti+OFvREplAkJ8yQndzx85l15SWprw5SW8SKb4WOHXb+YUUfcUrR2C8gWGTdWWvAq7Iob3ejv9SqeEyT/us7KBoqlLjUEyjVQVZSSex1vT6lCEhniBBWff0w08T3GMSfuDSFJhvx2fm4ryNAo4QIj3mI72Ohna81o7nMlZdKPi0RnF0Piy4gMoToAoE8g4FsBuclhlyvsAodd42jZitv5ekzDKp5HmshAITmWLqpKzo+QBc/3IdZR6lNXQXzc+rtMzagXSABd+FQiuwH4fsUujJpL4LER6/SKy5w+ARP7xqRdJUWEaBtq9OB7SiOE2mOfUA9L0p47Y0LckOtiGayNaoO1sS3+DZ6TalrDlMVQS/ZJkSJyXLJbWlGK7VqDUpngHZEi/z1hpCgQI5ylDkCwOfLHpLrWFR2GIeUi0iJ8y1KkapbLHb8uUwx/aZKdT4Zr24sIOapzKCVPs83xs1ya5OICCRDHoi5zL3yfvx0vVsrtC8/ulNzUU05KCRHi9aRZ81QwpHYcyng1N7Oi2f9+oGOS1hPa/+0Nc+NQcO8A0eiaUwaovx7auepdNIZTZWEcpsfBx3g20Msq2KIpcLMrVWAEkrt7Se0G5oyRs8pZyJ8358pc5KTxAIwDHPFv6DwSn36eaEJqG5EqfBzO2nhtDCU5KTIUkHLNyShDJGkC3xeRkWA8Omo88mQKKrTTzgPnibITjW5C5FCdMEZ0HCRgfwvh3NpN3G639Li1pAeaC5rdxL59AD5OwiD1oyVqwOeAJlYARgjR8ZW4quHx4nHgNYtwwoiNU5M0kPJqvB0cxPvTd2uEesAnNtB25T40vQskDyd6sH08J+NMhL4OJiBA2oxldG2HeP15BjirreGkLcI6mulFx2eiWuyMUTPPBbc552JChd7F93M/hOusrZHk9xfL3P3Lt+scOP+bi33Q9/4A1a5y3HVPs3M0F7pEjAcxvCVChL4vAOzdmpvA5d877Zxj97gtdkHMuND5fvo+HiN2qVPOlXMuHLdWHh1H7aTdnBTUCKmxppA9plKkjl0iRNYU3ccG2zLhd9ZeLTmR3PQl+4LbKrWECN0XS7rNLasQFTFapaxJhociQ5zFkpcPfkEVXCjNDUspF2H0UUJj3c/mEBcy3w9Zh0JWLGaVC1Q+ouygMY7GS1Kx1pW143RdR/pw6oxE4THVqjvEODrADIh2njvDlDN2X+Df2Plaelz03KIx8HM+yL8VxQxprkNa0HsiTTE1aPUyTXyACRuqx2fspfGSMcZyT5IKoO3HcpmqLrSMY5dwuzzRAlE2iMqhlLU6WuIDZXvq3OJz2CuJGbRxqwkblCQNqYQbJAkCu5YqGUfbtTFuyTmM9VWlrcB9jrsoe+wIt/INTLnxYmiEDC8CiwxssjhsAeniyVaKYjZrlSJtVl3rS1vskv+dmrEvUJdIMoiCpSGqyBAvGxMn7tCafqO2FBc64k7H1jEi5bXidoeNcU1B0hJUjSayC86ztn9lWVO4JPUKK1hSvUmoIUO7DuU6EhnimJIpLmWvl7jGlthGXD2T+l4AyypEz/6/9R81tp46oEOSodB/wcuxpD+mEtUSIDUBAd6utc+fC63v0vSWJahUwciuqWMtUQ8LEgok++SBu7l2SUPsHlHW2lCJnwYyJtSFMo7k9ff7bgdCmkzf0/GTmWNtZlMzHuXjUwmM8mzxtYHU9WU6+XhpvILcjjabXwz8CGIVx+nGKiUCsQ4lT6iMP6A4EJoE18tj0lQiu6H94f0tM1SpCoG3o7Hgx0N7zMk7Cm9XqmtprAHU4ypJCz4X2vER1RF0MqSWK68zJhQ4HTvZTrK7AVIBnHreyDmcki3XyW2RBA4ouQIuk3TP/L2jtKu+m0tSR1cmkCFGfI0yUaJIYKO0xH2IfF/yhIn3oY4PnXejXY+tnJTCcXUJq2KqN4aSLGOK8qMRgVRa9alIJfaYgqUM+BTZ7hSyqBGigsn9Ik+u1Lmp9cAZjUs/bz/9e/9vvb1KLKYQvfDZ//d4Rp30hNidxPQwUu1IdTPlWWQIj0Upp5IRlCQd8Pvx/UfJBdD2gM7QcfGEEH4frM6klI8CtYSMhfnu5+KKyOKM2rGi8uh4MUbkhJ0X/zfvE5+HkO7byLOO/JqH9i25Z6hao5AFEw0tnpKa3ouA9hHOFT7Pq6hu4lk/11kYjmlMVUg0wcY7cocUjtdhRceYSKAshI+oMxBeis6YaKwatMgoJ1jEyFbIF5kR0uqDWB8H8g8duwZoNnroTAzmtyyWDBMzJRZGrwPhGPm+0vV0PCHCOo7PkyysAHE1CJe3p+icKAoVb9vZ2AZJZNDRuCEpXmdYxbWXBpRsgCsqmET2a7k8sPHihBE9Oidy8oi4f2059KkQGlXFQXFY/TreS6MySYIxvrYkUYZJKEWpGCRfLnBJ3b0P43ty9M6WLASFtOwSKuz/SCZXSBhg/m9j4rvMxnKo58eBXce9JwIqk/q471LDVHBvq4ld0X6vJUMACYJYOgblvJckW1BjnqzJn2sAapj7pAyp8eKkDbysQao/BXh/TR3kdixXCnH9rL3LxltS1vq4CDKkHYd0rvy2Aju6mgzt900KMZVYjBA1NDQ0NDQ0NDQ0NDRcNyxHiEoUnRLfv5J2PKvMMU5YQB0K7Vi5nHJj89XwjD5XURCKsq1xdQhDG6MWb6NlvEueT8U9SnFp0mKRijLcMQUpQFPEfB8F7lVkHzITVunGgNOCs/glrg5JZRXKTC+5fsexL6wGDSdxqn04XcFwugpjcUerON51F5WJldXv/RLpHKFkYV7tOvPkBziJwhR1yIMrANgFr9eym7FYE5omOj4fkjpknNNjfLQMdiRuKG4nmeNO5fKwhpA0YFgjRWUdzw8u90eGqGL+uOT+LSqbfB0ldmaXUns/lhLlZkWv7bYks15JHBQ+59g7qqP9j1OD+3flOH25NJaNcq36E7m+NvaRSuT8mExwr3PWxO2dvG+oF9rC3wXlXQ5QbSXQd52JCnIXyyO1QnnXksW0S7O7epQoF6l9SJXC1M8lcSiTMpHt9jGDEqQ+BeQdqnzrEiqRmh2Pn+uw0Lpl9QqUEG3BWA2VMVzF49DGlIovK9nOx6GpYpr6pca7K3XmQlLIAJA9ZmiKdt6/aoPPUfSWO77DKERTB1hKhgp+I8GZ3IDWyBAnBb6tgjIBPqs5adCyf1BY5gGx2hgFckBSaXO3NeVfaAv3Lx0bPr8lhrQVyspdqY4P98fPM/4Nu9CthDFiSGM3hpIhnLxhzYgQj6vxLio4mJW5Y4kvBYVc+v52blV7grOycfu6I+RpWNvg3hSIlEXjNibUV4mohfAR1hJGOOVFWJIoYfc3RLc7Tm68wVdJhngAPF6LRTJ+uYEefsduYqiuNwD7dTxvagwRJlkCYcIpoIcVGgchPMg9bB3/90b0sDYhicCwitt3LnDxeIY1/Tu6bWGjOR5PIFlo/aJhhVzYVnTNo3hs8XcxNXaiLLWHCZ4fR7/GREpvL7SBXSItrZtzB8R9EZc4dJ59soRhFYmuW+mk1UNLQqEl8QjbcfIElkhBIkXiWl1Wee4BxG+acaiMYi3M4MK7CmcA3S3wmzDUUpNefuwFE1aBcPD1h8TvFXLfYgtX8kB5jmpSJNVHS0Co7nJkotNAyBYnEaPaGJcaUmRMTJ6wP4f+XBtjYrpuY3fn1aJjwy7mmitdTXIEyWVNPD5GJKR/+Hdt/9Kx8jFqYypxATwAZrnL5UQMfn9r++YmM3g70j29IAnCWORqvPA5f0f/kRnryXpz6jAyJO7DX8bhxo1GfCp+pXpx0inHpLWFDWeu8iBoaoKaUUjrj/Ud2rLc2M+X9UwjSn8TMDoPJTE9OPOathgemQXLt4nLw8rCUJQZT7lHyVhRu0dIDULHMBzhMjsfawvDsc/2Z3aqkf8NxxaRc6Jcq5IXJirSWCmIweSGlrV9tKD0IjKkqZh8f0RE+OKsJM6FqA7admSM4ixiyvZU5rhAWHisENp/e8PUlU/oeVAVC7J2Eaq/jjEvmCgBsBgmpS01+5q6npI2JnptB0TMNBWoV7LN4e38b00hwwrQ5gY+ptjOcIRJGx0X6QPFe5FzpYxXjWVTJiEwWSWLwBp9H57xLbm4dA244S/FcXK7QSNFyruIGn74W9TJZUaGSJsJQ6+EFKnqUOVaSyO7Rk0uNEM50uwl/E3EGeUAdiSoaF0l7buqqECa+qGVOXEKE+KFxoXmwaSNjxMkTUUqJVVa/yVl9X7XngnlOgOU3Vfqfc/aMgXXMGVPFKpbSQ5SgUWyzBUNpiRrVwpLkyFhe3VqbADdkK9tqzSrGarPSUA1GSu59Er/RW5fAGxtlMJMIx4zk8YY58g1Vdf10bKtaRn+VNKCCAkmSalbFwclKylqtcVOVVKFi+zjaFAWKJwRavdbIvtT2KmA4CkGVskCrABjQ1fcp5YM8Xe+lcu0krIdALR04ho50IxZmmlO6So1Di3LGsuMF8oo+dYo0xzJLie3lcQMG7no2NWsc7wx/Js8+KKMecC/J7HIkz6IZX7PaUoDztKGr88mlrsNzuSm1ZffJaN3AP5NPb/svOHfyFpIOFsZzjCHU2+jbHO98g7mf2sJBLTsaFq2udQaRx5C4gT0h74fGpdmRqltaS5miXTi1S6DmjGpZZvrtWxxaLt0Psm3FGWjK8k4V2uDpKC1VZn9rwjJjGpsnasSzHFrKyBDu2qFhEhsV7lHtfoA+vXAa2oC6OeyMqzmp3/3u+X6FVhGr6tRQrhLU8l+hWQIAL38+cX0F6eEDFmoc1+T+tPGmvqN19HICFZsfMyMpjKkZrtEF4KolpEVrq2J2bmQC1ixdK0dr4ZaMsSvh0UGMfttZJhornTieagjQzv3KnQOFcLO3Rxp5j4T+9iXh+Mu1OmPbSAR/bEN67UMawv9cQf9XhkaOgv9ySqMpUcxSCO/fzxGfJ94l7kOla0BKbvcFDKkutOZaKTVkiHs1ubd4cLfKznTHM5g5uvhcqi3iu5z/Rq1q5GhNQTDeljHMZOsbMi1aqQMJcrBTWsdFaRhFbe7DmA4juX+CLnZdbJrHclot070f0S3+9/6o9h/qiz1oR4T2u73D30zsjkI7nxaxjxfB7sjiu55R/FaDUf0fiT3CVaDjk0c/xE7luM4rlC2SGkyeaXIOEdcMJNuqeF9h94zBj0/hj1XRlGKHFrc2EWDnbjMsYXDkyoTfs9o2T9xLI1vV8k2BwBRreDfJmXm3Chu8yIEpUhbi0YlQ6UwRs4yl7I7fP3B0TJug3x3NE8OZBPw+BD8nTSGuNQZbRI658aYtJMSqoy2f85WSRneJWTTt+W3dZ3eJt8n1X8KlRPuSZIvTX6mjrtUQ9GuaWfLro/WZs32SsxWiF74fl+/Kyy3nFHExINXH2zNL5eToRpMUbhSahB+0aF4DYMNUa1vpuCoM8sFahTef1jZMHvkOjQWG1/SpGwMnTmsVYmmkCEN/JwWqEGqUtOZODaNDK1tJAQrG9vtUN+dAYPWDsEfKXXdIXTv9sddONf9SRdmZvuTLqg+w5GF7iwe37A20N3ZX8OVge72fhbVGLBncUaVzOwqKhFxxbQWEWX6AQwky5hwjZwxgRDQMpCXoLbukO4ehMbHyFDcDmSme1jFdOBDBzFAvQOilqhAQyTB+et4z/dHBpWBlgc/Dlr2680MK6oAqFCUk6GLKoNbAXRncbsv+9/sGa7n9sdhwJ7vy0exPILyCsQkG+8/pezHNDpebf0evOzJKp6HYQXQ7cv9mpbxuR6O4j79UfytP6bKjb4QMKqD798jAHuOyvi83437dnejK6m/Vs4ArNB5wIoQVpCwCqgpRc6aoBA6a8I7xHUmrGvkn6PwrjKQWJgVj6sX61A1Ao3FxDT+ztr43jFGVSeMskaOunZOiYLTdbE/a+Wy9LfwzSZl/zfuR9yeV4DUxeVxvdL1BpVvsRmtMySoRb59X9caqh7hc7/fxxhDFbvadYNSqotvy1gQFSh+PYr6S5zD0nb9M4cmDWcnOeCKkD/erhP7SCpD+B5X+1CIoFYH34f+b83uq70+GU7w07/zXfk2ElhGIQJYjKFl20v0QwLW+cviIsmQ7xv/k/YrUYNKZtdYH3ytm9H6N3bcP1GAsCGjxQsJqgcJysV18eGnZioAlidD/v8wO2GCYiSqQQYlF1ACspNkCADAsLY71Ldvb2XitQkZy+TzOqwi6cCqTn8yLg9rG+KH+mO7C7D38R6nNmST6m+swjnBGepwrNIoWYXf5q9RJpkCDrqGAT1rjpf9CUQGmn83Etc2llUrbEd1UmQIAHysEo6noIkTaH0ttognPPDjJAHyR7GPoNLgso0z/LhMyJWSyICUkZrj453IsXtl4zhu74+BBvkf43ooHofEPcVtvtwfR2WpP44Kx04RMep+teXQ7lHsY1ijMlLCeJmfy34dzxMu+/MqKVGSK2R/HNWk7UmMpeqPgZZ9+ySebP8/Pu8n8f7qT0wgmv1xfEZwJjp/jYxjZExSitB7Biui4X2zskQpo7GocSxqxkukCGmutJJS5NB7Ba+5RzwWPLRFStX4z5gMIAT/W0vK8bvgE80wDwlexn975AzDrkMKC4ujCarCBDIEkDc0NST2S3kyjLO6KseAVTqc8ELLhCZBSn6Qq8vbzdkbmoqRs2dL62oxPyVt8vKIAKPjDfev0cmQOD7hvC5BhqRjqNlXwkSBpAbLESKA5QY2hQxpF4sEbVrxpbyrN+FiV45RracRIG2sPOsMwmgBPCRBElcJ5aOFCdCAjWMSbK+8cBB2rhLouHwxOZui/1SN1HVAD6mWWIFsLyiTc8XS2Yrk0SSuAW5XIUDbG6h8C9VRUvcC7Ayd7ene6DCoDQssyQI6Rs240V6UijucGgvE3kCUPKPtSixHCRkaubshA4+npSbJA46VMklCgOsYtB1dBxZkH/pGi3nicYz6OC0o38iXnY2GuFvtxuXHNqxQeU3HvLkVj2VzXyyf36+UH0D10XZ8TP1J/Fsr831wH3gcZHw3UZkklYjtcLc8THD6Y5Qw4sgQ9zTSDyqfk7HEfjY3lTKqQ877Kl5TZxOpugVStNsfkxVAZSOWAU8AWEqYiEIL9P1G+lnL36giUkS2A2B3dDXRTC0pQgkADC6v17QOJmASIQo7auNSxtLJY6kOMAfQF2adU+bIETBhXGpCCO3ca6SodhFS/7dU1hJpqMY+S/5QkvKaEy+t7dprzcdVuUCtqghp965G7gHovSKFo2RQdA+l+s9t52OcieVc5jwWzI1ftB3YSS9JXblUthyOyracMcRFqiiNN1G3eL0F+yeGaUG7yurlxB0stdL2HDKEz8+U62kMAHb/0NzWcNsacVTW9qAN4b6Bus9hoOPCRLU/Rn3jGXy+fghuCvXR3cW+RQZWd6KPjT1D7i4bxW8MfzQzCuJueyEZUjLC0XKsPyh1NDKE9939Rsuj4HwJmIwphE2LsyFptvEYj4C66GGSV3k7E/dU7OWD3ajYcQ4dQHeu/M7uVXFcWnlJaG5yfUGZGINy8/2xIa5wux3RbpoLnJYgw8plmvAEtbOOLnMA1KURuwviOth9rkPujPhZp4ky5IMfVoa43/FzRBJYoPckTspBkrXgd6lSLjXQiftyrfucliRA+0Z0FtQA71QCiBKo8TQJW0QZZzFRqUHi+JLfbQx8fZTEDcSVriThBUeJjaNeQ6U/noigNktfretfCtzlryQ5Q4l7HKmvtFkyiQxQTODxfVp0D6WesZJ725jLdZmbTYY0iVCqp2AxMiQx/JoXjPbyMvqaP1Kd3XhRA3i9H40MsVmTVJ9i/1wiZ7P8wZWOu8cFtYMbuuO2iPvUBNJsnFOJCiFTfo2GUQPKvcavGzOyaXKD/Q+qimaR65Qla32Q84bcWDC4m4rfp0cJFLanXdi+PbWBFGxPbHSNO8auRDtFxKcOdtZEZShzfwcFTEu0wTPL4SQLwjHxNNve0MLnObYllGeQoWFFnxmS3IBmkR0F1uO1fsRgfBx8jxUgXOYJFyyqg/teOxg6F8puFcvDWigfORiO4vbel1dxu1s56E/8duQG1tHzxX/vj6J60R/H7dsTtP00qhfb06iYbU+j2rE9QduVMv8bq1f9MVKQjlCdo9jHsI51RmVpfSbkjheOHStHx/Ha9CdIRTqJ27enWF2S3eRw/f7EQX8cr5u/Jh5+zDt1CJfjO5sszJtZyNUZvoAsfSfQY4/vOT+R459L0sbeHdd1JiRvccbQlP+ZpQb40haqKoNUdGdMVPCNISqQqBThOp2N5VU3nrGXUjdzJUJTAFLfFeG7PQoon2DzFClFc8DaEQmYPz5ppt8Y1f5S03Pz8y1tZ4a/lMiC1BtdwwIFSts/VeYptnNrG+WQU4FQ/6azkE3iobl6Fo+HndtMQo+RPQnA7B9FWUs9YyVwbsxJKjGLEBHMCVhLvRRKyVCBTDjKnqWVa2daEmSopjzKYqe5yaHN5OYCnZioZbK2DnrQjaluSz3XJUjciSoRwkhN0hhl7HydnxDfY1WFIkmGhO1qGRvrR5YQL6ws4Zgh7Ca3uRnbOsflW3KZ70Nc7pArHnbRAwA2maAYOgVucqqKoLw4x23FOtVkCMf1IEN79zfuj++HjE9siGJ3OFxGLmzYxUlbcwgbxLuMaPFvXMb1+tNY3t6oLN9E7TAi1qP1cvjvm/tj+fyB2Mb5Q7F89sRYvvuEfFkjQgD0HJ2hPs4fRGU8DjS+zX1K+RZ+3mgZ3wMAEDLx8bbP75O30z7juDb3O3G7J0UAu2uL78/NLbQPcb9T7kWFFGnrHYnuo2EsVizv/sb1sIsuendgUrSWy/S9QcmB6r5MVGjZNQ6TIrdGN/LRWqw/IkJ4H20dOv635nakrd+DYQwlECVuQ3j3JUlRwT6azbAbjGynlJKiETHKlElWQKWcdKWTYm94H3jtqIIydF3Z2kMcWr3acZUQHR7/VUvMNXWu0NbbLQLt7Rw7JkY141I7mTcpMMtl7oXP+Tu7AS+ZvaOgDmef8qwMZZ7EQJ/jMoczuCSyucwiBIkbIhiAg4tpTvnMvIOR+iCCEBilf+fi+RrQOJkqE9wqnAO6ZgXOWlbw4tZU7RLXQgB6bQH0Y8T3EMnyhscyxBf5MKDznSBDJS5zSn+mdzE4eXBhBtY45CbnokFkBn2hSg6chWp1B5VvRxeG1d1Ytmd9OM92O4RzZxyM1Rxf5uQ6HBgo9em1UX8jrmbTyRAu83qmdzFIvY917TYSBVweHZeQCGG0HfVvBghqjhlMIECmB3BrCOWQVrmn56Fo3R7sMoc8ieyZCcpT+Nsf71kkcPY8kgN7RsmYuvaOPCyC1W0TiNrqtoF+X+5QefWYIWROdZPbxhNB3AJRne5uPKbuLBIuXLbnlMR255Sk0Vg1rSyfH3tuAgmyGzqWUL5jYFjFc4L3J25yt1EZP8dK9jm7jWO3W/R+6eXybvBAgN+9ZB0r5Jpnz+X1zewGvUc2fXwfb4eYmns70P5JtkDsbuXk7Vuc1a4P7xGz7eP7u+/Ju1wsc6SIRsq1DtsH/p04OCh1NarBbPe5UvclBUXErB/i386BmKEPQM0ESPorOC7nXKg3WgupwOVuVh+8nymL5CpjxOPC/e9/9D9EMsXv7bkT/Sml0I9Ls805SlwyJ1KTOesRzVeILpAMidlPapUhhQxprmXJsZWoPhi2oKy1z92KWLyG5vKWlDVNLIffkGsYWe8IqIFfEodFPqT8NsmdI6yWQSHBTNzNGhnauWJ4NxBLk0ocrZQyno3Eqg9Wg9i5xpIxymJH1kY5QjO0OJkCihnCs8ObG2g7JkZonROfGQ3/TmaYNaVISRgxaMqQQoZI5kFNPWK/gWJ8zlKGjug9MKwNITSa0qMlMeAZw0J2sKNogOJ1hvpjalRj1Wc4xmVUhykJcezIiFg7cPu/3Rq5z2GXuY4qPphoAABssSqhKBxYndnejO5etDxAf3OfAv7WAP2taPjg8tlTogF79mRUflIs330S2hcrZMcujL8/iscyHMXt2GVud0yxfK6UsQoGAHD+QCz3py5co/4GKp/Gc8yVHkyKN/fFY1HPNaqDtzubSJhRohRVlocVchHdZ93zapOz0c3QdVFddYbHNeL3oKwgOSVhz87daj8eCzRbpy/j7QBUKUJKj0PqUFGZZ6nlCo7qEobtC0UdwmWmuqvr1C2FFFEqsXMSKAuaZ9uVtOMaEVEJitIfyWrHMtxp60WJbmelfbB9VFfAkvLoEJXtpQk9MHGpRcHyLKR6KRlivx0kJm4iJitEL3zO35nQ2zwypNbhMzyELOAbp4Aw4aEUnpq5xro0Jk6GQhnFVOzqJdpQoKpB2BBlcRxaYLK6ajlWQbTVyXE5te5DScwiP7/aA2eV624NiGsGjPpB+xP3E9kdTlcQ4znCa4Lw8RK3LUxqsHsLdn/CE0IsJ8LqLj0mP8NsnAtrFAFQ1YiuXo52RoeVIkOxDCRmCKNkzaFBIeMaGeJr/oQ6e4OOr1MT20Zl7VEycnm0FpFfW+jIkcawOqMH4jtxu9a3WzswGxPaN+fo493jMtqd3+La9cXjUsY+3LcFc3u3wd3agnmMBWZJcFoZjVdRhoYTB92ju4ENRw5Wt+M+diMfrypfsXcHvSby8fYnDuz+HOPybh/cFn5Zyt3jMeJ2urv4PQKwekwoA1WKaHIFtHvJTLXBzxtVmlxnQtu7JBxYHcL9I3UIlcm3gSSwQf07+g4M+xijr2eEt2tJFEq+49bGgH9raaKGVLB3idGYmJTUUHK9akMGCKyJ58sYEBfnBCie8FZn+ZVEGLu/5XOMTdIiMlSKpda8kdpUf95/Y40pUsBo9wXHrqmb1tYfrz6QWFZUzpLMwyIOpBRNVYnmK0SlSF3cDIstJkPML3gOGcr95n9PqkFY7ZCgHXuKDAHsPqx+VkFTfQyo5QCuBkkz+dJL2w/DuXhsjq1a7sc1OJmA4Rm4VApINmOonkv+Pkcvg7imDTsuM94+CuBEsze7c7Tfv4AMURUuGkpqdrK9T39UGArI0AmEczKgOJCBqQLOAGxOx9fSE93+FLnnncZ03GEm1xh6Tvy9UkiGpDq+nrTmECdAEpmiBCReT3zcEhnCY+qPo6GLlZ5hDXGNHp6mGa8B5JUhpAYRpeDI34devYjPA070MKxcML6HtaPj8KmRUZIFXg7H5behhArD8YDKVE3CCRlC+RgpH1gduTXAcOLLPQynO4NmuG9nebsbKIPUzb01fmu7+yeV/X63tuB8+WYP7lZsb7i17+M0Kk4DVsv248TqEFaNvJtffxyVrP4ElU9jooPtjZ3KFP4+dcGlbnuKkk2cxPb5OPoTdB5PhqjeHbtwTYbjIV6TtQvH41YQXAZ3ypC/d/ZjQKm7Sdk/1wbFxJl4H+LYOOxpMEoegu7rsG0d64uqkgEYjnH/glLE3iNeEcKKPPZGCIqJELPIkyuEtqyN6hBOosATKkhlYY0gH5MkBoFLsT/4W87XUULvSnJs3MMFIacUFa0ThNcI4oqE/x3vJ2GuUpSwz3JKUTEhKFk3iu+H7RCtnOtDaoddUzXGSTwsRalKjYvXyRHj1PFK4+OTxlJChRxS/UgTBIdIFFKIwxOixENfMnOSJEP8YqHt1WRIORNFyRA4rFLWblZlXSHNwOTngUvtRQkQ+MJ7ewwFBi4AFKtnYX+FBJSs8bP78KDGFEWheCzaOebHq9TTXMg0FUONOVAC+PnfZG0hUo71e0KYaJn/LbUFQGdrsWFD3Ft4IgrhWEaLOvpjYjFOmpucfh5xW6g+CSDHxwBJqGv64AD/U6WsrEU0KEkTduNErl+EtFGXsNgWKp9Exj+cDvL2EzorgNWc/mYkK9h9DWDn6hbK2HXrwbjP9glRbhieFHN026egABeAQGYAAE7f69Fs+eS9otRx9LQYILN6aiybp8Qc1MOTYm5sfhybB+Pf57iMEjBscDIG5AZ49hBtC/99jso8GcXmAXSOULm/L5Y9qUuV8bHgazB2b0RlTIpu5J9xrYwnWPC+Ejan8n5aQgZKkLQEDPL7BaDs++CQO7M7Udzhjo/E8ijpAd4Hu9+tOpq4QVsDSSBVozInO4rRrpEiNbOu6qLH7CRtn0OSogLbRyMSRft2ieOoXS9Ka6t07R62TXOvU8ta2x27V5X+1MQWc9ZDwuCZfFP7FFzrSWrfgXBYl7nUgdbOjKROoJZim71ci8jQUuvhcPj+eCIGMibcVp4MiS49Uj+8T+Kao5wT7TLwdYX8+XIu/uYYYSpwP9MwWofCj7FH6hRO9hB2VEihEgOj7WsGR2Yu/P7GuSIyVL0ui4sGvhm4n37e6MFqTMplbn3boe1DqNudDeF6dRv2MOA/tXsokTQhjMtFN7ldkgbUheYax1JoS9t7osygsbp4joIb3Z647JIb4GNB+xWQbfrMovIQVQMzoPEMVEHSAvGBuGqhZ6BgTGYbkyaYc5pAwQxowPxdhyct0D6A9z+KN1W3Rob7nRWc3L8jLncfPYIb91OiJMGhkzcMSrlHhvMGHfyjK3BHu/7to11QXwAguA4CAEm6gAk/zdRJ30/adbB3LQw39n3eNdAjYqpeF7S/+i7ALo1o7N1jNrS7esyE/bG7HABNtNChZ7xD6yppLlj4nW97F54nu3Xk2erOHVFksTtep7nMneG1idD1wS5zvQvHZQYXxmP6gXwftPWIVHfsXj5e0/dBYTI40cK2p3YEdu/i7mSamw+ugseOEiCBc7FP/l1WZsZxH0XLjOAEDrg/HmTPEx+E/Rd2nyvpR0m0kLQhJQM7dU4PASkpx5zzx8cuEYphUNU1gpJ4tJLkILwtbTI/lX2w4D6nNiQbV+V1vHoucylV6CLIUGfiSWR9upkKg4gSMpQol5AhNRGCJJd2cll3a4ofXGdBdLcjrnC4XArsfrai7gM4sUEoWxNmD11nqGrEVznXYLC7lQWyvg2qE90MDHEjVLPJlShDLKFAOF6jJ/AYtHS52H1OmekdVtGgd5Ya3sY5QgIIoVrL/ZAECuz58X8PnUVlg1zAlHsVgCVHiGM8CBkCnjI4oe6wRAnRdUhZA4ivE4QMa5oIALeLjBuWHMEbz249BCN9t31fqXPRqu/c7p/HKn6E3QlyXcNGOyZfq50LV3CtO0LJGU6GQILMjW0gQev7zmB1HC3hk9OoFD35aQ+H8jPe611x+32PkbL/+4m3bsOT9uWHbt2GJ96/Kz946w484f6dhX/rxhncf1+09jHJWj0xlt0TouXvEElzRy4QmOF4gH6voPWnQ1DThhsDOL820I1h/zc+l0gdegipUw8iRoDqw9Gw+wcAcNwD7MdjjgYwodyHc2rWAxh8vXB/WK1DyRiwMgRAEy2Ee91Eop9agwg/T/idwN1r8d+uM8Q1r9dc5nzZ0oQxRFk+kt+pRAEyhrrWofXRovsddrmz6rfCHWMFCSlAx+hEGIPc6QxVUYwhbnLSd8uPLR4LajulZGQ8ZlQyxEATS9CyE1wUyfFqbVcYpKNvq0TcNGPf74P/l6ARAqxGsWtV7TZWUsaJC/ix5NzrpD61Y9TKnLRwt8hcfyU2dypWDWc4VuztpGqUKl+CinQYhShFhvZw1ugzH1pbNWQotz2F0iD+AZXxGEtmOCaQIbFNPA68TYCmAFGViI2FKEL7/3lqbT7jB6ieNA7lWIYjGwJxh7UFe74zFFxndylbhT7U2RgAcu0HQqCisc6JMklhjoevnK8UGZL23f2ItgeyRqsQYx+RHmyY9CTlNtoZ3RPefvYB0qbfpRQG2M3adihd7/p2PJfdXWUWFh8GTzDhk0SsLHlRajPzJW5ys8kQJoz8N6zU4MQK5HlGbmtrALuRyzgdcVFa5pWyHZOczsUT1iE1du2IqjDOjuAbQ3UGZTvAzoA/3yufp1tw57tBr25uoN+rMjfuO4Pz83gwx4gYnR5FonDUoTTuVn42n37zYXjTow8CAMDTbr4H3vzoAwAA8NQbj8Bb9uUnnN6Gtz0S08Cdb+MJOz+L5S0quzPkmrLFBukA5u7eEDwZwOzrudMezNneoL6xBThjDyFJiFCg9ODX8lEfFK3uaAhlvH3XMbrv0XZzHsv2diyvH4v1VaXIRKXI2fi8c9DYTmU7AElsgdO3OxtVZ2di6m9ndqpz2AenAUeqM1ESyHcDdY7roEQLzhiw+++O6wwY9H0gabtL0kqz77X/njljdirSfjsAxBTfxujfnlpDDic40MbG7QpFHSLrNCn2jlvZeL4MS1iBk0loqk0hVKXIOf14U99zD811jBvxUpA+P49LQ+un5LgwStJldzYeY2f1vrX9a714NMLOlaEU0df615SiVL0EpipEkwjREmQobMYuSbhewrVstFjakmTIA7thaYSDu2qlXn7Kcc0mQwkE9wPnppEhgNGDgrOhma1yExM7wtFxoBkiP1Noti7MINrzgagy2Bi3m7jGhN2gtXH6gZ5fADIjEhY9NXEGxRkAToZip+iAXTxHxtF7NbaLzqPh1wuycOw64nbDCvI2KkZDF417Z82YDAEADGM7uVNc5rozFwydncvcvnwez7HdxmPfuYD48w0xTmhw1CWR2ezhOF08xp3r4eHJUFDHHP0bBgixOqY30c1tG8t2Q9U2DWYb65kBkR4HcZ0h5DJnHETXNFYGzU0Ob+9NUB3c1oDxCRVweWPjPhsT3d82NioZAADnFsxpJDnYHa7fWLhx384d7vy8CwrOY2dH8LT7HwEAgIfvnsB73/duAAB4++37Qvltj90PT7/5MAAAvOWxB0L5TY8+CE+7+Z7Qx3aIB/mWRx+AJ5zu+njbI/fB/Se7vt/x6M1Avh5+5BTWR7vx3nnkBOxecekfWYfjMrdXQTEydy1RX7ArmznrdoTI46wDe3PXz3B3Bd3+t/5Oh8or6PbKTn+3A3u8T/5w3oWxALBPAibXGwt2P7bhvAOzV/iGO6twvcydDtx+n+6xaASuH4uTNdhdDgBgdQcdInFli88QXk9rtOaWvze3lLTb80juu3P6zsKTKquzmDRkdXcI7378LtmV9+/xPpYNWZvIofe7o4YZ+iZZtIaR2WAXuCEoQ2bTR1fn7RDLmz7EGpu+pxdLW/MIYEcafF1tTSPn5DWI+oGW8XGlSBH+vkkxQM5FNah3QSEzwxDL6Dz4cyGVlyBF1VnnnKsnQ/iccJsw9Jc4j0uU+fFx8GPPrYWF3eFSNrBmE6bGmR2fo3ZfYfy+poyqY06RnQWzzk0hRcu6zFWSodHfOQkVYHzjE3KhkKFSKU4jGyXlEjI0Gi9uazoZ8m5XagKIkoQLnXDjsjJJgTs4MgZ1kpqoKdidAq1/czN+eTe38Ho/6BquDPSnylpA/IEk114el0aGRvcnyWqmESiFABHimS/z/tV6Bdv5k01S+26pO55KQrCL4JFSXsv1xyQPl+X+1AxyWmrtSjIEsHORo0kT4o27RWW6XTsO+ndPkisg41fIRrYrI9cs5D4HSvwOAJAHzRyjhXRx+QSXo6FvTpGhjgkAAHT3IZXndAPdKtZ94MFodT/jiQ+H8gc96e2h/Kee9JZQ/r+e/IZQ/vgn/65Y/rin/F4oP/P0XfDsm38c/v6IJ78plD/kSX8Yys95YqzztCdEMvXAQygxw4MxAYN5AEkjD8bjs6dber4eivsAABw9FN3xTh+KDOMGKp8+EOsc3xf3P7oZ+8TnEACg6+L1XqPrsj6NY+tuosCfm7EOToqBEy1gdzkAeq+SmEMtaQh2H1XUZ/4bWbDWjJO4xHJ8CfTaGmvkHaMkWjiiLxPynsD7ILe34aSgfCy7lu1cyPC3h73MsHsZdofTylqyA27LlAS6d3LfxBXwNJb7G0diGYCdL+xah8c+Z2FPab9q9Qwzb8VVjJ837bfapAIl+/J9ku3NSOigET6OksQPJcebij/SyFDqPCg25WgsSoKxi3KfW04hmkCG1H1TEqHaNp41UcgQWY07wZ5rT0nBsY+6WJAMpcem1MXbC9QzrAZZEhjJmDwuE0KAjgt/BPGHDw8PT5Djlc/P6EwedpXgpIwGTssfOI0METUIqxsA+vUi65fIxCYFSh7jdmrYyMYHns3FsMxdhq9ZgoOjV2gtIjzrqwdky2PnCpt2v6okSSFAJL5qAhniWecIOZFUNtDvSQzT8/1jRW1NGpK0gNxbaDtWgwZD4oQM+s1o7lxkUk1/xi1qa7VGRvi2g1s3o+H/4I1ICJ54EknIQ0dx+/1Ioji2lHSFdtEB/95jT4Rnnr4rlJ92+kj47T2bE7H87rvRun/kbryot+/GG2G7QRMmKEmDu9uBRUoYPo+YsPC/8TnWkkHg7WTite9G5EhC36P3InJPdLdjefUoKmP3OaYUdSinhSVKPqqkPb8c+Fbd4vcHfT5W6J3RKWU1uQKfbPNlPGO8dfrz6ORjVF3meHIgX94wpYipFkRJ0VBisKVmvDWlSMkOp2XfwxOQdtOHRXLt+ZZ8Dw12Y8Tf0w16ficoRaPvhqYOackVSgx6ft/W2nS1CZ+4cpJaL2qOax5XfTRCNIcolLiTJvpQydAoy1/iXGr94sQpE5Wiy1OIaskQZvHF7FqfBRil2PbxCxoZSo25Fpr6xNqnxjm9qbLr/zA1Awfk07GArlAUkCGSQAFjcMGww5mAdjspNygnI/t9huMuHNv2pAuqS39sg/IwHNkQnDusDGxP0YwiUok4qdSymoFFC8vi2DULNGbI72uZGlRChiyED7Ezhn6US9yHiXESy8PKBHVnWJkYt9Ih33wDo4xyALttWMWwW0cznKHxE0OlZ8oNcjOUEiW4zsTxW9DvL408lpChVTynhAytgZxrslZKigwduzDO4QjCm3A4cjCgRAlhXZ9VTKawGw9Sk5Aa5FbxWSFJLlByBLd29Hx5dGg7y3xmkAubRcTIdg6MfzY7B2ZPqIx1wdg3nQv72NUQyqt1D6t1DxbF+mAS8OD90cp+yq1H4WjvV/nMW++CG6sd036/W++AJxztyNEH3nwbPO34YQAA+IDTP4RnHe8Unfc7eTu838lOTXrfk3eEMgDAJz3ht0L5454QFaQnHz0C73fzjwAA4AlHj8H77hWkG6tzePqtXR/Hqy086dau71U3wP178rZa9SHhw2rdwxrFO63vR2oOUmlu3DiD4+MNHB/vHrCbp2dwsnfPu3lyDjf2228cb+Dmya7t4/UWTvfb1+sejo5QP+v4QB4dR9VntephtSdHuNx1Q9jfGkeSVxi0vtPWp+p2TClCChAGdrXdBdLvyyu0HtHaxHWvVpHc+zJdVwtPyNC+tGQvNPFLfJeEyTAbxwWGvw/kyTPAx2JRcgP8HbBy0gNnDZ0UU5I57Npg6hRO3CAE7DuLvudozSdc9vUCCAFT3KQUMjQcrWJSm5NV6KM/7kh//U2qGnl1yHWWqGbBvc45PdFCwnZSF5Qduf2Z8XbcDzequSu82Llii+Hf+HachEBKSMDBf+P7S3Yb71Mbe4kQgOvxBBJSHa0s7aPtr9QJ17qGDJWS2UtSiuYrRFPIEC5rN7p24jjRUNYbSq5DVHLIWh1tzPh4TZy9GhEMErOD90ddJ8gQqe9QOYFSMoQRZt+wv3bvQp+mT/h74r7Rw9wf29Du9rQL8UHbGzakbt2emBCo2x8ZplowpciXySrmwjhQdrdQtiYaqCQbnHgYpJ2wPz5O4samXdf9poH1g7+H+CNGjHtKGuKii4YF6O+bZATJbhwhZjjWgCZToLOzvh1n4jXGiRJcB5EIdixRinp/4/Easj0QLpaxLhz7GtVZ0fuWGGHYLQhneTum90d/FO/14ciBj59yaxdSNruVI+mbQXt9KMcIq/jcOFQG6+IBrIZY7hzpg6hBWLUg3hEDDPv9rR1g2MfkaOXVqoehpzf7Ghn0N5AR7+N5AACeeiO6qn3gzbfDI/sT/YEnb4N39rv0Zx9w/Ifwts0DAADwnKO3wx9snggAAM9c/zG8YfPksP8GseLbSOZ7FF28h1aPwe/e2e1z2m3g928/AQAAjuwW3np710dnBvjj27u+V10P77kd999u0ew5Ft/QOV2vqZJ138kZ3DnfPWD3n5zBY+e7sd06PoNHz3Y30/FqC4+d7bavV32oD6CrRlhl6rohKEJdN4RxGuNgc+4DfBxs767j2O8gdegRRSkiMUTooCzEyZQVBGV4WAOacIlltwKSKAQASEIF7DHQIY9D41AablwGpBQZtL/hkzGK0qOoRs6a0JbrUIKADm1Hk2D4PTZqV4mpIckVAHbfZD9OG8fsOhPeH3hidgSihimqCYBsZzAyFMqnK3IsJIkQthuw0LMyYO/65AoA9k684PYcXXwfU8RTaOMxQoYM4bL/e3Dj33IgLmGFhrKUbMCYqEKU2oQapP3DpKuRY2b4PpodTVzNrG57+ondztLvdMk10baX2Lq5xX1TsU4YBTFntUrRFIVoGiF6v68fM3vM/kvJkDqqA5KhUInNWEgoDapjZEjFkmSoEGo/vowzrjGQhAYlyRR434wMAew+mETx0dbQIcZ7DJxd3e5Dubu9DecIZ6EDAODZiYirFpkdxESDnQglwFDMUMcntAoSK3BShElZVBlMLK9NUFCGNe1DdZnb0GtjhmgY2W38vdtE8mM3Lhgdpk/c0woJNENMlOBVKt93sIHdmAx50DghSoZCfROP2Zk4c+0MhMVRd9tRWSBDoT2cAruT72ezNeE3stYPLvdo3Z/BkBggp2Utw9udiX87CMH24AwqI5LkTFB4BlROwVp6fENv4WivSDgHcN/pzsLtBwtPvvloKD/r1rsAAOBs6OADb0aV573W7w7lJ67ioqs3TLSU/2DzRHjmeqfyvGHzZHjWvvw750+BZ6x37f7/zp4KT109vNt+9lR4aJ9G7XfvPBlO0aI6b717fyi//U7MRPfwGXKxu30Cqz15vHu2DurL2dkKTk92bZ1vVnBrf6xn2w7uO6GxRGt0LjGZ2aC1kR47O4L1XuW5c74OmfXOt11Q27aoPAwmlPveEkUOu8xtkMvf5g668e90YPYPZPeohZhcIU5SdHchvHPsGVAVEl966XsA+2cWh9Rs43OLEyqQpA1n8Zbuzimhp+sUyeQHJ22xG5QoYRsVV1KnH+g7ljxa2KBC2weUqAEpMaaXiZDZDsC9MEyJ69gA0e7ASRCUdfSIGx4nRRgKGQLYESJ/XN6LwmwG6E92+3SbIcRrdWcD+e6RycUUKfLHKxCjYjLkkcuqJ2EKGcoBX5O5yRVS408ld8DJN7DNIa0lxaHY2jhZGS+r45C2p/rLZZdLJWXgfQLMJ0Xsuvz073yXdARJTHeZK/DvLCJDKRkvtT+pB3I9CzLDzY0nV9ZWlsZdcPm0gAzpLHwBMkS25/clYQlDbGuUTIHcoKiI42FQUCwmQ9sbaPuJCYpIf2xIrMz5/cg4uA+RqRtohowHvmqyN54t7EwYM08PTa6XpqQpfusYxrHse+y8SvtraW55YgTSzzbui/fnyTZwGzqRlcuEAGHXTXaucawPNqz0FOWoDnOfi9eKHRd2rVNIE8lMd0SPtT+ivwXVCbu2rRyJ9Rnw+jTYTQ6XyTpDqD7JGudAc43DfxscM6TED1mU5hob19a6QHxwuevc6FV4fBLJhidDABDIEAAEMgQA8KG33hrK738ckx58wPHb4Andbp/3Xf0xPKWL+3/8aXSH+zOnvxPKH4vK/9eNWP7TN34/lD/kRkzYsDY9PGsfc9QZB++FFKuHTqI88uBNFNeE4qAeuBXLT8BrJN2iOawfOL4LN9Y7ieXW0Rnc3JdPVxu4/1iOq7qFCNUJSkW+RvFDK3SNjtB2g34zBuAIZarDCRgAr1N0A5VxQhAlacLQxWfCdXjShT1PI/dS1B5ZUwu/41GdNb3BiNKtrK1G11+zch1tzSIT13jjWT6dkiSGxJRq8aX8m4JhDHXvIusOKfE9OGCeLBCOJ3CZ0e+PBbuvMQzIjXyLXOM296EySlaEy84Y6E+o0hTKmHQlgvpVMqQBu8wBTLC/Cu2yElcxLQlBSVmyr0qUnpJkDZrygo7FdXb07fUoS6SlHAt3xSvob0RWubKl9YO3F8Qkac+teo0qMU0hev9vyNYpJkMaCmcAitJsTzlBKZc5qTonQ1qzBWRIzf62BBnCp0JSPYCRIezOMDga5LrBFioqYqMWZ5NTyBCOCeHHSIL+0doWK+zmdRvNaiWCXp3mj84/oglXQrFdTQ0i5Emvp7nb6YuxxvrYwBhNb7BTgWdnV3flMlkzZKsQJkLWdaKi7aPGS5Hsc2j7yMBC5YIECsRYTCRW4BndHFZSyAx0/qZwJCsI+sE6uczqEdc4TJLQPpYoGGhfLfsDq7digf43j6OPFXaTe8aNh0P5/W9EZeh9jt4Ryk9fR8L0zO5ReBgx02PEwgd08e+im+UxFy/qO/tboexd7wAA3nT+BDLeN999MJT/UFGK8PpFGEcrtMDsis4uHHfofcLO5YCu/Z1tPMa7eJ0k5Ka37eUHAreL27TGEQUKr7mElSKD0nCvHo03zuo2agu5zJGJEHZ7aO67HGRCBiXDIwkUUDIH/L7hf+N3C3nPqMkV8Di0STjqyUCg7E/6UJQiYG2qiRqAvefwecXHhfcniSUKkinA2FUuDBOXcWY+ZRzYBR0MQIfVIVw+Qxd7Q58Vk1K0PJTZ/t3fheqQR2kgv29yittYCXL7HiIx18hDqsIgTHWtTYzaxFqhKqnkBlyB7V2aVEQpa+P/6d/+5/m+GaZTKQZn4yzNJDKkqCmzydBU/1BpdoGpQWFW+YLJkJRiW0u5TWDYx1D44Iw+PP7Q2U1ntliiZH34Wf119GfFZGhz04ZztrlhgsG7PTUkc1p/ZGBzY/f30AGc30SKkidUgwtuAQC7mcORWgT7c4L9yBXi5Ayo50UqA8TjNQ6RAwfx48NuP64aeUPDDMg4MLHsDDImDF1o0W83g6PkdUtdGTu2Jkl0T4lExPRx+85VbnwfpbIaEmXJKMk/EkQQxyWFuB6UTGH3dzzHJOHEGm3H5eMYOzUc0WuHyZA7GggBcjjBgXVRubFR7XGdi2Xrwv6uiyrTbDJkXTh+jQxZ6wIJ2pX39dGri9fjZOj0aBMM8weO70K/jzV66ukjsN1fqGefvgN6Xz5+O9j9iX3O0dvhxGxIew/sLeanr7bwxP05enLn4Kn7Y3uC7eHp+xv5QXsOz9irSTfNOTxz9U4AADgxG3jfPemyxoUkDRy9M/Ckk6hGPbBXcDrj4HS9G8fRahtI0M2j8+AOd9/RGaz3MuwDR3fggaM7cLJ3z7v/6C7cWkfV58bqPPy9sgPcd3QWxnZjjdKWE0WoD3U8CcJkyBgHHXNzXO/3cS7GdQ3OQOeVot6ENZVMbyLhdzR1fFBtDFJqLVODcOIPrBp18R/A7h1EJykg9BkmZRxd7wtPZPC/B5REIay1ZlDiARO/f86a8I7ajWNfRokVOIg9ghUkYBNe0ow5XxuRuVJr317Xmfgcd8xuCIkeUP/OxXWXEm74pO91FwgVUYZurMI3dXsaEyr0pzFBUX9kod+nQnedge0NbfYKQqIFvI7Rbt0k5MblXN4oz7li5dyqMEoUBGtGY8J2qWqb1iJ3rTT7MWNXku1a0gQQbOza/gSbM3fuxOMtJEPcHhgthYPhr7M1RenRU+OvxWRCVCTDlaRNBIgnUsvSwcqpE5o80bVQ+wCxPJsMkbZwHb3NFDHSoKYPVskSMhSNYTFESickOYBAZADg/Fasc/aA7D4HACTzGCFFp0jxOaIvd/XBIGlcB0L41Fgqly+TGCtSRvWZwqals9XKHfPZ98AKj9lSYtSduxEZim3jscllbT0rgGhYOWZk6dkScbtyWY2nc8wgI1nwxmMCAJpsggkFJGYIrwdkI8kBAEpc8D7YHW4ll4k7nBKXtOsjFjHpIWX8DTLKdqW+MfQ3ToawWnKKDPsHUTrtpx5H17T3PnpnKL/vOqpEJ2YDz0Ruck9H7T5nHdWNZyP3n+egOu+L4o/edxXJzzOPYhmTomecvBt6dPPg8XqyArAjQB63juP2B5DrG04jDgCBFAEA3Fqfhax6qX6w0rRGpBYTHk6GcB38G35NrFDGOrzoK76HMbnHWQ9J3B1LvkKfJ7kMACzzo1ZG73vsVremrsijzJGoXhynXNbWSHM4zrIzum1SQoq0d1dnyDdt9O3Fk3ArxQZSlntQXf53D67YB84Mh5WhzS008XgLfWvvk7dvb3Thndufrsg3yZF15TKuYhJKvWxKSEqllxE3jouWM6m1FxMkAwDKXMVK3ckQisZfuR4RPz9FNr3q6slcSBX7vIgUSW0LZdWVrhKT9szeXPhB5jdK6mHAKCE8A/rNoXTQAyT75OpOiVsU3lcENxYLZshFMuTi7PJu1mjcVUqyT4Ib89q5lzLy+Eu7jSuOixndXHyRmsHBdq/emN4FMmQcwObm/txYCCqQFEM0rGJd6Vi2NzukAHQ70oGyrMTjFdSuDmcfMpEIVMwyEOUIZc2hmYzQmFE5KkvjfbDrWofLZ1Ex6M5i257o2G0kOt05kJgiSVkCg9o3VKHy4D76AGMCJMYTGfS/RIAcve9xFr7QhM8jgFzzdirRfpZ0b/CZHpWHODtuehPLw85w9MajcZQM7U6MiyRIUnrw7xZdfIu2czmxY+eUqE/oWDUy5Os4E41mZ9CrzyS/5Ty7mQdWTfrBBOJwPnSBIJz1K3jGybsBYJcJ7n2OdwRog6zrYX/hnt6dgbdrn9yt4IbZ3SQP2N0FuM8ewQ2zDttO9gf2BGvRfufQ7W/wp3XvgX5/op6xfue+3w7e62g3nrNhBU893q1btEVWu1e6bqzPw/la2wGO9sqLMS7EB1nj4P6jfbpuO4SkCLfWZ3C0f5BOuw3c3BOilZBD/+b6PPR5stqGzHLrbgjllBujh68zOBPiifz+R0fbsJ6SPd0C9Pv348kQVVKkhvbH8T0R4oZMJDcDUoPC/wZNLrD7iSY9gdg2UWb3xzogt1aHYoqEU0CWN1gBer8Y+ozg7WFM2AAUvqUe+N2TIkU+UxeJ7+GGmoljsmybZvfwWf9wvDb2KSV/UghX7xdedZEMGbf7Fu7aiuvVDR39rnqEGF0DUSnC7e3dlobjVXAZdOtVJDl7o7cqfqjUDuS/BbtOUdGEpTNyKF4Gpha8He1YcmSKjTWoIGgJkyx5LDmu3PFqNr1Ehvh2YLavgCQpwn/j47ZKGT8vE0nRLJc5NSiLl7WLUulaNzq5FuIDavBaM3S7On7JSBPKqmscVrZIu8qYlaHQGXITjGa+ng0GieVxbvS3VB71Kb3MEi844rutKEj4XPTHXVBOtjds2P/8ZjyuzU1DjOvz+41Y3iA1aYNUJrt10J9GAjYcdVEtckBJqaLuqNv5grOewPQuHAsuw+BAzcynqEbqookOYhYnh1zjnL4AIk65i8sAVEUivvwblHmpj6REy0YFMCZDUrnsXo/ne2eQyPsQGLnscCphlDJ4OHLIrW5XpqodNqrwtDxOc6jcIAbiG9Sg8eAyf8MS9Qk1ZVm7qBweL+NivIlxzDU//yHHRjmPjTlZb+F8H7ty39EZPLrdTfM/6fhReM9+wZn3Ono3vLu/EfZ5ShcXUX2yRckYukiWnmjjAjnHJsoVa9PBLXu8H4uBB+yu795Fd7vd/lG5ebCL5ftQsMotpN5gZad3NrifYQXmuNtG0rQ6JzE8AAAPHKEkDOs7qIz7jMe7HSycrnb9bvoukKp+sNB5N8qaWbc9sKrX9zYoRW5rwZzsyV1vYDhxscyShYSyouyQmD/+3bOUCIUJCwdBbTIDU6Eq1SQwyAXOmFi2dHuZyxv+7gJFeGwcLYdJGGZspwx0TF6ULLbJSVdtlluze3BsJfKEGE666JJ+I04Mbk9i8Pv2xJIkF3hykSQ1Qi7tOO7X9AO4/d9mGGJyB+8ypxmeJeoQmdx2cj1+TTR7ZoLqoxKoEjUqPQMl/50iJYoxX+x9VULoao+rpKxxAAlWLifX58IkTHKl4yRsRkIFPsSKvRgrqz1xAPILJ9HWKFixZOTKw6NN1qVeYqprXIIM0U7l8Y3IkDgwpUmBCAW1gZVxW6RPbvQjiKm2jaHGPe7Dx59sHfTopUoX88MnFRW7mBGpP44f2e0NE87d5lZ0v9jctHT9CjZ23WUOwnnerXxu4v6IGIRzgYhQ+M2XsWsbXu27d6pqFLdD+ICZPp4Lg9Z6AqCBrytSjkpYd4ZTZkMIeDY9dZkzgxuRIem4UsSkZL0ldd8Sm9DFPiwiaDh9t+3jS9RugWWyQ21pz69vb+3Pi4lkyAFVejQ1iLwPlDI/XoX0GCG2yDmjnlNsXJeQop2C5EIdTwy2fQfbvoMTtA4PdgFboRSHJ4ikvLu/Ac9YvQsAAO66NTy125GGjQN40MYLcGp21vkKukCGbtgjWJv4bjg2sf4Jev89YDdwd39hn2gfg8f2qc6evHpPWKfoSetH4bG9f9aDR3fgbr+rf2N1HmKdAKjL2hE6JkyEBmfg5uo8KEGdcSHV95HdBmXoJiJft1ZnsB3Q5IzyYdHIEN/u/7aI+OL1igB2ZCgemEJ4juK7hcTJdSCTdlwGnUzwMnnu1kBUWxLP5+L2OF56f2vuc9IC0bsykO14/TLtOFTPCrb2Sly4G7n7SbaJaqugptXFwuMEIVhLJ0Hx0FC8kV9M1fQDDChu1scFAewIUNgXT06uTbhH+uM49u2pDe/7Hana/dHfWNOECdryJSDMxuc8WPh50yZhNYLKl3aRjPJCkpAkRTk1p0ZNKnE5NGyB4RzJ4/dgYR/i+FOK1UQyJCYYsXKZZq217Pri7IyozAmiNv4KTCNEnLlpJzj0YuT/eT3exx5q5hat3oB+Ex7OCZN1qP/Ew5W6CNIzb1iqZ6xwwZjIzAEhTtzrgxn9vo6Uatv0KO6mH5B7XXyxDUc2EAQc57PZx/94m2R7Mx5/fxo/sMNRJEfOolktF+OO7BZgc9O740FIrGC2Q0iYgD9GdG0KP2aIyRUMJVVaMoUAF//3+3kCaYZIlkzvAnEzvQv9Ydc+cEhxQokVJKWvOx/CPp7c2D6qRt3GBRe47pwqInYTx61lk+MLuuJj5dmowvgKn6eRvYjtEOSaGdzkbDynzkJUfbpI4IgahFQitze+7CYaAnhx1WHtAPx6gx2aJeAKDjYayfELD6Rh/3MSxevt28EKEJkk2BMcSWR2yBCXSBFfKsQvyGoMhIQJq66HVdfD3c3uBJ2stvDYZkdiHjzaZZl79yYqPO/a7hY/fdrqYfjjfSa4J3S34ZH9g3ufNXDX7U7qsVnDsD+YztCXtidEm33dNXRw5vaEY/9+ve06uG+fJu09wwk8aHfjeef2FjzQ+fJNuG+1U23eszmBG3uV5m6/DokSMOnxpMYTj5NuG1ztdiTKhJikIxRg1xlH2vNE6XzoQmzRWY8C3PfnlydL8Pv7MQ3OhGvhGDnz5AqvVdT3NsQQuc1+P+Ty6WOHiMvowBZuxu5xRi57kOQxJpbDe2CIRMz0kbzsyr5/RGocI2583bd9PwCMSKiKNN7PhDGL7nMOfZ/9cUgkBicKwHGlwto7vO8w7oS9E93NB5CSK+BxOewtsu6IG5v/vnh3NzM44jkBsJt8jGvYRdc5Z2nyouDK3rugFNnNAMPJ7iUqrpOE40R4coWcMcoTLdQGwmO7zrAscpXZgQESpKh0LP7/HHHStknjKLGrpXEobRePn5cx0ehsvFYJl7RRLDt/TlVCR9sg/3M3Ob+/phpdKCEKeyckPHWfyoubQmm9OekVMUpd4ypR4F6+7yRRTv0W+kmQIjweLfUpTkuKZ49wakZ0GsgM1RE9P2StjGhzwfaGVkYvcJxqGSVsyL3YtDGraViVRANETWEgCRHO406EgGwGuXwubyfpUWG3UK3H+k5sd41SkeMyAHOZwy53ZKFEeizqjOqc70cJKeLb8T74sNT7fOrgassKyUnVK4FyXI4pQAMmRei3vpfLuD53E+uH+k9Bjw5yINuRcoHKngDxMscGtXsOKBgcWfYbZCVvUPzQFm3nCpAGruxYNOaOuBkWpBhm6NF1wWoSLuM02zhJhKYEcpDsiCRTIq6DyiZfnvoMiSQDGJHBbnUK8dn9rfymjFkflFIGYO+TCQetKkMJjxjcpWI3UIOSxR3tQVJrM5BsrSfydlwma0qR9eIqXKIwSox4jITXzWKLsM6w0araLRyj5hpXpPqUlEvHogoZQpwQL7N9HJ/kECYtkuUu0RaCqhol1usqwUSXuQST5Se9xE8zs3208rTCAA1TWNS85VNe9nPJkFSFj4krXCAYpZj8SERI+i1DimhigFjXYgKEXcKElNWmR6uLb4bgMoeNb08KNjf9Po6QHh+Ii1PB9idxbNubJriDnd80ob3tqQ1kAscQSTFPlNS5OLPI3e+U8xiVHCfX3W8LvyMXODOg84xij+wWKUTbIdwXxCXPu73t7cjVXReUtp0StG9r48J5sVtHFCPbY/c5IGUO4grpH+8BmDFiyHGXIvX8mR7HNMUPhe3jPWE3aPsmGkukvPdsGlYu3DN4kVW7MeBtbdObqOAMJh6jRt5KyQ6xkIR29nXC64PV925uDvN4rwAJ/bjBhFfKMJhQlxIkG9o9367gfLsKGdEeOz8KC5C++3z3YD6IYmgeWu1ieN62fSDE8/xRfxNu7iW6hwcH670adNtF17KN6wMB2rgebg8ouwcAPOqQO97+WNdmgD8edjMlJ3YDf9TfDwC72KF3bO8L5Xee714mp90G3rPZWX4rOxDFxuN8T5z88d/tV3C0X3Pobr+GtRlgvX8YtkNHyJAnKivbw539wmlHtofb291LC69d5GOIyHpEewLEFSJf3g429OEgElRrHWy3vjzAcL4/Bp/lEKme/j4fVjRuLqgMFoqeVfGWdvH2jMlnkCLbxXcTSYePkqG4jqbW9yCkiHtfMVJEVGnfloHwzhwtm6BM7gGkJsK8HZFwmfPb/Nh8cXCj2W2yi28Pu8lZO1rrKGAV1RvsMheUof03YnMDLXFBiM6+D5REA6/jtj0xYRKvP8WeHR2YzV4VPUbPkjc4hwHCmkJcpQkHy2xDvF0qS3HZBUShSp2SrkntwrILoCgVuGZXp+xtCdp1yO3jUZLwAtCzatE/bb/UGHH6evR/SMOvqUaSklWJ6S5zWKrS2H1p0oTMxRrJbyn5OjVm/OeMZ2CSMqSSGPmlrJEiLU5o9BsO/Ofr3pSoIOjFDn2UxHfuc/syIlJgTVgU1a0tdGcoPSxOwY38yLHq0x9DMDTdKr7IwQHsY7rBbnakCGBnzG/w/if6rMXIHdCTIoPKlp0X5RxjkLghHkOEzr0nlmZwhFDRa+L7ZSoTUoe6u/Re8cqRQUSHZJnb7Nz1fHt2E/u0G0fuQxJPlEysgcqSS2eOsIc+5DIYE4geX4speDFZlBnPslTieDkc8gzR43AdgNn4F6sLWbvAwI4UScclHEcVlDYcdnPzfTsDDsWODFjpIWWqiHgVaBhsVIScgX7rXbMANptIDIxxcPs8PpTvvhvl2rvoYb2NrKj77B148+YhANil2n4bSrTwjt4TnwEeHnbubI8OZ/DosItNeni4C7cRAXonIkd/jI7rbf3NUH7L5iHo9hfzTedPgPX+JnzL2YPBle2Pz27Aar/du/15nKFFUzFRskT9cfBYfwSPoeP0dbFqc6dfh9iq29sjEpPUE9VHVoMwUeVlHyvU9zZ8Fjabjn4ucbIP5T40WxOyyZltTFqDJzS0ddU0MiSVDUrbb7cQrAm7daTPMJaBJm3R4hEJKWLvjFDPoWNR1X7hWKR6pA+5LdHmwCTMwxryXlTtg2GIbujDQNYjIhO7g/+mduF7Mxx30XUaaMwV9sQg6c9ZmvU+ZOF0sDn1k0sO+r3LXLcZyDpHJNidG5ultlipqiH1w+tLdlOJLcbGeplkaIRaNWcqcm5yGhlKjGWUJTFFhkv6J+oU6oektI/FXeIV5DI3MbnCPJe5jj0kmNVXJk0oIkOjH+kLaxRD5OsobRSTIuIDPOOGVGeJy0gRIT8sgxkN9pfVHHEWzI9F+SiQmStcRylb1F931gf/5NVZJDD2PJIh0/N1K/Jl7BO/uWECMehPdjNc/sPhVlZdSVtz/xspReEYnfixJHFB24FmmSPucGgtEXSOLLk+gLYj1ed8CL9hUoPHAUDd5FZ36M2N3ez4tddImlif/6bcu+r9hcojUoSeLWRnUoKobO/OqVLkP/72PMZQ2M3OOKSuRPh5M0oZdOR8dvjv+FRi2xaRAUyEXG+D65QbTJwV701oexgscQnrN51Y3pzHB+f8nCoot8/XIS31u++ehmxtb7t7P9zaL3r15rOH4D4bFaO3bR8M5TfvY4oAAN6EDOU3bmN9T4oAAG67TSBD584FMtQ7MyJDsRz7e/v5faH8rvNI4h45Ry8TiGRo03fhPN7drgMZenRzPHKZw6ToDiKFuHyO3PSObA+39yRsZQe4s4/JMsYRdzic9AKf/w26RufkGqFsXwag3ytOZjWAO9/fI50Dsy8PayBxcqSsvbsTkwbj78J+s4lkyCGVaFcn/1GlrnSx3xEpQts1cqO9Cy1TXHTSFI3pJBmqxIgUobjVoKzAngxl9qc/xHPUnQ8hw2q3cSGhghniNxWnWgdg39ROLpOsdqerMNk3HK3i2Ffd7l9tyutaUlRTrxL3JBnK9ZciQ0o9MWV8TT8plz2JOyAFCSdjAGCEaQIm7S0u0qXJd0tfXP7+kNJu43psNmE0jNwzwW6KyWsASciRIuciIRkgHhP+H5+PAWJ9PE7UhvQxIMoS/ihgY90HtxuaZW70exfd17YnHXR7Q3xzakIcS39qwsKi/TEgV4v90A2EczMcRSNYiila3XUhcUN3d4BhbcOifXbTRzVrcKMXIDm+zRDOpbTwLF5Ulbi1kcxxLpAriVSa7UDOc0zGICtIIUmDi+TKDNElDoboSufJQXc+hN/NduxCtzsvsktfWtHxHz7hNyWjoXSspOycmpqco9s48DPCdhONKn/8zsbFanEZLEB3d08oDIA9M2DP9n9bF1Si4AaHiAkgAhL+HyIRGbnEqedRIEWhPda2r4JVIz+mIapGbjAw7A3eoTcweAWIEKs9ydhGtWi7WQVicHa2hrOzdTj8h+/spNjODvBHd3YE56TbwJvuPggAAMd2C7939pRdHexOtv+MvLm/BXf3bPMPewsP76/zO/dG1DuHIWzb/b6r+5b+GB7ZZ8H4g+0DcHdvtf3B5omh7T/YPAEAAKwZ4M1nu/GsTA9vv3trvz2Ox5PDx86PgjqzHSzc3ZOjwRl4FBGn95yjIIs9HuuPYNjfFOfDipAhD68UPbY9Cum9b2/WIdX2OVKmttsuXgPkSodVIVz2JMk/TltEmoazLiT/MBsb0sLbc0PdR61/7vc7GkqARvc2m6zAypHtUXkL8VncxneCf286G9/pu8QovswID+zajO8U5C6L1awBr1GmEBuBDPn3j+3Re1dzk+Ou1GGgie+9d7cmkxzC+w9nYEXpvbHLNqDvKxnH3tby7msAEL+vp114/21PbFDN+yN0/nlmwdD2vtsjE7wLtieGfLsBAOxZH9Nub/oYu9EPu39+fEusR6TZhFLoAzaCg2qYGQP7XSQnWAmc4omU6v6qkKESlJIhY8ri8CaMH6s+zlpZATKGrg2GxzUBk+mUK0mocKiLyImAYISFekIdfqPPcZ8rhbo2UI4UAVCVJiHjY+Oct0GUD/LxGMSy9uGwPH4Iz3BpL0VtM5spjB26XeavPbAtwjOdadDUCq4YxSxzRj9fWnptTenhRMuXHSNbmppE2o11sBtidxerQVThoinA48eP78dThYcyJ9ke5N5C7Tr+G75f5pRR14a69VE3OXweQSwb7EoHEIkQAJlJBwBKiuaU8bnjRMvDGfo3Sqvs0Lh8VjEAgAErQGf5sustDGj/LVIeAADu3o0P2CN3I1F411mcgfjDs/tD+Y3nTwrl3zl/SijfHo7hDxTV6H9tIun4n0jd+Z/nT4x1zp8Wyv/77Omh/LtnsY/fvxP7ftPtB4ky9s67UVl6953Y32NnUfF5BJXfcxbrvPsMZXYB6uZ2p1/DOfI3enQTz9GdbTx3dxEBwmRoo6l0Z3HfftsFBQgASBZBQobwtUP3FH5WsIpKXFyJkkO/e3RtNCAgbW/k7eSbwsbC44JqoH0rR2p6IG70Y6O9r1UPARJ3iiVcN7YhBvpuz41fTQ5D3r3xB2cMgBCvG37zZW35A/J9HZNRgN1Ek1+wdXXXwZBI1FALdY06gHpSNHswBUaeEnOulmu6r42lr62zJGrI0ELgmek01YeUSWIFvH36uIxz9Vf4+R/2/8INxB9mxvVoSJ54/Pxqi5xxSQ+Pk1wErY95N4G+OKr2IisYk9hPvg5d3VuphN0oMIFwjBDhlzdyn+xvxg/92YPI5eQJsc7ZQ3Ec22jHECIEAGE2HwDgKK4DCSfvHFA5fs2PHqaWrz3DVnVsm2R4WVkQZ5wYqDujTHC1a+osTbGurj+lzXJoH7fkYoRcmSi4QZR7j8rieDuohLckKReJI8CuGijTEZ+cJz7zyEMqrL4OAFuSuRCRayYGDCfoHl6zA9GyyJFJDO1Dp50UVLaubH/FyCnpb+TB0CGX1jXN9HbzNLLMJ92Ki6A+6+a7QvnZN94Rtx/F8lNW8eF85urdISECAIT4HwCaKe6uixfWrzMEACGlNwDAOzaRPL1lrwwB7JSiN92Of2MyhEkPzqxnURrsU7T20i209hIAwK01XouJ3sTnyAXuMUSMHj6TCRgmQwN2hVSue7fqCTHCbnaEDJ3FtrrbqHwXkST07iSTA/xWccpv/HFQSJM6ITEiVnhiCm0nCyXLkyM0XkmeSHIG5LXzANTJRtVNTnFlE2Hzxhhpm0yYxYMnZAhPMq8suDUi1ffF++v8QUSwbyESjd5/OGkFPnfr23iyzZFMpEfviReye098L9i7NCEKbOKFweey6BsKUEY8CshTMrGC8t0rStetocIOrCZDF0EQNUwhQ6XJE6aExZTYqE5+bl/3a/+P3m5ld8V7aasrL4mkm5riGkf2Sb3ohBkckiwAQDV+S8Y7Wv/Gt4Xdq1jSg1DHya5G/m9cxguA8n5Ie57g5NzxfB9EwpfJEP7NrSzYvZLRH3dBvdiemPAC7k8MrPahBcMaQkawXZ905t67gHRnMRB0dduFTDrr2y4kVFjd6WE4smGWy573cfy9U4keyZrnqNtbdC0b6PnF7SD3M08YTT+ILoehj+A2hq4lviY4Nql3cV2jAfUxUDWIry3EZ0dJ3JNUZmMRY6b4djJLHA0dstis5jI3oDWaBjR+x9QgZsx5Fw9n4r3jDEo6YQD2y9PsyndMKHdnyJ3OOGI0mnNF3cEqDnaZ4y51uIzro0QJmhoEvYkz/gPEcm9iJjFc3rKyV4A2NpYBYqwJMMWpt7C9u4atV4ecgcduRwP/HY/uCIYFB2967MGw/fdu7xSajevgd86eCgAAjwynRCn673efGcpv2TwEf7DZqUBv2DwZ3rx9aF9+Erxt+8CufP4k+KN95rjfPX8yPLzPw/+Gu0+CR/eM9/fuPAnOkErzhseisvT22/cFReddt09huyctd86O4Gwfz3O2WcGdPVHZ9l1QwnpnApnpnYXeWXgYxSRhNQiXH9mcBJe695wfg89cd/t8Hcrn///2/j3ouqWqD0bHnGs972WzN5vLh/JB3Kg5IHogicQyFQkhBJSNVCpWKokVy0oZQXLhU+I5lSCnPDEnnhAsySdWHRNFOBKj8ValEZOwJRVNfWU0URSNHj4uChFEwpbL3u/9edZas88fa3X36DHH6B49L2ut53nGr+qtt5+5enb37Nmze/x6XPosmieu14ugzdps2hhMYdMkQTJWp/EZN6s2mD12p4s4vhAZau+1MfriWZOksYkpRuI3RAIjhO93nX7P7SreJ59nBoBN6ZI6E9IT823Pu/PplDCFc/AUZIj+1qyQWfOmY02EmzWau9d4fsfrHPTN0jNcKczzaN3tES1v7bPZQBJYAZdDtVP+9pMWFve2HbK52gaTdGz6tjmJfbb10YrzrR8fi7N00wnLO4u7yDzv7hrcSTTbk0zmtnU1yf8csr5GkiypIE0iuaEWNGjtYfNrUXGPaE7IlTFkE3MqHAMZaoU0dclp4//JJsTAYApclfu6c4tK8iRFUwMAnfncBhEGTv3t70nIDypXSYrE6GSS86dkaoUFdo78kHT4He844bRAACQTrrTQJh522kB/wfDZ8KaOaDYV8yyjv/VWsA0LY5OYMbWC2YdksrH9WyA8EilabdJxIJpUlM3ketd9sZ0jdQj1SSZ6mTOLGuQflO6spsRsIZ2NRO4J6ZwzshcsiFleErEueZbydSm9WJFFG52fhAl1csYS2vjHO+fb+1F7TyOxac6aOEZQ4ILtb3HSa1Y43QhpNEnSgA3+b0yEAADQ/YDqw0Jwkr6H0neRBgERI3fWBjLUnS6SoA0AAKs7ccf51u2o6fCkCADgo7efHNLvvxVN2zwpAtiazz26Izb/4+x/SQIi/NLtL0Lp58T0rZj+r7f+eEj/5q2HQvp3bkbzudNuCR+9sy137Rbw6B0UXOEOCq5wC6XRM+H0Yyj/p+8gNTUAPH52PUTZu7W6GsjQWbeEm8j8D2uGcLS+JGgCSmNzxfUp1h5FYtRtGthgE0mUD7/v9i5KIzKfpAkZ8nPp9vDoXXpDND6pwiz9jlC6xd9gRjMU/FmaNDhCI63bgslfjgyFuckBifiJ50wk6K/I3O8hbWJxxCikhbb0ysDzKp9OZZEuRp87WwffWIAtGWLr6/h+bBOZAzVpiXx7rzaBDG1OWmjvIu2PIMtQaLQhVWGy2Ur4+nskRxXwpzKtaEcVak35hpQ7xIqrlgwNaRcFIjmq84ukM4tGkKLRdGqwydyAl8yFmQ7AwQQS216BONE2UGe6cD/KLzhMcg7lPS0NKS8JdbrBu0mMMOqA3YnuaY2wdmKD0miHCFCdOBgA7ZOe3w3jFJpolVofyKALO0rLu+tg3nTlVnyuk1vbsrsTRIrQbn+DHHi94OqWAMvtAfWwudLAlV0ZmysNLG/vJvErLSzurmGxm8jxRxL7gGpuBOLk+4KZVBuHtDSO5N/9jzVAMS8TxQ2RpCRAAx4fmEgxJiHbAAxIq0UCM/jFEP8fwnx30jgUFhDfRS7tDxqUA7djG8zD1wHpuMF178plSZFzyXWKxSkEQr24F52zF/cip1ncbcg9UXPTepLhmkBkmk0TCI4n6M06kvVm0/DX1w00m5hn2x/ptQZrgxjtbKIh8ul1w2uOsA+UpEHy5Grdgru3c9jvmhC8YXX3JGgzMCl69Nb9QRPy0dtPDlqa37v9tG3e9VX48N1t+lOrB0LQhT84e2rw/fl95HP0kdOn7X5/Cvzuvc8N6d+7t8376NkT4SO78h5DUVRu7877+djtJwWztUdv3x80Q4/duR7CXt+9u9MErRaBmJydLcN5PnfvnYS8N+9eCxqlx+5eh8fubknS6XoZfIzurk+Cr9Cts6shctzN06gxwmZyp8g3yPv/uK4Jflw48IUPhtGt25g+W4DzQTJOF/GdhzGKyJBLyX5iMkesm9o1IO1IJCRUM4Tze+F5q8HFafy9QkhTSEJ5qjHaXneNQICakmYornHtqkvns/C8/Q2rxqH5n1hMYI24/z+7EcuY2KWyA7POoI3G0Ab8P0SytrW82L6M7soCljvikh6ouv1/eeoAawfxkQ5hPd0Nn+U9FzRFyztdsK5Y3NuE8/wwkWy8iZzfsdeYFuLAW/5ROVKkMZnDvzPXOW2MSJS4+ujvXF7aDgWyQSemJl+a5+Kg0bLl5OlSm1j5ulBeyaxQina317DbSCAeZTI3AcPWmMYluzF012fDDBjSNo2mKKcNYgXbzA6GqDWSNBIo1LQvKxFMfV5kptdvJ68V4Mjc9jqk8BqkRRNM5gAAlndQIAC844928oN5E6S7k3g3cnkbgvnclVsunLdwcqtLds7cok1P107ID5rYFaQo6UdkXrGtiO87EMptBa3Ltiz0P2fqSO4RNUV4B/QsfUELLERQMoNIWrKDq9h5TLWdZNx3mIClJI2tIwmjzWu1sGZoeZr242I3jlzThHRiPgdbgVESIBd4911IJ8RnxRMi/3e4H2l0GpxGO/lJ+lSob40I2lmbaqmQdqi9w6eb2yjU9u007DZsGljf3gryzjVBw7JxDXzyJgqpfetJIf3bj0fNzXtufH5I/5cbzw7p/+NG1Az9H49HbdBH7vwv8Il7DwIAwP+489SQ/v07T4FPnUZtzW8+9sdC+gOPRbO8P3j8wZD+1I2Y/9atSObWyPysO1sE88DNegF3d1qx9bqFm3fSUN2Poud99DbyZ0JapM8g7dItFIji3r2TMDWsz6KZW7dq4xlTANDdQ9qhe6idd9DZL3djukHvcYE0Q4tTfixTMpRqRNH1RIvKp7flpYc/c+ZztF4pWIpGc5FqrOMGB0eGYt0bPp3Ml6iSdRfWse067eeojszvqa+dLE/wcz9Lhnw6mHST9QXfLxypIZlLJzKZiySXagsTLTvehBIPrCXPVEOGpL+HIhM9WKUNErRyWcxFirRmcrXarFy7uN+GHGYqaHlr6teEmO+F4xba4jhyXYFhQRW+9B9tExvhoWqLpPaiA0P0BWjUbQPuoQewsZAIxABVpSagQt9BlhDE5BRwzKZxZEC+fhBIWiL0O5f0ow/RCQCwxsEVnoycqZ8U6149EO9dI4d3LJh7zRDAVruETehwQIWrn02lgPZOXAGSRU2KYIL6pHFxx6HZuORdyJMsrhyneafbJMQq6ccE0jiQxkpGrd2rUwgYIgU7kOqUxvo2dCz/AGmUQb7NOIBCEmgB7Yyur6bl4+AKGxxcIQ0kBptrsZ0dOsuzW2IJj216IgQ26wYcvkd4X+k7qpsj21UDHQ76IEwOUrFJ9mWayV1BhPO+KDB2mwbuf2K0a33KfSh9LQZdePBKlJ6vIKk2Cc2NGrBGh5589PaT4XOvbwMyfPz2g/C067fCb4n/DgqTfQtpY+7cQwEMkGmaW/Mvzq1aaK/HNp5ciemrV1Jbr6so8AIO640PXcXR5E4T/x8SGQ6fd4VNJPGLSYQL9J0iM0rJNG5xt0nGXWJGin00SaQ5Lt0LppAImGm5+PyaNLqcsIHSlfNQMhTrk8lQI0WTSzbxsECP2kQFZcl/BUCWDRSRraQNTVhvmNy7ck8QWb4vrqerJ6LACg8i88z7kFkdmtMW6Gw2HDwBAODkdmzLlRvxJS5vomAKd9AgWhGbSI1AS3/aCIREoyXK+RpJdY6RTykG+MokTdGYDO4jmEIiJ2SIqyayXE61ouwv8TwjzTtlIjX+/Hv/SaZRPIabzDkX7h5Fhvw9tepLqmGRBNNM22rvYTVFBdM4Frnn8pO2kx3RE8dAjpVzA8XhIA6CGRd+XqI9CuszcgqNz7rL20JU8bdNMF3rTlo42ZnMdYsGrtx0uzwAy9u+fdF8bnEWF1dMhjz8InzlZhcE5pNbqY11e28Vx+dqk+4EFvy2EpOL8Iy7/zvSt9wOo3OZncPYv70Q4MQ8I6Ql00kmAAIbpEE4hyp5Hges4LMdK3zZ3DhMzP6wg7HvIxTMIZS7iQEgthrN2Kbgp+CIT1FGU4QPpV3sxtQ26EKSLe6ou7hr3nQAi52g2a6bIHQ2K6SdWaXaIADgtTj4nnXcoW3XW4IDsP1fk07+P2tiWStU7lmsrz2LbW/PmqBJaFcArTcd3JnVBe3DpoHNzTSk360bWxa5Xi/g0Rtbbcmd1Qn8wc0nAcDW1+ajt54MAACfvPsAfGzna/SJuw+GKHAfvf1k+Pgu/fu3ngIfv/NguE7hzz/6+K0Hg3/OJ2/dD7d3/jmfvnVfCJRw89b1EJHt9PaVYJLW3VmGYBLu3iKaCK7SicutWzjbaYo26wXcuXMV7uy0Rav1Am7d3abvnp0Ek7jbp1cCCbp7eiWcHXTv7pUQKnuNgimEyHBeO3TWIhNIlF41Id2s2jCe2nttMK9s77WhnMW96I/TNwWN89XiFMKc0Z7F77pdRRLSrlLtTzjTbOVgsYobUPieBaOBCu3BGqR1bEu7RlrjtYNoLhvLaVfxeruKc0mPDJ0h7c5Zh+7BJnNRi9GsNnHuWXdBaEq0QVTjgQPxeNNWzjTfkQA4TLAiNRkimpdgorZogsmcO0EmcyctLHcHcrsWYHkvrut+XsRBaSgZWt6Nm2LL25sQkW5xexWuN/fWMerdGgUq8v3AIScEk424oslc7jfJDEwyEaPpkqxZC0UZrLyVsVCaDYJVUy6fqM2h3wknTwt9QkNu99pWGmOUi4wgk2NDI6QYorqrvT/zoYiqbHq/xpxONL9zfP7cgMITrVSHFJZTcu7n7GJzqnmfTtTsvAmZHFIaPRPxH0vSWK2fmM/F6ye3Y37vUwQAcOUGqoJsROF8J6is5d3UVCK1eRbSimAW2d8EMwadOQUeQ13ad/gdC32qOVCQPkfSXkTetmXjbyimU3MW4f2u+DTdEGgFM7/EHO6UNwFpk0AJfFpDigC2pCgxDULCJE4vhev0/CJMjBLzu7v89aRcHC5ZSLerdHLHWoHlHZS+LaRvxfQJSi9vplP/4gY6w+jmSRL57OZnoy/PH376wZD+0KefFtL//Y/+15B+7x9FM7f3PBojzv0GSr/30WeG9CfvPgAfvx3L/T//KAZq+B+ffkpI/8/PPDGkH/tsNF87fSyqlrsbiNDdQGaBN9FO+91lokE6vZGazN28EVWJn30cmcndiP2AgzbcuR3vX92N9fdCa+OgHMhkrsHBEbBp3K14fXkbjw/+XYOTAyDgMY+FYvydSOnt33y63aTkCH+H+HpiLi0FThECvuB5AYCYCaP1BR+xkKwByExOXA9wYAW/keRBptJGspaQ1hdpneXIEIMGh7Ze8fMlPovuBKdRaG2c3t6D3zffp0m/UK3OQDIUkpKVjVSuJAeWzouqSddqrmraiTBZYAdt3Zo+VUbeE+U+GpQLD+ecPM7lPxAGmcwB7MzmhAPFACA+KLb1pOkpgcp2bRtelFs0saMXTfoCRoQVxOfKuAbStMakSgNaN+473/cL4piZgXQ2k2hKB2jA4wAOzokmB9gEbXMNqfKfiMznHkRnKtwf6149Ie58b66h3f1FSoau3oyVX/0sMn+5kW5bNncFkzlswiYc+gVtq/pwe+M+/CCogpOzslD+tkknJLxYSNcRHFV/h29ht8vnXx36DfC3QduJ5azErI6tfus7to7fHD61PjksEc82uI7EjDGm8Rka+PrmahPKwmkfjt0jOZvovuSn5AwjbDKHzd+w6WC3jCRdSvcg9ZeQPclz4gIh6nB66VKihKc0XLDU1+m5rLC+7kL7N09AO+/3r0MAgOsPnCYHhF69Fr+tK0tkJtfyT4bJwVPvuw2P3tpqgp76hDvBZ+cpT7gTIts98fo9+Oyt+MJw3ThSm8MR2AQfLnfFBSLrrnUhX3N9E6LvLe9bw4aY2S2WSKjF5xGhZ9kg8zl8+G2zcLFtrYtkqHUk+mBMNoiEpiZkmJCj9iH/oa12IKYXOI0jwwm+PHmTOT7tFpG4uLYJRMe16fcgmdzJ/oeovVgz1BAy5K0RmibxDcpuhnpI69eiCfdvo+J57Uub5HVk7hRN7iWBkZIhvz7hdR4dPOmunSRnE23uR6aiD6AohthkDpkbJ2fgtSkZOtkFJYLOwfLOth+bdZcQzOYeGnjEpyqBRq5LNrEJgRnil6SpW0MOFOvsoDOCMvlGH9hakrO15UrmcxkZOXwLKO3/FiHK062cZ4DJ3BBzOVr1uLslNWqtuhKjpEYUPiRplx6fxZJVfwu2xr0PuZDOTcBJ1DMhKh5tO5teZVTuJO1JQeOcTuOQ7AQAi8TkwLnYnqaBhd9pWjRwcjtOrlcQofHmcwAAVx5H6ccQAULXMRm6cmMThPjl7VUaVe4u8SDthLEihlnld4p6zrc4jzQeldpG0SSTew4adEHY6elFIqRaLma89c4akoIuoHSyu4u1PoltPzn/iIuS59D5SZ18ztIC7XKnATowOyC74cj8snFRgGy6KEA2RvIKHQAAqV9JREFUG0jOJsJCZ6KREdKJqdoq+nK0ZzHdYDM3lPZ/h7pFDVDqVO9N/BanqO7T1GTOP1N71vRMrE5uoLIfRwTjMXSo8meiRmS9WsDtm1utzOm9k6AtuXXnGjy+S9+4fQ1u7KLVPX7rekgDAHz4kyjq3CfjeUIfexRpg/7owZC+d+tqCJCwunUF3I4QudvLSG7uLgLRWNxpU/+am0jrgjRhWIO0voEYMQC4sxbWuwAHGxSQYX26DIRsfRo1Td09FA0OABwKjpBog3Aa+wOdIjO506h5XJw20UztXgPtro7l3TSENR7baZr/TtqzSDywiXK7iunFmYPFWWpChzc3km9L0NzSiJHBNO/MJSZ7MRpcnJNoYBhRG3SP1wDBugtrfHIOW8ZkLj2qIk0nf+N8dJ1HZ8lhk+rYLqx12SQEo1njOtBz4WAQJNwwDlzkrTCaLr6TxVkaoRP7DAUyBH1Li1B3hgz1jv6o3V8XCStJa+qo1bQIwaPYvzXl1rYLQezHIeVq3kFOttZEm1OEjQegMqQTNytEmZu2udSuYfodfP9ADdGf+n/GQiRBUkLndAx8SNOUDnc6LVCGtZaQ0yhIzzg2St/GRVvKjUuDAkhaCqwhSRzb8W5lRtDHHy7uuyvIwfg+dJr2A8gxFJ2svbqO+z1Wh+2fr9zqwm8nNzeBQCxvrnofQnsraovwwpKMO9wP6CTwpK86SPo0Xs+8x6QhfECFfLCP3WXHp/t1COM6t2GG369Dfzsnaw+F8Zn6EArXk28g2pA3nYuanw4y2iG0E081RT6NAy1cT9tKNUch2IIjmiLsQoMDS1R+mu0ZQHfVC3YNdFd26VUDmyt181qq9eF3fWmkL/8ci7PUuRqPiY4EV8Bass31+MLcNfTNX0MC1ElMr+6ewJUnbL+5szsncPUJ8fvD2qEk0loSVQPnQZeRBgb7ADV3FuBOthkXd9rkvSXRtHAdSHuFA1Q4+j6wZghrC0/b8Pzu3gKaq6iPktDnqJ04gALW9CSRGvnri9MYrGNxtwG3m0YX99I5UgqgkJwTRA5QDteJ/47/thZnDtA5uIlTPoC8MZJGpsR58MYLqnMdDwttz7owRy5Ou2TukSLIpWcOoYIFDRCsNwDeCmLTpekhUbYSjb8wP242MR8lQ0k+3Gj0PVyNg7t7Qpys1khLtL4PEe0uaoraMxfmyOXdLglSg83klmjDcnEbrZ130YDCxI0QBvXZQskGnCBIU3NvD8nxn8gemrqzLg5cfVRmHRlYQTyoFK/LXcbXaspofdLfY8+Lkp6RyleJvIGFv7p3iueen/+N/5e6mRijfYhEMkSDDeB//hoHLGBz4MqRmLXXkDBlqg529btIjjhKcqG6fTrH6HPPiLVUWLMjadL8cznXc5wP7efCG3eQ2j2vYz04qADeyU/auFNhhuuSeQDa0Vrs1PCuaeDk1k4l7xxcubkJdfhzipanDk526vyTO3Fny/+emGwk8tRud/XO2TYiTgiogCQB59LJ1ptDNA1/IJ+/1JF+oM/LOd+SOpJy8b00DZCeQeTS69zvXKCGfrAMSMkKCsIQ/sbPQ/N15KyjEFIbnQKPNUDJ7mz/hPA0pDmqDwdUQMEcgqYIaZAa55ATcbpL3fOBIM7EiV8RDqiwS7drotFhND25tEeipVl5YTP+r0mzwRTOIJhPtaf9uttVFI7x/+H5Vlstg/dpatdN0HQ1G4Dlzn+lXTVBw9KsWoBd0AV3bwGrm1uBzPvNnN2+Amd3tunT29vfTm9dhbNd+uzmFVjtQnuvbl2BzS69uXUCm10Y8M2tZQg93d0+CQER4PYyHIzrg0A0qzb4W/l+Wd5tgolZL/jETkvWrBp0XwOLncbNB8EIIcxXLbhd2p0yQRrQtUCCztqoFThrALzCHGl62rN4DtU2Hd+PJyheM9mso0aPixC3uBfTy3v4egxskAQ8wHWQUNoePmCJP4fIb0phzZH/NmlAhhhMAc0Rq1QblARWAN8nu+9444JvjM+3OI2bXzjdnm2ith4HzsEaoM0mzsEJGeni/z7t50t8Dae5/L5MbIHRkfo9tGQIywIA0Jz6A6CaGO2taWB5OzJ/ryVKovid+f5zgfz497y8vQnPK5Kh01UUiqcgQ+j35DxDDRkC4GXGnPaEyk5cOTlLpZKsKoErT9LIkOt0nSyWLdWRq5srT/NMtfVxMiww8pWEDVOn0PZqpYyAUYQoS4a4NIWUTxq8ObUmvT+JBtYXggEi4QEgz5IQiU0xz7Y+3K6YTHfM+HZIARXENKOWFB3wRYdOhhRBOjGLAjyQ3TAn9B1DigAArtxE/gePx/Zd/yxOp6ZSeMG+cgPtUt+KZbXETC4hQ9LCJLyT7Tk6Qp8L7653xpVQLlsm/eCZSTKbFgIq9FXxkPyGkWgchPOBxCAK0vUzfpwBQGraJ5S1UARj8KQIgJAiQoIosDmRbHLEp09ul9OJwzukROkE/aZJL5PrqI4YpRpOUJrWd+UmynczzXflJiobmc9deQw59X8GmYB9Gu1MfwrFygdIzjo6ezT6AK0eRSZ3KO0ejfe7P0Kquk/FdPOZuEO+eCyWv6Smf/g5UEACHEziBAWTOLmBnu+x1LFq8ThShzwe68dnRAFAYnaHn73FgTFwwAwhcAc2u8TvnUZGxO97iceBYCaXBkOI108Eh3ocrIaD5IiPA+bg73Ehpjf8dXLO0AKZw+F0YjJ3inxFsd/LGVoPcBqvC1R4wmsDzrdap3/jfKhsXGdD7/egZEhajzZ8W/A6h0nRyU20xj6O+y01i1ve5tfPHhli2tEL1jPSREll9iXJg5oACLn7a+vT3FtVNt9+KXiWeJ34YUmBuEb1NU1LJJaOD2FsJ7JALhaBBFHuGk6GAGCcyZyKENVCciafAkpnsZgf31tWjVOI4cgl7ZSERZMEURDPf8rVI5kCJufw8OZkvbIEwpg8C1aDCuZzK5y+vw1Ouav72kSYlSIOSZM5AMh2z/jdLbGZ3CK+bxpQAUN4d6JToTSGJPO5IZDOIyImBqI5nWCyp25bonlF16mTqv+bBpDA3Bq3GfVRh4J9JGZ1yARkczXmWV9tQrnYXM6n8fvCpnYakznNEUKbk7ij3p0QM67a1427KulflDyJmqDNldSRPnGoxn1Nz2ZFz+7N/Xx53PUk+MQTNkFz456wTg+BTdosmPxhOD6NTcu6Ky4Qim7p0kNJsfkaLkswF+xIP7gT4TfUYHe1C+TIXXHpYboKczhsqpYc4ou1QFi5vUCBEpaphjPxO0sO20R58KZG0j4sjMTr3bJJosF1yyYGUFikc3LyvNL8KG3eYI0GEqa2gRKiP2ri4C9Fh9MKyBzaNsowTZMXrDSO6dKGYSIUknUJ14/XE3QWEVyNH2N3X0zjAEbdFT5wD/b/6hZNCKAATSOTIezHlNHepOcaCv1DN/mkDUepHvEMHOWEWuvrNLa+sUEXRsgFrm3CNycGbqB1DAkY4UHXd4D++s+ULZnIie4qgsy1/S3++PO/+Z3alicYrCFKKpTI0BAVnoYEcepHTT1YBeo/OqqeVjnDI5U40s7QdNI+Lk2+e00Y62YdwzTTE7UT80B88jV53lSNL7B2abJyLpqjYT8aMlATUzw/wToHi2RHK6avfWaN0mgH6/YmaAaWtzdBW7G8uQrCTjKZ31slZKhZrWWnzw3/3oH2K3dv5sMUzTE1Id6HqMA1hIS0q6E7Pl0smzvTSDwLC5vMbVxSZ1KfFO5206GxEvulcUgz1UFiJicGWsBkWdAULe+61JzORSdwyWSOmp9hs7XUPC6mE60R2tVPzNYU5neLU1Q3No07TQVeXAfWBiURxojJ3OJuFKzbFcDJnfjsXiPVrpqgscDXAdLgDstPRTa1/KMoqC1uR7O2xe02aEiWd5tAYhZ3o1nYAl+/F89PWt5tEv+YK4/zWp+EGNF35U0j1zFfu8JmgzsTsbv937Zlo3qQZigJ2nAaTfYWZw0yT4MkHUzIcNCEU0jSmLhI4ykZ29hM7jSSjcWZS9O7b2xxFs8YogETqKYo0QDhEM2Jn1JqGteGerrUxM63ZdUFEtSebZJ5MNEG4fkcR5M7W8e5b7WO8ysyk2vWm2hGvOmiUI/m0GbTpQEM1rJGhO6+N5wc0XVxE462JZgJk2BI+O/MQa1wyhyW6hwsdlqjpnNBI9SedWFOXNzbBM374u4aTvBm4q04SWCfIUyMmvWmv/74v5tGXmOla5JMlAvtrZHrSmmpfRzGyKj0fg1B1zyvMp3VJtW0V1u3ZFZaA0ZThN1V6FmPAeTsrqFkaFfuMA0RAMDDz/92ouLFAjJKOzcdC+Y+LK4emqYaDw+N1khyAsPlSnXTNiuFaha0Dq5MgPwHm4TYRmYiggN78rwkaEMkX2QgC32XaIrwjtZVdKo7Olx1eXcN62vb35a319Bd2aVvnYUdqcWdjGYIIFno0qARWEuGNEXKZ/fall6QDIRB2kb/U6dIA8hjljZJE64bIO6iO3SPNLY7B4m2Aw07KeqdhMYBdMsY2jbsONI0Gh9dkhY0RVg7dDV9VhxMoeligIZ2HR2R2xWEYAPtGSSBB1SxszHwcDiL9S9O5XSo+1SuO3Fed3wejMWZS/qlXTnY7IJQNOsYnrxF6WYNsH5CLBBrl5y0rSa0ZXm3gc31nbB8B6XvNbC51k/3nlGhgUk0DyggQLuJGq92Hfu6XQGs70PC/VkDG/Q3fkYpwEYjvJMWBUfopXdTz+IU2LRvG592xTyLsxi0IEmvosN2e+aS99lQeVz8rvF1lO5wP8ZACe26C5re9mwT5tYG5fH5Qlmac4MwgVlvwnzRrFEwg65L1uqQZyPP31nBOdnlxmOwi2Xj4DFUNvLImaBhrbikJbqO1LobB91927/bs01YY9vTuHYu7q6SAELY/I5uJMZKMsItkatKB672tExSX+B+GBPAQJKZtMiGkEbroBSAQRtATFunR07eVJQl+n3lvgWNnE3l3kTTU6clEoOiJTJIf5P5kd/+f/PPoMA4QvR//X+kF/yAltS/NB1akcmTax79aEplYFMofH3RRqFt0ab5cXU5AVfT/mRicKFMUZukRY4QSc/rf14sYjz5JZ3ceEmn117OBhTV55bR0dhdW4brm+snoR829y3TMKu4anxeBYow5BZtQohyZCi0Bav22zaOw0WbfqSKiGr4nAppbPfGjP9bUVcPLUQhhJIiZozjs7IAduSUqrVL9eOf6DP6spooBLmmiYtei8/0QHmIOr/XRp+m52P551KSIi+44kh0nhT5OtfXUuEVC6K4/u5K1M50V6K2oXe9lL4a05urqQZHAq3Pa7Q2V5qQ7k5QGl3HeTZXm8SkqiPnEeH+w+RrfR8E8631E1wIFLG5z4VABZvrLph0bc8Q212/Fk3b1igNACCZs2FsrrlQVnc1msZ1Jzgd+7FbRo1at4zkoFumGpeE4JBpDpvJ0WdM3h02UfR1nsR35U4g3OuWLgnnnkZaQ21ZxGdJzOQWEELNu0V8p/icoW06flf+XbuWmNIl/oGo7mXU+LhFkxCurclct8sXf+sW+Hob5nC3bGJ60SQkR7L/3z7XJqQbH2a7BZL2McKbaNLVNEHr4hZt1MBgU7hdPha9uY03X+vNtT4wz3IR5j23aNP5TRtNjatzuQjzLI421yNFu37s7jtJ10gsZm14oglNk5Ih7wfVNMCej9TbxEPyRMY8K+kHSrKkPkJtFGVHCTlNjFSuRj71KJmJSaDEYKhMnHsnEgQiP7pu5eZBT9YObSGkqCSz428U0nlkDCEaHWUuQBrsUpqqvLjrnDZIgqZOMagBSq83KIpMqooTY6Wr6uAXAdFxH6skud+4ttO/pbYkJgFp0IX0fCKUVkwuPTWmv44m3xYRmOXNKA2ePH4a1P7t6Rrau8Kp4+j5FreRql9BhrbPlOlTzfPiOhTjVmU+J5hg0vvZqIEAqcmdcM5R7x7JWZPWL+XDaTRmWlWwDj4NzvXMQ9m0EGgh2TFHAiA9pyg1oYvVN5tIVgBSIRIfDDxVGp/B5c982VfdWBAG2JnDIVNC7KOCgzAkpmoofeWxcvoqSmMiiM0I6W+paRxKo0AJcnABlBZ8btpVn5QuUSCDE+l5b/DtWibt4tPY9A+byfXanAToQGNWCpqQmM917PWEGJ2m54IskCnc4m6qJsJn1OB8+PoSzdn4fuzU3yTnlW3S+RxpK7DmIjlnCAvup7xGQwxmkDGzSfxMpQA89G9cp9QWMWACWZultuC1GtdxNw7aFq2Di5tx8CbrLjm3KZgh3T2D5g5aR5FJXhoIIkNYpPVCWDt6/bARnl3qE41cpCFDQ8qSZC9qlpcD58pAy9bIxGP6ATKykKZujVzP3S8ExUhkTU1gMY2rxwCM0hAB7LREtc6MQ1SgWk1Rbbm5tgiOgqLDl4TEtEBJ8jTPRD/AWk3TkmwRC+cTiX2k8LdKgMrprp8kAzk5B0jYZZJ2uJLIQisi6dHdIH+Zaoqk84nQPdWavJymCNcltFEDzXla/bbg+pt0HNWexZH4DOGGVfYVbSPVDoU0uo7PJkKOxBucFs4pon9vrqaCqeq7rp05JS3IlVRzo6oPD5lKkzmqEdlcTbUUSZAJHFABB11Igg2U26sJRKEFft7UcV/Ik9wck7gfaB8ApBq0pM9qzecEU75e0ATs7yWZxuEj1ZK0U+THhDimHdLybNtLNlLEcVfe+On5KoY6hE0RkDdCQEM0HF+fal6j2qQhQZ2kXXepXXStxH+3LZ9G5nNYa4TX0CQ/Jiy4P3HkvbZNyZD2LKBWISdIgrREhOh7qK1PwhBRV1NHbTsoJI3RFGVz5eS0RJq6x/Zjog0SZOxFA5qAY3RT+pH/3xvr24YwXkOEne0AsrsF8cR7F/NJmhCaB/8u/EZDDIs7FPh+6cwfgPS8AYbN9s4nqiWnkkaolgzltElcPR7rDTpHwRFbbNQn0plIuwGcJUNU+7ZDe+s07PY16y7sCDZn6+BE256uw85We28VSFCyw3VvFdrUI0M0OEIuLYVm92Xn7i2NZXo/1RTh+7FjbintnDwW6VlZguaod75ShYPq1skRlYm/KZ/GZzSR+nphypnzj7b5eGEtjNEGEoEOh+TG2iFKOtJzi+J1GlAhOcsGO+mvfLlp0AUxTQIceJyg3X91fSidnA+zE4YXZy5ECaPaJ/zc2/pjOo2EFgNQbDVIsV0+LQWJkIJBLE5lbRDtHynIRNIn4dn5dK8/hSAYWBvj8+K0b9tilT5vuE7edXJe1AalfRtJ0ASsGVpgjc6pdJ5QXOt6QROcb2vU9i7OYvCTduUSkpOEwMYanLXbBUrwYwAFQVh16PyhLhCsZhUDDbSrqAFqzzZBe9yerZPryTd9irVJaD4/I/O8n19W6zh3Y+uODZlXpXOH8DoqaUT8nKuYj1mZAQc4wu2iGhBJC0LXVE4ztemS9dT3XXO2Dutmc28V1+DTs9ifZyto7qGPby20wz9X8ndGO5B7DokMOSf3Q65s6XdOppLe31Bo5AEqG2BIGqNcHbX1KWR01ea8IG9zaZUGigtK4qKlSNZihpYzQVTq8RqiL3p9/CPX0QwrVZ3ES+5VqwAz4OpvutR5OwmWoGG00k69pB3S7KDnnPNyAzkzgNnnBQAxyADn5EbeiaiylD7urgPwAR26DuDKbpdrvQF3dbv71aw2IQhDc7YOu1/N6TrVbEm7hrQtknaoaeJvTcNrivDz0mAhEqQdmdw4qQmo0AEf3CNXR6Zd4NDYcBB2vsV0J/SJbw9+Ll+d0F89Hyb0XMFB2UEIugCQjkvJp0jSFG3zIe0QSmNNQLt2IV+7iunFmQv3LM4yeYhGKj4v+kPYhMP3S/X1ri8hm4fW15GTwLHWB2uGmg3Axocr36CAEyQogQ9WsDiL2qQWpQF0miJJ65KUiwMlnEEICtCuXHTiXznolr6tMQ0AWR8i/M1gLdHibOsfBQDQnsb0AgXIwIE3FqeoT05jexenkAYxwFochTYoDZQQ29+uXHi/SfosvZ4EAcDmrkm0S0ggaoDWXZgzm9UmaG3bVQyU0KxicINmtWGvAwA5HFsOmsBdT+agzSauLzhN5QoccGHsbjhe02jZXD3Jxmsmqhxu1xINGqwlwushXk9X65jvbBXa15yt4ryKD19db+R+oL4zGJLWppIMua6DZne/cy6k+/VXaqUwNAEi8DvL1aEFlWEl2TZpiyD31SJjKVKSyaW0/1sDeg8rczoX5eoOpTXfEUAynh75P/+Zql0SpiNEGtZJXgAbJ73CcYtz0h6CpC00qAJOewiBF3LO6dVkCCCSntwZLhVkiMMgUoTfSQiT7ORJT2FCJ0UjcVeWYbfLnSyiedxyEVX+yKE2WycmP5B59pyzoeRsywQrkIMdtPK5RRrg4AqCA2IvIIZkTjdERU/z4z7xQlULaeCQmuATtL3oWbSkyAvVCUG6mgZw2FxpguC3udIEgXBz0iTmRRgak7TuJJrAba4gB/STmN5ciee8YJM5KU3r05gxJe1Az9SdNImAvb4an319tQnahs01CNqNzbUGqAN8SEt2BvjzQOckdSdRO9MLPuE3vFGgApzuQSDc9Eyd8Owojd/N5mqTaIW6q7Et62uoLdcgBE0AAJDM56T30y1REIRlLGtrMue/XRJYAaeTQAmoPhx4RjSfQ++vRUEPWggHorq2CT56mNxs/0a/LdpIptomNWHGz64xq27bOMe3bdT006AJKI2vp/OPQC6kKLMY+P7FIqbbNi0X/7ZYxPoXi3Qu1mgeMCHA47dpwt9Nsi7HoERw5STU4VAarpzE/jlZpgfHChYbok8IfSYPv8415H+fHkCGOKhJUUZOZNuhgTRmcvXl5FcpzxhIsqEmipwgj6uRe26cjcrXoe1IjpYCm+XAmJ4+8oHvqnoEitEmc74Btao31Wm8UpqaxmE1NK1fozaU7Jk1QRiQylU6k2gQBNvrYjx9ZgcqN9DF5+XM5wBSB356fk64zpeZnNsA6W6f5Ajb3EZOosj5E5/H0AsRmpv4AmFo5LFRo+ql+RX3JudHOWT2hoIrhHxcWrKxFwJiABBhhAomWM0umY9qFhnOnA3Ibq/wTfUCSwjCUxK0AdeXnE3EpxfEVCwNthDznaDgAv5sGoCtuZTkk4EPsTy53fHpO0I6yePYdLtyob4FSuPrAKkZVlJH4gif9gP+DT976uCf9kk4u2ntQgCLduVSAXyFy6pLYzPC1KQQpc9on/g8kJj+JSZo98r1AZDgFzdQPpROAhRg8zl8XhQyn6P1qAIl4PdBTOlC3WshLZCh7f3ITA6d39Xi6/fW6XlAOGgCvo59OCU/zxU6j2cVzeSa1SYNFoDndXwd+7vg9CqmHU5LplzYNA2vFZsNwBrvEqDjGvB1AHCofifck6RFOYInQ9A5cPiQWnwPesZkDcTpO/f4tBRsQmoraWNvjdSsk9Kaifs347flxDVaeL+admg3pPG92vs1sqemrFwar9fY5EySSTQysIYM1Ty3Rr5OAplUylaMjDmWDAFMoCECAHjF/+UfxD9qi8upPLXsefwj9NoihiQEkLUJml0olZBZOTjZMnjCKRYnaUuk0IgIVPiWdp7Ek66lfldADGlaqkd63pxpgEdtaM1MO0ZB0rBIsfxpvtxwrdUU4Z36kl15qS7qXOlRqSnCJnNYU7T9O96TBgjAfUqahR8FT/jJdeCBLUmkrlWaf4jaIZyWNMJJ36a/YZOyjdA/2NSLhu2WzqRKskw0VWcDNmjeBwbtduFdJZqw5Lrue0438YBNi4ESkvyK6xkylARQwIEWhE1KAEjmPE3wFPFQ85y/qXQgqhT1TSIUCI30TSnN8HvlCoEaRE2GXDBfRyYQRFIHPkMQm8xp5hCpbyUsyIfeM3EWFhKpTkyGFM+u0hJRSJui0rvWvDONfOfr1mokp0ZOflFoikSMlbEZrVFArXmiMOdMQYjGB1XAyLDELFsu7UpTVoz/pjvcNelMu7A2g2o2xEg00nOU+mBqEDIZBl+mH7JhMX0eEmyA1YDhA+hQO7JBLdCOndcaNetNTOfehRZkAggLPlV5cxM0DSrAPQd953Rng9uxke7Hjr9SmmhzUgdDl+aRNE2bTFCQYhtdyJ+cIC2RIVo+TlNNo0KA0miKEgfxVarF9b81ziXaHWm3va+Vka67cG+SXsX0IqSjANyuoxDb07QQX5LgpL92wdQNB1Roz1zwS8FlNbiOtYPFqYuani5qPJouBl5oOpdcT8OSp+0KgQTWUVBPnnEFoV3Neni6XfFl+nxJm7h29PodlYsCL7Sr+IxJYAUcSGIVtTU4eEUvjDrW6KBAC4uz2Mblafo+Q6CEFYR0u4rX2zUEwpdc15KhhBh1oaxm3aUEaB0DMjQbNJ+su2gyve4SrY+kDQr34mAI/u/QLqLJ8G2RyBB2qCZztde0OOeC8O2cC1oJ13XpdUxUKHHYbACcn3PxukXq4eQAmvZ1SGsG/puuH0meLmrMNl3sI7xW4GATOAgW1f5IaxlHmtom/sNlhHvQO5HIUJKnsm/9s/v/NUEScjKX9OwYmvpoWmOml5MXa2VbPPZq5SRJfpf6o9SmGnm3hi8wsv8gmZDBJBoigJ2WKPdAnCMZEdyLeWj+sU3X1I+vA5Sdwkh+sb3iR6fsNwkSweucfJ9Gc+Jc3IlyDlgHt4ypHPtxbTpInAelnaaxOxg5R8LSrgkdC5o6c+3lnCVxWiCUvfSQkPA5TYwnri46pWcDOvgicmOaEiINBN+hKk1R04DD2o4rKDDDSdoH3QkZDz6Nq1sLjvorlzjz4+tcoAUapMG3C+fRAvd7exbb1+C2rl3QAjWbqAFqNi7pH3AAnQ8AgfvIpYEhkqAEUkhq/AmtY752HTVK7Qal11EDpUkvUDAF314OkhYNB1eQ0uHv5F01u/pjul3FYAo4sEIPUluwWR8KlNCuYp8uUBCEdu3CuGw3LnyzOICC7EuUfoCNEGY7NXnzjMyPLRQoYd2FuabZoOAI6y58w80azWXrDXDO+81qnaw5iS+ouEmHyNB6DdD4dbiL6W4D0C7idS7IQjLvkkAMDV77MpMXzkeCHjW758IBAmga50/q454JIJS5/UPQGEkyB35Pm/gOVMEM8CHmAOn6ow34RMkQfl6cP6mf798Gy16a9bIWtA+1dUhrvxSwIVdnCTTQgKRp0cimtajp05z8Ra9j2RL3Lw2kQGTbd/3ud+vbk8GynEWJkpnMGLKUI0W0zJxTHQfpwxHqbDZdnMDxINx0aXQMeu8QMsS1aQykvkFtxKd9J06lANuFDD87vp/TlGnqpmRg0caF0DvX+Y8El6v9mEsfY82Y046x3OSY8w3D77zUJt9XnQOASJCarotBGzaQkhsvjS2YcY0nGCRsiVqdEgQy5OtxTZOkk7yBeMXvq9lgohavt+sukKKtoL9Lr6PQvzjrEvIBsBP63ZZMdFearQYCdumNgwYgccBvNnhn3kHcTY/PhK/3fGmamI4R4LoeKeKc/7slH5jBLSH47zQb1CYcDj0xx4oCNSZOALt+yETLa9yODJxsgy40HUB3AjG9jHW5JfQ0NQApAWg3EPtKPFsnTVOC5H/vFii9jP5cSR8u0kAZWHtHr4W/0TtcoEhti7P4fSxOIV4/3ZIiNmAECiqxOYkauG6ZBs7A/kb+ObY+s9trjYOorXFREwjoeu+5MmTIa1pd00C78/nBgRXCPYzfYkN3a32WDqKmGO9Udy7VaiMLALdo06AJnhg1TRSk2zb47DRNk/rvYKG628T/w3xJtEuBOLl4b6Ix6dI5jBN8nQNwO+LlOoAN7IIsxPsSjZOQ7pEh+jyIFDm8iejclhg4t+2j5TI+w3IZ+7pp+s8fio71YE1Zg5+Xi9K3QWXTZwDor9VaMqQEJnEqzQKQPkdgzSpLcptGnsWgmiOOFLHykV90Wj5Nyy5BI0tr2jUH8FyC24jkIlWsghGY1mSuhErn86Iq0t9H1bOSqllSO1cOeo15WfIiqVnfsUBqIyifUepPjVYs2bnCKnViL45V/XN9DFK7NGORfLBsWdL1XFo6OV2yp0/s73HaJSZt2zJQuwQzTzH2v5CWvxWUzgSM0ARUUJnPJWks0KaLRiLsJk73Md8SBRtoV7FdTXI2iwtEAF9PzBFpW7BjP6oD161Lp/0czplB6WbdIQE2mmQ1DhKzPoC0j3A6Oa8Jn+uUpIFPJ5HQImlqNhAJ5ia2K0mT9uGgAkn6lL++ENq9TAISoLau4j/8d0ijc4Z8GYtVahqHgzEkgSGEYBk4aIJ0Zlbqb+QSMs5dryVDAAAtOvOnPduQezZsWhVEBZloNat4/lByltA6DayQOPyv+AAGCRnqcH34umKe7Tb8PE3lCGyC5n/n6hQE/yRdIkMUzsVnpOZkfgPTuSSoRBJ8AbevQIYACEHQbjxSWQLXt6vfbbqUDOH3Jq4lCnlDbJJj01I+ajJZvWb3C1a3FQCiXEvTzsX3htMAclqSr2rbmrvOfTc+rZENhGBqGKJfo/YdVGK/hMhgMBgMBoPBYDAYjgiT+RABALziC//vMluT2H0ukpc24lht/HRNucqIHL1DPj0kfxgJU2o/coxcw6w1PkUavxq8uy+dfq11hsP15SIASvdItqtSfg1yKuchZXFpCdKYpOOO+IGJPkZjbIsV2iH1mE7GHn7nlf5ESTrmp9HmEr8hxSfbrl040LRddUk91e8Nt6OyyzUR75q1S5+plb8B7BOURuAT0okPER47QoOl6X8T29hs0nZUR6obkV8b/Y76eyUHvOJnV/QDPisp2S3tFHmE6HJNh8wl1+SUd0E7lGiAct9sMrfjdglmT8IRC6LFQe83IYpcLhQ0h9qDLSV/Hu5vqZ6WhmBk8mi1Qx4K35pttvLzqszHGn6eza4PwnsSNUM5OU/jSyTNpyNkKFxmz6dqWIH8ddynQwJBhCykjZI/mSSrYmj8mAas5Tn/5aRozeGvRN5414f/ua49CswXZQ5AR1RoBC/OxI3Lg03kcqo7qc5cfbmyqGmRFPY5sZtm2pGLXDYnNIIv83xNF22+E1Mrqubl1Oa5upqm3o5V01+Z5yx+aJzKV2P+JrVX+h33lTcr2aCITp2T01y0OYC+aUcmyhwbVQ6npW+I9gdThihY5fo2V0bie8CbL7Kmc871zigKEec2Lqa7aJ6Fzd2o6RsABJMuXE+76uQIc0m0uS7cx5qyCe+cmpUlJnGJ+V7a1uB70kWzPfzcsU/jfVKUspB20dSscZC2nek3bM5Hn4kiRtADMUJcI1yP+dM+59qEI/TRfkvuR1H6cL/4fAt0BlOIMLdKryfRA/G5SRucRs/XxfJDX61TH7YQ1ZGQoZAm/lAqMrRG87ePIMdFkVsjE9cNjlqGzMywqZyGDNGIXFIUOXp2iRSlTIhYlpUpfDpU3KXp3N/0Xmzixpl9ifUIcyv9u2BK1ouqV2k+1qtPc5TCEDKE09qNbcZHiz4vW25O1kweo1+O1J89Mzu+QOE5uvT/zH25+sWya3yLaJ1jyRDNW5IjEJJzRnPy1gyy8nwmc9LAkx5Iss+V0gCpD0Vtp2FtSe5DUZRbJEW+XKkdGmifb8wgESbA5ABVzenWpA1JiGuMWs2eBkqClSNF+GPUHBSsmjwUC414WLGUzgoU8s4rDb0d71EsgFNNTnSiEyMUojzSgbQafyLiS4EPpkwOck3OZUnTqT9LvF865DJJ4xDgQpoLE06v43Q6FtJ0cr4MenR6aK10Jo1IirDvFRMAoHevUA7ViEhn8WBfGsl/SfQnEnxyUt+i9H3hd0Z9yHBa7pOYFg/ixYfk4voE/6dkXEjjUxgLrmn0ZMhjnX4rkg9REh4brwtSCG3R/zE9+FQUpsWDHBU+FVI7RB8MoXz6Wy4CnfRbjgyFOgXZIVk7MmHIhbTDMs8Y9ObvcltEMqTxg8n0sypYhVSfkCfXh2y6gnQmUJKhmrbI41shs+R+G0tAxsjS1A+/RNwGYlKTOQCAV3zB/y3/sfnqpKhd2jRAHEy5qF8a7YOo0lSYzUnmZaLquZH7Zy72iwdczmyO62sfxYak3XKhamNCPHIBKDTQmM0NUM0m2WsdNzXme7kIdfTd0OtNE/sNvwtquikddEZN6KSxm/RtJr9issxqhzw05i3YTC5R/aN2Y5O1ioNbfV93yzamT9pACnoR30Jkt6bnqB4L5y+nB31KYwTnQWkUHc0tmtC3btGEtro2altci/K08bwt1zaJ+RQd/0lI7cTEEJvJ8eaMktmYayMZo2mvEXFtJEP967Ht/vlotLjqg15R/jQoSJoNk0gpyl93JaY3V9B4QWNnc9IEkoTTFJgQim3EQO2TosuBQwTYIU2ZczIZEoKgJPMQQEZIFzaNpLlfEoBBEKabhqwdTJvwGovTi0WewHCg85Ro3iWYsFGzL18/TgPwcyN9DgmSaZkGOfMzyWSO5sHRaGvJkPQ+JLMvzfNlZSzU/1x+KV2qT0D1wcBkjWUJntBGVUh2AJ3pHMZQWZQre6SMRNv1ro/878PaJmC/QRW0O+ZhF0NIr9fbf36S3Wx4Ey7/W039ktAmTPpZdssx2pyJH1fXIaB4H816k5rTCaZdCYb4AdXcqyRDuG1ie6X3J5QT8pXS0tiRiCNN43eRaH0yxFMin7j+pI3A51dojarJEO1b7jmccPAsKDVF2BzqrJM1NBpNzykWJKMmRoowh7U1W9O4/jfj/w5twu1NNBNCu6XIYfh6Mgagh4RkSJqiDfOenSOaClwmn8aaJUm7kmh0Ei2RrC0R+58x3UujAxJCAumYkSIPLu+U01gzhCPKJWHJV+k4iIccu/iuHMS0hgxB+s5Tc7qunKZaEc35QBORoV40Mle+v3rnXNIeSGl6rWdJoiCLkmZJo9UotWsoGPOzfH5CYGo1Q5IWTtE+cA5YU0TJRFLKQ+uWNCpD+rnW4oeQn3BgMP4G/KHAAOnzkfY6xTpfbM+Qe2ug0T4pydAcmF5D9Kxv5X/QVjPko9RAcxiWdJ06Qkq78RptkQZzaoe4OrQfgDLQRKkdqp1Gqd4JyJAKlRpHVaAGDamipIM7MwCnAVJNijQ2AVQHtImaIgVUZIgePJsUUH7PSVCISk0R3clL+wpdF96xRBqbLh6eidM9SHUI2XEeSZuh0SBI9SbBKSDVEgGATlOEy1Y4r6uCQSSEHN/L94EG9BDWpK10GHZSX/Nli8EUFJpB8f1Jz5f0EyGE6LdWMBfFIbVFLRFdX8eYkA8gQ/EPKnwLZEhjqTB2PZCQzFM0oA0zh9G5W6M1V9U9g5aItlN6Bn/NJzVkSAON1m0MuOfg6h4CReCHtCnCONCQRtLWRFOkCbAwFzSytQQlETp6DdG7fv978updCklLgkEd93P3S7v63DlG2vvpblBOgN2BdXqXNA05TZHm2XJAPjWubaIgoPG1ob5V0jNp+hI/0xhN0VzQvAP8G7muCtQwtF2lNKcp4szbxmiKOHQxT1VEudJk55zY1qKmqIPEB8ILhtvzjVIijoMaBK3IBl3HgQ+8k3loR/oMnLan5xzq7+8gNV8KeQCwRiDRXLpYduJQ7x8JOcDDhoxlpl5/Pw0mICFoMVzMtw2oACjdf+6eBhZpP0I0tC4+d7PBaaTRWcVDSLEPTzaABXP4KgXVGtHgBSHwwiqOhSQwxzqm2w0JzBHSkF5HGit8mGn8liIp9AffhjQaB/gZ6DOF9DrOt+0qbkY0a5L24LTL0rzIpGchQz0tdxfWDUfnQcFSpMoJXgsq55SEV2ld4bRNkvajRhPFBX7gIGmJSu+dPEei1eg2MhmicsVQrZtGPtLIJBK074FDheZNRYZyz9FVEE1tECsJufdFoVnna97NzGQIYN8mczloBig5PHR7W+xEKR0nHqJurHUclxwdNSZ0tVFapOs5YT1XhgbSh9kJfSAFWMhNoB45UlSrfRoLiThrxkQNKWLyZbVDQ9O0bnHCFZ6jhhSV8ojfj/CsCj8zlflcYjqGAiicbZJd8jbZJefLoj4W2AROZYqUhB+W8js2LQU9EO9dKerNCNCS6RwAANZOpNHn4vWFFIxBqD81q8PPHdNJUAHxYFg+TdvQ4neXIYPJgbWCyeQCBdZIgmyIB+miPEkADb7PKXkN+YXrrol/u6bJjCNhbGvDYUuBYOYiQ/g6+q1Hhrg0guT0PrGRDGpHpRyBn69zIJp4aSCa5wnllEgRSbuuSw92zfkLcVH+SJ3V2jGNjKZJi5uMm3K6FHWQbbYgvwLkyRCXFvpcNBPVyHcYNM+UZptD5Jg9YHKTOY9q0zlpcsvcW60q5wIzAOjM6cR7y+ZzAKBzvk9uGPlaMqZarOlcTnDmkDir8oEXsqipi6vbYwqzOe6DlAIISOMgMesq+y71oCHMEpIzejKmmphsKvqwZz7XMWkgBEozeWueT1Lva8zn8PUlDgTSJgJkt2xD292iDeOwF7yASaudbxMTKty3wrNqkJBXdLmJ46sfUAFCOuQnJnP4726JNMv4jKIluR8/dmIiVn6MRhhDyRk7ySKM8/NlukW8X5VuI/kJZo+eJLTlwBXdskkIimQKmfSHMD+o+gw/NxlzoR0uPkPjIJjG4TRAms6SITzfoUBG2YhQXFljyRCXn9bHoW1jHjQ3NE0TZIjBJnU5kzkuj7hpJpAkTV3SWpwL6FAoP9cfPbkr+UYVkeQ00PYrNwdr06F8sqaXZAD/m4TMGVEsJCIkndEoPQc6+0o0m2uFcUPbqVnbaJskjNnUFvp/Du0QwJwaoikPv9RAYK/JTpBmV5rm4dR4idYJMeeMyl4Ml6xgx5oQzD3MwXPxc2NTCnr+BDatq1GJztHeUlozJnLXmedTB5nA5Wi+C4UGSvQTy5VVqymaigxJ40N5v6gpwt+dJABCX3NUkxZDETtk0uaIORwynwtjwqF3lumP5LvHrzUhEoo09TtRhG5OQ2LH64lmI3l3Mdkz+fJy6YYPHtCsAaVdNCNbO3kexNrAUyEthQInATbEgBtSQItTYY6X0i72bdL/nWOvNy6+762JHcqD+lnSGolaG41miAYokoImiGtpeW5wzkVZge6Kc9c7dAilZPpO6xOsQkZricYe+MqliezCahCw1qXnZC/NtcO1RNl+Upm4lTV2ubaogieU0gBywISpghEMgYYMaZ4bQKclEr91ZpzR9L6xLzkRYTYNEUAhBHetgJrcmvkoKfyk1TkQd0AkYVRzOrPGH0bQQKmckBUDUlNOttzcYqIRsMX+GyHkS9BqhzSQnmfT8eOGjKFRQSakdki7nbifFOOsNyaksVyrKUIQyRD9u3bBkfqyUlOUBjnJaA8lzU0t8PyycbHOzgXNXeOcqC2W6hZDSwskRNM+Oj6SAApCsAqsKUo1Tei6YuxTbZAPzNCuXRpIQiJr+FnH7F4mpIW0MakPf59SHTEpaokqNUONi+O22biQj44H6UDWViLtOFKiJExntC7ipotEhqQDVyXSIpIZJJhnwnWLUKzJak2RJvy2hEpCIrYppzHCZfp5k268aTRaEuh3p9DsjXq+qZB7P5o1XyyXri8KLZGWDJWQaIAUWqIhAbFyATVC3RNqiTLf9FzaIYB9+BC1TXlAJaY8bZysxjqAAag0R7LZGCPIDSEPwi7WIM0PA6+FYJ251YUwH0luhw/3h7RLh3e0pHQtFLuO7N8lSG3PpTXakVJd9D5uvGvIEFLv9wRujblnpo09rYfm+Tw0gRzoeJ1CU0TGZTAh2u2+B63CxsXd8q5ThZKXD8pN+0XaqS9qjahW0T8r/XZcLC8GWkDPQN9VZo5JBGnBL4s1ZXMQgh0kwQNyWlLFp0l9ZjwJaHF4cxQAQdJENV18tkTzgoMnbNJ+ajdd7E8UTANrqXrPxwXlIBrCUHdHrvu2ukh2kqh7+H2QvpPIULPuAjFLAiisNmHV15Kh7NEEOM2tG2PIUOeiYDmWDCkwmgwByNoMnPZA3zM+NFXyMxE1Rly5vd+FfpJ8X6Q1m5ZL664kQ9zfvXto/aU2Svlpm3J1cukptSW1ZCj3fLVaopLsm5NPxoDKWNx1Kc+eMKuGCGCnJfIofaAKTVFRZas9uGsH1cFZ2pDdlTvvRdYtMfMcYyd/c+GA1eG3u8qPYo5gCNodCdwfUluSRbvr3wPQH6NSPw99v+LCRBcZoU0ajU7Oj4jaEGNovgUOlQRG2hQAYMgcly5oihqHtTMQtUbO9b5l1YG0Gkj5qUYIa1a8kIrzOICgVUDppovak2bThXfcrjtRiyBqqEjI1VB3G9OuaWJIbRydEiBqhByaX8hzOsU0nPgQJcJHTEqmYDT8tDTPJWncT3gu9H3mCYVvO9VQYYGf20FGfdA4iFq3Lr4L+q7Z/hPGQJImfSYF3Ei0RGcxgkViPiqQIbVJdm7dCGS+ixs2dG4LZEGY8yiR6rj8Xfy2cZoCb7yGSxXf+lRaC4kgSM9Bnsm32TkXNQGdi5oAKgvh8VrSGElyFL5OiUXy3nVECEP1DjS+WNI9VNPDPasmnStz+yD9Oug9HtRElOk/t+nSd829d4BxWqJaZOTN7BE1XBmV9GNO7RDAPjRESW0zCMwUfsdD+geQ7szsdl3wv90P6WTOmRBQNpsTrKU0x8RpHTXlkN/GaJ6qJ3/8LL7PfNuG/qPPikH7WNvPJY0W90w0Xaspqvnwad4gsOpIWBJ6G8NrisK4dvJz5Noj/TaSDPWuVZad+A5h4Rmnid+Bv2cbltuFexMNEg5nzaWlMcX1G/4eneIQThf7BIcObzZdDCmu8jnpEi0SRtO5qDXAxKuDMOZSTRi5l6ZdzNNs5DQOr43DbgdtEA0f7fN0pN9ybUHppJ+olgZHmeuAD7GOhZaetg6V69uJfaAknyn6LMIYCED3Je0LWp8ukKaWaoYYjdHkZIhLC347of8aEognR4YAoBe4h/PbzQVm0pAhb9lC/02BHBkqpRGqz67h5lZH7uM0WfhvTqMU3ksziAxpfg/lkTULy2xiSHWNtmhEVD41cmQIoNd/XsMjPaPsJ7QJ49V5wtI0opKhGlQ+o9Bq08a0YSbsP+w2nlioSZxGKzMWimguYthJTfQ7SXDThBwesdDkyu2FRmUnQyENIL8jXK+ve7PRPV8tNMSkp8qvvKe6/yvf0RjiNMR3CZeVy1dLika8R01o8jlIURJeGCBxKsemQ2KwBCkthPoWA6o4SIlX4lQfyQ5OR1KDz+5BC5IUzMUR8z7J2R6AmMx17HUp1LcUqlsMZCCGmY7t6ZEh5hlwKGlNOvVdkseG2GeYvDiSRuSKNU10TnUOVa1pZtI3SR689uD5CD2o8J3NRYYSSMKhcL02xLYIIhiyAvSUvitUONSQISkQACaHG4VplJiW+ltBHHq/ZdbfgcgFdJDID5d2zpFw4HGuTU3IKomRFJxhWyl/T4kMkXKdJC9qxvsYf50xMgqAfgwcIRkCgPlN5gCI2RyGSvDJnEit2RWRoHB6EwMvaE3opN+mCgyQe3VTfRS1Qj/GkH6qQa4cjSMjRu1noHmfUn7aj9JvmrolszltUIUkz0RjUSIrUhhRgbiNMZ+T2t9z+pf2XTTPj9uqMb3DaWwC45wqMIoUXU4cM6JJZVoXNqFLgyvgIB04v1AuLlYzfPBrx2nJFEwgBSrgd4KHIR6ftEiizSvBCXOCGGKdtCkxq0veHa4EXZaCTiTkvROuowOgpOhxFBoBae4w2xJxkCAGkxG0RFOTIQYiEdKuQZrnwKgNDa6Z+7SyWIWWaC7MErQhJz9KZnNjiBAFfu94DVwuYxqZyDWJqfxEygat7DrRNzW3uRzAnjREqgfJCZJe1d80/ckraJta/mPHqr0kjVS/GhUfvjezI8vW5f/2KJEMsc0kXWpvqU1cGwB4Yb+WDOHfqMlhzXPm6s4JhbUHsWFo+z+MBzR+tM9E68u1B6OWDPnvR/PckklFKY3DrmvIUG4cSzvVXPubRm6zFMjEkZ19TlsDkO6qb4R2JFogXjPVM9cTUArgsNUUoe8p9L1LzbKQFoI16UPtc02zFbwFApJoilDTE/M8NO7TUOLxvnCvA4gmX8Bqu6rJkEvvFUOYY1NHZuyFNuBv2v9G527ObI7Lx/YL06bMFNoI34McLp0nN4kWlBIVZM8vEvPcGoF9q7BvACL8sRiH1hQyJ2jCbCf5FeILt+7MRYbo2AjVppqNbNsG1RvnhqzZWBh7HahMwbRr7dxkSJK3NOlc3ZL5q/B9J8hZGjmmPyQy1DnAgUPYsS4gkYcl+VfCgH48JPZBhgAOYTKXg1bDMgTix50Z2KVyJFWmZiIZY6qlnVzG3D/VQpHrIyy0SukQcz+TpvcG871uey4STUv1+b+HphPbd2kCrCRnGEPIUC2kZ6hNa1AiiKAgRQDyt5QROETzKUQwej5DLBmO5KTpsJ8OKQfn54gNedZ0Z1/a5edN96R0aiaYEWqSCG8dSqPridkbyoPN1QRTN1GYF9qXJUNsno6/vi7n6f22EdqkOPdHbIfQ14mfkUt9i1I/ssJzt+jQ1BYRoCSt3CQp/eah+E5TU3RpHhTW4yHHcewTCrO4JDqe9DwaPyKVGd0Akzq8qeUKaU8WJJI1lAzl3ABq06r6hHVkIvM/AMiTITatI0PxD0GMl75JaRzWpnMykeY5jxB7MZnzYE3nJHadEWyqTeekRyxFBAEy8KR7MYRTsVkHd/b+kaprDTIRsViMMZubG1P6mlFNiiY/l8anO9P36cuvrStXn5YQ1Zhn0mcopQHEsSEe4lhCSetF8qj6ne5aC+/EtW3Q+ri2DcKpWzRRw7JoIulZkDpwOZp7vZArpVtI7u35RHGQTPqW6TfTJWcNYXNEvv9d8l6EuiWTMampQmhpiXikWj9gr9fOcz3fmU6oQwB+TrdA7z1z7pQv12GCohkPDSI9OA2IWDonpiWNtsbHr/c3FpLx+o02ndgAAC7dEEiucwJ1R/P3tQC99Zpbg6fWENWYxmH5YJspn0dKLxbpvBWeIeZpFgu+X/A8uVikMlONliE8Q1nbpAuaoJjTNLIcxtBogjnkTBBrz3CSXEJoXzDvusFR4xYL4pvvD3fDWqSGHzMaaORaKtNo1mYF9qUdAjgGDRGN3oJfHp7A0NlErOlcuJ95JM3CWIhCx97LXadsWjDdkSdFBfnQCpUSMx8qoOYgEZMxGheVViazO1S746HZOcGQ2iQ5rYpBNkbsoAwhQxgaEqwZR0J/iWRIM541Y1OzE0XbqRgLkomRqMUQNTEKjU5tIIdTvLPr+PSQ+QLiMzUOaVQ6lHaQaCu81ig5+8ehvul4s0SaDvXj9bRzEEJiOxdXK6oZ4jbR8N+JRs8BG8mtBhLxT4icoIESNEUpoXF8GmsK1/w3Jo3PnFmeClMJk6I2l09rAhxJzvV7QQ0ZAsicucTPQ6JWSXGQbbXGaEpMRYZq5zFFHqk9pSANk0DYvM+aUkrEN6SpDM2HZ2f7RitvlciqVL4H950cobZorxoigEyABQAdGSAfsCr0ZO2uwlTaIgxNgIGp7ZmLbarczdBMTlPZRWsw1SKtRW2QiDHtK8XvJ+1RBSDIobatiolUZe6maIN4rlLtc479phT1icEVpHI0wP3VtpFw5TQJgrYqoKAlCpqLZdRkuWUTCIRrm6AB6RZNIEOuRVqPRdwVpNoxLg3AECKALQkLhAb4MSZpXOmuaMgPkQw1FdohSbPof8avlow3MVACbS+H5PtB2XFfqEwlZzp/SBH4IHUYFyJ1aQ5vVfiHNJLwiB3Nx663tWRIs2YK5ciBASrXJI12bKyWaA4yVAvp/SdZ0HerqEvdX5qATpqgIaK2RQioIJxFpJJhNVD0qXojFiPz7e1TOwRwDBoijFxIbg9/ffdboi2SgixQE5vSSxqjLZLStYEYcg59EqR7pDo2XVzINM6Etf2oyTMG0nPlfhu4cw4A9RP3KM3XNLthaoxp6xxtQFAfJFxCRuhVpRWCjhj2WxOwQQzGEJO12qREGO54IRkAwplGvXZLIbWxb5EQgjsNfy3kweVzZAhSoV/SyEiEQXqXku8SAHn+yrHXaOoWNw0q2y1phsTw74JWesi3rJrDBOIyc5htkQyNWYvomij5Cc1AhjTXZyEVmsi9tcGpMCSnfUnbMIPDvyjTjYUkT0n9lbMmYiAGVEgsqxqWbIjnGglpcjMv0+ageJ5jwd41RAAFLZGH5GQm2VYCnYyECbgWtdoisZxdfudkpj1UW6Td0aPXufrw9VxaqkOa4AroncI8Ir19nHy+HqT3I6G0Q6LtR6lecTeq6f/eNOM1RB617x9dbzZdaMf2gMhd/q4r3pukhfarnnEuAq7R2Cmu98J+V0AiBhISjVDiD0TGLtIOYU1R4geEnx9HkhWfX8ijeHxVAAINGZLKF9aJnp9Q7dIoaYowhHGkGRdiuyVyh8kQvq7Ykc5qiSRBXzDFcmJAAC8ApgQp8RnC9TBrCxVfimQo51PCvZtMP6jIyUREiEJc0/zzdZ0sW9T6UHkZyHVpmoLpq1EEDj9DTvDm1uLeu62MwCb042itGiZD/hId274PBC10z3copAVt0QiorKK0mw6i1pK/vm/tEMCxaYg86O5VwnpJk/FAmVIFTO+j5g+1i6ViF22UtmAIptIKaFSpquaUd920dr7V9sDV2oZKm+cxacVubnYnWztWfT58j5Qm+cNBol1MJ0JM5t4knakzRNuiEyuXv/QMtc/K7fZ1Dgl15F5BA+x36Zuuq0vjA4+xcznW8uK0c8E8qnHEuZ76DeAocbt049L3mLxfr9XZxHITnyAnHDZKrnO+PFRjEohCB5F4K8hQL7w6SgdoydCQ7yE8cyyb+lbhcSQdyqs6oNdjg84voppKvPGAj1JQbD64Fm24cPf4Z/ECnHPRVNML7CFPi/I0PTK0LbLh10WytnBzeVZDU+tgf6RkqKoNU0E6pDR3y1gyVMovYZQmcES96joU8oi4OdrGe/D3g4OyNO1kMqOoMdLKsBq56oh8iQ5CiKqYHzcwfJAFFGihyoRuCGp2PyRIg2WICd2QQcQNYufSENZUOM2lJVSSolFECO1KJra49DdFWdXPKQHfqzo5XHCQ1bRBO/mPeU4hf3YXuVTOGNSUk3tWTZ8k71LYZZfS6w2bFgM2oMMypTTgtFC+WJfkSwKQkiJsfieZZSXmcJLpVuy75EwjKWy0ZD6mASFDbFoIZFIkQx7VZ1MJzymYt+F+l9KN4t2k7QEepW9op3UOGl8cvEIqR+gHle/QiEAKabMH7FzXtIf+LQnQU811AlRmeqVodr17hTbPRYY0AraGlAwlLlIArDFlAsj9JUVPpMjJvLAb41iu5aLLYdSahpN0ddh0SoQ4FH4/hHYIAA5jMuchms5JfjBcGkD8yEab0HGDayoHtaQexSQ+pC7NhINR66Ap1YWhWCTGHdom3KsI89g0Tah7UMCMmoMBpfCpUnm4XimogCaowlhIgoe4eI4gXgozuMlMA2tBzRdw2kMKSb5oI1FatHI5OA+XbhuoOusJjxs8VhZpX7nE7AL1NQ60IJm9SWZiSb+gujTmcwK5EU3mJH8j4PNgiNom+rfU7aXAGcK4cW0TviF1esPMH00Mwe6aJvoJORfa3EgbXcpoo2KkyMQUDqeRuRwm6ocKpKAxFxOQXZvG+O1MpCXyUAVdGGM2l4NGyB+hOVNBQ35xntq69tFfCrksqVsyl0Mht9n1aEiaq5+OJyzfYNB7pLVzh0ORIYBDm8xNpSoboy2SNEcKbdJkDnla9eMcUCxAozQYGMJEVUUsqclSLh93D8Lod8c5eEq7TBqNkLijVyYZ1doaCsV7LZIgbMqlVZXXOq2X8mt2pyiowFizE67RICk0OWJa0ghJ40wSUhOtUfp8aeQx1Nde64BNuhwxe0vMvnabCw69J+dimR2IZnWJ+ZyvnxISyWQOTR+sL46gDUrDYRNhREOGkjqkNP9uEu2OeAivlBa0fkldQjuDSZ3jNxSwefruW2A3IZzjy3IurMWu65B5Xpfm93AxT084ZMz/tk2Yb/NDHW55BjI0BtVEpFZLJIHkZ9/NRGaEk+3dz2UKp6q74nmIVoiVZYXACbSuqdKs9ta5vuzIvXPN2nxg87mDaogAAF7xrG/dJlpmssTQCuK12qKkDnSvRIgy2oZJMJW2SKMdIv3Dsn+88NX6B1UuGroQnSOHa+37G/pecb8J/Sz2OUDa1y3a8eF+x7v0iwF7HIp+r9YIacrHZVYGTFBpxLgxTHencs/O3b9P1PYnhjR3LOOuolpTlIw7rBGSdmLjXO7raBykfii+/A5QnugD0yNDodLoP5OOvZhU+Qmp1xP5pyI0n2Jl+aIGTNSkCRsU3MYC3r1lhJeE5PrfhAANbo2IvBTqWxN6WDgnZw4tkVoUmpkMYauFGvFsr1oirX/VDD5V1c9ZAl0fpHl/ov5SkVdNXXi+TtbJGfQcQ46fqTlqZtfX7/r97xnRyPE4eFCF0AE1gq7fxSoNeo22KMk/0s9oChxQW1T0p6kNdYk1d1NhpvOZ2ElqrBCsIH4qR8WgfUKCTE6TUTM+Mtqg4BhOhaeSFkjKk9PuTaUpwsh9M5o+KmmgpGtD01TT6AUj6miP3guXDvf78vFY8poitw2IwPkV9YMwdLEOFEQhBGDA7UP5fb6QJgEAJOTIEJ+W7q0kQx36t2u7FJhBlVYcSBvyK4NsiOOG+95Kz4uB57rct0HL4oItdB00IUqXi2sqzg8Qr3doYygTCCFeHkGGSB3YaZwFtQIo+fpOhNoN1snIEEBZFpuKDAnyRLXlzRg5Q7HWqODXtpwJ/w7Fd1Ub1S5odxXyKw77rUlLxUjvyH8LNTLjLu+hyRDAERAiAECdN2Bi0UwcjTAYhZ3Pg2mHPLSkaAZipAoysI9ILDlQQltLkmpI0RBgwiOYJkgBH1TvvrIN2t84LZBKM1TbBskP5ryQIpzWfC+V6Qabt0nphHQIacnEbp3uukvBFtKzjXiTrcT5f83nEcmIQDyqMCUZQkiJHG+WpkoLARSS/qksc5I5QqthHaE5T7XfcsTWGkweTKHrYpmSk33OnLJ2vHKaf4JGkFc0abGuoX5Uguk5FYiTvyXimJRbpxWqxhRzuxaazXzthn/JRI6SHu795YI61KQFqCL1AuiI0Awy7BgcBSF610ffMm5AYki7BRptUc4e81hRsyOoMSeEOLnhf+EeafGowRS+RADDSZGG2E5IcuXdR+EdaAkxky6SBGFXU9Q04B0fiZBLO9Q5jZCiTyYjRYeGtJuM0ljzA5B5rlyaKasRTZGIXwY9v8aXte4iWdgI7xwI6ZC0f44ZWyEP+r8j12hegPz3OZYMScS3lM7VkdtQ8r9tXNScadO031DR4TlEs1zSh1z+3d/hvfUcqUcIldJBrBQKAX6QmZbkA5pbz6aaYyo1GlVkiJOBhP7Jrk147hbWqp6mYAYTOYxJNp9rBPHafuNQaeav0gpJ8s5AjU+2LIBUA9b13/+oiMuw4wBHgKMgRAACKeKELArpN4X9oryzMkL7MBWkSUbKO9VELTnTYY0GY9ZTHbZS2H2clBQd4j0KRNOhc0Sqw82Obc/Iyap3XbMAJuZRdaRu8kAL+4bUToUmR8qjCqKgqLdHirjQzR2kfijeZEsgEVL450RjhPNIxE8R1roXIjtcL7xrBRnCJm/Ze7REx2PNp8XgCLVpHKjCxTTbRoD6zZ7SfJBDbfRLBVFomI3NvtnXBJYLkjwyFpKWaITGqFTGYA0RgTrQRAUZ0grUg8mQZk2Y0upFCk6AII3holYouU43NAa2u3LzIkHON4qbG7uu5xd4LGQIAGB56AYUMWYSkk45Ro5c2ME9vfdISBG2rfaH3QEIqtI9kCIfEajr4sdL2xnuVXyg2JE3XBLeiQY0OIci/DauM7RpLnATJGpfEgacTuQNejYfPMG5ZIFz4s6R3JcsoZAmt6FjLCdUsePI8f4JQrrpXOq0z5W/T9AxzfhjJWe75BbtUh7peXH/bLoYcMPPJR6bLoynZt2BY4SqIGjjwz83Lm6poahg+PDcdt3FoAnoHeE8TediyO5MP7DanoaMX0k7xIHTpnB11/Y/TmPtGqoX9yfXBk0a/y3mKX2veH7Ec07TpDviLdES+d8WbTTBbJoo7DRN3Dhr0+uBhDetGDQh2WhjoDIZw2UNJYH72FSZys/2UGRoZq0QzitGseOeXfsdSKaRY6DQColjWKMVmkpTVsxTJkJqcP17qE1LAUejIQIgWiK8I8Olp+jIWptctgghL9aASGkNNLvxI+7NntXEqVwlO+Ipd9B2KO6i5KAgtOqyBqC6X0k+Jwgmpe9jdPhtDtJOKX1GTgNWO07Ffiuni/5OdO6YYcyOKk96t/j30vzI3bODqCkCYP26emZ0/jpOc1od59L8mzguYrAGYE3pGheJTJLG5LFzAPh6aKNAhgqCkYoMAfTN+Zi0NmgCK/BXagGbkgCX24QIZWfGDVmrnLRBId1fqgNB9AEaShYkkzHpm68hkXMCO9Zr0vQ+gFS+kPq1AqJ/kP87ZkyvM0QDl3WQAMda80iNz174+biEehHSukLzFMvJzztZVwuCd33se8v17REHD7vN4RWf97ppC9Qwf6EbuO4ZfaBnoU4RGsdRabECiP2gJURsG/gdi8EalhHDb+zQZd/dGII0R7/i9+zDbDZEbY7JNm6OQrM5OjCBh4aMFLQ8/cYh8wF6LZPWPLdY15Dd5FCxIOxpAlPUEkcJmv5ZMAIVgHgAcBKeWyozmZtQmb4Ol55n49vQ4OsOUg0vTgcNEqpe+MZq/YZEQpTJj8ODhzTSkrHlaa9LkMpGfSzO/VKdHfOsGYIokmocqAMftJrkZw5mdR2wG0HER606umkJdM2cGozlw+wQXQDKpngSVAeHbjMW800haqoCSEio1QApglJQTLLBOoWGSDMXSNA8gzJISu5YkWMjQwBHpiHyeNfHvjfP3iXUOEdSCINAGuCTDPwptUUa4Yo5vLYaJY1Grv6J4TU80j+ch0vvBRoyRH/zu+V4UcXmkr1y6wTxXuCETBmTkKFSWaW6sfZJowmRAkTkMHb8at6BtEOXe/7Sjl6uHaU6aDQoFJKb1/AArwVyLvEzSrRGiWaJF6wbpPHZ3iON85ichQxJO5lC/iQtzcc04IhPU59CTXrTpeVI5GEIAZM0PhIZwgJX51IhEZ2P0mCS3aJzUwDk+XC0D4dyAzSzcz0KhzDRnYgMiRocbnxz43CEj1AJ2TU7984V7ZqqjaOg8RvSYKq1rOb7IMEWSjhGMgRwpIQIAOSPTDPZDXWQE4iCZFo1y2GsGubvQfumhhRRaAV3/3utCd0BJpvqMKVjgJ5PNbFyeWi/5vIqQUmB6NA+NTSCeW26Y8aWRIoyTvzVGptaIldCrfBaW0/h3oaax0k7/euy038SJEAypVsL74IlH4p3mGgdJiRDGFy/CQSokdYbKarfWjioVOj7qrlAsx5UmqICZDTJrE9kaiLFQjBprjqoep+gskFteo72cOnKIA0eXBhtAOhvmijkMvGcvRGoWrMV8p/UxoORoin81KeUuVj5RJARFXLEITbMh+AoTeY8XvGM/63/seMBTv+eEkK3iI59GHM7vE2lNsYTgXCCeBEaE7rzgn2Zy+HfpTrxLusIs7mkidgxWmi7eF3KM5U5GAdx0S8IIFizRkzp8PMPMq2rgKqvSwvPqAYwY4IznWN+gwUKqSyZ0iX5C6Z0C/IePJ9dNHFDZdEG0uGahk2LUZumJEOezLXCPbUamBKhaZo4L+M1jQbRceh9KALFqNuC62fa2HAbETgfXjuwuVwnCE0db14XxgG+RjcApUBJHnOQpZxJeo2p7dTfNa0T9w0XGCWjFWKh8aMhMhh2JZhatCzKFPTbGejvozrTaoQZYgLp+605t2uf5pmieTvSZiXZkXvJbj571x/+f+Zs4Sgcr4YIYNtxdFcCv/jNJt0pltJDkNEW1eRPUBNuM1debgLjIqZoSKPmYFqNVgNpi+JtR8u5U0yw41/tO1QrRGl2egVMrhEaQ4Y043PoDrekNSLtnVNbpiqvdrxxpmQaU4WMFk11TpGQJyEVQkCF3u9AtT0xLYbpxmkX/2cDLowhQ0Tglw5nZfNL41PqX7qOcemStsm5mJaCmojmh4KAS76Xoja1I6RgAkLSoM0gkNKlIAPVlSq1PMekDfJpeu7QvsgQ+lvUMO0TzPcya5sYU7xZA0aUvuXaOWAo6MZIuN71NjioZuiYyRDAkWuIPF7xjP9tmxjLhCfSAAwue6jjn1T32Em4JMg7YVIs7RIAZCO7HT1q21hLiKRd4pBGoVHx7jwnEACkO/i1QsEhtEO1u7tDNUVSGRlMpTUqaofGaBkkcG1XCnDJc4u7onyeRAvk28/97vMIbYj52ctsGG3XKPpaS4ZwXcI5SGIdoS5d+cXruY03bV4Jij4QfQxFrY9gPjVQS7StkqlzDnFln2tSTfsnkimqyFBFdLVsOTNg0jOTtPVIcyHGmCALGg2R5t4aojOVZUSlHPjIJ75vmnpnxFFriDwC6+66HuOvGvRjNEfY/IRLS+BOjS7l5+rm6uFMGAZMAqIQL7Uht0NQKIdzYqxNz46B/ZighgzROpHWrRjlpyXmYfsSGOYwldOEc63VFEnfu9C2QQEZhDLymYTvmcOYXT0tAeCEW6ztwdoImsdDCqZQ0iSR98S9A8mHpXiG1gAyBB0icRoi49uw6fg2SHO05vtg51lm3ufK5tJSyO8xZMg53pzIEfPyoYKYRiitQWnzRApznftNs87Xzoel/BVyhWotPWIyJNU5WFaoDAIwBtn2FLX7BeueMc9R0iJprQ9yfb2nPp4K50JDBADw8P/6WkhCsTLAB3pW7SbMuUNUmrRyQmyNtogrl7uXWeh7Q4DTEEltqNklwO+v8C5z2KuWqWQvLvVjLSGi9QFs+9AfZIkJ6WKBzCUqd7MoJIGrlHdq7ZAE1fkazHUqpNXsuBNwWiN6yGhy4ChbyND+qpyexR1HnRmQ02jdvEYyuQ9/77g9fU1R41wM5d1B1BpJ35gGbN+h5mvIEBma4jk/3HdAy+QI1ZilVpp7pJDbJcJd2BAAGkJcIkO4rIT4Il8iad7gtETksFZ2Q2hoP1LSxvibNIvFOCF/zJrNYYBWYhAu4rk7EvAY1FiytP35LoHyXYjyaUkm0miLPFxXl18DjZwmWLj4+8+DdgjgnGiIAJC6LSMgDN45kHbT9oWaD02jlQKIzyHtJubAhX7M1cNel0wlFEJ1AXudkLW7yrVlaaE1waHEegxx1oCbJKcS/jBmippVvI4gaY3UPkhDyVAtcgtXri5JO1BqX3If/t5RHiY0NwD0D3TNvbeS1mPjgD0w1dc1hAxpSEWNWSTpY0kLJmoopT7JPhPxKd391mw6vk6v4RL8RMRnDg+GSTMKCiOaXZIw3FpBTjtnUWuOUC9vYtyQNtPjGqoPBwcY/13vY63TRJELzTlnZIj61YzVtkvyoe+vwobfKE0Rd6A7Tc+FEX13XsgQwDkiRAAAj3zyX2wT/uUwwrVzTpUWiRGXnhqSHXhJfV8qI4ehpAhAXqiKZiUk4ILHmLQv2u3RiVMhfFQHU6iAaNPMgROcpugbrozqCFcKciMtNqW8kvCIMQEp0qaL0LyTqc0NhpAiDvQ8mnBfgRTl8nDtoqSpkG6ENIsSGSreoyeLUt9WjyNPaHDeJDR6ZRqXs0HEyaMXWnnGOVYInlA192n85SQCJNQZ0ruzYIrHbwzV3MwVLbdUZ4XW7VySIS49BQpaNO46139YLk3vFWQILE9x15PCB44pel+pfRkEmf2c4NyYzGE8/Dl/Z5uoUQ22TXyJJDw0DhXJYoyJ1hAyI+4iKEw4BoC3J64Q6qXdVIyhalzhvSVFa97hzJjFXM4nucAKmEC3jSwASOVjlAQ6KU+NUAjAExvJZLSkNdWYz+XKkTYlcLumhKY/S9oHDWrNG+jf3qyjxnSOXBfN55jd+iTgAg5zTUJel1AM1w3AkxTJrE7KD6DX2pJrQ33SxHD5Ffe5tomkh45zjVBcayLLlFk0ncPXSmZzQ4DJEGe+pN3gQRuruBy2jbVt18gLU5jLlQJVaM6SOlbUfCs1JnP9TEKZxBxTKH+QzKKQh6Bpo9xRK3fV3CetETs88uj319V9BDiXhMgjIUZDbCe1kdD2TYg8JKGRTqxzEyKAadSx/v3gd6VJUyhJEkB/0cql6RkKtWUESD5YmvfEkSK8M9k02zGV/K0kRPg3TGKnIESle4ZEipJ8ImpIkaYvaurXkH8P6fut1UDUYgwpQs/pzylqOpeeWTSUFAnvK/EtyqQp0cG/x8KEdyUK7tAvI5t/GBkCUBCiXNspiSnlBYDeuT30eocI0qaTfRmkAAqa772GENHrnhS1TXpOHm2/BEEw7RGgzm03mrAwyKX936hdiQWKb1t84LTNGmiEb/9cNcSIO8NJufF6mBDarj8eJR9kmq4F5yPKrTe0zzVrAncvKWeITJK0O+ePnZOt6LXSfb1n4+fz80iEPJaHbsAkoDaUWmIkCNXVQRnmAhUg/MQ054G0YluED6cGkoqXpksfI1WFM5MBNafjiEspnfudJUK0bRQlE0P/W8jXBY2Qcy4e0NrF69uyMsISVz6XLqFHypl7JW3PUEiCrl9QpGfGY6LUF7nvPCdQ18wPmj6Zigz5+0ukiD4DFro90dh0STqQInzvpoukCN/bdSkpovfhvFiLIqQx/HWRxOTG+IHIEADkNT1c26Xrped0Lv4t+QNx5xqVTIykNuaA5oTksM5kU2uRkiIPaQzjyG6aEP67tOjLFLTuWNgV0uT+yTRDNcDvsESKNJE7pfyHQMlsPjdG5zLpHGuZw31zSTF6mSQtV7OuKGWu3H2XCOfKh4jikUe/X1iMFE5nBaf/xEcFLzAazHFaNgCkZlLIt8hfLwhpJaE/wc5mut+GPQwZ+p5K75K+P8HnaNIm7mvXTCOEcXlqxyy9d0ooFmKVP1hJ+NAIr7kya36XBNSxfZgTmDUCPy0n5wwrjRGmb13byPVumMUTz0X4Z02/Mc/ZSGOo1N9Sv0n+S7VkqAKjIhDia6XxJvXVGpmm+bbQUOElYiaB/j40VLbgu+rNhsWNysKh5yIZks7Ok9IAqY/TglkPhXehCvQ0hJDQ4BkFAbxYBsLs69xUfj5DNUNTncnjQb+hDUP0MaT3Nldwhl5ByjGCZS+5UedaOwQA59tkzuPhp/3tbWKoVkehEkxMlkqocf4citwkqhA6qyAu5EeyiyBplKaY7DS77TS/B7vzongHJbM56YDWnKkYN+bojn0JkoDI/a4R0MIlvm6VT9++zOemhkbw5n6XoJqXFP0pXBdN5sKY5AXSno8QvY+OwbHvQTOmJb+hMWRIQVKLB8iWUPuNYgSCjLQKY5Z+VT/z332VL5Gw8VWzllWRIUnLnTEhT8z5kkNmO3VbR/msDIGChO2VDO0bijWdXX+GbHYPfW+SqV4oVtocYK5LJoa1yMhXj/zRDwwr84hwrjVEHuFFDP2AJfbLTcBDdt579U1QBobXFlGNEcHkZoB70RYp+krSKOGd0Fw697smD6fOBxjeP4lw1d9hlHcEM0KZNH5L2pOS9qWEjFBUWnDZ3zWCA4djIkMYvZ31gW3RzCc1GgrSJ40QWY4tWzqUVdIUce3RaI9y2iFab4fSXNs0O641mhwtSmOPe0apHzYdPz9JEeS0fUzboJ0/JtYSab+NJET2oo33LRaxPL+ptGjZc7V6ayjVJvhyMNGcUsOi0BIMRk6btw/ktNZzYwqtUKU2BwD4b0b67mhdXDoUJR2yy8gnPk39rXKyj4QLSIYALgghAiCkaOgunpYUSffXYo6FtLAIzUKKpiBGNSYZmnenOQdpg3YkuXCWJXtmnJZ2EOciRQA82cATmkSKtOnctWx79eNa3C1Gvw8WKqYyhxi6i1/Tx1PXXQvNLrak4WjIAkvKK5IiidxI6Q1zXSTvqP0boU257yR3TbouzLHcAb9ZlPok0UwI852/vl7HaziNNRqaPplgDRQ1NgPLENNcdM62SclQaAfSumvWSNcVBcfivCXJFiUBe+bvfFYcuVaoiAJBYfPUzHP4moIM8fUrZBWNTxaFIMtcFDIEcIEIEQB5MTU7i8k1Rlt0yI8YQPYPypGigraoiNpdnClJkURqS7vCvfyM/xF9vzWOhrUYEmWOQ9Mm78NpHGU70pdTCdZU6NWWi/JlBQVhzDnuvWvOJwKYRjvE7ZZL45WmNfmmQoUQlr231If+91ywDYkUjUFH0l0hzdSfNZOTviEOuWeqGVfa61I/S35AXhhjzLjYNN31pv9qUXsPJiWac/BAJkPs4eJiKHkSQKEpaLakDSoyN/U2HyVBNIcxEWXxnFW7BkDUtE2yiXoOtUKDNuM0hKlc8bD7DoCLRIYALhghAmBeUGlwicILEZxRsAV12VNDIkUS6RG0RVUT3KFIEU1LeTX5S1FUxqRLSEK2DjWHYsYh3nkqkSLut5rvojQGkl1rQfgqQaGNK5IiTfumgEaLMbTOGuf9IYJ6CYVnaKT21bSFkppSeuh9TBmNZjMBoG7MT41aMhSuM+kkmtymnNZ8T0PzlMiLBpxfL05Lwq+WDA0Fnos536EpggfUyjITYhQp2jcRygXEGIFs4B+6aZD7RnL5tO/tUH5fCBeNDAFcQEIEMMGLosTIA5GiSX2KapDT+JQmLXTvZDs/x4DcLu/osomWCV/P3SNhaLhmyQTQ59lsomBDF+KcEKvdQSyRK7ozLT4S0zZuwdSQolJ9JXKhfRdzfSelkN/S9aFERAuufKxhEfyFwLk03DlBz3ROo91htD0aNM71w3Pj//FZLDkyVCInEkpkUnMf911qCOlm0xfQpPWqZu6s0RTV+qX4eXaMOZ0YppshQ7Wm3qJf6a5Pmibpm5IpMPdblTCbm7uPRcOwb60QJsMTR5BTRUGVIEX+05hGshtKvPncZGRI0W8XkQwBXFBCBLB7YSU7ydKuDactwqZLlBiFsiYwt+LagZEjRRWO51WRSo4ZtI9qdvETAlwShggp4sjSlKgVvjApSq53cTdZ8jco+UZx4ZUl4JPmO6E+DE04dZ+11CfnlejXaCXmJEVS/0mkiI6z3H1CmgVWrjL+PyzpoWluLs7t3JcIxyGFTS0ZyvyeCHalcPg5glTSRg3VDkuYOnqotr7eutJNay0yR9jnQe2YWBQ8pFZoYpTIkJqIlL6PCbSzQ85brMUjn37roPvOAy5E2O0cHn7qa+pu0ISmZSbnhFjURMKqEd4Ugor4W+VZMAG1E9tQYrDvYSiFV83lnwpD6xWEAjYkPA7NnSuzBr7duO+kjQBm4m0acuJ8yCCMmcyBiNuf82ePVIchlzDn2Azf5wQEp8rPsNKvSpjf2HDcpRDdBK7wLjji5JqmTKhK/VjrT1U7Z5S0RCXtU61mCGu92OYw7dmnltQxRCJ5Lmb+kH6X3h3ne6Qxl+PQCWaFAHEeE0yXVRoi5htUnbM0F4aefdMrZ49r+ZFs3E5mbcO955nGRPVmeNNeaDIEcIE1RB7VL1BSjSdaBKIxghG7RSUzBU3enB9RsK0eGJb7SCacyVEr5EomJ3PDlQUC1oyMHghX0oxp6g91d+o+SHakktDNGt+fgtaIEwax0Fq7MA81Ra2BpI0snZdUqymcE16wpYe1ekghugvt47Q8EulhAyNoNL2SBktB7MeSIQDQR5qbgAzRA0D5alwvr7pdA1ElPAYTTMV8MTSQAocc+cLmcuHaAHO5WswZirsA1djYh4kcNYubA4cKAFFDcPAZRfvAJSBDAJdAQ+RRrSnigA9v82BO0+7lmeq8FG1ezQ5zzW5izeRwXjREU2CspmVMfcyCL2opAfgDTKWyPWo1FYJQFn8XyF0Nds8tfmsLJnyulLdXNvqttHs/FKUyaoMWcOA0hhgaQUKj2ZHOb/Hg+n1qc8YaQs/6qiG/lanmoBLx07zjkuZQQYaGQEVWJpj3ivNCQmLJ5g69T3Nu0VAyFMyMqYaI1x5VrZs1GqLkvvyBnYMx5hylfRCIfWzOcmOqgFm1Q9sKtv87x397A8dAzQb4I59526A6zhsuvIbI45FPv3W4EEYh7KzvzacIt4NDSVsEUBeWe66J6DySIIwpiM3Q+gSfNrFtOSdynL/0Oy2zQwJDrj9ypjGlXf2kHUwEJ59uW1kTxtWHoTGpG2JmJz0fh5oIcxJKpG7It1zqr5I2hgvCQPtFq+XRjBefpgeV5p6HXiu1SdNmBsdMhvC92TJKc0Xuntq8nVOYtg3YaCkFy0neaZdoJqqsQTiNhuDwXxf9dT+agWKb9q0VmhI0DPqA55g8MJWkBZTIEHffFKG/ES4LGQK4RBoij4ef8uptYkiITTGKTf/8hL34FEn34o+nRluErqsO/WLLrfgAj3noda5uEh7y3jQCMteGoX5FAHwo9tJkK7W14JfmNl3/VGyAPiHKgSUmLf+dcdqhBi2mOdJTo22t0UrUYGx0M432r1Y7xF3HPkTiLjyT5vJqxl6ozNXNcdjcmcurmRsnRBUZAkjbz/4+LRmSUBT6JO1y4f2EtiaEGYcALxAd/HtJS6SZ37j2jvEdqsBgwfpQGqJ9mZTNaRY3st7ZovSWNEUTlKf1H7pMZAjgEmmIPMILHqItknYRBJ8iMURwjrXX7LpJ92qcf7FmiBGSxbDc3ETBHWZbauPUoJou/PfQiaRm92gucidFP8S7l0ze3thjFm/1DnzFs/V8ETrUziEH1RYW5KQ+7XlMFFozOk3+oaBtnKreqcgQADseqs4lmsIckM4f9D1TjRAlEJJ2iX4nE6MXcltDxn3buLRg8nywoxQ0mrtwCX+zhPRo218jkHcuaitLGw1Yq+jJED0egK7fI0jJURx/IcgkYpClfZnHHbH/8t7J0AFw2cgQwCUkRACEFA05fFMKz1pjxjQ0Br0GNYJsIeiCihSFEKXCMw3Z7dZAEho5YUNjGsihFJodY5+kCNfHEPLtz47PjxfA0k71QNKS1J0c/Cj4A4TfCzvkQt4iKRqDfZGi2nq1QjXArOF9GxSooCmE3U6CGpTylkiTJnx8uCaYkQhjBBMY1flBU0EzrvbsWF/UetS8M7GMkWG6pXfErdNS0I9AmrqUDCXlDQyXzODgRAhAJEKTRJwdirmJ0CECJpSA5a+py1Xnjf1+GckQwCUlRADkhYdD4Vo+LWlAMDGShNNu5IFZ3M79nKDECIRdLIkUSZir7bWLythFqLRDNtd7ErWTZIeV5O0tbhwp10YvkuyUpfZKoP0jRXbEabyDL5jVONo2qimVCGLNxkHpWu56Dppw/9y1Wu0W/b1Wkyr0Z7Pp+toiTLrxeMG78FK5WsGa25zKvVep/Z0L/+g17m/6Ww5svhKJyJU99Gy5YwZdPyRzuVKfdw6dxcSs2/h+Pw6TdVzQuG82MZCCoHGvWedHv6OpBGhSxoXXCo18joNp9PxaNoFsUWr/ZSVDAJeYEAEwL76kISoRo4wp06hgCzlhYQrkIpeg34qTgUSKJFvy0k6fViMzhBRNQYxyGLprqlnwc3WJzSmQoly614aOrbOK+HPagRIpwmnR1wAJKjnzKIqhpGhKTEmKpjSVoyiM50RLVBpTJY2RpAUqaZcK9ea0WoHASFow5huUNEqTk6FexfsVzmZzORatC/JkqBitjt1c6VJtkMemP6ckRGhbIcrTJ0MNWS8pJhGoZ/IbuvBaIe2zCAEveGsZ4V1Mre3Zx2Y4XG4yBACXL6iChBBsoQaFgyO3gncaHnlwsAW2/vnMYABAtFPfXiosRKWy8X1tw6c9phboSu3CbSuhNvACJnHaPtHUG3b55RPd2QldmuQ5O/lSEIXSmOB+Lz1n0gYyTgB6AU3CM5bCb/vrQ/zMtAR36NQ6kPQmKBGiKeaOwnhiAy7Q+Y9uapTmAgD+G8JpfA1pC7PmfPR75L7Pij5zbTOeDGk2MehvMCNpQRgq1Iu+QzGD/HvHP6do1u3zLxb9dclbgPg0E9pbJEIAvXfgnAvtwOnZMFbg1mi29mladqjgCYo2ZIkQDX2O/64xpdS+T27OrCyTe55HHnu7rv4LjkutIcIYxIxLkW+cA858blCwBbb+ibVFPbM4OTR3UxK4alC0/6/Y3amFpC3SPlNN2+bWFAHUmZeIZRfs5GvGXMk3QBSMlBqkbsMLTJwwU2PGNwWmFIpqytoHGQKQNXC+mh0BSYjBUI1RScNeCDlb9G2SzCm1+QnYYBNTaIaUa8Qxms0NOtNGmD+4soqHQHPzAzKxS+/XkyGAsmboqKDRCs1NhtoJ5QcJI8kQ7ypATBUp6aBkSEN0agjUyHXKyFAeRogMBoPBYDAYDAbDpYURIoTJ7Cd7DsP9KGBZTVEt/P1z7HJz59bkMOR8Jy3m1hRR1OxcHTpyTcZ/TQywMBeGarcA+lqiUlCT4J+2/T3ZGZa0RBqzJLF9lWZU+9IScZrOfYatLfhpNZsuneNofqqB5OZGrj7ud3Ktp60ZM1fSe0tlabVDHDQ+C5wPVy5C6AFQNe8UgilIZeEDZYu+MEG7jDRCnHZorjX1kNh9ZweNJDe3dmiknFDtLyRBm3+IddBAc7k0T2PaIQIjRATVpEgyCaLRsXBeIqT27x3wgYT2jJzEWcGqZX8Xzea0pGjoZDiFj4UWtaSIWWxV9w2BlljkMFG/VYXmLRZWcLBOHKH7pjEiKer6AlavbaV2HioEN1eX5JejvX8oJLM1RvjnghGIJnQcgc35zmR+D3VJIZYloqLJU1Oe9ncORyyMYwKiySdnkN6Pcq0ERGAEc0k/HzjHl4XvT8gQhz2HPGcxxH8IyRR7N5ML/p7NfshQLUrtGBLRz/vczuFHNAA9ktc2lz6AAgcLqiCgKshCiQCwzsXxnmZR0MIM/VDGCj8Vwoh4GCdXFsbYSbgmMpcGc+yalSbcIQEGpPK54Aokjzq4goSC/b46oEJSwABBAz9j8g1t08l3hYMsAMRvSvr2Sv1R8jHRXM/h2L4LDO55MDnzvxf6003RRk5D4oXetjKQgtSW3PMObGNxnikRpwqfvkMFWSg660vBFDRnqgHwaxIO/lJaNyVhVVvXvjFUDsgRIYD5idA+MBERSknDCIIyZLzU1KfUEElaYtMM8TANkYBHPvO2Cmf5Csdx5h636VLzud79AzVGU2iLPLhdkpIjacNrlqowpG8Bjmt3tWCuwea7CBhCcjBKGjdsSsdpirBZiBSZa9Pxp9hPNX6OaRzORYbwdUljxESsLJ7pw5nFMe+Ing8UysfvNadxkjRD9Hk4KNvI3gPAj+/SmKlYC/a534m/t6IWohRZjpTbL0uyzCgEhPFpKWgCN46PgQzVgDlfbi9aoX0ESqCY8BkmMzE9JBlSaLOMDMkwDZECDz/pVeUPfKSWiN3Blwb+PjVGFbuTRS0RV2ZpMsP31/Qxxtjd3GMnKvvUEElmK5xQUyH0FKPKeYjvmNH4IK1QEzRCRFOEn9vfW9IU1WiCjkU7NCcZ4lAaYzUao1JVNeGtc9eylRT8t7TlcXMf1gwXCVRhPk0uH9G8NSTMNkBq/hrKGklQShpCrGE6JjI0QOO1F63QPjVBGGOeobQenjftEHM/fS4jQmWYhkiBRx57e53gzoENw0qCLVD7ZknDM4V/kbTw0t+HThYtEsypcE59j7QT6hhtUem5x4ALF43fbandY+9PysoQUZhgF2yops9j7GnkJUKF3yXaBXZ4Z5jbHW4bfoyUvkWa7xgwpY9dUVshbG6U+pLTGKEw3azGh9EosT5CuUN5Nc8koUbTVKqX67eh7TqS4AkiaoKsMOthmreir0sau5I26JjIkAe2Fim0de9aoRwkbT++VrKe4PIeC/x7mXPMiEeElOUxI0M6mIaoAkW/oiEajGTXtK8xEg9yDfkm4LS4XO1wYLREg2zGuXwUnHCvCdxQ1Oo1cls07fKoISxcu8fer9EI7DQjIiEaoT2s8h/CyGkRaVkcuOf2GqBE88Noish11pdoDj+REuYWVmrf85BvQ1vv2LFY0+fHtMzVEFbthhiT7yiW9pK/YOG8oHRuKcwng9p3hKRnJGbXCtVuaI3175mD/HDyVfJ7RYS40W0p1DUgohx+LiNDepiGqAJFv6JBvkT5yUsMzx3yTbAzUdr9pvUBiB9hVgNR8ikqmUNx2qZsW0tEZkLNUO09UijpIXVqFgxuPO0L3Luu2TWuycOFzCWaokRbFO4TfF80GNqfc+54St9STVuHbhTk/GJqtG+53f6SSRxXjgT6HnI72SVodsK17TvvZIiDJqpc+BlpcIaQIcaXhr2Gm4c2eY62DzOYXSs0NOrqEGjvr7GmKFkoaCPKza0N8qj0F6IymJGhOpiGaCBEv6IptUTMPUWNEcCs4RsH2bBL9uPc/ccY8aZGc7UvlDRFdGz4/DW+aiVoNUTMPcV8NeMgpykCiM9H/IdYvyKtpsi5vIZxrNZRC9wODK12NFduDmPfz1Thy4eQoc7FNtW+h1y/Dn2n2vFzXslQzkIgCYsvkCF6T7G++nlZ6rNjOctJg1nPFdqHVmgItNYjQvvD+62RmaYkQkO0Q+YvNBtMQzQQol/RWC0RpzkgC0U2Ih3AvLsX3AdcVOkSwsf5FIWJaaSPiQTtbi+3w3sop9EchmqYJqtfseBptXljD/OVbM49GBLWYIdq/Cw5TRHVZNQKnjU7piXtSI3WY0hdUplDBJ0xGqOSTwgHLh/X9qFCW8nfoab9F5kM4X6SAimQbz8bGVJV53Rk6LyA1WadV62QFhOsfz2yWxo7U8pVJU2U0leXs8oxMjQcpiEaCdGvKCfk1URDY3b201v24GNEMWRxriGPnBZhLnD9WjKL9O9EOyHjHWktau7hxsjcGiL0btXvuWY8jLU75/qkRb5E0hlFQZtUOBushNxuraTVyd1bQs2mRAnS2Mt+F4VnKrUFa9uG+DnltHVTziND3l3NM10kMuRR+v65A5UrLBGy9xRQ6rNj1xAdjVZon0EOcuuuJHeVzhwK+Xb3d12angoT+QvZ+ULzwAjRRGCJUcXHGe8pmOFpPuy5iVHFgXbszlWSQVHWGBMXDXDZmsNRh5IiXxetJ3cNty+HEikaGuJdAnmvrHkkAL8z7FEaC2NIkfTNlEgRF4bbX9cIwzSULzem/O+4THptCEqkQhpf/m/cZpwn901I7a8laEPK8PXT+zFqNXK5tkjt49671D7pntJ7L5iOZR3ppblmarBjXdAM0d+Rj2Msb15zuVnJ0BzCNMLREKEp69WgtN4qzOWy79WHWp8j5PoYMoTu5dpvRGgaGCGaEGpSNNS+v6At2t6aEXDnJkXahbrkP1Ioc68TMIehqvox7a45B6sVxoA2iuGAXXCVH1FWazIw0hyHHClq0t/UpAgLkZJPEYcaJ3ou3xhtScn3iSK36SDdV3qWMZqrffk5DV0C59D0ScgEFRgcVWxKUlTS+ObIELp+LIRoMBnCa+wM5xnNSoQA6sJoHwIjCdFBNH5D/YSYAFZGhuaF+RBNiEc+87Z5Kyid0QBowuT8AfYVGaWEkk8RhhSNzpcxl88RBo0MV+vzMsXiodFa9a6VtXHJAjuFAFdDdnHesX5EXLk5EzxvpoOfGUeoC9eYMnLfGNcOTV6pzJIvSs4vRXq3QwVo7XNz90jQ1Fl6XlqWND9qy5Huo2WMLTcHLhralGRoSmjJkPR7iQzVoHLTD/tgFKOk5uqjPiFey4A1DiM3JGffu9aso/vyEaIo+QxxcgSRDc4VGSJpaWwaGZoWpiGaCUFbNJXZXC/PgbVFQ6PNlUzfcpPeVDvCXJ05gXxs8IJ97eDlTCuJZoTmYRcLTmM0VDsUM/fzJb+PjDjnwfkTAaRmcAD985maJn4bkn9eKdIYN8ZLYzf0S9f/Nrlrmt9LGj98bW5th1ZTVDLnGurflEPu2XPvJal/wO/SPWN9hrTfyxQbSTVkqLBRUSREM2iJBmPI+jlSY3RQ7ZAqOMuAzUIN5vQZmgtDzeMUEeQAjAjNBdMQzYSgLZJ2NsZOZFRbxEQ9YrVFeIEvnMlQDfThspFvNP45tdoiWv4QjVHT9rVAOD12kt+HRgs/A4COcGg1AtLfFLQ82m9FwXQGQYYSQEG7UTwAUiJ9HHraKOldCNqE3En0pZPqJY1CScPEtadGE1SCRnvSMX0sRXSr0QaV2kXbiP8BjH8P0u/4Gncdg8x7R0eGuHNghpKhHDTRtyStzRj4soaWSTVGFdjLmUh+bS59d2wD0TpZcyaQBr5c7izCOcjXFJA2p0ob1MpxZWRoPpiGaA8YpC3S7mYoo9llNQDJPSPj8bvCIldDBLX+RTmHZLUfwYFMCSUnd4pSkAXN2CoEWfBjxDnHpj3o771nSTIXBCQpby6fBqXgCgCxP1CUuYYxV6jSFGGzulzkM3G8KsdhSaMDMM6JV1PH2N81bahFjTYo9w5yTvFTPPcQ7No7iZncWEJU0gRvOkFT2vWuyc9T6V8qBtZgNDMcMZGuTYkJgz4c3JcWoLxuHoK0HEI7VAqhPfReiG03IjQ/jBDtCUnAhZpAC0WBQjHhcA70pTq0pzVT1JhUlaAlKV4AyQ1lrcr/UOBMgaj5VcmsSDOuOFJEiDOdEvA17vfQJg5cyF3unlzfz02KmhagRTbaCelhwm9TUpTTUOBxKRH4GhJE76dpCk4IpN+2NqramN9zGCKs5NpA80ltpMDvQdrJr+0HjCEBMnqXRm4yeYwhRBoy5OvwfnlYg63VDGkIkdKst2iyKKWnRkU456PwD/Pw745aIkg4EiIEcEAyNBERAjAytC8YIdozetoiapKVE2AlVJCibZHM7n+FTWvAED8igP1obYYsJockRFMBkxwprHLOn2hoSN4hjtVDAzBoIfkR4d88IQJII85pSVGNUFYSwkvQTNU5vyF6TfJfyQmGYwTH3FymbfdYDVBOCJbKIOXValCzc2zN+AFGSB67WVALIThJ/Nvlv+taM7khptway4Ea0HJK5WrqHUKGDkmEanBZyJBphS4cjBAdAMXw3ENIEVcOB6Qtwrv+2bqEEJCDzyOaQ0sk3l9JjM47KZLGkRQ2ekhYeF+ezzuWDHH3lPJqUGM2t9MSbS9VaIpqhK8arZDWHIhDraaiZD5U87vGTI/THEntnEMDVNL+ZMrgNKUarWoPtWOH1L99ngOTIQD+Oy+E1t5mVbZdQ2BzGCLelDYSxpL286AZGroO7psMaYJKzVKvaYUuIowQHRBqYlT7YStJUe+2EjFKyigsTGNI0ZCDT0sYYuY1N7D5gdYUQVuWh8YUk9NWlkz1JOGIvrdaM8Y5oswB9J8rXO8Tou1l8u1xZmYacIJSLRkKl10QtIf6e7FkL6elGCJU1GiQSsJnqX0UNQK0UiPD+suF+jLfR8Y3bwgm0Q5NSYYA+O+8ghCJJrjF9ij9gnDbxpp2aqAhuceoHZpiza0hQ5oAS6X7c02ZkgyVNny0dZlW6OhhhOjAePgpr+ad5TkBbt/EqLRYaCLmuP4imGDfpOQY2oAhmU5q28DdzxEb9l5u55qQKdo3Go1Qcr20WzoTKSr5WNHvSvCnCr8PWQhrBCLFNDzIt0vIW4Qk0I0hSLm6AIZpiDBqwhoXNmzEvuXGIQ14Qubz6r5nmzuBkHwkZKhXzJQiyFC/o6kx0Bxw79qhKTbkaokQwKzazcnJUL6y0WWYVuh4YIToSPDwk161TUh+D3smRlUBGHIgw0u9sM9JRg5FiiSNkGZBwWFNh9xfE7QjR7Ik4jWEENX6c42NoqXwI6L3hu8ARaJLyyTClcZ0ptL3bvAuegb4+67ROO1ujm0uPb9kdghQ9lHirnHpnJaaa5/w3CxKWtEcRmiL1G2rbcsQ5OZnDRmSysDFEfIpEVLVt8AFEdFolGrzlcaepo3JLYX3PFarMoflRSnKrRQZdaroqrgpcxOhIdpE0wqdKxghOiIEUgRwGG0RM/Gow3XnMMR8bt+EaF/tmOvguqGkqOZdDt1FHCrQTUmKJDIEkJrNMb+zobiHYqiJ6R6QE0KZzHrtDSVFWv8PjTmUhELfqQTssYJoQZiTBLhJwy1PdeYZe+aQkgzR3xnUmBNWfRdDI8Zp7xui7RXGscokcwjmXEuHHDyPIT1TRZCfvWiEhmoVhfJMK3ScMEJ0hGCJUU5bhF9h6WMdot6GdOeuV1dpksjsfgPAYUzWak1QhkbboRqdQx8mNzS8ey00mhKAeUmR5EfE/Z4hRU3T8EL9mNPqKYYQIiqw53xZpLw0v4CcBonb3RcK4X040ofOX8tpfQoaoCL5oX1CkdOOljS2GfNklTYo164S5jhzKLehNXVwFAZjfJByQTDU7wFgfjKU3Deg7+ZaP5VnH6qgOU5CasbUa9YY/yBteaHYxojQEcII0ZGiqC2i1zFUPgL1xEhlC89dLxEigOPWEiX3VbTp0OSHg2bBGbvQVO3gKvIOJUU1ZnMALCkSQ3EnZVS856Gh6tmyJp66K4WRUvsGCyz4voHLU50WYeAYlDA0cmMJh44qpyFDNG+uvIkwhBCNLq/GVE6h2Zz0Wz8PRAigmgCFZpxjIrQt2sjQscII0ZGjyoyOYiZtUVpFYTc4oyU4uD/RsZGi0q7+VNCSIu1uvNZ3RoLmOXMClhT8IQdNgIXdb6roizmt0UB/g4OdVJ/TKJW0TwQlbRLOg24q+lSVyhSh/abG+FvkIj4OFAIPToYA0n4YupmVm9u4saZEyQ9OG9RC57tV6Tc0VCsU7j8wGZqaCI3EZIRoaOjsIWXu8POP/3+Hl22YHUaIzgmKZnT4OsUhiVEBB408tw9CBDBJ/wZMJQQfYCFTY+j7x/epSJ9AitpF73pVSHqA1PG/hKH+Q3OH4h0CzfhV+tNUmzAV6pj8u9ag5GOhIUjHQIYA6ggRzT9lO/aA7HirMZWrCZ4g1ncgQjTWP2gmjCZEUxMhhYWAEaHzgSO06TFwSFSsfoJ0XToBdk7YrZtwYRHqcM4NcgJvmqY/wc0x4ToX+8Gnxd3+CQhk005LhHA+/28MjlGY9hCJvTJaYm3f9Hzy+uGCk/GNx3ntLjLFUOFIa+YVzJy6/rU5gOeHThCa8e/oOu5jPJeotD7aOiUc4kBmqU017ZYw9RxK+yfxqctZKaB5UEpLwN/z1M+TKdMTcVbw1pChrov/xuIQZCj3bg5IhsR3UgPJPG5IuW1rZOiCwTRE5xCiGR1A2ceIjRg1ghdPqDFSHTw4ZtLXCFY15hpcW2rDYXtMvZtbW+9QU56hKEUmA5DNm6Y8zNaXj9tFfyd5RkdeVJgXTnLujLZvtOO0FFSgtgyMnEleDlMQ+7nJkFbwPxbtr3be5bREtaa+NX1fG11PahMtT2hn6uOqNJMbcuiqhLm+dwljjm+YEZOYyE2pFVL6jBoROn8wQnSOkRAjAN6UTmtGNzYAwEShMWfxKxqyCI1ZzGsExaGEZGr/ooIvyOTQ+htJJHWqMzW4b2UoKaL3ShCiosWfB5pyAgzvC+mMq5q8tWVg1AjStWO+tHExN2qOPJgCY77fWvM3ab4eu7EkoSaYSo5cF9pYJEMDgicMFrXm/O4B9GvUgTDFwcajCBF3BloGRoTOL4wQXQBMFpFuiqhoI8L3+jSLMaRojohTJWF8Lu3QQKfjwZhjMeTCKmsxtb/CmPOJmPGb3JcLF53BYEI0t4BfCn9N09x9FLT/p9A8zXEA5RgMeZ6x0H63NfNJTkuU0/iWiO5chGhgeVkyNFcUuRy0/ach+TUWDEfmZ6o91LiHoVHkKqKHGgm6GDBCdIFw3ojRoOhQFFORolqNi2bhqcEhtUMaTLU4lhYiDXGYkhSVQiQXtEXi7qXGJFDALJsCUyAXYTCXxqjd4dV8R0M0VPvEUDPaqSB9u1PPeQDDNUaasqV7x2rZIffNZQjRXBqhpP6JtG1DrBaGYg+WBipCNFQrVHm+nJGhiwMjRBcQg4jR1CZ0XB1TYOiCOkXUriE7z9p+1PTVvrVDHMaEDgaoF4jnJEUax+Hcd6GMlqZBUUtaay5Y0uDgOqQQ61x6CtT00VCTvGMGPaR5Ct+sHCQTsiHQzrMajVFt2SWfoBqUyBAmO5VaoVlEKg15lb6THMb2pR9TtE0z+qaqNEVDtEJGhC49jBBdYFQToz0FXJgEQxbVoVoobfk5TOWwegjtEMaYBXSo/fdcpKhEiDRmXhMEFakOsV2zUz9CUzU7pj5g8aLg0BqlHGrnv0MeqyBBIkMlEsTlQ9ibKDWVz+i+6j6EpgiTGyNCBiWMEF0CVB3uOoQUDY0QNQZjyEt2scss1lNFNcshZ95Sa9pC28vtsI/djT5mUpTzKdGGldV8DxlSJB1EqjIXzQWU4MBpf/YBOjZrSbMRozxKWrJ9kyY6F+bmRe13uw8yROpUk6GR2qDaeaBqTtCmJ9SoVWEmGUCtGZqQDBkRuvgwQnSJUDzcVeM7IeEQDpjaSbo2QlJNGbUYar99jCFYPfZFigDq3tkQcM+iMSfdl3koPRyTM2fbZwh1bd+X2mOkaBxqzO/mIlFD59m5z8VioCJDI4jQmFDRRyWSjZ1bZzKX69dT6S9UIEKYlBoRujwwQnQJEYhRrRldbhG9KIQoV+4UC/dYLVEJU/tYTOkDlZQ7Ayka6x+hDVEPoNcw1UAyh5TeqWQWJ2lqpPK1O8icn0BNX+fKpgEZDHWoDYWeSw+Fdp6tJUNDtBslIlTpI6QVk6Y4M6c6AuscmGqT6VCEaCARwnU88tjba5pmuAA4MgNlwz4QPvTOxYnPdXFxSq67uGDgPIdE7QIpLfLipDmjQDZFNKUcpg43rH3n1RqsEQsu995w37RN/+99YQpBIkfIuX5zjr8HX5PS2nyl8nPQENWLQobw+5kqraq3myY9N2q/j9IY5PILobSHkKHkvgyapsmTISyIF9K4HEqGuN+0aRWE/qsGnYMngNpfiF0fWpVWyMjQ5YZpiC45RgVeUPpSTI6xE/YYjdG+TOcA6jVFGu3QFGQrh0NrinLIjZsa7RDAcNPHHDSayRqt0LHgsvgRDQ1LnksfAkO0RJo5tVbzzuWv0WCGJgw3j8uJR1Whn/Ghnrm00AbN+X2DtUpzmxyPxKjACQIJkiLVGRG63DBCZAAAwYwOoJ4YzR1IYcqw02N8i/ZhjjaUEOXu0QjMRX+PAUE2suUhP5ipwnJLqDUVm5MQDTWRq723FEBjbsf8i06I5lxCS8RJEyq9lO7VqQxA4rEvMuRREUZ8CBnSaoTk9g34lnwb2racVmKvZGifwRMmIEIURoQMAEaIDAQPP+XV/A/HQIzm2vmeY0HXYE4tUc09tXVjHIPWaK4pbCgZAqgjRBSHGo8A8xCji0yIzvvyqe13aVzsmwxVoJYMjfYTGkKEanCMhGhmq5Ckr40IGWaGESIDi6MlRnObA+1bGD12UlRqA8C8pEi72z0VNCZLUwWamIoQSRqloWGwfVljoNESajWDufDph8JFWTbneAcHJEMiCYoZ2N9zZmajtUFTzF8DzOzKZSr7el9HaezQ628jQoY9wQiRIQuRGAEcjhwdihQBzEOM5oo8N4fQIQq3RxqanYIKIVoCVBOFS0NAxpAhev8c/mIA40hRjgRpfWRy9R+SEA0x06w5O2aOMrV11Zqv0nwHIkNVREjKg8op+gfVEKEcxohfYw+I1USj3CNEbdD2x/4NlSQIwIiQIQ8jRAY1jk5rNCcx2meo7rk1Dlw7DkmKDrTg9hbVIT4VNcQvJ3hOrR3KlanFmPeK759SKyThENqiqXbdxwqgNWHVa+uiwTr8NQ5TzoVzkSFFSG1cTlWgBA41pp85MqnBWO3QFMR8AmSJUMxUzGPaIMNYGCEyVMOIEQwXBmrP/xiyUO2DGI0VnmlZc5GkIVG7hmiEAKZ5RxeBEPXun0grJGEfhGif/hg5YVUD7YGsWoG4ZOYltVFDWucykRPn54FjZSoSJGGfZGggpj4PyYiQ4dhghMgwGEdHjAD2H3gBoJ4c1WLKEM4A0wknU5IiTbm1GCqo1La/tr1DdtDPOyEqYY4DQafAvsMWj8EYbTSNVjgXsdfcq8TsZKhkFjdVIJAjJ0OYcExRhxEhw7HCCJFhNCYjRj7fGG3BPoSTqbRGNZhK6PaYmxR5DBV0p7JrrxVa5tIIcdAKkxoyVCqzBrnQ+1y+saHLx4b9noIQ4T7mzMYwhmht5kZNH2g10xxB0jz7eSdDU/kH5TBE7Co8wxTnFTVNk/WjomaFmmAUPVNErbbNiJBhzzBCZJgMKmIEUCZHkmlHDfZNjHJnxmBI58docN40RRRThXSekhTR97bv4BDngRSVCFEJY6P1laARwHP+YrVO6KW2TEX0tHWMgXQeVe6sqlK+Eo6RDNWEzB5DhmYgQscA/E6qw5IryZIRIcPcMEJkmBwPP+XVsvmFVmvE7WDWRmHaJyQhZUphC2C8MD5X5Kd9k6KqOhXO+znhdS4n4zn8iHLl1mAMIaJkQ7PpMQRaMpA72FSDGt8dgHoftBpIIdYxtIEdPEp+jZo6cxizCYTQE1XOCxmaIZLcucIMZnEARoQM08MIkWFWPPykV8U/SsSocwALvwgzTtglh2CKYzBnqSVH1PyIM1GZixQB1AtZQ8zH9kmKhkYy21c0vBpSVBN6e6iWj3vmMYSo99sE776WCGlBN3FqiZCEKQiS9plrNzCmMEuV5qiJ5t8sEdpmEII97PK1rZzWQiL5c52NNiURyj0/7QvFGUfqOjnkzhhKspk2yLB/GCEy7AUqYpQzlcv5HXH5AY6DEGEM0RzNhTlIUQ32QYqGRjTbdzhwAB0xyp3xMqeG75gIkdY8rhZD5oq5DmIeUs+Ucx03j+5500kUS3JC+qHn1LGYmgSNgdQWTKJq6jWzOMM5gBEiw16RECOAvOkGm0fp8O3vOzZSBMD7h0y1s1iDIaQI3zs2uMAUpEhTL7fIngcyBFDWFJX8iXA+6X1lzw0qfF/sPQciRHMSoZy/YA1qnn+kVkhylNf5ezBBFWbQ/nC4kGSopKGpgaTNGUuCMKSyaT3075y5rJnFGY4cRogMB4OoNcIYEpCBu+8YURJ49vFpjiFFU2DMexriQ1SqT1EmJ1SOnkbnCMU9VHDXmnhNrZkrYUoyVCPQT/0daPyoKrVCXPQvVVOESGDqQ0onRjUZOgbxJUcepsIQspPzmavxodPWxcG0QYZzBCNEhoNDRYwA9Fqj3H3HhrlMgGpwaFIEMOwdDdEODRHwe0Xy+WYjRQC6QAu5MmrDMmsw5tyhmnqm/EYOSYQ40D4YoBXax/kzcyP7DMdIhvYV7KCWCOU0NBhj+640NkwbZDiHMEJkOCoUyREnRBk5Go9DkaKhDucH1A6VMHhK1YZ15ivVlcNFQ9RqV7UmkkPPfpLak8McRCiUvcfNgCMiQhTc2TRjNUiSCV8PhyJDXLCBfaHmHCQu+FAJNX1XU49pgwznHEaIDEeJLDGq8f+Y+wyUuXAIcnRIUlSDoeG2B2iH1D4XBIOm1SmimmmI0VAfkBr/qrm1CzX9e8xkKIfMIajDxtf0Pic5bWnOHE/VVr7g6jaqccgQ19p3McV3pQk9nzOBo/2E2l462NXDiJDhGGGEyHD0UB/4SqHVHJ1ncnTZSNEUZw/R+jJlDtkFn9V0LqlowLjgtDu5+kYHzpiYGB2KaO4TyvDfgzQrQ8NOKzHYn+5QARMuCwnikDOpo1Bqf3KaQyNBhmOHESLDuYFIjACm0RrlyjkWaH1JaqGNIHVeSFGNZjCjHRqKUdNqrUajNCY0EQxz51+NwVTC3D76c6pDR8ee6aPAoEhsHGYgRWqU2jqbefAlJkE1GGACt70v1WoaETKcFxghMpxLVGmNDnWA5JyYQ2t0LDvpmr4f6sOSi1rYK2a8UDKr6VyvspkOLB0L7uBKLaZo61zjesghqCPP8xmkFSphn6RI28bJNd9GglTQkiDOlBON7Uc+87apW2YwzA4jRIZzD5YcaTVGRopSnAdSdE7IEIYRIwIaEhi3Z+qQwADzRJerIUQDzvBRj5mxwv6+CNFlIkNjosPtG6StNdofI0GGiwQjRIYLg4QY1QrU55kYAUxrSncsoYmnJEUVJpVzhBveqwldqJSJKCfmdX1icpFQQ0imJkSV2BsRApiODElR2WoOH51j3I09BFWLof24TyLEvZvQDAUJEmBEyHBRYITIcGHx8FNfI/94Ec3oAKaLTncspAhgGDEaEWHu6AiRxxQCeM27mvMgx0PiiAjR0ANVj5IMjcG+wmgD9ANLaAJQSL8PwSFIENsMYgInmL/RsPBGgAwXFUaIDJcCPXI0ldnVMWKo0MvhWEIW15CiCQIqbIuZ3mxukPCbw9xmdQB935+LsGSMIUUD+1x631WR2abWctQK9RKxGIN9kCEp3HgmhHSvjNzvJRwjCQKQ/dvwXOk6I0GGSwEjRIZLh0COxhwueR6IEcC0/iSHIEeaQ0O1JpA1kQhhHk0Rh4Nrj4a+o/O8dMxIiLhDTEdjDnMvKjhT4kDzTd0GjQ/ZnP5lE53FFDAmeMhYDCFBbOZYziOffuvYVhkM5wpGiAyXGg8/7W/LP2oXtfNCjjymCMagPCslWzc2xSBmGb3fJNSQ2spyVISICmhUmKuYXrEgPXha3ofGqHfvOVxCZiJEk5GfuUiIR05LcszQfmtDv8PSfRxZOxSGkiBurt3BSJDhMsMIkcGww2BydN4IEcYhI9VxbRnalzXRAwGmO5hV+n2gmdlkZnVTnWVUVcY5Wkr2oCGqxhzmaBcVOS1Mzbd3aFJTi9qw2OHH1ATOSJDB0Mc5luQMBoPBYDAYDAaDYRxMQ2QwMGC1RSoTqnO6x6CNTjckNDM9s2KMv4t0DgZ36GWtH9hQTVHNLvPAPqyepg+hIUrKOwfLysRaokk0Q4ZpwX1vl1ErRGBaIYOhDyNEBkMBPXJ0GYgRtTMv3jciRLN0RkzuQMvC2RhJW7K/H4AUUVT0XdV0fWhSBHDcxGgoIZqKDF1GIkRNAWkIbAA5JHYuXPY+yuHyTwWuXgbFAAlGggyGwTBCZDBUoIocnVdSJGEfjvdTRpEaEymw5myiuXacLxIxAjg+clRLiKYKpnCZiNCUUdyOAVO9u4p+KQZIyMBIkMGghxEig2EEEoJ0UUJ1a0GDIAw924Zzgpb+HpNXwkUnRsdCiEL5R7LkaPoF98XYYAoXhQjlzvS5aATIg9PelM43qugbGkjFTOEMhv3DCJHBMBFE7REnmGvO1ymB86fJ+evU5h8LzvxOeu6hebX3enAEbqpw3CVCVDLrwX9zkM5mCT9n3t2xkaJQz4GWnwnN5cItWkJ0jBHkNKZiI0HPZcLh5bnf8N9TYV/11LSFBXu2Gv8OjAQZDNPACJHBMAMSclTr8F9DjrS+NEMx9LyhMcj5Eu0Thb7tCTQaQqSF1m+Bmb73RoxyZ0fVYowPWg1qtUKV9x+96RznMzMR6PlZYw42puXU/E3bpK2Hu5f+XnNGWFV/lOZxsiYYCTIYpocRIoNhD3j4qa9JLyR24CNN7eYmRTWYkrjknmtuglRLhtIfC2WPEEKpEF1jTrdPUjnGnBJgHCEa+5yltp5HX6KJTdnGkJ0x6JmTHbAs7sywqvKyh0obATIY9g0jRAbDnpElRwCTBgM4OKh2DP9dCp3NadZy9dCycmVzeSrrHHRo61SCqYIYiVP7IbRtGNoQ77WY6rk0hIiOGXz7MZGiAeONjuspScjBMYdp8Jh2cNjN70aCDIb9wgiRwXBgqAkSd47GhOTomOzrKWrMZvb5HEaKBqJEOrTvaq7nKPmiZdpQPe7mCuOcgfSNDKvrgCaupVD9HDSbJ9zfU7Q1g0c+87Zp6jEYDINghMhgODJkCVLJH6niXB0OGsFIa78/Nebapc75H5RIWBb7NJ0DOF7zOQk5klEkEXtu/wgzOoAZSVGlT9Agk67a87/mIke12u+xPm5j220EyGA4VzBCZDAcOXoEiSLnj8RpkBSCxVQO0VPgQpjr9M4SGakl0kSjC38eIRmioILqsREigHmDLdQSosrxU/yG5jC1nZlQ9FDytawlQxmzSBZGgAyGcw0jRAbDOUMVQfIoEaWa8NIDwDkg12J0e+j9+5r6stGlZiBGNeG4AaYhFzkt5pDIbsdKiHKBIqYgRSPOsgEonGfjsY/IlKX3X+u3R/u9JhLn2AAf0ns1AmQwXCgYITIYzjkCQcqdqyOZ2SlN7PZtriZhsnZI5RTO+pm8Pg/pXCKK0rlFtWQolLun3XypHokQSe/hWLRcU5OigTiIBkiDkj+PhLkOsR5KhhTtNwJkMJxvGCEyGC4YHn7Kq+MfWnJU4Xt0ochRbRljzssZ2l7Noa0eQwjR1BoiDWidtUEWpvZTGVpGJSECGEeKin5sXJABdeEjzpEaA82xAqUDpvHfEiZ+NiNABsPFghEig+ESoBjJDqDarG4fvj1jTevUIYPHPoumnXP317Frh3J1ThF1LvccHOGRwrDXYqSWaHTwDoDxGhj6DHORoznOVBt72K4CRn4MhosPI0QGwyVF9XlICm3THCTpYGZG/E3lPKX2zkGMakJuexwq+pem7lqfIq5MjvDURknTYoCmqBpD+lkTaKBEjoZiHwdKz0CGjPwYDJcTRogMBgMACMEaaklS2xyNSd1QDCZKU7RvCOFi6t6bqRzAfggRgC7Qwr6EbIDRobjV0DzTFD43Q4mQpu5DRLFTPo8RIIPBAGCEyGAwZKA2tStoj6aOWJdFzt8AX6/0tdh7+G9KdJSka69kCKNG6J2DEE2JqTQP2n7WRF0bE2ktBy4Km6Q1OlbyQyEcrGvkx2AwSDBCZDAYqhBIUs4Paeaw3scULOCYzkk6GBniIDm/a9pwCEI0halcrtxcf0iYK9raFNhH5LoRY/WRT791woYYDIaLDiNEBoNhNB5+2t/uX9yDD9Ixa0OkZ/FtHkukaDl7C6KwLwzxI6rFmL6YKyLbsZKgIyZARn4MBsNYGCEyGAyzoUeUOBJQqU3iCMXkxEg6zHEGkyFKjKRDbMcebAsA54cMAcxDiI6FAHFR3A5JhMaE6x4Kzbsg7TLiYzAY5oIRIoPBsFeotEkAVWcjVYMTxsZE3NIKs4c6IBPgfJOhcP0ARHBfUde0kEKIl85mOuaxx7TtkT/6gZkaYzAYDH0YITIYDEeBwUQJYNoQy4c4fwVgfoH1mAmRts+HLFdjn3vMeBhKgoaO52MC1+9GfAwGw5HCCJHBYDhqjCJKYzGXnwjGIbRLx0aOpiZEh9IITT0GzwMJMuJjMBguAIwQGQyGcws1WZLACbBzHlapwdzapGMjQwCHI0RTvNd9+P5w75vTGo255q+PaJORHoPBcF5hhMhgMFxIVJEl5+qIlAZzlAlwvFHIxmAsIaoNmDE1LuI78SDEx0iPwWC4iDBCZDAYLi1Y0iSBkhuJ8HDXc9PsGNJ03gRxKVrfmCAKhyJD563vFbAobgaD4bLCCJHBYDAI6BGmmkM1p0ItYTpmQb2WkByrRghAJnVH3P9GeAwGg4GHESKDwWAYgYef+hr5R0+c5gqBrCFL3HlK9Pq+oCEnU2mF9uX3penf2usDYGTHYDAYhsMIkcFgMOwJWfIkYQx5GmqON0Y454gIdxBpck9hGaoNBLHPIBhjUOhnIzkGg8GwHxghMhgMhiPG3kkUwDzBIHJBJnLL0DEcqqpFhuAYuTEYDIbjhREig8FguMBQE6oaEoWJjbSE+Dy1S8wUYcE1/jyVPj9GaAwGg+HiwgiRwWAwGAwGg8FguLQ43nA4BoPBYDAYDAaDwTAzjBAZDAaDwWAwGAyGSwsjRAaDwWAwGAwGg+HSwgiRwWAwGAwGg8FguLQwQmQwGAwGg8FgMBguLYwQGQwGg8FgMBgMhksLI0QGg8FgMBgMBoPh0sIIkcFgMBgMBoPBYLi0MEJkMBgMBoPBYDAYLi2MEBkMBoPBYDAYDIZLCyNEBoPBYDAYDAaD4dLCCJHBYDAYDAaDwWC4tDBCZDAYDAaDwWAwGC4tjBAZDAaDwWAwGAyGSwsjRAaDwWAwGAwGg+HSwgiRwWAwGAwGg8FguLQwQmQwGAwGg8FgMBguLYwQGQwGg8FgMBgMhksLI0QGg8FgMBgMBoPh0sIIkcFgMBgMBoPBYLi0MEJkMBgMBoPBYDAYLi2MEBkMBoPBYDAYDIZLCyNEBoPBYDAYDAaD4dLCCJHBYDAYDAaDwWC4tDBCZDAYDAaDwWAwGC4tlodugMFwEXHv3j04Ozs7dDMMBoPBcMFw5coVuHbt2qGbYTBcKBghMhgmxr179+DB60+GM7h36KYYDAaD4YLh6U9/OnzkIx8xUmQwTAgjRAbDxDg7O4MzuAd/Dr4als1VaNpm+0PTovTu/7YJ6aZt0fU25vO/N+02P76/aUheQNdpXnq/3BbXNNGgFteV/X13fZdO8tJrLf4dlbNL4/Jdcj3mdeDTEJ4r/k7youshH67fX2/5+wOS+4U00xdJ/WxeJg3C76Qt4v3StUL9HuI1piyuL6Bx6rZAs32q8Gy9vI6vE18P9cdrTe5+cOgTiDU3wv3+elImur8h96PPBdrk/vh7i661u6fH5fi8LUkDALSQXmuZtC9L+t3Xub3WxbqA/t7BAt0T827LX4CDBt0f86JrOL3L6+tZNF0oc7Grz5cb6mLKWjRdaOMC5fOf8QJwuf4eF8ra3u/vi+Us0PMvUFv8ewllQexL//v2GsS+8m1pABa7NxKvNdCGazG9aPy1Fl3bpm/c7OBZf/p/wNnZmREig2FCGCEyGGbCEk5g2ZxAgwgJTm//j1JT0yBChH9v0e9FQtT07hMJUUN+H02ImkgCEsITicGkhAgLxjMTIv5+IR3ub1Aa3V8gJCUSMTshYn73oIQo1y+DCBGqa++ECKeZ+ykhovfE4RIF50GEiLlnKCFKCY+eEOHr2/8lQoRJQD0hallC5IS0nhAtQrsaaHcd6snIlhD5dINIikPXHCoLQlti/fFajhAtKgjRQkWIzO3bYJgL9nUZDAaDwWAwGAyGSwsjRAaDwWAwGAwGg+HSwgiRwWAwGAwGg8FguLQwQmQwGAwGg8FgMBguLYwQGQwGg8FgMBgMhksLI0QGg8FgMBgMBoPh0sIIkcFgMBgMBoPBYLi0MEJkMBgMBoPBYDAYLi2MEBkMBoPBYDAYDIZLCyNEBoPBYDAYDAaD4dLCCJHBYDAYDAaDwWC4tDBCZDAYDAaDwWAwGC4tlodugMFwUbGGFYBroXHN7gpO7/53TUg3rkXX25iv2/3eoN8b/H8b06H4hslL7ye/uyakXdMAOCD3l37fXQcA6CDN6x/ZX2vx76ic0JQmPJZLrse8vnpoAKClZZG8bLeje5huT9oF3P1CmvZFk17n8zJpEH4nbRHvl64V6vcQrzFlcX0BjVO3BZrtU4Vn6+V1fJ34eqg/Xmty94NDn0CsuRHu99eTMtH9DbkffS7gkvvj7w5dc7un9+V06J6WpAEAWkivtUw6zDzC7y3ga12sC+jvHSzQPTHvtvwFOGjQ/TEvuobTu7y+nkXThTIXu/p8uaEupqxF04U2LlA+/xkvAJfr73GhrO39/r5YzgI9/wK1xb+rUBbEvvS/b69B7CvflgZgsXsj8VoDbbgW04sm5ovXtuXduNmBwWCYHkaIDIaJ4ZyD+++/H37p1n/YSnibQ7fIYDAYDBcF999/PzjnyhkNBoMaRogMhonRNA3cunULPvaxj8ETn/jEQzfHYDAYDBcEN27cgM/7vM+DBmuuDQbDaBghMhhmwhOf+EQjRAaDwWAwGAxHDguqYDAYDAaDwWAwGC4tjBAZDAaDwWAwGAyGSwsjRAbDxLh69Sp8x3d8B1y9evXQTTEYDAbDBYKtLwbDPGichSoxGAwGg8FgMBgMlxSmITIYDAaDwWAwGAyXFkaIDAaDwWAwGAwGw6WFESKDwWAwGAwGg8FwaWGEyGAwGAwGg8FgMFxaGCEyGAwGg8FgMBgMlxZGiAyXEm9605ugaRr4+3//7wMAwGc+8xn45m/+ZviiL/oiuH79Ojz00EPwLd/yLfD4448n9/2n//Sf4Cu+4ivggQcegKc//enw+te/Htbrdfj9Ax/4ALzkJS+Bz/3cz4Vr167BF37hF8K3f/u3w2q1yrbn137t1+ClL30pPOlJT4InP/nJ8PKXvxx+67d+K8njnIM3v/nN8JznPAeuXr0Kz3zmM+Gf/tN/Ok2HGAwGg2EwPv7xj8PXf/3Xw1Of+lS4fv06PP/5z4f3vOc94fdPfvKT8A3f8A3wjGc8A+677z54+OGH4UMf+hBblnMOXvGKV0DTNPBv/+2/TX4rrUEYv/u7vwsPPPAAPOlJTyq2/1u+5VvgT//pPw1Xr16FP/Wn/pT2sQ2GCwMjRIZLh1/7tV+DH/iBH4A/8Sf+RLj2h3/4h/CHf/iH8OY3vxl+53d+B97xjnfAI488Aq961atCnt/6rd+Cr/7qr4aHH34Y3vve98JP/MRPwDvf+U74tm/7tpDn5OQE/ubf/Jvw7ne/Gz7wgQ/AW97yFvjBH/xB+I7v+A6xPbdu3YKHH34YHnroIfhv/+2/wS/90i/BAw88AC9/+csTIvW6170O3va2t8Gb3/xmeP/73w/vfOc74cu//Msn7h2DwWAw1OCzn/0svPCFL4STkxN417veBe973/vgn//zfw5PfvKTAWBLcL7ma74GPvzhD8PP/uzPwnvf+1541rOeBS972cvg9u3bvfLe8pa3QNM0veuaNchjtVrB3/gbfwNe9KIXqZ/jG7/xG+Frv/ZrK57cYLhAcAbDJcLNmzfds5/9bPcf/+N/dC9+8Yvd6173OjHvT/7kT7orV6641WrlnHPuDW94g/uyL/uyJM873/lOd+3aNXfjxg2xnG/91m91f+7P/Tnx91/7tV9zAOA++tGPhmv//b//dwcA7kMf+pBzzrn3ve99brlcuve///2axzQYDAbDnvD6178+O8d/4AMfcADgfud3fidc22w27mlPe5r7wR/8wSTve9/7XvfMZz7TfeITn3AA4H7mZ34m/FazBv3Df/gP3dd//de7H/qhH3IPPvig+lm+4zu+w/3JP/kn1fkNhosC0xAZLhVe+9rXwitf+Up42cteVsz7+OOPwxOf+ERYLpcAAHB6egrXrl1L8ly/fh3u3bsHv/7rv86W8bu/+7vwyCOPwItf/GKxni/6oi+Cpz71qfD2t78dzs7O4O7du/D2t78dvviLvxg+//M/HwAAfu7nfg6+8Au/EP7dv/t38AVf8AXw+Z//+fDqV78aPvOZzyif3GAwGAxz4J3vfCd82Zd9Gfy1v/bX4HM+53PgS7/0S+EHf/AHw++np6cAAMn60bYtXL16FX7pl34pXLtz5w583dd9HXzf930fPP3pT+/Vo12DfuEXfgF+6qd+Cr7v+75vsmc0GC46jBAZLg1+/Md/HH7jN34D/tk/+2fFvJ/61KfgO7/zO+E1r3lNuPbyl78cfvmXfxl+7Md+DDabDXz84x+Hf/JP/gkAAHziE59I7v+Kr/gKuHbtGjz72c+GF73oRSEfhwceeAD+83/+z/AjP/IjcP36dbj//vvhkUcegXe9612BjH34wx+G3//934ef+qmfgh/+4R+Gd7zjHfDrv/7r8Ff/6l8d0hUGg8FgmAgf/vCH4V/+y38Jz372s+Hnf/7n4e/+3b8L3/It3wL/6l/9KwAAeO5znwsPPfQQvOENb4DPfvazcHZ2Bt/1Xd8Ff/AHf5CsHd/6rd8KX/EVXwF/+S//ZbYezRr06U9/Gr7hG74B3vGOd8ATn/jEmZ/cYLg4MEJkuBT42Mc+Bq973evgR3/0R3s7bBQ3btyAV77ylfAlX/Il8I//8T8O17/qq74Kvvu7vxv+zt/5O3D16lV4znOeA1/91V8NANvdPoyf+ImfgN/4jd+Af/Nv/g38+3//7+HNb36zWN/du3fhVa96FbzwhS+E//pf/yv8l//yX+B5z3sevPKVr4S7d+8CAEDXdXB6ego//MM/DC960YvgL/yFvwBvf/vb4Rd/8RfhAx/4wMBeMRgMBsNYdF0HL3jBC+CNb3wjfOmXfim85jWvgW/6pm+C7//+7weArW/pT//0T8MHP/hBeMpTngL33Xcf/OIv/iK84hWvCGvHO9/5TviFX/gFeMtb3iLWo1mDvumbvgm+7uu+Dv78n//z8z60wXDRcGibPYNhH/iZn/kZBwBusViEfwDgmqZxi8XCrddr55xzN27ccH/2z/5Z99KXvtTdvXuXLavrOvfxj3/c3blzx73vfe9zAOB+9Vd/Vaz7X//rf+2uX78e6qB429ve5j7ncz7HbTabcO309NTdd9997sd+7Mecc879o3/0j9xyuUzuu3PnjgMA9+53v7uqLwwGg8EwHR566CH3qle9Krn2L/7Fv3DPeMYzenkfe+wx9+ijjzrnnPvyL/9y9/f+3t9zzjn3ute9LqxHeI1q29a9+MUvTsrIrUEPPvhgUkbbtmHte/vb3158FvMhMlxWLA/IxQyGveGlL30p/PZv/3Zy7W/9rb8Fz33uc+H1r389LBYLuHHjBrz85S+Hq1evwjvf+U5Rk9Q0DTzjGc8AAIAf+7Efg8/7vM+DF7zgBWLdXdfBarWCrutgsVj0fr9z5w60bZtEFfJ/d10HAAAvfOELYb1ew+/93u/BH//jfxwAAD74wQ8CAMCznvWsip4wGAwGw5R44Qtf2NPUf/CDH2Tn5gcffBAAAD70oQ/Be97zHvjO7/xOAAD4tm/7Nnj1q1+d5H3+858P3/M93wN/6S/9peR6bg36lV/5FdhsNiHvz/7sz8J3fdd3wS//8i/DM5/5zJFPajBcXBghMlwKPPDAA/C85z0vufaEJzwBnvrUp8Lznvc8uHHjBnzVV30V3LlzB37kR34Ebty4ATdu3AAAgKc97WmByHz3d383PPzww9C2Lfz0T/80vOlNb4Kf/MmfDL//6I/+KJycnMDzn/98uHr1KrznPe+BN7zhDfC1X/u1cHJyAgAAP/MzPwNveMMb4P3vfz8AAHzlV34l/IN/8A/gta99LXzzN38zdF0Hb3rTm2C5XMJLXvISAAB42cteBi94wQvgG7/xG+Etb3kLdF0Hr33ta+Erv/Ir4TnPec5e+tBgMBgMfXjfnze+8Y3w1//6X4df/dVfhbe+9a3w1re+NeT5qZ/6KXja054GDz30EPz2b/82vO51r4Ov+Zqvga/6qq8CAICnP/3pbCCFhx56CL7gC74g/F1ag774i784uf8973kPtG2brH90DQLYBgC6desW/M//+T/h7t278Ju/+ZsAAPAlX/IlcOXKlfGdZDAcOw6tojIYDgUcdvsXf/EXHQCw/z7ykY+Ee17ykpe4Bx980F27ds39mT/zZ9x/+A//ISnzx3/8x90LXvACd//997snPOEJ7ku+5EvcG9/4xsT87od+6Icc/fTe/e53uxe+8IXuwQcfdE9+8pPdX/yLf9H9yq/8SpLn4x//uPsrf+WvuPvvv9997ud+rvuGb/gG9+lPf3raTjEYDAZDNX7u537OPe95z3NXr151z33uc91b3/rW5Pfv/d7vdX/sj/0xd3Jy4h566CH37d/+7e709DRbJpCw286V1yAKLuw2twa9+MUvLq5/BsNFRuOcc4cgYgaDwWAwGAwGg8FwaFiUOYPBYDAYDAaDwXBpYYTIYDAYDAaDwWAwXFoYITIYDAaDwWAwGAyXFkaIDAaDwWAwGAwGw6WFESKDwWAwGAwGg8FwaWGEyGAwGAwGg8FgMFxaGCEyGAwGg8FgMBgMlxZGiAwGg8FgMBgMBsOlhREig8FgMBgMBoPBcGlhhMhgMBgMBoPBYDBcWhghMhgMBoPBYDAYDJcW/3+hPIRJx3rgkQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "sky = cro.Sky.gsm(beam.frequencies, lmax=beam.lmax)\n", "hp.mollview(sky.hp_map(nside)[0], title=f\"Sky at {freq[0]:.0f} MHz\")" @@ -73,10 +104,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "9a5e0c5e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(sky.frequencies, np.real(sky[:, 0, 0]), label=\"Sky monopole spectrum\")\n", @@ -89,26 +131,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "10ca4c8e", - "metadata": { - "scrolled": false - }, + "metadata": {}, "outputs": [], "source": [ "# let's do a full sidereal day on the moon\n", "loc = (20., -10.)\n", "t_start = Time(\"2022-06-02 15:43:43\")\n", "t_end = t_start + cro.constants.sidereal_day_moon * seconds\n", - "sim = cro.Simulator(beam, sky, loc, t_start, world=\"moon\", t_end=t_end, N_times=300, lmax=lmax)" + "times = cro.simulatorbase.time_array(t_start=t_start, t_end=t_end, N_times=300)\n", + "sim = cro.Simulator(beam, sky, lmax=lmax, world=\"moon\", location=loc, times=times)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "a077a8e9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# the simulator view of the beam and sky after moving to MCMF coordinates\n", "hp.mollview(sim.beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")\n", @@ -125,12 +187,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "394a8fe8", - "metadata": { - "scrolled": false - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# dpss mode\n", "sim.run(dpss=True, nterms=40)\n", @@ -139,10 +210,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "9e0b5493", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "sim.run(dpss=False)\n", "sim.plot(power=2.5)" @@ -150,10 +232,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "79fb8cac", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(sim.frequencies, sim.waterfall[::10].T, ls=\"--\")\n", @@ -166,12 +259,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "65f0df23", - "metadata": { - "scrolled": false - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Temp vs time\n", "fig, axs = plt.subplots(figsize=(13,5), ncols=5, sharex=True, sharey=True)\n", @@ -195,10 +297,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "3e2b917b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "TypeError", + "evalue": "SimulatorBase.__init__() got an unexpected keyword argument 't_end'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[16], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m t_start \u001b[38;5;241m=\u001b[39m Time(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m2022-06-02 15:43:43\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 3\u001b[0m t_end \u001b[38;5;241m=\u001b[39m t_start \u001b[38;5;241m+\u001b[39m cro\u001b[38;5;241m.\u001b[39mconstants\u001b[38;5;241m.\u001b[39msidereal_day_earth \u001b[38;5;241m*\u001b[39m seconds\n\u001b[0;32m----> 4\u001b[0m sim \u001b[38;5;241m=\u001b[39m \u001b[43mcro\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSimulator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbeam\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msky\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt_start\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mworld\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mearth\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt_end\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mt_end\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mN_times\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m300\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlmax\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlmax\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mTypeError\u001b[0m: SimulatorBase.__init__() got an unexpected keyword argument 't_end'" + ] + } + ], "source": [ "loc = (20., -10.)\n", "t_start = Time(\"2022-06-02 15:43:43\")\n", @@ -206,6 +320,21 @@ "sim = cro.Simulator(beam, sky, loc, t_start, world=\"earth\", t_end=t_end, N_times=300, lmax=lmax)" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac00860d-a805-45c0-9086-f731c0a6c98e", + "metadata": {}, + "outputs": [], + "source": [ + "# let's do a full sidereal day on the moon\n", + "loc = (20., -10.)\n", + "t_start = Time(\"2022-06-02 15:43:43\")\n", + "t_end = t_start + cro.constants.sidereal_day_moon * seconds\n", + "times = cro.simulatorbase.time_array(t_start=t_start, t_end=t_end, N_times=300)\n", + "sim = cro.Simulator(beam, sky, lmax=lmax, world=\"moon\", location=loc, times=times)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -266,7 +395,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/notebooks/jax_example.ipynb b/notebooks/jax_example.ipynb index 4973c97..7883dd2 100644 --- a/notebooks/jax_example.ipynb +++ b/notebooks/jax_example.ipynb @@ -12,9 +12,13 @@ "jax.config.update(\"jax_enable_x64\", True)\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", + "from astropy.time import Time\n", + "from astropy.units import s as seconds\n", "import s2fft\n", "from healpy import mollview\n", - "from croissant import crojax" + "from croissant import crojax\n", + "from croissant import constants\n", + "from croissant.simulatorbase import time_array" ] }, { @@ -147,9 +151,11 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "9a5e0c5e", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { @@ -174,18 +180,109 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "10ca4c8e", + "execution_count": 7, + "id": "fed65b68-c628-4794-b5d6-6173abecdf09", "metadata": {}, "outputs": [], + "source": [ + "L = lmax + 1\n", + "flmn = jnp.zeros((2*L-1, L, 2*L-1)) # n, l, m\n", + "flmn = flmn.at[lmax, 0, lmax].set(1) # 0, 0, 0\n", + "s = s2fft.wigner.inverse(flmn, L, L, method=\"jax\", reality=True) # gamma, beta, alpha" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "fd17283b-6e1a-444e-b24b-05eaf12cbe9b", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'alpha' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43malpha\u001b[49m[\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m-\u001b[39malpha[\u001b[38;5;241m0\u001b[39m]\n", + "\u001b[0;31mNameError\u001b[0m: name 'alpha' is not defined" + ] + } + ], + "source": [ + "alpha[1]-alpha[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "33bd1770-1780-4a41-871b-42bcf99b4f24", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(257, 129, 257)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "10ca4c8e", + "metadata": {}, + "outputs": [ + { + "ename": "NotImplementedError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNotImplementedError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[9], line 6\u001b[0m\n\u001b[1;32m 4\u001b[0m t_end \u001b[38;5;241m=\u001b[39m t_start \u001b[38;5;241m+\u001b[39m constants\u001b[38;5;241m.\u001b[39msidereal_day_moon \u001b[38;5;241m*\u001b[39m seconds\n\u001b[1;32m 5\u001b[0m times \u001b[38;5;241m=\u001b[39m time_array(t_start\u001b[38;5;241m=\u001b[39mt_start, t_end\u001b[38;5;241m=\u001b[39mt_end, N_times\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m300\u001b[39m)\n\u001b[0;32m----> 6\u001b[0m sim \u001b[38;5;241m=\u001b[39m \u001b[43mcrojax\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSimulator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbeam\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msky\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlmax\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlmax\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mworld\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmoon\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlocation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mloc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimes\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/projects/croissant/.venv/lib/python3.10/site-packages/croissant/simulatorbase.py:135\u001b[0m, in \u001b[0;36mSimulatorBase.__init__\u001b[0;34m(self, beam, sky, lmax, frequencies, world, location, times)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbeam\u001b[38;5;241m.\u001b[39mcompute_total_power()\n\u001b[1;32m 134\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbeam\u001b[38;5;241m.\u001b[39mcoord \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msim_coord:\n\u001b[0;32m--> 135\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbeam\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mswitch_coords\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 136\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msim_coord\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlocation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtime\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mt_start\u001b[49m\n\u001b[1;32m 137\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 138\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbeam\u001b[38;5;241m.\u001b[39mlmax \u001b[38;5;241m>\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlmax:\n\u001b[1;32m 139\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbeam\u001b[38;5;241m.\u001b[39mreduce_lmax(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlmax)\n", + "File \u001b[0;32m~/Documents/projects/croissant/.venv/lib/python3.10/site-packages/croissant/crojax/healpix.py:223\u001b[0m, in \u001b[0;36mAlm.switch_coords\u001b[0;34m(self, to_coord, loc, time)\u001b[0m\n\u001b[1;32m 222\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mswitch_coords\u001b[39m(\u001b[38;5;28mself\u001b[39m, to_coord, loc\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, time\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m--> 223\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m\n", + "\u001b[0;31mNotImplementedError\u001b[0m: " + ] + } + ], "source": [ "# let's do a full sidereal day on the moon\n", "loc = (20., -10.)\n", "t_start = Time(\"2022-06-02 15:43:43\")\n", - "t_end = t_start + cro.constants.sidereal_day_moon * seconds\n", - "sim = cro.Simulator(beam, sky, loc, t_start, world=\"moon\", t_end=t_end, N_times=300, lmax=lmax)" + "t_end = t_start + constants.sidereal_day_moon * seconds\n", + "times = time_array(t_start=t_start, t_end=t_end, N_times=300)\n", + "sim = crojax.Simulator(beam, sky, lmax=lmax, world=\"moon\", location=loc, times=times)" ] }, + { + "cell_type": "code", + "execution_count": 11, + "id": "21ee8508-e60b-45bd-a07f-3268671629d3", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'Beam' object has no attribute 'data'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mbeam\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[38;5;241m.\u001b[39mshape\n", + "\u001b[0;31mAttributeError\u001b[0m: 'Beam' object has no attribute 'data'" + ] + } + ], + "source": [] + }, { "cell_type": "code", "execution_count": null, From c5d337367da8d7f42c8c4f3d3b1181340563564d Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 1 Feb 2024 14:29:42 -0800 Subject: [PATCH 067/129] initial commit --- notebooks/dpss.ipynb | 319 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 319 insertions(+) create mode 100644 notebooks/dpss.ipynb diff --git a/notebooks/dpss.ipynb b/notebooks/dpss.ipynb new file mode 100644 index 0000000..94a50cd --- /dev/null +++ b/notebooks/dpss.ipynb @@ -0,0 +1,319 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7cf7036d-747f-49dd-a4f4-f5e9db5ff967", + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "jax.config.update(\"jax_enable_x64\", True)\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import s2fft\n", + "from healpy import mollview\n", + "from croissant import crojax" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f91c0e4e-1e94-4583-b2de-df8587f642df", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "freqs = jnp.linspace(10, 50, 41)\n", + "lmax = 128\n", + "sky = crojax.Sky.gsm(freqs, lmax=lmax)\n", + "ix = -1\n", + "m = sky.alm2map(sampling=\"healpix\", nside=64, frequencies=freqs[ix])\n", + "mollview(m[0], title=f\"Sky at {freqs[ix]:.0f} MHz\")" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "890007b4-ed71-43ee-9ddc-032755261cf1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfft\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfftfreq\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mArray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbool_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumber\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcomplex\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mArray\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Return the Discrete Fourier Transform sample frequencies.\n", + "\n", + "LAX-backend implementation of :func:`numpy.fft.fftfreq`.\n", + "\n", + "*Original docstring below.*\n", + "\n", + "The returned float array `f` contains the frequency bin centers in cycles\n", + "per unit of the sample spacing (with zero at the start). For instance, if\n", + "the sample spacing is in seconds, then the frequency unit is cycles/second.\n", + "\n", + "Given a window length `n` and a sample spacing `d`::\n", + "\n", + " f = [0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n) if n is even\n", + " f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n) if n is odd\n", + "\n", + "Parameters\n", + "----------\n", + "n : int\n", + " Window length.\n", + "d : scalar, optional\n", + " Sample spacing (inverse of the sampling rate). Defaults to 1.\n", + "dtype : Optional\n", + " The dtype of the returned frequencies. If not specified, JAX's default\n", + " floating point dtype will be used.\n", + "\n", + "Returns\n", + "-------\n", + "f : ndarray\n", + " Array of length `n` containing the sample frequencies.\n", + "\u001b[0;31mFile:\u001b[0m ~/Documents/projects/croissant/.venv/lib/python3.10/site-packages/jax/_src/numpy/fft.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "jnp.fft.fftfreq?" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "a83793d6-1e1e-4732-a688-5f2b0269cd82", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(jnp.fft.fftshift(jnp.fft.fftfreq(freqs.size, 1e6*(freqs[1]-freqs[0])))*1e9, jnp.fft.fftshift(jnp.fft.fft(beam[:, 0, 0])))\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "ac9edb4b-d2b3-4d6e-831e-2ef447fa4b95", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAGdCAYAAADwjmIIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABV/0lEQVR4nO3de1xUZeIG8GdmmBmuM8gdFBFEQRQxMZG8pMmKRqXZVpqVuXbRxf2ltmXullp70Wp32y5mW+2m21XdXa00NVLEG95QVK6igqAw3JQZQK4z7+8PZJK8gQJnLs/385lPMvMyPMeTzuM57zmvTAghQERERGRj5FIHICIiIuoKLDlERERkk1hyiIiIyCax5BAREZFNYskhIiIim8SSQ0RERDaJJYeIiIhsEksOERER2SQHqQNIyWQyobi4GG5ubpDJZFLHISIionYQQqC6uhoBAQGQy69/vMauS05xcTECAwOljkFERES3oKioCL169bru63Zdctzc3AC0/CZpNBqJ0xAREVF7GAwGBAYGmj/Hr8euS07rKSqNRsOSQ0REZGVuNtWEE4+JiIjIJrHkEBERkU1iySEiIiKbxJJDRERENoklh4iIiGwSSw4RERHZJJYcIiIiskksOURERGSTWHKIiIjIJrHkEBERkU1iySEiIiKbxJJDRERENoklh8gG1DcZ8VlqATYePQ8hhNRxiIgsgl2vQk5k7ZqNJqxPO4e//3gSpYYGAEBSdineeGgwXNX8401E9o1/CxJZISEEtmbo8NYPuThTXgsA8NM4oqKmAZuPlyC7xIBVM6IR5ucmcVIiIumw5BBZmX2nKvDG1hwcO6cHAHi4qJA4LhSPj+iNjPN6zPvyKM6U12Lyyj3405RIPBTdS+LERETSkAk7PoFvMBig1Wqh1+uh0WikjkN0Qxnn9Xhjaw5251UAAJxVCjw9OgTPjA6Gm6PSPK6ypgHz16abx00fHoil9w+Eo1IhSW4ios7W3s9vlhyWHLJwBRW1+MsPudh0vAQAoFTIMCMmCInjQuHtpr7m9xhNAu/tyMM72/MgBBDhr8Gqx4ciyNOlO6MTEXUJlpx2YMkhS9ZsNOGPm7Px+f6zaDYJyGTA5KgALPxFGHp7OrfrPXbnleP5r9NxobYRbo4O+MvDUYgf6NfFyYmIulZ7P795CTmRhVp3+BxW7ytAs0lgXJg3Nv9mNP4+7Y52FxwAGN3PG5v/bxSig3qgur4Zz32Whj9tzkKT0dSFyYmILANLDpGF2pLRcnrq+fH98Oms4YgIuLWjjf5aJ3z97Ag8PSoYAPDx7nxM/2g/dPr6TstKRGSJWHKILJC+rgmppysBAJOHBNz2+ykVcrxyXwRWzRgKN7UDDp+9iPve241TZTW3/d5ERJaKJYfIAiXnlKHZJNDPxxUh3q6d9r6TIv3x3W9GIdzPDRU1jZi95hAu1jZ22vsTEVkSlhwiC7QtUwcAmDDQt9Pfu4+XC754Oga9ejjhbOUlzP0iDY3NnKNDRLaHJYfIwtQ3GZFyshwAuuxKKE9XNf458064qBTYf+YCln6bwTWviMjmsOQQWZg9eRW41GhEgNYRkT21XfZzwvzc8N5jd0AmA746WIRP9xZ02c8iIpICSw6RhfnpVJUfZDJZl/6se8J98ft7BwAA/rg5C8m5ZV3684iIuhNLDpEFaTaa8GN2KYCumY9zLbNHBePRYYEwCeA3Xx7FydLqbvm5RERdjSWHyIIcPnsRFy81wd1ZieF9PLrlZ8pkMvxhyiAMD/ZATUMzZq85hAu84oqIbABLDpEFaT1VNT7cFw6K7vvjqXKQ48PHo9HbwxlFF+ow5zNecUVE1o8lh8hCCCHwQ2bLqar4bjpVdSUPFxX+OXMY3NQOOFhwAb/fcIJXXBGRVWPJIbIQmcUGnK+qg5NSgTH9vSXJ0M+35YoruQxYn3YOn+zOlyQHEVFnYMkhshCtp6rG9PeCo1IhWY6xYT549b4IAMCft2Rj++WJ0ERE1oYlh8hC/HSqqmtuANgRT93VB4/F9IYQwP99dRQ5OoPUkYiIOowlh8gCFFTUIre0Gg5yGcaHd/98nJ+TyWR47YGBuKuvJ2objZi9+jAqahqkjkVE1CEsOUQWoPVU1YgQT2idlRKnaaFUyPHBjKHo4+mM81V1WPJNhtSRiIg6pEMlZ9WqVRg8eDA0Gg00Gg1iY2OxZcsW8+v19fVITEyEp6cnXF1d8dBDD6G0tO35/MLCQiQkJMDZ2Rk+Pj548cUX0dzc3GbMzp07MXToUKjVaoSGhmL16tVXZVm5ciX69OkDR0dHxMTE4ODBgx3ZFCKL0pULct4Od2cVVs4YCrkM+P6EDvvPVEodiYio3TpUcnr16oUVK1YgLS0Nhw8fxj333IPJkycjMzMTALBgwQJ89913WL9+PVJSUlBcXIypU6eav99oNCIhIQGNjY3Yt28f1qxZg9WrV2PJkiXmMfn5+UhISMC4ceOQnp6O+fPn4+mnn8a2bdvMY9auXYuFCxdi6dKlOHLkCKKiohAfH4+yMt6SnqxPmaEeR4uqAAATIqSfj/NzAwO0mD68NwDg9e+yYDTxsnIishLiNvXo0UN88sknoqqqSiiVSrF+/Xrza9nZ2QKASE1NFUII8f333wu5XC50Op15zKpVq4RGoxENDQ1CCCFeeuklMXDgwDY/49FHHxXx8fHmr4cPHy4SExPNXxuNRhEQECCWL1/eoex6vV4AEHq9vkPfR9SZPt9fIIIWbRIPvL9H6ijXVVFdLwYt3SqCFm0SXx44K3UcIrJz7f38vuU5OUajEV9//TVqa2sRGxuLtLQ0NDU1IS4uzjwmPDwcvXv3RmpqKgAgNTUVkZGR8PX96ZB8fHw8DAaD+WhQampqm/doHdP6Ho2NjUhLS2szRi6XIy4uzjzmehoaGmAwGNo8iKS2TcIbALaXp6sa8+P6AwD+si0X+romiRMREd1ch0vOiRMn4OrqCrVajTlz5mDDhg2IiIiATqeDSqWCu7t7m/G+vr7Q6VrmG+h0ujYFp/X11tduNMZgMKCurg4VFRUwGo3XHNP6HtezfPlyaLVa8yMwMLCjm0/UqQz1TUg9XQHAMi4dv5EnY4PQ19sFlbWNeG97ntRxiIhuqsMlJywsDOnp6Thw4ADmzp2LmTNnIisrqyuydbrFixdDr9ebH0VFRVJHIjuXnFOGJqNAX28X9PV2lTrODSkVcvNNAlfvK8Dp8hqJExER3ViHS45KpUJoaCiio6OxfPlyREVF4Z133oGfnx8aGxtRVVXVZnxpaSn8/Fr+hern53fV1VatX99sjEajgZOTE7y8vKBQKK45pvU9rketVpuvDGt9EEnJkm4A2B5jw3xwT7gPmk0Cf9qcLXUcIqIbuu375JhMJjQ0NCA6OhpKpRLbt283v5abm4vCwkLExsYCAGJjY3HixIk2V0ElJSVBo9EgIiLCPObK92gd0/oeKpUK0dHRbcaYTCZs377dPIbIGtQ3GbEzt+XPgrWUHAD4fcIAOMhl2JFThuRcXtFIRJarQyVn8eLF2LVrFwoKCnDixAksXrwYO3fuxIwZM6DVajF79mwsXLgQycnJSEtLw6xZsxAbG4sRI0YAACZMmICIiAg88cQTOHbsGLZt24ZXXnkFiYmJUKvVAIA5c+bgzJkzeOmll5CTk4MPPvgA69atw4IFC8w5Fi5ciI8//hhr1qxBdnY25s6di9raWsyaNasTf2uIutbeUxWobTTCT+OIwb20Usdpt77ernjqrj4AgD9sykKT0SRtICKi63DoyOCysjI8+eSTKCkpgVarxeDBg7Ft2zb84he/AAC8/fbbkMvleOihh9DQ0ID4+Hh88MEH5u9XKBTYtGkT5s6di9jYWLi4uGDmzJl4/fXXzWOCg4OxefNmLFiwAO+88w569eqFTz75BPHx8eYxjz76KMrLy7FkyRLodDoMGTIEW7duvWoyMpElu/IGgDKZTOI0HfOb8f2w4eh5nCmvxb9Tz2L2qGCpIxERXUUmhLDbO3sZDAZotVro9XrOz6FuZTQJ3PmnH3GhthFfPB2DkaFeUkfqsK8OFmLx/07AzdEBO387Fp6uaqkjEZGdaO/nN9euIpLA4YILuFDbCK2TEsODPaSOc0seGRaICH8Nquub8bekk1LHISK6CksOkQRabwA4foAPlArr/GOokMuw9P6WCwa+OliIrGLeXJOILIt1/u1KZMWEEOb5ONZ0VdW1xIR4IiHSHyYBvL4pE3Z89puILBBLDlE3yyox4HxVHRyVcozp5y11nNv28qRwqB3k2H/mArZm3Piu40RE3Yklh6ibtZ6qGtPPG04qhcRpbl+ghzOeGxMCAPjT99mobzJKnIiIqAVLDlE3+8FGTlVdac7YvvDTOOLcxTr8c0++1HGIiACw5BB1q7OVtcjRVUMhl2H8AB+p43QaZ5UDXp4UDgBYmXwKOn29xImIiFhyiLpV61pVMcEecHdWSZymc00eEoChvd1xqdGIxf87jrpGnrYiImmx5BB1o50nW9Z6+kWE7d2dWyaTYdkDA6FUyJCcW45ffrgP56vqpI5FRHaMJYeom9Q3GXG44CIAYHQ/67vDcXsM7uWOz2fHwNNFhcxiAx54bw8OnKmUOhYR2SmWHKJucrSwCg3NJni7qdHX21XqOF0mJsQT3/5mFAYGaFBZ24gZnxzAZ/vP8h46RNTtWHKIusm+0xUAgLv6elrdgpwd1dPdCf+ZcxfujwpAs0ng1Y0Z+N2GDDQ2c8VyIuo+LDlE3WTf6ZbTNiP72uapqp9zUinw7rQheHlSOGSylqUfHvt4P8qrG6SORkR2giWHqBvUNDTjWFEVACC2r6e0YbqRTCbDnLv74l9P3Qk3RwccPnsRD7y/B8fPVUkdjYjsAEsOUTc4VHABzSaBQA8nBHo4Sx2n240L88E3iSPR19sFJfp6PPxhKjYcPSd1LCKycSw5RN1g36nL83FC7ONU1bWEeLtiY+JIjA/3QUOzCQvWHsOfNmeh2ch5OkTUNVhyiLpB63ycu0Lt51TVtbg5KvHxk8Mwb1woAODj3fl45t+HYTTxyisi6nwsOURd7GJtI7JKDADsaz7O9cjlMvw2PgwfzBgKJ6UCybnlWH+4SOpYRGSDWHKIutiB/EoIAfTzcYWPm6PUcSzGvZH++G18GADgLz+cRE1Ds8SJiMjWsOQQdbG9py6fquJRnKs8MSIIwV4uqKhpwKqdp6SOQ0Q2hiWHqIuZbwIYar+Tjq9H5SDH4surl3+8Ox/nLl6SOBER2RKWHKIuVGqox+nyWshkwIhgHsm5ll9E+CI2xBONzSa8sTVX6jhEZENYcoi6UOrlq6oGBWihdVZKnMYyyWQyvHLfAMhkwHfHipF29qLUkYjIRrDkEHWhvad+Wq+Krm9ggBYPR/cCAPxxcxYX8ySiTsGSQ9RFhBBX3B+H83Fu5rcTwuCsUuBoYRW+PVYsdRwisgEsOURdpOhCHc5X1cFBLsOdfXpIHcfi+WgcMffuvgCAN7fmor7JKHEiIrJ2LDlEXaT1qqo7ervDWeUgcRrr8MyYEARoHXG+qg7/3JMvdRwisnIsOURdZO/lU1WxfXmqqr0clQq8NLHlkvIPkk+hrLpe4kREZM1Ycoi6gBACqZeP5IzkpOMOeSAqAFGB7qhtNOJvP5yUOg4RWTGWHKIukFdWg4qaRjgq5RjS213qOFZFLpdhyX0DAABrDxchq9ggcSIislYsOURdYN/lS8fv7OMBtYNC4jTWJzrIAwmD/SEELyknolvHkkPUBX6aj8NTVbfq5YnhUDnIse90JbZnl0kdh4isEEsOUSczmgT2n2kpOSM56fiWBXo441cjgwEAf/4+G43NJokTEZG1Yckh6mSZxXpU1zfDzdEBAwM0Usexaonj+sLTRYUzFbX44sBZqeMQkZVhySHqZK13OY4J9oSDgn/EboeboxILJ/QHAPz9xzxUXWqUOBERWRP+DUzUybheVed6dFggwnzdoK9rwjvb86SOQ0RWhCWHqBM1NptwqOACAGAk16vqFA4KOV65fEn5Z6lnkXFeL3EiIrIWLDlEnSi9qAr1TSZ4uqjQ39dV6jg2Y3Q/b4wP90GzSeDJfx1Ejo73ziGim2PJIepEretVxfb1hEwmkziNbfnbI0MQ2VOLC7WNeOzjAyw6RHRTLDlEnWjfqZZJx3fx0vFOp3VW4vPZMW2KTq6uWupYRGTBWHKIOsmlxmYcLboIABgZyknHXaG16AzqqblcdPbjZCmLDhFdG0sOUSc5XHARTUaBnu5O6O3hLHUcm9VadAYGaFB5uejksegQ0TWw5BB1kn1XLOXA+Thdy91ZhS+ebik6FTWNmM6iQ0TX0KGSs3z5ctx5551wc3ODj48PpkyZgtzc3DZjxo4dC5lM1uYxZ86cNmMKCwuRkJAAZ2dn+Pj44MUXX0Rzc3ObMTt37sTQoUOhVqsRGhqK1atXX5Vn5cqV6NOnDxwdHRETE4ODBw92ZHOIOlXrpGPeH6d7tBadCP/WonMAp8pYdIjoJx0qOSkpKUhMTMT+/fuRlJSEpqYmTJgwAbW1tW3GPfPMMygpKTE/3nzzTfNrRqMRCQkJaGxsxL59+7BmzRqsXr0aS5YsMY/Jz89HQkICxo0bh/T0dMyfPx9PP/00tm3bZh6zdu1aLFy4EEuXLsWRI0cQFRWF+Ph4lJVxIT/qfvpLTeb7t3DScfdpW3QaMO0jFh0i+olMCCFu9ZvLy8vh4+ODlJQUjBkzBkDLkZwhQ4bg73//+zW/Z8uWLbjvvvtQXFwMX19fAMCHH36IRYsWoby8HCqVCosWLcLmzZuRkZFh/r5p06ahqqoKW7duBQDExMTgzjvvxPvvvw8AMJlMCAwMxG9+8xu8/PLL7cpvMBig1Wqh1+uh0XCNIbp1P2Tq8OxnaQjxdsGOF8ZKHcfuXKxtxGOfHEB2iQFermp8/ewIhPrwPkVEtqq9n9+3NSdHr2/5l6uHh0eb57/44gt4eXlh0KBBWLx4MS5dumR+LTU1FZGRkeaCAwDx8fEwGAzIzMw0j4mLi2vznvHx8UhNTQUANDY2Ii0trc0YuVyOuLg48xii7tQ6H4enqqTRw6XliE64nxsqahow/eP9OF1eI3UsIpLYLZcck8mE+fPnY+TIkRg0aJD5+cceewyff/45kpOTsXjxYnz22Wd4/PHHza/rdLo2BQeA+WudTnfDMQaDAXV1daioqIDRaLzmmNb3uJaGhgYYDIY2D6LOkHqa98eRmoeLCl8+MwLhfm4or27A9I/2I7+i9ubfSEQ2y+FWvzExMREZGRnYs2dPm+efffZZ868jIyPh7++P8ePH4/Tp0+jbt++tJ+0Ey5cvx2uvvSZpBrI95dUNyL18ZU9sCI/kSKm16Dz28X7k6Kqx6L/HsfbZEbzajchO3dKRnHnz5mHTpk1ITk5Gr169bjg2JiYGAHDq1CkAgJ+fH0pLS9uMaf3az8/vhmM0Gg2cnJzg5eUFhUJxzTGt73Etixcvhl6vNz+KiorasbVEN5Z6puUoToS/Bj1cVBKnIQ8XFf711J1QKeQ4mH/BfJSNiOxPh0qOEALz5s3Dhg0bsGPHDgQHB9/0e9LT0wEA/v7+AIDY2FicOHGizVVQSUlJ0Gg0iIiIMI/Zvn17m/dJSkpCbGwsAEClUiE6OrrNGJPJhO3bt5vHXItarYZGo2nzILpdqbx03OIEuDth+vBAAMDbP57EbVxfQURWrEMlJzExEZ9//jm+/PJLuLm5QafTQafToa6uDgBw+vRp/OEPf0BaWhoKCgrw7bff4sknn8SYMWMwePBgAMCECRMQERGBJ554AseOHcO2bdvwyiuvIDExEWq1GgAwZ84cnDlzBi+99BJycnLwwQcfYN26dViwYIE5y8KFC/Hxxx9jzZo1yM7Oxty5c1FbW4tZs2Z11u8NUbuY5+NwKQeL8utxoVA5yHGo4CL2nKqQOg4RSUF0AIBrPj799FMhhBCFhYVizJgxwsPDQ6jVahEaGipefPFFodfr27xPQUGBmDRpknBychJeXl7ihRdeEE1NTW3GJCcniyFDhgiVSiVCQkLMP+NK7733nujdu7dQqVRi+PDhYv/+/R3ZHKHX6wWAq/IRtZehrlEELdokghZtEhdqGqSOQz+z7NsMEbRok3hw5R5hMpmkjkNEnaS9n9+3dZ8ca8f75NDtOlRwAQ9/mAp/rSNSF4+XOg79TFl1Pca8mYz6JhNWz7oTY8N8pI5ERJ2gW+6TQ2TvsopbbkMQ4c+SbIl83BzxeEwQAODtH/M4N4fIzrDkEN2G7JKWkjOAJcdiPXd3Xzgq5ThWVIXkXC77QmRPWHKIbgNLjuXzdlNjZmwfAMDfeTSHyK6w5BDdIqNJmG8COMDfTeI0dCPPjgmBs0qB4+f02J7NozlE9oIlh+gW5VfUor7JBCelAkGeLlLHoRvwdFVj5l19APC+OUT2hCWH6BZlXT5VFe7vBoWcywZYumdHh8BFpUBmsQE/ZJXe/BuIyOqx5BDdIs7HsS49XFSYNbLlLu1vJ52EycSjOUS2jiWH6Bax5Fifp0cHw03tgBxdNbZl6qSOQ0RdjCWH6Ba1lpwITjq2Gu7OKswa1XI05+8/5vFoDpGNY8khugWVNQ0oNTRAJgPC/Hgkx5rMHhUMN0cH5JZW4/uMEqnjEFEXYskhugXZJS2Xjgd5OMNV7SBxGuoIrZMSsy8fzXnnxzwYeTSHyGax5BDdAs7HsW6/GhUMjaMD8spqsOl4sdRxiKiLsOQQ3QKWHOumcVTimdEhAIB3tvNoDpGtYskhugVZLDlW76mRfeDurMSZ8lp8e+y81HGIqAuw5BB1UEOzEafKagAAEQEsOdbK7YqjOe9uP4Vmo0niRETU2VhyiDroVFkNmk0CGkcHBGgdpY5Dt2HmXX3g4aJCfkUtNqZzbg6RrWHJIeqg1iurBvhrIJNxOQdr5qp2wLNjWo7m/O2HXFysbZQ4ERF1JpYcog7ipGPb8mRsEII8nVGsr8f/fX2Uk5CJbAhLDlEHZRVfvtMx5+PYBGeVAz58PBqOSjl251Xg7aSTUkciok7CkkPUAUIIZOtal3NgybEVA/w1eOOhwQCA95NP4Qeua0VkE1hyiDpAZ6hH1aUmKOQyhPq4Sh2HOtHkIT0xa2QfAMDCdcdwurxG2kBEdNtYcog6oHU+Tl9vFzgqFRKnoc72u3sHYHgfD9Q0NGPOZ2mobWiWOhIR3QaWHKIOuPLKKrI9SoUc78+4Az5uauSV1eCl/xyHEJyITGStWHKIOsA86Zglx2b5uDli1eNDoVTIsPlECT7efUbqSER0i1hyiDqAl4/bh+ggDyy5LwIAsGJLDvadqpA4ERHdCpYcona61NiM/MpaACw59uDxEUGYOrQnTAKY99VRFFfVSR2JiDqIJYeonXJ11RAC8HJVw9tNLXUc6mIymQx/fjASEf4aXKhtxNwvjqCh2Sh1LCLqAJYconZqXXmcNwG0H45KBf7xRDS0TkocK6rCsm+zpI5ERB3AkkPUTj/Nx3GTOAl1p0APZ7w7/Q7IZMBXBwux9lCh1JGIqJ1YcojaqfXycV5ZZX/u7u+NF37RHwDw6jeZOFZUJW0gImoXlhyidjCZBHJ4ZZVd+/XYUPwiwheNzSbM/TwNhvomqSMR0U2w5BC1Q+GFS6htNELlIEeIl4vUcUgCcrkMf30kyrxi+aqdp6WOREQ3wZJD1A6t83HCfN3goOAfG3ulcVTilYSW++f8a08+LysnsnD825qoHTjpmFrFDfDB8GAPNDSb8NcfTkodh4hugCWHqB2yuGYVXSaTyfC7ewcAAP539Jx5qQ8isjwsOUTtwOUc6EpDAt1x32B/CAEs35ItdRwiug6WHKKb0F9qwvnLcy9YcqjVS/HhUCpk2J1XgV0ny6WOQ0TXwJJDdBPZupajOD3dnaB1UkqchixFb09nPDGiDwBg+ZYcGE1C2kBEdBWWHKKb4Kkqup7f3BMKN0cHZJcYsOHoeanjENHPsOQQ3URryYnglVX0Mz1cVJg3LhQA8NcfclHfxAU8iSwJSw7RTWTxSA7dwMy7+qCnuxNK9PX41958qeMQ0RVYcohuoNlowsnSGgBcfZyuzVGpwG/jW9a1WpV8GpU1DRInIqJWLDlEN3CmohaNzSa4qBQI7OEsdRyyUJOjemJggAbVDc14b8cpqeMQ0WUsOUQ30DofJ9xfA7lcJnEaslRy+U83CPx8/1kUVNRKnIiIgA6WnOXLl+POO++Em5sbfHx8MGXKFOTm5rYZU19fj8TERHh6esLV1RUPPfQQSktL24wpLCxEQkICnJ2d4ePjgxdffBHNzc1txuzcuRNDhw6FWq1GaGgoVq9efVWelStXok+fPnB0dERMTAwOHjzYkc0huqksLudA7TQy1Atjw7zRbBJ4c1uO1HGICB0sOSkpKUhMTMT+/fuRlJSEpqYmTJgwAbW1P/2rZcGCBfjuu++wfv16pKSkoLi4GFOnTjW/bjQakZCQgMbGRuzbtw9r1qzB6tWrsWTJEvOY/Px8JCQkYNy4cUhPT8f8+fPx9NNPY9u2beYxa9euxcKFC7F06VIcOXIEUVFRiI+PR1lZ2e38fhC10XrL/gh/rcRJyBosnjQAchnw/QkdjhRelDoOEYnbUFZWJgCIlJQUIYQQVVVVQqlUivXr15vHZGdnCwAiNTVVCCHE999/L+RyudDpdOYxq1atEhqNRjQ0NAghhHjppZfEwIED2/ysRx99VMTHx5u/Hj58uEhMTDR/bTQaRUBAgFi+fHm78+v1egFA6PX6Dmw12ZPoPySJoEWbxJGzF6SOQlbixfXpImjRJvHQB3uFyWSSOg6RTWrv5/dtzcnR6/UAAA8PDwBAWloampqaEBcXZx4THh6O3r17IzU1FQCQmpqKyMhI+Pr6msfEx8fDYDAgMzPTPObK92gd0/oejY2NSEtLazNGLpcjLi7OPOZaGhoaYDAY2jyIrqe8ugEVNQ2QyYAwP56uovZZ+IswOCrlOHz2IrZllt78G4ioy9xyyTGZTJg/fz5GjhyJQYMGAQB0Oh1UKhXc3d3bjPX19YVOpzOPubLgtL7e+tqNxhgMBtTV1aGiogJGo/GaY1rf41qWL18OrVZrfgQGBnZ8w8lutE46DvZ0gbPKQeI0ZC38tI54ZnQIAODNrTloMpokTkRkv2655CQmJiIjIwNff/11Z+bpUosXL4Zerzc/ioqKpI5EFow3AaRb9eyYEHi6qHCmohZfHyyUOg6R3bqlkjNv3jxs2rQJycnJ6NWrl/l5Pz8/NDY2oqqqqs340tJS+Pn5mcf8/Gqr1q9vNkaj0cDJyQleXl5QKBTXHNP6HteiVquh0WjaPIiux7ycA28CSB3k5qjE/Lh+AIC//5iH6vomiRMR2acOlRwhBObNm4cNGzZgx44dCA4ObvN6dHQ0lEoltm/fbn4uNzcXhYWFiI2NBQDExsbixIkTba6CSkpKgkajQUREhHnMle/ROqb1PVQqFaKjo9uMMZlM2L59u3kM0e3K5uXjdBumDe+NEC8XVNY24tWNGRCCq5QTdbcOlZzExER8/vnn+PLLL+Hm5gadTgedToe6ujoAgFarxezZs7Fw4UIkJycjLS0Ns2bNQmxsLEaMGAEAmDBhAiIiIvDEE0/g2LFj2LZtG1555RUkJiZCrVYDAObMmYMzZ87gpZdeQk5ODj744AOsW7cOCxYsMGdZuHAhPv74Y6xZswbZ2dmYO3cuamtrMWvWrM76vSE7Vt9kxOnyllsj8HQV3QqlQo4/PjgICrkMG9OLsTKZd0Im6nYduWQLwDUfn376qXlMXV2d+PWvfy169OghnJ2dxYMPPihKSkravE9BQYGYNGmScHJyEl5eXuKFF14QTU1NbcYkJyeLIUOGCJVKJUJCQtr8jFbvvfee6N27t1CpVGL48OFi//79HdkcXkJO13XiXJUIWrRJRL22jZcB0235LLVABC3aJIIWbRKbjhVLHYfIJrT381smhP0eQzUYDNBqtdDr9ZyfQ22sO1SEl/57HHf19cSXz4yQOg5Zude/y8K/9ubDUSnH2mdjERXoLnUkIqvW3s9vrl1FdA28soo60+8TBmBcmDfqm0x4+t+HUVxVJ3UkIrvAkkN0DdksOdSJFHIZ3p1+B8J83VBe3YCn1xxGbUPzzb+RiG4LSw7RzwgheGUVdTo3RyU+mTkMni4qZJUYMH9tOkwmu50tQNQtWHKIfubcxToY6pvhIJch1MdV6jhkQwI9nPHRk9FQOciRlFWKN7haOVGXYskh+pk9pyoAAIN6aqF2UEichmxNdJAH3vrlYADAP1LOYN1h3nmdqKuw5BD9zI6clhtV3hPuI3ESslWTh/TE/90TCgD4/YYT2H+mUuJERLaJJYfoCg3NRuy9fCSHJYe60vy4/kgY7I8mo8Ccz9NQUFErdSQim8OSQ3SFA2cu4FKjET5uagzkmlXUheRyGf76cBSiemlRdakJv1pzCPpLXOOKqDOx5BBdofVU1bgwH8hkMonTkK1zVCrw8ZPD4K91xJnyWiR+eQRNRpPUsYhsBksO0WVCCCTnXi45PFVF3cRH44hPZg6Ds0qBPacqsOzbTKkjEdkMlhyiy85U1OJs5SUoFTKM6ucldRyyIwMDtPj7o0MgkwFfHCjEZ6kFUkcisgksOUSXJV8+VRUT7AlXtYPEacjeTBjoh5fiwwEAy77LMk+AJ6Jbx5JDdJl5Pg5PVZFE5twdggfv6AmjSeDXXxxBPq+4IrotLDlEAKrrm3Aw/wIAXjpO0pHJZFg+NRJDAt2hr2vC02sOwVDPK66IbhVLDhGAPXkVaDYJBHu5INjLReo4ZMcclQp89GQ0/LWOOF1ei998eRRGrnFFdEtYcojQ9tJxIqn5uDni4yeHwVEpR8rJciz/PlvqSERWiSWH7J7JJJCcWw6Ap6rIcgzqqcVfHx4CAPhkTz7WHeIaV0QdxZJDdu/EeT0qahrgolJgeLCH1HGIzBIG++P58f0AAL/feAKHCi5InIjIurDkkN1rPVU1qp8XVA78I0GW5fnx/XBvpF/LGlefpeHcxUtSRyKyGvwbnexe612OeaqKLJFcLsNfHo7CwAANKmsb8fSaw6htaJY6FpFVYMkhu1ZWXY/j5/QAOOmYLJezygEfPzkMXq5q5OiqsWBtOky84oroplhyyK7tvDzhOLKnFj4aR4nTEF1fgLsTPnoyGioHOX7IKsXfkk5KHYnI4rHkkF1L5l2OyYoM7d0DK6ZGAgDeTz6Fb9LPS5yIyLKx5JDdamw2YXdey/pAnI9D1mLq0F6Yc3dfAMCi/x5H0QVORCa6HpYcsluHCy6gpqEZXq4qDO6plToOUbu9GB+G4cEeqG8y4fVNWVLHIbJYLDlkt1ovHb+7vw/kcpnEaYjaTyGX4Y9TBsFBLkNSVil+zCqVOhKRRWLJIbu1g5eOkxXr7+uG2aODAQDLvstEXaNR4kREloclh+zS2cpanCmvhYNchtH9vaSOQ3RL/u+efgjQOuLcxTqsTD4ldRwii8OSQ3ap9VTVsD49oHFUSpyG6Na4qB2w5P6BAIB/7DqN0+U1EicisiwsOWSXWksOT1WRtYsf6ItxYd5oMgos+SYDQvAmgUStWHLI7tQ2NOPAmZaFDllyyNrJZDK89sAgqB3k2HuqEt8dL5E6EpHFYMkhu7P3VAUajSYEejihr7er1HGIbltvT2ckjgsFAPxhUxYM9U0SJyKyDCw5ZHfMC3KG+UAm46XjZBueHROCYC8XlFc34G8/cMkHIoAlh+yMEALJOS3rVXEpB7IljkoFXnugZRLyv1MLkHFeL3EiIumx5JBdySoxQGeoh5NSgREhnlLHIepUY/p7I2GwP0wCeGVjBlcqJ7vHkkN2pXVBzpGhnnBUKiROQ9T5ltwXAVe1A9KLqrD2cJHUcYgkxZJDdmUHVx0nG+erccSCX/QHAKzYkoPKmgaJExFJhyWH7MaF2kYcLaoCAIwLY8kh2zUzNgjhfm7Q1zXhja05UschkgxLDtmNlJNlEAII93NDgLuT1HGIuoyDQo4/PTgIALDu8DkcLrggcSIiabDkkN3YcfmqKt4AkOxBdJAHHh0WCKBlEnKz0SRxIqLux5JDdqHZaEIKVx0nO7NoUjjcnZXI0VVj9b4CqeMQdTuWHLILRwqrYKhvhruzEnf07iF1HKJu4eGiwssTwwEAbyedRIm+TuJERN2LJYfsQutVVXf394ZCzrsck/14ZFgghvZ2R22jEa9s4AKeZF86XHJ27dqF+++/HwEBAZDJZNi4cWOb15966inIZLI2j4kTJ7YZc+HCBcyYMQMajQbu7u6YPXs2ampq2ow5fvw4Ro8eDUdHRwQGBuLNN9+8Ksv69esRHh4OR0dHREZG4vvvv+/o5pCdSOaq42Sn5HIZVjw0GEqFDNtzyvDtsWKpIxF1mw6XnNraWkRFRWHlypXXHTNx4kSUlJSYH1999VWb12fMmIHMzEwkJSVh06ZN2LVrF5599lnz6waDARMmTEBQUBDS0tLw1ltvYdmyZfjoo4/MY/bt24fp06dj9uzZOHr0KKZMmYIpU6YgIyOjo5tENu58VR1yS6shl7UcySGyN/193TBvXD8AwGvfZfHeOWQ3ZOI2jl3KZDJs2LABU6ZMMT/31FNPoaqq6qojPK2ys7MRERGBQ4cOYdiwYQCArVu34t5778W5c+cQEBCAVatW4fe//z10Oh1UKhUA4OWXX8bGjRuRk9Nyz4dHH30UtbW12LRpk/m9R4wYgSFDhuDDDz9sV36DwQCtVgu9Xg+NRnMLvwNkDT7ffxavbMzAsKAe+M/cu6SOQySJxmYTHnh/D3J01Zg8JADvTLtD6khEt6y9n99dMidn586d8PHxQVhYGObOnYvKykrza6mpqXB3dzcXHACIi4uDXC7HgQMHzGPGjBljLjgAEB8fj9zcXFy8eNE8Ji4urs3PjY+PR2pqaldsElmxZN7lmAgqBzneeGgw5DLgm/RibM8ulToSUZfr9JIzceJE/Pvf/8b27dvxxhtvICUlBZMmTYLRaAQA6HQ6+Pi0/bBxcHCAh4cHdDqdeYyvr2+bMa1f32xM6+vX0tDQAIPB0OZBtq2+yYi9pysA8C7HRFGB7nh6dAgA4PcbMmCob5I4EVHX6vSSM23aNDzwwAOIjIzElClTsGnTJhw6dAg7d+7s7B/VYcuXL4dWqzU/AgMDpY5EXSz1TCXqm0zw1zpigL+b1HGIJLcgrj/6eDpDZ6jHii1c8oFsW5dfQh4SEgIvLy+cOnUKAODn54eysrI2Y5qbm3HhwgX4+fmZx5SWtj2U2vr1zca0vn4tixcvhl6vNz+KirhCr61rPVU1NswHMhkvHSdyUimwfOpgAMCXBwqRerryJt9BZL26vOScO3cOlZWV8Pf3BwDExsaiqqoKaWlp5jE7duyAyWRCTEyMecyuXbvQ1PTTodSkpCSEhYWhR48e5jHbt29v87OSkpIQGxt73SxqtRoajabNg2yXEMJ8fxxeOk70k9i+nngspjcAYPH/jqOu0ShxIqKu0eGSU1NTg/T0dKSnpwMA8vPzkZ6ejsLCQtTU1ODFF1/E/v37UVBQgO3bt2Py5MkIDQ1FfHw8AGDAgAGYOHEinnnmGRw8eBB79+7FvHnzMG3aNAQEBAAAHnvsMahUKsyePRuZmZlYu3Yt3nnnHSxcuNCc4/nnn8fWrVvx17/+FTk5OVi2bBkOHz6MefPmdcJvC9mC0+U1OHexDiqFHCNDPaWOQ2RRXp4UDj+NIwoqL+HtH09KHYeoa4gOSk5OFgCuesycOVNcunRJTJgwQXh7ewulUimCgoLEM888I3Q6XZv3qKysFNOnTxeurq5Co9GIWbNmierq6jZjjh07JkaNGiXUarXo2bOnWLFixVVZ1q1bJ/r37y9UKpUYOHCg2Lx5c4e2Ra/XCwBCr9d39LeBrMA/Uk6JoEWbxOOf7Jc6CpFF+jFLJ4IWbRLBL28S6YUXpY5D1G7t/fy+rfvkWDveJ8e2TfsoFfvPXMDS+yMwa2Sw1HGILNLzXx/FN+nFCPdzw7fzRkHlwNV+yPJJep8cIqkZ6ptwuKDlnkqcj0N0fUvui4CHiwo5umqs2nla6jhEnYolh2zSnrwKNJsEQrxdEOTpInUcIovl6arG0vsjAADvJ+fhZGm1xImIOg9LDtkk81VVvAEg0U09EBWAuAE+aDIKvPSf4zCa7HYWA9kYlhyyOSaTwM5cXjpO1F4ymQx/mDIIbmoHpBdVYfW+AqkjEXUKlhyyOSfO61FR0whXtQOG9fGQOg6RVfDXOmHxvQMAAH/ZlovCyksSJyK6fSw5ZHNaT1WNCvXilSJEHTDtzkCMCPFAXZMRK7ZmSx2H6LbxE4BsTjJPVRHdErlchtceGASZDPj+hA7ZJVzEmKwbSw7ZlPLqBhw/pwcAjA33ljgNkfUJ83NDQmTLMjx/552Qycqx5JBNaZ1wHNlTCx83R4nTEFmn+XH9IJMB2zJLkXFeL3UcolvGkkM2pfVU1TieqiK6ZaE+bpgc1bKW4NtJPJpD1oslh2xGk9GE3ScrAHA+DtHtej6uPxRyGbbnlCG9qErqOES3hCWHbMahgguobmiGp4sKg3tqpY5DZNWCvVzw4B09AfBoDlkvlhyyGTtzywEAd4d5Qy6XSZyGyPr93z39oJDLkHKyHGlnL0gdh6jDWHLIZpiXcuCpKqJO0dvTGQ9H9wIAvJ2UJ3Eaoo5jySGbUHThEk6V1UAhl2F0P146TtRZEseFQqmQYc+pChw4Uyl1HKIOYckhm9B6FGdYUA9onZQSpyGyHYEeznhkWCAA4G9JJyEEF+8k68GSQzaBp6qIuk7iuFCoFHIcyL+A1NM8mkPWgyWHrN6lxmakXj6MzvvjEHW+AHcnPBbTGwCP5pB1Yckhq5d6uhKNzSb0dHdCPx9XqeMQ2aS5Y/tC7SDH4bMXsTuvQuo4RO3CkkNW78pTVTIZLx0n6gq+Gkc8PiIIAI/mkPVgySGrJoRAMufjEHWLOXf3haNSjvSiKvN9qYgsGUsOWbXc0moU6+vhqJQjtq+n1HGIbJq3mxozY/sA4NEcsg4sOWTVWk9V3dXXC45KhcRpiGzfs2NC4KxS4MR5PZKySqWOQ3RDLDlk1XbmtBwyHxfGGwASdQdPVzWeuqsPAODtH/NgMvFoDlkulhyyWvpLTUgrvAiAl44Tdadnx4TAVe2A7BIDtmXqpI5DdF0sOWS1UvLKYTQJ9Pd1Ra8ezlLHIbIb7s4q/GpUMADg7R9P8mgOWSyWHLJarfMBeBSHqPvNHhUMN0cHnCytweYTJVLHIbomlhyySiX6Omy5/BdrQqS/xGmI7I/WSYlnRocAAFZsyYH+UpPEiYiuxpJDVulfe/LRbBIYEeKBwb3cpY5DZJd+NSoYvT2ccb6qDi/+5xgvKSeLw5JDVkdf14QvDxQCAJ67u6/EaYjsl6vaASsfGwqVQo4fskrx6d4CqSMRtcGSQ1bn8/1nUdtoRLifG8b256XjRFKK7KXF7xMGAACWb8nGsaIqaQMRXYElh6xKfZPR/K/F5+4O4VpVRBbgydggTBzohyajQOKXR6Cv4/wcsgwsOWRVNhw9j4qaBgRoHXHf4ACp4xARAJlMhjd+ORiBHk44d7EOi/5znPNzyCKw5JDVMJoEPt51BgAwe3QIlAr+70tkKbROSqx8bCiUChm2ZuqwZl+B1JGIWHLIeiRl6XCmohZaJyWm3RkodRwi+pnBvdzxu3tb5uf86ftsHD9XJW0gsnssOWQVhBBYldJyFOeJEUFwUTtInIiIruWpu/ogfqAv5+eQRWDJIatwMP8CjhVVQeUgx1Mj+0gdh4iuQyaT4c1fRqFXDycUXajDy//l/BySDksOWYV/XJ6L83B0L3i5qiVOQ0Q3onVS4v3L83O2ZOjw2f6zUkciO8WSQxYvV1eNHTllkMlgvo08EVm2IYHueHlSy/ycP27KxolzeokTkT1iySGL949dpwEAkwb5oY+Xi8RpiKi9fjWyD34R4YtGowmJXx6BoZ7zc6h7seSQRSuuqsO36cUAgOfGcAkHImsik8nwl19Goae7EwovXMLi/57g/BzqViw5ZNFaF+KMDfFEVKC71HGIqIO0zkq8/9gdcJDLsPlECT7n/BzqRiw5ZLH0l5rw1cHWhTg5F4fIWt3RuwdenhQOAPjDpmwcKrggcSKyFyw5ZLE+P/DTQpx3cyFOIqs2e1QwJg3yQ6PRhOc+S8PZylqpI5Ed6HDJ2bVrF+6//34EBARAJpNh48aNbV4XQmDJkiXw9/eHk5MT4uLikJeX12bMhQsXMGPGDGg0Gri7u2P27NmoqalpM+b48eMYPXo0HB0dERgYiDfffPOqLOvXr0d4eDgcHR0RGRmJ77//vqObQxaqZSHOfABciJPIFshkMvztkSEY3EuLC7WN+NXqQ9Bf4kRk6lodLjm1tbWIiorCypUrr/n6m2++iXfffRcffvghDhw4ABcXF8THx6O+vt48ZsaMGcjMzERSUhI2bdqEXbt24dlnnzW/bjAYMGHCBAQFBSEtLQ1vvfUWli1bho8++sg8Zt++fZg+fTpmz56No0ePYsqUKZgyZQoyMjI6uklkgf535Dwqahq5ECeRDXFSKfDJk8Pgr3XE6fJazP0iDU1Gk9SxyJaJ2wBAbNiwwfy1yWQSfn5+4q233jI/V1VVJdRqtfjqq6+EEEJkZWUJAOLQoUPmMVu2bBEymUycP39eCCHEBx98IHr06CEaGhrMYxYtWiTCwsLMXz/yyCMiISGhTZ6YmBjx3HPPtTu/Xq8XAIRer2/391DXazaaxNi3kkXQok3ik91npI5DRJ0s87xeRLy6RQQt2iReWn9MmEwmqSORlWnv53enzsnJz8+HTqdDXFyc+TmtVouYmBikpqYCAFJTU+Hu7o5hw4aZx8TFxUEul+PAgQPmMWPGjIFKpTKPiY+PR25uLi5evGgec+XPaR3T+nOupaGhAQaDoc2DLE9Slg75XIiTyGZFBGjw3mN3QC4D1h4uwkeX72hO1Nk6teTodDoAgK+vb5vnfX19za/pdDr4+Pi0ed3BwQEeHh5txlzrPa78Gdcb0/r6tSxfvhxardb8CAzkB6ilEVcsxPlkLBfiJLJV94T7Ysl9EQCAFVtzsDWjROJEZIvs6uqqxYsXQ6/Xmx9FRUVSR6KfOXDFQpwz7+ojdRwi6kJPjQzGk7FBEAKYvzYdx89VSR2JbEynlhw/Pz8AQGlpaZvnS0tLza/5+fmhrKyszevNzc24cOFCmzHXeo8rf8b1xrS+fi1qtRoajabNgyzLP1JalnDgQpxE9mHJfRG4u7836ptMmL3mMIqr6qSORDakU0tOcHAw/Pz8sH37dvNzBoMBBw4cQGxsLAAgNjYWVVVVSEtLM4/ZsWMHTCYTYmJizGN27dqFpqafLi9MSkpCWFgYevToYR5z5c9pHdP6c8j6ZJcYkJxbzoU4ieyIg0KO9x+7A2G+biivbsCvVh9CTUOz1LHIRnS45NTU1CA9PR3p6ekAWiYbp6eno7CwEDKZDPPnz8cf//hHfPvttzhx4gSefPJJBAQEYMqUKQCAAQMGYOLEiXjmmWdw8OBB7N27F/PmzcO0adMQENByqfBjjz0GlUqF2bNnIzMzE2vXrsU777yDhQsXmnM8//zz2Lp1K/76178iJycHy5Ytw+HDhzFv3rzb/10hSbQexbk30p8LcRLZETdHJf751DB4uaqRo6vGb748gmZeWk6doaOXbSUnJwsAVz1mzpwphGi5jPzVV18Vvr6+Qq1Wi/Hjx4vc3Nw271FZWSmmT58uXF1dhUajEbNmzRLV1dVtxhw7dkyMGjVKqNVq0bNnT7FixYqrsqxbt070799fqFQqMXDgQLF58+YObQsvIbcchZW1ImTxZhG0aJM4ca5K6jhEJIGjhRdF/99/L4IWbRJLv8mQOg7dhmajSezJKxcrk/O65P3b+/ktE8J+l4Q1GAzQarXQ6/WcnyOxJd9k4N+pZzG6nxc+mx0jdRwiksj3J0rw6y+OAABee2AgL0CwMtklBmw8eh7fpBdDZ2i5CfDel+9BT3enTv057f385vW5JLmKmgasPdRypdvcsX0lTkNEUro30h8vTQzDm1tz8dp3mbjUaMSzY0KgkHNpF0ul09fjm/Tz2HD0PHJ01ebntU5KJAz2h5THUlhySHKr9xagodmEqEB3xIZ4Sh2HiCQ29+6+KLpQh68OFuKNrTn4MbsUf304inP1LEh1fRO2ZuiwMf089p2uRGuPUSnkuCfcB1Pu6Ilx4d5QOygkzcmSQ5Kqrm/Cv1MLALT8xcaFOIlIJpPhzw8OwtDe7nj9uyyknb2ISe/sxu/uDcfjI4L494REmo0m7M6rwP+OnkdSlg71TT9NDh/exwNT7uiJhEh/aJ2VEqZsiyWHJPXVwUIY6psR4u2CCRG+N/8GIrILMpkMDw8LxF2hXnhx/THsO12JV7/JxA9ZpXjjocEI6OQ5HnR9+RW1WH+4CP89cg6lhgbz8yHeLph6R09MHtITgR7OEia8PpYckkxDsxGf7M4HAMwZ0xdynnMnop/p6e6Ez2fH4N+pBVixNQe78yoQ//ddWHb/QEwd2pNHdbrIpcZmfH9Ch3WHinCw4IL5+R7OSkwe0hNTh/ZEZE+txf/+s+SQZDYcOY+y6gb4aRwx+Y4AqeMQkYWSy2V4amQwxvT3xsJ1x5BeVIUX1h/Dtkwd/jw1kndH7yRCCBwtqsL6w0X47liJ+aaMchkwpr83Hh0WiPEDfKFysJ4VoVhySBJGk8A/Lq88/PToYMknpxGR5QvxdsV/5sTiH7vO4O8/nsQPWaVIO3sRf3owEhMHXX9JH7qxipoGbDhyHusOFyGvrMb8fJCnMx4ZFoipQ3vCX2udpwdZckgS2zJ1yK+ohdZJiWnDe0sdh4ishINCjsRxoRgX5oOF69KRo6vGnM/T8OAdPfFKwgB48qjOTQkhkKOrxs7ccuzMLUPa2YtoNrVcHuWolOPeSH88MiwQw/t4WP00ApYc6nZCCKza2bKEw8zYILiq+b8hEXVMRIAG38wbiXd+zMOHKaex4eh5fH+iBFOH9sLsUX0Q6uMmdUSLYqhvwt68CuzMLUfKyXLzjfpaDQl0xyPDAnFflD80jpZzddTt4h2PecfjbrcnrwKP//MAHJVy7F10D//lRUS35UjhRbz2bSaOndObnxsX5o2nR4fgrr6eFj85tisIIZBdUo2dJ8uwM7ccR644WgO0HLGJDfHE2DAfjA3zRpCndd2DiHc8Jou1KuUUAGDanb1ZcIjotg3t3QMbE0fi8NmL+GT3GfyQVYrk3HIk55ZjgL8GT48Kxv1RAVY1YfZWnK+qQ+rpSqSersTeUxVXHa0J8XLB3WHeGBvmg5hgDzgqbX8uJI/k8EhOtzpWVIXJK/dCIZch5cWx6NXDMu+tQETWq6CiFp/uzce6w+dQ12QEAPi4qTHzrj54bHhv9HBRSZywc5RV15tLTeqZSpytvNTmdUelHHf19cLYMG+M7e+D3p628/dtez+/WXJYcrrV3M/TsCVDh6l39MTfHh0idRwismH6S0348mAhVu/LN9/EzlEpxy+je2Hanb0R4a+xqom1F2obsf9MJfadrkDq6UqcLq9t87pcBkT2csddfT1xV19P3NnHdo/WsOS0A0tO9zpdXoO4v6VACGDb/DEI8+PEQCLqeo3NJnx/ogQf7z6DzGKD+XkvVzVG9/PCmP5eGBXqDW83yzl9rq9rQmaxHlnFBmSc1yOj2IBTV1zeDQAyGRDhr8FdfT0Re7nUuNnQpOEb4Zwcsjgf7zoDIYC4AT4sOETUbVQOcky5oycmDwnA/jMXsHpfPnbnVbTcH+Zoy+rZQEthGNPfG2P6eSG6T49uu39XWXU9Ms8bkFmsR8Z5AzJL9Ci6UHfNsWG+boi9XGpigj3g7mwbp966Co/k8EhOt9Dp6zH6zR1oMgr8d24sooM8pI5ERHasodmItLMXsTuvArtOlrc5wgMATkoFYvt6YnQ/L0QFukPtIIdSIYeDXNbyX4UMDnI5lAoZHK54HgBq6puhr2uCob6p5b91Lf9t+1wzLl5qRI6uGuXVDdeKiF49nDAoQIuBARoM7KnB4F7uvLvzZTySQxblX3vz0WQUGN7HgwWHiCSndlDgrr5euKuvFxZNDEdFTQP2XC48uy4f5dmRU4YdOWVdnkUua7mb86AADQZeLjURARoepekELDnU5fSXmvDF/rMAgLlj+0qchojoal6uaky5oyem3NHTfI+Z3Xnl2JVXjoKKS2gymtBsEi3/NQo0m0xoMl7/RIiTUgGNkwO0TkpoHJXQOrU8NK0Px5bXQrxdMcDfDc4qfhx3Bf6uUpf7bH8BahuNCPdzw9gwb6njEBHdkEwmQ8TloynP3X39f5gJIWA0iTblxyQEXB0duB6fhWDJoS5V12jEp3sLALQcxbHHO48SkW2SyWQtc3MUsNlLta2dbd/+kST3fnIeKmsb0auHExIi/aWOQ0REdoQlh7pMdokB/0g5AwB4JSECDgr+70ZERN2HnzrUJYwmgcX/O4Fmk0D8QF9MHOQndSQiIrIzLDnUJT5LLUB6URXc1A547YFBUschIiI7xJJDna64qg5vbcsFALw0KRx+WkeJExERkT1iyaFOJYTAqxszUNtoxLCgHpgxvLfUkYiIyE6x5FCn+v6EDttzyqBUyLB8aqRVrfBLRES2hSWHOo3+UhOWfpsJAJg7NhT9fLkIJxERSYclhzrNiq3ZqKhpQF9vFySO4/INREQkLZYc6hT7z1Tiq4NFAIDlUwfzluZERCQ5lhy6bfVNRvzufycAANOH98bwYK4yTkRE0mPJodv2QfIpnKmohY+bGi9PCpc6DhEREQCWHLpNJ0ursSrlNADgtQcGQuuklDgRERFRC5YcumUmk8DL/z2OJqNA3AAu3UBERJaFJYdu2RcHzuJIYRVc1Q74w5SBkMl4TxwiIrIcLDl0S0r0dXhj6+WlGyaGwV/rJHEiIiKitlhyqMOEEFjyTSZqGppxR293zIgJkjoSERHRVVhyqMM2nyhBUlYplAoZVkwdDAWXbiAiIgvEkkMdUlBRi8X/bbknzty7+yLMj0s3EBGRZWLJoXarbzJi7hdHUN3QjDv79MBvxveTOhIREdF1seRQuy39JhPZJQZ4uarw/mNDoVTwfx8iIrJc/JSidll3uAhrDxdBLgPemXYHfDWOUkciIiK6IZYcuqmsYgNe3ZgBAFj4i/4YGeolcSIiIqKb6/SSs2zZMshksjaP8PCf1jOqr69HYmIiPD094erqioceegilpaVt3qOwsBAJCQlwdnaGj48PXnzxRTQ3N7cZs3PnTgwdOhRqtRqhoaFYvXp1Z28KATDUN+HXX6ShodmEsWHe+PXYUKkjERERtUuXHMkZOHAgSkpKzI89e/aYX1uwYAG+++47rF+/HikpKSguLsbUqVPNrxuNRiQkJKCxsRH79u3DmjVrsHr1aixZssQ8Jj8/HwkJCRg3bhzS09Mxf/58PP3009i2bVtXbI7dEkJg0X+Oo6DyEnq6O+HtR4ZAzsvFiYjISsiEEKIz33DZsmXYuHEj0tPTr3pNr9fD29sbX375JX75y18CAHJycjBgwACkpqZixIgR2LJlC+677z4UFxfD19cXAPDhhx9i0aJFKC8vh0qlwqJFi7B582ZkZGSY33vatGmoqqrC1q1b253VYDBAq9VCr9dDo9Hc3obboH/uyccfNmVBqZBh/Zy7MCTQXepIRERE7f787pIjOXl5eQgICEBISAhmzJiBwsJCAEBaWhqampoQFxdnHhseHo7evXsjNTUVAJCamorIyEhzwQGA+Ph4GAwGZGZmmsdc+R6tY1rfg25f2tkLWP59NgDg1fsiWHCIiMjqOHT2G8bExGD16tUICwtDSUkJXnvtNYwePRoZGRnQ6XRQqVRwd3dv8z2+vr7Q6XQAAJ1O16bgtL7e+tqNxhgMBtTV1cHJ6drrKDU0NKChocH8tcFguK1ttVWVNQ1I/OIomk0C90cF4IkRXLaBiIisT6eXnEmTJpl/PXjwYMTExCAoKAjr1q27bvnoLsuXL8drr70maQZLZzQJzF+bDp2hHn29XbB8aiRXFyciIqvU5ZeQu7u7o3///jh16hT8/PzQ2NiIqqqqNmNKS0vh5+cHAPDz87vqaqvWr282RqPR3LBILV68GHq93vwoKiq63c2zOe9uz8PuvAo4KRVY9Xg0XNWd3oOJiIi6RZeXnJqaGpw+fRr+/v6Ijo6GUqnE9u3bza/n5uaisLAQsbGxAIDY2FicOHECZWVl5jFJSUnQaDSIiIgwj7nyPVrHtL7H9ajVamg0mjYP+knKyXK8uyMPALB8aiT6+3JdKiIisl6dXnJ++9vfIiUlBQUFBdi3bx8efPBBKBQKTJ8+HVqtFrNnz8bChQuRnJyMtLQ0zJo1C7GxsRgxYgQAYMKECYiIiMATTzyBY8eOYdu2bXjllVeQmJgItVoNAJgzZw7OnDmDl156CTk5Ofjggw+wbt06LFiwoLM3x24UV9Vh/tdHIQQwI6Y3ptzRU+pIREREt6XTz0WcO3cO06dPR2VlJby9vTFq1Cjs378f3t7eAIC3334bcrkcDz30EBoaGhAfH48PPvjA/P0KhQKbNm3C3LlzERsbCxcXF8ycOROvv/66eUxwcDA2b96MBQsW4J133kGvXr3wySefID4+vrM3xy7UNjTjuc/ScPFSEyJ7avHqfRFSRyIiIrptnX6fHGvC++QAjc0mzF5zCLvzKuDhosI3iSMR6OEsdSwiIqLrkvQ+OWQdTCaBRf89bp5o/K+n7mTBISIim8GSY8dWbM3BhqPn4SCXYdXjQ3nDPyIisiksOXbqk91n8NGuMwCAN385GGPDfCRORERE1LlYcuzQxqPn8cfNLUs2vDwpHFOH9pI4ERERUedjybEzu06W47frjwEAfjUyGM+NCZE4ERERUddgybEjx89VYc7naWg2CTwQFYBXEgZwyQYiIrJZLDl2Ir+iFrM+PYRLjUaMCvXCXx6OglzOgkNERLaLJccOlFXX48l/HUBlbSMG9dTgwyeioXLgriciItvGTzobV13fhKf+dQhFF+oQ5OmMT58azkU3iYjILrDk2LCGZiOe+ywNWSUGeLmq8O9fDYe3m1rqWERERN2CJcdGVdc34fmv0rHvdCVcVAp8+tRwBHm6SB2LiIio2/C8hQ3anl2KVzZmoERfD6VChg+fiEZkL63UsYiIiLoVS44NKa9uwGvfZWLT8RIAQG8PZ6x4KBJ39fWSOBkREVH3Y8mxAUIIrE87hz9tzoa+rglyGfDM6BDMj+sPJ5VC6nhERESSYMmxcmcra/G7DSew91QlAGBggAZvPDQYg3ry9BQREdk3lhwr1Ww04Z978vH2jydR32SC2kGOhb/oj9mjguGg4HxyIiIilhwrlHFej0X/PY7MYgMAYGSoJ/78YCSvniIiIroCS44VqW8y4u0fT+KT3fkwmgS0Tkq8kjAAv4zuxTWoiIiIfoYlx0ocLbyIF9Yfw5nyWgDAfYP9sfT+gby5HxER0XWw5Fi4hmYj3vkxDx+mnIZJAD5uavz5wUjERfhKHY2IiMiiseRYsIzzevx2/THk6KoBAFOGBGDZAwPh7qySOBkREZHlY8mxQE1GEz5IPo33duSh2STg6aLCnx6MxMRBflJHIyIishosORbmZGk1Xlh3DCfO6wEAkwb54Y9TBsHTlXNviIiIOoIlx0IYTQIf7TqDt5NOotFogtZJidcnD8QDUQG8coqIiOgWsORYgDPlNXhh/TEcLawCANwT7oPlUyPhq3GUNhgREZEVY8mRUFaxAevTivDVwULUN5ngqnbAkvsj8DDve0NERHTbWHK62cXaRnyTfh7r086Z71gMAKNCvfDGLwejp7uThOmIiIhsB0tON2g2mrA7rwLr04rwY1YZGo0mAIBSIUPcAF88MiwQd/f3hlzOozdERESdhSWnC50qq8H6tCJsOHIeZdUN5ucHBmjwcHQvTB7SEz1ceM8bIiKirsCS08nqm4z435HzWJ9WZJ5IDAAeLipMHhKAh6MDERGgkS4gERGRnWDJ6QIrtmTDUN8MhVyGsf298fCwXrgn3BcqB7nU0YiIiOwGS04nc1QqMGdsXyhkMjw4tCd83HgZOBERkRRYcrrAr8eGSh2BiIjI7vH8CREREdkklhwiIiKySSw5REREZJNYcoiIiMgmseQQERGRTWLJISIiIpvEkkNEREQ2iSWHiIiIbBJLDhEREdkklhwiIiKySSw5REREZJNYcoiIiMgmseQQERGRTbLrVciFEAAAg8EgcRIiIiJqr9bP7dbP8eux65JTXV0NAAgMDJQ4CREREXVUdXU1tFrtdV+XiZvVIBtmMplQXFwMNzc3yGSyTntfg8GAwMBAFBUVQaPRdNr7WhJb30Zun/Wz9W3k9lk/W9/Grtw+IQSqq6sREBAAufz6M2/s+kiOXC5Hr169uuz9NRqNTf6PeyVb30Zun/Wz9W3k9lk/W9/Grtq+Gx3BacWJx0RERGSTWHKIiIjIJrHkdAG1Wo2lS5dCrVZLHaXL2Po2cvusn61vI7fP+tn6NlrC9tn1xGMiIiKyXTySQ0RERDaJJYeIiIhsEksOERER2SSWHCIiIrJJLDldYOXKlejTpw8cHR0RExODgwcPSh2pUyxbtgwymazNIzw8XOpYt2XXrl24//77ERAQAJlMho0bN7Z5XQiBJUuWwN/fH05OToiLi0NeXp40YW/BzbbvqaeeumqfTpw4UZqwt2D58uW488474ebmBh8fH0yZMgW5ubltxtTX1yMxMRGenp5wdXXFQw89hNLSUokSd0x7tm/s2LFX7cM5c+ZIlLjjVq1ahcGDB5tvGBcbG4stW7aYX7fm/QfcfPusff/93IoVKyCTyTB//nzzc1LuQ5acTrZ27VosXLgQS5cuxZEjRxAVFYX4+HiUlZVJHa1TDBw4ECUlJebHnj17pI50W2praxEVFYWVK1de8/U333wT7777Lj788EMcOHAALi4uiI+PR319fTcnvTU32z4AmDhxYpt9+tVXX3VjwtuTkpKCxMRE7N+/H0lJSWhqasKECRNQW1trHrNgwQJ89913WL9+PVJSUlBcXIypU6dKmLr92rN9APDMM8+02YdvvvmmRIk7rlevXlixYgXS0tJw+PBh3HPPPZg8eTIyMzMBWPf+A26+fYB1778rHTp0CP/4xz8wePDgNs9Lug8Fdarhw4eLxMRE89dGo1EEBASI5cuXS5iqcyxdulRERUVJHaPLABAbNmwwf20ymYSfn5946623zM9VVVUJtVotvvrqKwkS3p6fb58QQsycOVNMnjxZkjxdoaysTAAQKSkpQoiW/aVUKsX69evNY7KzswUAkZqaKlXMW/bz7RNCiLvvvls8//zz0oXqAj169BCffPKJze2/Vq3bJ4Tt7L/q6mrRr18/kZSU1GabpN6HPJLTiRobG5GWloa4uDjzc3K5HHFxcUhNTZUwWefJy8tDQEAAQkJCMGPGDBQWFkodqcvk5+dDp9O12Z9arRYxMTE2sz8BYOfOnfDx8UFYWBjmzp2LyspKqSPdMr1eDwDw8PAAAKSlpaGpqanNPgwPD0fv3r2tch/+fPtaffHFF/Dy8sKgQYOwePFiXLp0SYp4t81oNOLrr79GbW0tYmNjbW7//Xz7WtnC/ktMTERCQkKbfQVI/2fQrhfo7GwVFRUwGo3w9fVt87yvry9ycnIkStV5YmJisHr1aoSFhaGkpASvvfYaRo8ejYyMDLi5uUkdr9PpdDoAuOb+bH3N2k2cOBFTp05FcHAwTp8+jd/97neYNGkSUlNToVAopI7XISaTCfPnz8fIkSMxaNAgAC37UKVSwd3dvc1Ya9yH19o+AHjssccQFBSEgIAAHD9+HIsWLUJubi7+97//SZi2Y06cOIHY2FjU19fD1dUVGzZsQEREBNLT021i/11v+wDb2H9ff/01jhw5gkOHDl31mtR/BllyqN0mTZpk/vXgwYMRExODoKAgrFu3DrNnz5YwGd2qadOmmX8dGRmJwYMHo2/fvti5cyfGjx8vYbKOS0xMREZGhtXPE7ue623fs88+a/51ZGQk/P39MX78eJw+fRp9+/bt7pi3JCwsDOnp6dDr9fjPf/6DmTNnIiUlRepYneZ62xcREWH1+6+oqAjPP/88kpKS4OjoKHWcq/B0VSfy8vKCQqG4atZ4aWkp/Pz8JErVddzd3dG/f3+cOnVK6ihdonWf2cv+BICQkBB4eXlZ3T6dN28eNm3ahOTkZPTq1cv8vJ+fHxobG1FVVdVmvLXtw+tt37XExMQAgFXtQ5VKhdDQUERHR2P58uWIiorCO++8YzP773rbdy3Wtv/S0tJQVlaGoUOHwsHBAQ4ODkhJScG7774LBwcH+Pr6SroPWXI6kUqlQnR0NLZv325+zmQyYfv27W3Ov9qKmpoanD59Gv7+/lJH6RLBwcHw8/Nrsz8NBgMOHDhgk/sTAM6dO4fKykqr2adCCMybNw8bNmzAjh07EBwc3Ob16OhoKJXKNvswNzcXhYWFVrEPb7Z915Keng4AVrMPr8VkMqGhocHq99/1tG7ftVjb/hs/fjxOnDiB9PR082PYsGGYMWOG+deS7sMun9psZ77++muhVqvF6tWrRVZWlnj22WeFu7u70Ol0Uke7bS+88ILYuXOnyM/PF3v37hVxcXHCy8tLlJWVSR3tllVXV4ujR4+Ko0ePCgDib3/7mzh69Kg4e/asEEKIFStWCHd3d/HNN9+I48ePi8mTJ4vg4GBRV1cncfL2udH2VVdXi9/+9rciNTVV5Ofnix9//FEMHTpU9OvXT9TX10sdvV3mzp0rtFqt2LlzpygpKTE/Ll26ZB4zZ84c0bt3b7Fjxw5x+PBhERsbK2JjYyVM3X43275Tp06J119/XRw+fFjk5+eLb775RoSEhIgxY8ZInLz9Xn75ZZGSkiLy8/PF8ePHxcsvvyxkMpn44YcfhBDWvf+EuPH22cL+u5afXzEm5T5kyekC7733nujdu7dQqVRi+PDhYv/+/VJH6hSPPvqo8Pf3FyqVSvTs2VM8+uij4tSpU1LHui3JyckCwFWPmTNnCiFaLiN/9dVXha+vr1Cr1WL8+PEiNzdX2tAdcKPtu3TpkpgwYYLw9vYWSqVSBAUFiWeeecaqCvm1tg2A+PTTT81j6urqxK9//WvRo0cP4ezsLB588EFRUlIiXegOuNn2FRYWijFjxggPDw+hVqtFaGioePHFF4Ver5c2eAf86le/EkFBQUKlUglvb28xfvx4c8ERwrr3nxA33j5b2H/X8vOSI+U+lAkhRNcfLyIiIiLqXpyTQ0RERDaJJYeIiIhsEksOERER2SSWHCIiIrJJLDlERERkk1hyiIiIyCax5BAREZFNYskhIiIim8SSQ0RERDaJJYeIiIhsEksOERER2SSWHCIiIrJJ/w/ISIWgKd0FggAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(beam[:, 0, 0].real)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "4c3abeea-d3f9-4bd3-b69e-a3bd1a99e181", + "metadata": {}, + "outputs": [], + "source": [ + "from croissant import dpss" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "23eb1359-55d9-4b9d-a075-6393365f572a", + "metadata": {}, + "outputs": [], + "source": [ + "def res(nterms):\n", + " A = dpss.dpss_op(freqs, filter_half_width=100e-9, nterms=nterms)\n", + " M = jnp.linalg.inv(A.T @ A) @ A.T\n", + " cs = jnp.einsum(\"ij, jlm -> ilm\", M, sky.alm)\n", + " ss = jnp.einsum(\"ij, jlm -> ilm\", A, cs)\n", + " return jnp.abs(ss-sky.alm)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "eb924f69-0caa-428e-9cf1-6326537a4342", + "metadata": {}, + "outputs": [], + "source": [ + "rm = jnp.empty(41)\n", + "for i in range(41):\n", + " rm = rm.at[i].set(res(i+1).mean())\n", + "\n", + "plt.figure()\n", + "plt.plot(rm)\n", + "plt.yscale('log')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "848cdc15-d7f4-4cae-a029-038e2871d7cd", + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial\n", + "def map2alm(m, lmax):\n", + " forward = partial(\n", + " s2fft.forward_jax, spin=0, nside=None, sampling=\"mw\", reality=True, precomps=None, spmd=True, L_lower=0\n", + " )\n", + " L = lmax + 1\n", + " return jax.vmap(forward, in_axes=(0, None))(m, L)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "f38e9465-234d-4805-bf10-8c4e389c3c44", + "metadata": {}, + "outputs": [], + "source": [ + "beam = jnp.load(\"lusee_beam.npy\")[:, 9:, :, :-1]\n", + "beam = jnp.sqrt(jnp.abs(beam[0])**2 + jnp.abs(beam[1])**2)\n", + "beam = jnp.append(beam, jnp.zeros_like(beam)[:, :-1], axis=1)\n", + "beam_alm = map2alm(beam, lmax)\n", + "beam = crojax.Beam(beam_alm, frequencies=freqs, coord=\"T\")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "c38c68db-b1de-435a-9530-674328d7d43c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(beam[:, 0, 0])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8ac78db-eae7-4c4c-bf4f-69ba4816c87d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "c829613b-06cb-42f5-821d-e055a6a9d8c7", + "metadata": {}, + "outputs": [], + "source": [ + "def res(nterms):\n", + " A = dpss.dpss_op(freqs, filter_half_width=50e-9, nterms=nterms)\n", + " M = jnp.linalg.inv(A.T @ A) @ A.T\n", + " cs = jnp.einsum(\"ij, jlm -> ilm\", M, beam.alm)\n", + " ss = jnp.einsum(\"ij, jlm -> ilm\", A, cs)\n", + " return jnp.abs(ss-beam.alm) / jnp.abs(beam.alm)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "82500d59-6cfb-4c8d-a970-eec578da1fdc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rm = jnp.empty(41)\n", + "for i in range(41):\n", + " rm = rm.at[i].set(jnp.nanmean(res(i+1)))\n", + "\n", + "plt.figure()\n", + "plt.plot(rm)\n", + "#plt.yscale('log')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 48fe42e89bdae392a39f8b61c62ed01b66c5a705 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 4 Sep 2023 15:13:42 -0700 Subject: [PATCH 068/129] small bug in reshape --- croissant/core/healpix.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/croissant/core/healpix.py b/croissant/core/healpix.py index 75f132f..5baed2b 100644 --- a/croissant/core/healpix.py +++ b/croissant/core/healpix.py @@ -334,8 +334,7 @@ def __init__(self, alm, lmax=None, frequencies=None, coord=None): self.alm = alm else: self.frequencies = np.array(frequencies) - alm.reshape(self.frequencies.size, -1) - self.alm = alm + self.alm = alm.reshape(self.frequencies.size, -1) try: self.lmax = np.min([lmax, self.getlmax]) except TypeError: # lmax is None From ebfed204b8319e375ba80b4350861d43c959518e Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 5 Sep 2023 03:10:17 +0000 Subject: [PATCH 069/129] Bump actions/checkout from 3 to 4 Bumps [actions/checkout](https://github.com/actions/checkout) from 3 to 4. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v3...v4) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index 549bcd9..d0fd36d 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -11,7 +11,7 @@ jobs: python-version: ["3.8", "3.9", "3.10"] steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: From 3b86fbe80ca54c7e17e4c56adade6a2c2b1ccdc9 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 15 Sep 2023 03:34:48 +0000 Subject: [PATCH 070/129] Bump codecov/codecov-action from 3 to 4 Bumps [codecov/codecov-action](https://github.com/codecov/codecov-action) from 3 to 4. - [Release notes](https://github.com/codecov/codecov-action/releases) - [Changelog](https://github.com/codecov/codecov-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/codecov/codecov-action/compare/v3...v4) --- updated-dependencies: - dependency-name: codecov/codecov-action dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index d0fd36d..47a25a3 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -34,4 +34,4 @@ jobs: run: | pytest --cov=croissant --cov-report=xml croissant/tests croissant/core/tests croissant/crojax/tests - name: Upload coverage to Codecov - uses: codecov/codecov-action@v3 + uses: codecov/codecov-action@v4 From 2a1343bf3038a2a6b50e951dbc8e5d02a27e1023 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 18 Sep 2023 17:04:27 -0700 Subject: [PATCH 071/129] update codecov action with token --- .github/workflows/push.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index 47a25a3..02f4dc2 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -35,3 +35,6 @@ jobs: pytest --cov=croissant --cov-report=xml croissant/tests croissant/core/tests croissant/crojax/tests - name: Upload coverage to Codecov uses: codecov/codecov-action@v4 + with: + token: ${{ secrets.CODECOV_TOKEN }} + fail_ci_if_error: true From 3f0892ab4cef664d256f41b95b6145e3eaac221f Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Mon, 18 Sep 2023 17:09:30 -0700 Subject: [PATCH 072/129] revert to codecov v3 while v4 is in beta --- .github/workflows/push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index 02f4dc2..242ceab 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -34,7 +34,7 @@ jobs: run: | pytest --cov=croissant --cov-report=xml croissant/tests croissant/core/tests croissant/crojax/tests - name: Upload coverage to Codecov - uses: codecov/codecov-action@v4 + uses: codecov/codecov-action@v3 with: token: ${{ secrets.CODECOV_TOKEN }} fail_ci_if_error: true From f4d16d1bdaf9326ae0df3a4db324423074c54a35 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 2 Feb 2024 14:52:03 -0800 Subject: [PATCH 073/129] bump version number --- croissant/__init__.py | 2 +- setup.cfg | 7 ++----- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/croissant/__init__.py b/croissant/__init__.py index 04b713f..5895ad5 100644 --- a/croissant/__init__.py +++ b/croissant/__init__.py @@ -1,5 +1,5 @@ __author__ = "Christian Hellum Bye" -__version__ = "3.1.0" +__version__ = "4.0.0" from . import constants from . import core diff --git a/setup.cfg b/setup.cfg index a6b801d..ec5ab7f 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,11 +1,11 @@ [metadata] name = croissant-sim -version = 3.1.0 +version = 4.0.0 description = CROISSANT: Rapid spherical harmonics-based simulator of visibilities long_description = file: README.md author = Christian Hellum Bye author_email = chbye@berkeley.edu -license = GPLv2 +license = MIT url = https://github.com/christianhbye/croissant classifiers = Intended Audience :: Science/Research @@ -19,15 +19,12 @@ python_requires = >= 3.8 packages=find: install_requires = astropy - healpy hera-filters == 0.1.1 jupyter lunarsky matplotlib numpy <= 1.23 pygdsm - scipy - s2fft @ git+https://github.com/astro-informatics/s2fft.git [options.extras_require] dev = From 0b22b00bd54a8c8d34abd5e80fcb45ba7fc9d1d2 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 2 Feb 2024 14:52:31 -0800 Subject: [PATCH 074/129] --no-edit --- croissant/constants.py | 7 +- requirements.txt | 210 +++++++++++++++++++---------------------- 2 files changed, 100 insertions(+), 117 deletions(-) diff --git a/croissant/constants.py b/croissant/constants.py index 902ba2e..9aab980 100644 --- a/croissant/constants.py +++ b/croissant/constants.py @@ -1,7 +1,4 @@ -import numpy as np - -# nside's for which healpix has computed pixel weights: -PIX_WEIGHTS_NSIDE = (32, 64, 128, 256, 512, 1024, 2048, 4096) +from math import pi, sqrt # sidereal days in seconds # https://nssdc.gsfc.nasa.gov/planetary/factsheet/earthfact.html @@ -9,4 +6,4 @@ # https://nssdc.gsfc.nasa.gov/planetary/factsheet/moonfact.html sidereal_day_moon = 655.720 * 3600 -Y00 = 1 / np.sqrt(4 * np.pi) # the 0,0 spherical harmonic function +Y00 = 1 / sqrt(4 * pi) # the 0,0 spherical harmonic function diff --git a/requirements.txt b/requirements.txt index 25567bd..6c16c59 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,166 +1,152 @@ -anyio==4.0.0 +anyio==4.2.0 argon2-cffi==23.1.0 argon2-cffi-bindings==21.2.0 -arrow==1.2.3 -astropy==5.2.2 -asttokens==2.2.1 +arrow==1.3.0 +astropy==6.0.0 +astropy-iers-data==0.2024.1.29.0.30.37 +asttokens==2.4.1 async-lru==2.0.4 -attrs==23.1.0 -Babel==2.12.1 -backcall==0.2.0 -beautifulsoup4==4.12.2 -black==23.7.0 -bleach==6.0.0 -build==1.0.0 -certifi==2023.7.22 -cffi==1.15.1 -charset-normalizer==3.2.0 +attrs==23.2.0 +Babel==2.14.0 +beautifulsoup4==4.12.3 +black==24.1.1 +bleach==6.1.0 +build==1.0.3 +certifi==2023.11.17 +cffi==1.16.0 +charset-normalizer==3.3.2 click==8.1.7 -colorlog==6.7.0 -comm==0.1.4 -contourpy==1.1.0 -coverage==7.3.0 -cryptography==41.0.3 -cycler==0.11.0 -debugpy==1.6.7.post1 +comm==0.2.1 +contourpy==1.2.0 +coverage==7.4.1 +croissant-sim @ file:///home/christian/Documents/projects/croissant +cryptography==42.0.2 +cycler==0.12.1 +debugpy==1.8.0 decorator==5.1.1 defusedxml==0.7.1 docutils==0.20.1 -ephem==4.1.4 -exceptiongroup==1.1.3 -executing==1.2.0 -fastjsonschema==2.18.0 -flake8==6.1.0 -fonttools==4.42.1 +ephem==4.1.5 +exceptiongroup==1.2.0 +executing==2.0.1 +fastjsonschema==2.19.1 +flake8==7.0.0 +fonttools==4.47.2 fqdn==1.5.1 -h5py==3.9.0 -healpy==1.16.5 +h5py==3.10.0 +healpy==1.16.6 hera-filters==0.1.1 -idna==3.4 -importlib-metadata==4.13.0 +idna==3.6 +importlib-metadata==7.0.1 iniconfig==2.0.0 -ipykernel==6.25.1 -ipython==8.12.2 -ipython-genutils==0.2.0 -ipywidgets==8.1.0 +ipykernel==6.29.0 +ipython==8.21.0 +ipywidgets==8.1.1 isoduration==20.11.0 jaraco.classes==3.3.0 -jax==0.4.13 -jedi==0.19.0 +jedi==0.19.1 jeepney==0.8.0 -Jinja2==3.1.2 -jplephem==2.18 +Jinja2==3.1.3 +jplephem==2.21 json5==0.9.14 jsonpointer==2.4 -jsonschema==4.19.0 -jsonschema-specifications==2023.7.1 +jsonschema==4.21.1 +jsonschema-specifications==2023.12.1 jupyter==1.0.0 jupyter-console==6.6.3 -jupyter-events==0.7.0 -jupyter-lsp==2.2.0 -jupyter_client==8.3.1 -jupyter_core==5.3.1 -jupyter_server==2.7.3 -jupyter_server_terminals==0.4.4 -jupyterlab==4.0.5 -jupyterlab-pygments==0.2.2 -jupyterlab-widgets==3.0.8 -jupyterlab_server==2.24.0 -keyring==24.2.0 +jupyter-events==0.9.0 +jupyter-lsp==2.2.2 +jupyter_client==8.6.0 +jupyter_core==5.7.1 +jupyter_server==2.12.5 +jupyter_server_terminals==0.5.2 +jupyterlab==4.0.12 +jupyterlab-widgets==3.0.9 +jupyterlab_pygments==0.3.0 +jupyterlab_server==2.25.2 +keyring==24.3.0 kiwisolver==1.4.5 lunarsky==0.2.1 markdown-it-py==3.0.0 -MarkupSafe==2.1.3 -matplotlib==3.7.2 +MarkupSafe==2.1.4 +matplotlib==3.8.2 matplotlib-inline==0.1.6 mccabe==0.7.0 mdurl==0.1.2 -mistune==3.0.1 -ml-dtypes==0.2.0 -more-itertools==10.1.0 -mypy==1.5.1 +mistune==3.0.2 +more-itertools==10.2.0 +mypy==1.8.0 mypy-extensions==1.0.0 -nbclient==0.8.0 -nbconvert==7.8.0 +nbclient==0.9.0 +nbconvert==7.14.2 nbformat==5.9.2 -nest-asyncio==1.5.7 -notebook==7.0.3 +nest-asyncio==1.6.0 +nh3==0.2.15 +notebook==7.0.7 notebook_shim==0.2.3 numpy==1.23.0 -nvidia-cublas-cu12==12.2.5.6 -nvidia-cuda-cupti-cu12==12.2.142 -nvidia-cuda-nvcc-cu12==12.2.140 -nvidia-cuda-nvrtc-cu12==12.2.140 -nvidia-cuda-runtime-cu12==12.2.140 -nvidia-cudnn-cu12==8.9.4.25 -nvidia-cufft-cu12==11.0.8.103 -nvidia-cusolver-cu12==11.5.2.141 -nvidia-cusparse-cu12==12.1.2.141 -nvidia-nvjitlink-cu12==12.2.140 -opt-einsum==3.3.0 -overrides==7.4.0 -packaging==23.1 -pandocfilters==1.5.0 +overrides==7.7.0 +packaging==23.2 +pandocfilters==1.5.1 parso==0.8.3 -pathspec==0.11.2 -pexpect==4.8.0 -pickleshare==0.7.5 -Pillow==10.0.0 +pathspec==0.12.1 +pexpect==4.9.0 +pillow==10.2.0 pkginfo==1.9.6 -platformdirs==3.10.0 -pluggy==1.3.0 -prometheus-client==0.17.1 -prompt-toolkit==3.0.39 -psutil==5.9.5 +platformdirs==4.2.0 +pluggy==1.4.0 +prometheus-client==0.19.0 +prompt-toolkit==3.0.43 +psutil==5.9.8 ptyprocess==0.7.0 pure-eval==0.2.2 -pycodestyle==2.11.0 +pycodestyle==2.11.1 pycparser==2.21 pyephem==9.99 -pyerfa==2.0.0.3 -pyflakes==3.1.0 -pygdsm==1.3.0 -Pygments==2.16.1 -pyparsing==3.0.9 +pyerfa==2.0.1.1 +pyflakes==3.2.0 +pygdsm==1.5.0 +Pygments==2.17.2 +pyparsing==3.1.1 pyproject_hooks==1.0.0 -pytest==7.4.0 +pytest==8.0.0 pytest-cov==4.1.0 python-dateutil==2.8.2 python-json-logger==2.0.7 PyYAML==6.0.1 -pyzmq==25.1.1 -qtconsole==5.4.4 -QtPy==2.4.0 -readme-renderer==41.0 -referencing==0.30.2 +pyzmq==25.1.2 +qtconsole==5.5.1 +QtPy==2.4.1 +readme-renderer==42.0 +referencing==0.33.0 requests==2.31.0 requests-toolbelt==1.0.0 rfc3339-validator==0.1.4 rfc3986==2.0.0 rfc3986-validator==0.1.1 -rich==13.5.2 -rpds-py==0.10.0 -s2fft @ git+https://github.com/astro-informatics/s2fft.git -scipy==1.10.1 +rich==13.7.0 +rpds-py==0.17.1 +scipy==1.12.0 SecretStorage==3.3.3 Send2Trash==1.8.2 six==1.16.0 sniffio==1.3.0 -soupsieve==2.4.1 +soupsieve==2.5 spiceypy==6.0.0 -stack-data==0.6.2 -terminado==0.17.1 +stack-data==0.6.3 +terminado==0.18.0 tinycss2==1.2.1 tomli==2.0.1 -tornado==6.3.3 -traitlets==5.9.0 +tornado==6.4 +traitlets==5.14.1 twine==4.0.2 -typing_extensions==4.7.1 +types-python-dateutil==2.8.19.20240106 +typing_extensions==4.9.0 uri-template==1.3.0 -urllib3==2.0.4 -wcwidth==0.2.6 +urllib3==2.2.0 +wcwidth==0.2.13 webcolors==1.13 webencodings==0.5.1 -websocket-client==1.6.2 -widgetsnbextension==4.0.8 -zipp==3.16.2 +websocket-client==1.7.0 +widgetsnbextension==4.0.9 +zipp==3.17.0 From 89bc77b9f26cd18108e1b6310d6e829ff4e4d920 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 2 Feb 2024 14:56:19 -0800 Subject: [PATCH 075/129] Revert "revert to codecov v3 while v4 is in beta" This reverts commit 3f0892ab4cef664d256f41b95b6145e3eaac221f. --- .github/workflows/push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index 242ceab..02f4dc2 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -34,7 +34,7 @@ jobs: run: | pytest --cov=croissant --cov-report=xml croissant/tests croissant/core/tests croissant/crojax/tests - name: Upload coverage to Codecov - uses: codecov/codecov-action@v3 + uses: codecov/codecov-action@v4 with: token: ${{ secrets.CODECOV_TOKEN }} fail_ci_if_error: true From 753cb2cd8b360c1d8a15f6cd8d0da20117ce128b Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 2 Feb 2024 16:27:03 -0800 Subject: [PATCH 076/129] change crojax to croissant.jax --- croissant/__init__.py | 2 +- croissant/{crojax => jax}/README.md | 0 croissant/{crojax => jax}/__init__.py | 0 croissant/{crojax => jax}/beam.py | 0 croissant/{crojax => jax}/healpix.py | 0 croissant/{crojax => jax}/simulator.py | 0 croissant/{crojax => jax}/sky.py | 0 croissant/{crojax => jax}/tests/__init__.py | 0 croissant/{crojax => jax}/tests/test_beam.py | 0 croissant/{crojax => jax}/tests/test_healpix.py | 0 croissant/{crojax => jax}/tests/test_simulator.py | 0 11 files changed, 1 insertion(+), 1 deletion(-) rename croissant/{crojax => jax}/README.md (100%) rename croissant/{crojax => jax}/__init__.py (100%) rename croissant/{crojax => jax}/beam.py (100%) rename croissant/{crojax => jax}/healpix.py (100%) rename croissant/{crojax => jax}/simulator.py (100%) rename croissant/{crojax => jax}/sky.py (100%) rename croissant/{crojax => jax}/tests/__init__.py (100%) rename croissant/{crojax => jax}/tests/test_beam.py (100%) rename croissant/{crojax => jax}/tests/test_healpix.py (100%) rename croissant/{crojax => jax}/tests/test_simulator.py (100%) diff --git a/croissant/__init__.py b/croissant/__init__.py index 5895ad5..fef5b81 100644 --- a/croissant/__init__.py +++ b/croissant/__init__.py @@ -3,7 +3,7 @@ from . import constants from . import core -from . import crojax +from . import jax from . import dpss from . import utils diff --git a/croissant/crojax/README.md b/croissant/jax/README.md similarity index 100% rename from croissant/crojax/README.md rename to croissant/jax/README.md diff --git a/croissant/crojax/__init__.py b/croissant/jax/__init__.py similarity index 100% rename from croissant/crojax/__init__.py rename to croissant/jax/__init__.py diff --git a/croissant/crojax/beam.py b/croissant/jax/beam.py similarity index 100% rename from croissant/crojax/beam.py rename to croissant/jax/beam.py diff --git a/croissant/crojax/healpix.py b/croissant/jax/healpix.py similarity index 100% rename from croissant/crojax/healpix.py rename to croissant/jax/healpix.py diff --git a/croissant/crojax/simulator.py b/croissant/jax/simulator.py similarity index 100% rename from croissant/crojax/simulator.py rename to croissant/jax/simulator.py diff --git a/croissant/crojax/sky.py b/croissant/jax/sky.py similarity index 100% rename from croissant/crojax/sky.py rename to croissant/jax/sky.py diff --git a/croissant/crojax/tests/__init__.py b/croissant/jax/tests/__init__.py similarity index 100% rename from croissant/crojax/tests/__init__.py rename to croissant/jax/tests/__init__.py diff --git a/croissant/crojax/tests/test_beam.py b/croissant/jax/tests/test_beam.py similarity index 100% rename from croissant/crojax/tests/test_beam.py rename to croissant/jax/tests/test_beam.py diff --git a/croissant/crojax/tests/test_healpix.py b/croissant/jax/tests/test_healpix.py similarity index 100% rename from croissant/crojax/tests/test_healpix.py rename to croissant/jax/tests/test_healpix.py diff --git a/croissant/crojax/tests/test_simulator.py b/croissant/jax/tests/test_simulator.py similarity index 100% rename from croissant/crojax/tests/test_simulator.py rename to croissant/jax/tests/test_simulator.py From 3f0904de48dd8542142c53aeb3f07f9a9d9ee5d1 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 2 Feb 2024 16:38:40 -0800 Subject: [PATCH 077/129] update requirements.txt --- requirements.txt | 46 ---------------------------------------------- 1 file changed, 46 deletions(-) diff --git a/requirements.txt b/requirements.txt index cc65c95..6c16c59 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,7 +1,6 @@ anyio==4.2.0 argon2-cffi==23.1.0 argon2-cffi-bindings==21.2.0 -<<<<<<< HEAD arrow==1.3.0 astropy==6.0.0 astropy-iers-data==0.2024.1.29.0.30.37 @@ -36,37 +35,6 @@ fonttools==4.47.2 fqdn==1.5.1 h5py==3.10.0 healpy==1.16.6 -======= -astropy==5.1 -asttokens==2.0.7 -attrs==22.1.0 -backcall==0.2.0 -beautifulsoup4==4.11.1 -black==22.6.0 -bleach==5.0.1 -build==0.8.0 -certifi==2023.7.22 -cffi==1.15.1 -charset-normalizer==2.1.0 -click==8.1.3 -commonmark==0.9.1 -coverage==6.4.3 -croissant-sim==3.0.0 -cryptography==41.0.6 -cycler==0.11.0 -debugpy==1.6.2 -decorator==5.1.1 -defusedxml==0.7.1 -docutils==0.19 -entrypoints==0.4 -ephem==4.1.3 -executing==0.9.1 -fastjsonschema==2.16.1 -flake8==5.0.4 -fonttools==4.43.0 -h5py==3.7.0 -healpy==1.16.1 ->>>>>>> main hera-filters==0.1.1 idna==3.6 importlib-metadata==7.0.1 @@ -121,7 +89,6 @@ overrides==7.7.0 packaging==23.2 pandocfilters==1.5.1 parso==0.8.3 -<<<<<<< HEAD pathspec==0.12.1 pexpect==4.9.0 pillow==10.2.0 @@ -131,19 +98,6 @@ pluggy==1.4.0 prometheus-client==0.19.0 prompt-toolkit==3.0.43 psutil==5.9.8 -======= -pathspec==0.9.0 -pep517==0.13.0 -pexpect==4.8.0 -pickleshare==0.7.5 -Pillow==10.0.1 -pkginfo==1.8.3 -platformdirs==2.5.2 -pluggy==1.0.0 -prometheus-client==0.14.1 -prompt-toolkit==3.0.30 -psutil==5.9.1 ->>>>>>> main ptyprocess==0.7.0 pure-eval==0.2.2 pycodestyle==2.11.1 From fb586a26284d008d3d6135c6462f6b7269a82114 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 2 Feb 2024 16:48:33 -0800 Subject: [PATCH 078/129] remove croissant from requirements --- requirements.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 6c16c59..0819651 100644 --- a/requirements.txt +++ b/requirements.txt @@ -19,7 +19,6 @@ click==8.1.7 comm==0.2.1 contourpy==1.2.0 coverage==7.4.1 -croissant-sim @ file:///home/christian/Documents/projects/croissant cryptography==42.0.2 cycler==0.12.1 debugpy==1.8.0 From 2c21219e7bb05bee5197eb891ddda751df2b498d Mon Sep 17 00:00:00 2001 From: xzackli Date: Tue, 13 Feb 2024 10:34:20 -0800 Subject: [PATCH 079/129] small bugfixes: GSM name, and pixweight constant --- croissant/constants.py | 1 + croissant/core/sky.py | 2 +- croissant/jax/sky.py | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/croissant/constants.py b/croissant/constants.py index 9aab980..767549c 100644 --- a/croissant/constants.py +++ b/croissant/constants.py @@ -7,3 +7,4 @@ sidereal_day_moon = 655.720 * 3600 Y00 = 1 / sqrt(4 * pi) # the 0,0 spherical harmonic function +PIX_WEIGHTS_NSIDE = (32, 64, 128, 512, 1024, 2048, 4096) diff --git a/croissant/core/sky.py b/croissant/core/sky.py index db30ec9..633b834 100644 --- a/croissant/core/sky.py +++ b/croissant/core/sky.py @@ -1,5 +1,5 @@ import numpy as np -from pygdsm import GlobalSkyModel2016 as GSM16 +from pygdsm import GlobalSkyModel16 as GSM16 from .healpix import Alm from .sphtransform import map2alm diff --git a/croissant/jax/sky.py b/croissant/jax/sky.py index 28c8cbf..b18d301 100644 --- a/croissant/jax/sky.py +++ b/croissant/jax/sky.py @@ -2,7 +2,7 @@ import jax import jax.numpy as jnp import s2fft -from pygdsm import GlobalSkyModel2016 as GSM16 +from pygdsm import GlobalSkyModel16 as GSM16 from .healpix import Alm From 7f28b9d147b392539d17b49fa69d0b027e8c2440 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 13 Feb 2024 11:32:43 -0800 Subject: [PATCH 080/129] remove equirements.txt --- requirements.txt | 151 ----------------------------------------------- 1 file changed, 151 deletions(-) delete mode 100644 requirements.txt diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 0819651..0000000 --- a/requirements.txt +++ /dev/null @@ -1,151 +0,0 @@ -anyio==4.2.0 -argon2-cffi==23.1.0 -argon2-cffi-bindings==21.2.0 -arrow==1.3.0 -astropy==6.0.0 -astropy-iers-data==0.2024.1.29.0.30.37 -asttokens==2.4.1 -async-lru==2.0.4 -attrs==23.2.0 -Babel==2.14.0 -beautifulsoup4==4.12.3 -black==24.1.1 -bleach==6.1.0 -build==1.0.3 -certifi==2023.11.17 -cffi==1.16.0 -charset-normalizer==3.3.2 -click==8.1.7 -comm==0.2.1 -contourpy==1.2.0 -coverage==7.4.1 -cryptography==42.0.2 -cycler==0.12.1 -debugpy==1.8.0 -decorator==5.1.1 -defusedxml==0.7.1 -docutils==0.20.1 -ephem==4.1.5 -exceptiongroup==1.2.0 -executing==2.0.1 -fastjsonschema==2.19.1 -flake8==7.0.0 -fonttools==4.47.2 -fqdn==1.5.1 -h5py==3.10.0 -healpy==1.16.6 -hera-filters==0.1.1 -idna==3.6 -importlib-metadata==7.0.1 -iniconfig==2.0.0 -ipykernel==6.29.0 -ipython==8.21.0 -ipywidgets==8.1.1 -isoduration==20.11.0 -jaraco.classes==3.3.0 -jedi==0.19.1 -jeepney==0.8.0 -Jinja2==3.1.3 -jplephem==2.21 -json5==0.9.14 -jsonpointer==2.4 -jsonschema==4.21.1 -jsonschema-specifications==2023.12.1 -jupyter==1.0.0 -jupyter-console==6.6.3 -jupyter-events==0.9.0 -jupyter-lsp==2.2.2 -jupyter_client==8.6.0 -jupyter_core==5.7.1 -jupyter_server==2.12.5 -jupyter_server_terminals==0.5.2 -jupyterlab==4.0.12 -jupyterlab-widgets==3.0.9 -jupyterlab_pygments==0.3.0 -jupyterlab_server==2.25.2 -keyring==24.3.0 -kiwisolver==1.4.5 -lunarsky==0.2.1 -markdown-it-py==3.0.0 -MarkupSafe==2.1.4 -matplotlib==3.8.2 -matplotlib-inline==0.1.6 -mccabe==0.7.0 -mdurl==0.1.2 -mistune==3.0.2 -more-itertools==10.2.0 -mypy==1.8.0 -mypy-extensions==1.0.0 -nbclient==0.9.0 -nbconvert==7.14.2 -nbformat==5.9.2 -nest-asyncio==1.6.0 -nh3==0.2.15 -notebook==7.0.7 -notebook_shim==0.2.3 -numpy==1.23.0 -overrides==7.7.0 -packaging==23.2 -pandocfilters==1.5.1 -parso==0.8.3 -pathspec==0.12.1 -pexpect==4.9.0 -pillow==10.2.0 -pkginfo==1.9.6 -platformdirs==4.2.0 -pluggy==1.4.0 -prometheus-client==0.19.0 -prompt-toolkit==3.0.43 -psutil==5.9.8 -ptyprocess==0.7.0 -pure-eval==0.2.2 -pycodestyle==2.11.1 -pycparser==2.21 -pyephem==9.99 -pyerfa==2.0.1.1 -pyflakes==3.2.0 -pygdsm==1.5.0 -Pygments==2.17.2 -pyparsing==3.1.1 -pyproject_hooks==1.0.0 -pytest==8.0.0 -pytest-cov==4.1.0 -python-dateutil==2.8.2 -python-json-logger==2.0.7 -PyYAML==6.0.1 -pyzmq==25.1.2 -qtconsole==5.5.1 -QtPy==2.4.1 -readme-renderer==42.0 -referencing==0.33.0 -requests==2.31.0 -requests-toolbelt==1.0.0 -rfc3339-validator==0.1.4 -rfc3986==2.0.0 -rfc3986-validator==0.1.1 -rich==13.7.0 -rpds-py==0.17.1 -scipy==1.12.0 -SecretStorage==3.3.3 -Send2Trash==1.8.2 -six==1.16.0 -sniffio==1.3.0 -soupsieve==2.5 -spiceypy==6.0.0 -stack-data==0.6.3 -terminado==0.18.0 -tinycss2==1.2.1 -tomli==2.0.1 -tornado==6.4 -traitlets==5.14.1 -twine==4.0.2 -types-python-dateutil==2.8.19.20240106 -typing_extensions==4.9.0 -uri-template==1.3.0 -urllib3==2.2.0 -wcwidth==0.2.13 -webcolors==1.13 -webencodings==0.5.1 -websocket-client==1.7.0 -widgetsnbextension==4.0.9 -zipp==3.17.0 From 181de9dc61244225029d490aefb8f4596588d2d8 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 13 Feb 2024 11:33:29 -0800 Subject: [PATCH 081/129] add s2fft as dependency, change crojax to jax --- setup.cfg | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/setup.cfg b/setup.cfg index ec5ab7f..9f478cb 100644 --- a/setup.cfg +++ b/setup.cfg @@ -25,6 +25,7 @@ install_requires = matplotlib numpy <= 1.23 pygdsm + s2fft @ git+ssh://git@github.com:astro-informatics/s2fft.git [options.extras_require] dev = @@ -44,5 +45,5 @@ ignore = E203, W503 per-file-ignores = __init__.py:F401 croissant/core/__init__.py:F401 - croissant/crojax/__init__.py:E402, F401 + croissant/jax/__init__.py:E402, F401 max-line-length = 79 From f318eacaeadaa11af1d2115166a2d2788fdca2d8 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 13 Feb 2024 11:34:30 -0800 Subject: [PATCH 082/129] remove reference to requirements.txt --- .github/workflows/push.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index bc5ed24..b073822 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -20,7 +20,6 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - python -m pip install -r requirements.txt python -m pip install --upgrade "jax[cpu]" python -m pip install .[dev] - name: Lint with flake8 From 01cb7153bbcc80f929f388d1022d5fba28bc10b8 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 13 Feb 2024 12:00:23 -0800 Subject: [PATCH 083/129] fix github link --- setup.cfg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.cfg b/setup.cfg index 9f478cb..c2b1a65 100644 --- a/setup.cfg +++ b/setup.cfg @@ -25,7 +25,7 @@ install_requires = matplotlib numpy <= 1.23 pygdsm - s2fft @ git+ssh://git@github.com:astro-informatics/s2fft.git + s2fft @ git+https://github.com/astro-informatics/s2fft.git [options.extras_require] dev = From eb161a74186a44efd2dd21fade40956f2f19108c Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 13 Feb 2024 12:10:06 -0800 Subject: [PATCH 084/129] crojax -> jax --- .github/workflows/push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index b073822..b09bc27 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -31,7 +31,7 @@ jobs: #mypy ./croissant/ - name: Test with pytest run: | - pytest --cov=croissant --cov-report=xml croissant/tests croissant/core/tests croissant/crojax/tests + pytest --cov=croissant --cov-report=xml croissant/tests croissant/core/tests croissant/jax/tests - name: Upload coverage to Codecov uses: codecov/codecov-action@v4 with: From dd104fe860305784ef16df9a773ebc99c4fc3594 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Tue, 13 Feb 2024 12:16:02 -0800 Subject: [PATCH 085/129] crojax -> jax --- croissant/jax/tests/test_beam.py | 2 +- croissant/jax/tests/test_healpix.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/croissant/jax/tests/test_beam.py b/croissant/jax/tests/test_beam.py index e0b5186..2edf3ed 100644 --- a/croissant/jax/tests/test_beam.py +++ b/croissant/jax/tests/test_beam.py @@ -3,7 +3,7 @@ import jax.numpy as jnp from s2fft.sampling import s2_samples from croissant.constants import Y00 -from croissant.crojax import Beam +from croissant.jax import Beam pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) frequencies = jnp.linspace(1, 50, 50) diff --git a/croissant/jax/tests/test_healpix.py b/croissant/jax/tests/test_healpix.py index 4567b3e..3434e98 100644 --- a/croissant/jax/tests/test_healpix.py +++ b/croissant/jax/tests/test_healpix.py @@ -3,7 +3,7 @@ from numpy.random import default_rng import jax.numpy as jnp import s2fft -from croissant.crojax import healpix as hp +from croissant.jax import healpix as hp from croissant.constants import sidereal_day_earth, sidereal_day_moon, Y00 pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) From 4d29d756e1ce8663d75daea0f0a0727f3b19fb74 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 17 May 2024 17:08:37 -0700 Subject: [PATCH 086/129] ducktyping --- croissant/core/rotations.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/croissant/core/rotations.py b/croissant/core/rotations.py index 4536396..5a6f8c9 100644 --- a/croissant/core/rotations.py +++ b/croissant/core/rotations.py @@ -24,7 +24,10 @@ def get_rot_mat(from_frame, to_frame): """ # cannot instantiate a SkyCoord with a gaalctic frame from cartesian - from_name = from_frame.name if hasattr(from_frame, "name") else from_frame + try: + from_name = from_frame.name + except AttributeError: + from_name = from_frame if from_name.lower() == "galactic": from_frame = to_frame to_frame = "galactic" From 5e606540ea8fd7e4a12545b62407eed123cd1aad Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 17 May 2024 17:09:11 -0700 Subject: [PATCH 087/129] remove dependabot --- .github/dependabot.yml | 13 ------------- 1 file changed, 13 deletions(-) delete mode 100644 .github/dependabot.yml diff --git a/.github/dependabot.yml b/.github/dependabot.yml deleted file mode 100644 index 55603b4..0000000 --- a/.github/dependabot.yml +++ /dev/null @@ -1,13 +0,0 @@ -version: 2 -updates: - - - package-ecosystem: "pip" - directory: "/croissant" # Location of package manifests - schedule: - interval: "daily" - - - package-ecosystem: "github-actions" - directory: "/" # Location of package manifests - schedule: - interval: "daily" - From eb7acc7162bb7efb75a708515da5145933061b0c Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Sat, 18 May 2024 14:01:52 -0700 Subject: [PATCH 088/129] use version of pygsm that supports python 3.8 --- setup.cfg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.cfg b/setup.cfg index c2b1a65..abb7764 100644 --- a/setup.cfg +++ b/setup.cfg @@ -24,7 +24,7 @@ install_requires = lunarsky matplotlib numpy <= 1.23 - pygdsm + pygdsm == 1.5.0 s2fft @ git+https://github.com/astro-informatics/s2fft.git [options.extras_require] From faf14e0eade489b77c0a2e3cfa928b3e1de71361 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 22 May 2024 16:39:27 -0700 Subject: [PATCH 089/129] initial commit --- croissant/jax/alm.py | 293 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 293 insertions(+) create mode 100644 croissant/jax/alm.py diff --git a/croissant/jax/alm.py b/croissant/jax/alm.py new file mode 100644 index 0000000..9ce63d9 --- /dev/null +++ b/croissant/jax/alm.py @@ -0,0 +1,293 @@ +import jax.numpy as jnp +import s2fft + +from ..constants import Y00 + + +def alm2map( + alm, spin=0, nside=None, sampling="healpix", precomps=None, spmd=True +): + """ + Construct a map on the sphere from the alm array. This is a wrapper + around s2fft.inverse provided for convenience. + + Parameters + ---------- + alm : jnp.ndarray + The alm array. Must have shape (lmax+1, 2*lmax+1). Use + jax.vmap to vectorize over multiple alms. + spin : int + Harmonic spin of the map. Must be 0 or 1. + nside : int + The nside of the healpix map to construct. Required if sampling + is "healpix". + sampling : str + Sampling scheme on the sphere. Must be in + {"mw", "mwss", "dh", "healpix"}. Passed to s2fft.inverse. + precomps : list + Precomputed values for the s2fft.inverse function. Passed to + s2fft.inverse. + spmd : bool + Map the computation over all available devices. Passed to + s2fft.inverse. + + Returns + ------- + m : jnp.ndarray + The map(s) corresponding to the alm. + + """ + L = lmax_from_shape(alm.shape) + 1 + m = s2fft.inverse_jax( + alm, + L, + spin=spin, + nside=nside, + sampling=sampling, + reality=is_real(alm), + spmd=spmd, + L_lower=0, + ) + return m + + +def map2alm( + m, + lmax, + spin=0, + nside=None, + sampling="healpix", + reality=True, + precomps=None, + spmd=True, +): + """ + Construct the alm array from a map on the sphere. This is a wrapper + around s2fft.forward provided for convenience. + + Parameters + ---------- + m : jnp.ndarray + The map on the sphere. Use jax.vmap to vectorize over multiple + maps. + lmax : int + The maximum l value. Note that s2fft uses L which is lmax+1. + spin : int + Harmonic spin of the map. Must be 0 or 1. + nside : int + The nside of the healpix map. Required if sampling is "healpix". + sampling : str + Sampling scheme on the sphere. Must be in + {"mw", "mwss", "dh", "gl", "healpix"}. Passed to s2fft.forward. + reality : bool + True if the map is real-valued. Passed to s2fft.forward. + precomps : list + Precomputed values for the s2fft.forward function. Passed to + s2fft.forward. + spmd : bool + Map the computation over all available devices. Passed to + s2fft.forward. + + Returns + ------- + alm : jnp.ndarray + The alm array corresponding to the map. + + """ + L = lmax + 1 + alm = s2fft.forward_jax( + m, + L, + spin=spin, + nside=nside, + sampling=sampling, + reality=reality, + spmd=spmd, + L_lower=0, + ) + return alm + +def total_power(alm): + """ + Compute the integral of a signal (such as an antenna beam) given + the spherical harmonic coefficients. This is needed to normalize the + visibilities. Only the monoopole component will integrate to + a non-zero value. + + Parameters + ---------- + alm : jnp.ndarray + The spherical harmonic coefficients. The last two dimensions must + correspond to the ell and emm indices respectively. + + Returns + ------- + power : float + The total power of the signal. + + """ + lmax = lmax_from_shape(alm.shape) + # get the index of the monopole component + lix, mix = getidx(lmax, 0, 0) + monopole = alm[..., lix, mix] + return 4 * jnp.pi * jnp.real(monopole) * Y00 + + +def getidx(lmax, ell, emm): + """ + Get the index of the alm array for a given l and m. + + Parameters + ---------- + lmax : int + The maximum l value. + ell : int or jnp.ndarray + The value of l. + emm : int or jnp.ndarray + The value of m. + + Returns + ------- + l_ix : int or jnp.ndarray + The l index (which is the same as the input ell). + m_ix : int or jnp.ndarray + The m index. + + Raises + ------ + IndexError + If l,m don't satisfy abs(m) <= l <= lmax. + """ + if not ((jnp.abs(emm) <= ell) & (ell <= lmax)).all(): + raise IndexError("l,m must satsify abs(m) <= l <= lmax.") + return ell, emm + lmax + + +def getlm(lmax, ix): + """ + Get the l and m corresponding to the index of the alm array. + + Parameters + ---------- + lmax : int + The maximum l value. + + ix : jnp.ndarray + The indices of the alm array. The first row corresponds to the l + index, and the second row corresponds to the m index. Multiple + indices can be passed in as an array with shape (2, n). + + Returns + ------- + ell : jnp.ndarray + The value of l. Has shape (n,). + emm : jnp.ndarray + The value of m. Has shape (n,). + + """ + ell = ix[0] + emm = ix[1] - lmax + return ell, emm + + +def lmax_from_shape(shape): + """ + Get the lmax from the shape of the alm array. + + Parameters + ---------- + shape : tuple + The shape of the alm array. The last two dimensions must correspond + to the ell and emm indices respectively. + + Returns + ------- + lmax : int + The maximum l value. + + """ + return shape[-2] - 1 + + +def is_real(alm): + """ + Check if the coefficients of an array of alms correspond to a real-valued + signal. Mathematically, this is true if the coefficients satisfy + alm(l, m) = (-1)^m * conj(alm(l, -m)). + + Parameters + ---------- + alm : jnp.ndarray + The spherical harmonics coefficients. The last two dimensions must + correspond to the ell and emm indices respectively. + + Returns + ------- + is_real : bool + True if the coefficients correspond to a real-valued signal. + + """ + lmax = lmax_from_shape(alm.shape) + emm = jnp.arange(1, lmax + 1) # positive ms + # reshape emm to broadcast with alm by adding 1 or 2 dimensions + emm = emm.reshape((1,) * (alm.ndim - 1) + emm.shape) + # get alms for negative m, in reverse order (i.e., increasing abs(m)) + neg_m = alm[..., :lmax:-1] + # get alms for positive m + pos_m = alm[..., lmax + 1 :] + return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)).item() + + +def reduce_lmax(alm, new_lmax): + """ + Reduce the maximum l value of the alm. + + Parameters + ---------- + alm : jnp.ndarray + The alm array. Last two dimensions must correspond to the ell and + emm indices. + new_lmax : int + The new maximum l value. Must be less than or equal to alm lmax. + + Returns + ------- + new_alm : jnp.ndarray + The alm array with the new maximum l value. + + Raises + ------ + ValueError + If new_lmax is greater than the current lmax. + + """ + lmax = lmax_from_shape(alm.shape) + d = lmax - new_lmax # number of ell values to remove + if d < 0: + raise ValueError( + "new_lmax must be less than or equal to the current lmax" + ) + return alm[..., :-d, d:-d] + + +def zeros(lmax, nfreqs=None): + """ + Construct an alm array of zeros. + + Parameters + ---------- + lmax : int + The maximum l value. + nfreqs : int + The number of frequencies. If specified, the array will have an + additional dimension corresponding to the frequencies at axis 0. + + Returns + ------- + alm : jnp.ndarray + The alm array of zeros. Shape is ([nfreqs,] lmax+1, 2*lmax+1). + """ + s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) + shape = (nfreqs, s1, s2) + alm = jnp.zeros(shape, dtype=jnp.complex128) + return alm From 717f2593419071ff8599192be6e16d23d9fbeb06 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 22 May 2024 16:40:07 -0700 Subject: [PATCH 090/129] move functions to alm.py, shift from classes to pure functions --- croissant/jax/__init__.py | 4 +- croissant/jax/beam.py | 70 --------- croissant/jax/healpix.py | 308 -------------------------------------- 3 files changed, 1 insertion(+), 381 deletions(-) delete mode 100644 croissant/jax/beam.py delete mode 100644 croissant/jax/healpix.py diff --git a/croissant/jax/__init__.py b/croissant/jax/__init__.py index 63211f6..52d65fc 100644 --- a/croissant/jax/__init__.py +++ b/croissant/jax/__init__.py @@ -3,7 +3,5 @@ config.update("jax_enable_x64", True) -from .beam import Beam -from .healpix import Alm -from .simulator import Simulator +from . import alm, simulator from .sky import Sky diff --git a/croissant/jax/beam.py b/croissant/jax/beam.py deleted file mode 100644 index c918485..0000000 --- a/croissant/jax/beam.py +++ /dev/null @@ -1,70 +0,0 @@ -from functools import partial -import jax -import jax.numpy as jnp -import s2fft -from healpy import get_nside - -from ..constants import Y00 -from .healpix import Alm - - -class Beam(Alm): - def compute_total_power(self): - """ - Compute the total integrated power in the beam at each frequency. This - is a necessary normalization constant for computing the visibilities. - It should be computed before applying the horizon cut in order to - account for ground loss. - """ - a00 = self[:, 0, 0] - power = a00.real * Y00 * 4 * jnp.pi - self.total_power = power - - def horizon_cut(self, horizon=None, sampling="mw", nside=None): - """ - horizon : jnp.ndarray - A mask 0s and 1s indicating the horizon, with 1s corresponding to - above the horizon. If None, the horizon is assumed to be flat at - theta = pi/2. The shape must match the sampling scheme given by - ``sampling'' and the lmax of the beam given in self.lmax. See - s2fft.sampling.s2_samples.f_shape for details. - sampling : str - Sampling scheme of the horizon mask. Must be in - {"mw", "mwss", "dh", "healpix"}. Gets passed to s2fft.forward. - nside : int - The nside of the horizon mask for the intermediate step. Required - if sampling == "healpix" and horizon is None. - - Raises - ------ - ValueError - If horizon is not None and has elements outside of [0, 1]. - """ - if horizon is not None: - if horizon.min() < 0 or horizon.max() > 1: - raise ValueError("Horizon elements must be in [0, 1].") - if sampling.lower() == "healpix": - nside = get_nside(horizon) - - # invoke horizon mask in pixel space - m = self.alm2map(sampling=sampling, nside=nside) - if horizon is None: - horizon = jnp.ones_like(m) - theta = s2fft.sampling.s2_samples.thetas( - L=self.lmax + 1, sampling=sampling, nside=nside - ) - horizon = horizon.at[:, theta > jnp.pi / 2].set(0.0) - - m = m * horizon - forward = partial( - s2fft.forward_jax, - spin=0, - nside=nside, - sampling=sampling, - reality=self.is_real, - precomps=None, - spmd=True, - L_lower=0, - ) - L = self.lmax.item() + 1 - self.alm = jax.vmap(forward, in_axes=(0, None))(m, L) diff --git a/croissant/jax/healpix.py b/croissant/jax/healpix.py deleted file mode 100644 index 70a7365..0000000 --- a/croissant/jax/healpix.py +++ /dev/null @@ -1,308 +0,0 @@ -from functools import partial -import warnings -import jax -import jax.numpy as jnp -import s2fft -from .. import constants, utils - - -@jax.jit -def lmax_from_shape(shape): - """ - Get the lmax from the shape of the alm array. - """ - return shape[1] - 1 - - -@jax.jit -def _getlm(ix, lmax): - ell = ix[0] - emm = ix[1] - lmax - return ell, emm - - -@jax.jit -def _getidx(ell, emm, lmax): - l_ix = ell - m_ix = emm + lmax - return l_ix, m_ix - - -def _is_real(alm): - """ - Check if the alm coefficients correspond to a real-valued signal. - - Parameters - ---------- - alm : jnp.ndarray - The spherical harmonics coefficients. Must have shape - (nfreq, lmax+1, 2*lmax+1) corresponding to the frequencies, ell, and - emm indices. - - Returns - ------- - is_real : bool - True if the coefficients correspond to a real-valued signal. - - """ - lmax = lmax_from_shape(alm.shape) - emm = jnp.arange(1, lmax + 1)[None, None, :] # positive ms - # get alms for negative m, in reverse order (i.e., increasing abs(m)) - neg_m = alm[:, :, :lmax][:, :, ::-1] - # get alms for positive m - pos_m = alm[:, :, lmax + 1 :] - return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)).item() - - -def _rot_alm_z(lmax, phi): - """ - Get the coefficients that rotate the alms around the z-axis by phi - (measured counterclockwise). - - Parameters - ---------- - lmax : int - The maximum l value. - phi : jnp.ndarray - The angle(s) to rotate the azimuth by in radians. - - Returns - ------- - phase : np.ndarray - The coefficients that rotate the alms by phi. Has shape (n, 2*lmax+1), - where n is the number of phi values and 2*lmax+1 is the number of - m values given lmax. - """ - phi = jnp.atleast_1d(phi)[:, None] - emms = jnp.arange(-lmax, lmax + 1)[None] - phase = jnp.exp(-1j * emms * phi) - return phase - - -class Alm: - def __init__(self, alm, frequencies=None, coord=None): - """ - Base class for spherical harmonics coefficients. - - Alm can be indexed with [freq_index, ell, emm] to get the - coeffiecient corresponding to the given frequency index, and values of - ell and emm. The frequencies can be indexed in the usual numpy way and - may be 0 if the alms are specified for only one frequency. - - Parameters - ---------- - alm : jnp.ndarray - The spherical harmonics coefficients. Must have shape - (nfreq, lmax+1, 2*lmax+1). - frequencies : jnp.ndarray - The frequencies corresponding to the coefficients. Must have shape - (nfreq,). If None, then the coefficients are assumed to be for a - single frequency and nfreq is set to 1. - coord : str - The coordinate system of the coefficients. - - - """ - self.alm = alm - self.frequencies = frequencies - self.lmax = lmax_from_shape(alm.shape) - if coord is None: - self.coord = None - else: - self.coord = utils.coord_rep(coord) - - def __setitem__(self, key, value): - """ - Set the value of the spherical harmonics coefficient. The frequency - axis is indexed in the usual numpy way, while the other two indices - correspond to the values of l and m. - """ - lix, mix = self.getidx(*key[1:]) - new_key = (key[0], lix, mix) - self.alm = self.alm.at[new_key].set(value) - - def __getitem__(self, key): - lix, mix = self.getidx(*key[1:]) - new_key = (key[0], lix, mix) - return self.alm[new_key] - - def getlm(self, ix): - """ - Get the l and m corresponding to the index of the alm array. - - Parameters - ---------- - ix : jnp.ndarray - The indices of the alm array. The first row corresponds to the l - index, and the second row corresponds to the m index. Multiple - indices can be passed in as an array with shape (2, n). - - Returns - ------- - ell : jnp.ndarray - The value of l. Has shape (n,). - emm : jnp.ndarray - The value of m. Has shape (n,). - """ - return _getlm(ix, self.lmax) - - def getidx(self, ell, emm): - """ - Get the index of the alm array for a given l and m. - - Parameters - ---------- - ell : int or jnp.ndarray - The value of l. - emm : int or jnp.ndarray - The value of m. - - Returns - ------- - l_ix : int or jnp.ndarray - The l index (which is the same as the input ell). - m_ix : int or jnp.ndarray - The m index. - - Raises - ------ - IndexError - If l,m don't satisfy abs(m) <= l <= lmax. - """ - if not ((jnp.abs(emm) <= ell) & (ell <= self.lmax)).all(): - raise IndexError("l,m must satsify abs(m) <= l <= lmax.") - return _getidx(ell, emm, self.lmax) - - @classmethod - def zeros(cls, lmax, frequencies=None, coord=None): - """ - Construct an Alm object with all zero coefficients. - """ - s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) - shape = (jnp.size(frequencies), s1, s2) - alm = jnp.zeros(shape, dtype=jnp.complex128) - obj = cls( - alm=alm, - frequencies=frequencies, - coord=coord, - ) - return obj - - @property - def is_real(self): - """ - Check if the coefficients correspond to a real-valued signal. - Mathematically, this means that alm(l, m) = (-1)^m * conj(alm(l, -m)). - """ - return _is_real(self.alm) - - def reduce_lmax(self, new_lmax): - """ - Reduce the maximum l value of the alm. - - Parameters - ---------- - new_lmax : int - The new maximum l value. - - Raises - ------ - ValueError - If new_lmax is greater than the current lmax. - """ - d = self.lmax - new_lmax # number of ell values to remove - if d < 0: - raise ValueError( - "new_lmax must be less than or equal to the current lmax" - ) - elif d > 0: - self.alm = self.alm[:, :-d, d:-d] - self.lmax = new_lmax - - def switch_coords(self, to_coord, loc=None, time=None): - raise NotImplementedError - - def alm2map(self, sampling="healpix", nside=None, frequencies=None): - """ - Construct a Healpix map from the Alm for the given frequencies. - - Parameters - ---------- - sampling : str - Sampling scheme on the sphere. Must be in - {"mw", "mwss", "dh", "healpix"}. Gets passed to s2fft.inverse. - nside : int - The nside of the Healpix map to construct. Required if sampling - is "healpix". - frequencies : jnp.ndarray - The frequencies to construct the map for. If None, the map will - be constructed for all frequencies. - - Returns - ------- - m : jnp.ndarray - The map(s) corresponding to the alm. - - """ - if frequencies is None: - alm = self.alm - else: - indices = jnp.isin( - self.frequencies, frequencies, assume_unique=True - ).nonzero()[0] - if indices.size < jnp.size(frequencies): - warnings.warn( - "Some of the frequencies specified are not in" - "alm.frequencies.", - UserWarning, - ) - alm = self.alm[indices] - inverse = partial( - s2fft.inverse_jax, - spin=0, - nside=nside, - sampling=sampling, - reality=self.is_real, - precomps=None, # XXX - spmd=True, # XXX - L_lower=0, - ) - L = self.lmax.item() + 1 - m = jax.vmap(inverse, in_axes=[0, None])(alm, L) - return m - - def rot_alm_z(self, phi=None, times=None, world="moon"): - """ - Get the coefficients that rotate the alms around the z-axis by phi - (measured counterclockwise) or in time. - - Parameters - ---------- - phi : jnp.ndarray - The angle(s) to rotate the azimuth by in radians. - times : jnp.ndarray - The times to rotate the azimuth by in seconds. If given, phi will - be ignored and the rotation angle will be calculated from the - times and the sidereal day of the world. - world : str - The world to use for the sidereal day. Must be 'moon' or 'earth'. - - Returns - ------- - phase : jnp.ndarray - The coefficients (shape = (phi.size, 2*lmax+1) that rotate the - alms by phi. - - """ - if times is not None: - if world.lower() == "moon": - sidereal_day = constants.sidereal_day_moon - elif world.lower() == "earth": - sidereal_day = constants.sidereal_day_earth - else: - raise ValueError( - f"World must be 'moon' or 'earth', not {world}." - ) - phi = 2 * jnp.pi * times / sidereal_day - return _rot_alm_z(self.lmax, phi) - return _rot_alm_z(self.lmax, phi) From 9e706497991f41698ef64623ae55bcccd9d642d0 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 22 May 2024 16:40:22 -0700 Subject: [PATCH 091/129] shift from classes to pure functions --- croissant/jax/simulator.py | 72 ++++++++++++++++++++++---------------- 1 file changed, 41 insertions(+), 31 deletions(-) diff --git a/croissant/jax/simulator.py b/croissant/jax/simulator.py index a0711b1..902f787 100644 --- a/croissant/jax/simulator.py +++ b/croissant/jax/simulator.py @@ -1,21 +1,57 @@ +from functools import partial import jax import jax.numpy as jnp -from ..simulatorbase import SimulatorBase + +from .. import constants + + +@partial(jax.jit, static_argnums=(0,)) +def rot_alm_z(lmax, times, sidereal_day=constants.sidereal_day_moon): + """ + Compute the complex phases that rotate the sky for a range of times. The + first time is the reference time and the phases are computed relative to + this time. + + Parameters + ---------- + lmax : int + The maximum ell value. + times : jnp.ndarray + The times for which to compute the phases. + sidereal_day : str + The length of a sidereal day in the same units as ``times''. Default + is the sidereal day of the Moon, see constants.py for the sidereal + day of the Earth. + + Returns + ------- + phases : jnp.ndarray + The phases that rotate the sky, of the form exp(-i*m*phi(t)). + Shape (N_times, 2*lmax+1). + + """ + dt = times - times[0] # time difference from reference + phi = 2 * jnp.pi * dt / sidereal_day # rotation angle + emms = jnp.arange(-lmax, lmax + 1) # m values + phases = jnp.exp(-1j * emms[None] * phi[:, None]) + return phases + @jax.jit -def convolve(sky_alm, beam_alm, phases): +def run(sky_alm, beam_alm, phases): """ Compute the convolution for a range of times in jax. The convolution is a dot product in l,m space. Axes are in the order: time, freq, ell, emm. - + Parameters ---------- sky_alm : jnp.ndarray The sky alms. Shape (N_freqs, lmax+1, 2*lmax+1). beam_alm : jnp.ndarray - The beam alms. Shape (N_freqs, lmax+1, 2*lmax+1). + The beam alms. Shape (N_freqs, lmax+1, 2*lmax+1). The beam should be + normalized to have total power of unity. phases : jnp.ndarray - The phases that roate the sky, of the form exp(-i*m*phi(t)). + The phases that rotate the sky, of the form exp(-i*m*phi(t)). Shape (N_times, 2*lmax+1). Returns @@ -28,29 +64,3 @@ def convolve(sky_alm, beam_alm, phases): b = beam_alm.conjugate()[None, :, :, :] # add time axis and conjugate res = jnp.sum(s * p * b, axes=(2, 3)) # dot product in l,m space return res - -def convolve_dpss(): - raise NotImplementedError - -class Simulator(SimulatorBase): - def run(self, dpss=True, **dpss_kwargs): - """ - Compute the convolution for a range of times in jax. - - Parameters - ---------- - dpss : bool - Whether to use a dpss basis or not. - dpss_kwargs : dict - Passed to SimulatorBase().compute_dpss. - - """ - if dpss: - res = convolve_dpss() - else: - res = convolve( - self.sky.alm, - self.beam.alm, - self.sky.rot_alm_z(self.dt, self.world) - ) - self.waterfall = res / self.beam.total_power From c9f66457675db41d995fad59fc558d05dee54389 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 23 May 2024 15:56:23 -0700 Subject: [PATCH 092/129] delete sky module that no longer has a purpose --- croissant/jax/__init__.py | 3 +-- croissant/jax/sky.py | 38 -------------------------------------- 2 files changed, 1 insertion(+), 40 deletions(-) delete mode 100644 croissant/jax/sky.py diff --git a/croissant/jax/__init__.py b/croissant/jax/__init__.py index 52d65fc..18e57f2 100644 --- a/croissant/jax/__init__.py +++ b/croissant/jax/__init__.py @@ -3,5 +3,4 @@ config.update("jax_enable_x64", True) -from . import alm, simulator -from .sky import Sky +from . import alm, rotations, simulator diff --git a/croissant/jax/sky.py b/croissant/jax/sky.py deleted file mode 100644 index b18d301..0000000 --- a/croissant/jax/sky.py +++ /dev/null @@ -1,38 +0,0 @@ -from functools import partial -import jax -import jax.numpy as jnp -import s2fft -from pygdsm import GlobalSkyModel16 as GSM16 -from .healpix import Alm - - -class Sky(Alm): - @classmethod - def gsm(cls, freq, lmax): - """ - Construct a sky object with pygdsm. - - Parameters - ---------- - freq : jnp.ndarray - Frequencies to make map at in MHz. - lmax : int - Maximum multipole to compute alm up to. - """ - gsm = GSM16(freq_unit="MHz", data_unit="TRJ", resolution="lo") - sky_map = gsm.generate(freq) - sky_map = jnp.atleast_2d(sky_map) - forward = partial( - s2fft.forward_jax, - spin=0, - nside=gsm.nside, - sampling="healpix", - reality=True, - precomps=None, - spmd=True, - L_lower=0, - ) - L = lmax + 1 - sky_alm = jax.vmap(forward, in_axes=[0, None])(sky_map, L) - obj = cls(sky_alm, frequencies=freq, coord="G") - return obj From 2e7f8ff28387c88e578dd9973966e66ebc1fbd45 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 23 May 2024 15:56:47 -0700 Subject: [PATCH 093/129] make functions pure, decorate with jax.jit --- croissant/jax/alm.py | 34 +++++++++++++--------------------- 1 file changed, 13 insertions(+), 21 deletions(-) diff --git a/croissant/jax/alm.py b/croissant/jax/alm.py index 9ce63d9..5e95f80 100644 --- a/croissant/jax/alm.py +++ b/croissant/jax/alm.py @@ -1,9 +1,10 @@ +import jax import jax.numpy as jnp import s2fft from ..constants import Y00 - +@jax.jit def alm2map( alm, spin=0, nside=None, sampling="healpix", precomps=None, spmd=True ): @@ -50,7 +51,7 @@ def alm2map( ) return m - +@jax.jit def map2alm( m, lmax, @@ -107,6 +108,7 @@ def map2alm( ) return alm +@jax.jit def total_power(alm): """ Compute the integral of a signal (such as an antenna beam) given @@ -132,7 +134,7 @@ def total_power(alm): monopole = alm[..., lix, mix] return 4 * jnp.pi * jnp.real(monopole) * Y00 - +@jax.jit def getidx(lmax, ell, emm): """ Get the index of the alm array for a given l and m. @@ -158,11 +160,9 @@ def getidx(lmax, ell, emm): IndexError If l,m don't satisfy abs(m) <= l <= lmax. """ - if not ((jnp.abs(emm) <= ell) & (ell <= lmax)).all(): - raise IndexError("l,m must satsify abs(m) <= l <= lmax.") return ell, emm + lmax - +@jax.jit def getlm(lmax, ix): """ Get the l and m corresponding to the index of the alm array. @@ -189,7 +189,7 @@ def getlm(lmax, ix): emm = ix[1] - lmax return ell, emm - +@jax.jit def lmax_from_shape(shape): """ Get the lmax from the shape of the alm array. @@ -208,7 +208,7 @@ def lmax_from_shape(shape): """ return shape[-2] - 1 - +@jax.jit def is_real(alm): """ Check if the coefficients of an array of alms correspond to a real-valued @@ -237,7 +237,7 @@ def is_real(alm): pos_m = alm[..., lmax + 1 :] return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)).item() - +@jax.jit def reduce_lmax(alm, new_lmax): """ Reduce the maximum l value of the alm. @@ -263,14 +263,10 @@ def reduce_lmax(alm, new_lmax): """ lmax = lmax_from_shape(alm.shape) d = lmax - new_lmax # number of ell values to remove - if d < 0: - raise ValueError( - "new_lmax must be less than or equal to the current lmax" - ) return alm[..., :-d, d:-d] - -def zeros(lmax, nfreqs=None): +@jax.jit +def zeros(lmax): """ Construct an alm array of zeros. @@ -278,16 +274,12 @@ def zeros(lmax, nfreqs=None): ---------- lmax : int The maximum l value. - nfreqs : int - The number of frequencies. If specified, the array will have an - additional dimension corresponding to the frequencies at axis 0. Returns ------- alm : jnp.ndarray - The alm array of zeros. Shape is ([nfreqs,] lmax+1, 2*lmax+1). + The alm array of zeros. Shape is (lmax+1, 2*lmax+1). """ - s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) - shape = (nfreqs, s1, s2) + shape = s2fft.sampling.s2_samples.flm_shape(lmax + 1) alm = jnp.zeros(shape, dtype=jnp.complex128) return alm From ff85d1b964160c23114deb864284ab9476aa6de6 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 23 May 2024 17:45:30 -0700 Subject: [PATCH 094/129] rename utils and move two functions from rotations.py --- croissant/coordinates.py | 86 +++++++++++++++++++++++++++++++++++++ croissant/core/rotations.py | 62 +------------------------- croissant/utils.py | 21 --------- 3 files changed, 87 insertions(+), 82 deletions(-) create mode 100644 croissant/coordinates.py delete mode 100644 croissant/utils.py diff --git a/croissant/coordinates.py b/croissant/coordinates.py new file mode 100644 index 0000000..5e628a2 --- /dev/null +++ b/croissant/coordinates.py @@ -0,0 +1,86 @@ +from lunarsky import SkyCoord +import numpy as np + + +def coord_rep(coord): + """ + Shorthand notation for coordinate systems. + + Parameters + ---------- + coord : str + The name of the coordinate system. + + Returns + ------- + rep : str + The one-letter shorthand notation for the coordinate system. + + """ + coord = coord.upper() + if coord[0] == "E" and coord[1] == "Q": + rep = "C" + else: + rep = coord[0] + return rep + + +def get_rot_mat(from_frame, to_frame): + """ + Get the rotation matrix that transforms from one frame to another. + + Parameters + ---------- + from_frame : str or astropy frame + The coordinate frame to transform from. + to_frame : str or astropy frame + The coordinate frame to transform to. + + Returns + ------- + rmat : np.ndarray + The rotation matrix. + + """ + try: + from_name = from_frame.name + except AttributeError: + from_name = from_frame + # skycoord does not support galactic -> cartesian, do the inverse + if from_name.lower() == "galactic": + from_frame = to_frame + to_frame = "galactic" + return_inv = True + else: + return_inv = False + x, y, z = np.eye(3) # unit vectors + sc = SkyCoord( + x=x, y=y, z=z, frame=from_frame, representation_type="cartesian" + ) + rmat = sc.transform_to(to_frame).cartesian.xyz.value + if return_inv: + rmat = rmat.T + return rmat + + +def rotmat_to_euler(mat): + """ + Convert a rotation matrix to Euler angles in the ZYX convention. This is + sometimes referred to as Tait-Bryan angles X1-Y2-Z3. + + Parameters + ---------- + mat : np.ndarray + The rotation matrix. + + Returns + -------- + eul : tup + The Euler angles. + + """ + beta = np.arcsin(mat[0, 2]) + alpha = np.arctan2(mat[1, 2] / np.cos(beta), mat[2, 2] / np.cos(beta)) + gamma = np.arctan2(mat[0, 1] / np.cos(beta), mat[0, 0] / np.cos(beta)) + eul = (gamma, beta, alpha) + return eul diff --git a/croissant/core/rotations.py b/croissant/core/rotations.py index 5a6f8c9..9f4c4e3 100644 --- a/croissant/core/rotations.py +++ b/croissant/core/rotations.py @@ -3,70 +3,10 @@ from lunarsky import LunarTopo, MoonLocation, SkyCoord import numpy as np +from ..coordinates import get_rot_mat, rotmat_to_euler from .sphtransform import map2alm, alm2map -def get_rot_mat(from_frame, to_frame): - """ - Get the rotation matrix that transforms from one frame to another. - - Parameters - ---------- - from_frame : str or astropy frame - The coordinate frame to transform from. - to_frame : str or astropy frame - The coordinate frame to transform to. - - Returns - ------- - rmat : np.ndarray - The rotation matrix. - - """ - # cannot instantiate a SkyCoord with a gaalctic frame from cartesian - try: - from_name = from_frame.name - except AttributeError: - from_name = from_frame - if from_name.lower() == "galactic": - from_frame = to_frame - to_frame = "galactic" - return_inv = True - else: - return_inv = False - x, y, z = np.eye(3) # unit vectors - sc = SkyCoord( - x=x, y=y, z=z, frame=from_frame, representation_type="cartesian" - ) - rmat = sc.transform_to(to_frame).cartesian.xyz.value - if return_inv: - rmat = rmat.T - return rmat - - -def rotmat_to_euler(mat): - """ - Convert a rotation matrix to Euler angles in the ZYX convention. This is - sometimes referred to as Tait-Bryan angles X1-Y2-Z3. - - Parameters - ---------- - mat : np.ndarray - The rotation matrix. - - Returns - -------- - eul : tup - The Euler angles. - - """ - beta = np.arcsin(mat[0, 2]) - alpha = np.arctan2(mat[1, 2] / np.cos(beta), mat[2, 2] / np.cos(beta)) - gamma = np.arctan2(mat[0, 1] / np.cos(beta), mat[0, 0] / np.cos(beta)) - eul = (gamma, beta, alpha) - return eul - - class Rotator(hp.Rotator): def __init__( self, diff --git a/croissant/utils.py b/croissant/utils.py deleted file mode 100644 index a2fdd53..0000000 --- a/croissant/utils.py +++ /dev/null @@ -1,21 +0,0 @@ -def coord_rep(coord): - """ - Shorthand notation for coordinate systems. - - Parameters - ---------- - coord : str - The name of the coordinate system. - - Returns - ------- - rep : str - The one-letter shorthand notation for the coordinate system. - - """ - coord = coord.upper() - if coord[0] == "E" and coord[1] == "Q": - rep = "C" - else: - rep = coord[0] - return rep From 40223cd56d7e8033b74e2fda75a696663aa21b4c Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 23 May 2024 18:22:10 -0700 Subject: [PATCH 095/129] initial commit --- croissant/jax/rotations.py | 141 +++++++++++++++++++++++++++++++++++++ 1 file changed, 141 insertions(+) create mode 100644 croissant/jax/rotations.py diff --git a/croissant/jax/rotations.py b/croissant/jax/rotations.py new file mode 100644 index 0000000..c5821fe --- /dev/null +++ b/croissant/jax/rotations.py @@ -0,0 +1,141 @@ +from astropy.coordinates import AltAz +from lunarsky import LunarTopo +from s2fft import rotate_flms +import jax + +from ..coordinates import get_rot_mat, rotmat_to_euler +from .alm import lmax_from_shape + + +@jax.jit +def rotate_alm(alm, from_frame, to_frame, dl_array=None): + """ + Transform a spherical harmonic decomposition from one coordinate system to + another. This is a wrapper around the s2fft.rotate_flms function that + computes the Euler angles from the input and output coordinate systems. + + Parameters + ---------- + alm : jnp.ndarray + The alm array to transform. + from_frame : str or astropy frame + The coordinate system of the input alm. + to_frame : str or astropy frame + The coordinate system of the output alm. + dl_array : jnp.ndarray + Precomputed array of reduced Wigner d-function values. These + can be computed with the s2fft.generate_rotate_dls function. + + Returns + ------- + alm_rot : jnp.ndarray + The alm array in the ``to_frame'' coordinate system. + + """ + rmat = get_rot_mat(from_frame, to_frame) + euler = rotmat_to_euler(rmat) + lmax = lmax_from_shape(alm.shape) + alm_rot = rotate_flms(alm, lmax + 1, euler, dl_array=dl_array) + return alm_rot + + +@jax.jit +def gal2eq(alm, dl_array=None): + """ + Transform a spherical harmonic decomposition from Galactic to Equatorial + coordinates. + + Parameters + ---------- + alm : jnp.ndarray + The alm array to transform. + dl_array : jnp.ndarray + Precomputed array of reduced Wigner d-function values. These + can be computed with the s2fft.generate_rotate_dls function. + + Returns + ------- + alm_rot : jnp.ndarray + The alm array in Equatorial coordinates. + + """ + return rotate_alm(alm, "galactic", "fk5", dl_array=dl_array) + + +@jax.jit +def gal2mcmf(alm, dl_array=None): + """ + Transform a spherical harmonic decomposition from Galactic to MCMF + coordinates (moon equivalent of equatorial coordinates). + + Parameters + ---------- + alm : jnp.ndarray + The alm array to transform. + dl_array : jnp.ndarray + Precomputed array of reduced Wigner d-function values. These + can be computed with the s2fft.generate_rotate_dls function. + + Returns + ------- + alm_rot : jnp.ndarray + The alm array in MCMF coordinates. + + """ + return rotate_alm(alm, "galactic", "mcmf", dl_array=dl_array) + + +@jax.jit +def topo2eq(alm, loc, time, dl_array=None): + """ + Transform a spherical harmonic decomposition from topocentric on Earth to + equatorial coordinates. + + Parameters + ---------- + alm : jnp.ndarray + The alm array to transform. + loc : astropy.coordinates.EarthLocation + The location of the observer. + time : astropy.time.Time + The time of the observation. + dl_array : jnp.ndarray + Precomputed array of reduced Wigner d-function values. These + can be computed with the s2fft.generate_rotate_dls function. + + Returns + ------- + alm_rot : jnp.ndarray + The alm array in Equatorial coordinates. + + """ + topo = AltAz(location=loc, obstime=time) + return rotate_alm(alm, topo, "fk5", loc, time, dl_array=dl_array) + + +@jax.jit +def topo2mcmf(alm, loc, time, dl_array=None): + """ + Transform a spherical harmonic decomposition from topocentric on Moon to + equatorial coordinates. + + Parameters + ---------- + alm : jnp.ndarray + The alm array to transform. + loc : lunarsky.MoonLocation + The location of the observer. + time : lunarsky.Time + The time of the observation. + dl_array : jnp.ndarray + Precomputed array of reduced Wigner d-function values. These + can be computed with the s2fft.generate_rotate_dls function. + + Returns + ------- + alm_rot : jnp.ndarray + The alm array in MCMF coordinates. + + """ + topo = LunarTopo(location=loc, obstime=time) + return rotate_alm(alm, topo, "mcmf", loc, time, dl_array=dl_array) From 1ca8d1170e6ec225e72ec6f548ac1005cbcf8b89 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 23 May 2024 18:22:51 -0700 Subject: [PATCH 096/129] change default sampling to mw so kwargs are consistent --- croissant/jax/alm.py | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/croissant/jax/alm.py b/croissant/jax/alm.py index 5e95f80..b50f8bd 100644 --- a/croissant/jax/alm.py +++ b/croissant/jax/alm.py @@ -6,7 +6,7 @@ @jax.jit def alm2map( - alm, spin=0, nside=None, sampling="healpix", precomps=None, spmd=True + alm, spin=0, nside=None, sampling="mw", precomps=None, spmd=True ): """ Construct a map on the sphere from the alm array. This is a wrapper @@ -57,7 +57,7 @@ def map2alm( lmax, spin=0, nside=None, - sampling="healpix", + sampling="mw", reality=True, precomps=None, spmd=True, @@ -211,15 +211,15 @@ def lmax_from_shape(shape): @jax.jit def is_real(alm): """ - Check if the coefficients of an array of alms correspond to a real-valued + Check if the an array of alms correspond to a real-valued signal. Mathematically, this is true if the coefficients satisfy alm(l, m) = (-1)^m * conj(alm(l, -m)). Parameters ---------- alm : jnp.ndarray - The spherical harmonics coefficients. The last two dimensions must - correspond to the ell and emm indices respectively. + The spherical harmonics coefficients. The last two dimensions + must correspond to the ell and emm indices respectively. Returns ------- @@ -237,7 +237,6 @@ def is_real(alm): pos_m = alm[..., lmax + 1 :] return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)).item() -@jax.jit def reduce_lmax(alm, new_lmax): """ Reduce the maximum l value of the alm. @@ -266,9 +265,9 @@ def reduce_lmax(alm, new_lmax): return alm[..., :-d, d:-d] @jax.jit -def zeros(lmax): +def shape_from_lmax(lmax): """ - Construct an alm array of zeros. + Get the shape of the alm array given the maximum l value. Parameters ---------- @@ -277,9 +276,7 @@ def zeros(lmax): Returns ------- - alm : jnp.ndarray - The alm array of zeros. Shape is (lmax+1, 2*lmax+1). + shape : tup + """ - shape = s2fft.sampling.s2_samples.flm_shape(lmax + 1) - alm = jnp.zeros(shape, dtype=jnp.complex128) - return alm + return (lmax + 1, 2 * lmax + 1) From 019f4061fbd32be1e0581e1f5f33935560e85c51 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 23 May 2024 18:26:28 -0700 Subject: [PATCH 097/129] utils changed to coordinates --- croissant/__init__.py | 2 +- croissant/core/healpix.py | 11 ++++++----- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/croissant/__init__.py b/croissant/__init__.py index fef5b81..ea21dad 100644 --- a/croissant/__init__.py +++ b/croissant/__init__.py @@ -2,9 +2,9 @@ __version__ = "4.0.0" from . import constants +from . import coordinates from . import core from . import jax from . import dpss -from . import utils from .core import * # noqa F403 diff --git a/croissant/core/healpix.py b/croissant/core/healpix.py index 5baed2b..e475ac3 100644 --- a/croissant/core/healpix.py +++ b/croissant/core/healpix.py @@ -3,7 +3,8 @@ from scipy.interpolate import RectSphereBivariateSpline import warnings -from .. import constants, utils +from .. import constants +from ..coordinates import coord_rep from .rotations import Rotator from .sphtransform import alm2map, map2alm @@ -168,7 +169,7 @@ def __init__( if coord is None: self.coord = None else: - self.coord = utils.coord_rep(coord) + self.coord = coord_rep(coord) data = np.array(data, copy=True, dtype=np.float64) if frequencies is not None: @@ -283,7 +284,7 @@ def switch_coords( string is given, it must be able to instantiate a Time object. """ - to_coord = utils.coord_rep(to_coord) + to_coord = coord_rep(to_coord) rot = Rotator(coord=[self.coord, to_coord], loc=loc, time=time) if rot_pixel: self.data = rot.rotate_map_pixel(self.data) @@ -342,7 +343,7 @@ def __init__(self, alm, lmax=None, frequencies=None, coord=None): if coord is None: self.coord = None else: - self.coord = utils.coord_rep(coord) + self.coord = coord_rep(coord) def __setitem__(self, key, value): """ @@ -447,7 +448,7 @@ def from_grid( return obj def switch_coords(self, to_coord, loc=None, time=None): - to_coord = utils.coord_rep(to_coord) + to_coord = coord_rep(to_coord) rot = Rotator(coord=[self.coord, to_coord], loc=loc, time=time) rot.rotate_alm(self.alm, lmax=self.lmax, inplace=True) self.coord = to_coord From 7535cb9e2257ceb4e21153082cbd2e1d64990d3a Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 23 May 2024 18:31:51 -0700 Subject: [PATCH 098/129] remove simulatorbase since jax version is not in class --- croissant/core/simulator.py | 208 +++++++++++++++++++++++++++++++++++- croissant/simulatorbase.py | 208 ------------------------------------ 2 files changed, 206 insertions(+), 210 deletions(-) delete mode 100644 croissant/simulatorbase.py diff --git a/croissant/core/simulator.py b/croissant/core/simulator.py index 8f0fdea..1558fff 100644 --- a/croissant/core/simulator.py +++ b/croissant/core/simulator.py @@ -1,8 +1,170 @@ +from astropy import units +from astropy.coordinates import EarthLocation +from copy import deepcopy +from lunarsky import MoonLocation, Time +import matplotlib.pyplot as plt import numpy as np -from ..simulatorbase import SimulatorBase +import warnings +from .. import dpss + + +def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): + """ + Generate an array of evenly sampled times to run the simulation at. + + Parameters + ---------- + t_start : str or astropy.time.Time + The start time of the simulation. + t_end : str or astropy.time.Time + The end time of the simulation. + N_times : int + The number of times to run the simulation at. + delta_t : float or astropy.units.Quantity + The time step between each time in the simulation. + + Returns + ------- + times : astropy.time.Time or astropy.units.Quantity + The evenly sampled times to run the simulation at. + + """ + + if t_start is not None: + t_start = Time(t_start, scale="utc") + + try: + dt = np.arange(N_times) * delta_t + except TypeError: + t_end = Time(t_end, scale="utc") + total_time = (t_end - t_start).sec + if N_times is None: + try: + delta_t = delta_t.to_value("s") + except AttributeError: + warnings.warn( + "delta_t is not an astropy.units.Quantity. Assuming " + "units of seconds.", + UserWarning, + ) + dt = np.arange(0, total_time + delta_t, delta_t) + else: + dt = np.linspace(0, total_time, N_times) + dt = dt * units.s + + if t_start is None: + times = dt + else: + times = t_start + dt + + return times + + +class Simulator: + def __init__( + self, + beam, + sky, + lmax=None, + frequencies=None, + world="moon", + location=None, + times=None, + ): + """ + BaseSimulator class. Prepares simulations. End users should use the + subclasses in core/simulator.py and crojax/simulator.py to + instantiate this class and run simulations. + """ + self.world = world.lower() + # set up frequencies to run the simulation at + if frequencies is None: + frequencies = sky.frequencies + self.frequencies = frequencies + if self.world == "moon": + Location = MoonLocation + self.sim_coord = "M" # mcmf + elif self.world == "earth": + Location = EarthLocation + self.sim_coord = "C" # equatorial + else: + raise KeyError('Keyword ``world\'\' must be "earth" or "moon".') + + try: + self.location = Location(*location) + except TypeError: # location is None or already Location + self.location = location + if isinstance(location, EarthLocation) and self.world == "moon": + raise TypeError( + "location is an EarthLocation but world is 'moon'." + ) + if isinstance(location, MoonLocation) and self.world == "earth": + raise TypeError( + "location is a MoonLocation but world is 'earth'." + ) + + if lmax is None: + lmax = np.min([beam.lmax, sky.lmax]) + else: + lmax = np.min([lmax, beam.lmax, sky.lmax]) + self.lmax = lmax + + if times is None: + self.times = np.array([0]) + t_start = None + elif isinstance(times, Time): + self.times = times + t_start = times[0] + else: + self.times = times + t_start = None + + dt = self.times - self.times[0] + try: + self.dt = dt.sec + except AttributeError: + self.dt = dt + self.N_times = self.dt.size + + # initialize beam and sky + self.beam = deepcopy(beam) + if not hasattr(self.beam, "total_power"): + self.beam.compute_total_power() + if self.beam.coord != self.sim_coord: + self.beam.switch_coords( + self.sim_coord, loc=self.location, time=t_start + ) + if self.beam.lmax > self.lmax: + self.beam.reduce_lmax(self.lmax) + self.sky = deepcopy(sky) + if self.sky.coord != self.sim_coord: + self.sky.switch_coords( + self.sim_coord, loc=self.location, time=t_start + ) + if self.sky.lmax > self.lmax: + self.sky.reduce_lmax(self.lmax) + + def compute_dpss(self, **kwargs): + # generate the set of target frequencies (subset of all freqs) + x = np.unique( + np.concatenate( + ( + self.beam.frequencies, + self.frequencies, + ), + axis=None, + ) + ) + + self.design_matrix = dpss.dpss_op(x, **kwargs) + self.beam.coeffs = dpss.freq2dpss( + self.beam.alm, + self.beam.frequencies, + self.frequencies, + self.design_matrix, + ) -class Simulator(SimulatorBase): def run(self, dpss=True, **dpss_kwargs): """ Compute the convolution for a range of times. @@ -52,3 +214,45 @@ def run(self, dpss=True, **dpss_kwargs): ) self.waterfall = np.squeeze(waterfall) / self.beam.total_power + + def plot( + self, + figsize=None, + extent=None, + interpolation="none", + aspect="auto", + power=0, + ): + """ + Plot the result of the simulation. + """ + if self.times[0] == 0: + time_label = "Time [hours]" + else: + t_start = self.times[0].to_value("iso", subfmt="date_hm") + time_label = f"Hours since {t_start}" + temp_label = "Temperature [K]" + plt.figure(figsize=figsize) + if self.waterfall.ndim == 1: # no frequency axis + plt.plot(self.dt / 3600, self.waterfall) + plt.xlabel(time_label) + plt.ylabel(temp_label) + else: + if extent is None: + extent = [ + self.frequencies.min(), + self.frequencies.max(), + self.dt[-1] / 3600, + 0, + ] + weight = self.frequencies**power + plt.imshow( + self.waterfall * weight.reshape(1, -1), + extent=extent, + aspect=aspect, + interpolation=interpolation, + ) + plt.colorbar(label=temp_label) + plt.xlabel("Frequency [MHz]") + plt.ylabel(time_label) + plt.show() diff --git a/croissant/simulatorbase.py b/croissant/simulatorbase.py deleted file mode 100644 index 48dd88a..0000000 --- a/croissant/simulatorbase.py +++ /dev/null @@ -1,208 +0,0 @@ -from astropy import units -from astropy.coordinates import EarthLocation -from copy import deepcopy -from lunarsky import MoonLocation, Time -import matplotlib.pyplot as plt -import numpy as np -import warnings - -from . import dpss - - -def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): - """ - Generate an array of evenly sampled times to run the simulation at. - - Parameters - ---------- - t_start : str or astropy.time.Time - The start time of the simulation. - t_end : str or astropy.time.Time - The end time of the simulation. - N_times : int - The number of times to run the simulation at. - delta_t : float or astropy.units.Quantity - The time step between each time in the simulation. - - Returns - ------- - times : astropy.time.Time or astropy.units.Quantity - The evenly sampled times to run the simulation at. - - """ - - if t_start is not None: - t_start = Time(t_start, scale="utc") - - try: - dt = np.arange(N_times) * delta_t - except TypeError: - t_end = Time(t_end, scale="utc") - total_time = (t_end - t_start).sec - if N_times is None: - try: - delta_t = delta_t.to_value("s") - except AttributeError: - warnings.warn( - "delta_t is not an astropy.units.Quantity. Assuming " - "units of seconds.", - UserWarning, - ) - dt = np.arange(0, total_time + delta_t, delta_t) - else: - dt = np.linspace(0, total_time, N_times) - dt = dt * units.s - - if t_start is None: - times = dt - else: - times = t_start + dt - - return times - - -class SimulatorBase: - def __init__( - self, - beam, - sky, - lmax=None, - frequencies=None, - world="moon", - location=None, - times=None, - ): - """ - BaseSimulator class. Prepares simulations. End users should use the - subclasses in core/simulator.py and crojax/simulator.py to - instantiate this class and run simulations. - """ - self.world = world.lower() - # set up frequencies to run the simulation at - if frequencies is None: - frequencies = sky.frequencies - self.frequencies = frequencies - if self.world == "moon": - Location = MoonLocation - self.sim_coord = "M" # mcmf - elif self.world == "earth": - Location = EarthLocation - self.sim_coord = "C" # equatorial - else: - raise KeyError('Keyword ``world\'\' must be "earth" or "moon".') - - try: - self.location = Location(*location) - except TypeError: # location is None or already Location - self.location = location - if isinstance(location, EarthLocation) and self.world == "moon": - raise TypeError( - "location is an EarthLocation but world is 'moon'." - ) - if isinstance(location, MoonLocation) and self.world == "earth": - raise TypeError( - "location is a MoonLocation but world is 'earth'." - ) - - if lmax is None: - lmax = np.min([beam.lmax, sky.lmax]) - else: - lmax = np.min([lmax, beam.lmax, sky.lmax]) - self.lmax = lmax - - if times is None: - self.times = np.array([0]) - t_start = None - elif isinstance(times, Time): - self.times = times - t_start = times[0] - else: - self.times = times - t_start = None - - dt = self.times - self.times[0] - try: - self.dt = dt.sec - except AttributeError: - self.dt = dt - self.N_times = self.dt.size - - # initialize beam and sky - self.beam = deepcopy(beam) - if not hasattr(self.beam, "total_power"): - self.beam.compute_total_power() - if self.beam.coord != self.sim_coord: - self.beam.switch_coords( - self.sim_coord, loc=self.location, time=t_start - ) - if self.beam.lmax > self.lmax: - self.beam.reduce_lmax(self.lmax) - self.sky = deepcopy(sky) - if self.sky.coord != self.sim_coord: - self.sky.switch_coords( - self.sim_coord, loc=self.location, time=t_start - ) - if self.sky.lmax > self.lmax: - self.sky.reduce_lmax(self.lmax) - - def compute_dpss(self, **kwargs): - # generate the set of target frequencies (subset of all freqs) - x = np.unique( - np.concatenate( - ( - self.beam.frequencies, - self.frequencies, - ), - axis=None, - ) - ) - - self.design_matrix = dpss.dpss_op(x, **kwargs) - self.beam.coeffs = dpss.freq2dpss( - self.beam.alm, - self.beam.frequencies, - self.frequencies, - self.design_matrix, - ) - - def plot( - self, - figsize=None, - extent=None, - interpolation="none", - aspect="auto", - power=0, - ): - """ - Plot the result of the simulation. - """ - if self.times[0] == 0: - time_label = "Time [hours]" - else: - t_start = self.times[0].to_value("iso", subfmt="date_hm") - time_label = f"Hours since {t_start}" - temp_label = "Temperature [K]" - plt.figure(figsize=figsize) - if self.waterfall.ndim == 1: # no frequency axis - plt.plot(self.dt / 3600, self.waterfall) - plt.xlabel(time_label) - plt.ylabel(temp_label) - else: - if extent is None: - extent = [ - self.frequencies.min(), - self.frequencies.max(), - self.dt[-1] / 3600, - 0, - ] - weight = self.frequencies**power - plt.imshow( - self.waterfall * weight.reshape(1, -1), - extent=extent, - aspect=aspect, - interpolation=interpolation, - ) - plt.colorbar(label=temp_label) - plt.xlabel("Frequency [MHz]") - plt.ylabel(time_label) - plt.show() From 2a7369b499a30c8179ed0bf0015eebe9ccbd03dd Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 23 May 2024 18:38:51 -0700 Subject: [PATCH 099/129] rename and move test modules to reflects change in filestructure --- croissant/core/tests/test_simulator.py | 116 ++++++++++++++++- .../{test_utils.py => test_coordinates.py} | 0 croissant/tests/test_simulator.py | 117 ------------------ 3 files changed, 111 insertions(+), 122 deletions(-) rename croissant/tests/{test_utils.py => test_coordinates.py} (100%) delete mode 100644 croissant/tests/test_simulator.py diff --git a/croissant/core/tests/test_simulator.py b/croissant/core/tests/test_simulator.py index 014c7ed..5d90971 100644 --- a/croissant/core/tests/test_simulator.py +++ b/croissant/core/tests/test_simulator.py @@ -1,15 +1,121 @@ -import numpy as np from astropy import units +from astropy.coordinates import EarthLocation +from copy import deepcopy import healpy as hp -from croissant import Beam, Simulator, Sky -from croissant.simulatorbase import time_array +from lunarsky import MoonLocation, Time +import numpy as np +import pytest + +from croissant import Beam, dpss, Rotator, Simulator, Sky +from croissant.constants import sidereal_day_earth +from croissant.simulator import time_array -loc = (137.0, 40.0) + +# define default params for simulator +lmax = 32 +frequencies = np.linspace(10, 50, 10) +theta = np.linspace(0, np.pi, 181) +phi = np.linspace(0, 2 * np.pi, 360, endpoint=False) +power = frequencies[:, None, None] ** 2 * np.cos(theta[None, :, None]) ** 2 +power = np.repeat(power, phi.size, axis=2) +beam = Beam.from_grid( + power, theta, phi, lmax, frequencies=frequencies, coord="T" +) +sky = Sky.gsm(frequencies, lmax=lmax) +loc = (137.0, 40.0) # (lon, lat) in degrees t_start = "2022-06-10 12:59:00" N_times = 150 delta_t = 3600 * units.s times = time_array(t_start=t_start, N_times=N_times, delta_t=delta_t) -kwargs = {"world": "moon", "location": loc, "times": times} +args = (beam, sky) +kwargs = {"lmax": lmax, "world": "moon", "location": loc, "times": times} + + +def test_time_array(): + # check that the times are set consistently regardless of + # which parameters that specify it + delta_t, step = np.linspace(0, sidereal_day_earth, N_times, retstep=True) + delta_t = delta_t * units.s + step = step * units.s + t_end = Time(t_start) + delta_t[-1] + # specify end, ntimes: + times = time_array(t_start, t_end=t_end, N_times=N_times) + assert np.allclose(delta_t.value, (times - times[0]).sec) + # specify end, delta t + times = time_array(t_start, t_end=t_end, delta_t=step) + assert np.allclose(delta_t.value, (times - times[0]).sec) + # specify ntimes, delta t + times = time_array(t_start, N_times=N_times, delta_t=step) + assert np.allclose(delta_t.value, (times - times[0]).sec) + times = time_array(N_times=N_times, delta_t=step) + assert np.allclose(times, np.arange(N_times) * step) + # check that we get a UserWarning if delta t does not have units + delta_t = 2 + with pytest.warns(UserWarning): + time_array(t_start, t_end=t_end, delta_t=delta_t) + + +def test_simulator_init(): + sim = Simulator(*args, **kwargs) + # check that the simulation attributes are set properly + assert sim.sim_coord == "M" # mcmf + assert sim.location == MoonLocation(*loc) + # check sky is in the desired simulation coords + assert sim.sky.coord == sim.sim_coord + rot = Rotator(coord="gm") + sky_alm = rot.rotate_alm(sky.alm, lmax=sky.lmax) + assert np.allclose(sim.sky.alm, sky_alm) + + # test lmax + beam_lmax = 10 # smaller than sky lmax + beam2 = deepcopy(beam) + beam2.reduce_lmax(beam_lmax) + sim = Simulator(beam2, sky, **kwargs) + assert sim.lmax == np.min([sky.lmax, beam2.lmax]) == beam_lmax + assert sim.beam.lmax == sim.sky.lmax == sim.lmax + kwargs["lmax"] = None + sim = Simulator(beam2, sky, **kwargs) + assert sim.lmax == np.min([sky.lmax, beam2.lmax]) == beam_lmax + assert sim.beam.lmax == sim.sky.lmax == sim.lmax + kwargs["lmax"] = lmax + + # use a Location object instead of a tuple + earth_loc = EarthLocation(*loc) + kwargs["location"] = earth_loc + with pytest.raises(TypeError): + Simulator(*args, **kwargs) # loc is EarthLocation, world is moon + moon_loc = MoonLocation(*loc) + kwargs["location"] = moon_loc + sim = Simulator(*args, **kwargs) + assert sim.location == moon_loc + + # check that init works correctly on earth + kwargs["world"] = "earth" + with pytest.raises(TypeError): + Simulator(*args, **kwargs) # loc is MoonLocation, world is earth + kwargs["location"] = earth_loc + sim = Simulator(*args, **kwargs) + assert sim.sim_coord == "C" + assert sim.location == earth_loc + kwargs["location"] = loc + + # check that we get a KeyError if world is not "earth" or "moon" + kwargs["world"] = "mars" + with pytest.raises(KeyError): + Simulator(*args, **kwargs) + + kwargs["world"] = "moon" + + +def test_compute_dpss(): + sim = Simulator(*args, **kwargs) + sim.compute_dpss(nterms=10) + design_matrix = dpss.dpss_op(frequencies, nterms=10) + assert np.allclose(design_matrix, sim.design_matrix) + beam_coeff = dpss.freq2dpss( + sim.beam.alm, frequencies, frequencies, design_matrix + ) + assert np.allclose(beam_coeff, sim.beam.coeffs) def test_run(): diff --git a/croissant/tests/test_utils.py b/croissant/tests/test_coordinates.py similarity index 100% rename from croissant/tests/test_utils.py rename to croissant/tests/test_coordinates.py diff --git a/croissant/tests/test_simulator.py b/croissant/tests/test_simulator.py deleted file mode 100644 index 2d898ca..0000000 --- a/croissant/tests/test_simulator.py +++ /dev/null @@ -1,117 +0,0 @@ -from astropy import units -from astropy.coordinates import EarthLocation -from copy import deepcopy -from lunarsky import MoonLocation, Time -import numpy as np -import pytest - -from croissant import Beam, dpss, Rotator, Sky -from croissant.constants import sidereal_day_earth -from croissant.simulatorbase import SimulatorBase, time_array - - -# define default params for simulator -lmax = 32 -frequencies = np.linspace(10, 50, 10) -theta = np.linspace(0, np.pi, 181) -phi = np.linspace(0, 2 * np.pi, 360, endpoint=False) -power = frequencies[:, None, None] ** 2 * np.cos(theta[None, :, None]) ** 2 -power = np.repeat(power, phi.size, axis=2) -beam = Beam.from_grid( - power, theta, phi, lmax, frequencies=frequencies, coord="T" -) -sky = Sky.gsm(frequencies, lmax=lmax) -loc = (137.0, 40.0) # (lon, lat) in degrees -t_start = "2022-06-10 12:59:00" -N_times = 150 -delta_t = 3600 * units.s -times = time_array(t_start=t_start, N_times=N_times, delta_t=delta_t) -args = (beam, sky) -kwargs = {"lmax": lmax, "world": "moon", "location": loc, "times": times} - - -def test_time_array(): - # check that the times are set consistently regardless of - # which parameters that specify it - delta_t, step = np.linspace(0, sidereal_day_earth, N_times, retstep=True) - delta_t = delta_t * units.s - step = step * units.s - t_end = Time(t_start) + delta_t[-1] - # specify end, ntimes: - times = time_array(t_start, t_end=t_end, N_times=N_times) - assert np.allclose(delta_t.value, (times - times[0]).sec) - # specify end, delta t - times = time_array(t_start, t_end=t_end, delta_t=step) - assert np.allclose(delta_t.value, (times - times[0]).sec) - # specify ntimes, delta t - times = time_array(t_start, N_times=N_times, delta_t=step) - assert np.allclose(delta_t.value, (times - times[0]).sec) - times = time_array(N_times=N_times, delta_t=step) - assert np.allclose(times, np.arange(N_times) * step) - # check that we get a UserWarning if delta t does not have units - delta_t = 2 - with pytest.warns(UserWarning): - time_array(t_start, t_end=t_end, delta_t=delta_t) - - -def test_simulator_init(): - sim = SimulatorBase(*args, **kwargs) - # check that the simulation attributes are set properly - assert sim.sim_coord == "M" # mcmf - assert sim.location == MoonLocation(*loc) - # check sky is in the desired simulation coords - assert sim.sky.coord == sim.sim_coord - rot = Rotator(coord="gm") - sky_alm = rot.rotate_alm(sky.alm, lmax=sky.lmax) - assert np.allclose(sim.sky.alm, sky_alm) - - # test lmax - beam_lmax = 10 # smaller than sky lmax - beam2 = deepcopy(beam) - beam2.reduce_lmax(beam_lmax) - sim = SimulatorBase(beam2, sky, **kwargs) - assert sim.lmax == np.min([sky.lmax, beam2.lmax]) == beam_lmax - assert sim.beam.lmax == sim.sky.lmax == sim.lmax - kwargs["lmax"] = None - sim = SimulatorBase(beam2, sky, **kwargs) - assert sim.lmax == np.min([sky.lmax, beam2.lmax]) == beam_lmax - assert sim.beam.lmax == sim.sky.lmax == sim.lmax - kwargs["lmax"] = lmax - - # use a Location object instead of a tuple - earth_loc = EarthLocation(*loc) - kwargs["location"] = earth_loc - with pytest.raises(TypeError): - SimulatorBase(*args, **kwargs) # loc is EarthLocation, world is moon - moon_loc = MoonLocation(*loc) - kwargs["location"] = moon_loc - sim = SimulatorBase(*args, **kwargs) - assert sim.location == moon_loc - - # check that init works correctly on earth - kwargs["world"] = "earth" - with pytest.raises(TypeError): - SimulatorBase(*args, **kwargs) # loc is MoonLocation, world is earth - kwargs["location"] = earth_loc - sim = SimulatorBase(*args, **kwargs) - assert sim.sim_coord == "C" - assert sim.location == earth_loc - kwargs["location"] = loc - - # check that we get a KeyError if world is not "earth" or "moon" - kwargs["world"] = "mars" - with pytest.raises(KeyError): - SimulatorBase(*args, **kwargs) - - kwargs["world"] = "moon" - - -def test_compute_dpss(): - sim = SimulatorBase(*args, **kwargs) - sim.compute_dpss(nterms=10) - design_matrix = dpss.dpss_op(frequencies, nterms=10) - assert np.allclose(design_matrix, sim.design_matrix) - beam_coeff = dpss.freq2dpss( - sim.beam.alm, frequencies, frequencies, design_matrix - ) - assert np.allclose(beam_coeff, sim.beam.coeffs) From 299ee0b6da8bc312c314096644e6d66a2fdba475 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 23 May 2024 18:46:46 -0700 Subject: [PATCH 100/129] move tests since functions moved --- croissant/core/tests/test_rotations.py | 69 +----------------------- croissant/tests/test_coordinates.py | 73 +++++++++++++++++++++++++- 2 files changed, 73 insertions(+), 69 deletions(-) diff --git a/croissant/core/tests/test_rotations.py b/croissant/core/tests/test_rotations.py index f721bea..43976ab 100644 --- a/croissant/core/tests/test_rotations.py +++ b/croissant/core/tests/test_rotations.py @@ -1,6 +1,6 @@ -from astropy.coordinates import AltAz, EarthLocation +from astropy.coordinates import EarthLocation import healpy as hp -from lunarsky import LunarTopo, MCMF, MoonLocation, SkyCoord, Time +from lunarsky import MoonLocation, Time import numpy as np import pytest @@ -35,71 +35,6 @@ def test_rotator_init(): rotations.Rotator(coord=["T", "M"], loc=loc) -def test_get_rot_mat(): - # check that we agree with healpy for galactic -> equatorial - rot_mat = rotations.get_rot_mat("galactic", "fk5") - rot = hp.Rotator(coord=["G", "C"]) - assert np.allclose(rot_mat, rot.mat) - - # equatorial -> galactic - rot_mat = rotations.get_rot_mat("fk5", "galactic") - rot = hp.Rotator(coord=["C", "G"]) - assert np.allclose(rot_mat, rot.mat) - - # check that we agree with astropy for equatorial -> AltAz - time = Time("2022-06-16 17:00:00") - loc = EarthLocation(lon=0, lat=40) - to_frame = AltAz(obstime=time, location=loc) - rot_mat = rotations.get_rot_mat("fk5", to_frame) - x, y, z = np.eye(3) - xp, yp, zp = ( - SkyCoord(x=x, y=y, z=z, frame="fk5", representation_type="cartesian") - .transform_to(to_frame) - .cartesian.xyz.value - ) - assert np.allclose(rot_mat, np.array([xp, yp, zp])) - - # MCMF -> AltAz - loc = MoonLocation(lon=0, lat=40) - to_frame = LunarTopo(obstime=time, location=loc) - rot_mat = rotations.get_rot_mat("mcmf", to_frame) - xp, yp, zp = ( - SkyCoord(x=x, y=y, z=z, frame="mcmf", representation_type="cartesian") - .transform_to(to_frame) - .cartesian.xyz.value - ) - assert np.allclose(rot_mat, np.array([xp, yp, zp])) - - # galactic -> MCMF - # in this case we have to invert the matrix that does MCMF -> galactic - # since we cannot instantiate a galactic frame from cartesian coords - rot_mat = rotations.get_rot_mat("galactic", MCMF()) - xp, yp, zp = ( - SkyCoord(x=x, y=y, z=z, frame="mcmf", representation_type="cartesian") - .transform_to("galactic") - .cartesian.xyz.value - ) - assert np.allclose(rot_mat, np.array([xp, yp, zp]).T) - - -def test_rotmat_to_euler(): - # check that rotmat_to_euler is the inverse of euler_matrix_new - rot_mat = rotations.get_rot_mat("galactic", "fk5") - eul = rotations.rotmat_to_euler(rot_mat) - rmat = hp.rotator.get_rotation_matrix(eul)[0] - assert np.allclose(rot_mat, rmat) - - rot_mat = rotations.get_rot_mat("galactic", "mcmf") - eul = rotations.rotmat_to_euler(rot_mat) - rmat = hp.rotator.get_rotation_matrix(eul)[0] - assert np.allclose(rot_mat, rmat) - - rot_mat = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]]) - eul = rotations.rotmat_to_euler(rot_mat) - rmat = hp.rotator.get_rotation_matrix(eul)[0] - assert np.allclose(rot_mat, rmat) - - def test_rotate_alm(): lmax = 10 size = hp.Alm.getsize(lmax) diff --git a/croissant/tests/test_coordinates.py b/croissant/tests/test_coordinates.py index e450a5c..e035d11 100644 --- a/croissant/tests/test_coordinates.py +++ b/croissant/tests/test_coordinates.py @@ -1,8 +1,77 @@ -from croissant.utils import coord_rep +from astropy.coordinates import AltAz, EarthLocation +import healpy as hp +from lunarsky import LunarTopo, MCMF, MoonLocation, SkyCoord, Time +import numpy as np +from croissant import coordinates def test_coord_rep(): coords = ["galactic", "equatorial", "ecliptic", "mcmf", "topocentric"] short = ["G", "C", "E", "M", "T"] for i in range(len(coords)): - assert coord_rep(coords[i]) == short[i] + assert coordinates.coord_rep(coords[i]) == short[i] + + +def test_get_rot_mat(): + # check that we agree with healpy for galactic -> equatorial + rot_mat = coordinates.get_rot_mat("galactic", "fk5") + rot = hp.Rotator(coord=["G", "C"]) + assert np.allclose(rot_mat, rot.mat) + + # equatorial -> galactic + rot_mat = coordinates.get_rot_mat("fk5", "galactic") + rot = hp.Rotator(coord=["C", "G"]) + assert np.allclose(rot_mat, rot.mat) + + # check that we agree with astropy for equatorial -> AltAz + time = Time("2022-06-16 17:00:00") + loc = EarthLocation(lon=0, lat=40) + to_frame = AltAz(obstime=time, location=loc) + rot_mat = coordinates.get_rot_mat("fk5", to_frame) + x, y, z = np.eye(3) + xp, yp, zp = ( + SkyCoord(x=x, y=y, z=z, frame="fk5", representation_type="cartesian") + .transform_to(to_frame) + .cartesian.xyz.value + ) + assert np.allclose(rot_mat, np.array([xp, yp, zp])) + + # MCMF -> AltAz + loc = MoonLocation(lon=0, lat=40) + to_frame = LunarTopo(obstime=time, location=loc) + rot_mat = coordinates.get_rot_mat("mcmf", to_frame) + xp, yp, zp = ( + SkyCoord(x=x, y=y, z=z, frame="mcmf", representation_type="cartesian") + .transform_to(to_frame) + .cartesian.xyz.value + ) + assert np.allclose(rot_mat, np.array([xp, yp, zp])) + + # galactic -> MCMF + # in this case we have to invert the matrix that does MCMF -> galactic + # since we cannot instantiate a galactic frame from cartesian coords + rot_mat = coordinates.get_rot_mat("galactic", MCMF()) + xp, yp, zp = ( + SkyCoord(x=x, y=y, z=z, frame="mcmf", representation_type="cartesian") + .transform_to("galactic") + .cartesian.xyz.value + ) + assert np.allclose(rot_mat, np.array([xp, yp, zp]).T) + + +def test_rotmat_to_euler(): + # check that rotmat_to_euler is the inverse of euler_matrix_new + rot_mat = coordinates.get_rot_mat("galactic", "fk5") + eul = coordinates.rotmat_to_euler(rot_mat) + rmat = hp.rotator.get_rotation_matrix(eul)[0] + assert np.allclose(rot_mat, rmat) + + rot_mat = coordinates.get_rot_mat("galactic", "mcmf") + eul = coordinates.rotmat_to_euler(rot_mat) + rmat = hp.rotator.get_rotation_matrix(eul)[0] + assert np.allclose(rot_mat, rmat) + + rot_mat = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]]) + eul = coordinates.rotmat_to_euler(rot_mat) + rmat = hp.rotator.get_rotation_matrix(eul)[0] + assert np.allclose(rot_mat, rmat) From 4972f66eebc42ba04ba4281011bc1f3dbe8f6ab1 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 24 May 2024 09:45:38 -0700 Subject: [PATCH 101/129] fix some imports as modules changed names and functions moved --- croissant/core/__init__.py | 2 +- croissant/core/tests/test_healpix.py | 2 +- .../tests/{test_healpix.py => test_alm.py} | 16 ++++ croissant/jax/tests/test_beam.py | 67 -------------- croissant/jax/tests/test_simulator.py | 91 ------------------- 5 files changed, 18 insertions(+), 160 deletions(-) rename croissant/jax/tests/{test_healpix.py => test_alm.py} (92%) delete mode 100644 croissant/jax/tests/test_beam.py delete mode 100644 croissant/jax/tests/test_simulator.py diff --git a/croissant/core/__init__.py b/croissant/core/__init__.py index c89a908..b30f85b 100644 --- a/croissant/core/__init__.py +++ b/croissant/core/__init__.py @@ -1,4 +1,4 @@ -from . import sphtransform +from . import simulator, sphtransform from .healpix import Alm, HealpixMap from .beam import Beam from .rotations import Rotator diff --git a/croissant/core/tests/test_healpix.py b/croissant/core/tests/test_healpix.py index a177231..b03783b 100644 --- a/croissant/core/tests/test_healpix.py +++ b/croissant/core/tests/test_healpix.py @@ -4,7 +4,7 @@ import pytest from croissant import healpix as hp, sphtransform as spht from croissant.constants import sidereal_day_earth, sidereal_day_moon, Y00 -from croissant.utils import coord_rep +from croissant.coordinates import coord_rep def test_healpix2lonlat(): diff --git a/croissant/jax/tests/test_healpix.py b/croissant/jax/tests/test_alm.py similarity index 92% rename from croissant/jax/tests/test_healpix.py rename to croissant/jax/tests/test_alm.py index 3434e98..86b2f42 100644 --- a/croissant/jax/tests/test_healpix.py +++ b/croissant/jax/tests/test_alm.py @@ -12,6 +12,22 @@ nfreqs = freqs.size +def test_compute_total_power(lmax): + # make a beam that is 1 everywhere so total power is 4pi: + beam = Beam.zeros(lmax) + beam[0, 0, 0] = 1 / Y00 + beam.compute_total_power() + assert jnp.allclose(beam.total_power, 4 * jnp.pi) + + # beam(theta) = cos(theta)**2 * freq**2 + beam = Beam.zeros(lmax, frequencies=frequencies) + beam[:, 0, 0] = 1 / (3 * Y00) * frequencies**2 + beam[:, 2, 0] = 4 * jnp.sqrt(jnp.pi / 5) * 1 / 3 * frequencies**2 + beam.compute_total_power() + power = beam.total_power + expected_power = 4 * jnp.pi / 3 * frequencies**2 + assert jnp.allclose(power, expected_power.ravel()) + def test_lmax_from_shape(lmax): s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) shape = (1, s1, s2) # add frequency axis diff --git a/croissant/jax/tests/test_beam.py b/croissant/jax/tests/test_beam.py deleted file mode 100644 index 2edf3ed..0000000 --- a/croissant/jax/tests/test_beam.py +++ /dev/null @@ -1,67 +0,0 @@ -from copy import deepcopy -import pytest -import jax.numpy as jnp -from s2fft.sampling import s2_samples -from croissant.constants import Y00 -from croissant.jax import Beam - -pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) -frequencies = jnp.linspace(1, 50, 50) - - -def test_compute_total_power(lmax): - # make a beam that is 1 everywhere so total power is 4pi: - beam = Beam.zeros(lmax) - beam[0, 0, 0] = 1 / Y00 - beam.compute_total_power() - assert jnp.allclose(beam.total_power, 4 * jnp.pi) - - # beam(theta) = cos(theta)**2 * freq**2 - beam = Beam.zeros(lmax, frequencies=frequencies) - beam[:, 0, 0] = 1 / (3 * Y00) * frequencies**2 - beam[:, 2, 0] = 4 * jnp.sqrt(jnp.pi / 5) * 1 / 3 * frequencies**2 - beam.compute_total_power() - power = beam.total_power - expected_power = 4 * jnp.pi / 3 * frequencies**2 - assert jnp.allclose(power, expected_power.ravel()) - - -def test_horizon_cut(lmax): - # make a beam that is 1 everywhere - beam_base = Beam.zeros(lmax) - beam_base[0, 0, 0] = 1 / Y00 - - # default horizon (1 frequency) - beam = deepcopy(beam_base) - beam.horizon_cut() # doesn't throw error - - # default horizon (multiple frequencies) - beam_nf = Beam.zeros(lmax, frequencies=frequencies) - beam_nf[:, 0, 0] = 1 / Y00 - beam_nf.horizon_cut() # doesn't throw error - assert jnp.allclose(beam_nf.alm, beam.alm) - - # try custom horizon - beam = deepcopy(beam_base) - ntheta, nphi = s2_samples.f_shape(lmax + 1, sampling="mw") - horizon = jnp.ones((1, ntheta, nphi)) # no horizon - beam_map = beam.alm2map(sampling="mw") # before horizon cut - beam.horizon_cut(horizon=horizon, sampling="mw") - # should be the same before and after since the horizon is all 1s - assert jnp.allclose(beam_map, beam.alm2map(sampling="mw")) - - beam = deepcopy(beam_base) - horizon = jnp.zeros((1, ntheta, nphi)) # full horizon - beam.horizon_cut(horizon=horizon, sampling="mw") - # should be all zeros since the horizon is all 0s - assert jnp.allclose(beam.alm2map(sampling="mw"), 0) - - # try horizon with invalid values - horizon = jnp.ones((1, ntheta, nphi)) - horizon = horizon.at[0, 0, 0].set(2.0) # invalid value - with pytest.raises(ValueError): - beam.horizon_cut(horizon=horizon, sampling="mw") - horizon = jnp.ones((1, ntheta, nphi)) - horizon = horizon.at[0, 0, 0].set(-1.0) # invalid value - with pytest.raises(ValueError): - beam.horizon_cut(horizon=horizon, sampling="mw") diff --git a/croissant/jax/tests/test_simulator.py b/croissant/jax/tests/test_simulator.py deleted file mode 100644 index 014c7ed..0000000 --- a/croissant/jax/tests/test_simulator.py +++ /dev/null @@ -1,91 +0,0 @@ -import numpy as np -from astropy import units -import healpy as hp -from croissant import Beam, Simulator, Sky -from croissant.simulatorbase import time_array - -loc = (137.0, 40.0) -t_start = "2022-06-10 12:59:00" -N_times = 150 -delta_t = 3600 * units.s -times = time_array(t_start=t_start, N_times=N_times, delta_t=delta_t) -kwargs = {"world": "moon", "location": loc, "times": times} - - -def test_run(): - # retrieve constant temperature sky - freq = np.linspace(1, 50, 50) # MHz - lmax = 16 - kwargs["lmax"] = lmax - sky_alm = np.zeros((freq.size, hp.Alm.getsize(lmax)), dtype=np.complex128) - sky_alm[:, 0] = 10 * freq ** (-2.5) - # sky is constant in space, varies like power law spectrally - sky = Sky(sky_alm, lmax=lmax, frequencies=freq, coord="G") - beam_alm = np.zeros_like(sky_alm) - beam_alm[:, 0] = 1.0 * freq**2 - # make a constant beam with spectral power law - beam = Beam(beam_alm, lmax=lmax, frequencies=freq, coord="T") - # beam is no longer constant after horizon cut - beam.horizon_cut() - sim = Simulator(beam, sky, **kwargs) - sim.run(dpss=False) - beam_a00 = sim.beam[0, 0, 0] # a00 @ freq = 1 MHz - sky_a00 = sim.sky[0, 0, 0] # a00 @ freq = 1 MHz - # total spectrum should go like f ** (2 - 2.5) - expected_vis = beam_a00 * sky_a00 * np.squeeze(freq) ** (-0.5) - expected_vis /= sim.beam.total_power - expected_vis.shape = (1, -1) # add time axis - assert np.allclose(sim.waterfall, np.repeat(expected_vis, N_times, axis=0)) - # with dpss - sim.run(dpss=True, nterms=50) - assert np.allclose(sim.waterfall, np.repeat(expected_vis, N_times, axis=0)) - - # test with nonzero m-modes - kwargs["times"] = None - sky_alm = np.zeros_like(sky_alm[0]) # remove the frequency axis - sky = Sky(sky_alm, lmax=lmax, coord="M") - sky[0, 0] = 1e7 - sky[2, 0] = 1e4 - sky[3, 1] = -20.2 + 20.4j - sky[6, 6] = 1.0 - 3.0j - - beam_alm = np.zeros_like(sky_alm) - beam = Beam(beam_alm, lmax=lmax, coord="M") - beam[0, 0] = 10 - beam[2, 0] = 5 - beam[3, 1] = 1 + 2j - beam[6, 6] = -1 - 1.34j - - sim = Simulator(beam, sky, **kwargs) - - sim.run(dpss=False) - expected_vis = ( - sky[0, 0] * beam[0, 0] - + sky[2, 0] * beam[2, 0] - + 2 * np.real(sky[3, 1] * np.conj(beam[3, 1])) - + 2 * np.real(sky[6, 6] * np.conj(beam[6, 6])) - ) - expected_vis /= sim.beam.total_power - assert np.isclose(sim.waterfall, expected_vis) - - # test the einsum computation in dpss mode - frequencies = np.linspace(1, 50, 50).reshape(-1, 1) - beam_alm = beam.alm.reshape(1, -1) * frequencies**2 - beam = Beam(beam_alm, lmax=lmax, frequencies=frequencies, coord="M") - sky_alm = sky.alm.reshape(1, -1) * frequencies ** (-2.5) - sky = Sky(sky_alm, lmax=lmax, frequencies=frequencies, coord="M") - sim = Simulator(beam, sky, **kwargs) - sim.run(dpss=True, nterms=10) - # expected output is dot product of alms in frequency space: - sky_alm = sim.sky.alm - beam_alm = sim.design_matrix @ sim.beam.coeffs - temp_vector = np.empty(frequencies.size) - for i in range(frequencies.size): - t = sky_alm[i, : lmax + 1].real.dot(beam_alm[i, : lmax + 1].real) - t += 2 * np.real( - sky_alm[i, lmax + 1 :].dot(beam_alm[i, lmax + 1 :].conj()) - ) - temp_vector[i] = t - # output of simulator - wfall = sim.waterfall * sim.beam.total_power - assert np.allclose(temp_vector, wfall) From 869a0824cdd36c7a1413278de2300fb8d1f92f06 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 24 May 2024 10:49:19 -0700 Subject: [PATCH 102/129] rename coordinates to utils and add more geeneral utility functions --- croissant/__init__.py | 5 +-- croissant/core/healpix.py | 2 +- croissant/core/rotations.py | 4 +- croissant/core/simulator.py | 54 ------------------------- croissant/core/tests/test_healpix.py | 2 +- croissant/core/tests/test_simulator.py | 2 +- croissant/jax/rotations.py | 2 +- croissant/tests/test_coordinates.py | 24 +++++------ croissant/{coordinates.py => utils.py} | 56 +++++++++++++++++++++++++- 9 files changed, 75 insertions(+), 76 deletions(-) rename croissant/{coordinates.py => utils.py} (56%) diff --git a/croissant/__init__.py b/croissant/__init__.py index ea21dad..b45cb53 100644 --- a/croissant/__init__.py +++ b/croissant/__init__.py @@ -2,9 +2,8 @@ __version__ = "4.0.0" from . import constants -from . import coordinates from . import core -from . import jax from . import dpss - +from . import jax +from . import utils from .core import * # noqa F403 diff --git a/croissant/core/healpix.py b/croissant/core/healpix.py index e475ac3..a285be4 100644 --- a/croissant/core/healpix.py +++ b/croissant/core/healpix.py @@ -4,7 +4,7 @@ import warnings from .. import constants -from ..coordinates import coord_rep +from ..utils import coord_rep from .rotations import Rotator from .sphtransform import alm2map, map2alm diff --git a/croissant/core/rotations.py b/croissant/core/rotations.py index 9f4c4e3..5b9b7b4 100644 --- a/croissant/core/rotations.py +++ b/croissant/core/rotations.py @@ -1,9 +1,9 @@ from astropy.coordinates import AltAz, EarthLocation import healpy as hp -from lunarsky import LunarTopo, MoonLocation, SkyCoord +from lunarsky import LunarTopo, MoonLocation import numpy as np -from ..coordinates import get_rot_mat, rotmat_to_euler +from ..utils import get_rot_mat, rotmat_to_euler from .sphtransform import map2alm, alm2map diff --git a/croissant/core/simulator.py b/croissant/core/simulator.py index 1558fff..88cdfa2 100644 --- a/croissant/core/simulator.py +++ b/croissant/core/simulator.py @@ -1,66 +1,12 @@ -from astropy import units from astropy.coordinates import EarthLocation from copy import deepcopy from lunarsky import MoonLocation, Time import matplotlib.pyplot as plt import numpy as np -import warnings from .. import dpss -def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): - """ - Generate an array of evenly sampled times to run the simulation at. - - Parameters - ---------- - t_start : str or astropy.time.Time - The start time of the simulation. - t_end : str or astropy.time.Time - The end time of the simulation. - N_times : int - The number of times to run the simulation at. - delta_t : float or astropy.units.Quantity - The time step between each time in the simulation. - - Returns - ------- - times : astropy.time.Time or astropy.units.Quantity - The evenly sampled times to run the simulation at. - - """ - - if t_start is not None: - t_start = Time(t_start, scale="utc") - - try: - dt = np.arange(N_times) * delta_t - except TypeError: - t_end = Time(t_end, scale="utc") - total_time = (t_end - t_start).sec - if N_times is None: - try: - delta_t = delta_t.to_value("s") - except AttributeError: - warnings.warn( - "delta_t is not an astropy.units.Quantity. Assuming " - "units of seconds.", - UserWarning, - ) - dt = np.arange(0, total_time + delta_t, delta_t) - else: - dt = np.linspace(0, total_time, N_times) - dt = dt * units.s - - if t_start is None: - times = dt - else: - times = t_start + dt - - return times - - class Simulator: def __init__( self, diff --git a/croissant/core/tests/test_healpix.py b/croissant/core/tests/test_healpix.py index b03783b..a177231 100644 --- a/croissant/core/tests/test_healpix.py +++ b/croissant/core/tests/test_healpix.py @@ -4,7 +4,7 @@ import pytest from croissant import healpix as hp, sphtransform as spht from croissant.constants import sidereal_day_earth, sidereal_day_moon, Y00 -from croissant.coordinates import coord_rep +from croissant.utils import coord_rep def test_healpix2lonlat(): diff --git a/croissant/core/tests/test_simulator.py b/croissant/core/tests/test_simulator.py index 5d90971..17e8a44 100644 --- a/croissant/core/tests/test_simulator.py +++ b/croissant/core/tests/test_simulator.py @@ -8,7 +8,7 @@ from croissant import Beam, dpss, Rotator, Simulator, Sky from croissant.constants import sidereal_day_earth -from croissant.simulator import time_array +from croissant.utils import time_array # define default params for simulator diff --git a/croissant/jax/rotations.py b/croissant/jax/rotations.py index c5821fe..d1cf5cc 100644 --- a/croissant/jax/rotations.py +++ b/croissant/jax/rotations.py @@ -3,7 +3,7 @@ from s2fft import rotate_flms import jax -from ..coordinates import get_rot_mat, rotmat_to_euler +from ..utils import get_rot_mat, rotmat_to_euler from .alm import lmax_from_shape diff --git a/croissant/tests/test_coordinates.py b/croissant/tests/test_coordinates.py index e035d11..c65fd56 100644 --- a/croissant/tests/test_coordinates.py +++ b/croissant/tests/test_coordinates.py @@ -2,24 +2,24 @@ import healpy as hp from lunarsky import LunarTopo, MCMF, MoonLocation, SkyCoord, Time import numpy as np -from croissant import coordinates +from croissant import utils def test_coord_rep(): coords = ["galactic", "equatorial", "ecliptic", "mcmf", "topocentric"] short = ["G", "C", "E", "M", "T"] for i in range(len(coords)): - assert coordinates.coord_rep(coords[i]) == short[i] + assert utils.coord_rep(coords[i]) == short[i] def test_get_rot_mat(): # check that we agree with healpy for galactic -> equatorial - rot_mat = coordinates.get_rot_mat("galactic", "fk5") + rot_mat = utils.get_rot_mat("galactic", "fk5") rot = hp.Rotator(coord=["G", "C"]) assert np.allclose(rot_mat, rot.mat) # equatorial -> galactic - rot_mat = coordinates.get_rot_mat("fk5", "galactic") + rot_mat = utils.get_rot_mat("fk5", "galactic") rot = hp.Rotator(coord=["C", "G"]) assert np.allclose(rot_mat, rot.mat) @@ -27,7 +27,7 @@ def test_get_rot_mat(): time = Time("2022-06-16 17:00:00") loc = EarthLocation(lon=0, lat=40) to_frame = AltAz(obstime=time, location=loc) - rot_mat = coordinates.get_rot_mat("fk5", to_frame) + rot_mat = utils.get_rot_mat("fk5", to_frame) x, y, z = np.eye(3) xp, yp, zp = ( SkyCoord(x=x, y=y, z=z, frame="fk5", representation_type="cartesian") @@ -39,7 +39,7 @@ def test_get_rot_mat(): # MCMF -> AltAz loc = MoonLocation(lon=0, lat=40) to_frame = LunarTopo(obstime=time, location=loc) - rot_mat = coordinates.get_rot_mat("mcmf", to_frame) + rot_mat = utils.get_rot_mat("mcmf", to_frame) xp, yp, zp = ( SkyCoord(x=x, y=y, z=z, frame="mcmf", representation_type="cartesian") .transform_to(to_frame) @@ -50,7 +50,7 @@ def test_get_rot_mat(): # galactic -> MCMF # in this case we have to invert the matrix that does MCMF -> galactic # since we cannot instantiate a galactic frame from cartesian coords - rot_mat = coordinates.get_rot_mat("galactic", MCMF()) + rot_mat = utils.get_rot_mat("galactic", MCMF()) xp, yp, zp = ( SkyCoord(x=x, y=y, z=z, frame="mcmf", representation_type="cartesian") .transform_to("galactic") @@ -61,17 +61,17 @@ def test_get_rot_mat(): def test_rotmat_to_euler(): # check that rotmat_to_euler is the inverse of euler_matrix_new - rot_mat = coordinates.get_rot_mat("galactic", "fk5") - eul = coordinates.rotmat_to_euler(rot_mat) + rot_mat = utils.get_rot_mat("galactic", "fk5") + eul = utils.rotmat_to_euler(rot_mat) rmat = hp.rotator.get_rotation_matrix(eul)[0] assert np.allclose(rot_mat, rmat) - rot_mat = coordinates.get_rot_mat("galactic", "mcmf") - eul = coordinates.rotmat_to_euler(rot_mat) + rot_mat = utils.get_rot_mat("galactic", "mcmf") + eul = utils.rotmat_to_euler(rot_mat) rmat = hp.rotator.get_rotation_matrix(eul)[0] assert np.allclose(rot_mat, rmat) rot_mat = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]]) - eul = coordinates.rotmat_to_euler(rot_mat) + eul = utils.rotmat_to_euler(rot_mat) rmat = hp.rotator.get_rotation_matrix(eul)[0] assert np.allclose(rot_mat, rmat) diff --git a/croissant/coordinates.py b/croissant/utils.py similarity index 56% rename from croissant/coordinates.py rename to croissant/utils.py index 5e628a2..5ec9c71 100644 --- a/croissant/coordinates.py +++ b/croissant/utils.py @@ -1,5 +1,7 @@ -from lunarsky import SkyCoord +from astropy import units +from lunarsky import SkyCoord, Time import numpy as np +import warnings def coord_rep(coord): @@ -84,3 +86,55 @@ def rotmat_to_euler(mat): gamma = np.arctan2(mat[0, 1] / np.cos(beta), mat[0, 0] / np.cos(beta)) eul = (gamma, beta, alpha) return eul + + +def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): + """ + Generate an array of evenly sampled times to run the simulation at. + + Parameters + ---------- + t_start : str or astropy.time.Time + The start time of the simulation. + t_end : str or astropy.time.Time + The end time of the simulation. + N_times : int + The number of times to run the simulation at. + delta_t : float or astropy.units.Quantity + The time step between each time in the simulation. + + Returns + ------- + times : astropy.time.Time or astropy.units.Quantity + The evenly sampled times to run the simulation at. + + """ + + if t_start is not None: + t_start = Time(t_start, scale="utc") + + try: + dt = np.arange(N_times) * delta_t + except TypeError: + t_end = Time(t_end, scale="utc") + total_time = (t_end - t_start).sec + if N_times is None: + try: + delta_t = delta_t.to_value("s") + except AttributeError: + warnings.warn( + "delta_t is not an astropy.units.Quantity. Assuming " + "units of seconds.", + UserWarning, + ) + dt = np.arange(0, total_time + delta_t, delta_t) + else: + dt = np.linspace(0, total_time, N_times) + dt = dt * units.s + + if t_start is None: + times = dt + else: + times = t_start + dt + + return times From 64d3f5686a32288340a9861898ac18a0c5470108 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Sun, 26 May 2024 17:50:33 -0700 Subject: [PATCH 103/129] firts pass at simulator in jax --- croissant/jax/simulator.py | 188 ++++++++++++++++++++++++++++++++++++- 1 file changed, 184 insertions(+), 4 deletions(-) diff --git a/croissant/jax/simulator.py b/croissant/jax/simulator.py index 902f787..3c90338 100644 --- a/croissant/jax/simulator.py +++ b/croissant/jax/simulator.py @@ -3,9 +3,11 @@ import jax.numpy as jnp from .. import constants +from ..utils import hp_npix2nside +from . import alm, rotations -@partial(jax.jit, static_argnums=(0,)) +@partial(jax.jit, static_argnums=(0)) def rot_alm_z(lmax, times, sidereal_day=constants.sidereal_day_moon): """ Compute the complex phases that rotate the sky for a range of times. The @@ -38,18 +40,18 @@ def rot_alm_z(lmax, times, sidereal_day=constants.sidereal_day_moon): @jax.jit -def run(sky_alm, beam_alm, phases): +def convolve(beam_alm, sky_alm, phases): """ Compute the convolution for a range of times in jax. The convolution is a dot product in l,m space. Axes are in the order: time, freq, ell, emm. Parameters ---------- - sky_alm : jnp.ndarray - The sky alms. Shape (N_freqs, lmax+1, 2*lmax+1). beam_alm : jnp.ndarray The beam alms. Shape (N_freqs, lmax+1, 2*lmax+1). The beam should be normalized to have total power of unity. + sky_alm : jnp.ndarray + The sky alms. Shape (N_freqs, lmax+1, 2*lmax+1). phases : jnp.ndarray The phases that rotate the sky, of the form exp(-i*m*phi(t)). Shape (N_times, 2*lmax+1). @@ -64,3 +66,181 @@ def run(sky_alm, beam_alm, phases): b = beam_alm.conjugate()[None, :, :, :] # add time axis and conjugate res = jnp.sum(s * p * b, axes=(2, 3)) # dot product in l,m space return res + + +def _spht_wrapper(m, lmax, sampling): + """ + Wrapper for the spherical harmonic transform. This function is called + by ``run'' to compute the spherical harmonic transform of the beam and + sky. + + Parameters + ---------- + m : jnp.ndarray + The maps on the sphere with a frequency axis. + lmax : int + The maximum ell value. + sampling : str + The sampling scheme. Supported sampling schemes are ``mw'', ``mwss'', + ``dh'', ```gl'' and ``healpix''. See s2fft documentation for more + information. + + Returns + ------- + alm : jnp.ndarray + The spherical harmonic coefficients. + + """ + if sampling == "healpix": + npix = m.shape[-1] + nside = hp_npix2nside(npix) + else: + nside = None + # arguments for map2alm + args = { + "lmax": lmax, + "spin": 0, + "nside": nside, + "sampling": sampling, + "reality": True, + "precomps": None, + "spmd": True, + } + return jax.vmap(partial(alm.map2alm, **args))(m) + + +def run( + beam, + sky, + lmax, + beam_type="dh", + beam_coords="topocentric", + normalize_beam=True, + sky_type="healpix", + sky_coords="galactic", + world="moon", + location=None, + times=None, + nfreqs=1, +): + """ + Run the simulation in jax. The beam and sky could each be maps on the + sphere or spherical harmonic coefficients. This is specified by the + ``beam_type'' and ``sky_type'' arguments; if maps on the sphere, this + should be the sampling scheme used. + + The shapes of the arrays depend on if they are alms or maps on the sphere + (in which caase the shape also depends on the sampling scheme). See + the functions ``f_shape'' and ``flm_shape'' in + ``s2fft.sampling.s2_samples''. + + The beam and sky could be specified at several frequencies (or any other + batch dimension). This needs to be the axis 0 of the input arrays. In + this case, the argument ``nfreqs'' must be set accordingly. + + Parameters + ---------- + beam : jnp.ndarray + The beam maps or alms. + sky : jnp.ndarray + The sky maps or alms. + lmax : int + The maximum ell value (inclusive). + beam_type : str + Must be ``alm'' or a sampling shceme. Supported sampling schemes are + ``mw'', ``mwss'', ``dh'', ```gl'' and ``healpix''. Default is ``dh'', + which is equiangular sampling. See s2fft documentation for more + information. + beam_coords : str + The coordinate system of the beam. Default is ``topocentric''. + Other options are ``equatorial'' (earth) and ``mcmf'' (moon). + normalize_beam : bool + Whether to normalize the beam to have total power of unity. Default is + True. + sky_type : str + Must be ``alm'' or a sampling shceme. Supported sampling schemes are + ``mw'', ``mwss'', ``dh'', ```gl'' and ``healpix''. Default is + ``healpix''. See s2fft documentation for more information. + sky_coords : str + The coordinate system of the sky. Default is ``galactic''. Other + options are ``equatorial'' (earth) and ``mcmf'' (moon). + world : str + ``earth'' or ``moon''. Default is ``moon''. + location : astropy.coordinates.EarthLocation or lunrsky.MoonLocation + The location of the observer. Required if beam_coords is + ``topocentric''. + times : astropy.time.Time or lunarsky.Time or list of these + The times for which to compute the convolution. Required if + beam_coords is ``topocentric''. See ``utils.time_array'' for a + convenient way to generate evenly spaced times. + nfreqs : int + The number of frequencies. Default is 1. + + Returns + ------- + res : jnp.ndarray + The convolution. Shape (N_times, N_freqs). + + """ + # add frequency axis + if nfreqs == 1: + beam = beam[None] + sky = sky[None] + # beam spherical harmonic transform + if beam_type == "alm": + beam_alm = beam + else: + beam_alm = _spht_wrapper(beam, lmax, beam_type) + + # get the reference time + try: + t0 = times[0] # times is a list + ntimes = len(times) + except IndexError: + t0 = times # times is a single time + ntimes = 1 + except TypeError: + ntimes = 0 # times is None + + # beam coordinate transformation if topocentric + if beam_coords == "topocentric": + args = {"loc": location, "time": t0, "dl_array": None} + if world == "earth": + func = rotations.topo2eq + elif world == "moon": + func = rotations.topo2mcmf + else: + raise ValueError("world must be 'earth' or 'moon'") + beam_alm = jax.vmap(partial(func, **args))(beam_alm) + + # normalize beam + if normalize_beam: + norm = alm, total_power(beam_alm) + beam_alm /= norm + + # sky spherical harmonic transform + if sky_type == "alm": + sky_alm = sky + else: + sky_alm = _spht_wrapper(sky, lmax, sky_type) + + # sky coordinate transformation if galactic + if sky_coords == "galactic": + sky_alm = jax.vmap(rotations.gal2eq)(sky_alm) + + # compute the phases that rotate the sky + if ntimes < 2: + phases = jnp.array([1.0]) + else: + t_sec = jnp.array([t.to_value("unix") for t in times]) + if world == "earth": + sidereal_day = constants.sidereal_day_earth + elif world == "moon": + sidereal_day = constants.sidereal_day_moon + else: + raise ValueError("world must be 'earth' or 'moon'") + phases = rot_alm_z(lmax, t_sec, sidereal_day=sidereal_day) + + # compute the convolution + res = convolve(beam_alm, sky_alm, phases) + return res From cb42ea71fe59defa307cc97cfd314ef4a81f1e2b Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Sun, 26 May 2024 17:51:03 -0700 Subject: [PATCH 104/129] add npix 2 nside --- croissant/utils.py | 23 ++++++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/croissant/utils.py b/croissant/utils.py index 5ec9c71..1e40cd1 100644 --- a/croissant/utils.py +++ b/croissant/utils.py @@ -87,6 +87,23 @@ def rotmat_to_euler(mat): eul = (gamma, beta, alpha) return eul +def hp_npix2nside(npix): + """ + Calculate the nside of a HEALPix map from the number of pixels. + + Parameters + ---------- + npix : int + The number of pixels in the map. + + Returns + ------- + nside : int + The nside of the map. + + """ + nside = int(np.sqrt(npix / 12)) + return nside def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): """ @@ -94,9 +111,9 @@ def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): Parameters ---------- - t_start : str or astropy.time.Time + t_start : str or astropy.time.Time or lunarsky.Time The start time of the simulation. - t_end : str or astropy.time.Time + t_end : str or astropy.time.Time or lunarsky.Time The end time of the simulation. N_times : int The number of times to run the simulation at. @@ -105,7 +122,7 @@ def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): Returns ------- - times : astropy.time.Time or astropy.units.Quantity + times : astropy.time.Time or lunarsky.Time or astropy.units.Quantity The evenly sampled times to run the simulation at. """ From 82400d12057101056df43b64c2388d75f8c9f9c0 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 29 May 2024 09:50:54 -0700 Subject: [PATCH 105/129] write tests for alm.py --- croissant/jax/tests/test_alm.py | 296 +++++++++++--------------------- 1 file changed, 100 insertions(+), 196 deletions(-) diff --git a/croissant/jax/tests/test_alm.py b/croissant/jax/tests/test_alm.py index 86b2f42..fe94f1a 100644 --- a/croissant/jax/tests/test_alm.py +++ b/croissant/jax/tests/test_alm.py @@ -1,141 +1,120 @@ -from copy import deepcopy -import pytest -from numpy.random import default_rng import jax.numpy as jnp +import numpy as np +import pytest import s2fft -from croissant.jax import healpix as hp -from croissant.constants import sidereal_day_earth, sidereal_day_moon, Y00 +from croissant.constants import Y00 +import croissant.jax as crojax pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) -rng = default_rng(1913) -freqs = jnp.linspace(1, 50, 50) -nfreqs = freqs.size +rng = np.random.default_rng(seed=0) -def test_compute_total_power(lmax): - # make a beam that is 1 everywhere so total power is 4pi: - beam = Beam.zeros(lmax) - beam[0, 0, 0] = 1 / Y00 - beam.compute_total_power() - assert jnp.allclose(beam.total_power, 4 * jnp.pi) +@pytest.mark.parametrize("sampling", ["dh", "mw", "healpix"]) +def test_alm2map(lmax, sampling): + if sampling == "healpix": + nside = lmax // 2 + else: + nside = None + # make constant map + shape = crojax.alm.shape_from_lmax(lmax) + alm = jnp.zeros(shape, dtype=jnp.complex128) + a00 = 5 + alm[crojax.alm.getidx(lmax, 0, 0)] = a00 + m = crojax.alm.alm2map(alm, sampling=sampling, nside=nside) + assert jnp.allclose(m, a00 * Y00) - # beam(theta) = cos(theta)**2 * freq**2 - beam = Beam.zeros(lmax, frequencies=frequencies) - beam[:, 0, 0] = 1 / (3 * Y00) * frequencies**2 - beam[:, 2, 0] = 4 * jnp.sqrt(jnp.pi / 5) * 1 / 3 * frequencies**2 - beam.compute_total_power() - power = beam.total_power - expected_power = 4 * jnp.pi / 3 * frequencies**2 - assert jnp.allclose(power, expected_power.ravel()) + # XXX compare to healpy with more complex alm -def test_lmax_from_shape(lmax): - s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) - shape = (1, s1, s2) # add frequency axis - _lmax = hp.lmax_from_shape(shape) - assert _lmax == lmax +@pytest.mark.parametrize("sampling", ["dh", "mw", "healpix"]) +def test_map2alm(lmax, sampling): + if sampling == "healpix": + nside = lmax // 2 + else: + nside = None + # make constant map + shape = s2fft.sampling.s2_samples.f_shape( + lmax + 1, sampling=sampling, nside=nside + ) + const = 10 # constant map with value 10 + m = jnp.ones(shape, dtype=jnp.float64) * const + alm = crojax.alm.map2alm(m, sampling=sampling, nside=nside) + a00_idx = crojax.alm.getidx(lmax, 0, 0) + a00 = alm[a00_idx] + assert jnp.allclose(a00, 4 * jnp.pi * Y00 * const) -def test_alm_indexing(lmax): - # initialize all alms to 0 - alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) - # set a00 = 1 for first half of frequencies - alm[: nfreqs // 2, 0, 0] = 1.0 - # check __setitem__ acted correctly on alm.alm - l_ix, m_ix = alm.getidx(0, 0) - mask = jnp.zeros_like(alm.alm, dtype=bool) - mask = mask.at[: nfreqs // 2, l_ix, m_ix].set(True) - # first half frequencies of a00, which should be 1 - assert jnp.allclose(alm.alm[mask], 1) - # all other alm should be 0 - assert jnp.allclose(alm.alm[~mask], 0) - # check that __getitem__ agrees: - assert jnp.allclose(alm[: nfreqs // 2, 0, 0], 1) - assert jnp.allclose(alm[nfreqs // 2 :, 0, 0], 0) - # __getitem__ can't get multiple l-modes or m-modes at once... - for ell in range(1, lmax + 1): - for emm in range(-ell, ell + 1): - assert jnp.allclose(alm[:, ell, emm], 0) + # XXX compare to healpy with more complex map - # set everything back to 0 - alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) - # negative indexing - val = 3.0 + 2.3j - alm[-1, 6, 3] = val - assert alm[-1, 6, 3] == val - l_ix, m_ix = alm.getidx(6, 3) - assert alm[-1, 6, 3] == alm.alm[-1, l_ix, m_ix] + # XXX test that map2alm(alm2map(alm)) == alm - # frequency index not specified - with pytest.raises(TypeError): - alm[3, 2] = 5 - alm[7, -1] +def test_total_power(lmax): + # make a map that is 1 everywhere so total power is 4pi: + shape = crojax.alm.shape_from_lmax(lmax) + alm = jnp.zeros(shape, dtype=jnp.complex128) + a00_idx = crojax.alm.getidx(lmax, 0, 0) + alm[a00_idx] = 1 / Y00 + power = crojax.alm.compute_power(alm) + assert jnp.isclose(power, 4 * jnp.pi) -def test_getlm(lmax): - alm = hp.Alm.zeros(lmax=lmax) - nrows, ncols = alm.alm.shape[1:] - # l correspond to rows, m correspond to columns - ls = jnp.arange(nrows) - ms = jnp.arange(ncols) - lmax - for i in range(nrows): - for j in range(ncols): - ix = (i, j) - ell, emm = alm.getlm(ix) - assert ell == ls[i] - assert emm == ms[j] + # m(theta) = cos(theta)**2 + alm = jnp.zeros(shape, dtype=jnp.complex128) + alm[a00_idx] = 1 / (3 * Y00) + a20_idx = crojax.alm.getidx(lmax, 2, 0) + alm[a20_idx] = 4 * jnp.sqrt(jnp.pi / 5) * 1 / 3 + power = crojax.alm.compute_power(alm) + expected_power = 4 * jnp.pi / 3 + assert jnp.isclose(power, expected_power) def test_getidx(lmax): # using ints ell = 3 emm = 2 - ix = hp._getidx(ell, emm, lmax) - ell_, emm_ = hp._getlm(ix, lmax) + ix = crojax.alm.getidx(ell, emm, lmax) + ell_, emm_ = crojax.alm.getlm(lmax, ix) assert ell == ell_ assert emm == emm_ # using arrays ls = lmax // jnp.arange(1, 10) ms = jnp.arange(-lmax, lmax + 1) - ixs = hp._getidx(ls, ms, lmax) - ls_, ms_ = hp._getlm(ixs, lmax) + ixs = crojax.alm.getidx(ls, ms, lmax) + ls_, ms_ = crojax.alm.getlm(lmax, ixs) assert jnp.allclose(ls, ls_) assert jnp.allclose(ms, ms_) - # using ell > lmax should raise error in class method - alm = hp.Alm.zeros(lmax=lmax) - ell = 3 - emm = 2 - bad_ell = 2 * lmax # bigger than lmax - bad_emm = 4 # bigger than ell - with pytest.raises(IndexError): - alm.getidx(bad_ell, emm) - alm.getidx(ell, bad_emm) - alm.getidx(-ell, emm) # should fail since l < 0 - # check that error is raised if array contains bad ell - bad_ells = lmax + jnp.arange(-2, 2) - with pytest.raises(IndexError): - alm.getidx(bad_ells, emm) +def test_getlm(lmax): + alm = jnp.zeros(crojax.alm.shape_from_lmax(lmax), dtype=jnp.complex128) + nrows, ncols = alm.shape + # l correspond to rows, m correspond to columns + ls = jnp.arange(nrows) + ms = jnp.arange(ncols) - lmax + for i in range(nrows): + for j in range(ncols): + ix = (i, j) + ell, emm = crojax.alm.getlm(lmax, ix) + assert ell == ls[i] + assert emm == ms[j] -def test_zeros(lmax): - alm = hp.Alm.zeros(lmax=lmax, frequencies=freqs) - assert alm.lmax == lmax - assert alm.frequencies is freqs - s1, s2 = s2fft.sampling.s2_samples.flm_shape(lmax + 1) - assert alm.alm.shape == (nfreqs, s1, s2) - assert jnp.allclose(alm.alm, 0) +def test_lmax_from_shape(lmax): + shape = s2fft.sampling.s2_samples.flm_shape(lmax + 1) + _lmax = crojax.alm.lmax_from_shape(shape) + assert _lmax == lmax def test_is_real(lmax): - alm = hp.Alm.zeros(lmax=lmax) - assert alm.is_real + alm = jnp.zeros(crojax.alm.shape_from_lmax(lmax), dtype=jnp.complex128) + assert crojax.alm.is_real(alm) val = 1.0 + 2.0j - alm[0, 2, 1] = val # set l=2, m=1 mode but not m=-1 mode - assert not alm.is_real - alm[0, 2, -1] = -1 * val.conjugate() # set m=-1 mode to complex conjugate - assert alm.is_real + ix_21 = crojax.alm.getidx(2, 1, lmax) # get index for l=2, m=1 + alm[ix_21] = val # set l=2, m=1 mode but not m=-1 mode + assert not crojax.alm.is_real(alm) + ix_2m1 = crojax.alm.getidx(2, -1, lmax) # get index for l=2, m=-1 + alm[ix_2m1] = -1 * val.conjugate() # set m=-1 mode to complex conjugate + assert crojax.alm.is_real(alm) # generate a real signal and check that alm.is_real is True alm = s2fft.utils.signal_generator.generate_flm( @@ -154,103 +133,28 @@ def test_is_real(lmax): def test_reduce_lmax(lmax): - sig = s2fft.utils.signal_generator.generate_flm(rng, lmax + 1) - alm = hp.Alm(sig[None]) - old_alm = deepcopy(alm) + signal1 = s2fft.utils.signal_generator.generate_flm(rng, lmax + 1) # reduce to same lmax, should do nothing - alm.reduce_lmax(lmax) - assert alm.lmax == lmax - assert jnp.allclose(alm.alm, old_alm.alm) - # reduce to new lmax + signal2 = crojax.alm.reduce_lmax(signal1, lmax) + assert crojax.alm.lmax_from_shape(signal2.shape) == lmax + assert jnp.allclose(signal1, signal2) + # reduce lmax of signal 2 to new_lmax new_lmax = 5 - alm.reduce_lmax(new_lmax) - assert alm.lmax == new_lmax - s1, s2 = s2fft.sampling.s2_samples.flm_shape(new_lmax + 1) - assert alm.alm.shape == (1, s1, s2) + signal2 = crojax.alm.reduce_lmax(signal1, lmax) + assert crojax.alm.lmax_from_shape(signal2.shape) == new_lmax + # confirm that signal 2 has the expected shape + expected_shape = crojax.alm.shape_from_lmax(new_lmax) + assert signal2.shape == expected_shape + # check that the signals are the same for all ell, emm for ell in range(new_lmax + 1): for emm in range(-ell, ell + 1): - assert alm[:, ell, emm] == old_alm[:, ell, emm] - with pytest.raises(IndexError): - alm[:, 7, 0] # asking for ell > new_lmax should raise error - # try to reduce to greater lmax - new_lmax = 200 - with pytest.raises(ValueError): - alm.reduce_lmax(new_lmax) - - -@pytest.mark.parametrize("sampling", ["mw", "healpix"]) -def test_alm2map(lmax, sampling): - if sampling == "healpix": - nside = lmax // 2 - else: - nside = None - # make constant map - alm = hp.Alm.zeros(lmax=lmax) - a00 = 5 - alm[0, 0, 0] = a00 - m = alm.alm2map(sampling=sampling, nside=nside) - assert jnp.allclose(m, a00 * Y00) - - # make many maps - frequencies = jnp.linspace(1, 50, 50) - alm = hp.Alm.zeros(lmax=lmax, frequencies=frequencies) - alm[:, 0, 0] = a00 * frequencies - m = alm.alm2map(sampling=sampling, nside=nside, frequencies=frequencies) - m_ = a00 * frequencies * Y00 - for i in range(m.ndim - 1): - m_ = m_[:, None] # match dimensions of m - assert jnp.allclose(m, m_) - - # use subset of frequencies and compare to full set - alm = hp.Alm.zeros(lmax=lmax, frequencies=frequencies) - # some random map - alm[:, 0, 0] = a00 * frequencies - alm[:, 1, 1] = 2 * a00 * frequencies - alm[::2, 8, 3] = -3 * a00 * frequencies[::2] - m = alm.alm2map(sampling=sampling, nside=nside, frequencies=frequencies) - freq_indices = jnp.array([10, 20, 35]) # indices of frequencies to use - freqs = frequencies[freq_indices] # frequencies to use - m_select = alm.alm2map(sampling=sampling, nside=nside, frequencies=freqs) - assert jnp.allclose(m_select, m[freq_indices]) - - # use some frequencies that are not in alm.frequencies - f = jnp.array([0, 30, 100]) - with pytest.warns(UserWarning): - alm.alm2map(sampling=sampling, nside=nside, frequencies=f) - - -def test_rot_alm_z(lmax): - alm = hp.Alm.zeros(lmax=lmax) - - # rotate a single angle - phi = jnp.array([jnp.pi / 2]) - phase = alm.rot_alm_z(phi=phi) - ms = jnp.arange(-lmax, lmax + 1) - assert phase.shape == (1, ms.size) - assert jnp.allclose(phase, jnp.exp(-1j * ms * phi)) - - # rotate a set of angles - phi = jnp.linspace(0, 2 * jnp.pi, num=361) # 1 deg spacing - phase = alm.rot_alm_z(phi=phi) - assert phase.shape == (phi.size, ms.size) - assert jnp.allclose(phase[0], jnp.exp(-1j * ms * phi[0])) - assert jnp.allclose(phase, jnp.exp(-1j * ms[None] * phi[:, None])) + # indexing differes since lmax differs + ix1 = crojax.alm.getidx(ell, emm, lmax) + ix2 = crojax.alm.getidx(ell, emm, new_lmax) + assert signal1[ix1] == signal2[ix2] - # check that phi = 0 and phi = 2pi give the same answer - assert jnp.allclose(phase[0], phase[-1]) - # rotate in time - alm = hp.Alm.zeros(lmax=lmax) - div = jnp.array([1, 2, 4, 8]) - for d in div: - dphi = jnp.array([2 * jnp.pi / d]) - # earth - dt = sidereal_day_earth / d - assert jnp.allclose( - alm.rot_alm_z(times=dt, world="earth"), alm.rot_alm_z(phi=dphi) - ) - # moon - dt = sidereal_day_moon / d - assert jnp.allclose( - alm.rot_alm_z(times=dt, world="moon"), alm.rot_alm_z(phi=dphi) - ) +def test_shape_from_lmax(lmax): + shape = crojax.alm.shape_from_lmax(lmax) + expected_shape = s2fft.sampling.s2_samples.flm_shape(lmax + 1) + assert shape == expected_shape From 91b05a05d751d65a7fd0c780d997398dea41ba32 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 29 May 2024 09:57:08 -0700 Subject: [PATCH 106/129] fix jnp array updates --- croissant/jax/tests/test_alm.py | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/croissant/jax/tests/test_alm.py b/croissant/jax/tests/test_alm.py index fe94f1a..ac16447 100644 --- a/croissant/jax/tests/test_alm.py +++ b/croissant/jax/tests/test_alm.py @@ -19,7 +19,7 @@ def test_alm2map(lmax, sampling): shape = crojax.alm.shape_from_lmax(lmax) alm = jnp.zeros(shape, dtype=jnp.complex128) a00 = 5 - alm[crojax.alm.getidx(lmax, 0, 0)] = a00 + alm = alm.at[crojax.alm.getidx(lmax, 0, 0)].set(a00) m = crojax.alm.alm2map(alm, sampling=sampling, nside=nside) assert jnp.allclose(m, a00 * Y00) @@ -53,15 +53,15 @@ def test_total_power(lmax): shape = crojax.alm.shape_from_lmax(lmax) alm = jnp.zeros(shape, dtype=jnp.complex128) a00_idx = crojax.alm.getidx(lmax, 0, 0) - alm[a00_idx] = 1 / Y00 + alm = alm.at[a00_idx].set(1 / Y00) power = crojax.alm.compute_power(alm) assert jnp.isclose(power, 4 * jnp.pi) # m(theta) = cos(theta)**2 alm = jnp.zeros(shape, dtype=jnp.complex128) - alm[a00_idx] = 1 / (3 * Y00) + alm = alm.at[a00_idx].set(1 / (3 * Y00)) a20_idx = crojax.alm.getidx(lmax, 2, 0) - alm[a20_idx] = 4 * jnp.sqrt(jnp.pi / 5) * 1 / 3 + alm = alm.at[a20_idx].set(4 * jnp.sqrt(jnp.pi / 5) * 1 / 3) power = crojax.alm.compute_power(alm) expected_power = 4 * jnp.pi / 3 assert jnp.isclose(power, expected_power) @@ -110,26 +110,23 @@ def test_is_real(lmax): assert crojax.alm.is_real(alm) val = 1.0 + 2.0j ix_21 = crojax.alm.getidx(2, 1, lmax) # get index for l=2, m=1 - alm[ix_21] = val # set l=2, m=1 mode but not m=-1 mode + alm = alm.at[ix_21].set(val) # set l=2, m=1 mode but not m=-1 mode assert not crojax.alm.is_real(alm) ix_2m1 = crojax.alm.getidx(2, -1, lmax) # get index for l=2, m=-1 - alm[ix_2m1] = -1 * val.conjugate() # set m=-1 mode to complex conjugate + # set m=-1 mode to complex conjugate + alm = alm.at[ix_2m1].set(-1 * val.conjugate()) assert crojax.alm.is_real(alm) # generate a real signal and check that alm.is_real is True alm = s2fft.utils.signal_generator.generate_flm( rng, lmax + 1, reality=True ) - alm = alm[None] # add frequency dimension - assert hp._is_real(alm) - assert hp.Alm(alm).is_real + assert crojax.alm.is_real(alm) # complex alm = s2fft.utils.signal_generator.generate_flm( rng, lmax + 1, reality=False ) - alm = alm[None] # add frequency dimension - assert not hp._is_real(alm) - assert not hp.Alm(alm).is_real + assert not crojax.alm.is_real(alm) def test_reduce_lmax(lmax): From a46b36b5a0ec9c310a9a789ae4b31ae5a43891c7 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 29 May 2024 10:00:04 -0700 Subject: [PATCH 107/129] make str static arg in jit --- croissant/jax/alm.py | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/croissant/jax/alm.py b/croissant/jax/alm.py index b50f8bd..8aede82 100644 --- a/croissant/jax/alm.py +++ b/croissant/jax/alm.py @@ -1,13 +1,13 @@ +from functools import partial import jax import jax.numpy as jnp import s2fft from ..constants import Y00 -@jax.jit -def alm2map( - alm, spin=0, nside=None, sampling="mw", precomps=None, spmd=True -): + +@partial(jax.jit, static_argnums=(3,)) +def alm2map(alm, spin=0, nside=None, sampling="mw", precomps=None, spmd=True): """ Construct a map on the sphere from the alm array. This is a wrapper around s2fft.inverse provided for convenience. @@ -51,7 +51,8 @@ def alm2map( ) return m -@jax.jit + +@partial(jax.jit, static_argnums=(4,)) def map2alm( m, lmax, @@ -108,6 +109,7 @@ def map2alm( ) return alm + @jax.jit def total_power(alm): """ @@ -134,6 +136,7 @@ def total_power(alm): monopole = alm[..., lix, mix] return 4 * jnp.pi * jnp.real(monopole) * Y00 + @jax.jit def getidx(lmax, ell, emm): """ @@ -162,6 +165,7 @@ def getidx(lmax, ell, emm): """ return ell, emm + lmax + @jax.jit def getlm(lmax, ix): """ @@ -189,6 +193,7 @@ def getlm(lmax, ix): emm = ix[1] - lmax return ell, emm + @jax.jit def lmax_from_shape(shape): """ @@ -208,6 +213,7 @@ def lmax_from_shape(shape): """ return shape[-2] - 1 + @jax.jit def is_real(alm): """ @@ -237,6 +243,7 @@ def is_real(alm): pos_m = alm[..., lmax + 1 :] return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)).item() + def reduce_lmax(alm, new_lmax): """ Reduce the maximum l value of the alm. @@ -264,6 +271,7 @@ def reduce_lmax(alm, new_lmax): d = lmax - new_lmax # number of ell values to remove return alm[..., :-d, d:-d] + @jax.jit def shape_from_lmax(lmax): """ From c1ea7bd6b7b7af1aceeea7e8e2acf1946d50bf82 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 29 May 2024 10:07:48 -0700 Subject: [PATCH 108/129] remove jit for now --- croissant/jax/alm.py | 11 ----------- croissant/jax/rotations.py | 7 ------- croissant/jax/simulator.py | 2 -- 3 files changed, 20 deletions(-) diff --git a/croissant/jax/alm.py b/croissant/jax/alm.py index 8aede82..1dfd9d5 100644 --- a/croissant/jax/alm.py +++ b/croissant/jax/alm.py @@ -1,12 +1,8 @@ -from functools import partial -import jax import jax.numpy as jnp import s2fft - from ..constants import Y00 -@partial(jax.jit, static_argnums=(3,)) def alm2map(alm, spin=0, nside=None, sampling="mw", precomps=None, spmd=True): """ Construct a map on the sphere from the alm array. This is a wrapper @@ -52,7 +48,6 @@ def alm2map(alm, spin=0, nside=None, sampling="mw", precomps=None, spmd=True): return m -@partial(jax.jit, static_argnums=(4,)) def map2alm( m, lmax, @@ -110,7 +105,6 @@ def map2alm( return alm -@jax.jit def total_power(alm): """ Compute the integral of a signal (such as an antenna beam) given @@ -137,7 +131,6 @@ def total_power(alm): return 4 * jnp.pi * jnp.real(monopole) * Y00 -@jax.jit def getidx(lmax, ell, emm): """ Get the index of the alm array for a given l and m. @@ -166,7 +159,6 @@ def getidx(lmax, ell, emm): return ell, emm + lmax -@jax.jit def getlm(lmax, ix): """ Get the l and m corresponding to the index of the alm array. @@ -194,7 +186,6 @@ def getlm(lmax, ix): return ell, emm -@jax.jit def lmax_from_shape(shape): """ Get the lmax from the shape of the alm array. @@ -214,7 +205,6 @@ def lmax_from_shape(shape): return shape[-2] - 1 -@jax.jit def is_real(alm): """ Check if the an array of alms correspond to a real-valued @@ -272,7 +262,6 @@ def reduce_lmax(alm, new_lmax): return alm[..., :-d, d:-d] -@jax.jit def shape_from_lmax(lmax): """ Get the shape of the alm array given the maximum l value. diff --git a/croissant/jax/rotations.py b/croissant/jax/rotations.py index d1cf5cc..b0f29a3 100644 --- a/croissant/jax/rotations.py +++ b/croissant/jax/rotations.py @@ -1,13 +1,10 @@ from astropy.coordinates import AltAz from lunarsky import LunarTopo from s2fft import rotate_flms -import jax - from ..utils import get_rot_mat, rotmat_to_euler from .alm import lmax_from_shape -@jax.jit def rotate_alm(alm, from_frame, to_frame, dl_array=None): """ Transform a spherical harmonic decomposition from one coordinate system to @@ -39,7 +36,6 @@ def rotate_alm(alm, from_frame, to_frame, dl_array=None): return alm_rot -@jax.jit def gal2eq(alm, dl_array=None): """ Transform a spherical harmonic decomposition from Galactic to Equatorial @@ -62,7 +58,6 @@ def gal2eq(alm, dl_array=None): return rotate_alm(alm, "galactic", "fk5", dl_array=dl_array) -@jax.jit def gal2mcmf(alm, dl_array=None): """ Transform a spherical harmonic decomposition from Galactic to MCMF @@ -85,7 +80,6 @@ def gal2mcmf(alm, dl_array=None): return rotate_alm(alm, "galactic", "mcmf", dl_array=dl_array) -@jax.jit def topo2eq(alm, loc, time, dl_array=None): """ Transform a spherical harmonic decomposition from topocentric on Earth to @@ -113,7 +107,6 @@ def topo2eq(alm, loc, time, dl_array=None): return rotate_alm(alm, topo, "fk5", loc, time, dl_array=dl_array) -@jax.jit def topo2mcmf(alm, loc, time, dl_array=None): """ Transform a spherical harmonic decomposition from topocentric on Moon to diff --git a/croissant/jax/simulator.py b/croissant/jax/simulator.py index 3c90338..2ef68b9 100644 --- a/croissant/jax/simulator.py +++ b/croissant/jax/simulator.py @@ -7,7 +7,6 @@ from . import alm, rotations -@partial(jax.jit, static_argnums=(0)) def rot_alm_z(lmax, times, sidereal_day=constants.sidereal_day_moon): """ Compute the complex phases that rotate the sky for a range of times. The @@ -39,7 +38,6 @@ def rot_alm_z(lmax, times, sidereal_day=constants.sidereal_day_moon): return phases -@jax.jit def convolve(beam_alm, sky_alm, phases): """ Compute the convolution for a range of times in jax. The convolution is From 6d63a45be76a90ea8394d156f2ef10977611af70 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 29 May 2024 10:27:59 -0700 Subject: [PATCH 109/129] fix syntax error in reverse indexing --- croissant/jax/alm.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/croissant/jax/alm.py b/croissant/jax/alm.py index 1dfd9d5..d1f53c6 100644 --- a/croissant/jax/alm.py +++ b/croissant/jax/alm.py @@ -228,7 +228,7 @@ def is_real(alm): # reshape emm to broadcast with alm by adding 1 or 2 dimensions emm = emm.reshape((1,) * (alm.ndim - 1) + emm.shape) # get alms for negative m, in reverse order (i.e., increasing abs(m)) - neg_m = alm[..., :lmax:-1] + neg_m = alm[..., :lmax][..., ::-1] # get alms for positive m pos_m = alm[..., lmax + 1 :] return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)).item() From d694171b10e15b2a951353b78efe6f7b0290c911 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 29 May 2024 10:32:57 -0700 Subject: [PATCH 110/129] specify that new_lmax must be strictly less than current in reduce_lmax --- croissant/jax/alm.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/croissant/jax/alm.py b/croissant/jax/alm.py index d1f53c6..6ca85e6 100644 --- a/croissant/jax/alm.py +++ b/croissant/jax/alm.py @@ -244,17 +244,13 @@ def reduce_lmax(alm, new_lmax): The alm array. Last two dimensions must correspond to the ell and emm indices. new_lmax : int - The new maximum l value. Must be less than or equal to alm lmax. + The new maximum l value. Must be less than the lmax of alm. Returns ------- new_alm : jnp.ndarray The alm array with the new maximum l value. - Raises - ------ - ValueError - If new_lmax is greater than the current lmax. """ lmax = lmax_from_shape(alm.shape) From c5eb43988083f4baa9f72e4c903dc2e2542f0b57 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 29 May 2024 10:44:15 -0700 Subject: [PATCH 111/129] fix typo --- croissant/jax/simulator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/croissant/jax/simulator.py b/croissant/jax/simulator.py index 2ef68b9..a4d07a4 100644 --- a/croissant/jax/simulator.py +++ b/croissant/jax/simulator.py @@ -213,7 +213,7 @@ def run( # normalize beam if normalize_beam: - norm = alm, total_power(beam_alm) + norm = alm.total_power(beam_alm) beam_alm /= norm # sky spherical harmonic transform From e4ddd2d53b2f07462266fb0ab4c249f645fc40d6 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 29 May 2024 10:44:36 -0700 Subject: [PATCH 112/129] some syntax --- croissant/jax/tests/test_alm.py | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/croissant/jax/tests/test_alm.py b/croissant/jax/tests/test_alm.py index ac16447..fabe898 100644 --- a/croissant/jax/tests/test_alm.py +++ b/croissant/jax/tests/test_alm.py @@ -38,7 +38,7 @@ def test_map2alm(lmax, sampling): ) const = 10 # constant map with value 10 m = jnp.ones(shape, dtype=jnp.float64) * const - alm = crojax.alm.map2alm(m, sampling=sampling, nside=nside) + alm = crojax.alm.map2alm(m, lmax, sampling=sampling, nside=nside) a00_idx = crojax.alm.getidx(lmax, 0, 0) a00 = alm[a00_idx] assert jnp.allclose(a00, 4 * jnp.pi * Y00 * const) @@ -54,7 +54,7 @@ def test_total_power(lmax): alm = jnp.zeros(shape, dtype=jnp.complex128) a00_idx = crojax.alm.getidx(lmax, 0, 0) alm = alm.at[a00_idx].set(1 / Y00) - power = crojax.alm.compute_power(alm) + power = crojax.alm.total_power(alm) assert jnp.isclose(power, 4 * jnp.pi) # m(theta) = cos(theta)**2 @@ -62,7 +62,7 @@ def test_total_power(lmax): alm = alm.at[a00_idx].set(1 / (3 * Y00)) a20_idx = crojax.alm.getidx(lmax, 2, 0) alm = alm.at[a20_idx].set(4 * jnp.sqrt(jnp.pi / 5) * 1 / 3) - power = crojax.alm.compute_power(alm) + power = crojax.alm.total_power(alm) expected_power = 4 * jnp.pi / 3 assert jnp.isclose(power, expected_power) @@ -71,7 +71,7 @@ def test_getidx(lmax): # using ints ell = 3 emm = 2 - ix = crojax.alm.getidx(ell, emm, lmax) + ix = crojax.alm.getidx(lmax, ell, emm) ell_, emm_ = crojax.alm.getlm(lmax, ix) assert ell == ell_ assert emm == emm_ @@ -79,7 +79,7 @@ def test_getidx(lmax): # using arrays ls = lmax // jnp.arange(1, 10) ms = jnp.arange(-lmax, lmax + 1) - ixs = crojax.alm.getidx(ls, ms, lmax) + ixs = crojax.alm.getidx(lmax, ls, ms) ls_, ms_ = crojax.alm.getlm(lmax, ixs) assert jnp.allclose(ls, ls_) assert jnp.allclose(ms, ms_) @@ -109,12 +109,12 @@ def test_is_real(lmax): alm = jnp.zeros(crojax.alm.shape_from_lmax(lmax), dtype=jnp.complex128) assert crojax.alm.is_real(alm) val = 1.0 + 2.0j - ix_21 = crojax.alm.getidx(2, 1, lmax) # get index for l=2, m=1 + ix_21 = crojax.alm.getidx(lmax, 2, 1) # get index for l=2, m=1 alm = alm.at[ix_21].set(val) # set l=2, m=1 mode but not m=-1 mode assert not crojax.alm.is_real(alm) - ix_2m1 = crojax.alm.getidx(2, -1, lmax) # get index for l=2, m=-1 + ix_2m1 = crojax.alm.getidx(lmax, 2, -1) # get index for l=2, m=-1 # set m=-1 mode to complex conjugate - alm = alm.at[ix_2m1].set(-1 * val.conjugate()) + alm = alm.at[ix_2m1].set(-1 * val.conjugate()) assert crojax.alm.is_real(alm) # generate a real signal and check that alm.is_real is True @@ -131,13 +131,9 @@ def test_is_real(lmax): def test_reduce_lmax(lmax): signal1 = s2fft.utils.signal_generator.generate_flm(rng, lmax + 1) - # reduce to same lmax, should do nothing - signal2 = crojax.alm.reduce_lmax(signal1, lmax) - assert crojax.alm.lmax_from_shape(signal2.shape) == lmax - assert jnp.allclose(signal1, signal2) - # reduce lmax of signal 2 to new_lmax + # reduce lmax to new_lmax new_lmax = 5 - signal2 = crojax.alm.reduce_lmax(signal1, lmax) + signal2 = crojax.alm.reduce_lmax(signal1, new_lmax) assert crojax.alm.lmax_from_shape(signal2.shape) == new_lmax # confirm that signal 2 has the expected shape expected_shape = crojax.alm.shape_from_lmax(new_lmax) @@ -146,8 +142,8 @@ def test_reduce_lmax(lmax): for ell in range(new_lmax + 1): for emm in range(-ell, ell + 1): # indexing differes since lmax differs - ix1 = crojax.alm.getidx(ell, emm, lmax) - ix2 = crojax.alm.getidx(ell, emm, new_lmax) + ix1 = crojax.alm.getidx(lmax, ell, emm) + ix2 = crojax.alm.getidx(new_lmax, ell, emm) assert signal1[ix1] == signal2[ix2] From 582862e547b381a93193c2153596446b2281da63 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 30 May 2024 12:34:49 -0700 Subject: [PATCH 113/129] compute the euler angles correctly for both the healpy and s2fft conventions --- croissant/core/rotations.py | 3 +- croissant/jax/rotations.py | 2 +- croissant/utils.py | 84 ++++++++++++++++++++++++++++++++++--- 3 files changed, 81 insertions(+), 8 deletions(-) diff --git a/croissant/core/rotations.py b/croissant/core/rotations.py index 5b9b7b4..b579441 100644 --- a/croissant/core/rotations.py +++ b/croissant/core/rotations.py @@ -33,7 +33,8 @@ def __init__( rot : sequence of floats Euler angles in degrees (or radians if deg=False) describing the rotation. The order of the angles depends on the value of - eulertype. + ``eulertype''. When ``eulertype'' is "ZYX", the angles are + (yaw, -pitch, roll). coord : sequence of strings Coordinate systems to rotate between. Supported values are "G" (galactic), "C" (equatorial), "E" (ecliptic), "M" (MCMF), diff --git a/croissant/jax/rotations.py b/croissant/jax/rotations.py index b0f29a3..21363d8 100644 --- a/croissant/jax/rotations.py +++ b/croissant/jax/rotations.py @@ -30,7 +30,7 @@ def rotate_alm(alm, from_frame, to_frame, dl_array=None): """ rmat = get_rot_mat(from_frame, to_frame) - euler = rotmat_to_euler(rmat) + euler = rotmat_to_euler(rmat, eulertype="ZYZ") lmax = lmax_from_shape(alm.shape) alm_rot = rotate_flms(alm, lmax + 1, euler, dl_array=dl_array) return alm_rot diff --git a/croissant/utils.py b/croissant/utils.py index 1e40cd1..548d014 100644 --- a/croissant/utils.py +++ b/croissant/utils.py @@ -65,7 +65,43 @@ def get_rot_mat(from_frame, to_frame): return rmat -def rotmat_to_euler(mat): +def rotmat_to_euler(mat, eulertype="ZYX"): + """ + Convert a rotation matrix to Euler angles in the specified convention. + + Parameters + ---------- + mat : np.ndarray + The rotation matrix. + eulertype : str, either ``ZYX'' or ``ZYZ''. + The Euler angle convention to use. + + Returns + ------- + eul : tup + The Euler angles in the specified convention. + + Notes + ----- + ``ZYX'' is the default healpy convention, what you would make ``rot'' + when you call healpy.Rotator(rot, euletype="ZYX"). Wikipedia refers + to this as Tait-Bryan angles X1-Y2-Z3. + + ``ZYZ'' is the convention typically used for Wigner D matrices, which + s2fft uses. Wkipidia calls it Euler angles Z1-Y2-Z3. This would be + used in s2fft.utils.rotation.rotate_flms. + + + """ + if eulertype == "ZYX": + return rotmat_to_eulerZYX(mat) + elif eulertype == "ZYZ": + return rotmat_to_eulerZYZ(mat) + else: + raise ValueError("Invalid Euler angle convention.") + + +def rotmat_to_eulerZYX(mat): """ Convert a rotation matrix to Euler angles in the ZYX convention. This is sometimes referred to as Tait-Bryan angles X1-Y2-Z3. @@ -78,15 +114,50 @@ def rotmat_to_euler(mat): Returns -------- eul : tup - The Euler angles. + The Euler angles in the order yaw, -pitch, roll. This is the input + healpy.rotator.Rotator expects when ``eulertype'' is ZYX. """ - beta = np.arcsin(mat[0, 2]) - alpha = np.arctan2(mat[1, 2] / np.cos(beta), mat[2, 2] / np.cos(beta)) - gamma = np.arctan2(mat[0, 1] / np.cos(beta), mat[0, 0] / np.cos(beta)) - eul = (gamma, beta, alpha) + beta = -np.arcsin(mat[0, 2]) # pitch + cb = np.cos(beta) + if np.abs(cb) > 1e-10: # can divide by cos(beta) + gamma = np.arctan2(mat[1, 2] / cb, mat[2, 2] / cb) # roll + alpha = np.arctan2(mat[0, 1] / cb, mat[0, 0] / cb) # yaw + # else: cos(beta) = 0, sensitive only to alpha+gamma or alpha-gamma; + # this is called gimbal lock. We take gamma = 0. + else: + gamma = 0 + alpha = np.arctan2(-mat[1, 0], mat[1, 1]) + + eul = (alpha, -beta, gamma) # healpy convention for ZYX + return eul + + +def rotmat_to_eulerZYZ(mat): + """ + Convert a rotation matrix to Euler angles in the ZYZ convention. This is + sometimes referred to as Euler angles Z1-Y2-Z3. + + Parameters + ---------- + mat : np.ndarray + The rotation matrix. + + Returns + -------- + eul : tup + The Euler angles in the order alpha, beta, gamma. This is the input + s2fft.utils.rotation.rotate_flms expects. + + """ + alpha = np.arctan2(mat[1, 2], mat[0, 2]) + cos_beta = mat[2, 2] + beta = np.arctan2(np.sqrt(1 - cos_beta**2), cos_beta) + gamma = np.arctan2(mat[2, 1], -mat[2, 0]) + eul = (alpha, beta, gamma) return eul + def hp_npix2nside(npix): """ Calculate the nside of a HEALPix map from the number of pixels. @@ -105,6 +176,7 @@ def hp_npix2nside(npix): nside = int(np.sqrt(npix / 12)) return nside + def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): """ Generate an array of evenly sampled times to run the simulation at. From 5669b0cc955e3177cec54284ea91b25ffe167951 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 30 May 2024 12:35:00 -0700 Subject: [PATCH 114/129] initial commit --- croissant/jax/tests/test_rotations.py | 41 +++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 croissant/jax/tests/test_rotations.py diff --git a/croissant/jax/tests/test_rotations.py b/croissant/jax/tests/test_rotations.py new file mode 100644 index 0000000..6e43f4f --- /dev/null +++ b/croissant/jax/tests/test_rotations.py @@ -0,0 +1,41 @@ +import healpy as hp +import numpy as np +import pytest +from s2fft.sampling.reindex import flm_2d_to_hp_fast +from s2fft.utils.signal_generator import generate_flm +from croissant.jax import rotations + +rng = np.random.default_rng(seed=0) +pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) + + +def test_rotate_alm(lmax): + alm = generate_flm(rng, lmax + 1, reality=True) + + # galactic -> equatorial + alm_rot = rotations.rotate_alm(alm, "galactic", "fk5") + # need to convert to healpy ordering + alm_hp = np.array(flm_2d_to_hp_fast(alm, lmax + 1)) + alm_rot_hp = np.array(flm_2d_to_hp_fast(alm_rot, lmax + 1)) + rot = hp.Rotator(coord=["G", "C"]) + assert np.allclose(alm_rot_hp, rot.rotate_alm(alm_hp)) + + # equatorial -> galactic + alm_rot = rotations.rotate_alm(alm, "fk5", "galactic") + alm_rot_hp = np.array(flm_2d_to_hp_fast(alm_rot, lmax + 1)) + rot = hp.Rotator(coord=["C", "G"]) + assert np.allclose(alm_rot_hp, rot.rotate_alm(alm_hp)) + + # galactic to mcmf + # alm_rot = rotations.rotate_alm(alm, "galactic", "mcmf") + # XXX this is not implemented in healpy + # assert np.allclose(alm_rot, expected) # XXX + + # topo to equatorial XXX + # topo to mcmf XXX + + # check that inverse works + alm_rot = rotations.rotate_alm(alm, "galactic", "fk5") + assert np.allclose(alm, rotations.rotate_alm(alm_rot, "fk5", "galactic")) + alm_rot = rotations.rotate_alm(alm, "galactic", "mcmf") + assert np.allclose(alm, rotations.rotate_alm(alm_rot, "mcmf", "galactic")) From 45338f80807a6140f00fa7e372f9ec37431a4bbb Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 31 May 2024 11:55:28 -0700 Subject: [PATCH 115/129] make constants.sideral_day a dictionary --- croissant/constants.py | 2 ++ croissant/core/healpix.py | 9 +-------- 2 files changed, 3 insertions(+), 8 deletions(-) diff --git a/croissant/constants.py b/croissant/constants.py index 767549c..c472bf6 100644 --- a/croissant/constants.py +++ b/croissant/constants.py @@ -6,5 +6,7 @@ # https://nssdc.gsfc.nasa.gov/planetary/factsheet/moonfact.html sidereal_day_moon = 655.720 * 3600 +sidereal_day = {"earth": sidereal_day_earth, "moon": sidereal_day_moon} + Y00 = 1 / sqrt(4 * pi) # the 0,0 spherical harmonic function PIX_WEIGHTS_NSIDE = (32, 64, 128, 512, 1024, 2048, 4096) diff --git a/croissant/core/healpix.py b/croissant/core/healpix.py index a285be4..9d3e9fe 100644 --- a/croissant/core/healpix.py +++ b/croissant/core/healpix.py @@ -542,14 +542,7 @@ def rot_alm_z(self, phi=None, times=None, world="moon"): """ if times is not None: - if world.lower() == "moon": - sidereal_day = constants.sidereal_day_moon - elif world.lower() == "earth": - sidereal_day = constants.sidereal_day_earth - else: - raise ValueError( - f"World must be 'moon' or 'earth', not {world}." - ) + sidereal_day = constants.sidereal_day[world] phi = 2 * np.pi * times / sidereal_day return self.rot_alm_z(phi=phi, times=None) From b779069d86e67cc3e777def7ae0fc209ff728461 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 31 May 2024 11:58:50 -0700 Subject: [PATCH 116/129] take out wrapper functions that didn't do anything, jit some functions --- croissant/jax/alm.py | 117 +++----------------------------- croissant/jax/tests/test_alm.py | 40 ----------- 2 files changed, 8 insertions(+), 149 deletions(-) diff --git a/croissant/jax/alm.py b/croissant/jax/alm.py index 6ca85e6..92bc331 100644 --- a/croissant/jax/alm.py +++ b/croissant/jax/alm.py @@ -1,111 +1,11 @@ +from functools import partial +import jax import jax.numpy as jnp -import s2fft from ..constants import Y00 -def alm2map(alm, spin=0, nside=None, sampling="mw", precomps=None, spmd=True): - """ - Construct a map on the sphere from the alm array. This is a wrapper - around s2fft.inverse provided for convenience. - - Parameters - ---------- - alm : jnp.ndarray - The alm array. Must have shape (lmax+1, 2*lmax+1). Use - jax.vmap to vectorize over multiple alms. - spin : int - Harmonic spin of the map. Must be 0 or 1. - nside : int - The nside of the healpix map to construct. Required if sampling - is "healpix". - sampling : str - Sampling scheme on the sphere. Must be in - {"mw", "mwss", "dh", "healpix"}. Passed to s2fft.inverse. - precomps : list - Precomputed values for the s2fft.inverse function. Passed to - s2fft.inverse. - spmd : bool - Map the computation over all available devices. Passed to - s2fft.inverse. - - Returns - ------- - m : jnp.ndarray - The map(s) corresponding to the alm. - - """ - L = lmax_from_shape(alm.shape) + 1 - m = s2fft.inverse_jax( - alm, - L, - spin=spin, - nside=nside, - sampling=sampling, - reality=is_real(alm), - spmd=spmd, - L_lower=0, - ) - return m - - -def map2alm( - m, - lmax, - spin=0, - nside=None, - sampling="mw", - reality=True, - precomps=None, - spmd=True, -): - """ - Construct the alm array from a map on the sphere. This is a wrapper - around s2fft.forward provided for convenience. - - Parameters - ---------- - m : jnp.ndarray - The map on the sphere. Use jax.vmap to vectorize over multiple - maps. - lmax : int - The maximum l value. Note that s2fft uses L which is lmax+1. - spin : int - Harmonic spin of the map. Must be 0 or 1. - nside : int - The nside of the healpix map. Required if sampling is "healpix". - sampling : str - Sampling scheme on the sphere. Must be in - {"mw", "mwss", "dh", "gl", "healpix"}. Passed to s2fft.forward. - reality : bool - True if the map is real-valued. Passed to s2fft.forward. - precomps : list - Precomputed values for the s2fft.forward function. Passed to - s2fft.forward. - spmd : bool - Map the computation over all available devices. Passed to - s2fft.forward. - - Returns - ------- - alm : jnp.ndarray - The alm array corresponding to the map. - - """ - L = lmax + 1 - alm = s2fft.forward_jax( - m, - L, - spin=spin, - nside=nside, - sampling=sampling, - reality=reality, - spmd=spmd, - L_lower=0, - ) - return alm - - -def total_power(alm): +@partial(jax.jit, static_argnums=(1,)) +def total_power(alm, lmax): """ Compute the integral of a signal (such as an antenna beam) given the spherical harmonic coefficients. This is needed to normalize the @@ -117,6 +17,8 @@ def total_power(alm): alm : jnp.ndarray The spherical harmonic coefficients. The last two dimensions must correspond to the ell and emm indices respectively. + lmax : int + The maximum l value. Returns ------- @@ -124,13 +26,13 @@ def total_power(alm): The total power of the signal. """ - lmax = lmax_from_shape(alm.shape) # get the index of the monopole component lix, mix = getidx(lmax, 0, 0) monopole = alm[..., lix, mix] return 4 * jnp.pi * jnp.real(monopole) * Y00 +@jax.jit def getidx(lmax, ell, emm): """ Get the index of the alm array for a given l and m. @@ -151,14 +53,11 @@ def getidx(lmax, ell, emm): m_ix : int or jnp.ndarray The m index. - Raises - ------ - IndexError - If l,m don't satisfy abs(m) <= l <= lmax. """ return ell, emm + lmax +@jax.jit def getlm(lmax, ix): """ Get the l and m corresponding to the index of the alm array. diff --git a/croissant/jax/tests/test_alm.py b/croissant/jax/tests/test_alm.py index fabe898..1e8dd85 100644 --- a/croissant/jax/tests/test_alm.py +++ b/croissant/jax/tests/test_alm.py @@ -8,46 +8,6 @@ pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) rng = np.random.default_rng(seed=0) - -@pytest.mark.parametrize("sampling", ["dh", "mw", "healpix"]) -def test_alm2map(lmax, sampling): - if sampling == "healpix": - nside = lmax // 2 - else: - nside = None - # make constant map - shape = crojax.alm.shape_from_lmax(lmax) - alm = jnp.zeros(shape, dtype=jnp.complex128) - a00 = 5 - alm = alm.at[crojax.alm.getidx(lmax, 0, 0)].set(a00) - m = crojax.alm.alm2map(alm, sampling=sampling, nside=nside) - assert jnp.allclose(m, a00 * Y00) - - # XXX compare to healpy with more complex alm - - -@pytest.mark.parametrize("sampling", ["dh", "mw", "healpix"]) -def test_map2alm(lmax, sampling): - if sampling == "healpix": - nside = lmax // 2 - else: - nside = None - # make constant map - shape = s2fft.sampling.s2_samples.f_shape( - lmax + 1, sampling=sampling, nside=nside - ) - const = 10 # constant map with value 10 - m = jnp.ones(shape, dtype=jnp.float64) * const - alm = crojax.alm.map2alm(m, lmax, sampling=sampling, nside=nside) - a00_idx = crojax.alm.getidx(lmax, 0, 0) - a00 = alm[a00_idx] - assert jnp.allclose(a00, 4 * jnp.pi * Y00 * const) - - # XXX compare to healpy with more complex map - - # XXX test that map2alm(alm2map(alm)) == alm - - def test_total_power(lmax): # make a map that is 1 everywhere so total power is 4pi: shape = crojax.alm.shape_from_lmax(lmax) From aac9f04d1d5fe808ca2b416bbb914c1acd2b159e Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 31 May 2024 14:33:25 -0700 Subject: [PATCH 117/129] make a minimal run function that can be jitted --- croissant/jax/simulator.py | 215 ++++--------------------------------- 1 file changed, 22 insertions(+), 193 deletions(-) diff --git a/croissant/jax/simulator.py b/croissant/jax/simulator.py index a4d07a4..ff0a128 100644 --- a/croissant/jax/simulator.py +++ b/croissant/jax/simulator.py @@ -3,11 +3,9 @@ import jax.numpy as jnp from .. import constants -from ..utils import hp_npix2nside -from . import alm, rotations -def rot_alm_z(lmax, times, sidereal_day=constants.sidereal_day_moon): +def rot_alm_z(lmax, N_times, delta_t, world="moon"): """ Compute the complex phases that rotate the sky for a range of times. The first time is the reference time and the phases are computed relative to @@ -17,12 +15,12 @@ def rot_alm_z(lmax, times, sidereal_day=constants.sidereal_day_moon): ---------- lmax : int The maximum ell value. - times : jnp.ndarray - The times for which to compute the phases. - sidereal_day : str - The length of a sidereal day in the same units as ``times''. Default - is the sidereal day of the Moon, see constants.py for the sidereal - day of the Earth. + N_times : int + The number of times to compute the convolution at. + delta_t : float + The time difference between the times. + world : str + ``earth'' or ``moon''. Default is ``moon''. Returns ------- @@ -31,14 +29,16 @@ def rot_alm_z(lmax, times, sidereal_day=constants.sidereal_day_moon): Shape (N_times, 2*lmax+1). """ - dt = times - times[0] # time difference from reference - phi = 2 * jnp.pi * dt / sidereal_day # rotation angle + day = constants.sidereal_day[world] + dt = jnp.arange(N_times) * delta_t + phi = 2 * jnp.pi * dt / day # rotation angle emms = jnp.arange(-lmax, lmax + 1) # m values phases = jnp.exp(-1j * emms[None] * phi[:, None]) return phases -def convolve(beam_alm, sky_alm, phases): +@partial(jax.jit, static_argnums=(2, 5)) +def convolve(beam_alm, sky_alm, lmax, N_times, delta_t, world="moon"): """ Compute the convolution for a range of times in jax. The convolution is a dot product in l,m space. Axes are in the order: time, freq, ell, emm. @@ -50,129 +50,14 @@ def convolve(beam_alm, sky_alm, phases): normalized to have total power of unity. sky_alm : jnp.ndarray The sky alms. Shape (N_freqs, lmax+1, 2*lmax+1). - phases : jnp.ndarray - The phases that rotate the sky, of the form exp(-i*m*phi(t)). - Shape (N_times, 2*lmax+1). - - Returns - ------- - res : jnp.ndarray - The convolution. Shape (N_times, N_freqs). - """ - s = sky_alm[None, :, :, :] # add time axis - p = phases[:, None, None, :] # add freq and ell axes - b = beam_alm.conjugate()[None, :, :, :] # add time axis and conjugate - res = jnp.sum(s * p * b, axes=(2, 3)) # dot product in l,m space - return res - - -def _spht_wrapper(m, lmax, sampling): - """ - Wrapper for the spherical harmonic transform. This function is called - by ``run'' to compute the spherical harmonic transform of the beam and - sky. - - Parameters - ---------- - m : jnp.ndarray - The maps on the sphere with a frequency axis. - lmax : int - The maximum ell value. - sampling : str - The sampling scheme. Supported sampling schemes are ``mw'', ``mwss'', - ``dh'', ```gl'' and ``healpix''. See s2fft documentation for more - information. - - Returns - ------- - alm : jnp.ndarray - The spherical harmonic coefficients. - - """ - if sampling == "healpix": - npix = m.shape[-1] - nside = hp_npix2nside(npix) - else: - nside = None - # arguments for map2alm - args = { - "lmax": lmax, - "spin": 0, - "nside": nside, - "sampling": sampling, - "reality": True, - "precomps": None, - "spmd": True, - } - return jax.vmap(partial(alm.map2alm, **args))(m) - - -def run( - beam, - sky, - lmax, - beam_type="dh", - beam_coords="topocentric", - normalize_beam=True, - sky_type="healpix", - sky_coords="galactic", - world="moon", - location=None, - times=None, - nfreqs=1, -): - """ - Run the simulation in jax. The beam and sky could each be maps on the - sphere or spherical harmonic coefficients. This is specified by the - ``beam_type'' and ``sky_type'' arguments; if maps on the sphere, this - should be the sampling scheme used. - - The shapes of the arrays depend on if they are alms or maps on the sphere - (in which caase the shape also depends on the sampling scheme). See - the functions ``f_shape'' and ``flm_shape'' in - ``s2fft.sampling.s2_samples''. - - The beam and sky could be specified at several frequencies (or any other - batch dimension). This needs to be the axis 0 of the input arrays. In - this case, the argument ``nfreqs'' must be set accordingly. - - Parameters - ---------- - beam : jnp.ndarray - The beam maps or alms. - sky : jnp.ndarray - The sky maps or alms. lmax : int - The maximum ell value (inclusive). - beam_type : str - Must be ``alm'' or a sampling shceme. Supported sampling schemes are - ``mw'', ``mwss'', ``dh'', ```gl'' and ``healpix''. Default is ``dh'', - which is equiangular sampling. See s2fft documentation for more - information. - beam_coords : str - The coordinate system of the beam. Default is ``topocentric''. - Other options are ``equatorial'' (earth) and ``mcmf'' (moon). - normalize_beam : bool - Whether to normalize the beam to have total power of unity. Default is - True. - sky_type : str - Must be ``alm'' or a sampling shceme. Supported sampling schemes are - ``mw'', ``mwss'', ``dh'', ```gl'' and ``healpix''. Default is - ``healpix''. See s2fft documentation for more information. - sky_coords : str - The coordinate system of the sky. Default is ``galactic''. Other - options are ``equatorial'' (earth) and ``mcmf'' (moon). + The maximum ell value of the alms. + N_times : int + The number of times to compute the convolution at. + delta_t : float + The time difference between the times. world : str ``earth'' or ``moon''. Default is ``moon''. - location : astropy.coordinates.EarthLocation or lunrsky.MoonLocation - The location of the observer. Required if beam_coords is - ``topocentric''. - times : astropy.time.Time or lunarsky.Time or list of these - The times for which to compute the convolution. Required if - beam_coords is ``topocentric''. See ``utils.time_array'' for a - convenient way to generate evenly spaced times. - nfreqs : int - The number of frequencies. Default is 1. Returns ------- @@ -180,65 +65,9 @@ def run( The convolution. Shape (N_times, N_freqs). """ - # add frequency axis - if nfreqs == 1: - beam = beam[None] - sky = sky[None] - # beam spherical harmonic transform - if beam_type == "alm": - beam_alm = beam - else: - beam_alm = _spht_wrapper(beam, lmax, beam_type) - - # get the reference time - try: - t0 = times[0] # times is a list - ntimes = len(times) - except IndexError: - t0 = times # times is a single time - ntimes = 1 - except TypeError: - ntimes = 0 # times is None - - # beam coordinate transformation if topocentric - if beam_coords == "topocentric": - args = {"loc": location, "time": t0, "dl_array": None} - if world == "earth": - func = rotations.topo2eq - elif world == "moon": - func = rotations.topo2mcmf - else: - raise ValueError("world must be 'earth' or 'moon'") - beam_alm = jax.vmap(partial(func, **args))(beam_alm) - - # normalize beam - if normalize_beam: - norm = alm.total_power(beam_alm) - beam_alm /= norm - - # sky spherical harmonic transform - if sky_type == "alm": - sky_alm = sky - else: - sky_alm = _spht_wrapper(sky, lmax, sky_type) - - # sky coordinate transformation if galactic - if sky_coords == "galactic": - sky_alm = jax.vmap(rotations.gal2eq)(sky_alm) - - # compute the phases that rotate the sky - if ntimes < 2: - phases = jnp.array([1.0]) - else: - t_sec = jnp.array([t.to_value("unix") for t in times]) - if world == "earth": - sidereal_day = constants.sidereal_day_earth - elif world == "moon": - sidereal_day = constants.sidereal_day_moon - else: - raise ValueError("world must be 'earth' or 'moon'") - phases = rot_alm_z(lmax, t_sec, sidereal_day=sidereal_day) - - # compute the convolution - res = convolve(beam_alm, sky_alm, phases) + phases = rot_alm_z(lmax, N_times, delta_t, world=world) + s = sky_alm[None, :, :, :] # add time axis + p = phases[:, None, None, :] # add freq and ell axes + b = beam_alm.conjugate()[None, :, :, :] # add time axis and conjugate + res = jnp.sum(s * p * b, axes=(2, 3)) # dot product in l,m space return res From b43715d5e2d5787b9d8c243d319128134d987829 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 31 May 2024 14:33:37 -0700 Subject: [PATCH 118/129] syntax --- croissant/jax/tests/test_alm.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/croissant/jax/tests/test_alm.py b/croissant/jax/tests/test_alm.py index 1e8dd85..3ca3077 100644 --- a/croissant/jax/tests/test_alm.py +++ b/croissant/jax/tests/test_alm.py @@ -14,7 +14,7 @@ def test_total_power(lmax): alm = jnp.zeros(shape, dtype=jnp.complex128) a00_idx = crojax.alm.getidx(lmax, 0, 0) alm = alm.at[a00_idx].set(1 / Y00) - power = crojax.alm.total_power(alm) + power = crojax.alm.total_power(alm, lmax) assert jnp.isclose(power, 4 * jnp.pi) # m(theta) = cos(theta)**2 @@ -22,7 +22,7 @@ def test_total_power(lmax): alm = alm.at[a00_idx].set(1 / (3 * Y00)) a20_idx = crojax.alm.getidx(lmax, 2, 0) alm = alm.at[a20_idx].set(4 * jnp.sqrt(jnp.pi / 5) * 1 / 3) - power = crojax.alm.total_power(alm) + power = crojax.alm.total_power(alm, lmax) expected_power = 4 * jnp.pi / 3 assert jnp.isclose(power, expected_power) From e85b2ba65046e612c5f0a12db48dcfc664a1e483 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Sat, 1 Jun 2024 16:58:47 -0700 Subject: [PATCH 119/129] change rotation.py to generate euler angles and wigner functions, which are passed to s2fft --- croissant/jax/rotations.py | 128 ++++--------------------------------- 1 file changed, 12 insertions(+), 116 deletions(-) diff --git a/croissant/jax/rotations.py b/croissant/jax/rotations.py index 21363d8..8905908 100644 --- a/croissant/jax/rotations.py +++ b/croissant/jax/rotations.py @@ -1,134 +1,30 @@ -from astropy.coordinates import AltAz -from lunarsky import LunarTopo -from s2fft import rotate_flms +from s2fft import generate_rotate_dls from ..utils import get_rot_mat, rotmat_to_euler -from .alm import lmax_from_shape -def rotate_alm(alm, from_frame, to_frame, dl_array=None): +def generate_euler_dl(lmax, from_frame, to_frame): """ - Transform a spherical harmonic decomposition from one coordinate system to - another. This is a wrapper around the s2fft.rotate_flms function that - computes the Euler angles from the input and output coordinate systems. + Generate the Euler angles and reduced Wigner d-function values for a + coordinate transformation. Parameters ---------- - alm : jnp.ndarray - The alm array to transform. + lmax : int + The maximum spherical harmonic degree. from_frame : str or astropy frame The coordinate system of the input alm. to_frame : str or astropy frame The coordinate system of the output alm. - dl_array : jnp.ndarray - Precomputed array of reduced Wigner d-function values. These - can be computed with the s2fft.generate_rotate_dls function. Returns ------- - alm_rot : jnp.ndarray - The alm array in the ``to_frame'' coordinate system. + euler : jnp.ndarray + The Euler angles for the coordinate transformation. + dl_array : jnp.ndarray + The reduced Wigner d-function values for the coordinate transformation. """ rmat = get_rot_mat(from_frame, to_frame) euler = rotmat_to_euler(rmat, eulertype="ZYZ") - lmax = lmax_from_shape(alm.shape) - alm_rot = rotate_flms(alm, lmax + 1, euler, dl_array=dl_array) - return alm_rot - - -def gal2eq(alm, dl_array=None): - """ - Transform a spherical harmonic decomposition from Galactic to Equatorial - coordinates. - - Parameters - ---------- - alm : jnp.ndarray - The alm array to transform. - dl_array : jnp.ndarray - Precomputed array of reduced Wigner d-function values. These - can be computed with the s2fft.generate_rotate_dls function. - - Returns - ------- - alm_rot : jnp.ndarray - The alm array in Equatorial coordinates. - - """ - return rotate_alm(alm, "galactic", "fk5", dl_array=dl_array) - - -def gal2mcmf(alm, dl_array=None): - """ - Transform a spherical harmonic decomposition from Galactic to MCMF - coordinates (moon equivalent of equatorial coordinates). - - Parameters - ---------- - alm : jnp.ndarray - The alm array to transform. - dl_array : jnp.ndarray - Precomputed array of reduced Wigner d-function values. These - can be computed with the s2fft.generate_rotate_dls function. - - Returns - ------- - alm_rot : jnp.ndarray - The alm array in MCMF coordinates. - - """ - return rotate_alm(alm, "galactic", "mcmf", dl_array=dl_array) - - -def topo2eq(alm, loc, time, dl_array=None): - """ - Transform a spherical harmonic decomposition from topocentric on Earth to - equatorial coordinates. - - Parameters - ---------- - alm : jnp.ndarray - The alm array to transform. - loc : astropy.coordinates.EarthLocation - The location of the observer. - time : astropy.time.Time - The time of the observation. - dl_array : jnp.ndarray - Precomputed array of reduced Wigner d-function values. These - can be computed with the s2fft.generate_rotate_dls function. - - Returns - ------- - alm_rot : jnp.ndarray - The alm array in Equatorial coordinates. - - """ - topo = AltAz(location=loc, obstime=time) - return rotate_alm(alm, topo, "fk5", loc, time, dl_array=dl_array) - - -def topo2mcmf(alm, loc, time, dl_array=None): - """ - Transform a spherical harmonic decomposition from topocentric on Moon to - equatorial coordinates. - - Parameters - ---------- - alm : jnp.ndarray - The alm array to transform. - loc : lunarsky.MoonLocation - The location of the observer. - time : lunarsky.Time - The time of the observation. - dl_array : jnp.ndarray - Precomputed array of reduced Wigner d-function values. These - can be computed with the s2fft.generate_rotate_dls function. - - Returns - ------- - alm_rot : jnp.ndarray - The alm array in MCMF coordinates. - - """ - topo = LunarTopo(location=loc, obstime=time) - return rotate_alm(alm, topo, "mcmf", loc, time, dl_array=dl_array) + dl_array = generate_rotate_dls(lmax, euler[1]) + return euler, dl_array From 16d3e054d88a2bf01ab122a5ed23ebf339f12b6e Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Sat, 1 Jun 2024 16:59:36 -0700 Subject: [PATCH 120/129] use rot_alm_z to generate phases, make convolve very minimal + syntax --- croissant/jax/simulator.py | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) diff --git a/croissant/jax/simulator.py b/croissant/jax/simulator.py index ff0a128..3973498 100644 --- a/croissant/jax/simulator.py +++ b/croissant/jax/simulator.py @@ -1,4 +1,3 @@ -from functools import partial import jax import jax.numpy as jnp @@ -37,8 +36,8 @@ def rot_alm_z(lmax, N_times, delta_t, world="moon"): return phases -@partial(jax.jit, static_argnums=(2, 5)) -def convolve(beam_alm, sky_alm, lmax, N_times, delta_t, world="moon"): +@jax.jit +def convolve(beam_alm, sky_alm, phases): """ Compute the convolution for a range of times in jax. The convolution is a dot product in l,m space. Axes are in the order: time, freq, ell, emm. @@ -50,14 +49,9 @@ def convolve(beam_alm, sky_alm, lmax, N_times, delta_t, world="moon"): normalized to have total power of unity. sky_alm : jnp.ndarray The sky alms. Shape (N_freqs, lmax+1, 2*lmax+1). - lmax : int - The maximum ell value of the alms. - N_times : int - The number of times to compute the convolution at. - delta_t : float - The time difference between the times. - world : str - ``earth'' or ``moon''. Default is ``moon''. + phases : jnp.ndarray + The phases that rotate the sky, of the form exp(-i*m*phi(t)). + Shape (N_times, 2*lmax+1). See the function ``rot_alm_z''. Returns ------- @@ -65,9 +59,8 @@ def convolve(beam_alm, sky_alm, lmax, N_times, delta_t, world="moon"): The convolution. Shape (N_times, N_freqs). """ - phases = rot_alm_z(lmax, N_times, delta_t, world=world) s = sky_alm[None, :, :, :] # add time axis p = phases[:, None, None, :] # add freq and ell axes b = beam_alm.conjugate()[None, :, :, :] # add time axis and conjugate - res = jnp.sum(s * p * b, axes=(2, 3)) # dot product in l,m space + res = jnp.sum(s * p * b, axis=(2, 3)) # dot product in l,m space return res From abe6d3a23df8b7f31e52191c5f49957b8003e067 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Sat, 1 Jun 2024 17:00:00 -0700 Subject: [PATCH 121/129] initial commit --- notebooks/croissant_jax.ipynb | 202 ++++++++++++++++++++++++++++++++++ 1 file changed, 202 insertions(+) create mode 100644 notebooks/croissant_jax.ipynb diff --git a/notebooks/croissant_jax.ipynb b/notebooks/croissant_jax.ipynb new file mode 100644 index 0000000..14bd2da --- /dev/null +++ b/notebooks/croissant_jax.ipynb @@ -0,0 +1,202 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "9f3469f3-959d-4e39-8ef1-8432975e6f7f", + "metadata": {}, + "outputs": [], + "source": [ + "import croissant as cro\n", + "import croissant.jax as crojax\n", + "from functools import partial\n", + "from healpy import get_nside, projview\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import lunarsky\n", + "import matplotlib.pyplot as plt\n", + "from pygdsm import GlobalSkyModel16 as GSM16\n", + "import s2fft" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "223b215e-1342-4c0b-aa1a-cd175fe31cba", + "metadata": {}, + "outputs": [], + "source": [ + "# simulation parameters\n", + "world = \"moon\"\n", + "L = 180 # maximal harmonic band limit given sampling of beam\n", + "freq = jnp.arange(11, 51) # 11-50 MHz\n", + "time = lunarsky.Time(\"2025-12-01 09:00:00\") # time at the beginning of the simulation\n", + "loc = lunarsky.MoonLocation(lon=0, lat=-22.5) # location of telescope\n", + "topo = lunarsky.LunarTopo(obstime=time, location=loc) # coordinate frame of telescope\n", + "# 24 bins in a sidereal day on the moon\n", + "ntimes = 240\n", + "dt = cro.constants.sidereal_day[world] / ntimes\n", + "phases = crojax.simulator.rot_alm_z(L-1, ntimes, dt, world=world)\n", + "\n", + "# get the euler angles and wigner d functions for the coordinate transforms\n", + "eul_topo, dl_topo = crojax.rotations.generate_euler_dl(L-1, topo, \"mcmf\") # beam transform, from topocentric to mcmf\n", + "eul_gal, dl_gal = crojax.rotations.generate_euler_dl(L-1, \"galactic\", \"mcmf\") # sky transform, from galactic to mcmf\n", + "\n", + "topo2mcmf = partial(s2fft.utils.rotation.rotate_flms, L=L, rotation=eul_topo, dl_array=dl_topo)\n", + "gal2mcmf = partial(s2fft.utils.rotation.rotate_flms, L=L, rotation=eul_gal, dl_array=dl_gal)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f2e8e12b-fbd7-4c25-9a97-39d863b3820e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "etheta, ephi = jnp.load(\"lusee_beam.npy\")[:, 10:, :, :-1]\n", + "beam = jnp.abs(etheta)**2 + jnp.abs(ephi)**2 # power beam\n", + "# add horizon\n", + "beam = jnp.concatenate((beam, jnp.zeros_like(beam)[:, :-1, :]), axis=1)\n", + "plt.figure()\n", + "plt.imshow(beam[30], aspect=\"auto\")\n", + "plt.xlabel(\"$\\\\phi$ [deg]\")\n", + "plt.ylabel(\"$\\\\theta$ [deg]\")\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1cdb03e4-1bc0-491b-90d2-87dd8832745c", + "metadata": {}, + "outputs": [], + "source": [ + "# define the map2alm transform for the beam\n", + "beam2alm = partial(s2fft.forward_jax, L=L, spin=0, nside=None, sampling=\"mwss\", reality=True)\n", + "# use vmap t vectorize frequency axis\n", + "beam_alm = jax.vmap(beam2alm)(beam)\n", + "\n", + "# normalization for visibilities\n", + "norm = crojax.alm.total_power(beam_alm, L-1)[:, None, None]\n", + "beam_alm /= norm" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f1b916b6-161f-484f-a621-534d27310fda", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# sky\n", + "gsm = GSM16(freq_unit=\"MHz\", data_unit=\"TRJ\", resolution=\"lo\")\n", + "sky_map = gsm.generate(freq)\n", + "ix = -6\n", + "projview(m=sky_map[ix], title=f\"GSM at {freq[ix]} MHz\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "91f2b69f-103c-4471-86de-711448abb1d0", + "metadata": {}, + "outputs": [], + "source": [ + "# define the map2alm transform for the sky\n", + "sky2alm = partial(s2fft.forward_jax, L=L, spin=0, nside=get_nside(sky_map[0]), sampling=\"healpix\", reality=True)\n", + "sky_alm = jax.vmap(sky2alm)(sky_map)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fdf352d3-b46a-4477-ad14-799e2f970ed5", + "metadata": {}, + "outputs": [], + "source": [ + "# coordinate transform\n", + "beam_alm = jax.vmap(topo2mcmf)(beam_alm)\n", + "sky_alm = jax.vmap(gal2mcmf)(sky_alm)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0c1a8329-b180-4a52-852f-72149c7adca3", + "metadata": {}, + "outputs": [], + "source": [ + "vis = crojax.simulator.convolve(beam_alm, sky_alm, phases).real" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "25e7ec10-c915-4fee-b528-3e5b784583ce", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.imshow(vis, aspect=\"auto\")\n", + "plt.colorbar()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a6c7ace5ea863dc9640f378c3e3a0ea1bed1583a Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Sat, 1 Jun 2024 17:00:24 -0700 Subject: [PATCH 122/129] delete old example notebook --- notebooks/jax_example.ipynb | 450 ------------------------------------ 1 file changed, 450 deletions(-) delete mode 100644 notebooks/jax_example.ipynb diff --git a/notebooks/jax_example.ipynb b/notebooks/jax_example.ipynb deleted file mode 100644 index 7883dd2..0000000 --- a/notebooks/jax_example.ipynb +++ /dev/null @@ -1,450 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "6a05778f", - "metadata": {}, - "outputs": [], - "source": [ - "import jax\n", - "import jax.numpy as jnp\n", - "jax.config.update(\"jax_enable_x64\", True)\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "from astropy.time import Time\n", - "from astropy.units import s as seconds\n", - "import s2fft\n", - "from healpy import mollview\n", - "from croissant import crojax\n", - "from croissant import constants\n", - "from croissant.simulatorbase import time_array" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "2348797a", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "True\n", - "(41, 129, 257)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# simple beam in topocentric coordinates\n", - "lmax = 128\n", - "freq = jnp.linspace(40, 80, 41)\n", - "beam = crojax.Beam.zeros(lmax, frequencies=freq, coord=\"T\")\n", - "\n", - "# set (l=0, m=0) and (l=1, m=0) mode\n", - "beam[:, 0, 0] = 30 * (freq/freq[0]) ** 2\n", - "beam[:, 1, 0] = 10 * (freq/freq[0])**2\n", - "print(beam.is_real)\n", - "\n", - "# visualize\n", - "nside = None\n", - "sampling = \"mw\" # mw, mwss, dh, healpix\n", - "if sampling == \"healpix\":\n", - " nside = 2 * lmax\n", - "m = beam.alm2map(sampling=sampling, nside=nside, frequencies=freq)\n", - "print(m.shape)\n", - "if sampling == \"healpix\":\n", - " mollview(m[0])\n", - "else:\n", - " plt.figure()\n", - " plt.imshow(m[0], aspect=\"auto\")\n", - " plt.colorbar()\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "bd23f9db-6922-4364-a6bc-83aa23cb5232", - "metadata": {}, - "outputs": [], - "source": [ - "# precompute ..." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "3be26219", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgsAAAGhCAYAAADvMPfbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAw+ElEQVR4nO3de3DU9b3/8dcGySYiuzEguWjA6KECgqAiacR6oGSEFC0caRVPOidSB1pNVIxHMR1uUjWCjmW4FKrTAzgHvE0FLafiUBByqCFCIq14QdAUcpQNrTRZCE0Iu5/fH8j+XAkbku83m+9uno+Z7wz7vX72Y+Lnnffn8nUZY4wAAADOIaGrCwAAAJyNYAEAAEREsAAAACIiWAAAABERLAAAgIgIFgAAQEQECwAAICKCBQAAEBHBAgAAiIhgAQAARNSlwcLy5ct1+eWXKykpSTk5OXrvvfe6sjgAAKAVXRYsvPLKKyopKdG8efNUXV2t4cOHa/z48Tpy5EhXFQkAALTC1VUvksrJydENN9ygZcuWSZKCwaCysrJ0//3367HHHot4bTAY1JdffqnevXvL5XJFo7gAgBhljNGxY8eUmZmphITO+xu5qalJJ0+etHyfxMREJSUl2VAi+1zQFQ89efKkqqqqVFpaGtqXkJCgvLw8VVRUnHV+c3OzmpubQ5+/+OILDRkyJCplBQDEh9raWl122WWdcu+mpiZlD7hIviMBy/dKT09XTU2NowKGLgkW/v73vysQCCgtLS1sf1pamj755JOzzi8rK9Pjjz9+1v6D1ZfLcxFjNAEA5+Y/HtSA6/6q3r17d9ozTp48Kd+RgGqqBsjTu+Ptkv9YUNnXH9TJkycJFtqrtLRUJSUloc9+v19ZWVnyXJRg6T8KAKD7iEa3tad3fLZLXRIs9O3bVz169FBdXV3Y/rq6OqWnp591vtvtltvtjlbxAADokIAJKmBhJGDABO0rjI26JPxJTEzU9ddfry1btoT2BYNBbdmyRbm5uV1RJAAALAvKWN6cqMu6IUpKSlRYWKiRI0dq1KhRWrx4sRobGzVt2rSuKhIAAJYEFZSV3IC1qztPlwULd955p/72t79p7ty58vl8GjFihDZt2nTWoEcAANC1unSAY3FxsYqLi7uyCAAA2CZgjAIWli+ycm1nionZEAAAxAKr4w6cOmYh/uZ3AAAAW5FZAADAJkEZBeIws0CwAACATeiGAAAA3RKZBQAAbMJsCAAAEFHw683K9U5ENwQAAIgopjMLVl/YAQCIf9F8OVPA4mwIK9d2ppgOFgAAcJKAkcW3TtpXFjsRLAAAYBPGLAAAgG6JzAIAADYJyqWAXJaudyKCBQAAbBI0pzcr1zsR3RAAACCimM4sWF2DGwAQ/6LZTgQsdkNYubYzxXSwAACAk8RrsEA3BAAAiIjMAgAANgkal4LGwmwIC9d2JoIFAABsEq/dEDEdLAQVdOxqVwAAZ6ClsC6mgwUAAJwkoAQFLAwHDNhYFjsRLAAAYBNjccyCYcwCAADxLV7HLDB1EgAARBTTmYWAMQoYVnAEAJxbNNuJgElQwFgYs9DOopaXl+uZZ55RVVWVDh8+rPXr12vy5MmSpJaWFs2ePVt/+MMf9Pnnn8vr9SovL09PP/20MjMz2/UcMgsAANgkKJeCSrCwta8borGxUcOHD9fy5cvPOnbixAlVV1drzpw5qq6u1uuvv659+/bphz/8Ybu/V0xnFgAA6M7y8/OVn5/f6jGv16vNmzeH7Vu2bJlGjRqlQ4cOqX///uf9HIIFAABsYtcAR7/fH7bf7XbL7XZbKpskNTQ0yOVyKSUlpV3XxXSwwKJMAIC2RLOlsD5m4fSghaysrLD98+bN0/z5860UTU1NTZo1a5buuusueTyedl0b08ECAADxqLa2NqxBt5pVaGlp0R133CFjjFasWNHu6wkWAACwyekBjhZeJPX1tR6Pp91//Z/LmUDh4MGD2rp1a4fuS7AAAIBNghaXew7K3mmeZwKF/fv365133lGfPn06dJ+YDhYCMgrYXLEAgPgSz+3E8ePHdeDAgdDnmpoa7dmzR6mpqcrIyNCPfvQjVVdXa+PGjQoEAvL5fJKk1NRUJSYmnvdzYjpYAADASewa4Hi+du/erbFjx4Y+l5SUSJIKCws1f/58vfnmm5KkESNGhF33zjvvaMyYMef9HIIFAABscmZxpY5f375gYcyYMTIRAoxIx9qDYAEAAJsEjEsBC2+OtHJtZ4rpYMEYoyDvhgAARGDXX9fdWUwHCwAAOEnA4mwIpw7GJFgAAMAmQZOgoIUBjk7Nlsd0sMDUSQBAW2gnrIvpYAEAACehGwIAAEQUlLUZDU59OWJMBwtBObdiAQDOQDthXUwHCwAAOIn1RZk6fm1nIlgAAMAm1pd77ibBQllZmV5//XV98sknSk5O1o033qiFCxfqqquuCp3T1NSkhx9+WC+//LKam5s1fvx4/frXv1ZaWlq7nhUwpt3raAMAuhfaCetsD2G2b9+uoqIi7dy5U5s3b1ZLS4tuueUWNTY2hs556KGH9Pvf/16vvfaatm/fri+//FK333673UUBACCqgnJZ3pzI9szCpk2bwj6vXr1a/fr1U1VVlW6++WY1NDTot7/9rdatW6fvf//7kqRVq1Zp8ODB2rlzp7773e+e97MCX28AAJxLNNsJuiE6qKGhQdLpd2dLUlVVlVpaWpSXlxc6Z9CgQerfv78qKipaDRaam5vV3Nwc+uz3+zu51AAAtJ/1dRacGSx0aqmCwaBmzpyp0aNHa+jQoZIkn8+nxMREpaSkhJ2blpYmn8/X6n3Kysrk9XpDW1ZWVmcWGwAAfEOnZhaKioq0d+9e7dixw9J9SktLVVJSEvrs9/uVlZXFOgsAgDZFs50IGpeCVhZl6m6vqC4uLtbGjRtVXl6uyy67LLQ/PT1dJ0+eVH19fVh2oa6uTunp6a3ey+12y+12d1ZRAQCwRdBiN4RT11mwvVTGGBUXF2v9+vXaunWrsrOzw45ff/316tmzp7Zs2RLat2/fPh06dEi5ubl2FwcAAFhke2ahqKhI69at0xtvvKHevXuHxiF4vV4lJyfL6/XqnnvuUUlJiVJTU+XxeHT//fcrNze3XTMhJClgTm8AAJxLNNsJ66+odmZmwfZgYcWKFZKkMWPGhO1ftWqV7r77bknSr371KyUkJGjKlClhizIBABDLAnIpYGGtBCvXdibbgwVzHitlJSUlafny5Vq+fLm1Z4kBjgCAyEhAW8e7IQAAsAndEA5kNd0DAIh/0WwnAhaf59RViZ0ZwgAAAMeI7cyCcSng0AUsAADOEM12gm4IAAAQES+SAgAAERmLr5k2Dh2HF9PBgpPf/Q0AcAbaCetiOlgAAMBJ6IZwIKZOAgDaEs12Il7fOunMEAYAADhGTGcWrEZwAID4F812ImDxFdVWru1MMR0sAADgJPHaDRHTwQJjFgAAbaGdsC6mgwUAAJwkqAQFLXQlWLm2M8V0sBAkswAAaEM011mw+hoCp77CwJkhDAAAcIzYzixYfGEHACD+BU00n8UARwAAEIGx+EescegfwDEdLDAbAgDQlmi2E1bbJae2ac4MYQAAgGPEeGbB2kpZAID4F4jis4LG2riDaI6vaI+YDhYAAHASqwPvnTpoP6aDhdOjTp1ZsQAAZwgah/65HkNiOlhggCMAoC1RfUW1XJYWgWrvteXl5XrmmWdUVVWlw4cPa/369Zo8eXLouDFG8+bN0wsvvKD6+nqNHj1aK1as0MCBA9v1HP4sBwDAJmdWcLSytUdjY6OGDx+u5cuXt3p80aJFWrJkiVauXKnKykr16tVL48ePV1NTU7ueE9uZBZOgAN0QAIAIAnHcDZGfn6/8/PxWjxljtHjxYs2ePVuTJk2SJL344otKS0vThg0bNHXq1PN+Di0tAAA2OTPA0comSX6/P2xrbm5ud1lqamrk8/mUl5cX2uf1epWTk6OKiop23SumMwvG4tu9AADxzyh6mYWgLC73/PWYhaysrLD98+bN0/z589t1L5/PJ0lKS0sL25+WlhY6dr5iOlgAACAe1dbWyuPxhD673e4uLE2MBwvMhgAAtCWa7YSxOBvCfH2tx+MJCxY6Ij09XZJUV1enjIyM0P66ujqNGDGiXfcihw8AgE3OvHXSymaX7Oxspaena8uWLaF9fr9flZWVys3Nbde9YjuzwGwIAEAbojkbItorOB4/flwHDhwIfa6pqdGePXuUmpqq/v37a+bMmXriiSc0cOBAZWdna86cOcrMzAxbi+F8xHSwEGSAIwCgDcEoDnCMtt27d2vs2LGhzyUlJZKkwsJCrV69Wo8++qgaGxs1Y8YM1dfX66abbtKmTZuUlJTUrufEdLAAAICTWO1KaO+1Y8aMkYmQOXG5XFqwYIEWLFjQ4TJJMR4s0A0BAGhLVLshorzcc7TEdrDAbAgAQBtoJ6yL6WABAAAniXY3RLTEdLAQlLVRpwCA+BfNAY7xGizQ0gIAgIhiPLPgUoB4BwAQQVDB6D0rTjMLMR0sdOTd3wCA7iWa7US8Bgv8WQ4AACKK6cwCKzgCANoSzXbCyNpaCU5dazKmgwUWZQIAtCWa7US8dkPEdLAAAICTECw4UEAJzIYAAEREO2FdTAcLdr/7GwAQf6LZTsRrZqHTw62nn35aLpdLM2fODO1rampSUVGR+vTpo4suukhTpkxRXV1dZxcFAIBOdSZYsLI5UadmFnbt2qXf/OY3uuaaa8L2P/TQQ/qf//kfvfbaa/J6vSouLtbtt9+uP/3pT+26P90QAIC20E5Y12nBwvHjx1VQUKAXXnhBTzzxRGh/Q0ODfvvb32rdunX6/ve/L0latWqVBg8erJ07d+q73/3ueT/DGN4NAQCIzESxnTDGJWMhO2Dl2s7UaTVYVFSkiRMnKi8vL2x/VVWVWlpawvYPGjRI/fv3V0VFRav3am5ult/vD9sAAHCaoFyWNyfqlMzCyy+/rOrqau3ateusYz6fT4mJiUpJSQnbn5aWJp/P1+r9ysrK9Pjjj5+1PyAX7ykHAEREO2Gd7cFCbW2tHnzwQW3evFlJSUm23LO0tFQlJSWhz36/X1lZWQrSDQEAaEM024l4nQ1he7BQVVWlI0eO6LrrrgvtCwQCKi8v17Jly/T222/r5MmTqq+vD8su1NXVKT09vdV7ut1uud1uu4sKAICt4nXMgu3Bwrhx4/TBBx+E7Zs2bZoGDRqkWbNmKSsrSz179tSWLVs0ZcoUSdK+fft06NAh5ebmtutZdEMAANpCO2Gd7cFC7969NXTo0LB9vXr1Up8+fUL777nnHpWUlCg1NVUej0f333+/cnNz2zUTQjqT7qEbAgBwbizKZF2XrOD4q1/9SgkJCZoyZYqam5s1fvx4/frXv+6KogAAYBu6ISzYtm1b2OekpCQtX75cy5cvt3Rf3joJAGhLNNsJYzGz0K2Dhc7i5DmpAABnoJ2wLqaDBQAAnMRIMsba9U4U08FCkG4IAEAborrOglxyWchkODULEtvBAt0QAIA20E5YF9PBAgAATsJsCAdiNgQAoC3RbCeCxiUX6yw4i9XFLwAA8Y92wrqYDhYAAHASYyzOhnDodIiYDhYCSlBAdEMAAM4tmu0EYxYciG4IAEBbaCesI1gAAMS1aLYTZBYcKEg3BACgDcEothPMhgAAABExwNGB6IYAALSFdsK6GA8WEqK65jcAIPZEs504nVmwMmbBxsLYKKaDBQAAnIQBjg4UFC8IAQBEFuzqAsSBmA4WAsalgEOjMACAM0SznTBfb1aud6KYDhYAAHASuiEciAGOAIC20E5YF+PBAlMnAQCRRbWdiNN+iNgOFuRigCMAIKKothMWuyHUzmsDgYDmz5+v//7v/5bP51NmZqbuvvtuzZ49Wy6Xfd875oMFBjgCACKJZrAQ7RUcFy5cqBUrVmjNmjW6+uqrtXv3bk2bNk1er1cPPPBAxwvyLTEdLAAA0J29++67mjRpkiZOnChJuvzyy/XSSy/pvffes/U5MR0sMMARANCW6K7gaM9sCL/fH7bf7XbL7Xafdf6NN96o559/Xp9++qm+853v6M9//rN27Nih5557rsNlaE2MBwsMcAQARBbdAY6udo87OOt6SVlZWWG7582bp/nz5591+mOPPSa/369BgwapR48eCgQCevLJJ1VQUNDxMrQitoMFBjgCANoQi+1EbW2tPB5P6HNrWQVJevXVV7V27VqtW7dOV199tfbs2aOZM2cqMzNThYWFtpUnpoMFAACcxK4Bjh6PJyxYOJdHHnlEjz32mKZOnSpJGjZsmA4ePKiysjKChTPohgAAtCWe11k4ceKEEhLCx2T06NFDwaC9b8QgWAAAxLV4biduu+02Pfnkk+rfv7+uvvpqvf/++3ruuef005/+1NbnECwAAOJaNNuJaL8bYunSpZozZ47uu+8+HTlyRJmZmfrZz36muXPndrgMrYnxYIGpkwCAyKLeTkRxyebevXtr8eLFWrx4cac+h5YWAABEFNuZBaZOAgDaEN3lnnlFteMwZgEA0JZ4ng0RLTEdLAAA4Cyurzcr1ztPTAcLxsT3lBgAgHVWFknCaTEdLNANAQBoC90Q1sV0sGB1IAkAIP5FtZ0gWHAeZkMAANpCO2FdbAcLdEMAANoQi6+odpqYDhYAAHASu9466TQxHSyQWQAAtIV2wrqYDhYY4AgAaAsDHK2L6WABAABHYcyC85wKJkhB3oUFADi3U7QTlnVKDX7xxRf6yU9+oj59+ig5OVnDhg3T7t27Q8eNMZo7d64yMjKUnJysvLw87d+/vzOKAgBA1LiM9c2JbM8s/OMf/9Do0aM1duxYvfXWW7rkkku0f/9+XXzxxaFzFi1apCVLlmjNmjXKzs7WnDlzNH78eH300UdKSko672dZ7RoCAMS/qLYTjFk4PwsXLlRWVpZWrVoV2pednR36tzFGixcv1uzZszVp0iRJ0osvvqi0tDRt2LBBU6dOPe9nGWZDAADaEN0BjoxZOC9vvvmmxo8frx//+Mfavn27Lr30Ut13332aPn26JKmmpkY+n095eXmha7xer3JyclRRUdFqsNDc3Kzm5ubQZ7/fL4nZEACAttFOWGf7mIXPP/9cK1as0MCBA/X222/r3nvv1QMPPKA1a9ZIknw+nyQpLS0t7Lq0tLTQsW8rKyuT1+sNbVlZWXYXGwAA64wNmwPZnlkIBoMaOXKknnrqKUnStddeq71792rlypUqLCzs0D1LS0tVUlIS+uz3+5WVlaWgXHIRMQIAIojquyEYs3B+MjIyNGTIkLB9gwcP1u9+9ztJUnp6uiSprq5OGRkZoXPq6uo0YsSIVu/pdrvldrvP2k83BACgLbQT1tkeLIwePVr79u0L2/fpp59qwIABkk4PdkxPT9eWLVtCwYHf71dlZaXuvffedj0r6OBpJgAAZwhGs50gs3B+HnroId1444166qmndMcdd+i9997T888/r+eff16S5HK5NHPmTD3xxBMaOHBgaOpkZmamJk+e3K5nkVkAALSF2RDW2R4s3HDDDVq/fr1KS0u1YMECZWdna/HixSooKAid8+ijj6qxsVEzZsxQfX29brrpJm3atKldaywAAIDo6JTlnm+99Vbdeuut5zzucrm0YMECLViwwNJzyCwAANoSzXbC6iqMTu1aj+l3QwQNsyEAAJFFdfE+xiw4T3PzBUro0bOriwEAcLBgc6CrixDzYjpYuPB/e6lHIuMcAADnFjjZo6uLEPNiOlhI+90nusCV2NXFAAA42ClzUnuj9CyXLI5ZsK0k9orpYCFQ75fLRTcEAODcAqYleg+L06mTtr8bAgAAxJeYziwAAOAozIYAAAARxWmwQDcEAACIiMwCAAA2YQVHAAAQGd0QAACgOyKzAACAXeI0s0CwAACATeJ1zALdEAAAICIyCwAA2CVOl3smWAAAwC6MWQAAAJEwZgEAAHRLBAsAANjF2LC10xdffKGf/OQn6tOnj5KTkzVs2DDt3r3b+nf5BrohAACwi8VuiPYGC//4xz80evRojR07Vm+99ZYuueQS7d+/XxdffLGFQpyNYAEAgBi1cOFCZWVladWqVaF92dnZtj+HbggAAOxiUzeE3+8P25qbm1t93JtvvqmRI0fqxz/+sfr166drr71WL7zwgu1fi2ABAAC72BQsZGVlyev1hraysrJWH/f5559rxYoVGjhwoN5++23de++9euCBB7RmzRpbvxbdEAAAOExtba08Hk/os9vtbvW8YDCokSNH6qmnnpIkXXvttdq7d69WrlypwsJC28pDZgEAAJucWWfByiZJHo8nbDtXsJCRkaEhQ4aE7Rs8eLAOHTpk6/ciWAAAIEaNHj1a+/btC9v36aefasCAAbY+h2ABAIAY9dBDD2nnzp166qmndODAAa1bt07PP/+8ioqKbH0OwQIAAHaJ8qJMN9xwg9avX6+XXnpJQ4cO1S9/+UstXrxYBQUF9nyfrzHAEQAAm3TFuyFuvfVW3XrrrR1/6HkgWAAAwE4OfRmUFXRDAACAiMgsAABglw6+DCrsegciWAAAwCZdMWYhGuiGAAAAEZFZAADALnRDAACASOiGAAAA3RKZBQAA7EI3BAAAiChOgwW6IQAAQERkFgAAsEm8DnAkWAAAwC5x2g1BsAAAgF3iNFhgzAIAAIiIzAIAADaJ1zELtmcWAoGA5syZo+zsbCUnJ+vKK6/UL3/5Sxnz/2vAGKO5c+cqIyNDycnJysvL0/79++0uCgAA0WVs2BzI9mBh4cKFWrFihZYtW6aPP/5YCxcu1KJFi7R06dLQOYsWLdKSJUu0cuVKVVZWqlevXho/fryamprsLg4AALDI9m6Id999V5MmTdLEiRMlSZdffrleeuklvffee5JOZxUWL16s2bNna9KkSZKkF198UWlpadqwYYOmTp1qd5EAAIgKuiHO04033qgtW7bo008/lST9+c9/1o4dO5Sfny9Jqqmpkc/nU15eXugar9ernJwcVVRUtHrP5uZm+f3+sA0AAMeJ024I2zMLjz32mPx+vwYNGqQePXooEAjoySefVEFBgSTJ5/NJktLS0sKuS0tLCx37trKyMj3++ON2FxUAAJwH2zMLr776qtauXat169apurpaa9as0bPPPqs1a9Z0+J6lpaVqaGgIbbW1tTaWGAAAm5BZOD+PPPKIHnvssdDYg2HDhungwYMqKytTYWGh0tPTJUl1dXXKyMgIXVdXV6cRI0a0ek+32y232213UQEAsJXr683K9U5ke2bhxIkTSkgIv22PHj0UDAYlSdnZ2UpPT9eWLVtCx/1+vyorK5Wbm2t3cQAAgEW2ZxZuu+02Pfnkk+rfv7+uvvpqvf/++3ruuef005/+VJLkcrk0c+ZMPfHEExo4cKCys7M1Z84cZWZmavLkyXYXBwCA6InT5Z5tDxaWLl2qOXPm6L777tORI0eUmZmpn/3sZ5o7d27onEcffVSNjY2aMWOG6uvrddNNN2nTpk1KSkqyuzgAAERNvE6ddJlvLq0YI/x+v7xer8Zoki5w9ezq4gAAHOyUadE2vaGGhgZ5PJ5OecaZdunqnz2lHu6O/+EbaG7Sh7/5RaeWtSN4kRQAAIiIF0kBAGCnmMvXt41gAQAAm8TrmAW6IQAAQERkFgAAsAtTJwEAQCR0QwAAgG6JzAIAAHahGwIAAERCNwQAAOiWyCwAAGAXuiEAAEBEBAsAACASxiwAAIBuicwCAAB2oRsCAABE4jJGLtPxFt/KtZ2JbggAABARwQIAAHYxNmwWPP3003K5XJo5c6a1G30L3RAAANikK2dD7Nq1S7/5zW90zTXXdPwm50BmAQCAGHf8+HEVFBTohRde0MUXX2z7/QkWAACwSxd1QxQVFWnixInKy8uzVv5zoBsCAACb2NUN4ff7w/a73W653e5Wr3n55ZdVXV2tXbt2dfzBbSCzAACAw2RlZcnr9Ya2srKyVs+rra3Vgw8+qLVr1yopKanTykNmAQAAu9i0KFNtba08Hk9o97myClVVVTpy5Iiuu+660L5AIKDy8nItW7ZMzc3N6tGjh4UCnUawAACATezqhvB4PGHBwrmMGzdOH3zwQdi+adOmadCgQZo1a5YtgYJEsAAAgH2ivNxz7969NXTo0LB9vXr1Up8+fc7abwVjFgAAQERkFgAAsFFXv2Z627Zttt+TYAEAALsYc3qzcr0D0Q0BAAAiIrMAAIBNuvLdEJ2JYAEAALtEeTZEtNANAQAAIiKzAACATVzB05uV652IYAEAALvQDQEAALojMgsAANiE2RAAACCyOF2UiWABAACbxGtmgTELAAAgIjILAADYJU5nQxAsAABgE7ohAABAt0RmAQAAuzAbAgAAREI3BAAA6JbILAAAYJc4nQ3R7sxCeXm5brvtNmVmZsrlcmnDhg1hx40xmjt3rjIyMpScnKy8vDzt378/7JyjR4+qoKBAHo9HKSkpuueee3T8+HFLXwQAgK52phvCyuZE7Q4WGhsbNXz4cC1fvrzV44sWLdKSJUu0cuVKVVZWqlevXho/fryamppC5xQUFOjDDz/U5s2btXHjRpWXl2vGjBkd/xYAAKDTtLsbIj8/X/n5+a0eM8Zo8eLFmj17tiZNmiRJevHFF5WWlqYNGzZo6tSp+vjjj7Vp0ybt2rVLI0eOlCQtXbpUP/jBD/Tss88qMzPTwtcBAKALBc3pzcr1DmTrAMeamhr5fD7l5eWF9nm9XuXk5KiiokKSVFFRoZSUlFCgIEl5eXlKSEhQZWVlq/dtbm6W3+8P2wAAcBxjw+ZAtgYLPp9PkpSWlha2Py0tLXTM5/OpX79+YccvuOACpaamhs75trKyMnm93tCWlZVlZ7EBALCFSxbHLHT1FziHmJg6WVpaqoaGhtBWW1vb1UUCAKDbsHXqZHp6uiSprq5OGRkZof11dXUaMWJE6JwjR46EXXfq1CkdPXo0dP23ud1uud1uO4sKAID94nQFR1szC9nZ2UpPT9eWLVtC+/x+vyorK5WbmytJys3NVX19vaqqqkLnbN26VcFgUDk5OXYWBwCAqIrXqZPtziwcP35cBw4cCH2uqanRnj17lJqaqv79+2vmzJl64oknNHDgQGVnZ2vOnDnKzMzU5MmTJUmDBw/WhAkTNH36dK1cuVItLS0qLi7W1KlTmQkBAIADtTtY2L17t8aOHRv6XFJSIkkqLCzU6tWr9eijj6qxsVEzZsxQfX29brrpJm3atElJSUmha9auXavi4mKNGzdOCQkJmjJlipYsWWLD1wEAoAvF6QqOLmMc2kESgd/vl9fr1RhN0gWunl1dHACAg50yLdqmN9TQ0CCPx9MpzzjTLn1vzDxdcEFS2xecw6lTTfrfbY93alk7IiZmQwAAgK7Di6QAALBL8OvNyvUORLAAAIBNXMbIZaF338q1nYluCAAAEBGZBQAA7BKnsyEIFgAAsEucruBIsAAAgE2srsLo1BUcGbMAAAAiIrMAAIBd6IYAAACRuIKnNyvXOxHdEAAAICIyCwAA2IVuCAAAEFGcrrNANwQAAIiIzAIAADbh3RAAACCyM2MWrGztUFZWphtuuEG9e/dWv379NHnyZO3bt8/2r0WwAABAjNq+fbuKioq0c+dObd68WS0tLbrlllvU2Nho63PohgAAwC5GkpW1EtrZC7Fp06awz6tXr1a/fv1UVVWlm2++2UJBwhEsAABgE7vGLPj9/rD9brdbbre7zesbGhokSampqR0uQ2vohgAAwC5GFscsnL5NVlaWvF5vaCsrK2vz0cFgUDNnztTo0aM1dOhQW78WmQUAABymtrZWHo8n9Pl8sgpFRUXau3evduzYYXt5CBYAALCLTSs4ejyesGChLcXFxdq4caPKy8t12WWXdfz550CwAACAXYKSXBavbwdjjO6//36tX79e27ZtU3Z2toWHnxvBAgAAMaqoqEjr1q3TG2+8od69e8vn80mSvF6vkpOTbXsOAxwBALDJmdkQVrb2WLFihRoaGjRmzBhlZGSEtldeecXW70VmAQAAu0T5rZMmSstDk1kAAAARkVkAAMAuUc4sRAvBAgAAdonTYIFuCAAAEBGZBQAA7BLldRaihWABAACb2PUiKachWAAAwC6MWQAAAN0RmQUAAOwSNJLLQnYg6MzMAsECAAB2oRsCAAB0R2QWAACwjcXMgpyZWSBYAADALnRDAACA7ojMAgAAdgkaWepKYDYEAABxzgRPb1audyC6IQAAQERkFgAAsEucDnAkWAAAwC6MWQAAABHFaWah3WMWysvLddtttykzM1Mul0sbNmwIHWtpadGsWbM0bNgw9erVS5mZmfqP//gPffnll2H3OHr0qAoKCuTxeJSSkqJ77rlHx48ft/xlAACA/dodLDQ2Nmr48OFavnz5WcdOnDih6upqzZkzR9XV1Xr99de1b98+/fCHPww7r6CgQB9++KE2b96sjRs3qry8XDNmzOj4twAAwAmM/n92oUNbV3+B1rW7GyI/P1/5+fmtHvN6vdq8eXPYvmXLlmnUqFE6dOiQ+vfvr48//libNm3Srl27NHLkSEnS0qVL9YMf/EDPPvusMjMzO/A1AABwALohOqahoUEul0spKSmSpIqKCqWkpIQCBUnKy8tTQkKCKisrW71Hc3Oz/H5/2AYAAKKjU4OFpqYmzZo1S3fddZc8Ho8kyefzqV+/fmHnXXDBBUpNTZXP52v1PmVlZfJ6vaEtKyurM4sNAEDHBIPWNwfqtGChpaVFd9xxh4wxWrFihaV7lZaWqqGhIbTV1tbaVEoAAGxkabyC1TdWdp5OmTp5JlA4ePCgtm7dGsoqSFJ6erqOHDkSdv6pU6d09OhRpaent3o/t9stt9vdGUUFAABtsD2zcCZQ2L9/v/74xz+qT58+Ycdzc3NVX1+vqqqq0L6tW7cqGAwqJyfH7uIAABA9ZBZOO378uA4cOBD6XFNToz179ig1NVUZGRn60Y9+pOrqam3cuFGBQCA0DiE1NVWJiYkaPHiwJkyYoOnTp2vlypVqaWlRcXGxpk6dykwIAEBsYwXH03bv3q2xY8eGPpeUlEiSCgsLNX/+fL355puSpBEjRoRd984772jMmDGSpLVr16q4uFjjxo1TQkKCpkyZoiVLlnTwKwAAgM7U7mBhzJgxMhHSJJGOnZGamqp169a199EAADiaMUEZC6+ZtnJtZ+LdEAAA2MUYa10J8TJmAQAAnIOxOGbBocFCp6/gCAAAYhuZBQAA7BIMSi4L4w4YswAAQJyjGwIAAHRHZBYAALCJCQZlLHRDMHUSAIB4RzcEAADojsgsAABgl6CRXPGXWSBYAADALsZIsjJ10pnBAt0QAAAgIjILAADYxASNjIVuiPN5GWNXILMAAIBdTND61gHLly/X5ZdfrqSkJOXk5Oi9996z9WsRLAAAYBMTNJa39nrllVdUUlKiefPmqbq6WsOHD9f48eN15MgR274XwQIAADHsueee0/Tp0zVt2jQNGTJEK1eu1IUXXqj/+q//su0ZMTlm4Uyfzim1WFr7AgAQ/06pRVJ0xgOcMs2WXgZ1pqx+vz9sv9vtltvtPuv8kydPqqqqSqWlpaF9CQkJysvLU0VFRYfL8W0xGSwcO3ZMkrRDf+jikgAAYsWxY8fk9Xo75d6JiYlKT0/XDp/1dumiiy5SVlZW2L558+Zp/vz5Z53797//XYFAQGlpaWH709LS9Mknn1guyxkxGSxkZmbqo48+0pAhQ1RbWyuPx9PVRYoJfr9fWVlZ1Fk7UGftR511DPXWfudbZ8YYHTt2TJmZmZ1WlqSkJNXU1OjkyZOW72WMkcvlCtvXWlYhmmIyWEhISNCll14qSfJ4PPxitRN11n7UWftRZx1DvbXf+dRZZ2UUvikpKUlJSUmd/pxv6tu3r3r06KG6urqw/XV1dUpPT7ftOQxwBAAgRiUmJur666/Xli1bQvuCwaC2bNmi3Nxc254Tk5kFAABwWklJiQoLCzVy5EiNGjVKixcvVmNjo6ZNm2bbM2I2WHC73Zo3b16X9+PEEuqs/aiz9qPOOoZ6az/q7LQ777xTf/vb3zR37lz5fD6NGDFCmzZtOmvQoxUu49S1JQEAgCMwZgEAAEREsAAAACIiWAAAABERLAAAgIhiMljo7FdxxrL58+fL5XKFbYMGDQodb2pqUlFRkfr06aOLLrpIU6ZMOWsxj+6gvLxct912mzIzM+VyubRhw4aw48YYzZ07VxkZGUpOTlZeXp72798fds7Ro0dVUFAgj8ejlJQU3XPPPTp+/HgUv0V0tVVnd99991k/exMmTAg7p7vVWVlZmW644Qb17t1b/fr10+TJk7Vv376wc87nd/LQoUOaOHGiLrzwQvXr10+PPPKITp06Fc2vEjXnU2djxow562ft5z//edg53anOoiHmgoVovIoz1l199dU6fPhwaNuxY0fo2EMPPaTf//73eu2117R9+3Z9+eWXuv3227uwtF2jsbFRw4cP1/Lly1s9vmjRIi1ZskQrV65UZWWlevXqpfHjx6upqSl0TkFBgT788ENt3rxZGzduVHl5uWbMmBGtrxB1bdWZJE2YMCHsZ++ll14KO97d6mz79u0qKirSzp07tXnzZrW0tOiWW25RY2Nj6Jy2ficDgYAmTpyokydP6t1339WaNWu0evVqzZ07tyu+Uqc7nzqTpOnTp4f9rC1atCh0rLvVWVSYGDNq1ChTVFQU+hwIBExmZqYpKyvrwlI5x7x588zw4cNbPVZfX2969uxpXnvttdC+jz/+2EgyFRUVUSqh80gy69evD30OBoMmPT3dPPPMM6F99fX1xu12m5deeskYY8xHH31kJJldu3aFznnrrbeMy+UyX3zxRdTK3lW+XWfGGFNYWGgmTZp0zmu6e50ZY8yRI0eMJLN9+3ZjzPn9Tv7hD38wCQkJxufzhc5ZsWKF8Xg8prm5ObpfoAt8u86MMeZf//VfzYMPPnjOa7p7nXWGmMosnHkVZ15eXmhfZ7yKM9bt379fmZmZuuKKK1RQUKBDhw5JkqqqqtTS0hJWf4MGDVL//v2pv2+oqamRz+cLqyev16ucnJxQPVVUVCglJUUjR44MnZOXl6eEhARVVlZGvcxOsW3bNvXr109XXXWV7r33Xn311VehY9SZ1NDQIElKTU2VdH6/kxUVFRo2bFjYAjvjx4+X3+/Xhx9+GMXSd41v19kZa9euVd++fTV06FCVlpbqxIkToWPdvc46Q0yt4BitV3HGspycHK1evVpXXXWVDh8+rMcff1zf+973tHfvXvl8PiUmJiolJSXsmrS0NPl8vq4psAOdqYvWfs7OHPP5fOrXr1/Y8QsuuECpqandti4nTJig22+/XdnZ2frss8/0i1/8Qvn5+aqoqFCPHj26fZ0Fg0HNnDlTo0eP1tChQyXpvH4nfT5fqz+LZ47Fs9bqTJL+/d//XQMGDFBmZqb+8pe/aNasWdq3b59ef/11Sd27zjpLTAULaFt+fn7o39dcc41ycnI0YMAAvfrqq0pOTu7CkiHeTZ06NfTvYcOG6ZprrtGVV16pbdu2ady4cV1YMmcoKirS3r17w8YQIbJz1dk3x7kMGzZMGRkZGjdunD777DNdeeWV0S5mtxBT3RDRehVnPElJSdF3vvMdHThwQOnp6Tp58qTq6+vDzqH+wp2pi0g/Z+np6WcNqj116pSOHj1KXX7tiiuuUN++fXXgwAFJ3bvOiouLtXHjRr3zzju67LLLQvvP53cyPT291Z/FM8fi1bnqrDU5OTmSFPaz1h3rrDPFVLAQrVdxxpPjx4/rs88+U0ZGhq6//nr17NkzrP727dunQ4cOUX/fkJ2drfT09LB68vv9qqysDNVTbm6u6uvrVVVVFTpn69atCgaDof9xdXf/93//p6+++koZGRmSumedGWNUXFys9evXa+vWrcrOzg47fj6/k7m5ufrggw/CAq3NmzfL4/FoyJAh0fkiUdRWnbVmz549khT2s9ad6iwqunqEZXu9/PLLxu12m9WrV5uPPvrIzJgxw6SkpISNeu3OHn74YbNt2zZTU1Nj/vSnP5m8vDzTt29fc+TIEWOMMT//+c9N//79zdatW83u3btNbm6uyc3N7eJSR9+xY8fM+++/b95//30jyTz33HPm/fffNwcPHjTGGPP000+blJQU88Ybb5i//OUvZtKkSSY7O9v885//DN1jwoQJ5tprrzWVlZVmx44dZuDAgeauu+7qqq/U6SLV2bFjx8x//ud/moqKClNTU2P++Mc/muuuu84MHDjQNDU1he7R3ers3nvvNV6v12zbts0cPnw4tJ04cSJ0Tlu/k6dOnTJDhw41t9xyi9mzZ4/ZtGmTueSSS0xpaWlXfKVO11adHThwwCxYsMDs3r3b1NTUmDfeeMNcccUV5uabbw7do7vVWTTEXLBgjDFLly41/fv3N4mJiWbUqFFm586dXV0kx7jzzjtNRkaGSUxMNJdeeqm58847zYEDB0LH//nPf5r77rvPXHzxxebCCy80//Zv/2YOHz7chSXuGu+8846RdNZWWFhojDk9fXLOnDkmLS3NuN1uM27cOLNv376we3z11VfmrrvuMhdddJHxeDxm2rRp5tixY13wbaIjUp2dOHHC3HLLLeaSSy4xPXv2NAMGDDDTp08/K4jvbnXWWn1JMqtWrQqdcz6/k3/9619Nfn6+SU5ONn379jUPP/ywaWlpifK3iY626uzQoUPm5ptvNqmpqcbtdpt/+Zd/MY888ohpaGgIu093qrNo4BXVAAAgopgaswAAAKKPYAEAAEREsAAAACIiWAAAABERLAAAgIgIFgAAQEQECwAAICKCBQAAEBHBAgAAiIhgAQAARESwAAAAIiJYAAAAEf0/TE/cerwfK94AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# we can impose a horizon like this, ripples are due to finite lmax (a sharp edge requires infinite ell)\n", - "beam.horizon_cut()\n", - "m = beam.alm2map(sampling=sampling, nside=nside, frequencies=freq[0])\n", - "plt.figure()\n", - "plt.imshow(m[0], aspect=\"auto\")\n", - "plt.colorbar()\n", - "plt.show()\n", - "#mollview(m[0], title=f\"Beam at {freq[0]:.0f} MHz\")" - ] - }, - { - "cell_type": "markdown", - "id": "a5f791e5", - "metadata": {}, - "source": [ - "We use the Global Sky Model (Zheng et al 2016) at 25 MHz as the sky model. It has a built-in interface in the sky module of croissant." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "6d25d25a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sky = crojax.Sky.gsm(beam.frequencies, lmax=beam.lmax.item())\n", - "m = sky.alm2map(sampling=\"healpix\", nside=64, frequencies=freq[0])\n", - "mollview(m[0], title=f\"Sky at {freq[0]:.0f} MHz\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "9a5e0c5e", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlUAAAGwCAYAAACAZ5AeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABwWElEQVR4nO3deVhU1f8H8PcwMMO+ya4sIu7ihhuaO4FKpallZeZaabibIi1qtmj2bbNMW9XKcqnUco0UXHFDUVFERRCUTVEY2WHm/P7wx+QEKsjAHeD9ep55cu49c+/nzDjOu3vuPVcmhBAgIiIiomoxkroAIiIiovqAoYqIiIhIDxiqiIiIiPSAoYqIiIhIDxiqiIiIiPSAoYqIiIhIDxiqiIiIiPTAWOoC6guNRoPU1FRYWVlBJpNJXQ4RERFVghACd+7cgZubG4yMqnesiaFKT1JTU+Hu7i51GURERPQIUlJS0KRJk2ptg6FKT6ysrADc/VCsra0lroaIiIgqQ6VSwd3dXfs7Xh0MVXpSNuRnbW3NUEVERFTH6OPUHZ6oTkRERKQHDFVEREREesBQRURERKQHPKeKiMhAqNVqlJSUSF0GUb1iYmICuVxeK/tiqCIikpgQAunp6cjOzpa6FKJ6ydbWFi4uLjU+jyRDFRGRxMoClZOTE8zNzTmBMJGeCCGQn5+PzMxMAICrq2uN7o+hiohIQmq1WhuoGjVqJHU5RPWOmZkZACAzMxNOTk41OhTIE9WJiCRUdg6Vubm5xJUQ1V9l36+aPmfRYELV0qVLIZPJMHPmTO2ywsJChISEoFGjRrC0tMSIESOQkZGh87rk5GQEBwfD3NwcTk5OmDt3LkpLS3XaREZGonPnzlAqlfDx8cGaNWvK7X/FihXw8vKCqakpunfvjmPHjtVEN4mIKsQhP6KaU1vfL4MIVcePH8fXX3+N9u3b6yyfNWsW/vrrL2zatAn79u1Damoqhg8frl2vVqsRHByM4uJiHD58GGvXrsWaNWuwYMECbZvExEQEBwejf//+iImJwcyZMzFp0iTs3r1b22bDhg2YPXs2Fi5ciJMnT6JDhw4ICgrSjsESERERPZSQ2J07d0Tz5s1FeHi46Nu3r5gxY4YQQojs7GxhYmIiNm3apG0bFxcnAIioqCghhBA7duwQRkZGIj09Xdtm5cqVwtraWhQVFQkhhJg3b55o27atzj5HjRolgoKCtM+7desmQkJCtM/VarVwc3MTS5YsqXQ/cnJyBACRk5NT+c4TUYNXUFAgzp8/LwoKCqQuhajeetD3TJ+/35IfqQoJCUFwcDACAgJ0lkdHR6OkpERneatWreDh4YGoqCgAQFRUFHx9feHs7KxtExQUBJVKhXPnzmnb/HfbQUFB2m0UFxcjOjpap42RkRECAgK0bSpSVFQElUql8yAiIl0ymQxbtmyRuow6IykpCTKZDDExMVKXQo9A0lC1fv16nDx5EkuWLCm3Lj09HQqFAra2tjrLnZ2dkZ6erm1zb6AqW1+27kFtVCoVCgoKcPPmTajV6grblG2jIkuWLIGNjY324e7uXrlOExHVEzdu3MCUKVPg4eEBpVIJFxcXBAUF4dChQ1KXRhKKjIyETCZrkPOuSTalQkpKCmbMmIHw8HCYmppKVcYjCwsLw+zZs7XPVSoV3N3dkXwrD+2srSWsjIiodowYMQLFxcVYu3YtvL29kZGRgT179iArK0vq0qgOKC4uhkKhkLoMvZLsSFV0dDQyMzPRuXNnGBsbw9jYGPv27cPy5cthbGwMZ2dnFBcXl0u6GRkZcHFxAQC4uLiUuxqw7PnD2lhbW8PMzAwODg6Qy+UVtinbRkWUSiWsra11HgDwafjFqr8ZRET3EEIgv7hUkocQolI1Zmdn48CBA/jwww/Rv39/eHp6olu3bggLC8NTTz1139ctXLgQrq6uOH36NKytrfHbb7/prN+yZQssLCxw586dCl/fr18/TJs2DTNnzoSdnR2cnZ3x7bffIi8vD+PHj4eVlRV8fHywc+dOndft27cP3bp1g1KphKurK+bPn69zpXi/fv0wffp0zJs3D/b29nBxccGiRYt0tpGcnIyhQ4fC0tIS1tbWePbZZ3V+OxYtWoSOHTvi66+/hru7O8zNzfHss88iJydH20aj0WDx4sVo0qQJlEolOnbsiF27dj3wvY6NjcXgwYNhaWkJZ2dnjBkzBjdv3rxv+6tXr+LJJ5+EnZ0dLCws0LZtW+zYsQPAv0eRtm/fjvbt28PU1BQ9evRAbGyszjYOHjyI3r17w8zMDO7u7pg+fTry8vK064uKihAaGgp3d3ftlfXff/89kpKS0L9/fwCAnZ0dZDIZxo0bp32Pp06dipkzZ8LBwQFBQUEVDndmZ2dDJpMhMjJSp+bdu3ejU6dOMDMzw4ABA5CZmYmdO3eidevWsLa2xgsvvID8/PwHvpc1TbIjVQMHDsTZs2d1lo0fPx6tWrXSflAmJibYs2cPRowYAQCIj49HcnIy/P39AQD+/v54//33tRN6AUB4eDisra3Rpk0bbZuyv0xlwsPDtdtQKBTw8/PDnj17MGzYMAB3/9Lv2bMHU6dOrXK/ws9n4uiVLHT35iR+RPRoCkrUaLNg98Mb1oDzi4Ngrnj4T4OlpSUsLS2xZcsW9OjRA0ql8oHthRCYPn06tm3bhgMHDsDHxwfPPfccVq9ejZEjR2rblT23srK677bWrl2LefPm4dixY9iwYQOmTJmCzZs34+mnn8Ybb7yBTz/9FGPGjEFycjLMzc1x/fp1DBkyBOPGjcOPP/6ICxcu4OWXX4apqalOcFq7di1mz56No0ePIioqCuPGjUOvXr3w+OOPQ6PRaAPVvn37UFpaipCQEIwaNUr74w8Aly9fxsaNG/HXX39BpVJh4sSJeO2117Bu3ToAwOeff46PP/4YX3/9NTp16oQffvgBTz31FM6dO4fmzZuX62t2djYGDBiASZMm4dNPP0VBQQFCQ0Px7LPPYu/evRW+PyEhISguLsb+/fthYWGB8+fPw9LSUqfN3Llz8fnnn8PFxQVvvPEGnnzySVy8eBEmJiZISEjAoEGD8N577+GHH37AjRs3MHXqVEydOhWrV68GALz00kuIiorC8uXL0aFDByQmJuLmzZtwd3fH77//jhEjRiA+Pl57AOPe93jKlCmPNES8aNEifPnll9qw+uyzz0KpVOKXX35Bbm4unn76aXzxxRcIDQ2t8rb1ptqnuuvRvVf/CSHE5MmThYeHh9i7d684ceKE8Pf3F/7+/tr1paWlol27diIwMFDExMSIXbt2CUdHRxEWFqZtc+XKFWFubi7mzp0r4uLixIoVK4RcLhe7du3Stlm/fr1QKpVizZo14vz58+KVV14Rtra2OlcVPkzZ1QPuMzeKJ5YfEGq1pnpvBhE1CBVdlZRXVCI8Q7dJ8sgrKql07b/99puws7MTpqamomfPniIsLEycPn1apw0AsWnTJvHCCy+I1q1bi2vXrmnXHT16VMjlcpGamiqEECIjI0MYGxuLyMjI++6zb9++4rHHHtM+Ly0tFRYWFmLMmDHaZWlpaTpXir/xxhuiZcuWQqP599/lFStWCEtLS6FWqyvcrhBCdO3aVYSGhgohhPj777+FXC4XycnJ2vXnzp0TAMSxY8eEEEIsXLhQyOVynT7u3LlTGBkZibS0NCGEEG5ubuL9998vt5/XXntNCCFEYmKiACBOnTolhBDi3XffFYGBgTrtU1JSBAARHx9f4Xvk6+srFi1aVOG6iIgIAUCsX79euywrK0uYmZmJDRs2CCGEmDhxonjllVd0XnfgwAFhZGQkCgoKRHx8vAAgwsPDH7iP27dv6yzv27ev6NSpk86y//ZXCCFu374tAIiIiAid7f3zzz/aNkuWLBEAREJCgnbZq6++qnNl/71q6+o/g75NzaeffgojIyOMGDECRUVFCAoKwldffaVdL5fLsW3bNkyZMgX+/v6wsLDA2LFjsXjxYm2bpk2bYvv27Zg1axY+//xzNGnSBN999x2CgoK0bUaNGoUbN25gwYIFSE9P1x6O/e/J65VhoZTj7PUcbIm5juGdm1TvDSCiBsnMRI7zi4Me3rCG9l1ZI0aMQHBwMA4cOIAjR45g586dWLZsGb777jvtkA9wd85BpVKJI0eOwMHBQbu8W7duaNu2LdauXYv58+fj559/hqenJ/r06fPA/d47p6FcLkejRo3g6+urXVb2b3fZXINxcXHw9/fXmQCyV69eyM3NxbVr1+Dh4VFuu8Dd+8Tduw13d3edi5LatGkDW1tbxMXFoWvXrgAADw8PNG7cWNvG398fGo0G8fHxMDc3R2pqKnr16qWzn169euH06dMV9vX06dOIiIgod6QJABISEtCiRYtyy6dPn44pU6bg77//RkBAAEaMGFGub2WjNQBgb2+Pli1bIi4uTrvPM2fOaI+uAXePNGo0GiQmJuLs2bOQy+Xo27dvhTU/iJ+fX5VfU+bePjg7O8Pc3Bze3t46y6SeuNugQtW9h1ABwNTUFCtWrMCKFSvu+xpPT89yw3v/1a9fP5w6deqBbcoObVbXpN5N8cWBVCzbFY/B7Vxhpqi5ewwRUf0kk8kqNQRnCExNTfH444/j8ccfx9tvv41JkyZh4cKFOqHq8ccfx6+//ordu3dj9OjROq+fNGkSVqxYgfnz52P16tUYP378Q2e/NjEx0Xkuk8l0lpW9XqPRVKkvFW23qtvQt9zcXDz55JP48MMPy627382BJ02ahKCgIGzfvh1///03lixZgo8//hjTpk2r9D5fffVVTJ8+vdw6Dw8PXL58uWqduIeFhYXOcyOju6d2i3vO5bvfrWT++xkb4ucl+TxV9c2YHl5obGuGdFUhvj1wRepyiIhqVZs2bXROaAaAp556Cr/88gsmTZqE9evX66x78cUXcfXqVSxfvhznz5/H2LFj9V5T69atERUVpfPDfejQIVhZWaFJk8qNKLRu3RopKSlISUnRLjt//jyys7O15/ACd09mT01N1T4/cuQIjIyM0LJlS1hbW8PNza3c+USHDh3S2ca9OnfujHPnzsHLyws+Pj46j/8GlHu5u7tj8uTJ+OOPPzBnzhx8++23OuuPHDmi/fPt27dx8eJFtG7dWrvP8+fPl9ufj48PFAoFfH19odFosG/fvgr3XXZFn1qtvm99ZRwdHQEAaWlp2mV1eY4uhio9MzWRY/7gVgCAlZEJyFAVSlwREZH+ZWVlYcCAAfj5559x5swZJCYmYtOmTVi2bBmGDh1arv3TTz+Nn376CePHj9e54s/Ozg7Dhw/H3LlzERgYWOmQUxWvvfYaUlJSMG3aNFy4cAFbt27FwoULMXv2bO2RkocJCAiAr68vRo8ejZMnT+LYsWN46aWX0LdvX3Tp0kXbztTUFGPHjsXp06dx4MABTJ8+Hc8++6z2avK5c+fiww8/xIYNGxAfH4/58+cjJiYGM2bMqHC/ISEhuHXrFp5//nkcP34cCQkJ2L17N8aPH3/f0DJz5kzs3r0biYmJOHnyJCIiIrSBqczixYuxZ88exMbGYty4cXBwcNBerBUaGorDhw9j6tSpiImJwaVLl7B161btaI6XlxfGjh2LCRMmYMuWLUhMTERkZCQ2btwI4O4Ikkwmw7Zt23Djxg3k5ube9301MzNDjx49sHTpUsTFxWHfvn146623KvWZGCKGqhrwRHtXdPKwRUGJGv/bHS91OUREemdpaYnu3bvj008/RZ8+fdCuXTu8/fbbePnll/Hll19W+JqRI0di7dq1GDNmDP744w/t8okTJ6K4uBgTJkyokVobN26MHTt24NixY+jQoQMmT56MiRMnVunHWyaTYevWrbCzs0OfPn0QEBAAb29vbNiwQaedj48Phg8fjiFDhiAwMBDt27fXORd4+vTpmD17NubMmQNfX1/s2rULf/75Z4VX/gHQHtlSq9UIDAyEr68vZs6cCVtb2/sGQrVajZCQELRu3RqDBg1CixYtdGoAgKVLl2LGjBnw8/NDeno6/vrrL+0Rpvbt22Pfvn24ePEievfujU6dOmHBggVwc3PTvn7lypUYOXIkXnvtNbRq1Qovv/yy9ghl48aN8c4772D+/PlwdnZ+6Kk1P/zwA0pLS+Hn54eZM2fivffee2B7QyYTopKTktADqVQq2NjYICcnB9bW1jiZfBvDvzoMmQz4a+pjaNfYRuoSicgAFRYWIjExEU2bNq2TEyHrw08//YRZs2YhNTW1Tk8GuWjRImzZssWgh68iIyPRv39/3L59u9wdS+qzB33P/vv7XR08UlVDOnvY4ckObhACeH97XKUn1CMiaijy8/ORkJCApUuX4tVXX63TgYoIYKiqUaGDWkJhbISoK1n4Jy5T6nKIiAzKsmXL0KpVK7i4uCAsLEzqcoiqjcN/enK/w4fLdl3AV5EJaOpggd0z+0BhzBxLRP/i8B9RzePwXz0xpV8zOFgqkHgzD+uOXpW6HCIyUPz/W6KaU1vfL4aqGmZlaoLZj7cEAHz2zyVk5xdLXBERGZKyCQylvhEsUX1W9v3674Sh+lY3puyt457t0gRrDychPuMOlu+5jAVPVjzJGxE1PHK5HLa2ttrboZibmz90RnEiqhwhBPLz85GZmQlbW1vI5TV7lxOGqlpgLDfCm8Gt8dIPx/BjVBJe7OEBb8fy93EiooapbGLIsmBFRPpla2ur/Z7VJIaqWtKnhSP6tXREZPwNLN15Ad+81OXhLyKiBkEmk8HV1RVOTk73ve8ZET0aExOTGj9CVYahqha9OaQ1Dly6ib/PZyAqIQv+zRpJXRIRGRC5XF5r//gTkf7xRPVa1NzZCi908wAAvLf9PDQaXu1DRERUXzBU1bKZAc1hpTTGuVQVfj95TepyiIiISE8YqmpZI0slpg7wAQB8tDse+cWlEldERERE+sBQJYGxPb3gbm+GzDtFWBmZIHU5REREpAcMVRIwNZHjjcGtAQBf77uCxJt5EldERERE1cVQJZFB7VzQp4UjitUaLNgay1tUEBER1XEMVRKRyWRY/FRbKIyNcODSTew4my51SURERFQNDFUS8nKwwJS+zQAAi7edQ24RT1onIiKqqxiqJDalXzN4NjJHhqoIn4VflLocIiIiekQMVRIzNZHjnafaAgBWH05CXJpK4oqIiIjoUTBUGYB+LZ0wxNcFao3AW1tiOdM6ERFRHcRQZSDefqINzBVyRF+9jd+iOdM6ERFRXcNQZSBcbcwwK6AFAGDJzjjcziuWuCIiIiKqCoYqAzKulxdaOlvhdn4Jlu2+IHU5REREVAUMVQbERG6E955uBwD49VgKTibflrgiIiIiqiyGKgPT1cseI/2aAADe2hyLUrVG4oqIiIioMhiqDFDY4FawMTPB+TQVfjpyVepyiIiIqBIYqgxQI0sl5g1qCQD4+O+LyFQVSlwRERERPQxDlYF6rqsHOrjbIreoFO9tj5O6HCIiInoIhioDJTeS4f1h7WAkA/48nYpDl29KXRIRERE9AEOVAWvX2AYv+XsBAN7eGouiUrW0BREREdF9MVQZuNmBLeBgqcSVG3n47kCi1OUQERHRfTBUGThrUxO8/URrAMDyPZeQcitf4oqIiIioIgxVdcBTHdzg790IRaUaLPzzHITgDZeJiIgMDUNVHSCTyfDusHYwkcuw90Im/jydKnVJRERE9B8MVXWEj5MlpvZvDgBY9Oc53MwtkrgiIiIiuhdDVR3yWv9maO1qjdv5JVi49ZzU5RAREdE9JA1VK1euRPv27WFtbQ1ra2v4+/tj586d2vX9+vWDTCbTeUyePFlnG8nJyQgODoa5uTmcnJwwd+5clJaW6rSJjIxE586doVQq4ePjgzVr1pSrZcWKFfDy8oKpqSm6d++OY8eO1Uifq8NEboSPRraH3EiG7WfTsPNsmtQlERER0f+TNFQ1adIES5cuRXR0NE6cOIEBAwZg6NChOHfu36MwL7/8MtLS0rSPZcuWadep1WoEBwejuLgYhw8fxtq1a7FmzRosWLBA2yYxMRHBwcHo378/YmJiMHPmTEyaNAm7d+/WttmwYQNmz56NhQsX4uTJk+jQoQOCgoKQmZlZO29EFbRrbIMpfZsBuDt31e28YokrIiIiIgCQCQO7lMze3h4fffQRJk6ciH79+qFjx4747LPPKmy7c+dOPPHEE0hNTYWzszMAYNWqVQgNDcWNGzegUCgQGhqK7du3IzY2Vvu65557DtnZ2di1axcAoHv37ujatSu+/PJLAIBGo4G7uzumTZuG+fPnV6pulUoFGxsb5OTkwNrauhrvwMMVlarxxPKDuJSZi2Ed3fDZc51qdH9ERET1lT5/vw3mnCq1Wo3169cjLy8P/v7+2uXr1q2Dg4MD2rVrh7CwMOTn/ztPU1RUFHx9fbWBCgCCgoKgUqm0R7uioqIQEBCgs6+goCBERUUBAIqLixEdHa3TxsjICAEBAdo2FSkqKoJKpdJ51BalsRwfPdMBRjJgS0wq/jmfUWv7JiIioopJHqrOnj0LS0tLKJVKTJ48GZs3b0abNm0AAC+88AJ+/vlnREREICwsDD/99BNefPFF7WvT09N1AhUA7fP09PQHtlGpVCgoKMDNmzehVqsrbFO2jYosWbIENjY22oe7u/ujvwmPoKO7LV7u7Q0AeHPLWeQUlNTq/omIiEiXsdQFtGzZEjExMcjJycFvv/2GsWPHYt++fWjTpg1eeeUVbTtfX1+4urpi4MCBSEhIQLNmzSSsGggLC8Ps2bO1z1UqVa0Hq1mPt0D4+QxcuZmH97adx0fPdKjV/RMREdG/JD9SpVAo4OPjAz8/PyxZsgQdOnTA559/XmHb7t27AwAuX74MAHBxcUFGhu7QV9lzFxeXB7axtraGmZkZHBwcIJfLK2xTto2KKJVK7VWLZY/aZmoix7KR7SGTAZuir2HfxRu1XgMRERHdJXmo+i+NRoOiooontoyJiQEAuLq6AgD8/f1x9uxZnav0wsPDYW1trR1C9Pf3x549e3S2Ex4erj1vS6FQwM/PT6eNRqPBnj17dM7tMlRdvOwxrqcXACDs9zO4U8hhQCIiIilIGqrCwsKwf/9+JCUl4ezZswgLC0NkZCRGjx6NhIQEvPvuu4iOjkZSUhL+/PNPvPTSS+jTpw/at28PAAgMDESbNm0wZswYnD59Grt378Zbb72FkJAQKJVKAMDkyZNx5coVzJs3DxcuXMBXX32FjRs3YtasWdo6Zs+ejW+//RZr165FXFwcpkyZgry8PIwfP16S96Wq5ga1hIe9OVJzCrF05wWpyyEiImqYhIQmTJggPD09hUKhEI6OjmLgwIHi77//FkIIkZycLPr06SPs7e2FUqkUPj4+Yu7cuSInJ0dnG0lJSWLw4MHCzMxMODg4iDlz5oiSkhKdNhEREaJjx45CoVAIb29vsXr16nK1fPHFF8LDw0MoFArRrVs3ceTIkSr1JScnRwAoV19tOXz5pvAM3SY8Q7eJQ5duSFIDERFRXaPP32+Dm6eqrqrNearu560tZ/HzkWS425th14w+sFBKfh0CERGRQauX81RR9c0f3BqNbc2QcqsAH+2Ol7ocIiKiBoWhqh6xVBpjyXBfAMDaqCQcT7olcUVEREQNB0NVPdOnhSNGdXGHEMC8386goFgtdUlEREQNAkNVPfRGcGs4WyuReDMPn/5zUepyiIiIGgSGqnrIxsxEOwz43YEriL56W+KKiIiI6j+GqnpqQCtnDO/UGBoBzNoQg9yiUqlLIiIiqtcYquqxhU+1RWNbMyTfyseiP89JXQ4REVG9xlBVj9mYmeDTUR1hJAN+i76GbWdSpS6JiIio3mKoque6NbVHSH8fAMAbf5xFanaBxBURERHVTwxVDcD0gc3Rwd0WqsJSzNoQA7WGk+gTERHpG0NVA2AiN8LnozrCXCHH0cRb+Gb/FalLIiIiqncYqhoILwcLLHqqLQDg47/jcfZajsQVERER1S8MVQ3IM35NMMTXBaUagRnrTyG/mNMsEBER6QtDVQMik8nwwdO+cLE2xZWbeXh3W5zUJREREdUbDFUNjK25Ap+M6gCZDPj1WDJ2n0uXuiQiIqJ6gaGqAerZzAGv9PEGAMz//QwyVIUSV0RERFT3MVQ1UHMeb4l2ja1xO78Er286DQ2nWSAiIqoWhqoGSmFshM9GdYKpiREOXLqJHw4lSl0SERFRncZQ1YD5OFni7SfaAACW7YrH+VSVxBURERHVXQxVDdwL3TwQ0NoZxWoNZm44hcIStdQlERER1UkMVQ2cTCbDhyN84WilxMWMXCzdeUHqkoiIiOokhipCI0sl/vdMBwDAmsNJiLiQKXFFREREdQ9DFQEA+rZwxIReTQEAczadRlpOgcQVERER1S0MVaQ1b9DdaRZu5RUjZN1JlKg1UpdERERUZzBUkZapiRxfveAHK1NjnEzO5vlVREREVcBQRTo8Gpnjk2c7AgC+P5iInWfTpC2IiIiojmCoonIeb+OMV/vevY3N3N/OIPFmnsQVERERGT6GKqrQ3MCW6NbUHrlFpZjyczQKijl/FRER0YMwVFGFjOVG+PL5TnCwVOJC+h0s2BordUlEREQGjaGK7svJ2hTLn+8IIxmwKfoaNh5PkbokIiIig8VQRQ/Us5kD5gS2BAC8vTWW9wckIiK6D4YqeqgpfZuhf0tHFJVq8Nq6aKgKS6QuiYiIyOAwVNFDGRnJ8Omojmhsa4akrHzM23QGQgipyyIiIjIoDFVUKbbmCnw1ujNM5DLsOpeO7w8mSl0SERGRQWGookrr4G6LBU+0AQAs3XkBJ5JuSVwRERGR4WCooip5sYcnnuzghlKNwNRfTuFmbpHUJRERERkEhiqqEplMhiXDfdHM0QLpqkLMXB8DtYbnVxERETFUUZVZKo2x8kU/mJnIcfDyTXy+55LUJREREUmOoYoeSQtnKywZ7gsA+GLvJRy6fFPiioiIiKTFUEWPbFinxni+mweEAGZtiEEWz68iIqIGTNJQtXLlSrRv3x7W1tawtraGv78/du7cqV1fWFiIkJAQNGrUCJaWlhgxYgQyMjJ0tpGcnIzg4GCYm5vDyckJc+fORWlpqU6byMhIdO7cGUqlEj4+PlizZk25WlasWAEvLy+Ympqie/fuOHbsWI30ub5Z8EQb+DhZIvNOEUJ/5/xVRETUcEkaqpo0aYKlS5ciOjoaJ06cwIABAzB06FCcO3cOADBr1iz89ddf2LRpE/bt24fU1FQMHz5c+3q1Wo3g4GAUFxfj8OHDWLt2LdasWYMFCxZo2yQmJiI4OBj9+/dHTEwMZs6ciUmTJmH37t3aNhs2bMDs2bOxcOFCnDx5Eh06dEBQUBAyMzNr782oo8wUcix/rhMUciP8E5eJn45clbokIiIiaQgDY2dnJ7777juRnZ0tTExMxKZNm7Tr4uLiBAARFRUlhBBix44dwsjISKSnp2vbrFy5UlhbW4uioiIhhBDz5s0Tbdu21dnHqFGjRFBQkPZ5t27dREhIiPa5Wq0Wbm5uYsmSJZWuOycnRwAQOTk5VetwPfH9gSvCM3SbaP7mDhGX1jDfAyIiqnv0+fttMOdUqdVqrF+/Hnl5efD390d0dDRKSkoQEBCgbdOqVSt4eHggKioKABAVFQVfX184Oztr2wQFBUGlUmmPdkVFRelso6xN2TaKi4sRHR2t08bIyAgBAQHaNhUpKiqCSqXSeTRk43t5oX9LRxSXajD911MoLFFLXRIREVGtkjxUnT17FpaWllAqlZg8eTI2b96MNm3aID09HQqFAra2tjrtnZ2dkZ6eDgBIT0/XCVRl68vWPaiNSqVCQUEBbt68CbVaXWGbsm1UZMmSJbCxsdE+3N3dH6n/9YVMJsNHz3SAg6USFzNy8d7281KXREREVKskD1UtW7ZETEwMjh49iilTpmDs2LE4f97wf5DDwsKQk5OjfaSkpEhdkuQcLJX45NkOAICfjyTj73P3D6VERET1jeShSqFQwMfHB35+fliyZAk6dOiAzz//HC4uLiguLkZ2drZO+4yMDLi4uAAAXFxcyl0NWPb8YW2sra1hZmYGBwcHyOXyCtuUbaMiSqVSe9Vi2YOAPi0c8XLvpgCAeb+fQXpOocQVERER1Q7JQ9V/aTQaFBUVwc/PDyYmJtizZ492XXx8PJKTk+Hv7w8A8Pf3x9mzZ3Wu0gsPD4e1tTXatGmjbXPvNsralG1DoVDAz89Pp41Go8GePXu0bahq5ga1QrvG1sjOL8GsDbyNDRERNQyShqqwsDDs378fSUlJOHv2LMLCwhAZGYnRo0fDxsYGEydOxOzZsxEREYHo6GiMHz8e/v7+6NGjBwAgMDAQbdq0wZgxY3D69Gns3r0bb731FkJCQqBUKgEAkydPxpUrVzBv3jxcuHABX331FTZu3IhZs2Zp65g9eza+/fZbrF27FnFxcZgyZQry8vIwfvx4Sd6Xuk5hbITlz3WCuUKOqCtZWLUvQeqSiIiIap4erkZ8ZBMmTBCenp5CoVAIR0dHMXDgQPH3339r1xcUFIjXXntN2NnZCXNzc/H000+LtLQ0nW0kJSWJwYMHCzMzM+Hg4CDmzJkjSkpKdNpERESIjh07CoVCIby9vcXq1avL1fLFF18IDw8PoVAoRLdu3cSRI0eq1JeGPqVCRTYcTxaeoduEd9h2cfLqLanLISIiKkefv98yITgFtj6oVCrY2NggJyeH51f9PyEEpv56CtvPpMHD3hzbpz8GK1MTqcsiIiLS0ufvt8GdU0X1h0wmwwdP+6KxrRmSb+VjwdZzUpdERERUYxiqqEbZmJng8+c6wkgGbD51HZtPXZO6JCIiohrBUEU1rouXPaYPbA4AeGtzLK5m5UlcERERkf4xVFGtmNrfB1297JBXrMb09TEoUWukLomIiEivGKqoVhjLjfDZc51gbWqM0ynZ+N/ueKlLIiIi0iuGKqo1jW3N8OGI9gCAr/dfwa7YNIkrIiIi0h+GKqpVg31dMemxu7exeX3TGSTcyJW4IiIiIv0wrkyjP//8s8obfvzxx2FmZlbl11H9Fzq4Fc5cy8GxpFuY/FM0toT0goWyUn8ViYiIDFalJv80MqraAS2ZTIZLly7B29v7kQurazj5Z9Vk3inEE8sPIvNOEZ5o74ovnu8EmUwmdVlERNTASDL5Z3p6OjQaTaUe5ubm1SqK6j8nK1OsGN0ZxkYybDuThtWHkqQuiYiIqFoqFarGjh1bpaG8F198kUdr6KG6etnjzeDWAIAPdsTheNItiSsiIiJ6dHq9919ubi4sLS31tbk6hcN/j0YIgRnrY/Dn6VQ4WimxfdpjcLI2lbosIiJqICQZ/vv0008fuP7OnTsICgqqVjHU8MhkMiwZ7osWzpa4cacIU385xYlBiYioTqp0qHrjjTfw448/VrguLy8PgwYNQlZWlt4Ko4bDQmmMVS/6wVJpjGNJt7B05wWpSyIiIqqySoeqn376Ca+++mq56RXy8vIQFBSEGzduICIiQu8FUsPg7WiJ/z3TAQDw/cFEbDuTKnFFREREVVPpUDVy5Eh88cUXeP755xEZGQng3yNUGRkZiIyMhKura03VSQ3AoHYumNy3GQBg3m9ncCnjjsQVERERVV6VJqCaNGkSFi5ciKFDhyIyMhKDBw9GamoqIiIi4ObmVlM1UgPyemAL9GzWCPnFarz6czTuFJZIXRIREVGlVPk2NfPmzcOUKVMwcOBAXL9+HZGRkWjSpElN1EYNkLHcCMuf7wRXG1NcuZGHeb+dgR4vUCUiIqoxlb43yPDhw3Wem5iYwMHBATNmzNBZ/scff+inMmqwHCyV+Gp0Zzz7dRR2xqbj2wNX8EqfZlKXRURE9ECVDlU2NjY6z59//nm9F0NUppOHHRY82RZvb4nF0p0X4NvYFv7NGkldFhER0X3pdfLPhoyTf+qfEAJzNp3GHyevo5GFAltCesHdnrdAIiIi/ZFk8k+i2iaTyfD+MF+0dbNGVl4xJq09wRPXiYjIYFUqVA0fPhwqlarSGx09ejQyMzMfuSiiMmYKOb4b2wVOVkrEZ9zB9F9PQa3hwVUiIjI8lRr+k8vluHjxIhwdHR+6QSEE3N3dERMTA29vb70UWRdw+K9mnbmWjWe/jkJhiQYTejXFgifbSF0SERHVA/r8/a7UiepCCLRo0aJaOyKqjvZNbPHJsx3x2rqT+OFQIpo5WWB0d0+pyyIiItKqVKh6lNvPNG7cuMqvIXqQIb6umPN4C3wcfhELtp6DVyML9PJxkLosIiIiALz6T284/Fc7hBCYtSEGW2JSYW1qjM0hvdDM0VLqsoiIqI7i1X/UYMlkMiwd0R5+nnZQFZZi4prjuJ1XLHVZREREDFVU95iayPH1GD80sTNDUlY+pqyLRnGpRuqyiIiogWOoojrJwVKJ78d2haXSGEeu3MLbW2J5j0AiIpIUQxXVWS1drPDF851gJAM2nEjBdwcSpS6JiIgasEcKVaWlpfjnn3/w9ddf486dOwCA1NRU5Obm6rU4oofp38oJbwXfnbPqg51xCD+fIXFFRETUUFU5VF29ehW+vr4YOnQoQkJCcOPGDQDAhx9+iNdff13vBRI9zPheXnihuweEAGasP4XzqZWf/Z+IiEhfqhyqZsyYgS5duuD27dswMzPTLn/66aexZ88evRZHVBkymQzvPNUWvXwaIb9YjUlrjyPzTqHUZRERUQNT5VB14MABvPXWW1AoFDrLvby8cP36db0VRlQVJnIjfPWCH7wdLJCaU4iXf4xGYYla6rKIiKgBqXKo0mg0UKvL/1hdu3YNVlZWeimK6FHYmJvg+3FdYWtugtMp2Zj6yymUqjnVAhER1Y4qh6rAwEB89tln2ucymQy5ublYuHAhhgwZos/aiKqsqYMFvhnTBQpjI/wTl4G3ONUCERHVkirfpiYlJQWDBg2CEAKXLl1Cly5dcOnSJTg4OGD//v1wcnKqqVoNGm9TY1h2n0vHlJ+joRHAtAE+mBPYUuqSiIjIAOnz9/uR7v1XWlqKDRs24PTp08jNzUXnzp0xevRonRPXGxqGKsPzy9FkvLH5LADgnafaYmxPL2kLIiIigyNZqCopKUGrVq2wbds2tG7dulo7rm8YqgzT8j2X8En4RchkwBfPd8IT7d2kLomIiAyIZDdUNjExQWGh/i5VX7JkCbp27QorKys4OTlh2LBhiI+P12nTr18/yGQyncfkyZN12iQnJyM4OBjm5uZwcnLC3LlzUVpaqtMmMjISnTt3hlKphI+PD9asWVOunhUrVsDLywumpqbo3r07jh07pre+kjSmDfDBmB6eEAKYtSEGBy/dlLokIiKqp6p8onpISAg+/PDDcqHlUezbtw8hISE4cuQIwsPDUVJSgsDAQOTl5em0e/nll5GWlqZ9LFu2TLtOrVYjODgYxcXFOHz4MNauXYs1a9ZgwYIF2jaJiYkIDg5G//79ERMTg5kzZ2LSpEnYvXu3ts2GDRswe/ZsLFy4ECdPnkSHDh0QFBSEzMzMaveTpCOTybDoqbYY4uuCErXAqz+dQOz1HKnLIiKieqjK51SVTfJpaWkJX19fWFhY6Kz/448/HrmYGzduwMnJCfv27UOfPn0A3D1S1bFjR50rDu+1c+dOPPHEE0hNTYWzszMAYNWqVQgNDcWNGzegUCgQGhqK7du3IzY2Vvu65557DtnZ2di1axcAoHv37ujatSu+/PJLAHenjnB3d8e0adMwf/78h9bO4T/DVlSqxrgfjiPqShYcLBX4bXJPeDlYPPyFRERUr0k2/AcAtra2GDFiBIKCguDm5gYbGxudR3Xk5Nw9gmBvb6+zfN26dXBwcEC7du0QFhaG/Px87bqoqCj4+vpqAxUABAUFQaVS4dy5c9o2AQEBOtsMCgpCVFQUAKC4uBjR0dE6bYyMjBAQEKBt819FRUVQqVQ6DzJcSmM5vnnJD21crXEztxgv/XCMs64TEZFeGVf1BatXr66JOqDRaDBz5kz06tUL7dq10y5/4YUX4OnpCTc3N5w5cwahoaGIj4/XHhFLT0/XCVQAtM/T09Mf2EalUqGgoAC3b9+GWq2usM2FCxcqrHfJkiV45513qtdpqlVWpiZYM6ErRq6MQvKtfIz74Tg2vNoDVqYmUpdGRET1QJVDVU0JCQlBbGwsDh48qLP8lVde0f7Z19cXrq6uGDhwIBISEtCsWbPaLlMrLCwMs2fP1j5XqVRwd3eXrB6qHCcrU/w4oRtGrjqM82kqvPJjNFaP7wpTE7nUpRERUR1X5VDVtGlTyGSy+66/cuVKlYuYOnUqtm3bhv3796NJkyYPbNu9e3cAwOXLl9GsWTO4uLiUu0ovIyMDAODi4qL9b9mye9tYW1vDzMwMcrkccrm8wjZl2/gvpVIJpVJZ+U6SwfBysMCa8d0w6usoRF3JwuyNMfji+c6QG93/7zUREdHDVDlUzZw5U+d5SUkJTp06hV27dmHu3LlV2pYQAtOmTcPmzZsRGRmJpk2bPvQ1MTExAABXV1cAgL+/P95//31kZmZqZ3MPDw+HtbU12rRpo22zY8cOne2Eh4fD398fAKBQKODn54c9e/Zg2LBhAO4OR+7ZswdTp06tUp+obmjX2AbfvNQF41Yfw46z6WhkcQ6Lh7Z94P8wEBERPZDQky+//FKMGzeuSq+ZMmWKsLGxEZGRkSItLU37yM/PF0IIcfnyZbF48WJx4sQJkZiYKLZu3Sq8vb1Fnz59tNsoLS0V7dq1E4GBgSImJkbs2rVLODo6irCwMG2bK1euCHNzczF37lwRFxcnVqxYIeRyudi1a5e2zfr164VSqRRr1qwR58+fF6+88oqwtbUV6enplepLTk6OACBycnKq9B6QtP46fV14zd8mPEO3iU/+jpe6HCIiqmX6/P3WW6hKSEgQVlZWVds5UOFj9erVQgghkpOTRZ8+fYS9vb1QKpXCx8dHzJ07t1zHk5KSxODBg4WZmZlwcHAQc+bMESUlJTptIiIiRMeOHYVCoRDe3t7afdzriy++EB4eHkKhUIhu3bqJI0eOVLovDFV115pDicIz9G6w+iristTlEBFRLdLn7/cj3fuvIsuWLcNXX32FpKQkfWyuzuE8VXXbiojL+Gj33dn83wpujUm9vSWuiIiIaoM+f7+rfE5Vp06ddM47EUIgPT0dN27cwFdffVWtYoikEtLfB8WlGny+5xLe2x4HhbERXvL3krosIiKqQ6ocqoYOHaoTqoyMjODo6Ih+/fqhVatWei2OqDbNDGiOErUGX0UmYMHWczA2MsIL3T2kLouIiOoIvQ3/NXQc/qsfhBD4YEccvj2QCAD4aGR7PNOF848REdVXkt6mRi6XV3iT4aysLMjlnECR6jaZTIY3hrTGuJ5eAIB5v5/BllPXpS2KiIjqhCqHqvsd2CoqKoJCoah2QURSk8lkWPhkG7zQ3QNCALM3xmD7mTSpyyIiIgNX6XOqli9fDuDuD853330HS0tL7Tq1Wo39+/fznCqqN2QyGd4b2g4lpRpsir6G6etPQW4kw6B2Fc+wT0REVOlzqspmO7969SqaNGmiM9SnUCjg5eWFxYsXa28j09DwnKr6Sa0ReH3TaWw+dR0mchlWveiHga2dH/5CIiKqEySZUiEx8e6Ju/3798cff/wBOzu7au2YqC6QG8nw0cj2KFFrsO1MGqb8fBLfju2Cvi0cpS6NiIgMTJXPqYqIiGCgogbFWG6ET0d1xKC2LihWa/DKjydw+PJNqcsiIiID80hTKly7dg1//vknkpOTUVxcrLPuk08+0VtxdQmH/+q/4lINXlsXjX/iMmFmIsea8V3R3buR1GUREVE1SDqj+p49e/DUU0/B29sbFy5cQLt27ZCUlAQhBDp37lytYogMmcLYCCtGd8YrP0Zj38UbGL/mOH4Y1xU9GKyIiAiPMPwXFhaG119/HWfPnoWpqSl+//13pKSkoG/fvnjmmWdqokYig6E0luPrMX7o3dwB+cVqjP3hGCLjy8/bRkREDU+VQ1VcXBxeeuklAICxsTEKCgpgaWmJxYsX48MPP9R7gUSGxtREjm9f6oKBrZxQVKrByz+ewK7YdKnLIiIiiVU5VFlYWGjPo3J1dUVCQoJ23c2bPHmXGgZTEzlWjfFDcHtXlKgFQn45yZnXiYgauCqfU9WjRw8cPHgQrVu3xpAhQzBnzhycPXsWf/zxB3r06FETNRIZJBO5EZY/1wlmJnL8Fn0NszbGoKBEjee78SbMREQNUZVD1SeffILc3FwAwDvvvIPc3Fxs2LABzZs3b7BX/lHDJTeSYdmI9jAzkeOnI1cR9sdZ5BerMfGxplKXRkREtaxKoUqtVuPatWto3749gLtDgatWraqRwojqCiMjGRYPbQtzhRxf77+Cd7edR0FxKaYOaC51aUREVIuqdE6VXC5HYGAgbt++XVP1ENVJMpkM8we3wuzHWwAA/vf3RXy468J9b0BORET1T5VPVG/Xrh2uXLlSE7UQ1WkymQzTBzbHW8GtAQArIxPwzl/nodEwWBERNQRVDlXvvfceXn/9dWzbtg1paWlQqVQ6D6KGblJvb7z/dDvIZMCaw0mY/8cZqBmsiIjqvSrfpsbI6N8cJpPJtH8WQkAmk0GtVuuvujqEt6mh//rj5DW8vuk0NAJ4soMbPnm2A0zkVf7/GCIiqkGS3qYmIiKiWjskaiiGd24CMxM5pq8/hb9Op6KgWI0vX+gEUxO51KUREVENeKQbKlN5PFJF9xNxIROTf45GUakGPbzt8fWYLrAxM5G6LCIign5/vx9pLOLAgQN48cUX0bNnT1y/fncW6Z9++gkHDx6sVjFE9VH/Vk5YPb4rLJXGOHLlFp5dFYW0nAKpyyIiIj2rcqj6/fffERQUBDMzM5w8eRJFRUUAgJycHHzwwQd6L5CoPujZzAEbXu0BJysl4jPuYPhXh3Ex447UZRERkR490tV/q1atwrfffgsTk3+HMHr16oWTJ0/qtTii+qStmw3+eK0nmjlaIC2nECNXHsaRK1lSl0VERHpS5VAVHx+PPn36lFtuY2OD7OxsfdREVG81sTPH71N6oounHVSFpXjp+2PYfiZN6rKIiEgPqhyqXFxccPny5XLLDx48CG9vb70URVSf2Zor8POk7ghq64xitQZTfz2JHw4mSl0WERFVU5VD1csvv4wZM2bg6NGjkMlkSE1Nxbp16/D6669jypQpNVEjUb1jaiLHV6P98JK/J4QAFm87jw92xHH2dSKiOqzK81TNnz8fGo0GAwcORH5+Pvr06QOlUonXX38d06ZNq4kaieoluZEM7zzVFq42Zvhw1wV8s/8K0nIK8b9n2kNpzLmsiIjqmkeep6q4uBiXL19Gbm4u2rRpA0tLS33XVqdwniqqjj9OXsO8386gVCPg790IX7/kB2tTzmVFRFTTJJ+nCgAUCgWsrKzg6ura4AMVUXUN79wEq8d3hYVCjqgrWXh2VRTScwqlLouIiKqgyqGqtLQUb7/9NmxsbODl5QUvLy/Y2NjgrbfeQklJSU3USNQg9G7uiA2v+sPRSokL6Xcw/KtDnMuKiKgOqXKomjZtGr755hssW7YMp06dwqlTp7Bs2TJ8//33mD59ek3USNRgtGtsgz+m9IS3owVScwoxYuVh7Lt4Q+qyiIioEqp8TpWNjQ3Wr1+PwYMH6yzfsWMHnn/+eeTk5Oi1wLqC51SRPt3OK8bLP57Aiau3YSQD3gpug/G9vCCTyaQujYioXpH0nCqlUgkvL69yy5s2bQqFQlGtYojoLjsLBda93B0j/ZpA8/9TLryx+SyKSzVSl0ZERPdR5VA1depUvPvuu9p7/gFAUVER3n//fUydOlWvxRE1ZEpjOT4a2R5vDmkNmQz49VgKxnx/FLfziqUujYiIKlDl4b+nn34ae/bsgVKpRIcOHQAAp0+fRnFxMQYOHKjT9o8//tBfpQaOw39Uk/ZeyMD0X2OQW1QKD3tzfD+2C5o7W0ldFhFRnafP3+8qT/5pa2uLESNG6Cxzd3evVhFE9GADWjnjj9d6YuLa40i+lY+nvzqML57vhP6tnKQujYiI/t8jT/5JunikimrDrbxiTP45GscSb8FIBrwxpDUmPtaUJ7ATET0ig5j8Ux+WLFmCrl27wsrKCk5OThg2bBji4+N12hQWFiIkJASNGjWCpaUlRowYgYyMDJ02ycnJCA4Ohrm5OZycnDB37lyUlpbqtImMjETnzp2hVCrh4+ODNWvWlKtnxYoV8PLygqmpKbp3745jx47pvc9E1WFvocDPE7vjua7u0Ajgve1xmPfbGRSVqqUujYiowatyqMrKykJISAjatGkDBwcH2Nvb6zyqYt++fQgJCcGRI0cQHh6OkpISBAYGIi8vT9tm1qxZ+Ouvv7Bp0ybs27cPqampGD58uHa9Wq1GcHAwiouLcfjwYaxduxZr1qzBggULtG0SExMRHByM/v37IyYmBjNnzsSkSZOwe/dubZsNGzZg9uzZWLhwIU6ePIkOHTogKCgImZmZVX2LiGqUwtgIS4b7YsETbWAkAzZFX8OL3x1FVm7Rw19MREQ1psrDf0OGDMHly5cxceJEODs7lxt2GDt27CMXc+PGDTg5OWHfvn3o06cPcnJy4OjoiF9++QUjR44EAFy4cAGtW7dGVFQUevTogZ07d+KJJ55AamoqnJ2dAQCrVq1CaGgobty4AYVCgdDQUGzfvh2xsbHafT333HPIzs7Grl27AADdu3dH165d8eWXXwIANBoN3N3dMW3aNMyfP/+htXP4j6QQGZ+Jab+cwp2iUjS2NcP347qglQv//hERVZakJ6ofOHAABw8e1F75p09lE4eWHfGKjo5GSUkJAgICtG1atWoFDw8PbaiKioqCr6+vNlABQFBQEKZMmYJz586hU6dOiIqK0tlGWZuZM2cCuHtz6OjoaISFhWnXGxkZISAgAFFRURXWWlRUpDOthEqlql7niR5Bv5ZO2BzSExPXnsDVrHyM+OowPn62Awa1c5W6NCKiBqfKw3+tWrVCQUGB3gvRaDSYOXMmevXqhXbt2gEA0tPToVAoYGtrq9PW2dkZ6enp2jb3Bqqy9WXrHtRGpVKhoKAAN2/ehFqtrrBN2Tb+a8mSJbCxsdE+eAUkScXHyQpbXuuFns0aIa9Yjck/n8QHO+JQquZEoUREtanKoeqrr77Cm2++iX379iErKwsqlUrn8ahCQkIQGxuL9evXP/I2alNYWBhycnK0j5SUFKlLogbMzkKBtRO64ZU+3gCAb/ZfwQvfHUXmnUKJKyMiajiqHKpsbW2hUqkwYMAAODk5wc7ODnZ2drC1tYWdnd0jFTF16lRs27YNERERaNKkiXa5i4sLiouLkZ2drdM+IyMDLi4u2jb/vRqw7PnD2lhbW8PMzAwODg6Qy+UVtinbxn8plUpYW1vrPIikZCI3whtDWmPl6M6wVBrjWOItPLH8II4n3ZK6NCKiBqHKoWr06NEwMTHBL7/8gj179mDv3r3Yu3cvIiIisHfv3iptSwiBqVOnYvPmzdi7dy+aNm2qs97Pzw8mJibYs2ePdll8fDySk5Ph7+8PAPD398fZs2d1rtILDw+HtbU12rRpo21z7zbK2pRtQ6FQwM/PT6eNRqPBnj17tG2I6orBvq7YOrUXmjtZIvNOEZ775gi+O3AFnJKOiKiGiSoyMzMTFy5cqOrLKjRlyhRhY2MjIiMjRVpamvaRn5+vbTN58mTh4eEh9u7dK06cOCH8/f2Fv7+/dn1paalo166dCAwMFDExMWLXrl3C0dFRhIWFadtcuXJFmJubi7lz54q4uDixYsUKIZfLxa5du7Rt1q9fL5RKpVizZo04f/68eOWVV4Stra1IT0+vVF9ycnIEAJGTk6OHd4ao+nILS8S0X04Kz9BtwjN0m3htXbS4U1gidVlERAZFn7/fVQ5VvXv3FuHh4dXesRBCAKjwsXr1am2bgoIC8dprrwk7Ozthbm4unn76aZGWlqaznaSkJDF48GBhZmYmHBwcxJw5c0RJie6PR0REhOjYsaNQKBTC29tbZx9lvvjiC+Hh4SEUCoXo1q2bOHLkSKX7wlBFhkij0Yg1hxJFs7DtwjN0mxjwvwhxKUMldVlERAZDn7/fVZ6natOmTVi0aBHmzp0LX19fmJiY6Kxv3769Ho6f1T2cp4oMWfTV2whZdxLpqkKYK+RYNrI9nmjvJnVZRESS0+fvd5VDlZFR+dOwZDIZhBCQyWRQqxvm7TIYqsjQ3cwtwrRfTiHqShYAYHwvL7wxpDVM5JLerYqISFKShqqrV68+cL2np2e1CqqrGKqoLihVa/Bx+EWsjEwAAHTxtMOXL3SGi42pxJUREUlD0lBFFWOoorrk73PpmLPxNO4UlcLeQoH/PdMeA1o5P/yFRET1jD5/vx/puP9PP/2EXr16wc3NTXvk6rPPPsPWrVurVQwR1Y7Ati74a9pjaO1qjVt5xZiw5gTe+escikob5vA9EZE+VDlUrVy5ErNnz8aQIUOQnZ2tPYfK1tYWn332mb7rI6Ia4uVggc2v9cT4Xl4AgNWHkvD0isNIuJErbWFERHVUlUPVF198gW+//RZvvvkm5HK5dnmXLl1w9uxZvRZHRDXL1ESOhU+2xfdju8DeQoHzaSo8sfwgNh5P4WShRERVVOVQlZiYiE6dOpVbrlQqkZeXp5eiiKh2DWztjJ0zeqNns0YoKFFj3u9nMO3XU1AVlkhdGhFRnVHlUNW0aVPExMSUW75r1y60bt1aHzURkQScrU3x08TumDeoJeRGMmw7k4Yhnx/AyeTbUpdGRFQnVDpULV68GPn5+Zg9ezZCQkKwYcMGCCFw7NgxvP/++wgLC8O8efNqslYiqmFyIxle6+eDTZP94W5vhmu3C/DMqiisiLgMtYbDgURED1LpKRXkcjnS0tLg5OSEdevWYdGiRUhIuDvXjZubG9555x1MnDixRos1ZJxSgeobVWEJ3tociz9PpwIAejZrhE9HdYSzNee0IqL6Q5J5qoyMjJCeng4nJyftsvz8fOTm5uosa6gYqqg+EkLgt+hrWPjnOeQXq2FnboKPRnZAQBvOaUVE9YNk81TJZDKd5+bm5gxURPWYTCbDM13c8de0x9DWzRq380sw6ccTmP/7GeQWlUpdHhGRQanSkSobG5tyweq/bt26pZfC6hoeqaL6rqhUjY92xeO7g4kAgCZ2ZvhoZAf4N2skcWVERI9On7/fxlVp/M4778DGxqZaOySiuklpLMdbT7TBwNbOmPvbaVy7XYDnvz2C8b28EDqoFUxN5A/fCBFRPVatc6roXzxSRQ1JblEp3t8eh1+PJQMAvB0t8PEzHdDJw07iyoiIqkaSc6oeNuxHRA2HpdIYS4b7Ys34rnC2VuLKjTyMWHkYH+2+gOJSjdTlERFJotKhiresIKL/6tfSCX/P7IthHd2gEcCKiAQ89eVBnE9VSV0aEVGtq3So0mg0HPojonJszE3w2XOdsHJ0Z9hbKHAh/Q6GrjiIFRGXUarmUSsiajiqfJsaIqKKDPZ1xd+z+iCwjTNK1AIf7Y7HyFVRSLiRK3VpRES1gqGKiPTGwVKJr8f44ZNnO8DK1BgxKdkY8vkBfLv/Co9aEVG9x1BFRHolk8kwvHMT/D2rD3o3d0BRqQbv74jD018dRuz1HKnLIyKqMQxVRFQjXG3M8OOEblg2oj2sTY1x9noOhq44hCU741BQrJa6PCIivWOoIqIaI5PJ8GxXd/wzpy+C27tCrRH4et8VDPp8Pw5dvil1eUREesVQRUQ1zsnKFCte6IzvXuoCVxtTXM3Kx+jvjmLuptPIzi+WujwiIr1gqCKiWhPQxhl/z+qDsf6ekMmATdHXEPDJPvx5OpVz4RFRncdQRUS1ysrUBO8MbYffJvdEcydL3MwtxvRfT2Hi2hO4nl0gdXlERI+MoYqIJOHnaYft03tjVkALKORG2HshE4Gf7MOaQ4lQa3jUiojqHoYqIpKMwtgIMwKaY8eMx9DVyw55xWos+us8hq88jLPXOP0CEdUtDFVEJDkfJytseMUf7w1rByulMU6nZOOpFQfx1pazPJGdiOoMhioiMghGRjK82MMTe+bcvUGzEMDPR5Ix4ON92HA8GRoOCRKRgZMJXnKjFyqVCjY2NsjJyYG1tbXU5RDVeUeuZGHh1nOIz7gDAOjobot3h7aDbxMbiSsjovpEn7/fDFV6wlBFpH8lag3WHk7CZ/9cQm5RKWQy4IVuHpgb1BK25gqpyyOiekCfv98c/iMig2UiN8Kk3t7Ye8+Q4Lqjyej/v0isP8YhQSIyLDxSpSc8UkVU8zgkSET6xuE/A8RQRVQ77jckOCewJewtOCRIRFXDUGWAGKqIalemqhAf7IjDlphUAICVqTGmD2iOl3p6Qmksl7g6IqorGKoMEEMVkTSOXMnC4r/O43yaCgDg2cgcYYNbIaitC2QymcTVEZGhY6gyQAxVRNJRawR+P3kNH+2Ox407RQCAbl72eOuJ1mjfxFba4ojIoDFUGSCGKiLp5RWV4ut9CfjmwBUUlmgAAMM7N8bcoJZwtTGTuDoiMkQMVQaIoYrIcKRmF+Cj3fHYfOo6AMDUxAiv9GmGV/t4w0JpLHF1RGRIGKoMEEMVkeE5nZKN97afx/Gk2wAAJyslXg9qiZGdm8DIiOdbEVE9mvxz//79ePLJJ+Hm5gaZTIYtW7borB83bhxkMpnOY9CgQTptbt26hdGjR8Pa2hq2traYOHEicnNzddqcOXMGvXv3hqmpKdzd3bFs2bJytWzatAmtWrWCqakpfH19sWPHDr33l4hqVwd3W2x81R8rR3eGh705Mu8UYd5vZ/Dklwdx+PJNqcsjonpG0lCVl5eHDh06YMWKFfdtM2jQIKSlpWkfv/76q8760aNH49y5cwgPD8e2bduwf/9+vPLKK9r1KpUKgYGB8PT0RHR0ND766CMsWrQI33zzjbbN4cOH8fzzz2PixIk4deoUhg0bhmHDhiE2Nlb/nSaiWiWTyTDY1xXhs/vgjSGtYKU0xrlUFV747ijGfH8UZ65lS10iEdUTBjP8J5PJsHnzZgwbNky7bNy4ccjOzi53BKtMXFwc2rRpg+PHj6NLly4AgF27dmHIkCG4du0a3NzcsHLlSrz55ptIT0+HQnF3YsD58+djy5YtuHDhAgBg1KhRyMvLw7Zt27Tb7tGjBzp27IhVq1ZVuO+ioiIUFRVpn6tUKri7u3P4j8jAZeUW4Yu9l7Hu6FWUqO/+8xfs64rZgS3QzNFS4uqIqLbVm+G/yoiMjISTkxNatmyJKVOmICsrS7suKioKtra22kAFAAEBATAyMsLRo0e1bfr06aMNVAAQFBSE+Ph43L59W9smICBAZ79BQUGIioq6b11LliyBjY2N9uHu7q6X/hJRzWpkqcSip9pi75x+GN6pMWQyYPvZNAR+uh/zfz+DtJwCqUskojrKoEPVoEGD8OOPP2LPnj348MMPsW/fPgwePBhqtRoAkJ6eDicnJ53XGBsbw97eHunp6do2zs7OOm3Knj+sTdn6ioSFhSEnJ0f7SElJqV5niahWudub45NRHbFzRm8EtHaGWiOw/ngK+n4UiQ92xOF2XrHUJRJRHWPQ1xY/99xz2j/7+vqiffv2aNasGSIjIzFw4EAJKwOUSiWUSqWkNRBR9bVyscZ3Y7sg+uotfLgzHseSbuGb/Vfw69FkvNrXG+N7NeU0DERUKQZ9pOq/vL294eDggMuXLwMAXFxckJmZqdOmtLQUt27dgouLi7ZNRkaGTpuy5w9rU7aeiOo/P097bHi1B1aP74rWrta4U1SK//19EX0/isTaw0koLtVIXSIRGbg6FaquXbuGrKwsuLq6AgD8/f2RnZ2N6OhobZu9e/dCo9Gge/fu2jb79+9HSUmJtk14eDhatmwJOzs7bZs9e/bo7Cs8PBz+/v413SUiMiAymQz9Wzph+7TH8PlzHeHZyBw3c4uw8M9zGPBxJDYcT0aJmuGKiCom6dV/ubm52qNOnTp1wieffIL+/fvD3t4e9vb2eOeddzBixAi4uLggISEB8+bNw507d3D27Fnt0NvgwYORkZGBVatWoaSkBOPHj0eXLl3wyy+/AABycnLQsmVLBAYGIjQ0FLGxsZgwYQI+/fRT7dQLhw8fRt++fbF06VIEBwdj/fr1+OCDD3Dy5Em0a9euUn3h5J9E9U+JWoMNx1Pw+Z5L2nsKNrEzw7QBPhjeuQlM5HXq/0uJqAJ6/f0WEoqIiBAAyj3Gjh0r8vPzRWBgoHB0dBQmJibC09NTvPzyyyI9PV1nG1lZWeL5558XlpaWwtraWowfP17cuXNHp83p06fFY489JpRKpWjcuLFYunRpuVo2btwoWrRoIRQKhWjbtq3Yvn17lfqSk5MjAIicnJyqvxFEZNDyi0rFt/sThN+74cIzdJvwDN0mei3dI9YfuyqKS9VSl0dE1aDP32+DmaeqruORKqL6r6BYjXVHr2LVviu4mcsjV0T1Ae/9Z4AYqogaDoYrovqDocoAMVQRNTwMV0R1H0OVAWKoImq47heupvRrhhGdm8DURC5xhUR0PwxVBoihiogqCleOVkpMfKwpRnf3gJWpicQVEtF/MVQZIIYqIipTUKzGr8eS8e2BK0jLKQQAWJsa4yV/L4zr5QUHS96NgchQMFQZIIYqIvqv4lINtsZcx6p9CUi4kQcAMDUxwqgu7ni5jzea2JlLXCERMVQZIIYqIrofjUbg7/MZWBl5Gaev5QAA5EYyDO3ghsn9mqGFs5XEFRI1XAxVBoihiogeRgiBwwlZWBmZgIOXb2qXP97GGVP6NUNnDzsJqyNqmBiqDBBDFRFVxemUbKyMTMDu8+ko+1e4e1N7TOrtjYGtnGBkJJO2QKIGgqHKADFUEdGjuJyZi6/3JWDzqeso1dz957ipgwUm9PLCCL8mMFcYS1whUf3GUGWAGKqIqDrScgqw5nASfjmajDuFpQAAGzMTjO7ugbE9veBsbSpxhUT1E0OVAWKoIiJ9yCsqxaYTKVh9OAlXs/IBACZyGZ5s74aJvZuirZuNxBUS1S8MVQaIoYqI9EmtEfgnLgPfH0jEsaRb2uX+3o0wqXdT9G/J866I9IGhygAxVBFRTTmdko3vDyZi+9k0qP//vCtvRwtM6NUUwzs35nlXRNXAUGWAGKqIqKalZhdg7eEk/HLs3/OurEyN8YyfO8b4e6Kpg4XEFRLVPQxVBoihiohqS25RKTYeT8GPUUlI+v/zrgCgTwtHjPX3RL+WTpBzaJCoUhiqDBBDFRHVNo1GYP+lG/gx6ioi4jO18101sTPDmB6eeLaLO+wsFNIWSWTgGKoMEEMVEUkpOSsfPx+9ig3HU5BTUAIAUBob4akObhjb0wvtGvOqQaKKMFQZIIYqIjIEBcVq/HU6FWsOJ+F8mkq7vJOHLcb6e2GwrwuUxnIJKyQyLAxVBoihiogMiRACJ5Nv48eoq9hxNg0l6rv/1NtbKDCic2M8180DzRwtJa6SSHoMVQaIoYqIDFXmnUJsOJaCdUeTka4q1C7v3tQeL3T3QFBbF5ia8OgVNUwMVQaIoYqIDF2pWoPI+Bv49VgyIuIz8f9TXsHW3ATDOzXB893c0dzZStoiiWoZQ5UBYqgiorokLacAG49fw4bjyUjN+ffoVVcvOzzX1QPB7V159IoaBIYqA8RQRUR1kVojsP/iDfxyLBl7L2RqZ2y3NjXG8M5N8Fw3d7Ry4b9pVH8xVBkghioiqusyVIXYdCIFvx5LwfXsAu1y38Y2eKZLEzzVwQ225pz3iuoXhioDxFBFRPWFRiNw4PJN/Ho0Gf/EZaD0/49eKeRGCGjjhGf83NG7uQOM5UYSV0pUfQxVBoihiojqo6zcImyNScVv0dd05r1ytFJieKfGGOnXhCe3U53GUGWAGKqIqL47l5qD36KvYWtMKm7lFWuXd3C3xUi/JniqvRtszE0krJCo6hiqDBBDFRE1FMWlGkTEZ2LTiWuIiP/35HaFsREC2zhjeOfG6N3cESYcHqQ6gKHKADFUEVFDdONOEbbGXMdv0ddwIf2Odrm9hQJPtHfF0I6N0dnDFjKZTMIqie6PocoAMVQRUUMmhMC5VBV+i76GbWdScTP33+FBD3tzDO3ohqEdG8PHibfGIcPCUGWAGKqIiO4qVWtw8PJNbI1Jxe5z6cgvVmvX+Ta2wdCObniqgxucrE0lrJLoLoYqA8RQRURUXn5xKcLPZ2BrTCr2XbyhPf/KSAb08nHA0I6NEdTWGVamPMGdpMFQZYAYqoiIHiwrtwjbz6Zhy6nrOJmcrV2uMDZC/5aOCG7vhoGtnGChNJauSGpwGKoMEEMVEVHlXc3Kw9aYVGyJuY4rN/K0y01NjDCglROeaO+G/i2dYKbg/QepZjFUGSCGKiKiqhNCIC7tDrafTcW2M2m4mpWvXWdmIsfA1ncDVr+WjrzBM9UIhioDxFBFRFQ9ZVcQ/nUmFdvPpOHa7X/vP2ihkOPxNs4Ibu+GPi0coDRmwCL9YKgyQAxVRET6I4TA6Ws52P7/ASs1p1C7zkppjIGtnTConQv6tHCEuYLnYNGjY6gyQAxVREQ1Q6MROJWSjW1nUrHjbBoyVEXadaYmRujbwhGD2rlgQCtn2JjxKkKqGoYqA8RQRURU8zQagZPJt7H7XDp2xqbrDBGayGXo2cwBg9q54PE2znCwVEpYKdUV+vz9lvTGTPv378eTTz4JNzc3yGQybNmyRWe9EAILFiyAq6srzMzMEBAQgEuXLum0uXXrFkaPHg1ra2vY2tpi4sSJyM3N1Wlz5swZ9O7dG6ampnB3d8eyZcvK1bJp0ya0atUKpqam8PX1xY4dO/TeXyIiqh4jIxm6eNnjzeA2ODCvP7ZNewzTBviguZMlStQC+y7eQNgfZ9Ht/X/w7NdR+OFgIlKzCx6+YSI9kDRU5eXloUOHDlixYkWF65ctW4bly5dj1apVOHr0KCwsLBAUFITCwn/H1kePHo1z584hPDwc27Ztw/79+/HKK69o16tUKgQGBsLT0xPR0dH46KOPsGjRInzzzTfaNocPH8bzzz+PiRMn4tSpUxg2bBiGDRuG2NjYmus8ERFVi0wmQ7vGNpgT2BLhs/vin9l9MTeoJdo3sYFGAMcSb2HxtvPouXQvnvziID775yJir+eAAzRUUwxm+E8mk2Hz5s0YNmwYgLtHqdzc3DBnzhy8/vrrAICcnBw4OztjzZo1eO655xAXF4c2bdrg+PHj6NKlCwBg165dGDJkCK5duwY3NzesXLkSb775JtLT06FQKAAA8+fPx5YtW3DhwgUAwKhRo5CXl4dt27Zp6+nRowc6duyIVatWVVhvUVERior+HddXqVRwd3fn8B8RkQG4djsff5/LwK5z6TiedAv3/tK52ZhiYGtnBLRxRg9ve15J2MDVm+G/B0lMTER6ejoCAgK0y2xsbNC9e3dERUUBAKKiomBra6sNVAAQEBAAIyMjHD16VNumT58+2kAFAEFBQYiPj8ft27e1be7dT1mbsv1UZMmSJbCxsdE+3N3dq99pIiLSiyZ25pjwWFNsfNUfx98MwLKR7RHYxhlmJnKk5hTipyNXMfaHY+i8OByvrYvGHyev4XZe8cM3TPQABnsdanp6OgDA2dlZZ7mzs7N2XXp6OpycnHTWGxsbw97eXqdN06ZNy22jbJ2dnR3S09MfuJ+KhIWFYfbs2drnZUeqiIjIsDhYKvFsF3c828UdhSVqHE64ifDzmdgTl4HMO0XYcTYdO86mw0gGdPGyx+OtnTGwtRO8HS2lLp3qGIMNVYZOqVRCqeSVJUREdYmpiRwDWjljQCtnaDTtcPZ6DvbEZSA8LhNxaSocS7yFY4m38P6OOHg2Mkf/lk7o19IRPbwbcUZ3eiiDDVUuLi4AgIyMDLi6umqXZ2RkoGPHjto2mZmZOq8rLS3FrVu3tK93cXFBRkaGTpuy5w9rU7aeiIjqHyMjGTq426KDuy1mB7bEtdv52BOXifDzGTiamIWrWflYczgJaw4nwdTECD2bOaB/S0f0a+kEd3tzqcsnA2Sw51Q1bdoULi4u2LNnj3aZSqXC0aNH4e/vDwDw9/dHdnY2oqOjtW327t0LjUaD7t27a9vs378fJSUl2jbh4eFo2bIl7OzstG3u3U9Zm7L9EBFR/dfEzhxje3rh50ndcWpBIL4Z44fnu3nA1cYUhSUa7L2Qibe3nkPvZRF4/JN9+GBHHA4n3ERxqUbq0slASHr1X25uLi5fvgwA6NSpEz755BP0798f9vb28PDwwIcffoilS5di7dq1aNq0Kd5++22cOXMG58+fh6mpKQBg8ODByMjIwKpVq1BSUoLx48ejS5cu+OWXXwDcvWKwZcuWCAwMRGhoKGJjYzFhwgR8+umn2qkXDh8+jL59+2Lp0qUIDg7G+vXr8cEHH+DkyZNo165dpfrCyT+JiOonIQQupN9BRHwmIi/cQHTybag1//50WiqN0cunEfq2cELv5g48ilXH1JsZ1SMjI9G/f/9yy8eOHYs1a9ZACIGFCxfim2++QXZ2Nh577DF89dVXaNGihbbtrVu3MHXqVPz1118wMjLCiBEjsHz5clha/nuC4ZkzZxASEoLjx4/DwcEB06ZNQ2hoqM4+N23ahLfeegtJSUlo3rw5li1bhiFDhlS6LwxVREQNQ05+CQ5cvoGICzew72ImbubqXjXo7WCB3s0d0KfF3XOxLJQGe6YNoR6FqvqEoYqIqOHRaARiU3MQGX8DBy7dwMnkbJ2jWCZyGTp72KFPC0f0ae6Itm7WMDKSSVgx/RdDlQFiqCIiIlVhCaISsrD/4g3sv3QDKbd0b5Fjb6HAYz4O6N3cAb2bO8LFxlSiSqkMQ5UBYqgiIqL/upqV9/8B6yaiErKQW1Sqs76ZowV6+TigZ7NG8Pd2gI25iUSVNlwMVQaIoYqIiB6kRK3BqeRsHLh0A/sv3sCZ6zk6t8+RyYB2bjbo6dMIvZo5oKuXPcwUnBurpjFUGSCGKiIiqoqc/BJEXcnC4YSbOHT5JhJu5OmsV8iN0MnDFr18HNDLpxHaN7GFidxgZ0KqsxiqDBBDFRERVUd6TiEOJ9zE4YQsHL58E6k5hTrrLRRydPGyRw/vRujhbY92jW0YsvSAocoAMVQREZG+CCGQlJWPQ5dvaoNWdn6JThsLhRx+Xvbo4X03aPkyZD0ShioDxFBFREQ1RaMRiEtX4eiVWzhyJQtHE28hp0A3ZJkr5PDztPv/I1mN0L4JQ1ZlMFQZIIYqIiKqLRrN3Vne7wasuyHrv0eyzEzuhqwuXnbo5mWPTh52PPG9AgxVBoihioiIpKLRCMRn3A1ZR65k4VjiLdz+T8gyNpKhXWMbdGtqjy6edujqZQ87C4VEFRsOhioDxFBFRESGQqMRuJh5B8cTb+FY0m0cT7yFdFVhuXbNnSzRtak9unnZo4uXHZrYNbz7FjJUGSCGKiIiMlRCCFy7XYDjSbdwPOkWjiXeKjeFAwC42Ziis6cd/P7/0drVut6fl8VQZYAYqoiIqC7Jyi3Ciat3j2IdT7qF2FSVzn0LAcDUxAgdmthqQ1ZnD7t6N2TIUGWAGKqIiKguyysqxelr2Th59Tai//+hKiwt187b0QJ+HnbaI1o+jpZ1+ibRDFUGiKGKiIjqE41G4MrNXG3Air56u8IhQyulMdq726CTux06utuio4ctHCyVElT8aBiqDBBDFRER1Xe384pxKuXfkHU6JQcFJepy7dztzdCxLGS526KtmzVMTQxzOgeGKgPEUEVERA1NqVqD+Iw7iEnJRkxyNk6lZONyZm65diZyGdq4WmuPZPk2toW3g4VBDBsyVBkghioiIiJAVViCMyk5iEm5jVPJ2YhJyUZWXnG5dlZKY7RrbIP27jbo0MQWvo1t0MTODDJZ7QYthioDxFBFRERUXtl0DieTbyMmJRtnruXgXGoOCks05do2slDAt4kN2jexRYcmNvBtYgMnK9MarY+hygAxVBEREVVOqVqDixm5OHs9G6ev5eDMtWxcSLuDUk35SOJqY4p2jW3Qzs0Gvk2s0c7NBk7W+gtaDFUGiKGKiIjo0RWWqHEh/Q7OXLt7NOvMtWxcysxFRSnF0UoJ38Y2aOdmjbaNbeDb2AauNqaPNHTIUGWAGKqIiIj0K6+oFOdSVYi9noPY1BzEXs/B5cxcVHBAC/YWCrR1s4ZvYxu0dbNBGzdreNqbP/RkeIYqA8RQRUREVPMKitU4n6bCudQcnL2Wg9hUFS5lVDx0aKGQo5WrNdq6WaONqzXauFmjhbOVzvQODFUGiKGKiIhIGoUlasSn38HZ63dPgj+fqsKF9DsoKi1/MrzcSIZmjhbakOVpZYRBnb0ZqgwJQxUREZHhKFVrkHgzD+dSVTifpsL51LtHt27nl+i00xTlI+WzZ/Xy+21crVcTERERGSBjuRGaO1uhubMVhnVqDODu9A4ZqiKcT7t7NOt8mgqnr6QhRU/75JEqPeGRKiIiorpHn7/fRnqqiYiIiKhBY6giIiIi0gOGKiIiIiI9YKgiIiIi0gOGKiIiIiI9YKgiIiIi0gOGKiIiIiI9YKgiIiIi0gOGKiIiIiI9YKgiIiIi0gOGKiIiIiI9YKgiIiIi0gOGKiIiIiI9YKgiIiIi0gNjqQuoL4QQAACVSiVxJURERFRZZb/bZb/j1cFQpSdZWVkAAHd3d4krISIioqrKysqCjY1NtbbBUKUn9vb2AIDk5ORqfyh1iUqlgru7O1JSUmBtbS11ObWG/Wa/GwL2m/1uCHJycuDh4aH9Ha8Ohio9MTK6e3qajY1Ng/rLWMba2pr9bkDY74aF/W5YGmq/y37Hq7UNPdRBRERE1OAxVBERERHpAUOVniiVSixcuBBKpVLqUmoV+81+NwTsN/vdELDf1e+3TOjjGkIiIiKiBo5HqoiIiIj0gKGKiIiISA8YqoiIiIj0gKGKiIiISA8Yqqph6dKlkMlkmDlzpnZZYWEhQkJC0KhRI1haWmLEiBHIyMiQrsgaUFG/+/XrB5lMpvOYPHmydEXqwaJFi8r1qVWrVtr19fWzfli/6+NnXeb69et48cUX0ahRI5iZmcHX1xcnTpzQrhdCYMGCBXB1dYWZmRkCAgJw6dIlCSvWj4f1e9y4ceU+80GDBklYsX54eXmV65dMJkNISAiA+vsdf1i/6+N3XK1W4+2330bTpk1hZmaGZs2a4d1339W5358+vt+cUf0RHT9+HF9//TXat2+vs3zWrFnYvn07Nm3aBBsbG0ydOhXDhw/HoUOHJKpUv+7XbwB4+eWXsXjxYu1zc3Pz2iytRrRt2xb//POP9rmx8b9fmfr8WT+o30D9/Kxv376NXr16oX///ti5cyccHR1x6dIl2NnZadssW7YMy5cvx9q1a9G0aVO8/fbbCAoKwvnz52Fqaiph9Y+uMv0GgEGDBmH16tXa5/Xhsvvjx49DrVZrn8fGxuLxxx/HM888A6D+fscf1m+g/n3HP/zwQ6xcuRJr165F27ZtceLECYwfPx42NjaYPn06AD19vwVV2Z07d0Tz5s1FeHi46Nu3r5gxY4YQQojs7GxhYmIiNm3apG0bFxcnAIioqCiJqtWf+/VbCFHueX2wcOFC0aFDhwrX1efP+kH9FqJ+ftZCCBEaGioee+yx+67XaDTCxcVFfPTRR9pl2dnZQqlUil9//bU2SqwRD+u3EEKMHTtWDB06tHYKktCMGTNEs2bNhEajqdff8f+6t99C1M/veHBwsJgwYYLOsuHDh4vRo0cLIfT3/ebw3yMICQlBcHAwAgICdJZHR0ejpKREZ3mrVq3g4eGBqKio2i5T7+7X7zLr1q2Dg4MD2rVrh7CwMOTn59dyhfp36dIluLm5wdvbG6NHj0ZycjKA+v9Z36/fZerjZ/3nn3+iS5cueOaZZ+Dk5IROnTrh22+/1a5PTExEenq6zmduY2OD7t271+nP/GH9LhMZGQknJye0bNkSU6ZMQVZWlgTV1pzi4mL8/PPPmDBhAmQyWb3/jpf5b7/L1LfveM+ePbFnzx5cvHgRAHD69GkcPHgQgwcPBqC/7zeH/6po/fr1OHnyJI4fP15uXXp6OhQKBWxtbXWWOzs7Iz09vZYqrBkP6jcAvPDCC/D09ISbmxvOnDmD0NBQxMfH448//qjlSvWne/fuWLNmDVq2bIm0tDS888476N27N2JjY+v1Z/2gfltZWdXLzxoArly5gpUrV2L27Nl44403cPz4cUyfPh0KhQJjx47Vfq7Ozs46r6vrn/nD+g3cHfobPnw4mjZtioSEBLzxxhsYPHgwoqKiIJfLJe6BfmzZsgXZ2dkYN24cgPr97/m9/ttvoH7+ez5//nyoVCq0atUKcrkcarUa77//PkaPHg0Aevt+M1RVQUpKCmbMmIHw8PA6e/7Eo6hMv1955RXtn319feHq6oqBAwciISEBzZo1q61S9ars/2AAoH379ujevTs8PT2xceNGmJmZSVhZzXpQvydOnFgvP2sA0Gg06NKlCz744AMAQKdOnRAbG4tVq1Zpw0V9VJl+P/fcc9r2vr6+aN++PZo1a4bIyEgMHDhQkrr17fvvv8fgwYPh5uYmdSm1qqJ+18fv+MaNG7Fu3Tr88ssvaNu2LWJiYjBz5ky4ubnp9fvN4b8qiI6ORmZmJjp37gxjY2MYGxtj3759WL58OYyNjeHs7Izi4mJkZ2frvC4jIwMuLi7SFK0HD+v3vSc8lunevTsA4PLly7Vdbo2xtbVFixYtcPnyZbi4uNTLz7oi9/a7IvXls3Z1dUWbNm10lrVu3Vo79Fn2uf736q+6/pk/rN8V8fb2hoODQ53/zMtcvXoV//zzDyZNmqRd1hC+4xX1uyL14Ts+d+5czJ8/H8899xx8fX0xZswYzJo1C0uWLAGgv+83Q1UVDBw4EGfPnkVMTIz20aVLF4wePVr7ZxMTE+zZs0f7mvj4eCQnJ8Pf31/CyqvnYf2u6PB/TEwMgLv/YNcXubm5SEhIgKurK/z8/OrlZ12Re/tdkfryWffq1Qvx8fE6yy5evAhPT08AQNOmTeHi4qLzmatUKhw9erROf+YP63dFrl27hqysrDr/mZdZvXo1nJycEBwcrF3WEL7jFfW7IvXhO56fnw8jI93II5fLodFoAOjx+62f8+obrv9eJTF58mTh4eEh9u7dK06cOCH8/f2Fv7+/dAXWkHv7ffnyZbF48WJx4sQJkZiYKLZu3Sq8vb1Fnz59pC2ymubMmSMiIyNFYmKiOHTokAgICBAODg4iMzNTCFF/P+sH9bu+ftZCCHHs2DFhbGws3n//fXHp0iWxbt06YW5uLn7++Wdtm6VLlwpbW1uxdetWcebMGTF06FDRtGlTUVBQIGHl1fOwft+5c0e8/vrrIioqSiQmJop//vlHdO7cWTRv3lwUFhZKXH31qdVq4eHhIUJDQ8utq6/fcSHu3+/6+h0fO3asaNy4sdi2bZtITEwUf/zxh3BwcBDz5s3TttHH95uhqpr+G6oKCgrEa6+9Juzs7IS5ubl4+umnRVpamnQF1pB7+52cnCz69Okj7O3thVKpFD4+PmLu3LkiJydH2iKradSoUcLV1VUoFArRuHFjMWrUKHH58mXt+vr6WT+o3/X1sy7z119/iXbt2gmlUilatWolvvnmG531Go1GvP3228LZ2VkolUoxcOBAER8fL1G1+vOgfufn54vAwEDh6OgoTExMhKenp3j55ZdFenq6hBXrz+7duwWACj/H+vodF+L+/a6v33GVSiVmzJghPDw8hKmpqfD29hZvvvmmKCoq0rbRx/dbJsQ904kSERER0SPhOVVEREREesBQRURERKQHDFVEREREesBQRURERKQHDFVEREREesBQRURERKQHDFVEREREesBQRURERKQHDFVERLVs3LhxkMlkkMlk2LJli6S1REZGamsZNmyYpLUQ1XUMVURUbfeGhHsfdfmu9jVt0KBBSEtLw+DBg7XLyt63I0eO6LQtKipCo0aNIJPJEBkZqdO+olA2bty4Sgeknj17Ii0tDc8+++yjdIOI7sFQRUR6URYS7n00bdq0XLvi4mIJqjM8SqUSLi4uUCqVOsvd3d2xevVqnWWbN2+GpaVljdShUCjg4uICMzOzGtk+UUPCUEVEelEWEu59yOVy9OvXD1OnTsXMmTPh4OCAoKAgAEBsbCwGDx4MS0tLODs7Y8yYMbh586Z2e3l5eXjppZdgaWkJV1dXfPzxx+jXrx9mzpypbVPRkRpbW1usWbNG+zwlJQXPPvssbG1tYW9vj6FDhyIpKUm7vuyozv/+9z+4urqiUaNGCAkJQUlJibZNUVERQkND4e7uDqVSCR8fH3z//fcQQsDHxwf/+9//dGqIiYl55CN1Y8eOxfr161FQUKBd9sMPP2Ds2LFV3hYAJCUlVXgUsV+/fo+0PSK6P4YqIqpxa9euhUKhwKFDh7Bq1SpkZ2djwIAB6NSpE06cOIFdu3YhIyNDZwhq7ty52LdvH7Zu3Yq///4bkZGROHnyZJX2W1JSgqCgIFhZWeHAgQM4dOgQLC0tMWjQIJ0jZhEREUhISEBERATWrl2LNWvW6ASzl156Cb/++iuWL1+OuLg4fP3117C0tIRMJsOECRPKHVlavXo1+vTpAx8fnyq/V35+fvDy8sLvv/8OAEhOTsb+/fsxZsyYKm8LuHvk696jh6dOnUKjRo3Qp0+fR9oeET2AICKqprFjxwq5XC4sLCy0j5EjRwohhOjbt6/o1KmTTvt3331XBAYG6ixLSUkRAER8fLy4c+eOUCgUYuPGjdr1WVlZwszMTMyYMUO7DIDYvHmzznZsbGzE6tWrhRBC/PTTT6Jly5ZCo9Fo1xcVFQkzMzOxe/dube2enp6itLRU2+aZZ54Ro0aNEkIIER8fLwCI8PDwCvt+/fp1IZfLxdGjR4UQQhQXFwsHBwexZs2aB75fQ4cOLbe8rD+fffaZ6N+/vxBCiHfeeUc8/fTT4vbt2wKAiIiI0Glvamqq875bWFgIY2PjCrdfUFAgunfvLp544gmhVqsrVRMRVZ6xlIGOiOqP/v37Y+XKldrnFhYW2j/7+fnptD19+jQiIiIqPE8oISEBBQUFKC4uRvfu3bXL7e3t0bJlyyrVdPr0aVy+fBlWVlY6ywsLC5GQkKB93rZtW8jlcu1zV1dXnD17FsDdoTy5XI6+fftWuA83NzcEBwfjhx9+QLdu3fDXX3+hqKgIzzzzTJVqvdeLL76I+fPn48qVK1izZg2WL19+37affvopAgICdJaFhoZCrVaXazthwgTcuXMH4eHhMDLiQAWRvjFUEZFeWFhY3He4696ABQC5ubl48skn8eGHH5Zr6+rqWulzkWQyGYQQOsvuPRcqNzcXfn5+WLduXbnXOjo6av9sYmJSbrsajQYAKnUC96RJkzBmzBh8+umnWL16NUaNGgVzc/NK9aEijRo1whNPPIGJEyeisLAQgwcPxp07dyps6+LiUu59t7KyQnZ2ts6y9957D7t378axY8fKhUwi0g+GKiKqdZ07d8bvv/8OLy8vGBuX/2eoWbNmMDExwdGjR+Hh4QEAuH37Ni5evKhzxMjR0RFpaWna55cuXUJ+fr7OfjZs2AAnJydYW1s/Uq2+vr7QaDTYt29fuSNCZYYMGQILCwusXLkSu3btwv79+x9pX/eaMGEChgwZgtDQUJ2jaI/i999/x+LFi7Fz5040a9as2rURUcV4/JeIal1ISAhu3bqF559/HsePH0dCQgJ2796N8ePHQ61Ww9LSEhMnTsTcuXOxd+9exMbGYty4ceWGrAYMGIAvv/wSp06dwokTJzB58mSdo06jR4+Gg4MDhg4digMHDiAxMRGRkZGYPn06rl27Vqlavby8MHbsWEyYMAFbtmzRbmPjxo3aNnK5HOPGjUNYWBiaN28Of3//ar9HgwYNwo0bN7B48eJqbSc2NhYvvfQSQkND0bZtW6SnpyM9PR23bt2qdo1EpIuhiohqnZubGw4dOgS1Wo3AwED4+vpi5syZsLW11Qanjz76CL1798aTTz6JgIAAPPbYY+XOzfr444/h7u6O3r1744UXXsDrr7+uM+xmbm6O/fv3w8PDA8OHD0fr1q21Q2pVOXK1cuVKjBw5Eq+99hpatWqFl19+GXl5eTptJk6ciOLiYowfP74a78y/ZDIZHBwcoFAoqrWdEydOID8/H++99x5cXV21j+HDh+ulTiL6l0z894QEIiID1a9fP3Ts2BGfffaZ1KWUc+DAAQwcOBApKSlwdnZ+YNtx48YhOztb8lvU3MsQayKqa3ikioioGoqKinDt2jUsWrQIzzzzzEMDVZlt27bB0tIS27Ztq+EKH+zAgQOwtLSs8GR+IqoanqhORFQNv/76KyZOnIiOHTvixx9/rNRrli1bhrfeegvA3asdpdSlSxfExMQAQI3dCoeooeDwHxEREZEecPiPiIiISA8YqoiIiIj0gKGKiIiISA8YqoiIiIj0gKGKiIiISA8YqoiIiIj0gKGKiIiISA8YqoiIiIj04P8AH/nlxdYMdFIAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure()\n", - "plt.plot(sky.frequencies, jnp.real(sky[:, 0, 0]), label=\"Sky monopole spectrum\")\n", - "plt.xlabel(\"Frequency [MHz]\")\n", - "plt.ylabel(\"Temperature [K]\")\n", - "plt.xlim(sky.frequencies.min(), sky.frequencies.max())\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "fed65b68-c628-4794-b5d6-6173abecdf09", - "metadata": {}, - "outputs": [], - "source": [ - "L = lmax + 1\n", - "flmn = jnp.zeros((2*L-1, L, 2*L-1)) # n, l, m\n", - "flmn = flmn.at[lmax, 0, lmax].set(1) # 0, 0, 0\n", - "s = s2fft.wigner.inverse(flmn, L, L, method=\"jax\", reality=True) # gamma, beta, alpha" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "fd17283b-6e1a-444e-b24b-05eaf12cbe9b", - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'alpha' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43malpha\u001b[49m[\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m-\u001b[39malpha[\u001b[38;5;241m0\u001b[39m]\n", - "\u001b[0;31mNameError\u001b[0m: name 'alpha' is not defined" - ] - } - ], - "source": [ - "alpha[1]-alpha[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "33bd1770-1780-4a41-871b-42bcf99b4f24", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(257, 129, 257)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "10ca4c8e", - "metadata": {}, - "outputs": [ - { - "ename": "NotImplementedError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNotImplementedError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[9], line 6\u001b[0m\n\u001b[1;32m 4\u001b[0m t_end \u001b[38;5;241m=\u001b[39m t_start \u001b[38;5;241m+\u001b[39m constants\u001b[38;5;241m.\u001b[39msidereal_day_moon \u001b[38;5;241m*\u001b[39m seconds\n\u001b[1;32m 5\u001b[0m times \u001b[38;5;241m=\u001b[39m time_array(t_start\u001b[38;5;241m=\u001b[39mt_start, t_end\u001b[38;5;241m=\u001b[39mt_end, N_times\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m300\u001b[39m)\n\u001b[0;32m----> 6\u001b[0m sim \u001b[38;5;241m=\u001b[39m \u001b[43mcrojax\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSimulator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbeam\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msky\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlmax\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlmax\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mworld\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmoon\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlocation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mloc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimes\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Documents/projects/croissant/.venv/lib/python3.10/site-packages/croissant/simulatorbase.py:135\u001b[0m, in \u001b[0;36mSimulatorBase.__init__\u001b[0;34m(self, beam, sky, lmax, frequencies, world, location, times)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbeam\u001b[38;5;241m.\u001b[39mcompute_total_power()\n\u001b[1;32m 134\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbeam\u001b[38;5;241m.\u001b[39mcoord \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msim_coord:\n\u001b[0;32m--> 135\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbeam\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mswitch_coords\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 136\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msim_coord\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlocation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtime\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mt_start\u001b[49m\n\u001b[1;32m 137\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 138\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbeam\u001b[38;5;241m.\u001b[39mlmax \u001b[38;5;241m>\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlmax:\n\u001b[1;32m 139\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbeam\u001b[38;5;241m.\u001b[39mreduce_lmax(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlmax)\n", - "File \u001b[0;32m~/Documents/projects/croissant/.venv/lib/python3.10/site-packages/croissant/crojax/healpix.py:223\u001b[0m, in \u001b[0;36mAlm.switch_coords\u001b[0;34m(self, to_coord, loc, time)\u001b[0m\n\u001b[1;32m 222\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mswitch_coords\u001b[39m(\u001b[38;5;28mself\u001b[39m, to_coord, loc\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, time\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m--> 223\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m\n", - "\u001b[0;31mNotImplementedError\u001b[0m: " - ] - } - ], - "source": [ - "# let's do a full sidereal day on the moon\n", - "loc = (20., -10.)\n", - "t_start = Time(\"2022-06-02 15:43:43\")\n", - "t_end = t_start + constants.sidereal_day_moon * seconds\n", - "times = time_array(t_start=t_start, t_end=t_end, N_times=300)\n", - "sim = crojax.Simulator(beam, sky, lmax=lmax, world=\"moon\", location=loc, times=times)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "21ee8508-e60b-45bd-a07f-3268671629d3", - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'Beam' object has no attribute 'data'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mbeam\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[38;5;241m.\u001b[39mshape\n", - "\u001b[0;31mAttributeError\u001b[0m: 'Beam' object has no attribute 'data'" - ] - } - ], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a077a8e9", - "metadata": {}, - "outputs": [], - "source": [ - "# the simulator view of the beam and sky after moving to MCMF coordinates\n", - "hp.mollview(sim.beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")\n", - "hp.mollview(sim.sky.hp_map(nside)[0], title=f\"Sky at {freq[0]:.0f} MHz\")" - ] - }, - { - "cell_type": "markdown", - "id": "d991be35", - "metadata": {}, - "source": [ - "Run the simulator!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "394a8fe8", - "metadata": {}, - "outputs": [], - "source": [ - "# dpss mode\n", - "sim.run(dpss=True, nterms=40)\n", - "sim.plot(power=2.5)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9e0b5493", - "metadata": {}, - "outputs": [], - "source": [ - "sim.run(dpss=False)\n", - "sim.plot(power=2.5)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "79fb8cac", - "metadata": {}, - "outputs": [], - "source": [ - "plt.figure()\n", - "plt.plot(sim.frequencies, sim.waterfall[::10].T, ls=\"--\")\n", - "plt.xlim(sim.frequencies.min(), sim.frequencies.max())\n", - "plt.xlabel(\"$\\\\nu$ [MHz]\")\n", - "plt.ylabel(\"Temperature [K]\")\n", - "plt.grid()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "65f0df23", - "metadata": {}, - "outputs": [], - "source": [ - "# Temp vs time\n", - "fig, axs = plt.subplots(figsize=(13,5), ncols=5, sharex=True, sharey=True)\n", - "for i, f in enumerate(sim.frequencies[::10]):\n", - " ax = axs.ravel()[i]\n", - " fidx = np.argwhere(sim.frequencies == f)[0, 0]\n", - " ax.plot(sim.waterfall[:, fidx] * f**2.5)\n", - " ax.set_title(f\"{f} MHz\")\n", - " ax.grid()\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "ada1730d", - "metadata": {}, - "source": [ - "# On Earth" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3e2b917b", - "metadata": {}, - "outputs": [], - "source": [ - "loc = (20., -10.)\n", - "t_start = Time(\"2022-06-02 15:43:43\")\n", - "t_end = t_start + cro.constants.sidereal_day_earth * seconds\n", - "sim = cro.Simulator(beam, sky, loc, t_start, world=\"earth\", t_end=t_end, N_times=300, lmax=lmax)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ef176681", - "metadata": {}, - "outputs": [], - "source": [ - "# the simulator view of the beam and sky after moving to equatorial coordinates\n", - "hp.mollview(sim.beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")\n", - "hp.mollview(sim.sky.hp_map(nside)[0], title=f\"Sky at {freq[0]:.0f} MHz\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d521d17d", - "metadata": {}, - "outputs": [], - "source": [ - "# dpss mode\n", - "sim.run(dpss=True, nterms=40)\n", - "sim.plot(power=2.5)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f08c3db8", - "metadata": {}, - "outputs": [], - "source": [ - "# Temp vs time\n", - "fig, axs = plt.subplots(figsize=(13,5), ncols=5, sharex=True, sharey=True)\n", - "for i, f in enumerate(sim.frequencies[::10]):\n", - " ax = axs.ravel()[i]\n", - " fidx = np.argwhere(sim.frequencies == f)[0, 0]\n", - " ax.plot(sim.waterfall[:, fidx] * f**2.5)\n", - " ax.set_title(f\"{f} MHz\")\n", - " ax.grid()\n", - "plt.tight_layout()\n", - "plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 9f0b6952df1b097dcc8f27e40a748143773bfe55 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Wed, 12 Jun 2024 11:52:55 -0700 Subject: [PATCH 123/129] remove test for function that doesn't exist anymore --- croissant/jax/tests/test_rotations.py | 39 +++------------------------ 1 file changed, 3 insertions(+), 36 deletions(-) diff --git a/croissant/jax/tests/test_rotations.py b/croissant/jax/tests/test_rotations.py index 6e43f4f..3528a2f 100644 --- a/croissant/jax/tests/test_rotations.py +++ b/croissant/jax/tests/test_rotations.py @@ -1,41 +1,8 @@ -import healpy as hp -import numpy as np +import jax.numpy as jnp import pytest -from s2fft.sampling.reindex import flm_2d_to_hp_fast -from s2fft.utils.signal_generator import generate_flm from croissant.jax import rotations -rng = np.random.default_rng(seed=0) pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) - -def test_rotate_alm(lmax): - alm = generate_flm(rng, lmax + 1, reality=True) - - # galactic -> equatorial - alm_rot = rotations.rotate_alm(alm, "galactic", "fk5") - # need to convert to healpy ordering - alm_hp = np.array(flm_2d_to_hp_fast(alm, lmax + 1)) - alm_rot_hp = np.array(flm_2d_to_hp_fast(alm_rot, lmax + 1)) - rot = hp.Rotator(coord=["G", "C"]) - assert np.allclose(alm_rot_hp, rot.rotate_alm(alm_hp)) - - # equatorial -> galactic - alm_rot = rotations.rotate_alm(alm, "fk5", "galactic") - alm_rot_hp = np.array(flm_2d_to_hp_fast(alm_rot, lmax + 1)) - rot = hp.Rotator(coord=["C", "G"]) - assert np.allclose(alm_rot_hp, rot.rotate_alm(alm_hp)) - - # galactic to mcmf - # alm_rot = rotations.rotate_alm(alm, "galactic", "mcmf") - # XXX this is not implemented in healpy - # assert np.allclose(alm_rot, expected) # XXX - - # topo to equatorial XXX - # topo to mcmf XXX - - # check that inverse works - alm_rot = rotations.rotate_alm(alm, "galactic", "fk5") - assert np.allclose(alm, rotations.rotate_alm(alm_rot, "fk5", "galactic")) - alm_rot = rotations.rotate_alm(alm, "galactic", "mcmf") - assert np.allclose(alm, rotations.rotate_alm(alm_rot, "mcmf", "galactic")) +def test_generate_euler_dl(lmax): + pass From 6d76f56abce66414ecbb93e73e86b844662b7581 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 13 Jun 2024 14:10:38 -0700 Subject: [PATCH 124/129] initial commit --- croissant/jax/tests/test_simulator.py | 34 +++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 croissant/jax/tests/test_simulator.py diff --git a/croissant/jax/tests/test_simulator.py b/croissant/jax/tests/test_simulator.py new file mode 100644 index 0000000..d86cec1 --- /dev/null +++ b/croissant/jax/tests/test_simulator.py @@ -0,0 +1,34 @@ +import jax.numpy as jnp +import numpy as np +import pytest +import s2fft +from croissant.constants import sidereal_day +from croissant.jax import simulator + +pytestmark = pytest.mark.parametrize("lmax", [8, 32]) +rng = np.random.default_rng(0) + +@pytest.mark.parametrize("world", ["earth", "moon"]) +@pytest.mark.parametrize("N_times", [1, 24]) +def test_rot_alm_z(lmax, world, N_times): + + # do one sidereal day (2pi rotation), split into N_times + delta_t = sidereal_day[world] / N_times + phases = simulator.rot_alm_z(lmax, N_times, delta_t, world=world) + # expected phases + dphi = jnp.linspace(0, 2 * jnp.pi, N_times, endpoint=False) + # the m-modes range from -lmax to lmax (inclusive) + for m_index in range(phases.shape[1]): + emm = m_index - lmax # m = -lmax, -lmax+1, ..., lmax + expected = jnp.exp(-1j * emm * dphi) + assert jnp.allclose(phases[:, m_index], expected) + + # check that these phases really rotate the alm + alm = s2fft.utils.signal_generator.generate_flm(rng, lmax+1) + for i in range(N_times): + phi = dphi[i].item() + phase = phases[i] + alm_rot = alm * phase[None, :] + euler = (phi, 0, 0) # rotation about z-axis + expected = s2fft.utils.rotation.rotate_flms(alm, lmax+1, euler) + assert jnp.allclose(alm_rot, expected) From 902c7c1859b7e1c4856d71c72f8bffd3fa317da1 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 13 Jun 2024 17:16:58 -0700 Subject: [PATCH 125/129] fix normalization --- croissant/jax/alm.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/croissant/jax/alm.py b/croissant/jax/alm.py index 92bc331..6154b3e 100644 --- a/croissant/jax/alm.py +++ b/croissant/jax/alm.py @@ -29,7 +29,7 @@ def total_power(alm, lmax): # get the index of the monopole component lix, mix = getidx(lmax, 0, 0) monopole = alm[..., lix, mix] - return 4 * jnp.pi * jnp.real(monopole) * Y00 + return jnp.real(monopole) / Y00 @jax.jit From 6efe46467a65ac7124b21a0786b1ec82c231b70f Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 13 Jun 2024 17:17:35 -0700 Subject: [PATCH 126/129] blacken --- croissant/jax/tests/test_alm.py | 1 + croissant/jax/tests/test_rotations.py | 1 + 2 files changed, 2 insertions(+) diff --git a/croissant/jax/tests/test_alm.py b/croissant/jax/tests/test_alm.py index 3ca3077..f372e72 100644 --- a/croissant/jax/tests/test_alm.py +++ b/croissant/jax/tests/test_alm.py @@ -8,6 +8,7 @@ pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) rng = np.random.default_rng(seed=0) + def test_total_power(lmax): # make a map that is 1 everywhere so total power is 4pi: shape = crojax.alm.shape_from_lmax(lmax) diff --git a/croissant/jax/tests/test_rotations.py b/croissant/jax/tests/test_rotations.py index 3528a2f..0db22de 100644 --- a/croissant/jax/tests/test_rotations.py +++ b/croissant/jax/tests/test_rotations.py @@ -4,5 +4,6 @@ pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) + def test_generate_euler_dl(lmax): pass From b1a19e1e35b081f54a1b12769cbb556dbae6881c Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Thu, 13 Jun 2024 17:17:54 -0700 Subject: [PATCH 127/129] write test_convolve --- croissant/jax/tests/test_simulator.py | 71 ++++++++++++++++++++++++--- 1 file changed, 64 insertions(+), 7 deletions(-) diff --git a/croissant/jax/tests/test_simulator.py b/croissant/jax/tests/test_simulator.py index d86cec1..5fa6ce1 100644 --- a/croissant/jax/tests/test_simulator.py +++ b/croissant/jax/tests/test_simulator.py @@ -1,13 +1,14 @@ import jax.numpy as jnp import numpy as np -import pytest import s2fft -from croissant.constants import sidereal_day -from croissant.jax import simulator +import pytest +from croissant.constants import sidereal_day, Y00 +from croissant.jax import alm, simulator -pytestmark = pytest.mark.parametrize("lmax", [8, 32]) rng = np.random.default_rng(0) + +@pytest.mark.parametrize("lmax", [8, 32]) @pytest.mark.parametrize("world", ["earth", "moon"]) @pytest.mark.parametrize("N_times", [1, 24]) def test_rot_alm_z(lmax, world, N_times): @@ -24,11 +25,67 @@ def test_rot_alm_z(lmax, world, N_times): assert jnp.allclose(phases[:, m_index], expected) # check that these phases really rotate the alm - alm = s2fft.utils.signal_generator.generate_flm(rng, lmax+1) + alm_arr = s2fft.utils.signal_generator.generate_flm(rng, lmax + 1) for i in range(N_times): phi = dphi[i].item() phase = phases[i] - alm_rot = alm * phase[None, :] + alm_rot = alm_arr * phase[None, :] euler = (phi, 0, 0) # rotation about z-axis - expected = s2fft.utils.rotation.rotate_flms(alm, lmax+1, euler) + expected = s2fft.utils.rotation.rotate_flms(alm_arr, lmax + 1, euler) assert jnp.allclose(alm_rot, expected) + + +def test_convolve(): + lmax = 32 + freq = jnp.arange(50, 251) # 50 to 250 MHz + Ntimes = 100 + delta_t = 3600 # 1 hour cadence + world = "earth" + # check that we recover sky temperature for a monopole sky + T_sky = 1e4 * (freq / 150) ** (-2.5) + sky_monopole = T_sky / Y00 # monpole component + shape = (freq.size, *alm.shape_from_lmax(lmax)) + sky = jnp.zeros(shape, dtype=jnp.complex128) + l_indx, m_indx = alm.getidx(lmax, 0, 0) + sky = sky.at[:, l_indx, m_indx].set(sky_monopole) + # the beam is achromatic, but the details don't matter + beam = s2fft.utils.signal_generator.generate_flm( + rng, lmax + 1, reality=True + ) + # normalization factor + norm = alm.total_power(beam, lmax) + # add frequency axis + beam = jnp.repeat(beam[None, :], freq.size, axis=0) + # get the phases that rotate the sky + phases = simulator.rot_alm_z(lmax, Ntimes, delta_t, world=world) + ant_temp = simulator.convolve(beam, sky, phases) / norm + assert jnp.allclose(ant_temp, T_sky) + + # for a general sky, the telescope is sensitive to the multipole moments + # that are in the beam. We consider a beam with 5 non-zero multipoles + sky = s2fft.utils.signal_generator.generate_flm( + rng, lmax + 1, reality=True + ) + shape = alm.shape_from_lmax(lmax) + beam = jnp.zeros(shape, dtype=jnp.complex128) + beam = beam.at[l_indx, m_indx].set(1.0) # monopole component + # randomly, we choose 5 (l, m) pairs + ells = rng.integers(1, lmax, size=5, endpoint=True) # random l + emms = [rng.integers(0, ell, endpoint=True) for ell in ells] # random m + # give the (l, m) mode a weight of 1 + 1j + val = 1.0 + 1j + for ell, emm in zip(ells, emms): + l_indx, m_indx = alm.getidx(lmax, ell, emm) + beam = beam.at[l_indx, m_indx].set(val) + # we need to set -m to the conjugate of m since the beam is real + neg_m_indx = alm.getidx(lmax, ell, -emm)[1] + neg_val = (-1) ** emm * val.conjugate() + beam = beam.at[l_indx, neg_m_indx].set(neg_val) + # add frequency axis, but only one frequency + ant_temp = simulator.convolve(beam[None], sky[None], phases) + # the antenna temperature is the sum of the sky temperature * beam + # over the multipoles that are in the beam + for i in range(Ntimes): + phase = phases[i] + expected = jnp.sum(sky * beam.conj() * phase[None]) + assert jnp.isclose(ant_temp[i], expected) From d8fd95e1e567ec6adbf640f04433b7247d8826de Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 14 Jun 2024 10:20:58 -0700 Subject: [PATCH 128/129] update docstring for convolve --- croissant/jax/simulator.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/croissant/jax/simulator.py b/croissant/jax/simulator.py index 3973498..f19e393 100644 --- a/croissant/jax/simulator.py +++ b/croissant/jax/simulator.py @@ -42,11 +42,14 @@ def convolve(beam_alm, sky_alm, phases): Compute the convolution for a range of times in jax. The convolution is a dot product in l,m space. Axes are in the order: time, freq, ell, emm. + Note that normalization is not included in this function. The usual + normalization factor can be computed with croissant.jax.alm.total_power + of the beam alm. + Parameters ---------- beam_alm : jnp.ndarray - The beam alms. Shape (N_freqs, lmax+1, 2*lmax+1). The beam should be - normalized to have total power of unity. + The beam alms. Shape (N_freqs, lmax+1, 2*lmax+1). sky_alm : jnp.ndarray The sky alms. Shape (N_freqs, lmax+1, 2*lmax+1). phases : jnp.ndarray From 3d9659d046ccbd13f0339b946f69df9c9f569803 Mon Sep 17 00:00:00 2001 From: Christian Hellum Bye Date: Fri, 14 Jun 2024 10:21:26 -0700 Subject: [PATCH 129/129] update notebook with ulsa map instead of gsm --- notebooks/croissant_jax.ipynb | 79 ++++++++++++++++++++++++++++------- 1 file changed, 63 insertions(+), 16 deletions(-) diff --git a/notebooks/croissant_jax.ipynb b/notebooks/croissant_jax.ipynb index 14bd2da..0da8621 100644 --- a/notebooks/croissant_jax.ipynb +++ b/notebooks/croissant_jax.ipynb @@ -15,7 +15,6 @@ "import jax.numpy as jnp\n", "import lunarsky\n", "import matplotlib.pyplot as plt\n", - "from pygdsm import GlobalSkyModel16 as GSM16\n", "import s2fft" ] }, @@ -29,11 +28,11 @@ "# simulation parameters\n", "world = \"moon\"\n", "L = 180 # maximal harmonic band limit given sampling of beam\n", - "freq = jnp.arange(11, 51) # 11-50 MHz\n", + "freq = jnp.arange(1, 51) # 1-50 MHz\n", "time = lunarsky.Time(\"2025-12-01 09:00:00\") # time at the beginning of the simulation\n", "loc = lunarsky.MoonLocation(lon=0, lat=-22.5) # location of telescope\n", "topo = lunarsky.LunarTopo(obstime=time, location=loc) # coordinate frame of telescope\n", - "# 24 bins in a sidereal day on the moon\n", + "# 240 bins in a sidereal day on the moon\n", "ntimes = 240\n", "dt = cro.constants.sidereal_day[world] / ntimes\n", "phases = crojax.simulator.rot_alm_z(L-1, ntimes, dt, world=world)\n", @@ -54,7 +53,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -64,7 +63,7 @@ } ], "source": [ - "etheta, ephi = jnp.load(\"lusee_beam.npy\")[:, 10:, :, :-1]\n", + "etheta, ephi = jnp.load(\"lusee_beam.npy\")[:, :, :, :-1]\n", "beam = jnp.abs(etheta)**2 + jnp.abs(ephi)**2 # power beam\n", "# add horizon\n", "beam = jnp.concatenate((beam, jnp.zeros_like(beam)[:, :-1, :]), axis=1)\n", @@ -95,13 +94,13 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "f1b916b6-161f-484f-a621-534d27310fda", + "execution_count": 12, + "id": "d5cb7cb6-ced9-4033-8b8f-5abd1e242cab", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -112,16 +111,15 @@ ], "source": [ "# sky\n", - "gsm = GSM16(freq_unit=\"MHz\", data_unit=\"TRJ\", resolution=\"lo\")\n", - "sky_map = gsm.generate(freq)\n", + "sky_map = jnp.load(\"../ulsa.npy\")\n", "ix = -6\n", - "projview(m=sky_map[ix], title=f\"GSM at {freq[ix]} MHz\")\n", + "projview(m=sky_map[ix], title=f\"ULSA sky at {freq[ix]} MHz\")\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "id": "91f2b69f-103c-4471-86de-711448abb1d0", "metadata": {}, "outputs": [], @@ -133,7 +131,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 14, "id": "fdf352d3-b46a-4477-ad14-799e2f970ed5", "metadata": {}, "outputs": [], @@ -145,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 15, "id": "0c1a8329-b180-4a52-852f-72149c7adca3", "metadata": {}, "outputs": [], @@ -155,13 +153,38 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 20, + "id": "fdb085d4-2fad-4bc4-a95d-45e55fda095e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(freq, jnp.mean(sky_map, axis=-1))\n", + "plt.plot(freq, jnp.mean(sky_map, axis=-1)[0] * (freq/freq.min())**(-2.5))\n", + "plt.yscale(\"log\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "id": "25e7ec10-c915-4fee-b528-3e5b784583ce", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -176,6 +199,30 @@ "plt.colorbar()\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "dcab37f2-8d91-497e-bbca-b180eac12097", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(freq, vis[150])\n", + "plt.yscale(\"log\")\n", + "plt.show()" + ] } ], "metadata": {