From a8a7874b4a0becce26ed99e5834b0f587697279f Mon Sep 17 00:00:00 2001 From: sgiardie Date: Wed, 8 May 2024 17:43:49 +0100 Subject: [PATCH 01/43] first commit --- .../notebooks/tutorial_foregrounds.ipynb | 59 +++++++++--------- mflike/MFLike.yaml | 17 +++++- mflike/mflike.py | 1 + mflike/theoryforge.py | 61 ++++++++++++++++++- 4 files changed, 108 insertions(+), 30 deletions(-) diff --git a/docs/source/notebooks/tutorial_foregrounds.ipynb b/docs/source/notebooks/tutorial_foregrounds.ipynb index b6be9ae..be967b6 100644 --- a/docs/source/notebooks/tutorial_foregrounds.ipynb +++ b/docs/source/notebooks/tutorial_foregrounds.ipynb @@ -5,7 +5,6 @@ "execution_count": 1, "id": "4ceb8c1d-f460-45c5-8f00-d5796187b05a", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -35,7 +34,6 @@ "cell_type": "markdown", "id": "d0fc87a9-b986-40d0-b763-cbc8cc50147d", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -50,7 +48,6 @@ "execution_count": 2, "id": "aba04f84-35e6-4a6f-b4df-b58b767743a3", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -63,19 +60,41 @@ "name": "stdout", "output_type": "stream", "text": [ - " Numpy : 1.26.4\n", - "Matplotlib : 3.8.3\n", + " Numpy : 1.24.3\n", + "Matplotlib : 3.8.2\n", " CAMB : 1.5.4\n", - " Cobaya : 3.5\n", + " Cobaya : 3.4.1\n", "[install] Installing external packages at '/tmp/LAT_packages'\n", - "[install] The installation path has been written into the global config file: /home/garrido/.config/cobaya/config.yaml\n", + "\n", + "================================================================================\n", + "likelihood:mflike.MFLike\n", + "================================================================================\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "hwloc/linux: Ignoring PCI device with non-16bit domain.\n", + "Pass --enable-32bits-pci-domain to configure to support such devices\n", + "(warning: it would break the library ABI, don't enable unless really needed).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[install] Checking if dependencies have already been installed...\n", + "[install] External dependencies for this component already installed.\n", + "[install] Doing nothing.\n", "\n", "================================================================================\n", "* Summary * \n", "================================================================================\n", "\n", "[install] All requested components' dependencies correctly installed at /tmp/LAT_packages\n", - "[camb] `camb` module loaded successfully from /home/garrido/Workdir/cmb/development/LAT_MFLike/pyenv/lib/python3.11/site-packages/camb\n", + "[camb] `camb` module loaded successfully from /home/serenagiardiello/anaconda3/envs/mflike/lib/python3.10/site-packages/camb\n", "[mflike.mflike] Number of bins used: 3087\n", "[mflike.mflike] Initialized!\n" ] @@ -89,7 +108,6 @@ "cell_type": "markdown", "id": "1705bbb3-d4fc-469b-baf0-21adb235b9c2", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -104,7 +122,6 @@ "cell_type": "markdown", "id": "4d55ae94-7651-4222-ace7-9bf9d21d1090", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -119,7 +136,6 @@ "execution_count": 3, "id": "be8e0522-1ca9-4395-b0df-f9c4c68e36b5", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -143,7 +159,6 @@ "cell_type": "markdown", "id": "45a2433f-6772-4c0a-a60e-73cc7ef37a50", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -158,7 +173,6 @@ "execution_count": 4, "id": "fc62cc85-bc24-4e54-98bd-6fa7ac797e00", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -167,7 +181,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -197,7 +211,6 @@ "cell_type": "markdown", "id": "2650800c-779f-4086-adb4-c53481c6b423", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -212,7 +225,6 @@ "cell_type": "markdown", "id": "04cd6293-2e20-4334-9cf9-0ad7cbd44359", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -227,7 +239,6 @@ "execution_count": 5, "id": "5d92f955-32a9-4ecf-bd57-586b63744791", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -242,7 +253,6 @@ "cell_type": "markdown", "id": "257fcef9-4011-4b17-a948-55be787bc692", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -257,7 +267,6 @@ "execution_count": 6, "id": "5ab52bad-b704-491c-a6da-6e4457138a68", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -276,7 +285,6 @@ "cell_type": "markdown", "id": "2d711277-a179-4f6e-be65-008641cef13e", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -291,7 +299,6 @@ "execution_count": 7, "id": "891866ef-c35e-41da-befd-38a2fc2e8241", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -349,7 +356,6 @@ "execution_count": 8, "id": "9e6a13f2-3447-41f2-8282-13dd083f9090", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -375,7 +381,6 @@ "cell_type": "markdown", "id": "30008fcf-48db-47c3-8107-c7d1fcbec9ea", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -390,7 +395,6 @@ "execution_count": 9, "id": "f606505e-cdd5-43c1-bce5-3658541e10b7", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -417,7 +421,6 @@ "execution_count": 10, "id": "63bf6b71-b573-4697-ad85-9004e00edd5d", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -442,9 +445,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "mflike", "language": "python", - "name": "python3" + "name": "mflike" }, "language_info": { "codemirror_mode": { @@ -456,7 +459,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.10.0" }, "widgets": { "application/vnd.jupyter.widget-state+json": { diff --git a/mflike/MFLike.yaml b/mflike/MFLike.yaml index 51aa62c..27cbc3c 100644 --- a/mflike/MFLike.yaml +++ b/mflike/MFLike.yaml @@ -78,11 +78,26 @@ top_hat_band: # bandwidth: 0 # uncomment the block to include a systematic template -# to be read from external file at "rootname" +# to be read from external file with name "rootname" +# notice that, so far, the file has to be saved in the syslibrary/data directory!! # default is systematic_template to be a null dict systematics_template: # rootname: "test_template" +# specify if the beam profile has to be computed as a Gaussian beam +# or be read from a file (either from external file with name "rootname" or from sacc) +# if Gaussian = False and rootname = False, it will be read from the sacc file +# if Gaussian = False and "rootname" is specified, it will be read from this file +# the file has to be saved in the same path as the data +# it has to be a yaml with keys = experiments and items = array((freqs, ells)) +# i.e. numpy arrays of beam profiles for each frequency in the passband of that array +# default is the beam_profile to be a null dict and chromatic beam not +# taken into account +beam_profile: +# Gaussian has to be either True or False +# Gaussian: +# rootname: + foregrounds: normalisation: nu_0: 150.0 diff --git a/mflike/mflike.py b/mflike/mflike.py index 9b9be48..398e35a 100644 --- a/mflike/mflike.py +++ b/mflike/mflike.py @@ -44,6 +44,7 @@ class MFLike(InstallableLikelihood): foregrounds: dict top_hat_band: dict systematics_template: dict + beam_profile: dict def initialize(self): # Set default values to data member not initialized via yaml file diff --git a/mflike/theoryforge.py b/mflike/theoryforge.py index a73f172..e5afc85 100644 --- a/mflike/theoryforge.py +++ b/mflike/theoryforge.py @@ -164,7 +164,13 @@ def __init__(self, mflike=None): raise LoggedError( self.log, "One band has width = 0, set a positive width and run again" ) - + + self.use_beam_profile = bool(mflike.beam_profile) + if self.use_beam_profile: + self.gaussian_beam = mflike.beam_profile["Gaussian"] + if not self.gaussian_beam: + self._init_beam_from_file() + # Takes care of the bandpass construction. It returns a list of nu-transmittance # for each frequency or an array with the effective freqs. # bandpasses saved in the sacc file have to be divided by nu^2 @@ -634,3 +640,56 @@ def _get_template_from_file(self, dls_dict, **nuis_params): ) return dls_dict + + ########################################################################### + ## This part deals with beam functions, i.e. reading beam from file or + ## computing it as a Gaussian beam. We also have a function to compute + ## the correction expected for a Gaussian beam in case of bandpass shift + ## that should be applied to any beam profile + ########################################################################### + + + def _init_beam_from_file(self): + """ + Reads the beam profile from an external file or the sacc file + """ + + self.beam_file = mflike.beam_profile["rootname"] + if not self.beam_file: + # option to read beam from sacc. Is it actually possible? + # needs to be read in mflike.prepare_data + .... + else: + import yaml + + data_path = self.data_folder + filename = os.path.join(data_path, '%s.yaml'%self.beam_file) + if not os.path.exists(filename): + raise ValueError('File '+filename+' does not exist!') + + with open(filename, 'r') as f: + self.beams = yaml.load(f, Loader=yaml.Loader) + + + def _init_gauss_beams(self): + """ + Computes the dictionary of beams for each frequency of self.experiments + """ + for iexp, exp in enumerate(self.experiments): + bands = self.bands[f"{exp}_s0"] + nu = np.asarray(bands["nu"]) + + def gauss_beams(self, nu): + """ + Computes the gaussian beam for each frequency of a frequency array + according to eq. 54 of arXiv:astro-ph/0008228 + """ + from astropy import constants, units + mirror_size = 6 * units.m + wavelenght = constants.c / (fband * 1e9 / units.s) + fwhm = 1.22 * wavelenght / mirror_size + bls = np.empty((len(nu), self.l_bpws[-1]-1)) + for ifw,fw in enumerate(fwhm): + #computing the beam from ell = 2 to ell max of l_bpws + bls[ifw,:] = hp.gauss_beam(fw,lmax=self.l_bpws[-1])[2:] + return bls From c794bee35c98d9cb5a8e9be33f4aa518520b7f0d Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 9 May 2024 16:18:09 +0100 Subject: [PATCH 02/43] beam functions implemented --- mflike/mflike.py | 18 ++++++-- mflike/theoryforge.py | 103 ++++++++++++++++++++++++++++++++++++------ 2 files changed, 102 insertions(+), 19 deletions(-) diff --git a/mflike/mflike.py b/mflike/mflike.py index 398e35a..02661f9 100644 --- a/mflike/mflike.py +++ b/mflike/mflike.py @@ -426,10 +426,20 @@ def get_sacc_names(pol, exp_1, exp_2): self.logp_const -= 0.5 * np.linalg.slogdet(self.cov)[1] self.experiments = data["experiments"] - self.bands = { - name: {"nu": tracer.nu, "bandpass": tracer.bandpass} - for name, tracer in s.tracers.items() - } + for name, tracer in s.tracers.items(): + self.bands = { + name: {"nu": tracer.nu, "bandpass": tracer.bandpass} + } + # trying to read beams, if present + try: + tracer.beams + except: + pass + else: + self.beams = { + name: {"nu": tracer.nu, "beams": tracer.beams} + } + # Put lcuts in a format that is recognisable by CAMB. self.lcuts = {k.lower(): c for k, c in self.lcuts.items()} diff --git a/mflike/theoryforge.py b/mflike/theoryforge.py index e5afc85..7ab4422 100644 --- a/mflike/theoryforge.py +++ b/mflike/theoryforge.py @@ -167,9 +167,12 @@ def __init__(self, mflike=None): self.use_beam_profile = bool(mflike.beam_profile) if self.use_beam_profile: - self.gaussian_beam = mflike.beam_profile["Gaussian"] - if not self.gaussian_beam: + self.beam_profile = mflike.beam_profile + if not self.beam_profile.get("Gaussian"): + self.beam_file = self.beam_profile.get("rootname") self._init_beam_from_file() + else: + self._init_gauss_beams() # Takes care of the bandpass construction. It returns a list of nu-transmittance # for each frequency or an array with the effective freqs. @@ -651,14 +654,21 @@ def _get_template_from_file(self, dls_dict, **nuis_params): def _init_beam_from_file(self): """ - Reads the beam profile from an external file or the sacc file + Reads the beam profile from an external file or the sacc file. + It has to be a dictionary + ``{"{exp}_s0": {"nu": nu, "beams": array(freqs, ells+2)}, + "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}`` + including temperature and polarization beams. """ - self.beam_file = mflike.beam_profile["rootname"] if not self.beam_file: - # option to read beam from sacc. Is it actually possible? - # needs to be read in mflike.prepare_data - .... + # option to read beam from sacc. + try: + mflike.beams + except: + raise ValueError('Beams not stored in sacc files!') + else: + self.beams = mflike.beams else: import yaml @@ -675,21 +685,84 @@ def _init_gauss_beams(self): """ Computes the dictionary of beams for each frequency of self.experiments """ + self.beams = {} for iexp, exp in enumerate(self.experiments): bands = self.bands[f"{exp}_s0"] nu = np.asarray(bands["nu"]) + # computing temperature beam for exp + self.beams[f"{exp}_s0"] = { + "nu": nu, "beams": self.gauss_beams(nu, False) + } + # computing polarization beam for exp + self.beams[f"{exp}_s2"] = { + "nu": nu, "beams": self.gauss_beams(nu, True) + } - def gauss_beams(self, nu): - """ - Computes the gaussian beam for each frequency of a frequency array - according to eq. 54 of arXiv:astro-ph/0008228 + + def gauss_beams(self, nu, pol): + r""" + Computes the Gaussian beam (either for T or pol) for each frequency of a + frequency array according to eqs. 54/55 of arXiv:astro-ph/0008228 + + :param nu: the frequency array in GHz + :param pol: (Bool) False to compute temperature Gaussian beam, + True for the polarization one + + :return: a :math:`B^{Gauss.}_{\ell}(\nu)`=``array(freqs, ells+2)`` with Gaussian beam + profiles for each frequency in :math:`\nu` (from :math:`\ell = 0`) """ from astropy import constants, units mirror_size = 6 * units.m - wavelenght = constants.c / (fband * 1e9 / units.s) + wavelenght = constants.c / (nu * 1e9 / units.s) fwhm = 1.22 * wavelenght / mirror_size - bls = np.empty((len(nu), self.l_bpws[-1]-1)) + bls = np.empty((len(nu), self.l_bpws[-1]+1)) for ifw,fw in enumerate(fwhm): - #computing the beam from ell = 2 to ell max of l_bpws - bls[ifw,:] = hp.gauss_beam(fw,lmax=self.l_bpws[-1])[2:] + #saving the beam from ell = 2 to ell max of l_bpws + if not pol: + bls[ifw,:] = hp.gauss_beam(fw,lmax=self.l_bpws[-1]) + else: + # selecting the polarized gaussian beam + bls[ifw,:] = hp.gauss_beam(fw,lmax=self.l_bpws[-1], pol = True)[:,1] + return bls + + def gauss_correction(self, Nu, DNu, pol): + r""" + Computes the correction to a Gaussian beam given by a bandpass shift, both + for temperature and polarization beams. This is applied to every kind of beams, + assuming the Gaussian correction is good enough also for a non-Gaussian beam. + + :param Nu: the frequency array in GHz + :param DNu: the bandpass shift :math:`\Delta \nu` + :param pol: (Bool) False to compute the correction to a temperature Gaussian beam, + True for the polarization one + + :return: a :math:`B^{Gauss. \, corr.}_{\ell}(\nu, \Delta \nu)`=``array(freqs, ells+2)`` + with correction to a Gaussian beam profiles for each frequency in :math:`\nu` + and bandpass shift :math:`\Delta \nu` (from :math:`\ell = 0`) + """ + from astropy import constants, units + mirror_size = 6 * units.m + # useful numerical factor coming from the conversion from sigma to nu + fac = 1.22 * constants.c / mirror_size /(2*np.sqrt(2*np.log(2))) + nu = Nu * 1e9 / units.s + dnu = DNu * 1e9 / units.s + # other repeating factor + dnuf = 1./(1. + 2.*dnu/nu + dnu**2/nu**2) + # let's compute it from ell = 0, as done in hp.gauss_beam + ell = np.arange(self.l_bpws[-1]+1) + if not pol: + bcorr = dnuf[..., np.newaxis] \ + *np.exp(-ell*(ell+1)*fac*fac*(dnuf[..., np.newaxis]-1) \ + /2./nu[..., np.newaxis]/nu[..., np.newaxis]) + else: + bcorr = dnuf[..., np.newaxis] \ + *np.exp(-(ell*(ell+1)-4.)*fac*fac*(dnuf[..., np.newaxis]-1) \ + /2./nu[..., np.newaxis]/nu[..., np.newaxis]) + + # normalizing the beam correction for each freq + bcorr /= bcorr.max(axis = 1)[...,np.newaxis] + + return bcorr + + From 1ae96f4d55d0d336eee15bf890ef8a4aa5545102 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 9 May 2024 16:34:54 +0100 Subject: [PATCH 03/43] pointing to the correct branch in fgspectra --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index b7b2402..40ffea0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -23,7 +23,7 @@ classifiers = [ ] requires-python = ">=3.9.0" dependencies = [ - "fgspectra>=1.1.0", + "fgspectra @ git+https://github.com/simonsobs/fgspectra@dev_beam", "syslibrary>=0.2.0", "cobaya>=3.4.1", "sacc>=0.9.0", From ac45a58fea3c977a049715fbf483ed253b4c1905 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Mon, 13 May 2024 16:48:58 +0100 Subject: [PATCH 04/43] continuing beam implementation + reformatting --- mflike/mflike.py | 11 +- mflike/tests/test_mflike.py | 24 ++-- mflike/theoryforge.py | 260 +++++++++++++++++++++++++----------- 3 files changed, 198 insertions(+), 97 deletions(-) diff --git a/mflike/mflike.py b/mflike/mflike.py index 02661f9..c1dcee9 100644 --- a/mflike/mflike.py +++ b/mflike/mflike.py @@ -44,7 +44,7 @@ class MFLike(InstallableLikelihood): foregrounds: dict top_hat_band: dict systematics_template: dict - beam_profile: dict + beam_profile: dict def initialize(self): # Set default values to data member not initialized via yaml file @@ -427,19 +427,14 @@ def get_sacc_names(pol, exp_1, exp_2): self.experiments = data["experiments"] for name, tracer in s.tracers.items(): - self.bands = { - name: {"nu": tracer.nu, "bandpass": tracer.bandpass} - } + self.bands = {name: {"nu": tracer.nu, "bandpass": tracer.bandpass}} # trying to read beams, if present try: tracer.beams except: pass else: - self.beams = { - name: {"nu": tracer.nu, "beams": tracer.beams} - } - + self.beams = {name: {"nu": tracer.nu, "beams": tracer.beams}} # Put lcuts in a format that is recognisable by CAMB. self.lcuts = {k.lower(): c for k, c in self.lcuts.items()} diff --git a/mflike/tests/test_mflike.py b/mflike/tests/test_mflike.py index 9ad3bb8..bbf0d99 100644 --- a/mflike/tests/test_mflike.py +++ b/mflike/tests/test_mflike.py @@ -31,13 +31,13 @@ "a_psee": 0, "a_pste": 0, "xi": 0.10, - "beta_s": -2.5, - "alpha_s": 1, - "T_effd": 19.6, - "beta_d": 1.5, - "alpha_dT": -0.6, - "alpha_dE": -0.4, - "alpha_p": 1, + "beta_s": -2.5, + "alpha_s": 1, + "T_effd": 19.6, + "beta_d": 1.5, + "alpha_dT": -0.6, + "alpha_dE": -0.4, + "alpha_p": 1, "bandint_shift_LAT_93": 0, "bandint_shift_LAT_145": 0, "bandint_shift_LAT_225": 0, @@ -75,7 +75,7 @@ def test_mflike(self): import camb camb_cosmo = cosmo_params.copy() - #using camb low accuracy parameters for the test + # using camb low accuracy parameters for the test camb_cosmo.update({"lmax": 9001, "lens_potential_accuracy": 1}) pars = camb.set_params(**camb_cosmo) results = camb.get_results(pars) @@ -88,7 +88,7 @@ def test_mflike(self): { "packages_path": packages_path, "input_file": pre + "00000.fits", - "cov_Bbl_file": "data_sacc_w_covar_and_Bbl.fits", + "cov_Bbl_file": "data_sacc_w_covar_and_Bbl.fits", "defaults": { "polarizations": select.upper().split("-"), "scales": { @@ -102,7 +102,7 @@ def test_mflike(self): } ) - loglike = my_mflike.loglike(cl_dict, **nuis_params) + loglike = my_mflike.loglike(cl_dict, **nuis_params) self.assertAlmostEqual(-2 * (loglike - my_mflike.logp_const), chi2, 2) def test_cobaya(self): @@ -111,7 +111,7 @@ def test_cobaya(self): "mflike.MFLike": { "input_file": pre + "00000.fits", "cov_Bbl_file": "data_sacc_w_covar_and_Bbl.fits", - }, + }, }, "theory": {"camb": {"extra_args": {"lens_potential_accuracy": 1}}}, "params": cosmo_params, @@ -150,7 +150,7 @@ def get_model(nsteps, bandwidth): } }, "theory": {"camb": {"extra_args": {"lens_potential_accuracy": 1}}}, - "params": {**cosmo_params, **params}, + "params": {**cosmo_params, **params}, "packages_path": packages_path, } diff --git a/mflike/theoryforge.py b/mflike/theoryforge.py index 7ab4422..7741794 100644 --- a/mflike/theoryforge.py +++ b/mflike/theoryforge.py @@ -119,10 +119,11 @@ def __init__(self, mflike=None): } self.l_bpws = np.arange(2, 6002) self.requested_cls = ["tt", "te", "ee"] - self.bandint_freqs = np.array([93.0, 145.0, 225.0]) + self.bandint_freqs_T = np.array([93.0, 145.0, 225.0]) + self.bandint_freqs_P = np.array([93.0, 145.0, 225.0]) self.use_top_hat_band = False self.bands = { - f"{exp}_s0": {"nu": [self.bandint_freqs[iexp]], "bandpass": [1.0]} + f"{exp}_s0": {"nu": [self.bandint_freqs_T[iexp]], "bandpass": [1.0]} for iexp, exp in enumerate(self.experiments) } else: @@ -164,7 +165,7 @@ def __init__(self, mflike=None): raise LoggedError( self.log, "One band has width = 0, set a positive width and run again" ) - + self.use_beam_profile = bool(mflike.beam_profile) if self.use_beam_profile: self.beam_profile = mflike.beam_profile @@ -173,7 +174,7 @@ def __init__(self, mflike=None): self._init_beam_from_file() else: self._init_gauss_beams() - + # Takes care of the bandpass construction. It returns a list of nu-transmittance # for each frequency or an array with the effective freqs. # bandpasses saved in the sacc file have to be divided by nu^2 @@ -181,7 +182,8 @@ def __init__(self, mflike=None): # This factor is already included in the _cmb2bb function def _bandpass_construction(self, **params): r""" - Builds the bandpass transmission + Builds the bandpass transmission with or without beam. + When chromatic beam is not considered, we compute: :math:`\frac{\frac{\partial B_{\nu+\Delta \nu}}{\partial T} \tau(\nu+\Delta \nu)}{\int d\nu \frac{\partial B_{\nu+\Delta \nu}}{\partial T} \tau(\nu+\Delta \nu)}` @@ -195,12 +197,31 @@ def _bandpass_construction(self, **params): If ``nstep = 1`` and ``bandint_width = 0``, the passband is a Dirac delta centered at :math:`\nu+\Delta \nu`. + When the chromatic beam is considered, we compute + :math:`r_{\ell}^T(\nu+\Delta \nu) = \frac{\frac{\partial B_{\nu+\Delta \nu}}{\partial T} + \tau(\nu+\Delta \nu) b^T_{\ell}(\nu) b^{T, Gauss \, corr}_{\ell}(\nu, \Delta \nu)} + {\int d\nu + \frac{\partial B_{\nu+\Delta \nu}}{\partial T} \tau(\nu+\Delta \nu) + b^T_{\ell}(\nu) b^{T, Gauss \, corr}_{\ell}(\nu, \Delta \nu)}` + for the temperature field, and a corresponding expression for the polarization field, + replacing the temperature beam with the polarization one + :math:`b^P_{\ell}(\nu) b^{P, Gauss \, corr}_{\ell}(\nu, \Delta \nu)`. + + In the presence of bandpass shift, we have to apply a correction to our beam + which is the correction expected for a Gaussian beam (this is an approximation + to compute this correction also when we don't have an analytical expression + for our beam). + + :param \**params: dictionary of nuisance parameters :return: the list of [nu, transmission] in the multifrequency case - or just an array of frequencies in the single frequency one + or just an array of frequencies in the single frequency one. + We distinguish between T and pol transmission when a chromatic + beam is included """ data_are_monofreq = False - self.bandint_freqs = [] + self.bandint_freqs_T = [] + self.bandint_freqs_P = [] for iexp, exp in enumerate(self.experiments): bandpar = f"bandint_shift_{exp}" # Only temperature bandpass for the time being @@ -220,32 +241,69 @@ def _bandpass_construction(self, **params): self.bandint_nsteps, dtype=float, ) - tranb = _cmb2bb(nub) - # normalization integral to be evaluated at the shifted freqs - # in order to have cmb component calibrated to 1 - tranb_norm = np.trapz(_cmb2bb(nub), nub) - self.bandint_freqs.append([nub, tranb / tranb_norm]) - # in case we don't want to do band integration, e.g. when we have multifreq bandpass in sacc file + + if not self.use_beam_profile: + # normalization integral to be evaluated at the shifted freqs + # in order to have cmb component calibrated to 1 + tranb = _cmb2bb(nub) + tranb_norm = np.trapz(_cmb2bb(nub), nub) + self.bandint_freqs_T.append([nub, tranb / tranb_norm]) + self.bandint_freqs_P.append([nub, tranb / tranb_norm]) + else: + blT, blP = self.return_beams(exp, nu_ghz, self.bandint_width[iexp]) + + tranb_normT = np.trapz(_cmb2bb(nub)[..., np.newaxis] * blT, nub, axis=0) + ratioT = _cmb2bb(nub)[..., np.newaxis] * blT / tranb_normT + self.bandint_freqs_T.append([nub, ratioT]) + + tranb_normP = np.trapz(_cmb2bb(nub)[..., np.newaxis] * blP, nub, axis=0) + ratioP = _cmb2bb(nub)[..., np.newaxis] * blP / tranb_normP + self.bandint_freqs_P.append([nub, ratioP]) + + # in case we don't want to do band integration if self.bandint_nsteps == 1: nub = fr + params[bandpar] data_are_monofreq = True - self.bandint_freqs.append(nub) + self.bandint_freqs_T.append(nub) + self.bandint_freqs_P.append(nub) # using the bandpass from sacc file else: nub = nu_ghz + params[bandpar] if len(bp) == 1: # Monofrequency channel data_are_monofreq = True - self.bandint_freqs.append(nub[0]) + self.bandint_freqs_T.append(nub[0]) + self.bandint_freqs_P.append(nub[0]) else: - trans_norm = np.trapz(bp * _cmb2bb(nub), nub) - trans = bp / trans_norm * _cmb2bb(nub) - self.bandint_freqs.append([nub, trans]) + if not self.use_beam_profile: + trans_norm = np.trapz(bp * _cmb2bb(nub), nub) + trans = bp / trans_norm * _cmb2bb(nub) + self.bandint_freqs_T.append([nub, trans]) + self.bandint_freqs_P.append([nub, trans]) + else: + blT, blP = self.return_beams(exp, nu_ghz, self.bandint_width[iexp]) + + trans_normT = np.trapz( + bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blT, nub, axis=0 + ) + ratioT = ( + bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blT / trans_normT + ) + self.bandint_freqs_T.append([nub, ratioT]) + + trans_normP = bp[..., np.newaxis] * np.trapz( + _cmb2bb(nub)[..., np.newaxis] * blP, nub, axis=0 + ) + ratioP = ( + bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blP / trans_normP + ) + self.bandint_freqs_P.append([nub, ratioP]) # fgspectra can't mix monofrequency with [nu, bp]. If one channel is mono-frequency then we # assume all of them and pass to fgspectra an array (not list!!) of frequencies if data_are_monofreq: - self.bandint_freqs = np.asarray(self.bandint_freqs) + self.bandint_freqs_T = np.asarray(self.bandint_freqs_T) + self.bandint_freqs_P = np.asarray(self.bandint_freqs_P) self.log.info("bandpass is delta function, no band integration performed") def get_modified_theory(self, Dls, **params): @@ -280,6 +338,7 @@ def get_modified_theory(self, Dls, **params): cmbfg_dict = {} # Sum CMB and FGs + # filling all exp x exp combinations for exp1, exp2 in product(self.experiments, self.experiments): for s in self.requested_cls: cmbfg_dict[s, exp1, exp2] = Dls[s] + fg_dict[s, "all", exp1, exp2] @@ -347,6 +406,10 @@ def _init_foreground_model(self): self.cibc = fgc.FactorizedCrossSpectrum(fgf.CIB(), fgp.PowerSpectrumFromFile(cibc_file)) self.dust = fgc.FactorizedCrossSpectrum(fgf.ModifiedBlackBody(), fgp.PowerLaw()) self.tSZ_and_CIB = fgc.SZxCIB_Choi2020() + self.radioTE = fgc.FactorizedCrossSpectrumTE(fgf.PowerLaw(), fgf.PowerLaw, fgp.PowerLaw()) + self.dustTE = fgc.FactorizedCrossSpectrumTE( + fgf.ModifiedBlackBody(), fgf.ModifiedBlackBody(), fgp.PowerLaw() + ) components = self.foregrounds["components"] self.fg_component_list = {s: components[s] for s in self.requested_cls} @@ -382,11 +445,11 @@ def _get_foreground_model(self, ell=None, freqs_order=None, **fg_params): model = {} model["tt", "kSZ"] = fg_params["a_kSZ"] * self.ksz( - {"nu": self.bandint_freqs}, {"ell": ell, "ell_0": ell_0} + {"nu": self.bandint_freqs_T}, {"ell": ell, "ell_0": ell_0} ) model["tt", "cibp"] = fg_params["a_p"] * self.cibp( { - "nu": self.bandint_freqs, + "nu": self.bandint_freqs_T, "nu_0": nu_0, "temp": fg_params["T_d"], "beta": fg_params["beta_p"], @@ -394,16 +457,16 @@ def _get_foreground_model(self, ell=None, freqs_order=None, **fg_params): {"ell": ell_clp, "ell_0": ell_0clp, "alpha": fg_params["alpha_p"]}, ) model["tt", "radio"] = fg_params["a_s"] * self.radio( - {"nu": self.bandint_freqs, "nu_0": nu_0, "beta": fg_params["beta_s"]}, + {"nu": self.bandint_freqs_T, "nu_0": nu_0, "beta": fg_params["beta_s"]}, {"ell": ell_clp, "ell_0": ell_0clp, "alpha": fg_params["alpha_s"]}, ) model["tt", "tSZ"] = fg_params["a_tSZ"] * self.tsz( - {"nu": self.bandint_freqs, "nu_0": nu_0}, + {"nu": self.bandint_freqs_T, "nu_0": nu_0}, {"ell": ell, "ell_0": ell_0}, ) model["tt", "cibc"] = fg_params["a_c"] * self.cibc( { - "nu": self.bandint_freqs, + "nu": self.bandint_freqs_T, "nu_0": nu_0, "temp": fg_params["T_d"], "beta": fg_params["beta_c"], @@ -412,7 +475,7 @@ def _get_foreground_model(self, ell=None, freqs_order=None, **fg_params): ) model["tt", "dust"] = fg_params["a_gtt"] * self.dust( { - "nu": self.bandint_freqs, + "nu": self.bandint_freqs_T, "nu_0": nu_0, "temp": fg_params["T_effd"], "beta": fg_params["beta_d"], @@ -422,9 +485,9 @@ def _get_foreground_model(self, ell=None, freqs_order=None, **fg_params): model["tt", "tSZ_and_CIB"] = self.tSZ_and_CIB( { "kwseq": ( - {"nu": self.bandint_freqs, "nu_0": nu_0}, + {"nu": self.bandint_freqs_T, "nu_0": nu_0}, { - "nu": self.bandint_freqs, + "nu": self.bandint_freqs_T, "nu_0": nu_0, "temp": fg_params["T_d"], "beta": fg_params["beta_c"], @@ -445,12 +508,12 @@ def _get_foreground_model(self, ell=None, freqs_order=None, **fg_params): ) model["ee", "radio"] = fg_params["a_psee"] * self.radio( - {"nu": self.bandint_freqs, "nu_0": nu_0, "beta": fg_params["beta_s"]}, + {"nu": self.bandint_freqs_P, "nu_0": nu_0, "beta": fg_params["beta_s"]}, {"ell": ell_clp, "ell_0": ell_0clp, "alpha": fg_params["alpha_s"]}, ) model["ee", "dust"] = fg_params["a_gee"] * self.dust( { - "nu": self.bandint_freqs, + "nu": self.bandint_freqs_P, "nu_0": nu_0, "temp": fg_params["T_effd"], "beta": fg_params["beta_d"], @@ -458,13 +521,20 @@ def _get_foreground_model(self, ell=None, freqs_order=None, **fg_params): {"ell": ell, "ell_0": 500.0, "alpha": fg_params["alpha_dE"]}, ) - model["te", "radio"] = fg_params["a_pste"] * self.radio( - {"nu": self.bandint_freqs, "nu_0": nu_0, "beta": fg_params["beta_s"]}, + model["te", "radio"] = fg_params["a_pste"] * self.radioTE( + {"nu": self.bandint_freqs_T, "nu_0": nu_0, "beta": fg_params["beta_s"]}, + {"nu": self.bandint_freqs_P, "nu_0": nu_0, "beta": fg_params["beta_s"]}, {"ell": ell_clp, "ell_0": ell_0clp, "alpha": fg_params["alpha_s"]}, ) - model["te", "dust"] = fg_params["a_gte"] * self.dust( + model["te", "dust"] = fg_params["a_gte"] * self.dustTE( { - "nu": self.bandint_freqs, + "nu": self.bandint_freqs_T, + "nu_0": nu_0, + "temp": fg_params["T_effd"], + "beta": fg_params["beta_d"], + }, + { + "nu": self.bandint_freqs_P, "nu_0": nu_0, "temp": fg_params["T_effd"], "beta": fg_params["beta_d"], @@ -651,35 +721,32 @@ def _get_template_from_file(self, dls_dict, **nuis_params): ## that should be applied to any beam profile ########################################################################### - def _init_beam_from_file(self): """ Reads the beam profile from an external file or the sacc file. - It has to be a dictionary - ``{"{exp}_s0": {"nu": nu, "beams": array(freqs, ells+2)}, - "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}`` + It has to be a dictionary ``{"{exp}_s0": {"nu": nu, "beams": array(freqs, ells+2)}, + "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}`` including temperature and polarization beams. """ - + if not self.beam_file: # option to read beam from sacc. try: mflike.beams except: - raise ValueError('Beams not stored in sacc files!') + raise ValueError("Beams not stored in sacc files!") else: self.beams = mflike.beams else: import yaml data_path = self.data_folder - filename = os.path.join(data_path, '%s.yaml'%self.beam_file) + filename = os.path.join(data_path, "%s.yaml" % self.beam_file) if not os.path.exists(filename): - raise ValueError('File '+filename+' does not exist!') - - with open(filename, 'r') as f: - self.beams = yaml.load(f, Loader=yaml.Loader) + raise ValueError("File " + filename + " does not exist!") + with open(filename, "r") as f: + self.beams = yaml.load(f, Loader=yaml.Loader) def _init_gauss_beams(self): """ @@ -690,79 +757,118 @@ def _init_gauss_beams(self): bands = self.bands[f"{exp}_s0"] nu = np.asarray(bands["nu"]) # computing temperature beam for exp - self.beams[f"{exp}_s0"] = { - "nu": nu, "beams": self.gauss_beams(nu, False) - } + self.beams[f"{exp}_s0"] = {"nu": nu, "beams": self.gauss_beams(nu, False)} # computing polarization beam for exp - self.beams[f"{exp}_s2"] = { - "nu": nu, "beams": self.gauss_beams(nu, True) - } - + self.beams[f"{exp}_s2"] = {"nu": nu, "beams": self.gauss_beams(nu, True)} def gauss_beams(self, nu, pol): r""" - Computes the Gaussian beam (either for T or pol) for each frequency of a - frequency array according to eqs. 54/55 of arXiv:astro-ph/0008228 + Computes the Gaussian beam (either for T or pol) for each frequency of a + frequency array according to eqs. 54/55 of arXiv:astro-ph/0008228 :param nu: the frequency array in GHz - :param pol: (Bool) False to compute temperature Gaussian beam, + :param pol: (Bool) False to compute temperature Gaussian beam, True for the polarization one - :return: a :math:`B^{Gauss.}_{\ell}(\nu)`=``array(freqs, ells+2)`` with Gaussian beam + :return: a :math:`b^{Gauss.}_{\ell}(\nu)` = ``array(freqs, lmax +2)`` with Gaussian beam profiles for each frequency in :math:`\nu` (from :math:`\ell = 0`) """ from astropy import constants, units + mirror_size = 6 * units.m wavelenght = constants.c / (nu * 1e9 / units.s) - fwhm = 1.22 * wavelenght / mirror_size - bls = np.empty((len(nu), self.l_bpws[-1]+1)) - for ifw,fw in enumerate(fwhm): - #saving the beam from ell = 2 to ell max of l_bpws + fwhm = 1.22 * wavelenght / mirror_size + bls = np.empty((len(nu), self.l_bpws[-1] + 1)) + for ifw, fw in enumerate(fwhm): + # saving the beam from ell = 2 to ell max of l_bpws if not pol: - bls[ifw,:] = hp.gauss_beam(fw,lmax=self.l_bpws[-1]) + bls[ifw, :] = hp.gauss_beam(fw, lmax=self.l_bpws[-1]) else: # selecting the polarized gaussian beam - bls[ifw,:] = hp.gauss_beam(fw,lmax=self.l_bpws[-1], pol = True)[:,1] - + bls[ifw, :] = hp.gauss_beam(fw, lmax=self.l_bpws[-1], pol=True)[:, 1] + return bls def gauss_correction(self, Nu, DNu, pol): r""" - Computes the correction to a Gaussian beam given by a bandpass shift, both + Computes the correction to a Gaussian beam given by a bandpass shift, both for temperature and polarization beams. This is applied to every kind of beams, assuming the Gaussian correction is good enough also for a non-Gaussian beam. - + :param Nu: the frequency array in GHz :param DNu: the bandpass shift :math:`\Delta \nu` :param pol: (Bool) False to compute the correction to a temperature Gaussian beam, True for the polarization one - :return: a :math:`B^{Gauss. \, corr.}_{\ell}(\nu, \Delta \nu)`=``array(freqs, ells+2)`` - with correction to a Gaussian beam profiles for each frequency in :math:`\nu` + :return: a :math:`b^{T/P, Gauss. \, corr.}_{\ell}(\nu, \Delta \nu)` = ``np.array(freqs, lmax +2)`` + with correction to a temperature/polarization Gaussian beam profile + for each frequency in :math:`\nu` and bandpass shift :math:`\Delta \nu` (from :math:`\ell = 0`) """ from astropy import constants, units + mirror_size = 6 * units.m # useful numerical factor coming from the conversion from sigma to nu - fac = 1.22 * constants.c / mirror_size /(2*np.sqrt(2*np.log(2))) + fac = 1.22 * constants.c / mirror_size / (2 * np.sqrt(2 * np.log(2))) nu = Nu * 1e9 / units.s dnu = DNu * 1e9 / units.s # other repeating factor - dnuf = 1./(1. + 2.*dnu/nu + dnu**2/nu**2) + dnuf = 1.0 / (1.0 + 2.0 * dnu / nu + dnu**2 / nu**2) # let's compute it from ell = 0, as done in hp.gauss_beam - ell = np.arange(self.l_bpws[-1]+1) + ell = np.arange(self.l_bpws[-1] + 1) if not pol: - bcorr = dnuf[..., np.newaxis] \ - *np.exp(-ell*(ell+1)*fac*fac*(dnuf[..., np.newaxis]-1) \ - /2./nu[..., np.newaxis]/nu[..., np.newaxis]) + bcorr = dnuf[..., np.newaxis] * np.exp( + -ell + * (ell + 1) + * fac + * fac + * (dnuf[..., np.newaxis] - 1) + / 2.0 + / nu[..., np.newaxis] + / nu[..., np.newaxis] + ) else: - bcorr = dnuf[..., np.newaxis] \ - *np.exp(-(ell*(ell+1)-4.)*fac*fac*(dnuf[..., np.newaxis]-1) \ - /2./nu[..., np.newaxis]/nu[..., np.newaxis]) + bcorr = dnuf[..., np.newaxis] * np.exp( + -(ell * (ell + 1) - 4.0) + * fac + * fac + * (dnuf[..., np.newaxis] - 1) + / 2.0 + / nu[..., np.newaxis] + / nu[..., np.newaxis] + ) # normalizing the beam correction for each freq - bcorr /= bcorr.max(axis = 1)[...,np.newaxis] - + bcorr /= bcorr.max(axis=1)[..., np.newaxis] + return bcorr + def return_beams(self, exp, nu, dnu): + r""" + Returns the temperature and polarization beams, properly normalized and from + :math:`\ell = 2` (like ``self.l_bpws``). We compute them from :math:`\ell = 0` + to normalize them in the correct way (temperature beam = 1 for :math:`\ell = 0`). + The polarization beam is normalized by the temperature one (as in ``hp.gauss_beam``). + + :param nu: the frequency array in GHz (for now, the math:`\nu` array is the same + between bandpass file and beam file for the same experiment/array. + It is passed from the ``_bandpass_construction`` function + for consistency.) + :param dnu: the bandpass shift :math:`\Delta \nu` + + :return: The temperature and polarization beams + """ + if dnu != 0: + blT = self.beams[f"{exp}_s0"]["beams"] * self.gauss_correction(nu, dnu, False) + blP = self.beams[f"{exp}_s2"]["beams"] * self.gauss_correction(nu, dnu, True) + else: + blT = self.beams[f"{exp}_s0"]["beams"] + blP = self.beams[f"{exp}_s2"]["beams"] + + # normalizing the pol beam by the T one for each freq + # if already normalized, this operation has no effect + blP /= blT[:, 0][..., np.newaxis] + # normalizing the beam profile such that it has a max at 1 at ell = 0 + blT /= blT[:, 0][..., np.newaxis] + return blT, blP From 2ecd387483424c60534c5299a3f3c1b815280fe3 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Tue, 14 May 2024 12:18:01 +0100 Subject: [PATCH 05/43] debugging --- mflike/MFLike.yaml | 1 + mflike/mflike.py | 6 ++++-- mflike/theoryforge.py | 13 +++++++------ 3 files changed, 12 insertions(+), 8 deletions(-) diff --git a/mflike/MFLike.yaml b/mflike/MFLike.yaml index 27cbc3c..0853f13 100644 --- a/mflike/MFLike.yaml +++ b/mflike/MFLike.yaml @@ -90,6 +90,7 @@ systematics_template: # if Gaussian = False and "rootname" is specified, it will be read from this file # the file has to be saved in the same path as the data # it has to be a yaml with keys = experiments and items = array((freqs, ells)) +# indicate only the name, without the yaml extension and the rest of the path # i.e. numpy arrays of beam profiles for each frequency in the passband of that array # default is the beam_profile to be a null dict and chromatic beam not # taken into account diff --git a/mflike/mflike.py b/mflike/mflike.py index c1dcee9..1b1b2c5 100644 --- a/mflike/mflike.py +++ b/mflike/mflike.py @@ -426,15 +426,17 @@ def get_sacc_names(pol, exp_1, exp_2): self.logp_const -= 0.5 * np.linalg.slogdet(self.cov)[1] self.experiments = data["experiments"] + self.bands = {} + self.beams = {} for name, tracer in s.tracers.items(): - self.bands = {name: {"nu": tracer.nu, "bandpass": tracer.bandpass}} + self.bands[name] = {"nu": tracer.nu, "bandpass": tracer.bandpass} # trying to read beams, if present try: tracer.beams except: pass else: - self.beams = {name: {"nu": tracer.nu, "beams": tracer.beams}} + self.beams[name] = {"nu": tracer.nu, "beams": tracer.beam} # Put lcuts in a format that is recognisable by CAMB. self.lcuts = {k.lower(): c for k, c in self.lcuts.items()} diff --git a/mflike/theoryforge.py b/mflike/theoryforge.py index 7741794..ebacd49 100644 --- a/mflike/theoryforge.py +++ b/mflike/theoryforge.py @@ -250,7 +250,7 @@ def _bandpass_construction(self, **params): self.bandint_freqs_T.append([nub, tranb / tranb_norm]) self.bandint_freqs_P.append([nub, tranb / tranb_norm]) else: - blT, blP = self.return_beams(exp, nu_ghz, self.bandint_width[iexp]) + blT, blP = self.return_beams(exp, nu_ghz, params[bandpar]) tranb_normT = np.trapz(_cmb2bb(nub)[..., np.newaxis] * blT, nub, axis=0) ratioT = _cmb2bb(nub)[..., np.newaxis] * blT / tranb_normT @@ -281,7 +281,7 @@ def _bandpass_construction(self, **params): self.bandint_freqs_T.append([nub, trans]) self.bandint_freqs_P.append([nub, trans]) else: - blT, blP = self.return_beams(exp, nu_ghz, self.bandint_width[iexp]) + blT, blP = self.return_beams(exp, nu_ghz, params[bandpar]) trans_normT = np.trapz( bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blT, nub, axis=0 @@ -406,7 +406,7 @@ def _init_foreground_model(self): self.cibc = fgc.FactorizedCrossSpectrum(fgf.CIB(), fgp.PowerSpectrumFromFile(cibc_file)) self.dust = fgc.FactorizedCrossSpectrum(fgf.ModifiedBlackBody(), fgp.PowerLaw()) self.tSZ_and_CIB = fgc.SZxCIB_Choi2020() - self.radioTE = fgc.FactorizedCrossSpectrumTE(fgf.PowerLaw(), fgf.PowerLaw, fgp.PowerLaw()) + self.radioTE = fgc.FactorizedCrossSpectrumTE(fgf.PowerLaw(), fgf.PowerLaw(), fgp.PowerLaw()) self.dustTE = fgc.FactorizedCrossSpectrumTE( fgf.ModifiedBlackBody(), fgf.ModifiedBlackBody(), fgp.PowerLaw() ) @@ -732,7 +732,7 @@ def _init_beam_from_file(self): if not self.beam_file: # option to read beam from sacc. try: - mflike.beams + bool(mflike.beams) except: raise ValueError("Beams not stored in sacc files!") else: @@ -744,7 +744,8 @@ def _init_beam_from_file(self): filename = os.path.join(data_path, "%s.yaml" % self.beam_file) if not os.path.exists(filename): raise ValueError("File " + filename + " does not exist!") - + + with open(filename, "r") as f: self.beams = yaml.load(f, Loader=yaml.Loader) @@ -871,4 +872,4 @@ def return_beams(self, exp, nu, dnu): # normalizing the beam profile such that it has a max at 1 at ell = 0 blT /= blT[:, 0][..., np.newaxis] - return blT, blP + return blT[:,2:self.l_bpws[-1] + 1], blP[:,2:self.l_bpws[-1] + 1] From 9171fd6ac5d74f3bb6bf5cddf7276f32606979c8 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Tue, 14 May 2024 16:38:21 +0100 Subject: [PATCH 06/43] more docs --- mflike/theoryforge.py | 41 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 39 insertions(+), 2 deletions(-) diff --git a/mflike/theoryforge.py b/mflike/theoryforge.py index ebacd49..9abb9b6 100644 --- a/mflike/theoryforge.py +++ b/mflike/theoryforge.py @@ -17,10 +17,12 @@ If one wants to use this class as standalone, the ``bands`` dictionary is filled when initializing ``TheoryForge``. -This class applies three kinds of systematic effects to the CMB + foreground power spectrum: +This class applies four kinds of systematic effects to the CMB + foreground power spectrum: * calibrations (global ``calG_all``, per channel ``cal_exp``, per field ``calT_exp``, ``calE_exp``) * polarization angles effect (``alpha_exp``) + * beam chromaticity (i.e. integrating the foreground SEDs with frequency dependent + beams) * systematic templates (e.g. T --> P leakage). In this case the dictionary ``systematics_template`` has to be filled with the correct path ``rootname``: @@ -41,7 +43,7 @@ (which is the default now) * building the passbands :math:`\tau(\nu)`, either as Dirac delta or as top-hat -For the first option, it is necessary to leave the `top_hat_band` key empty in ``MFLike.yaml``: +For the first option, it is necessary to leave the ``top_hat_band`` key empty in ``MFLike.yaml``: .. code-block:: yaml @@ -66,6 +68,41 @@ nsteps: 1 bandwidth: 0 +If we want to neglect the beam chromaticity effect, we should leave the ``beam_profile`` key empty +in ``MFLike.yaml``: + +.. code-block:: yaml + + beam_profile: null + +If we want to consider it, we have several options on how to compute/read the beam profiles. Notice that we need arrays(freqs, ells+2) (computed from :math:`\ell = 0`), since we want a beam window function for each freq in the bandpasses. We should use this block in ``MFLike.yaml``: + +.. code-block:: yaml + + beam_profile: + Gaussian: True/False + rootname: "filename"/null + +There are several options: + * reading the beams from the sacc file (``Gaussian: False``, ``rootname: null/False``). The beams have to be stored in the ``sacc.tracers[exp].beam`` tracer (this is not working so far, since + the sacc beam tracer doesn't like an array(freq, ell) + * reading the beams from an external yaml file (``Gaussian: False``, ``rootname: "filename"``). + Do not use the ".yaml" extension nor the path to the file, which has to be the same as the + data path. The yaml file has to be a dictionary ``{"{exp}_s0": {"nu": nu, + "beams": array(freqs, ells+2)}, "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}`` + * computing the beams as Gaussian beams (``Gaussian: True``, ``rootname: ...``). When + ``Gaussian = True``, the beam is automatically computed within the code. Both T and + polarization Gaussian beams are computed through ``healpy.gauss_beam``. + +Once computed/read, the beam profiles are saved in + +.. code-block:: python + + self.beams = {"{exp}_s0": {"nu": nu, "beams": array(freqs, ells+2)}, "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}. + +The beams are appropriately normalized, then we select the bandpowers used in the rest of the code. + +In case of bandpass shift, we apply a correction to our beam profiles which is the one expected for Gaussian beams: :math:`b^{T/P}_{\ell}(\nu + \Delta \nu) = b^{T/P}_{\ell}(\nu) b^{T/P, Gauss. \, corr.}_{\ell}(\nu, \Delta \nu)`. """ import os From 8ad4c39ba0d682e6455cfa52cd3d74f2944e814d Mon Sep 17 00:00:00 2001 From: sgiardie Date: Wed, 15 May 2024 10:38:25 +0100 Subject: [PATCH 07/43] more debugging --- mflike/mflike.py | 1 - mflike/theoryforge.py | 7 ++----- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/mflike/mflike.py b/mflike/mflike.py index 1b1b2c5..341dc0f 100644 --- a/mflike/mflike.py +++ b/mflike/mflike.py @@ -30,7 +30,6 @@ from .theoryforge import TheoryForge - class MFLike(InstallableLikelihood): _url = "https://portal.nersc.gov/cfs/sobs/users/MFLike_data" _release = "v0.8" diff --git a/mflike/theoryforge.py b/mflike/theoryforge.py index 9abb9b6..49104e2 100644 --- a/mflike/theoryforge.py +++ b/mflike/theoryforge.py @@ -876,9 +876,6 @@ def gauss_correction(self, Nu, DNu, pol): / nu[..., np.newaxis] ) - # normalizing the beam correction for each freq - bcorr /= bcorr.max(axis=1)[..., np.newaxis] - return bcorr def return_beams(self, exp, nu, dnu): @@ -897,8 +894,8 @@ def return_beams(self, exp, nu, dnu): :return: The temperature and polarization beams """ if dnu != 0: - blT = self.beams[f"{exp}_s0"]["beams"] * self.gauss_correction(nu, dnu, False) - blP = self.beams[f"{exp}_s2"]["beams"] * self.gauss_correction(nu, dnu, True) + blT = self.beams[f"{exp}_s0"]["beams"][:,:self.l_bpws[-1] + 1] * self.gauss_correction(nu, dnu, False) + blP = self.beams[f"{exp}_s2"]["beams"][:,:self.l_bpws[-1] + 1] * self.gauss_correction(nu, dnu, True) else: blT = self.beams[f"{exp}_s0"]["beams"] blP = self.beams[f"{exp}_s2"]["beams"] From f7cc8a8f38748a22b58c13b4570a0c8b8d478147 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Wed, 15 May 2024 15:52:19 +0100 Subject: [PATCH 08/43] import healpy where needed --- mflike/theoryforge.py | 1 + 1 file changed, 1 insertion(+) diff --git a/mflike/theoryforge.py b/mflike/theoryforge.py index 49104e2..2d58761 100644 --- a/mflike/theoryforge.py +++ b/mflike/theoryforge.py @@ -812,6 +812,7 @@ def gauss_beams(self, nu, pol): profiles for each frequency in :math:`\nu` (from :math:`\ell = 0`) """ from astropy import constants, units + import healpy as hp mirror_size = 6 * units.m wavelenght = constants.c / (nu * 1e9 / units.s) From 019d4746db8af2cd6ea2ef52824029107fe2e6d6 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Wed, 15 May 2024 16:41:28 +0100 Subject: [PATCH 09/43] changing jupyter kernel --- docs/source/notebooks/tutorial_foregrounds.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/source/notebooks/tutorial_foregrounds.ipynb b/docs/source/notebooks/tutorial_foregrounds.ipynb index be967b6..0cb29ff 100644 --- a/docs/source/notebooks/tutorial_foregrounds.ipynb +++ b/docs/source/notebooks/tutorial_foregrounds.ipynb @@ -445,9 +445,9 @@ ], "metadata": { "kernelspec": { - "display_name": "mflike", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "mflike" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -459,7 +459,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.0" + "version": "3.9.13" }, "widgets": { "application/vnd.jupyter.widget-state+json": { From 0948edf231c05cb0b381965c705266be8ecb72c0 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 16 May 2024 11:03:37 +0100 Subject: [PATCH 10/43] trying to solve macos-latest test failing --- .github/workflows/testing.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index d81d36d..e350938 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -27,6 +27,8 @@ jobs: run: | set -x sudo ln -s /usr/local/bin/gfortran-11 /usr/local/bin/gfortran + sudo mkdir /usr/local/gfortran + sudo ln -s /usr/local/Cellar/gcc@11/*/lib/gcc/11 /usr/local/gfortran/lib gfortran --version - name: Install dependencies via pip From 30c400d95052ad0e64dfc1fbb1a3c0e11a137799 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 16 May 2024 11:05:16 +0100 Subject: [PATCH 11/43] never mind --- .github/workflows/testing.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index e350938..d81d36d 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -27,8 +27,6 @@ jobs: run: | set -x sudo ln -s /usr/local/bin/gfortran-11 /usr/local/bin/gfortran - sudo mkdir /usr/local/gfortran - sudo ln -s /usr/local/Cellar/gcc@11/*/lib/gcc/11 /usr/local/gfortran/lib gfortran --version - name: Install dependencies via pip From 9d83dc4eb01b115d77d93b7fdb3bfd7efb38d0a2 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 16 May 2024 13:24:56 +0100 Subject: [PATCH 12/43] test --- .github/workflows/testing.yml | 2 +- docs/source/notebooks/tutorial_fisher.ipynb | 23 +-------------------- 2 files changed, 2 insertions(+), 23 deletions(-) diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index d81d36d..009a3c6 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -26,7 +26,7 @@ jobs: if: matrix.os == 'macos-latest' run: | set -x - sudo ln -s /usr/local/bin/gfortran-11 /usr/local/bin/gfortran + sudo ln -s /usr/local/bin/gfortran-12 /usr/local/bin/gfortran gfortran --version - name: Install dependencies via pip diff --git a/docs/source/notebooks/tutorial_fisher.ipynb b/docs/source/notebooks/tutorial_fisher.ipynb index 98a62eb..c4a39e8 100644 --- a/docs/source/notebooks/tutorial_fisher.ipynb +++ b/docs/source/notebooks/tutorial_fisher.ipynb @@ -5,7 +5,6 @@ "execution_count": 1, "id": "34cfa477-c7d6-4a47-b698-2a2c634eddcd", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -27,7 +26,6 @@ "cell_type": "markdown", "id": "6b126358-89b0-4766-8a19-180d5fe80a78", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -41,7 +39,6 @@ "cell_type": "markdown", "id": "61494c8a-a9d5-4950-92a7-c22dcd8c1978", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -56,7 +53,6 @@ "execution_count": 2, "id": "727a69c3-02b5-421d-a336-1a7980ec6385", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -102,7 +98,6 @@ "cell_type": "markdown", "id": "2de3baed-3383-4f43-9dbe-da5f8914d9b2", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -117,7 +112,6 @@ "execution_count": 3, "id": "43b78d59-8ff3-4720-9266-b43ea5e98446", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -143,7 +137,6 @@ "cell_type": "markdown", "id": "5869c6ff-4b0d-40eb-9649-314f936c123c", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -161,7 +154,6 @@ "execution_count": 4, "id": "e96d303c-9234-4472-a940-0e10575f2d51", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -196,7 +188,6 @@ "cell_type": "markdown", "id": "db9032cc-b02c-46b3-9fa9-2a470ab2b0f5", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -213,7 +204,6 @@ "execution_count": 5, "id": "749bbc53-58f6-480c-ba2d-4731b6db6744", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -229,7 +219,6 @@ "cell_type": "markdown", "id": "2521c615-536b-4ce8-aa0b-79728db3fd81", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -244,7 +233,6 @@ "execution_count": 6, "id": "9280106a-72c9-4f38-9f62-96798b42d86c", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -261,7 +249,6 @@ "cell_type": "markdown", "id": "84671593-d589-4d04-acf5-265c8e8c2440", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -279,7 +266,6 @@ "execution_count": 113, "id": "19f5f5f1-91a9-4d61-a5bb-29951b3ce2ca", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -345,7 +331,6 @@ "cell_type": "markdown", "id": "067a77fb-3ace-4f01-aa09-07597676eed3", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -361,7 +346,6 @@ "execution_count": 64, "id": "6e3f2b20-5240-4e65-afdf-f8c4a2d52ae1", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -410,7 +394,6 @@ "cell_type": "markdown", "id": "e86f9319-94b1-4c65-90e5-ff812d80c66b", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -425,7 +408,6 @@ "execution_count": 112, "id": "1d9ab7cb-e045-424c-9562-e0a38e259138", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -639,7 +621,6 @@ "cell_type": "markdown", "id": "a7d8390e-00bd-414f-a5ab-50076b05dd4e", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -655,7 +636,6 @@ "execution_count": 10, "id": "a9d2f236-e23e-4767-9e60-fcf5f750d872", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -686,7 +666,6 @@ "cell_type": "markdown", "id": "695c4ded-3e85-4055-8f2a-fc8dc00aca82", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -716,7 +695,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.9.13" }, "widgets": { "application/vnd.jupyter.widget-state+json": { From 2ca1010ce0525c7fa757de45bbcd2099c329e69c Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 16 May 2024 13:46:38 +0100 Subject: [PATCH 13/43] test --- .github/workflows/testing.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index 009a3c6..85987c8 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -23,10 +23,10 @@ jobs: python-version: ${{ matrix.python-version }} - name: Set gfortran link on macos-latest - if: matrix.os == 'macos-latest' + if: matrix.os == 'macos-13' run: | set -x - sudo ln -s /usr/local/bin/gfortran-12 /usr/local/bin/gfortran + sudo ln -s /usr/local/bin/gfortran-11 /usr/local/bin/gfortran gfortran --version - name: Install dependencies via pip From 2c41d8d854f5ecd6262ed0fc00906b0a181b254c Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 16 May 2024 13:57:39 +0100 Subject: [PATCH 14/43] test --- .github/workflows/testing.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index 85987c8..3ba0bd7 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -23,10 +23,12 @@ jobs: python-version: ${{ matrix.python-version }} - name: Set gfortran link on macos-latest - if: matrix.os == 'macos-13' + if: matrix.os == 'macos-latest' run: | set -x sudo ln -s /usr/local/bin/gfortran-11 /usr/local/bin/gfortran + sudo mkdir /usr/local/gfortran + sudo ln -s /opt/homebrew/Cellar/gcc@11/*/lib/gcc/11 /usr/local/gfortran/lib gfortran --version - name: Install dependencies via pip From 40298311fa77936e8a3f0d7a585143fcbee525dd Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 16 May 2024 14:05:05 +0100 Subject: [PATCH 15/43] skipping macos-latest for now --- .github/workflows/testing.yml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index 3ba0bd7..80a1a3e 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -11,7 +11,7 @@ jobs: runs-on: ${{ matrix.os }} strategy: matrix: - os: [ubuntu-latest, macos-latest] + os: [ubuntu-latest, #macos-latest] python-version: ["3.9", "3.10", "3.11"] steps: @@ -27,8 +27,6 @@ jobs: run: | set -x sudo ln -s /usr/local/bin/gfortran-11 /usr/local/bin/gfortran - sudo mkdir /usr/local/gfortran - sudo ln -s /opt/homebrew/Cellar/gcc@11/*/lib/gcc/11 /usr/local/gfortran/lib gfortran --version - name: Install dependencies via pip From 1b3223b32dbcdbca0c7c420bd3b113a6f15a161a Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 16 May 2024 14:34:46 +0100 Subject: [PATCH 16/43] reintroducing macos-latest test --- .github/workflows/testing.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index 80a1a3e..3089022 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -11,7 +11,7 @@ jobs: runs-on: ${{ matrix.os }} strategy: matrix: - os: [ubuntu-latest, #macos-latest] + os: [ubuntu-latest, macos-latest] python-version: ["3.9", "3.10", "3.11"] steps: @@ -26,7 +26,7 @@ jobs: if: matrix.os == 'macos-latest' run: | set -x - sudo ln -s /usr/local/bin/gfortran-11 /usr/local/bin/gfortran + sudo ln -s /opt/homebrew/bin/gfortran-11 /usr/local/bin/gfortran gfortran --version - name: Install dependencies via pip From 7aac53208de97508b2033d1ebaa3d4d20d99969b Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 16 May 2024 15:10:37 +0100 Subject: [PATCH 17/43] adding a test --- mflike/tests/test_mflike.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/mflike/tests/test_mflike.py b/mflike/tests/test_mflike.py index bbf0d99..5046140 100644 --- a/mflike/tests/test_mflike.py +++ b/mflike/tests/test_mflike.py @@ -179,3 +179,25 @@ def get_model(nsteps, bandwidth): } chi2_mflike = -2 * (getattr(self, model).loglikes(new_params)[0] - logp_const) self.assertAlmostEqual(chi2_mflike[0], chi2[i], 2) + + def test_Gaussian_chromatic_beams(self): + info = { + "likelihood": { + "mflike.MFLike": { + "input_file": pre + "00000.fits", + "cov_Bbl_file": "data_sacc_w_covar_and_Bbl.fits", + "beam_profile": {"Gaussian": True}, + }, + }, + "theory": {"camb": {"extra_args": {"lens_potential_accuracy": 1}}}, + "params": cosmo_params, + "packages_path": packages_path, + } + from cobaya.model import get_model + + model = get_model(info) + my_mflike = model.likelihood["mflike.MFLike"] + chi2 = -2 * (model.loglikes(nuis_params)[0] - my_mflike.logp_const) + chi2s_beam = {"tt-te-et-ee": 4272.842504438564} + self.assertAlmostEqual(chi2[0], chi2s_beam["tt-te-et-ee"], 2) + From 8f9eb0814c4cb974c53b1e31e5caa86efc3aa1db Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 16 May 2024 15:18:47 +0100 Subject: [PATCH 18/43] adding healpy as dependency --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 40ffea0..cf8529f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,6 +27,7 @@ dependencies = [ "syslibrary>=0.2.0", "cobaya>=3.4.1", "sacc>=0.9.0", + "healpy", ] [project.optional-dependencies] From 6fab0c7d65dae9c7c978be1536c46b5db08b80fb Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 16 May 2024 15:34:46 +0100 Subject: [PATCH 19/43] also yaml needed to read beam external file --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index cf8529f..d74ec3a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,6 +28,7 @@ dependencies = [ "cobaya>=3.4.1", "sacc>=0.9.0", "healpy", + "PyYAML", ] [project.optional-dependencies] From f0f475f28ee4c3bffbea8c2a9da481f5c49396fa Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 16 May 2024 15:39:06 +0100 Subject: [PATCH 20/43] maybe pyyaml not needed since already a dependency of cobaya --- pyproject.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index d74ec3a..cf8529f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,7 +28,6 @@ dependencies = [ "cobaya>=3.4.1", "sacc>=0.9.0", "healpy", - "PyYAML", ] [project.optional-dependencies] From 5b97cdea45ea26e42164774502733099b2261adc Mon Sep 17 00:00:00 2001 From: Serena Giardiello <67148348+sgiardie@users.noreply.github.com> Date: Wed, 22 May 2024 12:17:30 +0100 Subject: [PATCH 21/43] debugging --- mflike/theoryforge.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mflike/theoryforge.py b/mflike/theoryforge.py index 2d58761..98107b7 100644 --- a/mflike/theoryforge.py +++ b/mflike/theoryforge.py @@ -328,8 +328,8 @@ def _bandpass_construction(self, **params): ) self.bandint_freqs_T.append([nub, ratioT]) - trans_normP = bp[..., np.newaxis] * np.trapz( - _cmb2bb(nub)[..., np.newaxis] * blP, nub, axis=0 + trans_normP = np.trapz( + bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blP, nub, axis=0 ) ratioP = ( bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blP / trans_normP From c4a6cded7107e070bc32e1f8c37b769de799cb9b Mon Sep 17 00:00:00 2001 From: sgiardie Date: Fri, 24 May 2024 11:11:46 +0100 Subject: [PATCH 22/43] new FWHM parametrization for gaussian beams --- mflike/MFLike.yaml | 43 ++++++++-- mflike/mflike.py | 2 +- mflike/tests/test_mflike.py | 20 ++++- mflike/theoryforge.py | 166 +++++++++++++++++++++++++++--------- 4 files changed, 181 insertions(+), 50 deletions(-) diff --git a/mflike/MFLike.yaml b/mflike/MFLike.yaml index 0853f13..7382b5a 100644 --- a/mflike/MFLike.yaml +++ b/mflike/MFLike.yaml @@ -86,18 +86,43 @@ systematics_template: # specify if the beam profile has to be computed as a Gaussian beam # or be read from a file (either from external file with name "rootname" or from sacc) -# if Gaussian = False and rootname = False, it will be read from the sacc file -# if Gaussian = False and "rootname" is specified, it will be read from this file -# the file has to be saved in the same path as the data -# it has to be a yaml with keys = experiments and items = array((freqs, ells)) -# indicate only the name, without the yaml extension and the rest of the path -# i.e. numpy arrays of beam profiles for each frequency in the passband of that array +# - if Gaussian_beam = False/empty and beam_from_file = False/empty, it will be read from the sacc file +# - if Gaussian_beam = False/empty and beam_from_file is specified, it will be read from this file +# the file has to be saved in the same path as the data +# indicate only the name, without the yaml extension and the rest of the path +# it has to be a yaml with keys = experiments and items = array((freqs, ells)) +# i.e. numpy arrays of beam profiles for each frequency in the passband of that array +# - If we want to compute Gaussian beams, fill the Gaussian_beam entry with dictionaries +# containing the parametrization for FWHM for each experiment/array in T and pol +# - If bandpass shifts are != 0, you have to fill the Gaussian_beam_correction dict +# in the same way you would fill the Gaussian_beam one, since this correction is computed assuming +# a Gaussian beam. The beam profile in this case does not have to be Gaussian, we can read it from +# file and still apply this Gaussian correction due to bandpass shifts != 0. # default is the beam_profile to be a null dict and chromatic beam not # taken into account beam_profile: -# Gaussian has to be either True or False -# Gaussian: -# rootname: +# Gaussian has to be either empty or filled with params needed for each experiment +# Gaussian_beam: +# LAT_93_s0: +# FWHM_0: ... +# nu_0: ... +# alpha: ... +# LAT_93_s2: +# FWHM_0: ... +# nu_0: ... +# alpha: ... +# LAT_145_s0: +# ... +# ... +# Gaussian_beam_correction: +# LAT_93_s0: +# FWHM_0: ... +# nu_0: ... +# alpha: ... +# LAT_93_s2: +# FWHM_0: ... +# ... +# beam_from_file: "filename"/null foregrounds: normalisation: diff --git a/mflike/mflike.py b/mflike/mflike.py index 341dc0f..cdf1700 100644 --- a/mflike/mflike.py +++ b/mflike/mflike.py @@ -164,7 +164,7 @@ def logp(self, **params_values): return self.loglike(cl, **params_values_nocosmo) def loglike(self, cl, **params_values_nocosmo): - """ + r""" Computes the gaussian log-likelihood :param cl: the dictionary of theory + foregrounds :math:`D_{\ell}` diff --git a/mflike/tests/test_mflike.py b/mflike/tests/test_mflike.py index 5046140..5270372 100644 --- a/mflike/tests/test_mflike.py +++ b/mflike/tests/test_mflike.py @@ -181,12 +181,30 @@ def get_model(nsteps, bandwidth): self.assertAlmostEqual(chi2_mflike[0], chi2[i], 2) def test_Gaussian_chromatic_beams(self): + + def compute_FWHM(nu): + from astropy import constants, units + + mirror_size = 6 * units.m + wavelenght = constants.c / (nu * 1e9 / units.s) + fwhm = 1.22 * wavelenght / mirror_size + return fwhm + + beam_params = {} + for f in [93, 145, 225]: + beam_params[f"LAT_{f}_s0"] = { + "FWHM_0": compute_FWHM(f), + "nu_0": f, + "alpha": 2 + } + beam_params[f"LAT_{f}_s2"] = beam_params[f"LAT_{f}_s0"] + info = { "likelihood": { "mflike.MFLike": { "input_file": pre + "00000.fits", "cov_Bbl_file": "data_sacc_w_covar_and_Bbl.fits", - "beam_profile": {"Gaussian": True}, + "beam_profile": {"Gaussian_beam": beam_params}, }, }, "theory": {"camb": {"extra_args": {"lens_potential_accuracy": 1}}}, diff --git a/mflike/theoryforge.py b/mflike/theoryforge.py index 2d58761..7a8f3c0 100644 --- a/mflike/theoryforge.py +++ b/mflike/theoryforge.py @@ -80,19 +80,41 @@ .. code-block:: yaml beam_profile: - Gaussian: True/False - rootname: "filename"/null - + Gaussian_beam: dict/False/null + beam_from_file: "filename"/False/null + There are several options: - * reading the beams from the sacc file (``Gaussian: False``, ``rootname: null/False``). The beams have to be stored in the ``sacc.tracers[exp].beam`` tracer (this is not working so far, since - the sacc beam tracer doesn't like an array(freq, ell) - * reading the beams from an external yaml file (``Gaussian: False``, ``rootname: "filename"``). + * reading the beams from the sacc file (``Gaussian_beam: False/null``, ``beam_from_file: False/null``). + The beams have to be stored in the ``sacc.tracers[exp].beam`` tracer + (this is not working so far, since the sacc beam tracer doesn't like an array(freq, ell)) + * reading the beams from an external yaml file (``Gaussian_beam: False/null``, ``beam_from_file: "filename"``). Do not use the ".yaml" extension nor the path to the file, which has to be the same as the data path. The yaml file has to be a dictionary ``{"{exp}_s0": {"nu": nu, "beams": array(freqs, ells+2)}, "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}`` - * computing the beams as Gaussian beams (``Gaussian: True``, ``rootname: ...``). When - ``Gaussian = True``, the beam is automatically computed within the code. Both T and - polarization Gaussian beams are computed through ``healpy.gauss_beam``. + * computing the beams as Gaussian beams (``Gaussian_beam: dict``, ``beam_from_file: ...``). When + ``Gaussian_beam`` is not empty, the beam is automatically computed within the code. Both T and + polarization Gaussian beams are computed through ``healpy.gauss_beam``. We need to pass a + dictionary with the ``FWHM_0``, ``nu_0``, ``alpha`` parameters for each array/experiment (both in T and pol), + in order to parametrize the Gaussian FWHM as :math:`FWHM(\nu) = FWHM(\nu_0) \left( \frac{\nu}{\nu_0} \right)^{-\alpha/2}`: + +.. code-block:: yaml + + beam_profile: + Gaussian_beam: + LAT_93_s0: + FWHM_0: ... + nu_0: ... + alpha: ... + LAT_93_s2: + FWHM_0: ... + nu_0: ... + alpha: ... + LAT_145_s0: + FWHM_0: ... + nu_0: ... + alpha: ... + ... + beam_from_file: null Once computed/read, the beam profiles are saved in @@ -103,6 +125,30 @@ The beams are appropriately normalized, then we select the bandpowers used in the rest of the code. In case of bandpass shift, we apply a correction to our beam profiles which is the one expected for Gaussian beams: :math:`b^{T/P}_{\ell}(\nu + \Delta \nu) = b^{T/P}_{\ell}(\nu) b^{T/P, Gauss. \, corr.}_{\ell}(\nu, \Delta \nu)`. + +To compute :math:`b^{T/P, Gauss. \, corr.}_{\ell}(\nu, \Delta \nu)` we need a dictionary with the FWHM(\nu_0), nu_0 and alpha information for all the arrays/experiments, because of the parametrization of the FWHM for Gaussian beams. We need to provide this dictionary under ``Gaussian_beam_correction``: + +.. code-block:: yaml + + beam_profile: + Gaussian_beam_correction: + LAT_93_s0: + FWHM_0: ... + nu_0: ... + alpha: ... + LAT_93_s2: + FWHM_0: ... + nu_0: ... + alpha: ... + LAT_145_s0: + FWHM_0: ... + nu_0: ... + alpha: ... + ... + Gaussian_beam: dict/False/null + beam_from_file: "filename"/False/null + +The beam profile itself is not forced to be Gaussian, it can also be read from file and the Gaussian correction will still be applied to it. """ import os @@ -206,11 +252,15 @@ def __init__(self, mflike=None): self.use_beam_profile = bool(mflike.beam_profile) if self.use_beam_profile: self.beam_profile = mflike.beam_profile - if not self.beam_profile.get("Gaussian"): - self.beam_file = self.beam_profile.get("rootname") + if not self.beam_profile.get("Gaussian_beam"): + self.beam_file = self.beam_profile.get("beam_from_file") self._init_beam_from_file() else: + self.gaussian_params = self.beam_profile.get("Gaussian_beam") self._init_gauss_beams() + # filling the possible dictionary for the parametrization of gaussian correction + # this has to be present in case bandpass shifts != 0 + self.gaussian_correction_params = self.beam_profile.get("Gaussian_beam_correction") # Takes care of the bandpass construction. It returns a list of nu-transmittance # for each frequency or an array with the effective freqs. @@ -328,8 +378,8 @@ def _bandpass_construction(self, **params): ) self.bandint_freqs_T.append([nub, ratioT]) - trans_normP = bp[..., np.newaxis] * np.trapz( - _cmb2bb(nub)[..., np.newaxis] * blP, nub, axis=0 + trans_normP = np.trapz( + bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blP, nub, axis=0 ) ratioP = ( bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blP / trans_normP @@ -786,25 +836,51 @@ def _init_beam_from_file(self): with open(filename, "r") as f: self.beams = yaml.load(f, Loader=yaml.Loader) + #checking that the freq array is compatible with the bandpass one + for exp in self.experiments: + # checking nu is the same as the bandpass one + if not np.allclose(self.beams[f"{exp}_s0"]['nu'], self.bands[f"{exp}_s0"]['nu'], atol = 1e-5): + raise LoggedError(self.log, f"Frequency array for beam {exp}_s0 is not the same as the bandpass one!") + if not np.allclose(self.beams[f"{exp}_s2"]['nu'], self.bands[f"{exp}_s2"]['nu'], atol = 1e-5): + raise LoggedError(self.log, f"Frequency array for beam {exp}_s2 is not the same as the bandpass one!") + + def _init_gauss_beams(self): """ Computes the dictionary of beams for each frequency of self.experiments """ self.beams = {} for iexp, exp in enumerate(self.experiments): - bands = self.bands[f"{exp}_s0"] - nu = np.asarray(bands["nu"]) + gauss_pars = self.gaussian_params[f"{exp}_s0"] + FWHM0 = np.asarray(gauss_pars["FWHM_0"]) + #using the same freq array as the bandpass one + nu = np.asarray(self.bands[f"{exp}_s0"]['nu']) + nu0 = np.asarray(gauss_pars["nu_0"]) + alpha = np.asarray(gauss_pars["alpha"]) # computing temperature beam for exp - self.beams[f"{exp}_s0"] = {"nu": nu, "beams": self.gauss_beams(nu, False)} - # computing polarization beam for exp - self.beams[f"{exp}_s2"] = {"nu": nu, "beams": self.gauss_beams(nu, True)} - - def gauss_beams(self, nu, pol): + self.beams[f"{exp}_s0"] = {"nu": nu, "beams": self.gauss_beams(FWHM0, nu, nu0, alpha, False)} + # doing the same for polarization + gauss_pars = self.gaussian_params[f"{exp}_s2"] + FWHM0 = np.asarray(gauss_pars["FWHM_0"]) + # nu pol should be the same as the T one, I'll comment it for now + #nu = np.asarray(self.bands[f"{exp}_s2"]['nu']) + nu0 = np.asarray(gauss_pars["nu_0"]) + alpha = np.asarray(gauss_pars["alpha"]) + # checking nu is the same as the bandpass one + self.beams[f"{exp}_s2"] = {"nu": nu, "beams": self.gauss_beams(FWHM0, nu, nu0, alpha, True)} + + + def gauss_beams(self, fwhm0, nu, nu0, alpha, pol): r""" Computes the Gaussian beam (either for T or pol) for each frequency of a - frequency array according to eqs. 54/55 of arXiv:astro-ph/0008228 + frequency array according to eqs. 54/55 of arXiv:astro-ph/0008228. We assume a more general + scaling for the FWHM: :math:`FWHM(\nu) = FWHM(\nu_0) \left( \frac{\nu}{\nu_0} \right)^{-\alpha}`. + :param fwhm0: the FWHM for the pivot frequency :param nu: the frequency array in GHz + :param nu0: the pivot frequency in GHz + :param alpha: the exponent of the frequency scaling + :math:`\left( \frac{\nu}{\nu_0} \right)^{-\alpha/2}` :param pol: (Bool) False to compute temperature Gaussian beam, True for the polarization one @@ -814,9 +890,7 @@ def gauss_beams(self, nu, pol): from astropy import constants, units import healpy as hp - mirror_size = 6 * units.m - wavelenght = constants.c / (nu * 1e9 / units.s) - fwhm = 1.22 * wavelenght / mirror_size + fwhm = fwhm0 * (nu / nu0)**(-alpha/2.) bls = np.empty((len(nu), self.l_bpws[-1] + 1)) for ifw, fw in enumerate(fwhm): # saving the beam from ell = 2 to ell max of l_bpws @@ -828,31 +902,33 @@ def gauss_beams(self, nu, pol): return bls - def gauss_correction(self, Nu, DNu, pol): + def gauss_correction(self, fwhm0, nu, nu0, alpha, dnu, pol): r""" Computes the correction to a Gaussian beam given by a bandpass shift, both for temperature and polarization beams. This is applied to every kind of beams, assuming the Gaussian correction is good enough also for a non-Gaussian beam. - :param Nu: the frequency array in GHz - :param DNu: the bandpass shift :math:`\Delta \nu` + :param fwhm0: the FWHM for the pivot frequency + :param nu: the frequency array in GHz + :param nu0: the pivot frequency in GHz + :param alpha: the exponent of the frequency scaling + :math:`\left( \frac{\nu}{\nu_0} \right)^{-\alpha/2}` + :param dnu: the bandpass shift :math:`\Delta \nu` in GHz :param pol: (Bool) False to compute the correction to a temperature Gaussian beam, True for the polarization one :return: a :math:`b^{T/P, Gauss. \, corr.}_{\ell}(\nu, \Delta \nu)` = ``np.array(freqs, lmax +2)`` with correction to a temperature/polarization Gaussian beam profile for each frequency in :math:`\nu` - and bandpass shift :math:`\Delta \nu` (from :math:`\ell = 0`) + and bandpass shift :math:`\Delta \nu` (from :math:`\ell = 0`). + We assume the Gaussian beam FWHM to scale like: :math:`FWHM(\nu) = FWHM(\nu_0) \left( \frac{\nu}{\nu_0} \right)^{-\alpha}`. """ from astropy import constants, units - mirror_size = 6 * units.m # useful numerical factor coming from the conversion from sigma to nu - fac = 1.22 * constants.c / mirror_size / (2 * np.sqrt(2 * np.log(2))) - nu = Nu * 1e9 / units.s - dnu = DNu * 1e9 / units.s + fac = fwhm0 / (2 * np.sqrt(2 * np.log(2))) # other repeating factor - dnuf = 1.0 / (1.0 + 2.0 * dnu / nu + dnu**2 / nu**2) + dnuf = (1 + dnu/nu)**(-alpha) # let's compute it from ell = 0, as done in hp.gauss_beam ell = np.arange(self.l_bpws[-1] + 1) if not pol: @@ -861,20 +937,18 @@ def gauss_correction(self, Nu, DNu, pol): * (ell + 1) * fac * fac + * (nu[..., np.newaxis] / nu0)**(-alpha) * (dnuf[..., np.newaxis] - 1) / 2.0 - / nu[..., np.newaxis] - / nu[..., np.newaxis] ) else: bcorr = dnuf[..., np.newaxis] * np.exp( -(ell * (ell + 1) - 4.0) * fac * fac + * (nu[..., np.newaxis] / nu0)**(-alpha) * (dnuf[..., np.newaxis] - 1) / 2.0 - / nu[..., np.newaxis] - / nu[..., np.newaxis] ) return bcorr @@ -895,8 +969,22 @@ def return_beams(self, exp, nu, dnu): :return: The temperature and polarization beams """ if dnu != 0: - blT = self.beams[f"{exp}_s0"]["beams"][:,:self.l_bpws[-1] + 1] * self.gauss_correction(nu, dnu, False) - blP = self.beams[f"{exp}_s2"]["beams"][:,:self.l_bpws[-1] + 1] * self.gauss_correction(nu, dnu, True) + gauss_pars = self.gaussian_correction_params[f"{exp}_s0"] + FWHM0 = np.asarray(gauss_pars["FWHM_0"]) + #using the same freq array as the bandpass one + nu = np.asarray(self.bands[f"{exp}_s0"]['nu']) + nu0 = np.asarray(gauss_pars["nu_0"]) + alpha = np.asarray(gauss_pars["alpha"]) + blT = self.beams[f"{exp}_s0"]["beams"][:,:self.l_bpws[-1] + 1] * self.gauss_correction(FWHM0, nu, nu0, alpha, dnu, False) + + gauss_pars = self.gaussian_correction_params[f"{exp}_s2"] + FWHM0 = np.asarray(gauss_pars["FWHM_0"]) + #using the same freq array as the bandpass one + # nu pol should be the same as the T one, I'll comment it for now + #nu = np.asarray(self.bands[f"{exp}_s2"]['nu']) + nu0 = np.asarray(gauss_pars["nu_0"]) + alpha = np.asarray(gauss_pars["alpha"]) + blP = self.beams[f"{exp}_s2"]["beams"][:,:self.l_bpws[-1] + 1] * self.gauss_correction(FWHM0, nu, nu0, alpha, dnu, True) else: blT = self.beams[f"{exp}_s0"]["beams"] blP = self.beams[f"{exp}_s2"]["beams"] From a42c50d79ae466041795d6a1e30f339b756e9384 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 6 Jun 2024 11:17:15 +0100 Subject: [PATCH 23/43] changing approach for bandpass integration --- mflike/MFLike.yaml | 21 ++-- mflike/tests/test_mflike.py | 49 +++++++++ mflike/theoryforge.py | 213 ++++++++++++++++++------------------ mflike_utils/utils.py | 92 ++++++++++++++++ 4 files changed, 258 insertions(+), 117 deletions(-) create mode 100644 mflike_utils/utils.py diff --git a/mflike/MFLike.yaml b/mflike/MFLike.yaml index 7382b5a..efcd8df 100644 --- a/mflike/MFLike.yaml +++ b/mflike/MFLike.yaml @@ -86,7 +86,7 @@ systematics_template: # specify if the beam profile has to be computed as a Gaussian beam # or be read from a file (either from external file with name "rootname" or from sacc) -# - if Gaussian_beam = False/empty and beam_from_file = False/empty, it will be read from the sacc file +# - if Gaussian_beam = False/empty and beam_from_file = False/empty, it will be read from the sacc file (currently not working) # - if Gaussian_beam = False/empty and beam_from_file is specified, it will be read from this file # the file has to be saved in the same path as the data # indicate only the name, without the yaml extension and the rest of the path @@ -94,10 +94,12 @@ systematics_template: # i.e. numpy arrays of beam profiles for each frequency in the passband of that array # - If we want to compute Gaussian beams, fill the Gaussian_beam entry with dictionaries # containing the parametrization for FWHM for each experiment/array in T and pol -# - If bandpass shifts are != 0, you have to fill the Gaussian_beam_correction dict -# in the same way you would fill the Gaussian_beam one, since this correction is computed assuming -# a Gaussian beam. The beam profile in this case does not have to be Gaussian, we can read it from -# file and still apply this Gaussian correction due to bandpass shifts != 0. +# - If bandpass shifts are != 0, you have to fill the Bandpass_shifted_beams key +# with the name of the file containing the dictionary with beam profiles for different values +# of Delta nu. As before, the file should be a yaml, the filename should not contain the ".yaml" +# extension and should be in the same path as the data. The dictionary should contain a key for +# each experiment/array, and for each of these keys there should be a "nu_0", "alpha" and "beams" +# keys. The "beams" item would be a dictionary {"nu_0 + Delta nu": b_ell, "nu_0 + 2Delta nu": b'_ell,...} # default is the beam_profile to be a null dict and chromatic beam not # taken into account beam_profile: @@ -114,14 +116,7 @@ beam_profile: # LAT_145_s0: # ... # ... -# Gaussian_beam_correction: -# LAT_93_s0: -# FWHM_0: ... -# nu_0: ... -# alpha: ... -# LAT_93_s2: -# FWHM_0: ... -# ... +# Bandpass_shifted_beams: "filename"/null # beam_from_file: "filename"/null foregrounds: diff --git a/mflike/tests/test_mflike.py b/mflike/tests/test_mflike.py index 5270372..125dde5 100644 --- a/mflike/tests/test_mflike.py +++ b/mflike/tests/test_mflike.py @@ -219,3 +219,52 @@ def compute_FWHM(nu): chi2s_beam = {"tt-te-et-ee": 4272.842504438564} self.assertAlmostEqual(chi2[0], chi2s_beam["tt-te-et-ee"], 2) + + # testing the bandpass shift case + # generating the dictionary needed for the bandpass shift case + test_path = os.path.dirname(__file__) + import subprocess + subprocess.run("python "+os.path.join(test_path, "../../mflike_utils/utils.py"), shell=True, check=True) + + model.close() + + from copy import deepcopy + + # Let's vary values of bandint_shift parameters + params = deepcopy(nuis_params) + params.update( + { + k: {"prior": dict(min=0.9 * v, max=1.1 * v)} + for k, v in params.items() + if k.startswith("bandint_shift") + } + ) + + info = { + "likelihood": { + "mflike.MFLike": { + "input_file": pre + "00000.fits", + "cov_Bbl_file": "data_sacc_w_covar_and_Bbl.fits", + "beam_profile": {"Gaussian_beam": beam_params, + "Bandpass_shifted_beams": "LAT_beam_bandshift"}, + }, + }, + "theory": {"camb": {"extra_args": {"lens_potential_accuracy": 1}}}, + "params": {**cosmo_params, **params}, + "packages_path": packages_path, + } + from cobaya.model import get_model + + model = get_model(info) + logp_const = model.likelihood["mflike.MFLike"].logp_const + + chi2 = [4272.84250444, 10987.36734122, 127166.75296958] + + for i, bandshift in enumerate([0.0, 1.0, 5.0]): + new_params = { + **params, + **{par: bandshift for par in params.keys() if par.startswith("bandint_shift")}, + } + + chi2_mflike = -2 * (model.loglikes(new_params)[0] - logp_const) + self.assertAlmostEqual(chi2_mflike[0], chi2[i], 2) diff --git a/mflike/theoryforge.py b/mflike/theoryforge.py index 7a8f3c0..c91201d 100644 --- a/mflike/theoryforge.py +++ b/mflike/theoryforge.py @@ -124,31 +124,43 @@ The beams are appropriately normalized, then we select the bandpowers used in the rest of the code. -In case of bandpass shift, we apply a correction to our beam profiles which is the one expected for Gaussian beams: :math:`b^{T/P}_{\ell}(\nu + \Delta \nu) = b^{T/P}_{\ell}(\nu) b^{T/P, Gauss. \, corr.}_{\ell}(\nu, \Delta \nu)`. - -To compute :math:`b^{T/P, Gauss. \, corr.}_{\ell}(\nu, \Delta \nu)` we need a dictionary with the FWHM(\nu_0), nu_0 and alpha information for all the arrays/experiments, because of the parametrization of the FWHM for Gaussian beams. We need to provide this dictionary under ``Gaussian_beam_correction``: +In case of bandpass shift, the chromatic beams are derived as: :math:`b^{T/P}_{\ell}(\nu + \Delta \nu) = b^{T/P}_{\ell (\nu / \nu_0)^{-\alpha / 2}}(\nu_0 + \Delta \nu)`, starting from a monochromatic beam :math:`b^{T/P}_{\ell}(\nu_0 + \Delta \nu)`. This monochromatic beam is derived from measurements of the planet beam and assuming a certain bandpass shift :math:`\Delta \nu`. So we need a dictionary of these :math:`b^{T/P}_{\ell}(\nu_0 + \Delta \nu)` for the several values of :math:`\Delta \nu` that could be sampled in the MCMC. To apply the scaling :math:`b^{T/P}_{\ell (\nu / \nu_0)^{-\alpha / 2}}(\nu_0 + \Delta \nu)` we also need :math:`\nu_0` and :math:`\alpha` for each experiment/array. +The array of frequencies :math:`\nu` for each experiment/array is derived from the corresponding bandpass file. +This means that, when bandpass shifts are different from 0, we need to provide a yaml file under the key ``Bandpass_shifted_beams``: + .. code-block:: yaml beam_profile: - Gaussian_beam_correction: - LAT_93_s0: - FWHM_0: ... - nu_0: ... - alpha: ... - LAT_93_s2: - FWHM_0: ... - nu_0: ... - alpha: ... - LAT_145_s0: - FWHM_0: ... - nu_0: ... - alpha: ... - ... + Bandpass_shifted_beams: "bandpass_shifted_beams" Gaussian_beam: dict/False/null beam_from_file: "filename"/False/null -The beam profile itself is not forced to be Gaussian, it can also be read from file and the Gaussian correction will still be applied to it. +where the "bandpass_shifted_beams.yaml" file is structured as: + +.. code-block:: yaml + + LAT_93_s0: + beams: {..., '-2.0': b_ell(nu_0 -2), + '-1.0': b_ell(nu_0 -1), + ... + '5.0': b_ell(nu_0 + 5), + ...} + nu_0: ... + alpha: ... + LAT_93_s2: + beams: {'-10.0': b_ell(nu_0 - 10), ...} + nu_0: ... + alpha: ... + LAT_145_s0: + beams: ... + nu_0: ... + alpha: ... + ... + +The "bandpass_shifted_beams.yaml" file has to be saved in the same path as the data. + +It is important the keys of ``beam_profile["Bandpass_shifted_beams"]["{exp}_s0/2"]["beams"]`` are strings of floats representing the value of :math:`\Delta \nu` (if they are strings of int the code to read the associated beams would not work). """ import os @@ -258,9 +270,12 @@ def __init__(self, mflike=None): else: self.gaussian_params = self.beam_profile.get("Gaussian_beam") self._init_gauss_beams() - # filling the possible dictionary for the parametrization of gaussian correction + # reading the possible dictionary with beam profiles associated to bandpass shifts # this has to be present in case bandpass shifts != 0 - self.gaussian_correction_params = self.beam_profile.get("Gaussian_beam_correction") + self.bandsh_beams_path = self.beam_profile.get("Bandpass_shifted_beams") + if self.bandsh_beams_path: + print(self.bandsh_beams_path) + self.bandpass_shifted_beams = self._read_yaml_file(self.bandsh_beams_path) # Takes care of the bandpass construction. It returns a list of nu-transmittance # for each frequency or an array with the effective freqs. @@ -286,19 +301,13 @@ def _bandpass_construction(self, **params): When the chromatic beam is considered, we compute :math:`r_{\ell}^T(\nu+\Delta \nu) = \frac{\frac{\partial B_{\nu+\Delta \nu}}{\partial T} - \tau(\nu+\Delta \nu) b^T_{\ell}(\nu) b^{T, Gauss \, corr}_{\ell}(\nu, \Delta \nu)} + \tau(\nu+\Delta \nu) b^T_{\ell}(\nu + \Delta \nu)} {\int d\nu \frac{\partial B_{\nu+\Delta \nu}}{\partial T} \tau(\nu+\Delta \nu) - b^T_{\ell}(\nu) b^{T, Gauss \, corr}_{\ell}(\nu, \Delta \nu)}` + b^T_{\ell}(\nu + \Delta \nu)}` for the temperature field, and a corresponding expression for the polarization field, replacing the temperature beam with the polarization one - :math:`b^P_{\ell}(\nu) b^{P, Gauss \, corr}_{\ell}(\nu, \Delta \nu)`. - - In the presence of bandpass shift, we have to apply a correction to our beam - which is the correction expected for a Gaussian beam (this is an approximation - to compute this correction also when we don't have an analytical expression - for our beam). - + :math:`b^P_{\ell}(\nu + \Delta \nu)`. :param \**params: dictionary of nuisance parameters :return: the list of [nu, transmission] in the multifrequency case @@ -807,6 +816,18 @@ def _get_template_from_file(self, dls_dict, **nuis_params): ## the correction expected for a Gaussian beam in case of bandpass shift ## that should be applied to any beam profile ########################################################################### + def _read_yaml_file(self, file_path): + import yaml + + data_path = self.data_folder + filename = os.path.join(data_path, "%s.yaml" % file_path) + if not os.path.exists(filename): + raise ValueError("File " + filename + " does not exist!") + + with open(filename, "r") as f: + file = yaml.load(f, Loader=yaml.Loader) + + return file def _init_beam_from_file(self): """ @@ -825,16 +846,7 @@ def _init_beam_from_file(self): else: self.beams = mflike.beams else: - import yaml - - data_path = self.data_folder - filename = os.path.join(data_path, "%s.yaml" % self.beam_file) - if not os.path.exists(filename): - raise ValueError("File " + filename + " does not exist!") - - - with open(filename, "r") as f: - self.beams = yaml.load(f, Loader=yaml.Loader) + self.beams = self._read_yaml_file(self.beam_file) #checking that the freq array is compatible with the bandpass one for exp in self.experiments: @@ -902,89 +914,82 @@ def gauss_beams(self, fwhm0, nu, nu0, alpha, pol): return bls - def gauss_correction(self, fwhm0, nu, nu0, alpha, dnu, pol): - r""" - Computes the correction to a Gaussian beam given by a bandpass shift, both - for temperature and polarization beams. This is applied to every kind of beams, - assuming the Gaussian correction is good enough also for a non-Gaussian beam. - :param fwhm0: the FWHM for the pivot frequency - :param nu: the frequency array in GHz - :param nu0: the pivot frequency in GHz - :param alpha: the exponent of the frequency scaling - :math:`\left( \frac{\nu}{\nu_0} \right)^{-\alpha/2}` - :param dnu: the bandpass shift :math:`\Delta \nu` in GHz - :param pol: (Bool) False to compute the correction to a temperature Gaussian beam, - True for the polarization one - - :return: a :math:`b^{T/P, Gauss. \, corr.}_{\ell}(\nu, \Delta \nu)` = ``np.array(freqs, lmax +2)`` - with correction to a temperature/polarization Gaussian beam profile - for each frequency in :math:`\nu` - and bandpass shift :math:`\Delta \nu` (from :math:`\ell = 0`). - We assume the Gaussian beam FWHM to scale like: :math:`FWHM(\nu) = FWHM(\nu_0) \left( \frac{\nu}{\nu_0} \right)^{-\alpha}`. - """ - from astropy import constants, units - - # useful numerical factor coming from the conversion from sigma to nu - fac = fwhm0 / (2 * np.sqrt(2 * np.log(2))) - # other repeating factor - dnuf = (1 + dnu/nu)**(-alpha) - # let's compute it from ell = 0, as done in hp.gauss_beam - ell = np.arange(self.l_bpws[-1] + 1) - if not pol: - bcorr = dnuf[..., np.newaxis] * np.exp( - -ell - * (ell + 1) - * fac - * fac - * (nu[..., np.newaxis] / nu0)**(-alpha) - * (dnuf[..., np.newaxis] - 1) - / 2.0 - ) - else: - bcorr = dnuf[..., np.newaxis] * np.exp( - -(ell * (ell + 1) - 4.0) - * fac - * fac - * (nu[..., np.newaxis] / nu0)**(-alpha) - * (dnuf[..., np.newaxis] - 1) - / 2.0 - ) - - return bcorr + def beam_interpolation(self, b_ell_template, f_ell, ells, freqs, freq_ref, alpha): + r''' + Computing :math:`b_{\ell}(\nu)` from monochromatic beam :math:`b_{\ell}` using the + frequency scaling: :math:`(b \cdot f)_{\ell \cdot (\nu / \nu_0)^{-\alpha / 2}}` + + :param b_ell_template: (nell array) Template for :math:`b_{\ell}`, should be 1 at ell=0. + :param f_ell: (nell array) Multiplicate correction to the :math:`b_{\ell}` template. + Should be 1 at ell=0. + :param ells: (nell array) ell array + :param freqs: (nfreq array) Frequency for that experiment/array + :param freq_ref: (float) Reference frequency. + :param alpha: (float) Power law index. + + + :return: a (nfreq, nell) array: :math:`b_{\ell}(\nu)` at each input frequency. + ''' + from scipy.interpolate import interp1d + + #f_ell = np.ones_like(b_ell_template) + fi = interp1d(ells, b_ell_template * f_ell, kind='linear', fill_value='extrapolate') + bnu = fi(ells[:,np.newaxis] * (freqs / freq_ref) ** (-alpha / 2)) + # Because we extrapolate beyond lmax, output can become negative, that is + # unphysical so we set these to zero. + bnu[bnu < 0] = 0 + # transposing to have an object (nfreq, nell) + return bnu.T def return_beams(self, exp, nu, dnu): r""" Returns the temperature and polarization beams, properly normalized and from - :math:`\ell = 2` (like ``self.l_bpws``). We compute them from :math:`\ell = 0` + :math:`\ell = 2` (same ell range as ``self.l_bpws``). We compute them from :math:`\ell = 0` to normalize them in the correct way (temperature beam = 1 for :math:`\ell = 0`). The polarization beam is normalized by the temperature one (as in ``hp.gauss_beam``). + In the presence of bandpass shift, we have to select the monochromatic beam :math:`b_{\ell}` + computed from the planet beam assuming that bandpass shift. This has to be present in the + ``self.bandpass_shifted_beams`` dictionary. From each of these :math:`b_{\ell}`, the + chromatic beam is computed with the scaling :math:`b_{\ell (\nu / \nu_0)^{-\alpha / 2}}`, + where :math:`\nu_0` and :math:`\alpha` are also found in the same dictionary. + :param nu: the frequency array in GHz (for now, the math:`\nu` array is the same between bandpass file and beam file for the same experiment/array. It is passed from the ``_bandpass_construction`` function for consistency.) :param dnu: the bandpass shift :math:`\Delta \nu` - :return: The temperature and polarization beams + :return: The temperature and polarization chromatic beams """ if dnu != 0: - gauss_pars = self.gaussian_correction_params[f"{exp}_s0"] - FWHM0 = np.asarray(gauss_pars["FWHM_0"]) - #using the same freq array as the bandpass one + bandsh_beams = self.bandpass_shifted_beams[f"{exp}_s0"] + #reading the Delta nu list in the file + dnulist = np.array([float(dn) for dn in bandsh_beams["beams"].keys()]) + #finding the Delta nu closer to the sampled one + Dnu = dnulist[abs(dnulist - dnu).argmin()] + #reading the corresponding monochromatic beam + #the dnu keys have to be strings of floats, not int + b = bandsh_beams["beams"][f"{Dnu}"] nu = np.asarray(self.bands[f"{exp}_s0"]['nu']) - nu0 = np.asarray(gauss_pars["nu_0"]) - alpha = np.asarray(gauss_pars["alpha"]) - blT = self.beams[f"{exp}_s0"]["beams"][:,:self.l_bpws[-1] + 1] * self.gauss_correction(FWHM0, nu, nu0, alpha, dnu, False) - - gauss_pars = self.gaussian_correction_params[f"{exp}_s2"] - FWHM0 = np.asarray(gauss_pars["FWHM_0"]) + nu0 = np.asarray(bandsh_beams["nu_0"]) + alpha = np.asarray(bandsh_beams["alpha"]) + blT = self.beam_interpolation(b[:self.l_bpws[-1]+1], np.ones(self.l_bpws[-1]+1), np.arange(self.l_bpws[-1]+1), nu, nu0, alpha) + + bandsh_beams = self.bandpass_shifted_beams[f"{exp}_s2"] + #reading the Delta nu list in the file + dnulist = np.array([float(dn) for dn in bandsh_beams["beams"].keys()]) + #finding the Delta nu closer to the sampled one + Dnu = dnulist[abs(dnulist - dnu).argmin()] + #reading the corresponding monochromatic beam + b = bandsh_beams["beams"][f"{Dnu}"] #using the same freq array as the bandpass one # nu pol should be the same as the T one, I'll comment it for now - #nu = np.asarray(self.bands[f"{exp}_s2"]['nu']) - nu0 = np.asarray(gauss_pars["nu_0"]) - alpha = np.asarray(gauss_pars["alpha"]) - blP = self.beams[f"{exp}_s2"]["beams"][:,:self.l_bpws[-1] + 1] * self.gauss_correction(FWHM0, nu, nu0, alpha, dnu, True) + # nu = np.asarray(self.bands[f"{exp}_s2"]['nu']) + nu0 = np.asarray(bandsh_beams["nu_0"]) + alpha = np.asarray(bandsh_beams["alpha"]) + blP = self.beam_interpolation(b[:self.l_bpws[-1]+1], np.ones(self.l_bpws[-1]+1), np.arange(self.l_bpws[-1]+1), nu, nu0, alpha) else: blT = self.beams[f"{exp}_s0"]["beams"] blP = self.beams[f"{exp}_s2"]["beams"] @@ -994,5 +999,5 @@ def return_beams(self, exp, nu, dnu): blP /= blT[:, 0][..., np.newaxis] # normalizing the beam profile such that it has a max at 1 at ell = 0 blT /= blT[:, 0][..., np.newaxis] - + return blT[:,2:self.l_bpws[-1] + 1], blP[:,2:self.l_bpws[-1] + 1] diff --git a/mflike_utils/utils.py b/mflike_utils/utils.py new file mode 100644 index 0000000..8938f15 --- /dev/null +++ b/mflike_utils/utils.py @@ -0,0 +1,92 @@ +r""" +Simple code to generate the bandpass shift dictionary needed in the presence of bandpass shifts different from 0. +We compute simple gaussian beams for :math:`\nu_0 + \Delta \nu`, assuming a diffraction limited experiment. +This is thought to be used in the absence of data coming from the planets beams measurements. +""" + +import numpy as np +from astropy import constants, units +import os +import tempfile +import yaml +from cobaya.install import install + +packages_path = os.environ.get("COBAYA_PACKAGES_PATH") or os.path.join( + tempfile.gettempdir(), "LAT_packages" +) + +data_path = packages_path + "/data/MFLike/v0.8" + +install({"likelihood": {"mflike.MFLike": None}}, path=packages_path) + +def compute_FWHM(nu): + """ + Simple function to compute FWHMi for the LAT assuming a diffraction limited experiment. + + :param nu: the frequency array in GHz + + :return: the FWHM for each nu + """ + mirror_size = 6 * units.m + wavelenght = constants.c / (nu * 1e9 / units.s) + fwhm = 1.22 * wavelenght / mirror_size + return fwhm + +def gauss_beams(fwhm0, nu, nu0, alpha, lmax, pol): + r""" + Computes the Gaussian beam (either for T or pol) for each frequency of a + frequency array according to eqs. 54/55 of arXiv:astro-ph/0008228. We assume a more general + scaling for the FWHM: :math:`FWHM(\nu) = FWHM(\nu_0) \left( \frac{\nu}{\nu_0} \right)^{-\alpha}`. + + :param fwhm0: the FWHM for the pivot frequency + :param nu: the frequency array in GHz + :param nu0: the pivot frequency in GHz + :param alpha: the exponent of the frequency scaling + :math:`\left( \frac{\nu}{\nu_0} \right)^{-\alpha/2}` + :param lmax: the lmax of the beams + :param pol: (Bool) False to compute temperature Gaussian beam, + True for the polarization one + + :return: a :math:`b^{Gauss.}_{\ell}(\nu)` = ``array(freqs, lmax +2)`` with Gaussian beam + profiles for each frequency in :math:`\nu` (from :math:`\ell = 0`) + """ + from astropy import constants, units + import healpy as hp + + fwhm = fwhm0 * (nu / nu0)**(-alpha/2.) + bls = np.empty((len(nu), lmax + 1)) + for ifw, fw in enumerate(fwhm): + # saving the beam from ell = 2 to ell max of l_bpws + if not pol: + bls[ifw, :] = hp.gauss_beam(fw, lmax=lmax) + else: + # selecting the polarized gaussian beam + bls[ifw, :] = hp.gauss_beam(fw, lmax=lmax, pol=True)[:, 1] + + return bls + +beam_dnu_dict = {} +# express delta nu as floats for the correct behavior of the code that will read this dictionary +dnu = np.arange(-20, 21, dtype = float) +for f in [93, 145, 225]: + fwhm = compute_FWHM(f) + gbeamT = gauss_beams(fwhm, f+dnu, f, 2, 10000, False) + gbeamP = gauss_beams(fwhm, f+dnu, f, 2, 10000, True) + beam_dnu_dict[f"LAT_{f}_s0"] = { + "beams": {f"{dn}": gbeamT[idn] for idn, dn in enumerate(dnu)}, + "nu_0": f, + "alpha": 2 + } + beam_dnu_dict[f"LAT_{f}_s2"] = { + "beams": {f"{dn}": gbeamP[idn] for idn, dn in enumerate(dnu)}, + "nu_0": f, + "alpha": 2 + } + + +# saving the yaml file +with open(data_path + '/LAT_beam_bandshift.yaml', 'w') as file: + yaml.dump(beam_dnu_dict, file, default_flow_style=False) + print("saving "+data_path + '/LAT_beam_bandshift.yaml') + + From 98604bcc1da3bb0f3f7068355c6ff6d642d78599 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 6 Jun 2024 12:23:06 +0100 Subject: [PATCH 24/43] mini correction --- mflike_utils/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mflike_utils/utils.py b/mflike_utils/utils.py index 8938f15..8786ccf 100644 --- a/mflike_utils/utils.py +++ b/mflike_utils/utils.py @@ -21,7 +21,7 @@ def compute_FWHM(nu): """ - Simple function to compute FWHMi for the LAT assuming a diffraction limited experiment. + Simple function to compute FWHM for the LAT assuming a diffraction limited experiment. :param nu: the frequency array in GHz From 0ecb4f09ff83b33eab50c4ea1bba48d4b22cf2b2 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 6 Jun 2024 13:30:29 +0100 Subject: [PATCH 25/43] debugging --- mflike/mflike.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/mflike/mflike.py b/mflike/mflike.py index cdf1700..8f52865 100644 --- a/mflike/mflike.py +++ b/mflike/mflike.py @@ -430,11 +430,7 @@ def get_sacc_names(pol, exp_1, exp_2): for name, tracer in s.tracers.items(): self.bands[name] = {"nu": tracer.nu, "bandpass": tracer.bandpass} # trying to read beams, if present - try: - tracer.beams - except: - pass - else: + if hasattr(tracer, "beam"): self.beams[name] = {"nu": tracer.nu, "beams": tracer.beam} # Put lcuts in a format that is recognisable by CAMB. From 35351cc653e8eb40b19d6f9ea569e5e892f80fec Mon Sep 17 00:00:00 2001 From: sgiardie Date: Fri, 5 Jul 2024 12:29:21 +0100 Subject: [PATCH 26/43] changing healpy dipendency to optional --- pyproject.toml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index cf8529f..5767a23 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,11 +27,10 @@ dependencies = [ "syslibrary>=0.2.0", "cobaya>=3.4.1", "sacc>=0.9.0", - "healpy", ] [project.optional-dependencies] -test = ["pytest", "pytest-cov", "camb"] +test = ["pytest", "pytest-cov", "camb", "healpy"] notebook = ["jupyter", "camb", "seaborn", "latex2mathml"] [project.urls] From ec787f29e8f82d95557985d779bdb0aca0189fe0 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Mon, 9 Sep 2024 11:19:27 +0100 Subject: [PATCH 27/43] fixing test --- examples/mflike_example.yaml | 2 +- mflike/foreground.py | 10 +++++++--- mflike/mflike_common.yaml | 9 +++++++++ 3 files changed, 17 insertions(+), 4 deletions(-) diff --git a/examples/mflike_example.yaml b/examples/mflike_example.yaml index daffc22..d54fd65 100644 --- a/examples/mflike_example.yaml +++ b/examples/mflike_example.yaml @@ -3,7 +3,7 @@ debug: True likelihood: - mflike.MFLike: + mflike.TTTEEE: input_file: LAT_simu_sacc_00044.fits cov_Bbl_file: data_sacc_w_covar_and_Bbl.fits diff --git a/mflike/foreground.py b/mflike/foreground.py index 7886303..60fea41 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -518,7 +518,6 @@ def init_bandpowers(self): self.use_beam_profile = bool(self.beam_profile) if self.use_beam_profile: - print("AOOOOO", self.data_folder) if not self.beam_profile.get("Gaussian_beam"): self.beam_file = self.beam_profile.get("beam_from_file") self._init_beam_from_file() @@ -529,8 +528,13 @@ def init_bandpowers(self): # this has to be present in case bandpass shifts != 0 self.bandsh_beams_path = self.beam_profile.get("Bandpass_shifted_beams") if self.bandsh_beams_path: - print("AOOOOO", self.data_folder) - self.bandpass_shifted_beams = self._read_yaml_file(self.bandsh_beams_path) + if self.data_folder is not None: + self.bandpass_shifted_beams = self._read_yaml_file(self.bandsh_beams_path) + else: + if self._initialized: + self.log.info("The data path has not been found") + + self._bandint_shift_params = [f"bandint_shift_{f}" for f in self.experiments] diff --git a/mflike/mflike_common.yaml b/mflike/mflike_common.yaml index 066edfe..82ef5be 100644 --- a/mflike/mflike_common.yaml +++ b/mflike/mflike_common.yaml @@ -19,3 +19,12 @@ alpha_LAT_145: alpha_LAT_225: value: 0 #deg latex: \alpha^{225} +bandint_shift_LAT_93: + value: 0 + latex: \Delta_{\rm band}^{93} +bandint_shift_LAT_145: + value: 0 + latex: \Delta_{\rm band}^{145} +bandint_shift_LAT_225: + value: 0 + latex: \Delta_{\rm band}^{225} From 320ad11942bbc06cba545a384ee525ba798bec3f Mon Sep 17 00:00:00 2001 From: sgiardie Date: Mon, 9 Sep 2024 11:42:36 +0100 Subject: [PATCH 28/43] fixing notebooks --- docs/source/notebooks/tutorial_fisher.ipynb | 4 -- .../notebooks/tutorial_foregrounds.ipynb | 39 ------------------- docs/source/notebooks/tutorial_loading.ipynb | 19 +-------- .../source/notebooks/tutorial_residuals.ipynb | 18 +-------- 4 files changed, 2 insertions(+), 78 deletions(-) diff --git a/docs/source/notebooks/tutorial_fisher.ipynb b/docs/source/notebooks/tutorial_fisher.ipynb index f603f23..d8e1568 100644 --- a/docs/source/notebooks/tutorial_fisher.ipynb +++ b/docs/source/notebooks/tutorial_fisher.ipynb @@ -698,11 +698,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", -<<<<<<< HEAD - "version": "3.9.13" -======= "version": "3.10.14" ->>>>>>> master }, "widgets": { "application/vnd.jupyter.widget-state+json": { diff --git a/docs/source/notebooks/tutorial_foregrounds.ipynb b/docs/source/notebooks/tutorial_foregrounds.ipynb index 0a3b833..a42a71b 100644 --- a/docs/source/notebooks/tutorial_foregrounds.ipynb +++ b/docs/source/notebooks/tutorial_foregrounds.ipynb @@ -61,41 +61,15 @@ "output_type": "stream", "text": [ " Numpy : 1.24.3\n", -<<<<<<< HEAD - "Matplotlib : 3.8.2\n", - " CAMB : 1.5.4\n", - " Cobaya : 3.4.1\n", - "[install] Installing external packages at '/tmp/LAT_packages'\n", -======= "Matplotlib : 3.8.0\n", " CAMB : 1.5.7\n", " Cobaya : 3.5.1\n", "[install] Installing external packages at 'C:\\Users\\micro\\AppData\\Local\\Temp\\LAT_packages'\n", ->>>>>>> master "\n", "================================================================================\n", "likelihood:mflike.MFLike\n", "================================================================================\n", -<<<<<<< HEAD - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "hwloc/linux: Ignoring PCI device with non-16bit domain.\n", - "Pass --enable-32bits-pci-domain to configure to support such devices\n", - "(warning: it would break the library ABI, don't enable unless really needed).\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ -======= "\n", ->>>>>>> master "[install] Checking if dependencies have already been installed...\n", "[install] External dependencies for this component already installed.\n", "[install] Doing nothing.\n", @@ -104,13 +78,8 @@ "* Summary * \n", "================================================================================\n", "\n", -<<<<<<< HEAD - "[install] All requested components' dependencies correctly installed at /tmp/LAT_packages\n", - "[camb] `camb` module loaded successfully from /home/serenagiardiello/anaconda3/envs/mflike/lib/python3.10/site-packages/camb\n", -======= "[install] All requested components' dependencies correctly installed at C:\\Users\\micro\\AppData\\Local\\Temp\\LAT_packages\n", "[camb] `camb` module loaded successfully from C:\\Work\\Dist\\git\\camb\\camb\n", ->>>>>>> master "[mflike.mflike] Number of bins used: 3087\n", "[mflike.mflike] Initialized!\n" ] @@ -189,11 +158,7 @@ "outputs": [ { "data": { -<<<<<<< HEAD - "image/png": "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", -======= "image/png": "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", ->>>>>>> master "text/plain": [ "
" ] @@ -472,11 +437,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", -<<<<<<< HEAD "version": "3.9.13" -======= - "version": "3.11.5" ->>>>>>> master }, "widgets": { "application/vnd.jupyter.widget-state+json": { diff --git a/docs/source/notebooks/tutorial_loading.ipynb b/docs/source/notebooks/tutorial_loading.ipynb index 1d54397..c645063 100644 --- a/docs/source/notebooks/tutorial_loading.ipynb +++ b/docs/source/notebooks/tutorial_loading.ipynb @@ -4,7 +4,6 @@ "cell_type": "markdown", "id": "d561f7c6-434f-46d0-bafc-07f5705b39e0", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -18,7 +17,6 @@ "cell_type": "markdown", "id": "5ab80bfe-f276-4617-906d-1794fd09c932", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -33,7 +31,6 @@ "execution_count": 1, "id": "69c60337-7626-48a3-9769-4a6c5ed73d8b", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -70,7 +67,6 @@ "cell_type": "markdown", "id": "075b1afa-7f22-485e-9134-df7f3688e559", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -84,7 +80,6 @@ "cell_type": "markdown", "id": "f2e77f13-7af8-460f-995c-f905b5ce326a", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -99,7 +94,6 @@ "execution_count": 2, "id": "35d4d883-0554-4c0f-ba43-c39bbdbc0735", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -117,7 +111,6 @@ "cell_type": "markdown", "id": "d51c0d79-81e0-4eac-b5ed-31ceafa32a03", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -132,7 +125,6 @@ "execution_count": 3, "id": "a282004c-7f40-4960-b4e5-1f5272f7b2da", "metadata": { - "editable": true, "scrolled": true, "slideshow": { "slide_type": "" @@ -216,7 +208,6 @@ "cell_type": "markdown", "id": "d5b75efe-5856-44fe-afd0-01c2957c906b", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -231,7 +222,6 @@ "execution_count": 4, "id": "7e56816c-4ff0-42dc-87b9-d4ba860f0f68", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -299,7 +289,6 @@ "cell_type": "markdown", "id": "009299c6-edfd-4971-9a91-f3ce5b234f5c", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -315,7 +304,6 @@ "execution_count": 5, "id": "a1c392f3-db2a-4a4f-aa8f-2094fa385992", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -350,7 +338,6 @@ "cell_type": "markdown", "id": "05537a7c-64c8-47f2-ac43-c032b9e395e6", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -366,7 +353,6 @@ "execution_count": 6, "id": "a2304c24-57b5-499e-8dd1-e51198db6dec", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -393,7 +379,6 @@ "cell_type": "markdown", "id": "18e7f49d-a89f-4aed-b907-e1599fa5567d", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -410,7 +395,6 @@ "execution_count": 7, "id": "e243d3ea-59a6-45c8-b18f-314d0af4ff32", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -425,7 +409,6 @@ "cell_type": "markdown", "id": "5ba1f7e3-ebf0-4ca4-89a5-ab7d5bf6b168", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -452,7 +435,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.9.13" }, "widgets": { "application/vnd.jupyter.widget-state+json": { diff --git a/docs/source/notebooks/tutorial_residuals.ipynb b/docs/source/notebooks/tutorial_residuals.ipynb index a3cfe2e..dc2ceef 100644 --- a/docs/source/notebooks/tutorial_residuals.ipynb +++ b/docs/source/notebooks/tutorial_residuals.ipynb @@ -5,7 +5,6 @@ "execution_count": 1, "id": "4c01ab6b-ea9b-4bff-8c6f-abac185b6936", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -27,7 +26,6 @@ "cell_type": "markdown", "id": "85b86cd8-0b55-4cb4-a7b2-28a7d55eb9e5", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -41,7 +39,6 @@ "cell_type": "markdown", "id": "d17b0825-d1ae-46b5-a8b3-6941f0355a9b", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -59,7 +56,6 @@ "execution_count": 2, "id": "4b7740a7-e6df-4ee9-9bbc-5638ad0b6f0d", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -105,7 +101,6 @@ "cell_type": "markdown", "id": "68ad7e98-d99d-4893-b9ec-bfc05f09b63a", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -120,7 +115,6 @@ "execution_count": 3, "id": "4b8533bc-5f74-4d92-a4dd-e60364ea4bfc", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -146,7 +140,6 @@ "cell_type": "markdown", "id": "405a7fb9-55a9-48bd-9c06-a9cd05e65691", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -161,7 +154,6 @@ "execution_count": 4, "id": "2caf02a2-f817-4bcf-a942-21b6cc6cf835", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -180,7 +172,6 @@ "cell_type": "markdown", "id": "d4e0a07f-01d4-4e81-abcc-5e65c33f0684", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -194,7 +185,6 @@ "cell_type": "markdown", "id": "e3cb799b-e0a0-434c-99f7-d9d676e4085d", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -211,7 +201,6 @@ "execution_count": 5, "id": "a7ddb3fd-c948-4781-b764-cc78499bd83b", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -226,7 +215,6 @@ "cell_type": "markdown", "id": "f0809472-c381-4093-a1b2-06a21e1bd857", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -241,7 +229,6 @@ "execution_count": 6, "id": "48432290-be76-4d81-b3c8-e63988a09231", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -307,7 +294,6 @@ "execution_count": 7, "id": "a85c9d37-a635-4e01-920a-638cc27b0a4e", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -387,7 +373,6 @@ "cell_type": "markdown", "id": "973190d9-5c96-4e3e-8b22-de8b17b04037", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -468,7 +453,6 @@ "cell_type": "markdown", "id": "609e3a6e-6711-4def-8f27-c2aebc35e10d", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -495,7 +479,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.9.13" }, "widgets": { "application/vnd.jupyter.widget-state+json": { From 674bfbec986f5dbe83604028113bf8f2bedbb3e9 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 12 Sep 2024 15:53:19 +0100 Subject: [PATCH 29/43] making beam file paths absolute paths --- mflike/foreground.py | 52 +++++++++++++++---------------------- mflike/mflike.py | 3 +-- mflike/tests/test_mflike.py | 5 ++-- 3 files changed, 25 insertions(+), 35 deletions(-) diff --git a/mflike/foreground.py b/mflike/foreground.py index 7d55642..8bd424d 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -65,16 +65,15 @@ mflike.BandpowerForeground: beam_profile: Gaussian_beam: dict/False/null - beam_from_file: "filename"/False/null + beam_from_file: filename/False/null There are several options: * reading the beams from the sacc file (``Gaussian_beam: False/null``, ``beam_from_file: False/null``). The beams have to be stored in the ``sacc.tracers[exp].beam`` tracer (this is not working so far, since the sacc beam tracer doesn't like an array(freq, ell)) - * reading the beams from an external yaml file (``Gaussian_beam: False/null``, ``beam_from_file: "filename"``). - Do not use the ".yaml" extension nor the path to the file, which has to be the same as the - data path. The yaml file has to be a dictionary ``{"{exp}_s0": {"nu": nu, - "beams": array(freqs, ells+2)}, "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}`` + * reading the beams from an external yaml file (``Gaussian_beam: False/null``, ``beam_from_file: filename``). ``filename`` has to be the absolute path for the file, without the ``.yaml`` extension, + which is automatically added by the code. The yaml file has to be a dictionary + ``{"{exp}_s0": {"nu": nu, "beams": array(freqs, ells+2)}, "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}`` * computing the beams as Gaussian beams (``Gaussian_beam: dict``, ``beam_from_file: ...``). When ``Gaussian_beam`` is not empty, the beam is automatically computed within the code. Both T and polarization Gaussian beams are computed through ``healpy.gauss_beam``. We need to pass a @@ -115,11 +114,11 @@ .. code-block:: yaml beam_profile: - Bandpass_shifted_beams: "bandpass_shifted_beams" + Bandpass_shifted_beams: bandpass_shifted_beams Gaussian_beam: dict/False/null - beam_from_file: "filename"/False/null + beam_from_file: filename/False/null -where the "bandpass_shifted_beams.yaml" file is structured as: +where the ``bandpass_shifted_beams.yaml`` file is structured as: .. code-block:: yaml @@ -141,7 +140,7 @@ alpha: ... ... -The "bandpass_shifted_beams.yaml" file has to be saved in the same path as the data. +``bandpass_shifted_beams`` has to be an absolute path, without the ``.yaml`` extension, which is added by the code. It is important the keys of ``beam_profile["Bandpass_shifted_beams"]["{exp}_s0/2"]["beams"]`` are strings of floats representing the value of :math:`\Delta \nu` (if they are strings of int the code to read the associated beams would not work). """ @@ -478,7 +477,6 @@ def must_provide(self, **requirements): "requested_cls must be the same in Foreground and MFLike") self.ells = req.get("ells", self.ells) self.experiments = req.get("experiments", self.experiments) - # self.data_folder = req.get("data_folder", self.data_folder) class BandpowerForeground(Foreground): @@ -488,7 +486,6 @@ class BandpowerForeground(Foreground): bands: dict = None beams: dict = None beam_profile: dict = None - data_folder: Optional[str] def initialize(self): super().initialize() @@ -499,6 +496,7 @@ def initialize(self): self._initialized = False self.init_bandpowers() + def init_bandpowers(self): self.use_top_hat_band = bool(self.top_hat_band) # Parameters for band integration @@ -528,14 +526,7 @@ def init_bandpowers(self): # this has to be present in case bandpass shifts != 0 self.bandsh_beams_path = self.beam_profile.get("Bandpass_shifted_beams") if self.bandsh_beams_path: - if self.data_folder is not None: - self.bandpass_shifted_beams = self._read_yaml_file(self.bandsh_beams_path) - else: - if self._initialized: - self.log.info("The data path has not been found") - - - + self.bandpass_shifted_beams = self._read_yaml_file(self.bandsh_beams_path) self._bandint_shift_params = [f"bandint_shift_{f}" for f in self.experiments] # default bandpass when shift is 0 @@ -555,9 +546,8 @@ def must_provide(self, **requirements): self.beams = req.get("beams", self.beams) self.top_hat_band = req.get("top_hat_band", self.top_hat_band) self.beam_profile = req.get("beam_profile", self.beam_profile) - self.data_folder = req.get("data_folder", self.data_folder) self.init_bandpowers() - + def get_can_support_params(self): return self._bandint_shift_params @@ -728,9 +718,8 @@ def _bandpass_construction(self, _initialize=False, **params): def _read_yaml_file(self, file_path): import yaml - data_path = self.data_folder - filename = os.path.join(data_path, "%s.yaml" % file_path) - if not os.path.exists(filename): + filename = "%s.yaml" % file_path + if not os.path.exists("%s.yaml" % file_path): raise ValueError("File " + filename + " does not exist!") with open(filename, "r") as f: @@ -757,13 +746,14 @@ def _init_beam_from_file(self): else: self.beams = self._read_yaml_file(self.beam_file) - #checking that the freq array is compatible with the bandpass one - for exp in self.experiments: - # checking nu is the same as the bandpass one - if not np.allclose(self.beams[f"{exp}_s0"]['nu'], self.bands[f"{exp}_s0"]['nu'], atol = 1e-5): - raise LoggedError(self.log, f"Frequency array for beam {exp}_s0 is not the same as the bandpass one!") - if not np.allclose(self.beams[f"{exp}_s2"]['nu'], self.bands[f"{exp}_s2"]['nu'], atol = 1e-5): - raise LoggedError(self.log, f"Frequency array for beam {exp}_s2 is not the same as the bandpass one!") + if self._initialized: + #checking that the freq array is compatible with the bandpass one + for exp in self.experiments: + # checking nu is the same as the bandpass one + if not np.allclose(self.beams[f"{exp}_s0"]['nu'], self.bands[f"{exp}_s0"]['nu'], atol = 1e-5): + raise LoggedError(self.log, f"Frequency array for beam {exp}_s0 is not the same as the bandpass one!") + if not np.allclose(self.beams[f"{exp}_s2"]['nu'], self.bands[f"{exp}_s2"]['nu'], atol = 1e-5): + raise LoggedError(self.log, f"Frequency array for beam {exp}_s2 is not the same as the bandpass one!") def _init_gauss_beams(self): """ diff --git a/mflike/mflike.py b/mflike/mflike.py index 7d34c5e..0fb34e4 100644 --- a/mflike/mflike.py +++ b/mflike/mflike.py @@ -110,8 +110,7 @@ def get_fg_requirements(self): "requested_cls": self.requested_cls, "experiments": self.experiments, "bands": self.bands, - "beams": self.beams, - "data_folder": self.data_folder} + "beams": self.beams} def get_requirements(self): r""" diff --git a/mflike/tests/test_mflike.py b/mflike/tests/test_mflike.py index b09fc86..e39c16f 100644 --- a/mflike/tests/test_mflike.py +++ b/mflike/tests/test_mflike.py @@ -389,8 +389,9 @@ def compute_FWHM(nu): }, "theory": {"camb": {"extra_args": {"lens_potential_accuracy": 1}}, "mflike.BandpowerForeground":{ - "beam_profile": {"Gaussian_beam": beam_params, - "Bandpass_shifted_beams": "LAT_beam_bandshift"}, + "beam_profile": {"Gaussian_beam": beam_params, + "Bandpass_shifted_beams": packages_path + + "/data/MFLike/v0.8/LAT_beam_bandshift"}, }, }, "params": cosmo_params | params, From fc4da2c72af7123e3df8361a6a9545596596ac39 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 12 Sep 2024 16:32:24 +0100 Subject: [PATCH 30/43] fix typo --- mflike/foreground.py | 1 - 1 file changed, 1 deletion(-) diff --git a/mflike/foreground.py b/mflike/foreground.py index 8bd424d..bc25048 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -545,7 +545,6 @@ def must_provide(self, **requirements): self.bands = req.get("bands", self.bands) self.beams = req.get("beams", self.beams) self.top_hat_band = req.get("top_hat_band", self.top_hat_band) - self.beam_profile = req.get("beam_profile", self.beam_profile) self.init_bandpowers() def get_can_support_params(self): From 8332b4b0a15cd857da2a1722a663effe54e54935 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Wed, 18 Sep 2024 14:51:41 +0100 Subject: [PATCH 31/43] setting default in case with bandpass shifts open --- mflike/foreground.py | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/mflike/foreground.py b/mflike/foreground.py index bc25048..ca8ca6e 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -106,10 +106,12 @@ The beams are appropriately normalized, then we select the bandpowers used in the rest of the code. -In case of bandpass shift, the chromatic beams are derived as: :math:`b^{T/P}_{\ell}(\nu + \Delta \nu) = b^{T/P}_{\ell (\nu / \nu_0)^{-\alpha / 2}}(\nu_0 + \Delta \nu)`, starting from a monochromatic beam :math:`b^{T/P}_{\ell}(\nu_0 + \Delta \nu)`. This monochromatic beam is derived from measurements of the planet beam and assuming a certain bandpass shift :math:`\Delta \nu`. So we need a dictionary of these :math:`b^{T/P}_{\ell}(\nu_0 + \Delta \nu)` for the several values of :math:`\Delta \nu` that could be sampled in the MCMC. To apply the scaling :math:`b^{T/P}_{\ell (\nu / \nu_0)^{-\alpha / 2}}(\nu_0 + \Delta \nu)` we also need :math:`\nu_0` and :math:`\alpha` for each experiment/array. +In case of bandpass shifts :math:`\Delta \nu \neq 0`, you can decide whether to propagate the bandpass shift effect to :math:`b_{\ell}(\nu)` or not. If you want to leave :math:`b_{\ell}(\nu)` unchanged even if :math:`\Delta \nu \neq 0` (assuming this modification is a second order effect), you just need to leave the ``beam_profile`` block as it is, i.e. ``Bandpass_shifted_beams: null``. + +In case you want to propagate this effect, the chromatic beams are derived as: :math:`b^{T/P}_{\ell}(\nu + \Delta \nu) = b^{T/P}_{\ell (\nu / \nu_0)^{-\alpha / 2}}(\nu_0 + \Delta \nu)`, starting from a monochromatic beam :math:`b^{T/P}_{\ell}(\nu_0 + \Delta \nu)`. This monochromatic beam is derived from measurements of the planet beam and assuming a certain bandpass shift :math:`\Delta \nu`. So we need a dictionary of these :math:`b^{T/P}_{\ell}(\nu_0 + \Delta \nu)` for the several values of :math:`\Delta \nu` that could be sampled in the MCMC. To apply the scaling :math:`b^{T/P}_{\ell (\nu / \nu_0)^{-\alpha / 2}}(\nu_0 + \Delta \nu)` we also need :math:`\nu_0` and :math:`\alpha` for each experiment/array. The array of frequencies :math:`\nu` for each experiment/array is derived from the corresponding bandpass file. -This means that, when bandpass shifts are different from 0, we need to provide a yaml file under the key ``Bandpass_shifted_beams``: +This means that, to propagate the bandpass shifts to :math:`b_{\ell}(\nu)`, we need to provide a yaml file under the key ``Bandpass_shifted_beams``: .. code-block:: yaml @@ -523,7 +525,8 @@ def init_bandpowers(self): self.gaussian_params = self.beam_profile.get("Gaussian_beam") self._init_gauss_beams() # reading the possible dictionary with beam profiles associated to bandpass shifts - # this has to be present in case bandpass shifts != 0 + # this has to be present if we want to propagate bandpass shifts to the chromatic beams + # otherwise they are left unchanged self.bandsh_beams_path = self.beam_profile.get("Bandpass_shifted_beams") if self.bandsh_beams_path: self.bandpass_shifted_beams = self._read_yaml_file(self.bandsh_beams_path) @@ -640,7 +643,11 @@ def _bandpass_construction(self, _initialize=False, **params): if "te" in self.requested_cls or "ee" in self.requested_cls: self.bandint_freqs_P.append([nub, tranb / tranb_norm]) else: - blT, blP = self.return_beams(exp, nu_ghz, shift) + if self.bandsh_beams_path: + blT, blP = self.return_beams(exp, nu_ghz, shift) + else: + # not propagating bandpass shifts to the chromatic beams + blT, blP = self.return_beams(exp, nu_ghz, 0.) if "tt" in self.requested_cls or "te" in self.requested_cls: tranb_normT = trapezoid(_cmb2bb(nub)[..., np.newaxis] * blT, nub, axis=0) @@ -679,7 +686,11 @@ def _bandpass_construction(self, _initialize=False, **params): if "te" in self.requested_cls or "ee" in self.requested_cls: self.bandint_freqs_P.append([nub, trans]) else: - blT, blP = self.return_beams(exp, nu_ghz, shift) + if self.bandsh_beams_path: + blT, blP = self.return_beams(exp, nu_ghz, shift) + else: + # not propagating bandpass shifts to the chromatic beams + blT, blP = self.return_beams(exp, nu_ghz, 0.) if "tt" in self.requested_cls or "te" in self.requested_cls: trans_normT = trapezoid( From 78b1a5e3fc2880a7916db6e992148ab547a80c48 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 19 Sep 2024 10:27:37 +0100 Subject: [PATCH 32/43] more docs --- mflike/foreground.py | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/mflike/foreground.py b/mflike/foreground.py index ca8ca6e..9e64825 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -596,13 +596,17 @@ def _bandpass_construction(self, _initialize=False, **params): When the chromatic beam is considered, we compute :math:`r_{\ell}^T(\nu+\Delta \nu) = \frac{\frac{\partial B_{\nu+\Delta \nu}}{\partial T} - \tau(\nu+\Delta \nu) b^T_{\ell}(\nu + \Delta \nu)} + \tau(\nu+\Delta \nu) b^T_{\ell}(\nu)} {\int d\nu \frac{\partial B_{\nu+\Delta \nu}}{\partial T} \tau(\nu+\Delta \nu) - b^T_{\ell}(\nu + \Delta \nu)}` + b^T_{\ell}(\nu)}` for the temperature field, and a corresponding expression for the polarization field, replacing the temperature beam with the polarization one - :math:`b^P_{\ell}(\nu + \Delta \nu)`. + :math:`b^P_{\ell}(\nu)`. If we want to propagate the bandpass shifts to the beam, we + compute instead :math:`r_{\ell}^T(\nu+\Delta \nu) = \frac{\frac{\partial B_{\nu+\Delta \nu}}{ + \partial T} \tau(\nu+\Delta \nu) b^T_{\ell}(\nu + \Delta \nu)} + {\int d\nu \frac{\partial B_{\nu+\Delta \nu}}{\partial T} \tau(\nu+\Delta \nu) + b^T_{\ell}(\nu + \Delta \nu)}`. :param \**params: dictionary of nuisance parameters :return: the list of [nu, transmission] in the multifrequency case @@ -855,11 +859,12 @@ def return_beams(self, exp, nu, dnu): to normalize them in the correct way (temperature beam = 1 for :math:`\ell = 0`). The polarization beam is normalized by the temperature one (as in ``hp.gauss_beam``). - In the presence of bandpass shift, we have to select the monochromatic beam :math:`b_{\ell}` - computed from the planet beam assuming that bandpass shift. This has to be present in the - ``self.bandpass_shifted_beams`` dictionary. From each of these :math:`b_{\ell}`, the - chromatic beam is computed with the scaling :math:`b_{\ell (\nu / \nu_0)^{-\alpha / 2}}`, - where :math:`\nu_0` and :math:`\alpha` are also found in the same dictionary. + If we want to propagate bandpass shifts to the beams, we have to select the + monochromatic beam :math:`b_{\ell}` computed from the planet beam assuming + that bandpass shift. This has to be present in the ``self.bandpass_shifted_beams`` + dictionary. From each of these :math:`b_{\ell}`, the chromatic beam is computed + with the scaling :math:`b_{\ell (\nu / \nu_0)^{-\alpha / 2}}`, where :math:`\nu_0` + and :math:`\alpha` are also found in the same dictionary. :param nu: the frequency array in GHz (for now, the math:`\nu` array is the same between bandpass file and beam file for the same experiment/array. From b3a346c7dafc24e16f29a93e255d4a7b5b3d5e2d Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 19 Sep 2024 11:22:13 +0100 Subject: [PATCH 33/43] fixing Foreground.yaml --- mflike/Foreground.yaml | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-) diff --git a/mflike/Foreground.yaml b/mflike/Foreground.yaml index d416d9f..cbe1848 100644 --- a/mflike/Foreground.yaml +++ b/mflike/Foreground.yaml @@ -1,13 +1,10 @@ -requested_cls: [ "tt", "te", "ee" ] +requested_cls: ["tt", "te", "ee"] lmin: 2 lmax: 6001 # ells set automatically from above if not set directly ells: -experiments: [ "LAT_93", "LAT_145", "LAT_225" ] -bandint_freqs: [ 93.0, 145.0, 225.0 ] - -# path to data -data_folder: +experiments: ["LAT_93", "LAT_145", "LAT_225"] +bandint_freqs: [93.0, 145.0, 225.0] # Parameters to build a top-hat band: # - nsteps sets the number of frequencies used in the band integration @@ -37,18 +34,18 @@ top_hat_band: # or be read from a file (either from external file with name "rootname" or from sacc) # - if Gaussian_beam = False/empty and beam_from_file = False/empty, it will be read from the sacc file (currently not working) # - if Gaussian_beam = False/empty and beam_from_file is specified, it will be read from this file -# the file has to be saved in the same path as the data -# indicate only the name, without the yaml extension and the rest of the path +# the file name has to be its absolute path without the yaml extension # it has to be a yaml with keys = experiments and items = array((freqs, ells)) # i.e. numpy arrays of beam profiles for each frequency in the passband of that array # - If we want to compute Gaussian beams, fill the Gaussian_beam entry with dictionaries # containing the parametrization for FWHM for each experiment/array in T and pol -# - If bandpass shifts are != 0, you have to fill the Bandpass_shifted_beams key -# with the name of the file containing the dictionary with beam profiles for different values -# of Delta nu. As before, the file should be a yaml, the filename should not contain the ".yaml" -# extension and should be in the same path as the data. The dictionary should contain a key for -# each experiment/array, and for each of these keys there should be a "nu_0", "alpha" and "beams" -# keys. The "beams" item would be a dictionary {"nu_0 + Delta nu": b_ell, "nu_0 + 2Delta nu": b'_ell,...} +# - If bandpass shifts are != 0 and you want to propagate them to the beams, you have to fill +# the Bandpass_shifted_beams key with the name of the file containing the dictionary +# with beam profiles for different values of Delta nu. As before, the file should be a yaml, +# and you should provide its absolute path without the ".yaml" extension. +# The dictionary should contain a key for each experiment/array, and for each of these keys +# there should be a "nu_0", "alpha" and "beams" keys. The "beams" item would be a +# dictionary {"nu_0 + Delta nu": b_ell, "nu_0 + 2Delta nu": b'_ell,...} # default is the beam_profile to be a null dict and chromatic beam not # taken into account beam_profile: From 77f6a7a4eb901ac443ca7f78367fadb2b304e55e Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 19 Sep 2024 13:56:01 +0100 Subject: [PATCH 34/43] renaming utils.py --- mflike/foreground.py | 61 +++++++++---------- mflike/mflike.py | 6 +- mflike/tests/test_mflike.py | 2 +- .../generate_beams_w_bandpass_shifts.py | 2 +- 4 files changed, 33 insertions(+), 38 deletions(-) rename mflike_utils/utils.py => scripts/generate_beams_w_bandpass_shifts.py (96%) diff --git a/mflike/foreground.py b/mflike/foreground.py index 9e64825..e499cee 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -493,8 +493,8 @@ def initialize(self): super().initialize() if self.bands is None: self.bands = { - f"{exp}_s0": {"nu": [self.bandint_freqs_T[iexp]], "bandpass": [1.0]} - for iexp, exp in enumerate(self.experiments)} + f"{exp}_{spin}": {"nu": [self.bandint_freqs_T[iexp]], "bandpass": [1.0]} + for spin in ["s0","s2"] for iexp, exp in enumerate(self.experiments)} self._initialized = False self.init_bandpowers() @@ -516,7 +516,10 @@ def init_bandpowers(self): self.log, "One band has width = 0, set a positive width and run again" ) - self.use_beam_profile = bool(self.beam_profile) + if not self._initialized: + self.use_beam_profile = False + else: + self.use_beam_profile = bool(self.beam_profile) if self.use_beam_profile: if not self.beam_profile.get("Gaussian_beam"): self.beam_file = self.beam_profile.get("beam_from_file") @@ -527,6 +530,7 @@ def init_bandpowers(self): # reading the possible dictionary with beam profiles associated to bandpass shifts # this has to be present if we want to propagate bandpass shifts to the chromatic beams # otherwise they are left unchanged + self.bandsh_beams_path = self.beam_profile.get("Bandpass_shifted_beams") if self.bandsh_beams_path: self.bandpass_shifted_beams = self._read_yaml_file(self.bandsh_beams_path) @@ -750,48 +754,40 @@ def _init_beam_from_file(self): """ if not self.beam_file: - # option to read beam from sacc. - try: - bool(mflike.beams) - except: + # option to read beam from sacc + if not bool(self.beams): raise ValueError("Beams not stored in sacc files!") - else: - self.beams = mflike.beams else: self.beams = self._read_yaml_file(self.beam_file) - - if self._initialized: - #checking that the freq array is compatible with the bandpass one - for exp in self.experiments: - # checking nu is the same as the bandpass one - if not np.allclose(self.beams[f"{exp}_s0"]['nu'], self.bands[f"{exp}_s0"]['nu'], atol = 1e-5): - raise LoggedError(self.log, f"Frequency array for beam {exp}_s0 is not the same as the bandpass one!") - if not np.allclose(self.beams[f"{exp}_s2"]['nu'], self.bands[f"{exp}_s2"]['nu'], atol = 1e-5): - raise LoggedError(self.log, f"Frequency array for beam {exp}_s2 is not the same as the bandpass one!") + + #checking that the freq array is compatible with the bandpass one + from itertools import product + for exp, spin in product(self.experiments, ["s0", "s2"]): + key = f"{exp}_{spin}" + # checking nu is the same as the bandpass one + if not np.allclose(self.beams[key]['nu'], self.bands[key]['nu'], atol = 1e-5): + raise LoggedError(self.log, f"Frequency array for beam {key} is not the same as the bandpass one!") + # checking beam shape is correct + if not self.beams[key]["beams"].shape[0] == self.bands[key]['nu'].size: + shape_b = self.beams[key]["beams"].shape[0] + shape_n = self.bands[key]['nu'].size + raise LoggedError(self.log, f"beam {key} has a wrong shape! It is shape ({shape_b}, ells), but shoule be ({shape_n}, ells)") def _init_gauss_beams(self): """ Computes the dictionary of beams for each frequency of self.experiments """ self.beams = {} - for iexp, exp in enumerate(self.experiments): - gauss_pars = self.gaussian_params[f"{exp}_s0"] + from itertools import product + for exp, spin in product(self.experiments, ["s0", "s2"]): + key = f"{exp}_{spin}" + gauss_pars = self.gaussian_params[key] FWHM0 = np.asarray(gauss_pars["FWHM_0"]) - #using the same freq array as the bandpass one - nu = np.asarray(self.bands[f"{exp}_s0"]['nu']) - nu0 = np.asarray(gauss_pars["nu_0"]) - alpha = np.asarray(gauss_pars["alpha"]) - # computing temperature beam for exp - self.beams[f"{exp}_s0"] = {"nu": nu, "beams": self.gauss_beams(FWHM0, nu, nu0, alpha, False)} - # doing the same for polarization - gauss_pars = self.gaussian_params[f"{exp}_s2"] - FWHM0 = np.asarray(gauss_pars["FWHM_0"]) - # nu pol should be the same as the T one, I'll comment it for now - #nu = np.asarray(self.bands[f"{exp}_s2"]['nu']) + nu = np.asarray(self.bands[key]['nu']) nu0 = np.asarray(gauss_pars["nu_0"]) alpha = np.asarray(gauss_pars["alpha"]) # checking nu is the same as the bandpass one - self.beams[f"{exp}_s2"] = {"nu": nu, "beams": self.gauss_beams(FWHM0, nu, nu0, alpha, True)} + self.beams[key] = {"nu": nu, "beams": self.gauss_beams(FWHM0, nu, nu0, alpha, pol=spin=="s2")} def gauss_beams(self, fwhm0, nu, nu0, alpha, pol): r""" @@ -810,7 +806,6 @@ def gauss_beams(self, fwhm0, nu, nu0, alpha, pol): :return: a :math:`b^{Gauss.}_{\ell}(\nu)` = ``array(freqs, lmax +2)`` with Gaussian beam profiles for each frequency in :math:`\nu` (from :math:`\ell = 0`) """ - from astropy import constants, units import healpy as hp fwhm = fwhm0 * (nu / nu0)**(-alpha/2.) diff --git a/mflike/mflike.py b/mflike/mflike.py index 0fb34e4..fcfa40c 100644 --- a/mflike/mflike.py +++ b/mflike/mflike.py @@ -410,10 +410,10 @@ def get_sacc_names(pol, exp_1, exp_2): self.beams = {} for name, tracer in s.tracers.items(): self.bands[name] = {"nu": tracer.nu, "bandpass": tracer.bandpass} - # trying to read beams, if present - if hasattr(tracer, "beam"): + # trying to read beams, if present, and check if it is empty + if hasattr(tracer, "beam") and bool(tracer.beam): self.beams[name] = {"nu": tracer.nu, "beams": tracer.beam} - + # Put lcuts in a format that is recognisable by CAMB. self.lcuts = {k.lower(): c for k, c in self.lcuts.items()} if "et" in self.lcuts: diff --git a/mflike/tests/test_mflike.py b/mflike/tests/test_mflike.py index e39c16f..ba3f680 100644 --- a/mflike/tests/test_mflike.py +++ b/mflike/tests/test_mflike.py @@ -364,7 +364,7 @@ def compute_FWHM(nu): # generating the dictionary needed for the bandpass shift case test_path = os.path.dirname(__file__) import subprocess - subprocess.run("python "+os.path.join(test_path, "../../mflike_utils/utils.py"), shell=True, check=True) + subprocess.run("python "+os.path.join(test_path, "../../scripts/generate_beams_w_bandpass_shifts.py"), shell=True, check=True) model.close() diff --git a/mflike_utils/utils.py b/scripts/generate_beams_w_bandpass_shifts.py similarity index 96% rename from mflike_utils/utils.py rename to scripts/generate_beams_w_bandpass_shifts.py index eafc1a4..a71fbc4 100644 --- a/mflike_utils/utils.py +++ b/scripts/generate_beams_w_bandpass_shifts.py @@ -1,5 +1,5 @@ r""" -Simple code to generate the bandpass shift dictionary needed in the presence of bandpass shifts different from 0. +Simple code to generate the beam dictionary needed in the presence of bandpass shifts different from 0. We compute simple gaussian beams for :math:`\nu_0 + \Delta \nu`, assuming a diffraction limited experiment. This is thought to be used in the absence of data coming from the planets beams measurements. """ From 922aebb8ee243c415e9a4e770935f848be9db26e Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 19 Sep 2024 14:04:54 +0100 Subject: [PATCH 35/43] condition to check if tracer.beam is either empty applying to both list and arrays --- mflike/mflike.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mflike/mflike.py b/mflike/mflike.py index fcfa40c..642f759 100644 --- a/mflike/mflike.py +++ b/mflike/mflike.py @@ -411,7 +411,7 @@ def get_sacc_names(pol, exp_1, exp_2): for name, tracer in s.tracers.items(): self.bands[name] = {"nu": tracer.nu, "bandpass": tracer.bandpass} # trying to read beams, if present, and check if it is empty - if hasattr(tracer, "beam") and bool(tracer.beam): + if hasattr(tracer, "beam") and np.size(tracer.beam) != 0: self.beams[name] = {"nu": tracer.nu, "beams": tracer.beam} # Put lcuts in a format that is recognisable by CAMB. From f06f356bc82aaa3364258981da380b8ff674977f Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 19 Sep 2024 15:04:53 +0100 Subject: [PATCH 36/43] switching to cobaya yaml loader --- mflike/foreground.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/mflike/foreground.py b/mflike/foreground.py index e499cee..ad3f3f1 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -734,14 +734,11 @@ def _bandpass_construction(self, _initialize=False, **params): ## that should be applied to any beam profile ########################################################################### def _read_yaml_file(self, file_path): - import yaml - + + from cobaya.yaml import yaml_load_file + filename = "%s.yaml" % file_path - if not os.path.exists("%s.yaml" % file_path): - raise ValueError("File " + filename + " does not exist!") - - with open(filename, "r") as f: - file = yaml.load(f, Loader=yaml.Loader) + file = yaml_load_file(file_name = filename) return file From 449fcfed02c5f0c5acff3168f43115ffa0e6b423 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 19 Sep 2024 15:19:14 +0100 Subject: [PATCH 37/43] simplifying computation of transmission --- mflike/foreground.py | 36 ++++++++++++++---------------------- 1 file changed, 14 insertions(+), 22 deletions(-) diff --git a/mflike/foreground.py b/mflike/foreground.py index ad3f3f1..060df93 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -658,15 +658,15 @@ def _bandpass_construction(self, _initialize=False, **params): blT, blP = self.return_beams(exp, nu_ghz, 0.) if "tt" in self.requested_cls or "te" in self.requested_cls: - tranb_normT = trapezoid(_cmb2bb(nub)[..., np.newaxis] * blT, nub, axis=0) - ratioT = _cmb2bb(nub)[..., np.newaxis] * blT / tranb_normT - self.bandint_freqs_T.append([nub, ratioT]) + bpT = _cmb2bb(nub)[..., np.newaxis] * blT + self.bandint_freqs_T.append([nub, bpT / trapezoid(bpT, nub, axis=0)]) + if "te" in self.requested_cls or "ee" in self.requested_cls: - tranb_normP = trapezoid(_cmb2bb(nub)[..., np.newaxis] * blP, nub, axis=0) - ratioP = _cmb2bb(nub)[..., np.newaxis] * blP / tranb_normP - self.bandint_freqs_P.append([nub, ratioP]) - + + bpP = _cmb2bb(nub)[..., np.newaxis] * blP + self.bandint_freqs_P.append([nub, bpP / trapezoid(bpP, nub, axis=0)]) + # in case we don't want to do band integration, e.g. when we have multifreq bandpass in sacc file if self.bandint_nsteps == 1: nub = fr + shift @@ -701,23 +701,15 @@ def _bandpass_construction(self, _initialize=False, **params): blT, blP = self.return_beams(exp, nu_ghz, 0.) if "tt" in self.requested_cls or "te" in self.requested_cls: - trans_normT = trapezoid( - bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blT, nub, axis=0 - ) - ratioT = ( - bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blT / trans_normT - ) - self.bandint_freqs_T.append([nub, ratioT]) + + bpT = bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blT + self.bandint_freqs_T.append([nub, bpT / trapezoid(bpT, nub, axis=0)]) if "te" in self.requested_cls or "ee" in self.requested_cls: - trans_normP = trapezoid( - bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blP, nub, axis=0 - ) - ratioP = ( - bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blP / trans_normP - ) - self.bandint_freqs_P.append([nub, ratioP]) - + + bpP = bp[..., np.newaxis] * _cmb2bb(nub)[..., np.newaxis] * blP + self.bandint_freqs_P.append([nub, bpP / trapezoid(bpP, nub, axis=0)]) + # fgspectra can't mix monofrequency with [nu, bp]. If one channel is mono-frequency then we # assume all of them and pass to fgspectra an array (not list!!) of frequencies if data_are_monofreq: From 785caccba74734420c593aafb39ec70952651a7b Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 19 Sep 2024 15:51:00 +0100 Subject: [PATCH 38/43] changing yaml file path convention + small fixes --- mflike/Foreground.yaml | 4 ++-- mflike/foreground.py | 22 ++++++---------------- mflike/tests/test_mflike.py | 2 +- 3 files changed, 9 insertions(+), 19 deletions(-) diff --git a/mflike/Foreground.yaml b/mflike/Foreground.yaml index cbe1848..06efd30 100644 --- a/mflike/Foreground.yaml +++ b/mflike/Foreground.yaml @@ -34,7 +34,7 @@ top_hat_band: # or be read from a file (either from external file with name "rootname" or from sacc) # - if Gaussian_beam = False/empty and beam_from_file = False/empty, it will be read from the sacc file (currently not working) # - if Gaussian_beam = False/empty and beam_from_file is specified, it will be read from this file -# the file name has to be its absolute path without the yaml extension +# the file name has to be its absolute path, with the yaml extension # it has to be a yaml with keys = experiments and items = array((freqs, ells)) # i.e. numpy arrays of beam profiles for each frequency in the passband of that array # - If we want to compute Gaussian beams, fill the Gaussian_beam entry with dictionaries @@ -42,7 +42,7 @@ top_hat_band: # - If bandpass shifts are != 0 and you want to propagate them to the beams, you have to fill # the Bandpass_shifted_beams key with the name of the file containing the dictionary # with beam profiles for different values of Delta nu. As before, the file should be a yaml, -# and you should provide its absolute path without the ".yaml" extension. +# and you should provide its absolute path with the ".yaml" extension. # The dictionary should contain a key for each experiment/array, and for each of these keys # there should be a "nu_0", "alpha" and "beams" keys. The "beams" item would be a # dictionary {"nu_0 + Delta nu": b_ell, "nu_0 + 2Delta nu": b'_ell,...} diff --git a/mflike/foreground.py b/mflike/foreground.py index 060df93..19af9b5 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -71,7 +71,7 @@ * reading the beams from the sacc file (``Gaussian_beam: False/null``, ``beam_from_file: False/null``). The beams have to be stored in the ``sacc.tracers[exp].beam`` tracer (this is not working so far, since the sacc beam tracer doesn't like an array(freq, ell)) - * reading the beams from an external yaml file (``Gaussian_beam: False/null``, ``beam_from_file: filename``). ``filename`` has to be the absolute path for the file, without the ``.yaml`` extension, + * reading the beams from an external yaml file (``Gaussian_beam: False/null``, ``beam_from_file: filename``). ``filename`` has to be the absolute path for the file, with the ``.yaml/.yml`` extension, which is automatically added by the code. The yaml file has to be a dictionary ``{"{exp}_s0": {"nu": nu, "beams": array(freqs, ells+2)}, "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}`` * computing the beams as Gaussian beams (``Gaussian_beam: dict``, ``beam_from_file: ...``). When @@ -142,7 +142,7 @@ alpha: ... ... -``bandpass_shifted_beams`` has to be an absolute path, without the ``.yaml`` extension, which is added by the code. +``bandpass_shifted_beams`` has to be an absolute path, with the ``.yaml/.yml`` extension, which is added by the code. It is important the keys of ``beam_profile["Bandpass_shifted_beams"]["{exp}_s0/2"]["beams"]`` are strings of floats representing the value of :math:`\Delta \nu` (if they are strings of int the code to read the associated beams would not work). """ @@ -151,10 +151,10 @@ import numpy as np from cobaya.log import LoggedError from cobaya.theory import Theory -from cobaya.yaml import yaml_load +from cobaya.yaml import yaml_load, yaml_load_file from cobaya.typing import empty_dict -from typing import Optional from scipy import constants +from itertools import product try: from numpy import trapezoid @@ -533,7 +533,7 @@ def init_bandpowers(self): self.bandsh_beams_path = self.beam_profile.get("Bandpass_shifted_beams") if self.bandsh_beams_path: - self.bandpass_shifted_beams = self._read_yaml_file(self.bandsh_beams_path) + self.bandpass_shifted_beams = yaml_load_file(file_name = self.bandsh_beams_path) self._bandint_shift_params = [f"bandint_shift_{f}" for f in self.experiments] # default bandpass when shift is 0 @@ -725,14 +725,6 @@ def _bandpass_construction(self, _initialize=False, **params): ## the correction expected for a Gaussian beam in case of bandpass shift ## that should be applied to any beam profile ########################################################################### - def _read_yaml_file(self, file_path): - - from cobaya.yaml import yaml_load_file - - filename = "%s.yaml" % file_path - file = yaml_load_file(file_name = filename) - - return file def _init_beam_from_file(self): """ @@ -747,10 +739,9 @@ def _init_beam_from_file(self): if not bool(self.beams): raise ValueError("Beams not stored in sacc files!") else: - self.beams = self._read_yaml_file(self.beam_file) + self.beams = yaml_load_file(file_name = self.beam_file) #checking that the freq array is compatible with the bandpass one - from itertools import product for exp, spin in product(self.experiments, ["s0", "s2"]): key = f"{exp}_{spin}" # checking nu is the same as the bandpass one @@ -767,7 +758,6 @@ def _init_gauss_beams(self): Computes the dictionary of beams for each frequency of self.experiments """ self.beams = {} - from itertools import product for exp, spin in product(self.experiments, ["s0", "s2"]): key = f"{exp}_{spin}" gauss_pars = self.gaussian_params[key] diff --git a/mflike/tests/test_mflike.py b/mflike/tests/test_mflike.py index ba3f680..f21dad1 100644 --- a/mflike/tests/test_mflike.py +++ b/mflike/tests/test_mflike.py @@ -391,7 +391,7 @@ def compute_FWHM(nu): "mflike.BandpowerForeground":{ "beam_profile": {"Gaussian_beam": beam_params, "Bandpass_shifted_beams": packages_path + - "/data/MFLike/v0.8/LAT_beam_bandshift"}, + "/data/MFLike/v0.8/LAT_beam_bandshift.yaml"}, }, }, "params": cosmo_params | params, From c63e0d9954e506191b1ceb2d7bbe8de4c5af23d5 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 19 Sep 2024 15:54:20 +0100 Subject: [PATCH 39/43] small fix --- mflike/foreground.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mflike/foreground.py b/mflike/foreground.py index 19af9b5..9e02aea 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -736,7 +736,7 @@ def _init_beam_from_file(self): if not self.beam_file: # option to read beam from sacc - if not bool(self.beams): + if not self.beams: raise ValueError("Beams not stored in sacc files!") else: self.beams = yaml_load_file(file_name = self.beam_file) From a9fff525191bc39b07678e67e8284ee040e2864e Mon Sep 17 00:00:00 2001 From: sgiardie Date: Fri, 20 Sep 2024 10:59:43 +0100 Subject: [PATCH 40/43] removing the option to compute Gaussian beams within the likelihood --- mflike/Foreground.yaml | 26 +---- mflike/foreground.py | 116 ++++---------------- mflike/tests/test_mflike.py | 36 ++---- scripts/generate_beams_w_bandpass_shifts.py | 112 ++++++++++++++++--- 4 files changed, 133 insertions(+), 157 deletions(-) diff --git a/mflike/Foreground.yaml b/mflike/Foreground.yaml index 06efd30..ffbf656 100644 --- a/mflike/Foreground.yaml +++ b/mflike/Foreground.yaml @@ -30,15 +30,12 @@ top_hat_band: # bandwidth: 0 -# specify if the beam profile has to be computed as a Gaussian beam -# or be read from a file (either from external file with name "rootname" or from sacc) -# - if Gaussian_beam = False/empty and beam_from_file = False/empty, it will be read from the sacc file (currently not working) -# - if Gaussian_beam = False/empty and beam_from_file is specified, it will be read from this file +# specify if the beam profile has to be from an external file or from sacc +# - if beam_from_file: "filename", the code will read the beams from this external file # the file name has to be its absolute path, with the yaml extension # it has to be a yaml with keys = experiments and items = array((freqs, ells)) # i.e. numpy arrays of beam profiles for each frequency in the passband of that array -# - If we want to compute Gaussian beams, fill the Gaussian_beam entry with dictionaries -# containing the parametrization for FWHM for each experiment/array in T and pol +# if beam_from_file: null, the code will read the beams from the sacc file # - If bandpass shifts are != 0 and you want to propagate them to the beams, you have to fill # the Bandpass_shifted_beams key with the name of the file containing the dictionary # with beam profiles for different values of Delta nu. As before, the file should be a yaml, @@ -47,23 +44,10 @@ top_hat_band: # there should be a "nu_0", "alpha" and "beams" keys. The "beams" item would be a # dictionary {"nu_0 + Delta nu": b_ell, "nu_0 + 2Delta nu": b'_ell,...} # default is the beam_profile to be a null dict and chromatic beam not -# taken into account +# taken into account. To include this effect and read beams from sacc, just use "beam_profile: // beam_from_file: null". beam_profile: -# Gaussian has to be either empty or filled with params needed for each experiment -# Gaussian_beam: -# LAT_93_s0: -# FWHM_0: ... -# nu_0: ... -# alpha: ... -# LAT_93_s2: -# FWHM_0: ... -# nu_0: ... -# alpha: ... -# LAT_145_s0: -# ... -# ... -# Bandpass_shifted_beams: "filename"/null # beam_from_file: "filename"/null +# Bandpass_shifted_beams: "filename"/null normalisation: diff --git a/mflike/foreground.py b/mflike/foreground.py index 9e02aea..1a45b58 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -57,54 +57,35 @@ nsteps: 1 bandwidth: 0 -If we want to consider the beam chromaticity effect, we have several options on how to compute/read the beam profiles. Notice that we need arrays(freqs, ells+2) (computed from :math:`\ell = 0`), since we want a beam window function for each freq in the bandpasses. We should use this block under ``mflike.BandpowerForeground``: +If we don't want to include the beam chromaticity effect, just leave the ``beam_profile`` key empty: + +.. code-block:: yaml + + theory: + mflike.BandpowerForeground: + beam_profile: + +If we want to consider it, we have several options on how to compute/read the beam profiles. Notice that we need arrays(freqs, ells+2) (computed from :math:`\ell = 0`), since we want a beam window function for each freq in the bandpasses. We should use this block under ``mflike.BandpowerForeground``: .. code-block:: yaml theory: mflike.BandpowerForeground: beam_profile: - Gaussian_beam: dict/False/null beam_from_file: filename/False/null -There are several options: - * reading the beams from the sacc file (``Gaussian_beam: False/null``, ``beam_from_file: False/null``). +There are two options: + * reading the beams from the sacc file (``beam_from_file: False/null``). The beams have to be stored in the ``sacc.tracers[exp].beam`` tracer - (this is not working so far, since the sacc beam tracer doesn't like an array(freq, ell)) - * reading the beams from an external yaml file (``Gaussian_beam: False/null``, ``beam_from_file: filename``). ``filename`` has to be the absolute path for the file, with the ``.yaml/.yml`` extension, - which is automatically added by the code. The yaml file has to be a dictionary - ``{"{exp}_s0": {"nu": nu, "beams": array(freqs, ells+2)}, "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}`` - * computing the beams as Gaussian beams (``Gaussian_beam: dict``, ``beam_from_file: ...``). When - ``Gaussian_beam`` is not empty, the beam is automatically computed within the code. Both T and - polarization Gaussian beams are computed through ``healpy.gauss_beam``. We need to pass a - dictionary with the ``FWHM_0``, ``nu_0``, ``alpha`` parameters for each array/experiment (both in T and pol), - in order to parametrize the Gaussian FWHM as :math:`FWHM(\nu) = FWHM(\nu_0) \left( \frac{\nu}{\nu_0} \right)^{-\alpha/2}`: - -.. code-block:: yaml + * reading the beams from an external yaml file (``beam_from_file: filename``). ``filename`` has to be the absolute path for the file, with the ``.yaml/.yml`` extension. The yaml file has to be a dictionary ``{"{exp}_s0": {"nu": nu, "beams": array(freqs, ells+2)}, "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}`` - beam_profile: - Gaussian_beam: - LAT_93_s0: - FWHM_0: ... - nu_0: ... - alpha: ... - LAT_93_s2: - FWHM_0: ... - nu_0: ... - alpha: ... - LAT_145_s0: - FWHM_0: ... - nu_0: ... - alpha: ... - ... - beam_from_file: null Once computed/read, the beam profiles are saved in .. code-block:: python self.beams = {"{exp}_s0": {"nu": nu, "beams": array(freqs, ells+2)}, "{exp}_s2": {"nu": nu, "beams": array(freqs, ells+2)},...}. -The beams are appropriately normalized, then we select the bandpowers used in the rest of the code. +The beams are appropriately normalized, then we select the :math:`\ell` range used in the rest of the code. In case of bandpass shifts :math:`\Delta \nu \neq 0`, you can decide whether to propagate the bandpass shift effect to :math:`b_{\ell}(\nu)` or not. If you want to leave :math:`b_{\ell}(\nu)` unchanged even if :math:`\Delta \nu \neq 0` (assuming this modification is a second order effect), you just need to leave the ``beam_profile`` block as it is, i.e. ``Bandpass_shifted_beams: null``. @@ -117,7 +98,6 @@ beam_profile: Bandpass_shifted_beams: bandpass_shifted_beams - Gaussian_beam: dict/False/null beam_from_file: filename/False/null where the ``bandpass_shifted_beams.yaml`` file is structured as: @@ -516,21 +496,20 @@ def init_bandpowers(self): self.log, "One band has width = 0, set a positive width and run again" ) + # initialize beam params after mflike initialization if not self._initialized: self.use_beam_profile = False else: self.use_beam_profile = bool(self.beam_profile) if self.use_beam_profile: - if not self.beam_profile.get("Gaussian_beam"): - self.beam_file = self.beam_profile.get("beam_from_file") - self._init_beam_from_file() - else: - self.gaussian_params = self.beam_profile.get("Gaussian_beam") - self._init_gauss_beams() + # reading the beams either from an external file or + # from the sacc file + self.beam_file = self.beam_profile.get("beam_from_file") + self._init_beam_from_file() + # reading the possible dictionary with beam profiles associated to bandpass shifts # this has to be present if we want to propagate bandpass shifts to the chromatic beams # otherwise they are left unchanged - self.bandsh_beams_path = self.beam_profile.get("Bandpass_shifted_beams") if self.bandsh_beams_path: self.bandpass_shifted_beams = yaml_load_file(file_name = self.bandsh_beams_path) @@ -583,7 +562,7 @@ def _get_foreground_model_arrays(self, fg_params, ell=None): # This factor is already included in the _cmb2bb function def _bandpass_construction(self, _initialize=False, **params): r""" - Builds the bandpass transmission with or without beam. + Builds the bandpass transmission with or without beam. When chromatic beam is not considered, we compute: :math:`\frac{\frac{\partial B_{\nu+\Delta \nu}}{\partial T} \tau(\nu+\Delta \nu)}{\int d\nu @@ -720,10 +699,9 @@ def _bandpass_construction(self, _initialize=False, **params): self._initialized = True ########################################################################### - ## This part deals with beam functions, i.e. reading beam from file or - ## computing it as a Gaussian beam. We also have a function to compute - ## the correction expected for a Gaussian beam in case of bandpass shift - ## that should be applied to any beam profile + ## This part deals with beam functions, i.e. reading beam from file. + ## We also have a function to compute + ## the correction to the beams in case of bandpass shifts ########################################################################### def _init_beam_from_file(self): @@ -752,53 +730,7 @@ def _init_beam_from_file(self): shape_b = self.beams[key]["beams"].shape[0] shape_n = self.bands[key]['nu'].size raise LoggedError(self.log, f"beam {key} has a wrong shape! It is shape ({shape_b}, ells), but shoule be ({shape_n}, ells)") - - def _init_gauss_beams(self): - """ - Computes the dictionary of beams for each frequency of self.experiments - """ - self.beams = {} - for exp, spin in product(self.experiments, ["s0", "s2"]): - key = f"{exp}_{spin}" - gauss_pars = self.gaussian_params[key] - FWHM0 = np.asarray(gauss_pars["FWHM_0"]) - nu = np.asarray(self.bands[key]['nu']) - nu0 = np.asarray(gauss_pars["nu_0"]) - alpha = np.asarray(gauss_pars["alpha"]) - # checking nu is the same as the bandpass one - self.beams[key] = {"nu": nu, "beams": self.gauss_beams(FWHM0, nu, nu0, alpha, pol=spin=="s2")} - - def gauss_beams(self, fwhm0, nu, nu0, alpha, pol): - r""" - Computes the Gaussian beam (either for T or pol) for each frequency of a - frequency array according to eqs. 54/55 of arXiv:astro-ph/0008228. We assume a more general - scaling for the FWHM: :math:`FWHM(\nu) = FWHM(\nu_0) \left( \frac{\nu}{\nu_0} \right)^{-\alpha}`. - - :param fwhm0: the FWHM for the pivot frequency - :param nu: the frequency array in GHz - :param nu0: the pivot frequency in GHz - :param alpha: the exponent of the frequency scaling - :math:`\left( \frac{\nu}{\nu_0} \right)^{-\alpha/2}` - :param pol: (Bool) False to compute temperature Gaussian beam, - True for the polarization one - - :return: a :math:`b^{Gauss.}_{\ell}(\nu)` = ``array(freqs, lmax +2)`` with Gaussian beam - profiles for each frequency in :math:`\nu` (from :math:`\ell = 0`) - """ - import healpy as hp - - fwhm = fwhm0 * (nu / nu0)**(-alpha/2.) - bls = np.empty((len(nu), self.ells[-1] + 1)) - for ifw, fw in enumerate(fwhm): - # saving the beam from ell = 2 to ell max of self.ells - if not pol: - bls[ifw, :] = hp.gauss_beam(fw, lmax=self.ells[-1]) - else: - # selecting the polarized gaussian beam - bls[ifw, :] = hp.gauss_beam(fw, lmax=self.ells[-1], pol=True)[:, 1] - - return bls - + def beam_interpolation(self, b_ell_template, f_ell, ells, freqs, freq_ref, alpha): r''' Computing :math:`b_{\ell}(\nu)` from monochromatic beam :math:`b_{\ell}` using the diff --git a/mflike/tests/test_mflike.py b/mflike/tests/test_mflike.py index f21dad1..0a6b08a 100644 --- a/mflike/tests/test_mflike.py +++ b/mflike/tests/test_mflike.py @@ -319,24 +319,12 @@ def _get_model(nsteps, bandwidth): def test_Gaussian_chromatic_beams(self): nuis_params = common_nuis_params | TT_nuis_params | TE_nuis_params | EE_nuis_params - - def compute_FWHM(nu): - from astropy import constants, units - - mirror_size = 6 * units.m - wavelenght = constants.c / (nu * 1e9 / units.s) - fwhm = 1.22 * wavelenght / mirror_size - return fwhm - - beam_params = {} - for f in [93, 145, 225]: - beam_params[f"LAT_{f}_s0"] = { - "FWHM_0": compute_FWHM(f), - "nu_0": f, - "alpha": 2 - } - beam_params[f"LAT_{f}_s2"] = beam_params[f"LAT_{f}_s0"] - + + # generating the data products needed + test_path = os.path.dirname(__file__) + import subprocess + subprocess.run("python "+os.path.join(test_path, "../../scripts/generate_beams_w_bandpass_shifts.py"), shell=True, check=True) + info = { "likelihood": { "mflike.TTTEEE": { @@ -346,7 +334,8 @@ def compute_FWHM(nu): }, "theory": {"camb": {"extra_args": {"lens_potential_accuracy": 1}}, "mflike.BandpowerForeground":{ - "beam_profile": {"Gaussian_beam": beam_params}, + "beam_profile": {"beam_from_file": packages_path + + "/data/MFLike/v0.8/LAT_gauss_beams.yaml"}, }}, "params": cosmo_params | nuis_params, "packages_path": packages_path, @@ -360,12 +349,6 @@ def compute_FWHM(nu): self.assertAlmostEqual(chi2, chi2s_beam["tt-te-et-ee"], 2) - # testing the bandpass shift case - # generating the dictionary needed for the bandpass shift case - test_path = os.path.dirname(__file__) - import subprocess - subprocess.run("python "+os.path.join(test_path, "../../scripts/generate_beams_w_bandpass_shifts.py"), shell=True, check=True) - model.close() from copy import deepcopy @@ -389,7 +372,8 @@ def compute_FWHM(nu): }, "theory": {"camb": {"extra_args": {"lens_potential_accuracy": 1}}, "mflike.BandpowerForeground":{ - "beam_profile": {"Gaussian_beam": beam_params, + "beam_profile": {"beam_from_file": packages_path + + "/data/MFLike/v0.8/LAT_gauss_beams.yaml", "Bandpass_shifted_beams": packages_path + "/data/MFLike/v0.8/LAT_beam_bandshift.yaml"}, }, diff --git a/scripts/generate_beams_w_bandpass_shifts.py b/scripts/generate_beams_w_bandpass_shifts.py index a71fbc4..ff99cfc 100644 --- a/scripts/generate_beams_w_bandpass_shifts.py +++ b/scripts/generate_beams_w_bandpass_shifts.py @@ -1,6 +1,6 @@ r""" -Simple code to generate the beam dictionary needed in the presence of bandpass shifts different from 0. -We compute simple gaussian beams for :math:`\nu_0 + \Delta \nu`, assuming a diffraction limited experiment. +Simple code to generate a yaml file with Gaussian beams and the beam dictionary needed in the presence of bandpass shifts different from 0. Both are needed for one of the tests. +We compute simple gaussian beams for :math:`\nu` and :math:`\nu_0 + \Delta \nu`, assuming a diffraction limited experiment. This is thought to be used in the absence of data coming from the planets beams measurements. """ @@ -10,6 +10,8 @@ import tempfile import yaml from cobaya.install import install +from cobaya.model import get_model +from itertools import product packages_path = os.environ.get("COBAYA_PACKAGES_PATH") or os.path.join( tempfile.gettempdir(), "LAT_packages" @@ -19,6 +21,74 @@ install({"likelihood": {"mflike.TTTEEE": None}}, path=packages_path) +cosmo_params = { + "cosmomc_theta": 0.0104092, + "As": 2.0989031673191437e-09, + "ombh2": 0.02237, + "omch2": 0.1200, + "ns": 0.9649, + "Alens": 1.0, + "tau": 0.0544, +} + +nuis_params = { + "T_effd": 19.6, + "beta_d": 1.5, + "beta_s": -2.5, + "alpha_s": 1, + "bandint_shift_LAT_93": 0, + "bandint_shift_LAT_145": 0, + "bandint_shift_LAT_225": 0, + "cal_LAT_93": 1, + "cal_LAT_145": 1, + "cal_LAT_225": 1, + "calG_all": 1, + "alpha_LAT_93": 0, + "alpha_LAT_145": 0, + "alpha_LAT_225": 0, + "a_tSZ": 3.30, + "a_kSZ": 1.60, + "a_p": 6.90, + "beta_p": 2.20, + "a_c": 4.90, + "beta_c": 2.20, + "a_s": 3.10, + "T_d": 9.60, + "a_gtt": 2.80, + "xi": 0.10, + "alpha_dT": -0.6, + "alpha_p": 1, + "alpha_tSZ": 0., + "calT_LAT_93": 1, + "calT_LAT_145": 1, + "calT_LAT_225": 1, + "a_gte": 0.10, + "a_pste": 0, + "alpha_dE": -0.4, + "a_gee": 0.10, + "a_psee": 0, + "alpha_dE": -0.4, + "calE_LAT_93": 1, + "calE_LAT_145": 1, + "calE_LAT_225": 1, +} + +info = { + "likelihood": { + "mflike.TTTEEE": { + "input_file": "LAT_simu_sacc_00000.fits", + "cov_Bbl_file": "data_sacc_w_covar_and_Bbl.fits", + }, + }, + "theory": {"camb": {"extra_args": {"lens_potential_accuracy": 1}}, + "mflike.BandpowerForeground": None}, + "params": cosmo_params | nuis_params, + "packages_path": packages_path, +} + +model = get_model(info) +my_mflike = model.likelihood["mflike.TTTEEE"] + def compute_FWHM(nu): """ Simple function to compute FWHM for the LAT assuming a diffraction limited experiment. @@ -65,28 +135,34 @@ def gauss_beams(fwhm0, nu, nu0, alpha, lmax, pol): return bls +#first generating Gaussian beams for the frequencies in our arrays +beam_dict = {} +#generating the dictionary with (gaussian) beams for each nu+dnu beam_dnu_dict = {} -# express delta nu as floats for the correct behavior of the code that will read this dictionary dnu = np.arange(-20, 21, dtype = float) -for f in [93, 145, 225]: - fwhm = compute_FWHM(f) - gbeamT = gauss_beams(fwhm, f+dnu, f, 2, 10000, False) - gbeamP = gauss_beams(fwhm, f+dnu, f, 2, 10000, True) - beam_dnu_dict[f"LAT_{f}_s0"] = { - "beams": {f"{dn}": gbeamT[idn] for idn, dn in enumerate(dnu)}, - "nu_0": f, - "alpha": 2 - } - beam_dnu_dict[f"LAT_{f}_s2"] = { - "beams": {f"{dn}": gbeamP[idn] for idn, dn in enumerate(dnu)}, - "nu_0": f, + +for exp, spin in product(my_mflike.experiments, ["s0", "s2"]): + nu0 = int(exp[4:]) + fwhm = compute_FWHM(nu0) + key = f"{exp}_{spin}" + nu = my_mflike.bands[key]['nu'] + + beam_dict[key] = {"nu": nu, "beams": gauss_beams(fwhm, nu, nu0, 2, 10000, pol=spin=="s2")} + + + gbeambsh = gauss_beams(fwhm, nu0+dnu, nu0, 2, 10000, pol=spin=="s2") + beam_dnu_dict[key] = { + "beams": {f"{dn}": gbeambsh[idn] for idn, dn in enumerate(dnu)}, + "nu_0": nu0, "alpha": 2 } - # saving the yaml file +with open(data_path + '/LAT_gauss_beams.yaml', 'w') as file: + yaml.dump(beam_dict, file, default_flow_style=False) + print("saving "+data_path + '/LAT_gauss_beams.yaml') + + with open(data_path + '/LAT_beam_bandshift.yaml', 'w') as file: yaml.dump(beam_dnu_dict, file, default_flow_style=False) print("saving "+data_path + '/LAT_beam_bandshift.yaml') - - From f183a8e7d619123dc003343a7e3b17c98c33e044 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Mon, 23 Sep 2024 13:13:07 +0200 Subject: [PATCH 41/43] transposing beam from sacc + small fix --- mflike/foreground.py | 3 ++- mflike/mflike.py | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/mflike/foreground.py b/mflike/foreground.py index 1a45b58..1f4d773 100644 --- a/mflike/foreground.py +++ b/mflike/foreground.py @@ -817,7 +817,8 @@ def return_beams(self, exp, nu, dnu): # normalizing the beam profile such that it has a max at 1 at ell = 0 blT /= blT[:, 0][..., np.newaxis] - return blT[:,2:self.ells[-1] + 1], blP[:,2:self.ells[-1] + 1] + # selecting the ell range from the data, since bl start from ell = 0 + return blT[:, self.ells], blP[:, self.ells] class TTForeground(BandpowerForeground): diff --git a/mflike/mflike.py b/mflike/mflike.py index 642f759..0bb1bc9 100644 --- a/mflike/mflike.py +++ b/mflike/mflike.py @@ -412,7 +412,8 @@ def get_sacc_names(pol, exp_1, exp_2): self.bands[name] = {"nu": tracer.nu, "bandpass": tracer.bandpass} # trying to read beams, if present, and check if it is empty if hasattr(tracer, "beam") and np.size(tracer.beam) != 0: - self.beams[name] = {"nu": tracer.nu, "beams": tracer.beam} + # transposing the beam since it is (nells, nfreqs) in sacc + self.beams[name] = {"nu": tracer.nu, "beams": tracer.beam.T } # Put lcuts in a format that is recognisable by CAMB. self.lcuts = {k.lower(): c for k, c in self.lcuts.items()} From 89b469eaae5d54b09f0adaef22db823c632e1a93 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Tue, 24 Sep 2024 16:33:32 +0200 Subject: [PATCH 42/43] adding python 3.12 --- .github/workflows/testing.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index b60e5dd..0ca8c4a 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -12,7 +12,7 @@ jobs: strategy: matrix: os: [ubuntu-latest, macos-latest] - python-version: ["3.9", "3.10", "3.11"] + python-version: ["3.9", "3.10", "3.11", "3.12"] steps: - uses: actions/checkout@v4 From 8867e5e24f5055522e91d1d09eab59ccc5073ad5 Mon Sep 17 00:00:00 2001 From: sgiardie Date: Thu, 26 Sep 2024 17:18:13 +0200 Subject: [PATCH 43/43] updating fgspectra requirement --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index ad42ee7..f420a0a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -24,7 +24,7 @@ classifiers = [ ] requires-python = ">=3.9.0" dependencies = [ - "fgspectra @ git+https://github.com/simonsobs/fgspectra@dev_beam", + "fgspectra >= 1.3.0", "syslibrary>=0.2.0", "cobaya>=3.5.4", "sacc>=0.9.0",