From b085ee1bbd716fdc22f9f00648a28a49746551d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 9 Jul 2025 14:15:31 -0700 Subject: [PATCH 01/59] added 2d mean continuum --- .../mean_continuum_2d_expected_flux.py | 240 ++++++++++++++++++ .../delta_extraction/expected_fluxes/utils.py | 9 +- 2 files changed, 247 insertions(+), 2 deletions(-) create mode 100644 py/picca/delta_extraction/expected_fluxes/mean_continuum_2d_expected_flux.py diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_2d_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_2d_expected_flux.py new file mode 100644 index 000000000..bdb4d32f1 --- /dev/null +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_2d_expected_flux.py @@ -0,0 +1,240 @@ +"""This module defines the class Dr16ExpectedFlux""" +import logging + +import numpy as np +from scipy.interpolate import RegularGridInterpolator + +from picca.delta_extraction.errors import ExpectedFluxError +from picca.delta_extraction.astronomical_objects.forest import Forest +from picca.delta_extraction.expected_fluxes.dr16_expected_flux import Dr16ExpectedFlux, defaults, accepted_options +from picca.delta_extraction.utils import (update_accepted_options, + update_default_options, + ABSORBER_IGM) + +accepted_options = update_accepted_options(accepted_options, [ + "limit z", "num z bins" +]) + +defaults = update_default_options( + defaults, { + "limit z": (1.94, 4.5), + "num z bins": 10, + }) + + +class MeanContinuum2dExpectedFlux(Dr16ExpectedFlux): + """Class to the expected flux as done in the DR16 SDSS analysys + The mean expected flux is calculated iteratively as explained in + du Mas des Bourboux et al. (2020) except that the mean continuum is + computed in 2D (wavelength and redshift) instead of 1D. + + Methods + ------- + (see Dr16ExpectedFlux in py/picca/delta_extraction/expected_fluxes/dr16_expected_flux.py) + + Attributes + ---------- + (see Dr16ExpectedFlux in py/picca/delta_extraction/expected_fluxes/dr16_expected_flux.py) + + get_mean_cont: scipy.interpolate.RegularGridInterpolator + Interpolation function to compute the unabsorbed mean quasar continua. + + get_mean_cont_weight: scipy.interpolate.RegularGridInterpolator + Interpolation function to compute the weights associated with the unabsorbed + mean quasar continua. + + lambda_abs_igm: float + Wavelength in Angstroms at which the IGM absorption is computed. + + limit_z: tuple of float + Minimum and maximum redshift limits for the analysis. + + num_z_bins: int + Number of redshift bins to use for the analysis. + + z_bins: np.ndarray + Bins in redshift used to compute the mean continuum. + + z_centers: np.ndarray + Centers of the redshift bins used to compute the mean continuum. + This is used to interpolate the mean continuum and its weights. + """ + + def __init__(self, config): + """Initialize class instance. + + Arguments + --------- + config: configparser.SectionProxy + Parsed options to initialize class + + Raise + ----- + ExpectedFluxError if Forest class variables are not set + """ + self.logger = logging.getLogger(__name__) + super().__init__(config) + + # load variables from config + self.limit_z = None + self.num_z_bins = None + self.z_bins = None + self.z_centers = None + self.__parse_config(config) + + def __parse_config(self, config): + """Parse the configuration options + + Arguments + --------- + config: configparser.SectionProxy + Parsed options to initialize class + + Raises + ------ + ExpectedFluxError if variables are not valid + """ + super().__parse_config(config) + + limit_z_string = config.get("limit z") + if limit_z_string is None: + raise ExpectedFluxError( + "Missing argument 'limit z' required by MeanContinuum2dExpectedFlux") + limit_z = limit_z_string.split(",") + if limit_z[0].startswith("(") or limit_z[0].startswith("["): + z_min = float(limit_z[0][1:]) + else: + z_min = float(limit_z[0]) + if limit_z[1].endswith(")") or limit_z[1].endswith("]"): + z_max = float(limit_z[1][:-1]) + else: + z_max = float(limit_z[1]) + self.limit_z = (z_min, z_max) + + num_z_bins = config.getint("num z bins") + if num_z_bins is None or num_z_bins < 1: + raise ExpectedFluxError( + "Missing or invalid argument 'num z bins' required by MeanContinuum2dExpectedFlux") + self.num_z_bins = num_z_bins + + self.z_bins = np.linspace(self.limit_z[0], self.limit_z[1], + self.num_z_bins + 1) + self.z_centers = (self.z_bins[:-1] + self.z_bins[1:]) / 2 + + def _initialize_mean_continuum_arrays(self): + """Initialize mean continuum arrays + The initialized arrays are: + - self.get_mean_cont + - self.get_mean_cont_weight + """ + # initialize the mean quasar continuum + # TODO: maybe we can drop this and compute first the mean quasar + # continuum on compute_expected_flux + mean_cont = np.ones( + (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) + mean_cont_weight = np.zeros( + (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) + + self.get_mean_cont = RegularGridInterpolator( + (self.z_centers, Forest.log_lambda_rest_frame_grid), mean_cont, bounds_error=False, fill_value=0.0 + ) + self.get_mean_cont_weight = RegularGridInterpolator( + (self.z_centers, Forest.log_lambda_rest_frame_grid), mean_cont_weight, bounds_error=False, fill_value=0.0 + ) + + def compute_mean_cont(self, forests, which_cont=lambda forest: forest.continuum): + """Compute the mean quasar continuum over the whole sample. + Then updates the value of self.get_mean_cont to contain it + + Arguments + --------- + forests: List of Forest + A list of Forest from which to compute the deltas. + + which_cont: Function or lambda + Should return what to use as continuum given a forest + """ + + mean_cont = np.zeros( + (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) + mean_cont_weight = np.zeros( + (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) + + + # first compute in bins. C=Cont_old*spectrum_dependent_fitting_fct + # (and Cont_old is constant for all spectra in a bin), thus we actually + # compute + # 1/Cont_old * + for forest in forests: + if forest.bad_continuum_reason is not None: + continue + # Compute redshifts, use quasar redshift + forest_z = forest.z * np.ones_like(forest.log_lambda) + + # Bin indices for each pixel + lam_bins = Forest.find_bins( + forest.log_lambda - np.log10(1 + forest.z), + Forest.log_lambda_rest_frame_grid) + z_bins_idx = np.digitize(forest_z, self.z_bins) - 1 + + + weights = self.compute_forest_weights(forest, forest.continuum) + forest_continuum = which_cont(forest) + + # Accumulate in 2D + for lam_bin, zbin, continuum, weight in zip(lam_bins, z_bins_idx, forest_continuum, weights): + if 0 <= lam_bin < Forest.log_lambda_rest_frame_grid.size and 0 <= zbin < self.z_bins.size - 1: + mean_cont[zbin, lam_bin] += continuum * weight + mean_cont_weight[zbin, lam_bin] += weight + + # Normalize + w = mean_cont_weight > 0 + mean_cont[w] /= mean_cont_weight[w] + mean_cont /= mean_cont[w].mean() + + + # 2D interpolator for mean continuum + self.get_mean_cont = RegularGridInterpolator( + (self.z_centers, Forest.log_lambda_rest_frame_grid), mean_cont, bounds_error=False, fill_value=0.0 + ) + # 2D interpolator for weights + self.get_mean_cont_weight = RegularGridInterpolator( + (self.z_centers, Forest.log_lambda_rest_frame_grid), mean_cont_weight, bounds_error=False, fill_value=0.0 + ) + + def hdu_cont(self, results): + """Add to the results file an HDU with the continuum information + + Arguments + --------- + results: fitsio.FITS + The open fits file + """ + results.write([ + Forest.log_lambda_rest_frame_grid, + self.get_mean_cont(Forest.log_lambda_rest_frame_grid), + self.get_mean_cont_weight(Forest.log_lambda_rest_frame_grid), + ], + names=['LOGLAM_REST', 'MEAN_CONT', 'WEIGHT'], + units=['log(Angstrom)', Forest.flux_units, ''], + extname='CONT') + results["CONT"].write_comment("Mean quasar continuum") + results["CONT"].write_checksum() + + # Create meshgrid for evaluation + z_meshgrid, log_lam_mesh_grid = np.meshgrid(self.z_centers, Forest.log_lambda_rest_frame_grid, indexing='ij') + points = np.stack([z_meshgrid.ravel(), log_lam_mesh_grid.ravel()], axis=-1) + mean_cont_2d = self.get_mean_cont(points).reshape(z_meshgrid.shape) + mean_cont_weight_2d = self.get_mean_cont_weight(points).reshape(z_meshgrid.shape) + + results.write([ + z_meshgrid, + log_lam_mesh_grid, + mean_cont_2d, + mean_cont_weight_2d, + ], + names=['Z_CENTERS', 'LOGLAM_REST', 'MEAN_CONT', 'WEIGHT'], + units=['', 'log(Angstrom)', Forest.flux_units, ''], + extname='CONT') + results["CONT"].write_comment("2D mean quasar continuum (z, loglam)") + results["CONT"].write_checksum() diff --git a/py/picca/delta_extraction/expected_fluxes/utils.py b/py/picca/delta_extraction/expected_fluxes/utils.py index 034057013..5efe129c1 100644 --- a/py/picca/delta_extraction/expected_fluxes/utils.py +++ b/py/picca/delta_extraction/expected_fluxes/utils.py @@ -19,7 +19,7 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, forest: Forest A forest instance where the continuum will be computed - get_mean_cont: scipy.interpolate.interp1d + get_mean_cont: scipy.interpolate.interp1d or scipy.interpolate.RegularGridInterpolator Interpolation function to compute the unabsorbed mean quasar continua. get_eta: scipy.interpolate.interp1d @@ -54,7 +54,12 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, the chi2 of the fit, and the number of datapoints used in the fit. """ # get mean continuum - mean_cont = get_mean_cont(forest.log_lambda - np.log10(1 + forest.z)) + if isinstance(get_mean_cont, RegularGridInterpolator): + mean_cont = get_mean_cont(forest.log_lambda - np.log10(1 + forest.z), + forest.z) + else: + # get mean continuum as a function of log_lambda + mean_cont = get_mean_cont(forest.log_lambda - np.log10(1 + forest.z)) # add transmission correction # (previously computed using method add_optical_depth) From d4c9b2af18c2838a58c7326be46951b4c4a0ace8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 9 Jul 2025 14:47:48 -0700 Subject: [PATCH 02/59] renamed file to allow for automatic discovery --- ...nuum_2d_expected_flux.py => mean_continuum2d_expected_flux.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename py/picca/delta_extraction/expected_fluxes/{mean_continuum_2d_expected_flux.py => mean_continuum2d_expected_flux.py} (100%) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_2d_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py similarity index 100% rename from py/picca/delta_extraction/expected_fluxes/mean_continuum_2d_expected_flux.py rename to py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py From e056ba9538ebb1ae6e6271181887371d313d898a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 9 Jul 2025 15:17:09 -0700 Subject: [PATCH 03/59] make sure z_bins are intialized before super.__init__ is called --- .../expected_fluxes/mean_continuum2d_expected_flux.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py index bdb4d32f1..efcbbe807 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py @@ -73,8 +73,7 @@ def __init__(self, config): ExpectedFluxError if Forest class variables are not set """ self.logger = logging.getLogger(__name__) - super().__init__(config) - + # load variables from config self.limit_z = None self.num_z_bins = None @@ -82,6 +81,8 @@ def __init__(self, config): self.z_centers = None self.__parse_config(config) + super().__init__(config) + def __parse_config(self, config): """Parse the configuration options From 3d60800831417ba5febdf46cde4b0b738454d101 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 9 Jul 2025 15:24:06 -0700 Subject: [PATCH 04/59] removed reference to super.__parse_config as it is incorrect --- .../expected_fluxes/mean_continuum2d_expected_flux.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py index efcbbe807..de8a2d9eb 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py @@ -95,8 +95,7 @@ def __parse_config(self, config): ------ ExpectedFluxError if variables are not valid """ - super().__parse_config(config) - + limit_z_string = config.get("limit z") if limit_z_string is None: raise ExpectedFluxError( From 16a714d3762940e1022c14029c68c344cb6cf1a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 9 Jul 2025 15:30:37 -0700 Subject: [PATCH 05/59] added missing import --- py/picca/delta_extraction/expected_fluxes/utils.py | 1 + 1 file changed, 1 insertion(+) diff --git a/py/picca/delta_extraction/expected_fluxes/utils.py b/py/picca/delta_extraction/expected_fluxes/utils.py index 5efe129c1..037ee09d5 100644 --- a/py/picca/delta_extraction/expected_fluxes/utils.py +++ b/py/picca/delta_extraction/expected_fluxes/utils.py @@ -1,6 +1,7 @@ """This module defines the method compute_continuum to compute the quasar continua""" import iminuit import numpy as np +from scipy.interpolate import RegularGridInterpolator from picca.delta_extraction.astronomical_objects.forest import Forest from picca.delta_extraction.least_squares.least_squares_cont_model import LeastsSquaresContModel From 02ae4373b100a57fd292ea630b1dd39b45b4665c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 9 Jul 2025 15:37:49 -0700 Subject: [PATCH 06/59] fixed call to get_mean_cont --- py/picca/delta_extraction/expected_fluxes/utils.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/utils.py b/py/picca/delta_extraction/expected_fluxes/utils.py index 037ee09d5..1ed4144c4 100644 --- a/py/picca/delta_extraction/expected_fluxes/utils.py +++ b/py/picca/delta_extraction/expected_fluxes/utils.py @@ -56,8 +56,7 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, """ # get mean continuum if isinstance(get_mean_cont, RegularGridInterpolator): - mean_cont = get_mean_cont(forest.log_lambda - np.log10(1 + forest.z), - forest.z) + mean_cont = get_mean_cont([forest.z, forest.log_lambda - np.log10(1 + forest.z)]) else: # get mean continuum as a function of log_lambda mean_cont = get_mean_cont(forest.log_lambda - np.log10(1 + forest.z)) From 59ff851353c486e022537b8d7015b2cd6e95479c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 9 Jul 2025 15:47:30 -0700 Subject: [PATCH 07/59] potential fix to calling get_mean_cont --- py/picca/delta_extraction/expected_fluxes/utils.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/py/picca/delta_extraction/expected_fluxes/utils.py b/py/picca/delta_extraction/expected_fluxes/utils.py index 1ed4144c4..c773bcd25 100644 --- a/py/picca/delta_extraction/expected_fluxes/utils.py +++ b/py/picca/delta_extraction/expected_fluxes/utils.py @@ -56,7 +56,9 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, """ # get mean continuum if isinstance(get_mean_cont, RegularGridInterpolator): - mean_cont = get_mean_cont([forest.z, forest.log_lambda - np.log10(1 + forest.z)]) + log_lambda = forest.log_lambda - np.log10(1 + forest.z) + points = np.column_stack([np.full_like(log_lambda, forest.z), log_lambda]) + mean_cont = get_mean_cont(points) else: # get mean continuum as a function of log_lambda mean_cont = get_mean_cont(forest.log_lambda - np.log10(1 + forest.z)) From cc299e42f6e5d882bbccf7361dd1ee2da0231195 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 9 Jul 2025 16:08:17 -0700 Subject: [PATCH 08/59] removed incorrect old code --- .../expected_fluxes/mean_continuum2d_expected_flux.py | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py index de8a2d9eb..db00d017a 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py @@ -210,17 +210,6 @@ def hdu_cont(self, results): results: fitsio.FITS The open fits file """ - results.write([ - Forest.log_lambda_rest_frame_grid, - self.get_mean_cont(Forest.log_lambda_rest_frame_grid), - self.get_mean_cont_weight(Forest.log_lambda_rest_frame_grid), - ], - names=['LOGLAM_REST', 'MEAN_CONT', 'WEIGHT'], - units=['log(Angstrom)', Forest.flux_units, ''], - extname='CONT') - results["CONT"].write_comment("Mean quasar continuum") - results["CONT"].write_checksum() - # Create meshgrid for evaluation z_meshgrid, log_lam_mesh_grid = np.meshgrid(self.z_centers, Forest.log_lambda_rest_frame_grid, indexing='ij') points = np.stack([z_meshgrid.ravel(), log_lam_mesh_grid.ravel()], axis=-1) From 7931c5508a1265c3a94dc80710308e0181769075 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Thu, 10 Jul 2025 09:01:53 -0700 Subject: [PATCH 09/59] removed extra 1 --- .../expected_fluxes/mean_continuum2d_expected_flux.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py index db00d017a..731dcbb91 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py @@ -118,7 +118,7 @@ def __parse_config(self, config): self.num_z_bins = num_z_bins self.z_bins = np.linspace(self.limit_z[0], self.limit_z[1], - self.num_z_bins + 1) + self.num_z_bins) self.z_centers = (self.z_bins[:-1] + self.z_bins[1:]) / 2 def _initialize_mean_continuum_arrays(self): From 52f998ad11ecfb8397ba60d4ceaa7c794842a6dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Thu, 10 Jul 2025 14:35:49 -0700 Subject: [PATCH 10/59] restored the +1, fixed error message --- .../mean_continuum2d_expected_flux.py | 4 +- .../delta_extraction/mean_cont2d_tests.py | 839 ++++++++++++++++++ 2 files changed, 841 insertions(+), 2 deletions(-) create mode 100644 py/picca/tests/delta_extraction/mean_cont2d_tests.py diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py index 731dcbb91..dd847a74a 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py @@ -114,11 +114,11 @@ def __parse_config(self, config): num_z_bins = config.getint("num z bins") if num_z_bins is None or num_z_bins < 1: raise ExpectedFluxError( - "Missing or invalid argument 'num z bins' required by MeanContinuum2dExpectedFlux") + "Missing argument 'num z bins' required by MeanContinuum2dExpectedFlux") self.num_z_bins = num_z_bins self.z_bins = np.linspace(self.limit_z[0], self.limit_z[1], - self.num_z_bins) + self.num_z_bins + 1) self.z_centers = (self.z_bins[:-1] + self.z_bins[1:]) / 2 def _initialize_mean_continuum_arrays(self): diff --git a/py/picca/tests/delta_extraction/mean_cont2d_tests.py b/py/picca/tests/delta_extraction/mean_cont2d_tests.py new file mode 100644 index 000000000..b0da334eb --- /dev/null +++ b/py/picca/tests/delta_extraction/mean_cont2d_tests.py @@ -0,0 +1,839 @@ +"""This file contains tests related to ExpectedFlux and its childs""" +from configparser import ConfigParser +import copy +import os +import unittest + +import numpy as np +from scipy.interpolate import interp1d, RegularGridInterpolator + +from picca.delta_extraction.errors import ExpectedFluxError +from picca.delta_extraction.data_catalogues.desi_healpix import DesiHealpix +from picca.delta_extraction.data_catalogues.desi_healpix import defaults as defaults_desi_healpix +from picca.delta_extraction.data_catalogues.sdss_data import SdssData +from picca.delta_extraction.data_catalogues.sdss_data import defaults as defaults_sdss_data +from picca.delta_extraction.expected_fluxes.dr16_expected_flux import ( + compute_continuum) +from picca.delta_extraction.expected_fluxes.dr16_expected_flux import ( + defaults as defaults_dr16_expected_flux) +from picca.delta_extraction.expected_fluxes.mean_continuum2d_expected_flux import ( + MeanContinuum2dExpectedFlux, defaults as defaults_mean_continuum2d_expected_flux) +from picca.tests.delta_extraction.abstract_test import AbstractTest +from picca.tests.delta_extraction.test_utils import setup_forest, reset_forest +from picca.tests.delta_extraction.test_utils import desi_healpix_kwargs +from picca.tests.delta_extraction.test_utils import sdss_data_kwargs + +THIS_DIR = os.path.dirname(os.path.abspath(__file__)) + +class ExpectedFluxTest(AbstractTest): + """Test class ExpectedFlux and its childs. + Methods + ------- + compare_ascii (from AbstractTest) + compare_fits (from AbstractTest) + setUp + tearDown + test_expected_flux + test_dr16_expected_flux + test_dr16_expected_flux_compute_continuum + test_dr16_expected_flux_compute_delta_stack + test_dr16_expected_flux_compute_expected_flux + test_dr16_expected_flux_compute_mean_cont_lin + test_dr16_expected_flux_compute_mean_cont_log + test_dr16_expected_flux_compute_var_stats + test_dr16_expected_flux_populate_los_ids + test_dr16_expected_flux_save_iteration_step + """ + def test_mean_continuum2d_expected_flux(self): + """Test constructor for class MeanContinuum2dExpectedFlux + Load an MeanContinuum2dExpectedFlux instance. + """ + config = ConfigParser() + config.read_dict( + {"expected flux": { + "iter out prefix": "iter_out_prefix", + "limit z": "(1.94, 4.5)", + "num processors": 1, + "num z bins": 2, + "out dir": f"{THIS_DIR}/results/", + }}) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + # this should raise an error as Forest variables are not defined + expected_message = ( + "Forest class variables need to be set before initializing " + "variables here.") + with self.assertRaises(ExpectedFluxError) as context_manager: + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + self.compare_error_message(context_manager, expected_message) + + # setup Forest variables; case: logarithmic wavelength solution + setup_forest("log", rebin=3) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + self.assertTrue(isinstance(expected_flux.get_eta, interp1d)) + self.assertTrue(isinstance(expected_flux.get_fudge, interp1d)) + self.assertTrue(isinstance(expected_flux.get_mean_cont, RegularGridInterpolator)) + self.assertTrue(isinstance(expected_flux.get_var_lss, interp1d)) + self.assertTrue(isinstance(expected_flux.log_lambda_var_func_grid, np.ndarray)) + + # setup Forest variables; case: linear wavelength solution + reset_forest() + setup_forest("lin") + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + self.assertTrue(isinstance(expected_flux.get_eta, interp1d)) + self.assertTrue(isinstance(expected_flux.get_fudge, interp1d)) + self.assertTrue(isinstance(expected_flux.get_mean_cont, RegularGridInterpolator)) + self.assertTrue(isinstance(expected_flux.get_var_lss, interp1d)) + self.assertTrue(isinstance(expected_flux.log_lambda_var_func_grid, np.ndarray)) + + def test_mean_continuum2d_expected_flux_compute_continuum_lin(self): + """Test method compute_continuum for class MeanContinuum2dExpectedFlux for + linear wavelength solution""" + setup_forest("lin") + + out_file = f"{THIS_DIR}/results/continua_2d_lin.txt" + test_file = f"{THIS_DIR}/data/continua_2d_lin.txt" + + # initialize DesiHealpix and MeanContinuum2dExpectedFlux instances + config = ConfigParser() + config.read_dict({ + "data": desi_healpix_kwargs, + "expected flux": { + "iter out prefix": "iter_out_prefix", + "out dir": f"{THIS_DIR}/results/", + "num processors": 1, + }, + }) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + for key, value in defaults_desi_healpix.items(): + if key not in config["data"]: + config["data"][key] = str(value) + data = DesiHealpix(config["data"]) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + # compute the forest continua + for forest in data.forests: + (cont_model, bad_continuum_reason, + continuum_fit_parameters) = compute_continuum(forest, + expected_flux.get_mean_cont, + expected_flux.get_eta, + expected_flux.get_var_lss, + expected_flux.get_fudge, + expected_flux.use_constant_weight, + expected_flux.order) + forest.bad_continuum_reason = bad_continuum_reason + forest.continuum = cont_model + + # save the results + f = open(out_file, "w") + f.write("# thingid cont[0] ... cont[N]\n") + for forest in data.forests: + f.write(f"{forest.los_id} ") + if forest.continuum is not None: + for item in forest.continuum: + f.write(f"{item} ") + f.write("\n") + f.close() + + # load expected forest continua + continua = {} + f = open(test_file) + for line in f.readlines(): + if line.startswith("#"): + continue + cols = line.split() + los_id = int(cols[0]) + if len(cols) == 1: + continuum = None + else: + continuum = np.array([float(item) for item in cols[1:]]) + continua[los_id] = continuum + f.close() + + # compare the results + correct_forests = 0 + for forest in data.forests: + if forest.continuum is None: + if continua.get(forest.los_id) is not None: + print(f"For forest with los_id {forest.los_id}, new continuum " + "is None. Expected continua:") + print(continua.get(forest.los_id)) + self.assertTrue(continua.get(forest.los_id) is None) + elif continua.get(forest.los_id) is None: + self.assertTrue(forest.continuum is None) + else: + if not np.allclose(forest.continuum, continua.get(forest.los_id)): + print("Difference found in forest.continuum") + print(f"forest.los_id: {forest.los_id}") + print(f"result test are_close result-test") + for i1, i2 in zip(forest.continuum, continua.get(forest.los_id)): + print(i1, i2, np.isclose(i1, i2), i1-i2) + self.assertTrue( + np.allclose(forest.continuum, continua.get(forest.los_id))) + correct_forests += 1 + + # check that we loaded all quasars + self.assertTrue(correct_forests == len(continua)) + + def test_mean_continuum2d_expected_flux_compute_continuum_log(self): + """Test method compute_continuum for class MeanContinuum2dExpectedFlux for + logarithmic wavelength solution""" + setup_forest("log", rebin=3) + + out_file = f"{THIS_DIR}/results/continua_2d_log.txt" + test_file = f"{THIS_DIR}/data/continua_2d_log.txt" + + # initialize Data and MeanContinuum2dExpectedFlux instances + config = ConfigParser() + config.read_dict({ + "data": sdss_data_kwargs, + "expected flux": { + "iter out prefix": "iter_out_prefix", + "out dir": f"{THIS_DIR}/results/", + "num processors": 1, + }, + }) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + for key, value in defaults_sdss_data.items(): + if key not in config["data"]: + config["data"][key] = str(value) + data = SdssData(config["data"]) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + # compute the forest continua + for forest in data.forests: + (cont_model, bad_continuum_reason, + continuum_fit_parameters) = compute_continuum(forest, + expected_flux.get_mean_cont, + expected_flux.get_eta, + expected_flux.get_var_lss, + expected_flux.get_fudge, + expected_flux.use_constant_weight, + expected_flux.order) + forest.bad_continuum_reason = bad_continuum_reason + forest.continuum = cont_model + + # save the results + f = open(out_file, "w") + f.write("# thingid cont[0] ... cont[N]\n") + for forest in data.forests: + f.write(f"{forest.los_id} ") + for item in forest.continuum: + f.write(f"{item} ") + f.write("\n") + f.close() + + # load expected forest continua + continua = {} + f = open(test_file) + for line in f.readlines(): + if line.startswith("#"): + continue + cols = line.split() + los_id = int(cols[0]) + continuum = np.array([float(item) for item in cols[1:]]) + continua[los_id] = continuum + f.close() + + # compare the results + correct_forests = 0 + for forest in data.forests: + if not np.allclose(forest.continuum, continua.get(forest.los_id)): + print("Difference found in forest.continuum") + print(f"forest.los_id: {forest.los_id}") + print(f"result test are_close result-test") + for i1, i2 in zip(forest.continuum, continua.get(forest.los_id)): + print(i1, i2, np.isclose(i1, i2), i1-i2) + self.assertTrue( + np.allclose(forest.continuum, continua.get(forest.los_id))) + correct_forests += 1 + + # check that we loaded all quasars + self.assertTrue(correct_forests == len(continua)) + + def test_mean_continuum2d_expected_flux_compute_delta_stack_lin(self): + """Test method compute_delta_stack for class MeanContinuum2dExpectedFlux for + linear wavelength solution""" + setup_forest("lin") + + out_file = f"{THIS_DIR}/results/delta_stack_lin.txt" + test_file = f"{THIS_DIR}/data/delta_stack_lin.txt" + + # initialize Data and Dr16ExpectedFlux instances + config = ConfigParser() + config.read_dict({ + "data": desi_healpix_kwargs, + "expected flux": { + "iter out prefix": "iter_out_prefix", + "out dir": f"{THIS_DIR}/results/", + "num processors": 1, + "var lss mod": 1.0, + }, + }) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + for key, value in defaults_desi_healpix.items(): + if key not in config["data"]: + config["data"][key] = str(value) + data = DesiHealpix(config["data"]) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + # compute the forest continua + for forest in data.forests: + (cont_model, bad_continuum_reason, + continuum_fit_parameters) = compute_continuum(forest, + expected_flux.get_mean_cont, + expected_flux.get_eta, + expected_flux.get_var_lss, + expected_flux.get_fudge, + expected_flux.use_constant_weight, + expected_flux.order) + forest.bad_continuum_reason = bad_continuum_reason + forest.continuum = cont_model + + # compute variance functions and statistics + expected_flux.compute_delta_stack(data.forests) + + # save results + f = open(out_file, "w") + f.write("# log_lambda delta\n") + for log_lambda in np.arange(3.5563025, 3.7123025 + 3e-4, 3e-4): + f.write(f"{log_lambda} {expected_flux.get_stack_delta(log_lambda)}\n") + f.close() + + # load expected delta stack + expectations = np.genfromtxt(test_file, names=True) + + # compare with obtained results + stack_delta = expected_flux.get_stack_delta(expectations["log_lambda"]) + if not np.allclose(stack_delta, expectations["delta"]): + print(f"\nOriginal file: {test_file}") + print(f"New file: {out_file}") + print("Difference found in delta stack") + print(f"result test are_close result-test") + for i1, i2 in zip(stack_delta, expectations["delta"]): + print(i1, i2, np.isclose(i1, i2), i1-i2) + self.assertTrue(np.allclose(stack_delta, expectations["delta"])) + + def test_mean_continuum2d_expected_flux_compute_delta_stack_log(self): + """Test method compute_delta_stack for class MeanContinuum2dExpectedFlux for + logarithmic wavelength solution""" + setup_forest("log", rebin=3) + + out_file = f"{THIS_DIR}/results/delta_stack_2d_log.txt" + test_file = f"{THIS_DIR}/data/delta_stack_2d_log.txt" + + # initialize Data and MeanContinuum2dExpectedFlux instances + config = ConfigParser() + config.read_dict({ + "data": sdss_data_kwargs, + "expected flux": { + "iter out prefix": "iter_out_prefix", + "out dir": f"{THIS_DIR}/results/", + "num processors": 1 + }, + }) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + for key, value in defaults_sdss_data.items(): + if key not in config["data"]: + config["data"][key] = str(value) + data = SdssData(config["data"]) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + # compute the forest continua + for forest in data.forests: + (cont_model, bad_continuum_reason, + continuum_fit_parameters) = compute_continuum(forest, + expected_flux.get_mean_cont, + expected_flux.get_eta, + expected_flux.get_var_lss, + expected_flux.get_fudge, + expected_flux.use_constant_weight, + expected_flux.order) + forest.bad_continuum_reason = bad_continuum_reason + forest.continuum = cont_model + + # compute variance functions and statistics + expected_flux.compute_delta_stack(data.forests) + + # save results + f = open(out_file, "w") + f.write("# log_lambda delta\n") + for log_lambda in np.arange(3.5563025, 3.7123025 + 3e-4, 3e-4): + f.write(f"{log_lambda} {expected_flux.get_stack_delta(log_lambda)}\n") + f.close() + + # load expected delta stack + expectations = np.genfromtxt(test_file, names=True) + + # compare with obtained results + stack_delta = expected_flux.get_stack_delta(expectations["log_lambda"]) + if not np.allclose(stack_delta, expectations["delta"]): + print(f"\nOriginal file: {test_file}") + print(f"New file: {out_file}") + print("Difference found in delta stack") + print(f"result test are_close result-test") + for i1, i2 in zip(stack_delta, expectations["delta"]): + print(i1, i2, np.isclose(i1, i2), i1-i2) + self.assertTrue(np.allclose(stack_delta, expectations["delta"])) + + def test_mean_continuum2d_expected_flux_compute_expected_flux_lin(self): + """Test method compute_var_stats for class MeanContinuum2dExpectedFlux for + linear wavelength solution""" + setup_forest("lin") + + out_file = f"{THIS_DIR}/results/Log/iter_out_prefix_compute_expected_flux_2d_lin.fits.gz" + test_file = f"{THIS_DIR}/data/iter_out_prefix_compute_expected_flux_2d_lin.fits.gz" + + # initialize Data and MeanContinuum2dExpectedFlux instances + config = ConfigParser() + config.read_dict({ + "data": desi_healpix_kwargs, + "expected flux": { + "iter out prefix": "iter_out_prefix_compute_expected_flux_2d_lin", + "out dir": f"{THIS_DIR}/results/", + "num processors": 1, + }, + }) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + for key, value in defaults_desi_healpix.items(): + if key not in config["data"]: + config["data"][key] = str(value) + data = DesiHealpix(config["data"]) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + # compute the expected flux + expected_flux.compute_expected_flux(data.forests) + + # check the results + for iteration in range(1, 5): + self.compare_fits( + test_file.replace(".fits", f"_iteration{iteration}.fits"), + out_file.replace(".fits", f"_iteration{iteration}.fits")) + self.compare_fits(test_file, out_file) + + def test_mean_continuum2d_expected_flux_compute_expected_flux_log(self): + """Test method compute_var_stats for class MeanContinuum2dExpectedFlux for + logarithmic wavelength solution""" + setup_forest("log", rebin=3) + + out_file = f"{THIS_DIR}/results/Log/iter_out_prefix_compute_expected_flux_2d_log.fits.gz" + test_file = f"{THIS_DIR}/data/iter_out_prefix_compute_expected_flux_2d_log.fits.gz" + + # initialize Data and Dr16ExpectedFlux instances + config = ConfigParser() + config.read_dict({ + "data": sdss_data_kwargs, + "expected flux": { + "iter out prefix": "iter_out_prefix_compute_expected_flux_2d_log", + "out dir": f"{THIS_DIR}/results/", + "num processors": 1 + }, + }) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + for key, value in defaults_sdss_data.items(): + if key not in config["data"]: + config["data"][key] = str(value) + data = SdssData(config["data"]) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + # compute the expected flux + expected_flux.compute_expected_flux(data.forests) + + # check the results + for iteration in range(1, 5): + self.compare_fits( + test_file.replace(".fits", f"_iteration{iteration}.fits"), + out_file.replace(".fits", f"_iteration{iteration}.fits")) + self.compare_fits(test_file, out_file) + + def test_mean_continuum2d_expected_flux_compute_mean_cont_lin(self): + """Test method compute_mean_cont_lin for class MeanContinuum2dExpectedFlux + for linear wavelength solution""" + setup_forest("lin") + + out_file = f"{THIS_DIR}/results/mean_cont_2d_lin.txt" + test_file = f"{THIS_DIR}/data/mean_cont_2d_lin.txt" + + # initialize Data and MeanContinuum2dExpectedFlux instances + config = ConfigParser() + config.read_dict({ + "data": desi_healpix_kwargs, + "expected flux": { + "iter out prefix": "iter_out_prefix", + "out dir": f"{THIS_DIR}/results/", + "num processors": 1, + }, + }) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + for key, value in defaults_desi_healpix.items(): + if key not in config["data"]: + config["data"][key] = str(value) + data = DesiHealpix(config["data"]) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + # compute the forest continua + for forest in data.forests: + (cont_model, bad_continuum_reason, + continuum_fit_parameters) = compute_continuum(forest, + expected_flux.get_mean_cont, + expected_flux.get_eta, + expected_flux.get_var_lss, + expected_flux.get_fudge, + expected_flux.use_constant_weight, + expected_flux.order) + forest.bad_continuum_reason = bad_continuum_reason + forest.continuum = cont_model + + # compute mean quasar continuum + expected_flux.compute_mean_cont(data.forests) + + # save results + f = open(out_file, "w") + f.write("# log_lambda mean_cont\n") + for log_lambda in np.arange(3.0171, 3.079 + 3e-4, 3e-4): + f.write(f"{log_lambda} {expected_flux.get_mean_cont(log_lambda)}\n") + f.close() + + # load the expected results + expectations = np.genfromtxt(test_file, names=True) + + # compare with obtained results + mean_cont = expected_flux.get_mean_cont(expectations["log_lambda"]) + if not np.allclose(mean_cont, expectations["mean_cont"]): + print(f"\nOriginal file: {test_file}") + print(f"New file: {out_file}") + print("Difference found in mean_cont") + print(f"result test are_close result-test") + for i1, i2 in zip(mean_cont, expectations["mean_cont"]): + print(i1, i2, np.isclose(i1, i2), i1-i2) + self.assertTrue(np.allclose(mean_cont, expectations["mean_cont"])) + + def test_mean_continuum2d_expected_flux_compute_mean_cont_log(self): + """Test method compute_mean_cont_log for class MeanContinuum2dExpectedFlux for + logarithmic wavelength solution""" + setup_forest("log", rebin=3) + + out_file = f"{THIS_DIR}/results/mean_cont_2d_log.txt" + test_file = f"{THIS_DIR}/data/mean_cont_2d_log.txt" + + # initialize Data and MeanContinuum2dExpectedFlux instances + config = ConfigParser() + config.read_dict({ + "data": sdss_data_kwargs, + "expected flux": { + "iter out prefix": "iter_out_prefix", + "out dir": f"{THIS_DIR}/results/", + "num processors": 1 + }, + }) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + for key, value in defaults_sdss_data.items(): + if key not in config["data"]: + config["data"][key] = str(value) + data = SdssData(config["data"]) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + # compute the forest continua + for forest in data.forests: + (cont_model, bad_continuum_reason, + continuum_fit_parameters) = compute_continuum(forest, + expected_flux.get_mean_cont, + expected_flux.get_eta, + expected_flux.get_var_lss, + expected_flux.get_fudge, + expected_flux.use_constant_weight, + expected_flux.order) + forest.bad_continuum_reason = bad_continuum_reason + forest.continuum = cont_model + + # compute mean quasar continuum + expected_flux.compute_mean_cont(data.forests) + + # save results + f = open(out_file, "w") + f.write("# log_lambda mean_cont\n") + for log_lambda in np.arange(3.0171, 3.079 + 3e-4, 3e-4): + f.write(f"{log_lambda} {expected_flux.get_mean_cont(log_lambda)}\n") + f.close() + + # load the expected results + expectations = np.genfromtxt(test_file, names=True) + + # compare with obtained results + mean_cont = expected_flux.get_mean_cont(expectations["log_lambda"]) + if not np.allclose(mean_cont, expectations["mean_cont"]): + print(f"\nOriginal file: {test_file}") + print(f"New file: {out_file}") + print("Difference found in mean_cont") + print(f"result test are_close result-test") + for i1, i2 in zip(mean_cont, expectations["mean_cont"]): + print(i1, i2, np.isclose(i1, i2), i1-i2) + self.assertTrue(np.allclose(mean_cont, expectations["mean_cont"])) + + def test_mean_continuum2d_expected_flux_compute_var_stats_lin(self): + """Test method compute_var_stats for class MeanContinuum2dExpectedFlux with + linear wavelength solution + """ + setup_forest("lin") + + out_file = f"{THIS_DIR}/results/var_stats_2d_lin.txt" + test_file = f"{THIS_DIR}/data/var_stats_2d_lin.txt" + + # initialize Data and MeanContinuum2dExpectedFlux instances + config = ConfigParser() + config.read_dict({ + "data": desi_healpix_kwargs, + "expected flux": { + "iter out prefix": "iter_out_prefix", + "out dir": f"{THIS_DIR}/results/", + "num processors": 1, + }, + }) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + for key, value in defaults_desi_healpix.items(): + if key not in config["data"]: + config["data"][key] = str(value) + data = DesiHealpix(config["data"]) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + # compute the forest continua + for forest in data.forests: + (cont_model, bad_continuum_reason, + continuum_fit_parameters) = compute_continuum(forest, + expected_flux.get_mean_cont, + expected_flux.get_eta, + expected_flux.get_var_lss, + expected_flux.get_fudge, + expected_flux.use_constant_weight, + expected_flux.order) + forest.bad_continuum_reason = bad_continuum_reason + forest.continuum = cont_model + + # compute variance functions and statistics + expected_flux.compute_var_stats(data.forests) + + # save results + f = open(out_file, "w") + f.write("#log_lambda eta var_lss fudge num_pixels valid_fit\n") + for log_lambda in expected_flux.log_lambda_var_func_grid: + f.write(f"{log_lambda} ") + f.write(f"{expected_flux.get_eta(log_lambda)} ") + f.write(f"{expected_flux.get_var_lss(log_lambda)} ") + f.write(f"{expected_flux.get_fudge(log_lambda)} ") + f.write(f"{expected_flux.get_num_pixels(log_lambda)} ") + f.write(f"{expected_flux.get_valid_fit(log_lambda)} ") + f.write("\n") + f.close() + + # load the expected results + expectations = np.genfromtxt(test_file, names=True) + + # compare with obtained results + eta = expected_flux.get_eta(expectations["log_lambda"]) + var_lss = expected_flux.get_var_lss(expectations["log_lambda"]) + fudge = expected_flux.get_fudge(expectations["log_lambda"]) + num_pixels = expected_flux.get_num_pixels(expectations["log_lambda"]) + valid_fit = expected_flux.get_valid_fit(expectations["log_lambda"]) + self.assertTrue(np.allclose(eta, expectations["eta"])) + self.assertTrue(np.allclose(var_lss, expectations["var_lss"])) + self.assertTrue(np.allclose(fudge, expectations["fudge"])) + self.assertTrue(np.allclose(num_pixels, expectations["num_pixels"])) + self.assertTrue(np.allclose(valid_fit, expectations["valid_fit"])) + + def test_mean_continuum2d_expected_flux_compute_var_stats_log(self): + """Test method compute_var_stats for class MeanContinuum2dExpectedFlux with + logarithmic wavelength solution + """ + setup_forest("log", rebin=3) + + out_file = f"{THIS_DIR}/results/var_stats_2d_log.txt" + test_file = f"{THIS_DIR}/data/var_stats_2d_log.txt" + + # initialize Data and MeanContinuum2dExpectedFlux instances + config = ConfigParser() + config.read_dict({ + "data": sdss_data_kwargs, + "expected flux": { + "iter out prefix": "iter_out_prefix", + "out dir": f"{THIS_DIR}/results/", + "num processors": 1 + }, + }) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + for key, value in defaults_sdss_data.items(): + if key not in config["data"]: + config["data"][key] = str(value) + data = SdssData(config["data"]) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + # compute the forest continua + for forest in data.forests: + (cont_model, bad_continuum_reason, + continuum_fit_parameters) = compute_continuum(forest, + expected_flux.get_mean_cont, + expected_flux.get_eta, + expected_flux.get_var_lss, + expected_flux.get_fudge, + expected_flux.use_constant_weight, + expected_flux.order) + forest.bad_continuum_reason = bad_continuum_reason + forest.continuum = cont_model + + # compute variance functions and statistics + expected_flux.compute_var_stats(data.forests) + + # save results + f = open(out_file, "w") + f.write("#log_lambda eta var_lss fudge num_pixels valid_fit\n") + for log_lambda in expected_flux.log_lambda_var_func_grid: + f.write(f"{log_lambda} ") + f.write(f"{expected_flux.get_eta(log_lambda)} ") + f.write(f"{expected_flux.get_var_lss(log_lambda)} ") + f.write(f"{expected_flux.get_fudge(log_lambda)} ") + f.write(f"{expected_flux.get_num_pixels(log_lambda)} ") + f.write(f"{expected_flux.get_valid_fit(log_lambda)} ") + f.write("\n") + f.close() + + # load the expected results + expectations = np.genfromtxt(test_file, names=True) + + # compare with obtained results + eta = expected_flux.get_eta(expectations["log_lambda"]) + var_lss = expected_flux.get_var_lss(expectations["log_lambda"]) + fudge = expected_flux.get_fudge(expectations["log_lambda"]) + num_pixels = expected_flux.get_num_pixels(expectations["log_lambda"]) + valid_fit = expected_flux.get_valid_fit(expectations["log_lambda"]) + self.assertTrue(np.allclose(eta, expectations["eta"])) + self.assertTrue(np.allclose(var_lss, expectations["var_lss"])) + self.assertTrue(np.allclose(fudge, expectations["fudge"])) + self.assertTrue(np.allclose(num_pixels, expectations["num_pixels"])) + self.assertTrue(np.allclose(valid_fit, expectations["valid_fit"])) + + def test_mean_continuum2d_expected_flux_parse_config(self): + """Test method __parse_config for class MeanContinuum2dExpectedFlux""" + # Forest variables need to be initialize to finish ExpectedFlux.__init__ + setup_forest("log", rebin=3) + + # create a MeanContinuum2dExpectedFlux with missing 'limit z' + config = ConfigParser() + config.read_dict({"expected_flux": { + }}) + expected_message = ( + "Missing argument 'limit z' required by MeanContinuum2dExpectedFlux" + ) + with self.assertRaises(ExpectedFluxError) as context_manager: + MeanContinuum2dExpectedFlux(config["expected_flux"]) + self.compare_error_message(context_manager, expected_message) + + # create a MeanContinuum2dExpectedFlux with missing 'num z bins' + config = ConfigParser() + config.read_dict({"expected_flux": { + "limit z": "(1.94, 4.5)", + }}) + expected_message = ( + "Missing argument 'num z bins' required by MeanContinuum2dExpectedFlux" + ) + with self.assertRaises(ExpectedFluxError) as context_manager: + MeanContinuum2dExpectedFlux(config["expected_flux"]) + self.compare_error_message(context_manager, expected_message) + + # create a MeanContinuum2dExpectedFlux with missing ExpectedFlux Options + config = ConfigParser() + config.read_dict({"expected_flux": { + "limit z": "(1.94, 4.5)", + "num z bins": 2, + }}) + expected_message = ( + "Missing argument 'iter out prefix' required by ExpectedFlux" + ) + with self.assertRaises(ExpectedFluxError) as context_manager: + MeanContinuum2dExpectedFlux(config["expected_flux"]) + self.compare_error_message(context_manager, expected_message) + + # create a MeanContinuum2dExpectedFlux with missing Dr16ExpectedFlux Options + config = ConfigParser() + config.read_dict({"expected_flux": { + "iter out prefix": f"iter_out_prefix", + "out dir": f"{THIS_DIR}/results/", + "limit z": "(1.94, 4.5)", + "num bins variance": 20, + "num processors": 1, + "num z bins": 2, + "var lss mod": 1.0, + }}) + expected_message = ( + "Missing argument 'force stack delta to zero' required by Dr16ExpectedFlux" + ) + with self.assertRaises(ExpectedFluxError) as context_manager: + MeanContinuum2dExpectedFlux(config["expected_flux"]) + self.compare_error_message(context_manager, expected_message) + + def test_mean_continuum2d_expected_flux_populate_los_ids(self): + """Test method populate_los_ids for class MeanContinuum2dExpectedFlux""" + # setup Forest variables; case: logarithmic wavelength solution + setup_forest("log", rebin=3) + + # initialize Data and MeanContinuum2dExpectedFlux instances + config = ConfigParser() + config.read_dict({ + "data": sdss_data_kwargs, + "expected flux": { + "iter out prefix": "iter_out_prefix_2d_log", + "out dir": f"{THIS_DIR}/results/", + "num processors": 1 + }, + }) + for key, value in defaults_dr16_expected_flux.items(): + if key not in config["expected flux"]: + config["expected flux"][key] = str(value) + for key, value in defaults_sdss_data.items(): + if key not in config["data"]: + config["data"][key] = str(value) + data = SdssData(config["data"]) + expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) + + # compute the forest continua + for forest in data.forests: + (cont_model, bad_continuum_reason, + continuum_fit_parameters) = compute_continuum(forest, + expected_flux.get_mean_cont, + expected_flux.get_eta, + expected_flux.get_var_lss, + expected_flux.get_fudge, + expected_flux.use_constant_weight, + expected_flux.order) + forest.bad_continuum_reason = bad_continuum_reason + forest.continuum = cont_model + + # compute variance functions and statistics + expected_flux.compute_delta_stack(data.forests) + + # save iter_out_prefix for iteration 0 + expected_flux.populate_los_ids(data.forests) + +if __name__ == '__main__': + unittest.main() From c72aecbe2433a983a0c17fe92748de4e90675b14 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 11:15:05 +0200 Subject: [PATCH 11/59] renamed file, fixed 1d interpolation --- .../mean_continuum2d_expected_flux.py | 229 ------------- .../mean_continuum_interp_expected_flux.py | 316 ++++++++++++++++++ 2 files changed, 316 insertions(+), 229 deletions(-) delete mode 100644 py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py create mode 100644 py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py deleted file mode 100644 index dd847a74a..000000000 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum2d_expected_flux.py +++ /dev/null @@ -1,229 +0,0 @@ -"""This module defines the class Dr16ExpectedFlux""" -import logging - -import numpy as np -from scipy.interpolate import RegularGridInterpolator - -from picca.delta_extraction.errors import ExpectedFluxError -from picca.delta_extraction.astronomical_objects.forest import Forest -from picca.delta_extraction.expected_fluxes.dr16_expected_flux import Dr16ExpectedFlux, defaults, accepted_options -from picca.delta_extraction.utils import (update_accepted_options, - update_default_options, - ABSORBER_IGM) - -accepted_options = update_accepted_options(accepted_options, [ - "limit z", "num z bins" -]) - -defaults = update_default_options( - defaults, { - "limit z": (1.94, 4.5), - "num z bins": 10, - }) - - -class MeanContinuum2dExpectedFlux(Dr16ExpectedFlux): - """Class to the expected flux as done in the DR16 SDSS analysys - The mean expected flux is calculated iteratively as explained in - du Mas des Bourboux et al. (2020) except that the mean continuum is - computed in 2D (wavelength and redshift) instead of 1D. - - Methods - ------- - (see Dr16ExpectedFlux in py/picca/delta_extraction/expected_fluxes/dr16_expected_flux.py) - - Attributes - ---------- - (see Dr16ExpectedFlux in py/picca/delta_extraction/expected_fluxes/dr16_expected_flux.py) - - get_mean_cont: scipy.interpolate.RegularGridInterpolator - Interpolation function to compute the unabsorbed mean quasar continua. - - get_mean_cont_weight: scipy.interpolate.RegularGridInterpolator - Interpolation function to compute the weights associated with the unabsorbed - mean quasar continua. - - lambda_abs_igm: float - Wavelength in Angstroms at which the IGM absorption is computed. - - limit_z: tuple of float - Minimum and maximum redshift limits for the analysis. - - num_z_bins: int - Number of redshift bins to use for the analysis. - - z_bins: np.ndarray - Bins in redshift used to compute the mean continuum. - - z_centers: np.ndarray - Centers of the redshift bins used to compute the mean continuum. - This is used to interpolate the mean continuum and its weights. - """ - - def __init__(self, config): - """Initialize class instance. - - Arguments - --------- - config: configparser.SectionProxy - Parsed options to initialize class - - Raise - ----- - ExpectedFluxError if Forest class variables are not set - """ - self.logger = logging.getLogger(__name__) - - # load variables from config - self.limit_z = None - self.num_z_bins = None - self.z_bins = None - self.z_centers = None - self.__parse_config(config) - - super().__init__(config) - - def __parse_config(self, config): - """Parse the configuration options - - Arguments - --------- - config: configparser.SectionProxy - Parsed options to initialize class - - Raises - ------ - ExpectedFluxError if variables are not valid - """ - - limit_z_string = config.get("limit z") - if limit_z_string is None: - raise ExpectedFluxError( - "Missing argument 'limit z' required by MeanContinuum2dExpectedFlux") - limit_z = limit_z_string.split(",") - if limit_z[0].startswith("(") or limit_z[0].startswith("["): - z_min = float(limit_z[0][1:]) - else: - z_min = float(limit_z[0]) - if limit_z[1].endswith(")") or limit_z[1].endswith("]"): - z_max = float(limit_z[1][:-1]) - else: - z_max = float(limit_z[1]) - self.limit_z = (z_min, z_max) - - num_z_bins = config.getint("num z bins") - if num_z_bins is None or num_z_bins < 1: - raise ExpectedFluxError( - "Missing argument 'num z bins' required by MeanContinuum2dExpectedFlux") - self.num_z_bins = num_z_bins - - self.z_bins = np.linspace(self.limit_z[0], self.limit_z[1], - self.num_z_bins + 1) - self.z_centers = (self.z_bins[:-1] + self.z_bins[1:]) / 2 - - def _initialize_mean_continuum_arrays(self): - """Initialize mean continuum arrays - The initialized arrays are: - - self.get_mean_cont - - self.get_mean_cont_weight - """ - # initialize the mean quasar continuum - # TODO: maybe we can drop this and compute first the mean quasar - # continuum on compute_expected_flux - mean_cont = np.ones( - (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) - mean_cont_weight = np.zeros( - (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) - - self.get_mean_cont = RegularGridInterpolator( - (self.z_centers, Forest.log_lambda_rest_frame_grid), mean_cont, bounds_error=False, fill_value=0.0 - ) - self.get_mean_cont_weight = RegularGridInterpolator( - (self.z_centers, Forest.log_lambda_rest_frame_grid), mean_cont_weight, bounds_error=False, fill_value=0.0 - ) - - def compute_mean_cont(self, forests, which_cont=lambda forest: forest.continuum): - """Compute the mean quasar continuum over the whole sample. - Then updates the value of self.get_mean_cont to contain it - - Arguments - --------- - forests: List of Forest - A list of Forest from which to compute the deltas. - - which_cont: Function or lambda - Should return what to use as continuum given a forest - """ - - mean_cont = np.zeros( - (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) - mean_cont_weight = np.zeros( - (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) - - - # first compute in bins. C=Cont_old*spectrum_dependent_fitting_fct - # (and Cont_old is constant for all spectra in a bin), thus we actually - # compute - # 1/Cont_old * - for forest in forests: - if forest.bad_continuum_reason is not None: - continue - # Compute redshifts, use quasar redshift - forest_z = forest.z * np.ones_like(forest.log_lambda) - - # Bin indices for each pixel - lam_bins = Forest.find_bins( - forest.log_lambda - np.log10(1 + forest.z), - Forest.log_lambda_rest_frame_grid) - z_bins_idx = np.digitize(forest_z, self.z_bins) - 1 - - - weights = self.compute_forest_weights(forest, forest.continuum) - forest_continuum = which_cont(forest) - - # Accumulate in 2D - for lam_bin, zbin, continuum, weight in zip(lam_bins, z_bins_idx, forest_continuum, weights): - if 0 <= lam_bin < Forest.log_lambda_rest_frame_grid.size and 0 <= zbin < self.z_bins.size - 1: - mean_cont[zbin, lam_bin] += continuum * weight - mean_cont_weight[zbin, lam_bin] += weight - - # Normalize - w = mean_cont_weight > 0 - mean_cont[w] /= mean_cont_weight[w] - mean_cont /= mean_cont[w].mean() - - - # 2D interpolator for mean continuum - self.get_mean_cont = RegularGridInterpolator( - (self.z_centers, Forest.log_lambda_rest_frame_grid), mean_cont, bounds_error=False, fill_value=0.0 - ) - # 2D interpolator for weights - self.get_mean_cont_weight = RegularGridInterpolator( - (self.z_centers, Forest.log_lambda_rest_frame_grid), mean_cont_weight, bounds_error=False, fill_value=0.0 - ) - - def hdu_cont(self, results): - """Add to the results file an HDU with the continuum information - - Arguments - --------- - results: fitsio.FITS - The open fits file - """ - # Create meshgrid for evaluation - z_meshgrid, log_lam_mesh_grid = np.meshgrid(self.z_centers, Forest.log_lambda_rest_frame_grid, indexing='ij') - points = np.stack([z_meshgrid.ravel(), log_lam_mesh_grid.ravel()], axis=-1) - mean_cont_2d = self.get_mean_cont(points).reshape(z_meshgrid.shape) - mean_cont_weight_2d = self.get_mean_cont_weight(points).reshape(z_meshgrid.shape) - - results.write([ - z_meshgrid, - log_lam_mesh_grid, - mean_cont_2d, - mean_cont_weight_2d, - ], - names=['Z_CENTERS', 'LOGLAM_REST', 'MEAN_CONT', 'WEIGHT'], - units=['', 'log(Angstrom)', Forest.flux_units, ''], - extname='CONT') - results["CONT"].write_comment("2D mean quasar continuum (z, loglam)") - results["CONT"].write_checksum() diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py new file mode 100644 index 000000000..4aae82e01 --- /dev/null +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -0,0 +1,316 @@ +"""This module defines the class MeanContinuumInterpExpectedFlux""" +import logging + +import numpy as np +from scipy.interpolate import interp1d, RegularGridInterpolator + +from picca.delta_extraction.errors import ExpectedFluxError +from picca.delta_extraction.astronomical_objects.forest import Forest +from picca.delta_extraction.expected_fluxes.dr16_expected_flux import Dr16ExpectedFlux, defaults, accepted_options +from picca.delta_extraction.utils import (update_accepted_options, + update_default_options, + ABSORBER_IGM) + +accepted_options = update_accepted_options(accepted_options, [ + "limit z", "num z bins" +]) + +defaults = update_default_options( + defaults, { + "limit z": (1.94, 4.5), + "num z bins": 10, + }) + +ACCEPTED_INTERPOLATION_TYPES = ["1D", "2D"] + +class MeanContinuumInterpExpectedFlux(Dr16ExpectedFlux): + """Class to the expected flux as done in the DR16 SDSS analysys + The mean expected flux is calculated iteratively as explained in + du Mas des Bourboux et al. (2020) except that the we don't use + the stacking technique to compute the mean quasar continuum. + Instead, we build an interpolator. + + Additionally, the mean continuum can be computed in 2D, i.e. the + mean continuum is computed as a function of both the wavelength and + the redshift. + + Methods + ------- + (see Dr16ExpectedFlux in py/picca/delta_extraction/expected_fluxes/dr16_expected_flux.py) + + Attributes + ---------- + (see Dr16ExpectedFlux in py/picca/delta_extraction/expected_fluxes/dr16_expected_flux.py) + + get_mean_cont: scipy.interpolate.interp1d or scipy.interpolate.RegularGridInterpolator + Interpolation function to compute the unabsorbed mean quasar continua. + + lambda_abs_igm: float + Wavelength in Angstroms at which the IGM absorption is computed. + + limit_z: tuple of float + Minimum and maximum redshift limits for the analysis. + + num_z_bins: int + Number of redshift bins to use for the analysis. + + z_bins: np.ndarray + Bins in redshift used to compute the mean continuum. + + z_centers: np.ndarray + Centers of the redshift bins used to compute the mean continuum. + This is used to interpolate the mean continuum and its weights. + """ + + def __init__(self, config): + """Initialize class instance. + + Arguments + --------- + config: configparser.SectionProxy + Parsed options to initialize class + + Raise + ----- + ExpectedFluxError if Forest class variables are not set + """ + self.logger = logging.getLogger(__name__) + + # load variables from config + self.interpolation_type = None + self.limit_z = None + self.num_z_bins = None + self.z_bins = None + self.z_centers = None + self.__parse_config(config) + + super().__init__(config) + + self.mean_cont = None + + def __parse_config(self, config): + """Parse the configuration options + + Arguments + --------- + config: configparser.SectionProxy + Parsed options to initialize class + + Raises + ------ + ExpectedFluxError if variables are not valid + """ + + # this one needs to go first, as it constrains some of the other + self.interpolation_type = config.get("interpolation type") + if self.interpolation_type is None: + raise ExpectedFluxError( + "Missing argument 'interpolation type' required by MeanContinuum2dExpectedFlux") + if self.interpolation_type not in ACCEPTED_INTERPOLATION_TYPES: + raise ExpectedFluxError( + f"Invalid interpolation type '{self.interpolation_type}' " + f"required by MeanContinuum2dExpectedFlux. " + f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") + + if self.interpolation_type == "2D": + limit_z_string = config.get("limit z") + if limit_z_string is None: + raise ExpectedFluxError( + "Missing argument 'limit z' required by MeanContinuum2dExpectedFlux") + limit_z = limit_z_string.split(",") + if limit_z[0].startswith("(") or limit_z[0].startswith("["): + z_min = float(limit_z[0][1:]) + else: + z_min = float(limit_z[0]) + if limit_z[1].endswith(")") or limit_z[1].endswith("]"): + z_max = float(limit_z[1][:-1]) + else: + z_max = float(limit_z[1]) + self.limit_z = (z_min, z_max) + + num_z_bins = config.getint("num z bins") + if num_z_bins is None or num_z_bins < 1: + raise ExpectedFluxError( + "Missing argument 'num z bins' required by MeanContinuum2dExpectedFlux") + self.num_z_bins = num_z_bins + + self.z_bins = np.linspace(self.limit_z[0], self.limit_z[1], + self.num_z_bins + 1) + self.z_centers = (self.z_bins[:-1] + self.z_bins[1:]) / 2 + + def _initialize_mean_continuum_arrays(self): + """Initialize mean continuum arrays + The initialized arrays are: + - self.get_mean_cont + """ + # TODO: this should be replaced by a method that computes the interpolation + # using the interp_coeff_lambda function for consistency but we need to + # figure out how to solve clashes with the method compute_continuum in + # picca.delta_extraction.expected_fluxes.utils + # + # initialize the mean quasar continuum + if self.interpolation_type == "2D": + mean_cont = np.ones( + (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) + mean_cont_weight = np.zeros( + (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) + + self.get_mean_cont = RegularGridInterpolator( + (self.z_centers, Forest.log_lambda_rest_frame_grid), mean_cont, bounds_error=False, fill_value=0.0 + ) + elif self.interpolation_type == "1D": + mean_cont = np.ones(Forest.log_lambda_rest_frame_grid.size) + mean_cont_weight = np.zeros(Forest.log_lambda_rest_frame_grid.size) + + self.get_mean_cont = interp1d( + Forest.log_lambda_rest_frame_grid, + mean_cont, + fill_value='extrapolate' + ) + # this should never happen, but just in case + else: # pragma: no cover + raise ExpectedFluxError( + f"Invalid interpolation type '{self.interpolation_type}' " + f"required by MeanContinuum2dExpectedFlux. " + f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") + + def compute_mean_cont(self, forests, which_cont=lambda forest: forest.continuum): + """Compute the mean quasar continuum over the whole sample. + Then updates the value of self.get_mean_cont to contain it + + Arguments + --------- + forests: List of Forest + A list of Forest from which to compute the deltas. + + which_cont: Function or lambda + Should return what to use as continuum given a forest + """ + if self.interpolation_type == "1D": + self.compute_mean_cont_1d(forests, which_cont) + elif self.interpolation_type == "2D": + raise NotImplementedError( + "2D interpolation is not implemented yet in MeanContinuum2dExpectedFlux. " + "Please use 1D interpolation instead.") + # this should never happen, but just in case + else: # pragma: no cover + raise ExpectedFluxError( + f"Invalid interpolation type '{self.interpolation_type}' " + f"required by MeanContinuum2dExpectedFlux. " + f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") + + def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continuum): + """Compute the mean quasar continuum over the whole sample. + Then updates the value of self.get_mean_cont to contain it + The mean continuum is computed as a function of the rest-frame + wavelength. + + Arguments + --------- + forests: List of Forest + A list of Forest from which to compute the deltas. + + which_cont: Function or lambda + Should return what to use as continuum given a forest + """ + A_matrix = np.zeros( + (Forest.log_lambda_rest_frame_grid.size, Forest.log_lambda_rest_frame_grid.size) + ) + B_matrix = np.zeros(Forest.log_lambda_rest_frame_grid.size) + + for forest in forests: + if forest.bad_continuum_reason is not None: + continue + + log_lambda_rf = forest.log_lambda - np.log10(1 + forest.z) + weights = self.compute_forest_weights(forest, forest.continuum) + coeffs, rf_wavelength_bin = interp_coeff_lambda( + log_lambda_rf, + Forest.log_lambda_rest_frame_grid) + + w = np.where(forest.continuum > 0) + B_matrix[rf_wavelength_bin[w]] += weights[w] * coeffs[w] * forest.flux[w] / forest.continuum[w] + + w = np.where((forest.continuum > 0) & (rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1)) + B_matrix[rf_wavelength_bin[w] + 1] += weights[w] * (1 - coeffs[w]) * forest.flux[w] / forest.continuum[w] + + A_matrix[rf_wavelength_bin, rf_wavelength_bin] += weights * coeffs * coeffs + w = np.where(rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1) + A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weights[w] * coeffs[w] * (1 - coeffs[w]) + A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weights[w] * coeffs[w] * (1 - coeffs[w]) + A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weights[w] * (1 - coeffs[w]) * (1 - coeffs[w]) + + + # Take care of unstable solutions + # If the diagonal of A_matrix is zero, we set it to 1.0 + # This is a workaround for the case where there is no coverage + # for some wavelengths. + w = np.diagonal(A_matrix) == 0 + A_matrix[w, w] = 1.0 + + # Solve the linear system A_matrix * mean_cont = B_matrix + mean_cont = np.linalg.solve(A_matrix, B_matrix) + + # TODO: this should be replaced by a method that computes the interpolation + # using the interp_coeff_lambda function for consistency but we need to + # figure out how to solve clashes with the method compute_continuum in + # picca.delta_extraction.expected_fluxes.utils + # + # update the interpolator with the mean continuum + self.get_mean_cont = interp1d( + Forest.log_lambda_rest_frame_grid, + mean_cont, + fill_value='extrapolate' + ) + + def hdu_cont(self, results): + """Add to the results file an HDU with the continuum information + + Arguments + --------- + results: fitsio.FITS + The open fits file + """ + # Create meshgrid for evaluation + z_meshgrid, log_lam_mesh_grid = np.meshgrid(self.z_centers, Forest.log_lambda_rest_frame_grid, indexing='ij') + points = np.stack([z_meshgrid.ravel(), log_lam_mesh_grid.ravel()], axis=-1) + mean_cont_2d = self.get_mean_cont(points).reshape(z_meshgrid.shape) + + results.write([ + z_meshgrid, + log_lam_mesh_grid, + mean_cont_2d, + ], + names=['Z_CENTERS', 'LOGLAM_REST', 'MEAN_CONT'], + units=['', 'log(Angstrom)', Forest.flux_units, ''], + extname='CONT') + results["CONT"].write_comment("2D mean quasar continuum (z, loglam)") + results["CONT"].write_checksum() + + +@numba.njit() +def interp_coeff_lambda(rf_wavelength, rf_wavelength_grid): + """Compute the interpolation coefficients for a given rest-frame wavelength. + + Arguments + --------- + rf_wavelength: float + Rest-frame wavelength in Angstroms + rf_wavelength_grid: np.ndarray + Rest-frame wavelength nodes where the interpolation is defined + + Returns + ------- + coeff: np.ndarray + Interpolation coefficients for the given rest-frame wavelength + + rf_wavelength_bin: int or np.ndarray + Indices of the rf_wavelength bins for the given rf_wavelength value + """ + rf_wavelength_bin = np.digitize(rf_wavelength, rf_wavelength_grid) - 1 + rf_wavelength_low = rf_wavelength_grid[rf_wavelength_bin] + rf_wavelength_high = rf_wavelength_grid[rf_wavelength_bin + 1] + + coeff = (rf_wavelength_high - rf_wavelength) / (rf_wavelength_high - rf_wavelength_low) + + return coeff, rf_wavelength_bin \ No newline at end of file From 38a5c7143f4560614257d75d2f22a2b5cfdbf28f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 11:15:57 +0200 Subject: [PATCH 12/59] Added default values --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 4aae82e01..51d04e577 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -12,11 +12,12 @@ ABSORBER_IGM) accepted_options = update_accepted_options(accepted_options, [ - "limit z", "num z bins" + "interpolation type", "limit z", "num z bins" ]) defaults = update_default_options( defaults, { + "interpolation type": "1D", "limit z": (1.94, 4.5), "num z bins": 10, }) From 6416233475c30d109ed7a4ad6fa8e6d1d267f934 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 11:20:45 +0200 Subject: [PATCH 13/59] added missing import --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 1 + 1 file changed, 1 insertion(+) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 51d04e577..f32f3c8c1 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -1,6 +1,7 @@ """This module defines the class MeanContinuumInterpExpectedFlux""" import logging +import numba import numpy as np from scipy.interpolate import interp1d, RegularGridInterpolator From e37821a0d5b2eee6176b2e9118e303b3772a9d7d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 11:28:01 +0200 Subject: [PATCH 14/59] fixed writing function --- .../mean_continuum_interp_expected_flux.py | 39 ++++++++++++------- 1 file changed, 24 insertions(+), 15 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index f32f3c8c1..ea1816d6c 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -273,21 +273,30 @@ def hdu_cont(self, results): results: fitsio.FITS The open fits file """ - # Create meshgrid for evaluation - z_meshgrid, log_lam_mesh_grid = np.meshgrid(self.z_centers, Forest.log_lambda_rest_frame_grid, indexing='ij') - points = np.stack([z_meshgrid.ravel(), log_lam_mesh_grid.ravel()], axis=-1) - mean_cont_2d = self.get_mean_cont(points).reshape(z_meshgrid.shape) - - results.write([ - z_meshgrid, - log_lam_mesh_grid, - mean_cont_2d, - ], - names=['Z_CENTERS', 'LOGLAM_REST', 'MEAN_CONT'], - units=['', 'log(Angstrom)', Forest.flux_units, ''], - extname='CONT') - results["CONT"].write_comment("2D mean quasar continuum (z, loglam)") - results["CONT"].write_checksum() + if self.interpolation_type != "2D": + # Create meshgrid for evaluation + z_meshgrid, log_lam_mesh_grid = np.meshgrid(self.z_centers, Forest.log_lambda_rest_frame_grid, indexing='ij') + points = np.stack([z_meshgrid.ravel(), log_lam_mesh_grid.ravel()], axis=-1) + mean_cont_2d = self.get_mean_cont(points).reshape(z_meshgrid.shape) + + results.write([ + z_meshgrid, + log_lam_mesh_grid, + mean_cont_2d, + ], + names=['Z_CENTERS', 'LOGLAM_REST', 'MEAN_CONT'], + units=['', 'log(Angstrom)', Forest.flux_units, ''], + extname='CONT') + results["CONT"].write_comment("2D mean quasar continuum (z, loglam)") + results["CONT"].write_checksum() + elif self.interpolation_type == "1D": + super().hdu_cont(results) + # this should never happen, but just in case + else: # pragma: no cover + raise ExpectedFluxError( + f"Invalid interpolation type '{self.interpolation_type}' " + f"required by MeanContinuum2dExpectedFlux. " + f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") @numba.njit() From 9d8d8a62fb106dcb15629101e5fa24facff1ed97 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 11:42:12 +0200 Subject: [PATCH 15/59] fixed minor bug --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index ea1816d6c..d8dc83722 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -273,7 +273,7 @@ def hdu_cont(self, results): results: fitsio.FITS The open fits file """ - if self.interpolation_type != "2D": + if self.interpolation_type == "2D": # Create meshgrid for evaluation z_meshgrid, log_lam_mesh_grid = np.meshgrid(self.z_centers, Forest.log_lambda_rest_frame_grid, indexing='ij') points = np.stack([z_meshgrid.ravel(), log_lam_mesh_grid.ravel()], axis=-1) From 2939e865a906419e2b392d9cfa2cd92363c107e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 11:57:21 +0200 Subject: [PATCH 16/59] fixed hdu_cont for the 1d case --- .../mean_continuum_interp_expected_flux.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index d8dc83722..547c43a6a 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -201,6 +201,7 @@ def compute_mean_cont(self, forests, which_cont=lambda forest: forest.continuum) f"required by MeanContinuum2dExpectedFlux. " f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") + # TODO: numbaize this function def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continuum): """Compute the mean quasar continuum over the whole sample. Then updates the value of self.get_mean_cont to contain it @@ -290,8 +291,16 @@ def hdu_cont(self, results): results["CONT"].write_comment("2D mean quasar continuum (z, loglam)") results["CONT"].write_checksum() elif self.interpolation_type == "1D": - super().hdu_cont(results) - # this should never happen, but just in case + results.write([ + Forest.log_lambda_rest_frame_grid, + self.get_mean_cont(Forest.log_lambda_rest_frame_grid), + ], + names=['LOGLAM_REST', 'MEAN_CONT'], + units=['log(Angstrom)', Forest.flux_units, ''], + extname='CONT') + results["CONT"].write_comment("Mean quasar continuum") + results["CONT"].write_checksum() + # this should never happen, but just in case else: # pragma: no cover raise ExpectedFluxError( f"Invalid interpolation type '{self.interpolation_type}' " From e65b7cedfa75abc38aacd5fa78c4ac2d72fb7dad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 12:15:55 +0200 Subject: [PATCH 17/59] fixed a minor bug in hdu_cont --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 547c43a6a..6ee620aad 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -296,7 +296,7 @@ def hdu_cont(self, results): self.get_mean_cont(Forest.log_lambda_rest_frame_grid), ], names=['LOGLAM_REST', 'MEAN_CONT'], - units=['log(Angstrom)', Forest.flux_units, ''], + units=['log(Angstrom)', Forest.flux_units], extname='CONT') results["CONT"].write_comment("Mean quasar continuum") results["CONT"].write_checksum() From f58d41d735d715ab4bd65af25bf9fd814c12b318 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 14:23:32 +0200 Subject: [PATCH 18/59] test to update the get_mean_cont_method --- .../mean_continuum_interp_expected_flux.py | 68 ++++++++++++++----- 1 file changed, 52 insertions(+), 16 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 6ee620aad..39ff3b951 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -154,21 +154,18 @@ def _initialize_mean_continuum_arrays(self): if self.interpolation_type == "2D": mean_cont = np.ones( (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) - mean_cont_weight = np.zeros( - (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) self.get_mean_cont = RegularGridInterpolator( (self.z_centers, Forest.log_lambda_rest_frame_grid), mean_cont, bounds_error=False, fill_value=0.0 ) elif self.interpolation_type == "1D": - mean_cont = np.ones(Forest.log_lambda_rest_frame_grid.size) - mean_cont_weight = np.zeros(Forest.log_lambda_rest_frame_grid.size) - - self.get_mean_cont = interp1d( - Forest.log_lambda_rest_frame_grid, - mean_cont, - fill_value='extrapolate' - ) + self.mean_cont = np.ones(Forest.log_lambda_rest_frame_grid.size) + + #self.get_mean_cont = interp1d( + # Forest.log_lambda_rest_frame_grid, + # self.mean_cont, + # fill_value='extrapolate' + #) # this should never happen, but just in case else: # pragma: no cover raise ExpectedFluxError( @@ -252,7 +249,7 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu A_matrix[w, w] = 1.0 # Solve the linear system A_matrix * mean_cont = B_matrix - mean_cont = np.linalg.solve(A_matrix, B_matrix) + self.mean_cont = np.linalg.solve(A_matrix, B_matrix) # TODO: this should be replaced by a method that computes the interpolation # using the interp_coeff_lambda function for consistency but we need to @@ -260,11 +257,50 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu # picca.delta_extraction.expected_fluxes.utils # # update the interpolator with the mean continuum - self.get_mean_cont = interp1d( - Forest.log_lambda_rest_frame_grid, - mean_cont, - fill_value='extrapolate' - ) + #self.get_mean_cont = interp1d( + # Forest.log_lambda_rest_frame_grid, + # self.mean_cont, + # fill_value='extrapolate' + #) + + def get_mean_cont(self, points): + """Get the mean continuum at the given points + + Arguments + --------- + points: np.ndarray + Points where to evaluate the mean continuum. + If interpolation_type == "2D", it should be of shape + (N, 2) where N is the number of points and the two columns are the redshift + and the log wavelength in Angstroms. + If interpolation_type == "1D", it should be of shape (N,) where N is the number + of points and the values are the log wavelength in Angstroms. + + Returns + ------- + np.ndarray + The mean continuum at the given points. + """ + if self.interpolation_type == "2D": + raise NotImplementedError( + "2D interpolation is not implemented yet in MeanContinuum2dExpectedFlux. " + "Please use 1D interpolation instead.") + elif self.interpolation_type == "1D": + coeffs, rf_wavelength_bin = interp_coeff_lambda( + points, + Forest.log_lambda_rest_frame_grid) + + mean_cont = self.mean_cont[rf_wavelength_bin] * coeffs + \ + self.mean_cont[rf_wavelength_bin + 1] * (1 - coeffs) + + # this should never happen, but just in case + else: # pragma: no cover + raise ExpectedFluxError( + f"Invalid interpolation type '{self.interpolation_type}' " + f"required by MeanContinuum2dExpectedFlux. " + f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") + + return mean_cont def hdu_cont(self, results): """Add to the results file an HDU with the continuum information From 14a990afd6f223d21777c2c3475089b721dbf615 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 14:33:03 +0200 Subject: [PATCH 19/59] second test to fix that --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 39ff3b951..41b600e38 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -166,6 +166,7 @@ def _initialize_mean_continuum_arrays(self): # self.mean_cont, # fill_value='extrapolate' #) + self.get_mean_cont = self.get_mean_cont_aux # this should never happen, but just in case else: # pragma: no cover raise ExpectedFluxError( @@ -263,7 +264,10 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu # fill_value='extrapolate' #) - def get_mean_cont(self, points): + # TODO: fix naming of this function + # Currently it clashes with the initialization of the class + # due to the __init__ method from the parent class + def get_mean_cont_aux(self, points): """Get the mean continuum at the given points Arguments From b319e985c098b0578042224f0598300e08b406ae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 14:39:51 +0200 Subject: [PATCH 20/59] third attempt --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 41b600e38..c0ccb6953 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -86,9 +86,9 @@ def __init__(self, config): self.z_centers = None self.__parse_config(config) + self.mean_cont = None super().__init__(config) - self.mean_cont = None def __parse_config(self, config): """Parse the configuration options @@ -263,6 +263,7 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu # self.mean_cont, # fill_value='extrapolate' #) + self.get_mean_cont = self.get_mean_cont_aux # TODO: fix naming of this function # Currently it clashes with the initialization of the class From ece6b61fcaa51774aad1381907c3c1b0d7c252b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 14:56:18 +0200 Subject: [PATCH 21/59] fixed boundary issues --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index c0ccb6953..4a78551e3 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -295,8 +295,9 @@ def get_mean_cont_aux(self, points): points, Forest.log_lambda_rest_frame_grid) - mean_cont = self.mean_cont[rf_wavelength_bin] * coeffs + \ - self.mean_cont[rf_wavelength_bin + 1] * (1 - coeffs) + mean_cont = self.mean_cont[rf_wavelength_bin] * coeffs + w = np.where(rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1) + mean_cont[w] += self.mean_cont[rf_wavelength_bin[w] + 1] * (1 - coeffs[w]) # this should never happen, but just in case else: # pragma: no cover From 997a5ed3d57d5feec0af1aaa67523b3e3c42fcff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 16:32:13 +0200 Subject: [PATCH 22/59] numbaized and parallelized function --- .../mean_continuum_interp_expected_flux.py | 161 ++++++++++-------- 1 file changed, 94 insertions(+), 67 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 4a78551e3..f7feb80ac 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -1,5 +1,6 @@ """This module defines the class MeanContinuumInterpExpectedFlux""" import logging +import multiprocessing import numba import numpy as np @@ -145,11 +146,6 @@ def _initialize_mean_continuum_arrays(self): The initialized arrays are: - self.get_mean_cont """ - # TODO: this should be replaced by a method that computes the interpolation - # using the interp_coeff_lambda function for consistency but we need to - # figure out how to solve clashes with the method compute_continuum in - # picca.delta_extraction.expected_fluxes.utils - # # initialize the mean quasar continuum if self.interpolation_type == "2D": mean_cont = np.ones( @@ -161,11 +157,11 @@ def _initialize_mean_continuum_arrays(self): elif self.interpolation_type == "1D": self.mean_cont = np.ones(Forest.log_lambda_rest_frame_grid.size) - #self.get_mean_cont = interp1d( - # Forest.log_lambda_rest_frame_grid, - # self.mean_cont, - # fill_value='extrapolate' - #) + self.get_mean_cont = interp1d( + Forest.log_lambda_rest_frame_grid, + self.mean_cont, + fill_value='extrapolate' + ) self.get_mean_cont = self.get_mean_cont_aux # this should never happen, but just in case else: # pragma: no cover @@ -199,7 +195,6 @@ def compute_mean_cont(self, forests, which_cont=lambda forest: forest.continuum) f"required by MeanContinuum2dExpectedFlux. " f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") - # TODO: numbaize this function def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continuum): """Compute the mean quasar continuum over the whole sample. Then updates the value of self.get_mean_cont to contain it @@ -219,6 +214,48 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu ) B_matrix = np.zeros(Forest.log_lambda_rest_frame_grid.size) + context = multiprocessing.get_context('fork') + with context.Pool(processes=self.num_processors) as pool: + arguments = [( + Forest.log_lambda_rest_frame_grid, + forest.log_lambda, + forest.flux, + forest.continuum, + forest.z, + self.compute_forest_weights(forest, forest.continuum) + ) + for forest in forests if forest.bad_continuum_reason is None] + imap_it = pool.starmap(compute_mean_cont_1d, arguments) + + for partial_A_matrix, partial_B_matrix in imap_it: + A_matrix += partial_A_matrix + B_matrix += partial_B_matrix + + # Take care of unstable solutions + # If the diagonal of A_matrix is zero, we set it to 1.0 + # This is a workaround for the case where there is no coverage + # for some wavelengths. + w = np.diagonal(A_matrix) == 0 + A_matrix[w, w] = 1.0 + + # Solve the linear system A_matrix * mean_cont = B_matrix + self.mean_cont = np.linalg.solve(A_matrix, B_matrix) + + # update the interpolator with the mean continuum + self.get_mean_cont = interp1d( + Forest.log_lambda_rest_frame_grid, + self.mean_cont, + fill_value='extrapolate' + ) + + return + + # Old implementation without numba and without parallelization + A_matrix = np.zeros( + (Forest.log_lambda_rest_frame_grid.size, Forest.log_lambda_rest_frame_grid.size) + ) + B_matrix = np.zeros(Forest.log_lambda_rest_frame_grid.size) + for forest in forests: if forest.bad_continuum_reason is not None: continue @@ -251,62 +288,13 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu # Solve the linear system A_matrix * mean_cont = B_matrix self.mean_cont = np.linalg.solve(A_matrix, B_matrix) - - # TODO: this should be replaced by a method that computes the interpolation - # using the interp_coeff_lambda function for consistency but we need to - # figure out how to solve clashes with the method compute_continuum in - # picca.delta_extraction.expected_fluxes.utils - # - # update the interpolator with the mean continuum - #self.get_mean_cont = interp1d( - # Forest.log_lambda_rest_frame_grid, - # self.mean_cont, - # fill_value='extrapolate' - #) - self.get_mean_cont = self.get_mean_cont_aux - - # TODO: fix naming of this function - # Currently it clashes with the initialization of the class - # due to the __init__ method from the parent class - def get_mean_cont_aux(self, points): - """Get the mean continuum at the given points - - Arguments - --------- - points: np.ndarray - Points where to evaluate the mean continuum. - If interpolation_type == "2D", it should be of shape - (N, 2) where N is the number of points and the two columns are the redshift - and the log wavelength in Angstroms. - If interpolation_type == "1D", it should be of shape (N,) where N is the number - of points and the values are the log wavelength in Angstroms. - - Returns - ------- - np.ndarray - The mean continuum at the given points. - """ - if self.interpolation_type == "2D": - raise NotImplementedError( - "2D interpolation is not implemented yet in MeanContinuum2dExpectedFlux. " - "Please use 1D interpolation instead.") - elif self.interpolation_type == "1D": - coeffs, rf_wavelength_bin = interp_coeff_lambda( - points, - Forest.log_lambda_rest_frame_grid) - - mean_cont = self.mean_cont[rf_wavelength_bin] * coeffs - w = np.where(rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1) - mean_cont[w] += self.mean_cont[rf_wavelength_bin[w] + 1] * (1 - coeffs[w]) - - # this should never happen, but just in case - else: # pragma: no cover - raise ExpectedFluxError( - f"Invalid interpolation type '{self.interpolation_type}' " - f"required by MeanContinuum2dExpectedFlux. " - f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") - return mean_cont + # update the interpolator with the mean continuum + self.get_mean_cont = interp1d( + Forest.log_lambda_rest_frame_grid, + self.mean_cont, + fill_value='extrapolate' + ) def hdu_cont(self, results): """Add to the results file an HDU with the continuum information @@ -375,4 +363,43 @@ def interp_coeff_lambda(rf_wavelength, rf_wavelength_grid): coeff = (rf_wavelength_high - rf_wavelength) / (rf_wavelength_high - rf_wavelength_low) - return coeff, rf_wavelength_bin \ No newline at end of file + return coeff, rf_wavelength_bin + +@numba.njit() +def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, continuum, redshift, weight): + """Compute the mean quasar continuum over the whole sample. + Then updates the value of self.get_mean_cont to contain it + The mean continuum is computed as a function of the rest-frame + wavelength. + + Arguments + --------- + log_lambda_rest_frame_grid: np.ndarray + A 1D array of rest-frame wavelengths (in Angstroms) where the continuum is defined. + + which_cont: Function or lambda + Should return what to use as continuum given a forest + """ + A_matrix = np.zeros( + (log_lambda_rest_frame_grid.size, log_lambda_rest_frame_grid.size) + ) + B_matrix = np.zeros(log_lambda_rest_frame_grid.size) + + log_lambda_rf = log_lambda - np.log10(1 + redshift) + coeffs, rf_wavelength_bin = interp_coeff_lambda( + log_lambda_rf, + log_lambda_rest_frame_grid) + + w = np.where(continuum > 0) + B_matrix[rf_wavelength_bin[w]] += weight[w] * coeffs[w] * flux[w] / continuum[w] + + w = np.where((continuum > 0) & (rf_wavelength_bin < log_lambda_rest_frame_grid.size - 1)) + B_matrix[rf_wavelength_bin[w] + 1] += weight[w] * (1 - coeffs[w]) * flux[w] / continuum[w] + + A_matrix[rf_wavelength_bin, rf_wavelength_bin] += weight * coeffs * coeffs + w = np.where(rf_wavelength_bin < log_lambda_rest_frame_grid.size - 1) + A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weight[w] * coeffs[w] * (1 - coeffs[w]) + A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weight[w] * coeffs[w] * (1 - coeffs[w]) + A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weight[w] * (1 - coeffs[w]) * (1 - coeffs[w]) + + return A_matrix, B_matrix \ No newline at end of file From 17061d05a35db76eb5dbaa60470516a28b80e83f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 16:48:56 +0200 Subject: [PATCH 23/59] fixed forgotten removal --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 1 - 1 file changed, 1 deletion(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index f7feb80ac..8421728fc 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -162,7 +162,6 @@ def _initialize_mean_continuum_arrays(self): self.mean_cont, fill_value='extrapolate' ) - self.get_mean_cont = self.get_mean_cont_aux # this should never happen, but just in case else: # pragma: no cover raise ExpectedFluxError( From 8d5362b47fe72340573d043f1503faf2bce02f43 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 22 Jul 2025 17:13:47 +0200 Subject: [PATCH 24/59] fixed numba indexing --- .../mean_continuum_interp_expected_flux.py | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 8421728fc..67b323700 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -395,10 +395,19 @@ def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, continuum w = np.where((continuum > 0) & (rf_wavelength_bin < log_lambda_rest_frame_grid.size - 1)) B_matrix[rf_wavelength_bin[w] + 1] += weight[w] * (1 - coeffs[w]) * flux[w] / continuum[w] - A_matrix[rf_wavelength_bin, rf_wavelength_bin] += weight * coeffs * coeffs + # diagonal elements + #A_matrix[rf_wavelength_bin, rf_wavelength_bin] += weight * coeffs * coeffs + for index in range(rf_wavelength_bin.size): + A_matrix[rf_wavelength_bin[index], rf_wavelength_bin[index]] += weight[index] * coeffs[index] * coeffs[index] + + # Off-diagonal elements w = np.where(rf_wavelength_bin < log_lambda_rest_frame_grid.size - 1) - A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weight[w] * coeffs[w] * (1 - coeffs[w]) - A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weight[w] * coeffs[w] * (1 - coeffs[w]) - A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weight[w] * (1 - coeffs[w]) * (1 - coeffs[w]) + for index in w[0]: + A_matrix[rf_wavelength_bin[index] + 1, rf_wavelength_bin[index]] += weight[index] * coeffs[index] * (1 - coeffs[index]) + A_matrix[rf_wavelength_bin[index], rf_wavelength_bin[index] + 1] += weight[index] * coeffs[index] * (1 - coeffs[index]) + A_matrix[rf_wavelength_bin[index] + 1, rf_wavelength_bin[index] + 1] += weight[index] * (1 - coeffs[index]) * (1 - coeffs[index]) + #A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weight[w] * coeffs[w] * (1 - coeffs[w]) + #A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weight[w] * coeffs[w] * (1 - coeffs[w]) + #A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weight[w] * (1 - coeffs[w]) * (1 - coeffs[w]) return A_matrix, B_matrix \ No newline at end of file From 08cf727269f6504a4998ef222ae6dc99b29b273c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 23 Jul 2025 11:58:43 +0200 Subject: [PATCH 25/59] restored non-numbaized version as there are memory issues --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 67b323700..7e0c22895 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -208,6 +208,9 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu which_cont: Function or lambda Should return what to use as continuum given a forest """ + + """ + # numba implementation shows a memory leak when using A_matrix = np.zeros( (Forest.log_lambda_rest_frame_grid.size, Forest.log_lambda_rest_frame_grid.size) ) @@ -248,7 +251,7 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu ) return - + """ # Old implementation without numba and without parallelization A_matrix = np.zeros( (Forest.log_lambda_rest_frame_grid.size, Forest.log_lambda_rest_frame_grid.size) @@ -364,6 +367,7 @@ def interp_coeff_lambda(rf_wavelength, rf_wavelength_grid): return coeff, rf_wavelength_bin + @numba.njit() def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, continuum, redshift, weight): """Compute the mean quasar continuum over the whole sample. From 91585b92660c4a6a443a850c6d331de5c36a3c93 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Mon, 28 Jul 2025 09:55:08 +0200 Subject: [PATCH 26/59] first attempt at the 2D extension --- .../mean_continuum_interp_expected_flux.py | 133 +++++++++++++++++- 1 file changed, 126 insertions(+), 7 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 7e0c22895..705ca6245 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -152,7 +152,8 @@ def _initialize_mean_continuum_arrays(self): (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) self.get_mean_cont = RegularGridInterpolator( - (self.z_centers, Forest.log_lambda_rest_frame_grid), mean_cont, bounds_error=False, fill_value=0.0 + (self.z_centers, Forest.log_lambda_rest_frame_grid), + mean_cont, bounds_error=False, fill_value='extrapolate' ) elif self.interpolation_type == "1D": self.mean_cont = np.ones(Forest.log_lambda_rest_frame_grid.size) @@ -184,9 +185,7 @@ def compute_mean_cont(self, forests, which_cont=lambda forest: forest.continuum) if self.interpolation_type == "1D": self.compute_mean_cont_1d(forests, which_cont) elif self.interpolation_type == "2D": - raise NotImplementedError( - "2D interpolation is not implemented yet in MeanContinuum2dExpectedFlux. " - "Please use 1D interpolation instead.") + self.compute_mean_cont_2d(forests, which_cont) # this should never happen, but just in case else: # pragma: no cover raise ExpectedFluxError( @@ -298,6 +297,98 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu fill_value='extrapolate' ) + def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continuum): + """Compute the mean quasar continuum over the whole sample. + Then updates the value of self.get_mean_cont to contain it + The mean continuum is computed as a function of the rest-frame + wavelength and redshift. + + Arguments + --------- + forests: List of Forest + A list of Forest from which to compute the deltas. + + which_cont: Function or lambda + Should return what to use as continuum given a forest + """ + # for simplicity we introduce a new index + # combined_bin = z_bin + N_z_bins * rf_wavelength_bin + # where z_bin is the index of the redshift bin and rf_wavelength_bin + # is the index of the rest-frame wavelength bin. + # This allows us to use a similar logic as in the 1D case. + matrix_size = Forest.n_z_bins * Forest.log_lambda_rest_frame_grid.size + + A_matrix = np.zeros( + (matrix_size, matrix_size) + ) + B_matrix = np.zeros(matrix_size) + + for forest in forests: + if forest.bad_continuum_reason is not None: + continue + + log_lambda_rf = forest.log_lambda - np.log10(1 + forest.z) + weights = self.compute_forest_weights(forest, forest.continuum) + rf_wavelength_coeffs, rf_wavelength_bin = interp_coeff_lambda( + log_lambda_rf, + Forest.log_lambda_rest_frame_grid) + z_coeffs, z_bin = interp_coeff_z( + forest.z, + self.z_centers) + z_coeffs = np.repeat(z_coeffs, Forest.log_lambda_rest_frame_grid.size) + + # combined_bin is the index of the bin in the 2D matrix + combined_bin = z_bin + self.num_z_bins * rf_wavelength_bin + combined_bin_plus_wavelength = z_bin + self.num_z_bins * (rf_wavelength_bin + 1) + combined_bin_plus_z = z_bin + 1 + self.num_z_bins * (rf_wavelength_bin) + combined_bin_plus_both = z_bin + 1 + self.num_z_bins * (rf_wavelength_bin + 1) + + # Fill the B_matrix + # diagonal elements + w = np.where(forest.continuum > 0) + B_matrix[combined_bin[w]] += weights[w] * z_coeffs[w] * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w] + # off-diagonal elements + w = np.where((forest.continuum > 0) & (combined_bin_plus_wavelength < matrix_size - 1)) + B_matrix[combined_bin_plus_wavelength[w] + 1] += weights[w] * z_coeffs[w] * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w] + w = np.where((forest.continuum > 0) & (combined_bin_plus_z < matrix_size - 1)) + B_matrix[combined_bin_plus_z[w] + 1] += weights[w] * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w] + w = np.where((forest.continuum > 0) & (combined_bin_plus_both < matrix_size - 1)) + B_matrix[combined_bin_plus_both[w] + 1] += weights[w] * (1 - z_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w] + + # Fill the A_matrix + # diagonal elements + A_matrix[combined_bin, combined_bin] += weights * z_coeffs * z_coeffs * rf_wavelength_coeffs * rf_wavelength_coeffs + # off-diagonal elements + w = np.where(combined_bin_plus_wavelength < matrix_size - 1) + A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += weights[w] * z_coeffs[w] * z_coeffs[w] * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs[w] * z_coeffs[w] * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs[w] * z_coeffs[w] * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) + w = np.where(combined_bin_plus_z < matrix_size - 1) + A_matrix[combined_bin_plus_z[w], combined_bin[w]] += weights[w] * z_coeffs[w] * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + A_matrix[combined_bin[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs[w] * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_z[w], combined_bin_plus_z[w]] += weights[w] * (1 - z_coeffs[w]) * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + w = np.where(combined_bin_plus_both < matrix_size - 1) + A_matrix[combined_bin_plus_both[w], combined_bin[w]] += weights[w] * z_coeffs[w] * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs[w] * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_both[w], combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs[w]) * (1 - z_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) + + + # Take care of unstable solutions + # If the diagonal of A_matrix is zero, we set it to 1.0 + # This is a workaround for the case where there is no coverage + # for some wavelengths. + w = np.diagonal(A_matrix) == 0 + A_matrix[w, w] = 1.0 + + # Solve the linear system A_matrix * mean_cont = B_matrix + self.mean_cont = np.linalg.solve(A_matrix, B_matrix) + + # update the interpolator with the mean continuum + self.get_mean_cont = RegularGridInterpolator( + (self.z_centers, Forest.log_lambda_rest_frame_grid), + self.mean_cont, bounds_error=False, fill_value='extrapolate', + ) + def hdu_cont(self, results): """Add to the results file an HDU with the continuum information @@ -346,10 +437,11 @@ def interp_coeff_lambda(rf_wavelength, rf_wavelength_grid): Arguments --------- - rf_wavelength: float - Rest-frame wavelength in Angstroms + rf_wavelength: float or np.ndarray + Rest-frame wavelength in Angstroms + rf_wavelength_grid: np.ndarray - Rest-frame wavelength nodes where the interpolation is defined + Rest-frame wavelength nodes where the interpolation is defined Returns ------- @@ -367,6 +459,33 @@ def interp_coeff_lambda(rf_wavelength, rf_wavelength_grid): return coeff, rf_wavelength_bin +@numba.njit() +def interp_coeff_lambda(z, z_grid): + """Compute the interpolation coefficients for a given rest-frame wavelength. + + Arguments + --------- + z: float + Redshift + + z: np.ndarray + Redshift grid where the interpolation is defined + + Returns + ------- + coeff: np.ndarray + Interpolation coefficients for the given redshift + + z_bin: int or np.ndarray + Indices of the z bins for the given z value + """ + z_bin = np.digitize(z, z_grid) - 1 + z_low = z_grid[z_bin] + z_high = z_grid[z_bin + 1] + + coeff = (z_high - z) / (z_high - z_low) + + return coeff, z_bin @numba.njit() def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, continuum, redshift, weight): From af6a21e64ca45c657a30d8b59e9354cbcc03e805 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 09:47:08 +0200 Subject: [PATCH 27/59] fixed a few things --- .../mean_continuum_interp_expected_flux.py | 46 ++++++++++--------- 1 file changed, 25 insertions(+), 21 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 705ca6245..f5520c09f 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -150,10 +150,11 @@ def _initialize_mean_continuum_arrays(self): if self.interpolation_type == "2D": mean_cont = np.ones( (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) - + # fill_value cannot be "extrapolate" for RegularGridInterpolator + # so we use 0.0 instead self.get_mean_cont = RegularGridInterpolator( (self.z_centers, Forest.log_lambda_rest_frame_grid), - mean_cont, bounds_error=False, fill_value='extrapolate' + mean_cont, bounds_error=False, fill_value=0 ) elif self.interpolation_type == "1D": self.mean_cont = np.ones(Forest.log_lambda_rest_frame_grid.size) @@ -316,7 +317,7 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu # where z_bin is the index of the redshift bin and rf_wavelength_bin # is the index of the rest-frame wavelength bin. # This allows us to use a similar logic as in the 1D case. - matrix_size = Forest.n_z_bins * Forest.log_lambda_rest_frame_grid.size + matrix_size = self.num_z_bins * Forest.log_lambda_rest_frame_grid.size A_matrix = np.zeros( (matrix_size, matrix_size) @@ -335,7 +336,6 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu z_coeffs, z_bin = interp_coeff_z( forest.z, self.z_centers) - z_coeffs = np.repeat(z_coeffs, Forest.log_lambda_rest_frame_grid.size) # combined_bin is the index of the bin in the 2D matrix combined_bin = z_bin + self.num_z_bins * rf_wavelength_bin @@ -346,31 +346,31 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu # Fill the B_matrix # diagonal elements w = np.where(forest.continuum > 0) - B_matrix[combined_bin[w]] += weights[w] * z_coeffs[w] * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w] + B_matrix[combined_bin[w]] += weights[w] * z_coeffs * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w] # off-diagonal elements w = np.where((forest.continuum > 0) & (combined_bin_plus_wavelength < matrix_size - 1)) - B_matrix[combined_bin_plus_wavelength[w] + 1] += weights[w] * z_coeffs[w] * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w] + B_matrix[combined_bin_plus_wavelength[w] + 1] += weights[w] * z_coeffs * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w] w = np.where((forest.continuum > 0) & (combined_bin_plus_z < matrix_size - 1)) - B_matrix[combined_bin_plus_z[w] + 1] += weights[w] * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w] + B_matrix[combined_bin_plus_z[w] + 1] += weights[w] * (1 - z_coeffs) * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w] w = np.where((forest.continuum > 0) & (combined_bin_plus_both < matrix_size - 1)) - B_matrix[combined_bin_plus_both[w] + 1] += weights[w] * (1 - z_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w] + B_matrix[combined_bin_plus_both[w] + 1] += weights[w] * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w] # Fill the A_matrix # diagonal elements A_matrix[combined_bin, combined_bin] += weights * z_coeffs * z_coeffs * rf_wavelength_coeffs * rf_wavelength_coeffs # off-diagonal elements w = np.where(combined_bin_plus_wavelength < matrix_size - 1) - A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += weights[w] * z_coeffs[w] * z_coeffs[w] * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) - A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs[w] * z_coeffs[w] * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) - A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs[w] * z_coeffs[w] * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) w = np.where(combined_bin_plus_z < matrix_size - 1) - A_matrix[combined_bin_plus_z[w], combined_bin[w]] += weights[w] * z_coeffs[w] * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] - A_matrix[combined_bin[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs[w] * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] - A_matrix[combined_bin_plus_z[w], combined_bin_plus_z[w]] += weights[w] * (1 - z_coeffs[w]) * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_z[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + A_matrix[combined_bin[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_z[w], combined_bin_plus_z[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] w = np.where(combined_bin_plus_both < matrix_size - 1) - A_matrix[combined_bin_plus_both[w], combined_bin[w]] += weights[w] * z_coeffs[w] * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) - A_matrix[combined_bin[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs[w] * (1 - z_coeffs[w]) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) - A_matrix[combined_bin_plus_both[w], combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs[w]) * (1 - z_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_both[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_both[w], combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) # Take care of unstable solutions @@ -381,12 +381,16 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu A_matrix[w, w] = 1.0 # Solve the linear system A_matrix * mean_cont = B_matrix - self.mean_cont = np.linalg.solve(A_matrix, B_matrix) + mean_cont = np.linalg.solve(A_matrix, B_matrix) + # Undo the new indexing + self.mean_cont = mean_cont.reshape( + (self.num_z_bins, Forest.log_lambda_rest_frame_grid.size)) + # update the interpolator with the mean continuum self.get_mean_cont = RegularGridInterpolator( (self.z_centers, Forest.log_lambda_rest_frame_grid), - self.mean_cont, bounds_error=False, fill_value='extrapolate', + self.mean_cont, bounds_error=False, fill_value=0.0, ) def hdu_cont(self, results): @@ -460,8 +464,8 @@ def interp_coeff_lambda(rf_wavelength, rf_wavelength_grid): return coeff, rf_wavelength_bin @numba.njit() -def interp_coeff_lambda(z, z_grid): - """Compute the interpolation coefficients for a given rest-frame wavelength. +def interp_coeff_z(z, z_grid): + """Compute the interpolation coefficients for a given redshift. Arguments --------- From 30d1bf616c694fa5ab0e1a3ab9dae28ea5e771ac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 10:04:58 +0200 Subject: [PATCH 28/59] fixed bug in hdu_cont --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index f5520c09f..a0788534c 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -413,7 +413,7 @@ def hdu_cont(self, results): mean_cont_2d, ], names=['Z_CENTERS', 'LOGLAM_REST', 'MEAN_CONT'], - units=['', 'log(Angstrom)', Forest.flux_units, ''], + units=['', 'log(Angstrom)', Forest.flux_units], extname='CONT') results["CONT"].write_comment("2D mean quasar continuum (z, loglam)") results["CONT"].write_checksum() From be5c6301f980ab0c051455615473ac6c0cf6c941 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 10:27:57 +0200 Subject: [PATCH 29/59] added some debugging code --- .../mean_continuum_interp_expected_flux.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index a0788534c..4cb4faf9f 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -290,6 +290,14 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu # Solve the linear system A_matrix * mean_cont = B_matrix self.mean_cont = np.linalg.solve(A_matrix, B_matrix) + try: + mean_cont = np.linalg.solve(A_matrix, B_matrix) + except np.linalg.LinAlgError: + raise ExpectedFluxError( + "The linear system could not be solved. " + "This may be due to a lack of coverage for some wavelengths." + ) + mean_cont, *_ = np.linalg.lstsq(A_matrix, B_matrix, rcond=None) # update the interpolator with the mean continuum self.get_mean_cont = interp1d( @@ -312,6 +320,7 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu which_cont: Function or lambda Should return what to use as continuum given a forest """ + self.logger.debug("Entering compute_mean_cont_2d") # for simplicity we introduce a new index # combined_bin = z_bin + N_z_bins * rf_wavelength_bin # where z_bin is the index of the redshift bin and rf_wavelength_bin @@ -372,6 +381,16 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu A_matrix[combined_bin[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) A_matrix[combined_bin_plus_both[w], combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) + # check that A is symmetric + if not np.allclose(A_matrix, A_matrix.T): + raise ExpectedFluxError( + "A_matrix is not symmetric. " + "This should not happen, please report this issue.") + # check that the diagonal in A is positive or 0 + if not np.all(np.diagonal(A_matrix) >= 0): + raise ExpectedFluxError( + "A_matrix diagonal is not positive or 0. " + "This should not happen, please report this issue.") # Take care of unstable solutions # If the diagonal of A_matrix is zero, we set it to 1.0 From 7efcf12e29557c333e4324771ee3ff9bdfbfbf7f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 11:04:26 +0200 Subject: [PATCH 30/59] fixed lingering issues related to negative errors and zero division errors --- py/picca/delta_extraction/expected_fluxes/utils.py | 4 ++-- .../least_squares/least_squares_cont_model.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/utils.py b/py/picca/delta_extraction/expected_fluxes/utils.py index c773bcd25..4d137b761 100644 --- a/py/picca/delta_extraction/expected_fluxes/utils.py +++ b/py/picca/delta_extraction/expected_fluxes/utils.py @@ -93,8 +93,8 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, minimizer = iminuit.Minuit(leasts_squares, zero_point=zero_point, slope=slope) - minimizer.errors["zero_point"] = zero_point / 2. - minimizer.errors["slope"] = zero_point / 2. + minimizer.errors["zero_point"] = np.fabs(zero_point) / 10. + minimizer.errors["slope"] = np.fabs(slope) / 10. minimizer.errordef = 1. minimizer.print_level = 0 minimizer.fixed["slope"] = order == 0 diff --git a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py index 0e7974614..82a0ae54f 100644 --- a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py +++ b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py @@ -175,8 +175,8 @@ def get_continuum_weights(self, forest, cont_model, **kwargs): if "use_constant_weight" not in kwargs: raise LeastSquaresError("Function get_continuum_weights requires " "'use_constant_weight' in the **kwargs dictionary") - # Assign 0 weight to pixels with ivar==0 - w = forest.ivar > 0 + # Assign 0 weight to pixels with ivar==0 or cont_model==0 + w = forest.ivar > 0 and cont_model > 0 weights = np.empty_like(forest.log_lambda) weights[~w] = 0 From be59dd4a1c3a9040346afcddcd84635e9a9ff7e8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 11:11:39 +0200 Subject: [PATCH 31/59] fixes to previous commit, adding debug code --- .../delta_extraction/expected_fluxes/utils.py | 24 ++++++++++++------- .../least_squares/least_squares_cont_model.py | 2 +- 2 files changed, 16 insertions(+), 10 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/utils.py b/py/picca/delta_extraction/expected_fluxes/utils.py index 4d137b761..dfaadf4ea 100644 --- a/py/picca/delta_extraction/expected_fluxes/utils.py +++ b/py/picca/delta_extraction/expected_fluxes/utils.py @@ -90,15 +90,21 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, zero_point = (forest.flux * forest.ivar).sum() / forest.ivar.sum() slope = 0.0 - minimizer = iminuit.Minuit(leasts_squares, - zero_point=zero_point, - slope=slope) - minimizer.errors["zero_point"] = np.fabs(zero_point) / 10. - minimizer.errors["slope"] = np.fabs(slope) / 10. - minimizer.errordef = 1. - minimizer.print_level = 0 - minimizer.fixed["slope"] = order == 0 - minimizer.migrad() + # debugging code + import warnings + warnings.filterwarnings("error", category=iminuit.util.IMinuitWarning) + with warnings.catch_warnings(): + warnings.filterwarnings("error", category=iminuit.util.IMinuitWarning) + + minimizer = iminuit.Minuit(leasts_squares, + zero_point=zero_point, + slope=slope) + minimizer.errors["zero_point"] = np.fabs(zero_point) / 10. + minimizer.errors["slope"] = np.fabs(slope) / 10. + minimizer.errordef = 1. + minimizer.print_level = 0 + minimizer.fixed["slope"] = order == 0 + minimizer.migrad() bad_continuum_reason = None cont_model = leasts_squares.get_continuum_model( diff --git a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py index 82a0ae54f..ebfa1d5f5 100644 --- a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py +++ b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py @@ -176,7 +176,7 @@ def get_continuum_weights(self, forest, cont_model, **kwargs): raise LeastSquaresError("Function get_continuum_weights requires " "'use_constant_weight' in the **kwargs dictionary") # Assign 0 weight to pixels with ivar==0 or cont_model==0 - w = forest.ivar > 0 and cont_model > 0 + w = forest.ivar > 0 & cont_model > 0 weights = np.empty_like(forest.log_lambda) weights[~w] = 0 From 2127901aae1dd4613e0e4a63302ee13024045d28 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 11:18:23 +0200 Subject: [PATCH 32/59] fixed zero error in iminuit --- py/picca/delta_extraction/expected_fluxes/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/utils.py b/py/picca/delta_extraction/expected_fluxes/utils.py index dfaadf4ea..3e420e90b 100644 --- a/py/picca/delta_extraction/expected_fluxes/utils.py +++ b/py/picca/delta_extraction/expected_fluxes/utils.py @@ -99,8 +99,8 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, minimizer = iminuit.Minuit(leasts_squares, zero_point=zero_point, slope=slope) - minimizer.errors["zero_point"] = np.fabs(zero_point) / 10. - minimizer.errors["slope"] = np.fabs(slope) / 10. + minimizer.errors["zero_point"] = np.max(np.fabs(zero_point) / 10., 1e-6) + minimizer.errors["slope"] = np.max(np.fabs(slope) / 10., 1e-6) minimizer.errordef = 1. minimizer.print_level = 0 minimizer.fixed["slope"] = order == 0 From 8ee4a0f45f462e3a25ace040151bd108cb3fdc42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 11:27:29 +0200 Subject: [PATCH 33/59] fixed call to np.max --- py/picca/delta_extraction/expected_fluxes/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/utils.py b/py/picca/delta_extraction/expected_fluxes/utils.py index 3e420e90b..527180531 100644 --- a/py/picca/delta_extraction/expected_fluxes/utils.py +++ b/py/picca/delta_extraction/expected_fluxes/utils.py @@ -99,8 +99,8 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, minimizer = iminuit.Minuit(leasts_squares, zero_point=zero_point, slope=slope) - minimizer.errors["zero_point"] = np.max(np.fabs(zero_point) / 10., 1e-6) - minimizer.errors["slope"] = np.max(np.fabs(slope) / 10., 1e-6) + minimizer.errors["zero_point"] = np.max([np.fabs(zero_point) / 10., 1e-6]) + minimizer.errors["slope"] = np.max([np.fabs(slope) / 10., 1e-6]) minimizer.errordef = 1. minimizer.print_level = 0 minimizer.fixed["slope"] = order == 0 From ff42b03715f8783d3b66484e6c69f95e8a6cf0d1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 11:34:16 +0200 Subject: [PATCH 34/59] fixed bug --- .../delta_extraction/least_squares/least_squares_cont_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py index ebfa1d5f5..81d595115 100644 --- a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py +++ b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py @@ -176,7 +176,7 @@ def get_continuum_weights(self, forest, cont_model, **kwargs): raise LeastSquaresError("Function get_continuum_weights requires " "'use_constant_weight' in the **kwargs dictionary") # Assign 0 weight to pixels with ivar==0 or cont_model==0 - w = forest.ivar > 0 & cont_model > 0 + w = (forest.ivar > 0) & (cont_model > 0) weights = np.empty_like(forest.log_lambda) weights[~w] = 0 From 2e999a014e4d766c3b507b0636c985ffa707c6e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 12:04:12 +0200 Subject: [PATCH 35/59] removed previous changes as they generate more issues --- .../least_squares/least_squares_cont_model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py index 81d595115..0e7974614 100644 --- a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py +++ b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py @@ -175,8 +175,8 @@ def get_continuum_weights(self, forest, cont_model, **kwargs): if "use_constant_weight" not in kwargs: raise LeastSquaresError("Function get_continuum_weights requires " "'use_constant_weight' in the **kwargs dictionary") - # Assign 0 weight to pixels with ivar==0 or cont_model==0 - w = (forest.ivar > 0) & (cont_model > 0) + # Assign 0 weight to pixels with ivar==0 + w = forest.ivar > 0 weights = np.empty_like(forest.log_lambda) weights[~w] = 0 From 5effccdc443d064a8ac7b7c3596e362b706f9934 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 12:21:10 +0200 Subject: [PATCH 36/59] added debugging code --- .../least_squares/least_squares_cont_model.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py index 0e7974614..07d40885b 100644 --- a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py +++ b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py @@ -180,6 +180,15 @@ def get_continuum_weights(self, forest, cont_model, **kwargs): weights = np.empty_like(forest.log_lambda) weights[~w] = 0 + if np.any(cont_model[w] == 0): + print("w", w) + print("cont_model", cont_model) + print("kwargs", kwargs) + raise LeastSquaresError("The continuum model has zero values. " + "This will lead to division by zero in the " + "weights computation. Please check the " + "continuum model.") + if kwargs.get("use_constant_weight"): weights[w] = 1 else: From ef6f463567e7817e0c13497eba9f3d630eb21189 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 12:35:23 +0200 Subject: [PATCH 37/59] added bad continuum type --- py/picca/delta_extraction/expected_fluxes/utils.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/py/picca/delta_extraction/expected_fluxes/utils.py b/py/picca/delta_extraction/expected_fluxes/utils.py index 527180531..df906e95d 100644 --- a/py/picca/delta_extraction/expected_fluxes/utils.py +++ b/py/picca/delta_extraction/expected_fluxes/utils.py @@ -114,6 +114,8 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, bad_continuum_reason = "minuit didn't converge" if np.any(cont_model < 0): bad_continuum_reason = "negative continuum" + if np.all(cont_model == 0): + bad_continuum_reason = "zero continuum" if bad_continuum_reason is None: continuum_fit_parameters = (minimizer.values["zero_point"], From a09ea35f84c467fbc79163efafcc35c23af38d1e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 12:36:31 +0200 Subject: [PATCH 38/59] restored similar error values --- .../mean_continuum_interp_expected_flux.py | 1 - .../expected_fluxes/tests.ipynb | 1344 +++++++++++++++++ .../delta_extraction/expected_fluxes/utils.py | 5 +- 3 files changed, 1347 insertions(+), 3 deletions(-) create mode 100644 py/picca/delta_extraction/expected_fluxes/tests.ipynb diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 4cb4faf9f..4681cd617 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -404,7 +404,6 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu # Undo the new indexing self.mean_cont = mean_cont.reshape( (self.num_z_bins, Forest.log_lambda_rest_frame_grid.size)) - # update the interpolator with the mean continuum self.get_mean_cont = RegularGridInterpolator( diff --git a/py/picca/delta_extraction/expected_fluxes/tests.ipynb b/py/picca/delta_extraction/expected_fluxes/tests.ipynb new file mode 100644 index 000000000..bc9d3ba8f --- /dev/null +++ b/py/picca/delta_extraction/expected_fluxes/tests.ipynb @@ -0,0 +1,1344 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "eb062d72", + "metadata": {}, + "source": [ + "# Compute mean continuum using the old formalism to compare results" + ] + }, + { + "cell_type": "markdown", + "id": "b1ca67a3", + "metadata": {}, + "source": [ + "## Step 0: Load tests spectra" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "b9baecd8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of objects in the catalogue: 63\n" + ] + } + ], + "source": [ + "from configparser import ConfigParser\n", + "from picca.delta_extraction.astronomical_objects.forest import Forest\n", + "from picca.delta_extraction.data_catalogues.desi_healpix import DesiHealpix, defaults\n", + "\n", + "PICCA_TEST_DIR = \"$PICCA/py/picca/tests/delta_extraction\"\n", + "\n", + "config = ConfigParser()\n", + "config.read_dict({\"data\": {\n", + " \"catalogue\": f\"{PICCA_TEST_DIR}/data/QSO_cat_fuji_dark_healpix.fits.gz\",\n", + " \"keep surveys\": \"all\",\n", + " \"input directory\": f\"{PICCA_TEST_DIR}/data/\",\n", + " \"out dir\": f\"{PICCA_TEST_DIR}/results/\",\n", + " \"num processors\": 1,\n", + " \"analysis type\": \"BAO 3D\"\n", + "}})\n", + "for key, value in defaults.items():\n", + " if key not in config[\"data\"]:\n", + " config[\"data\"][key] = str(value)\n", + "\n", + "data_old = DesiHealpix(config[\"data\"])\n", + "\n", + "print(\"Number of objects in the catalogue:\", len(data_old.forests))" + ] + }, + { + "cell_type": "markdown", + "id": "a7530c7d", + "metadata": {}, + "source": [ + "## Step 1: Compute initial estimates of a_q and b_q for each forest" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "48cf7881", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/lib/python3.12/site-packages/iminuit/util.py:177: IMinuitWarning: Assigned errors must be positive. Non-positive values are replaced by a heuristic.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "from scipy.interpolate import interp1d\n", + "from picca.delta_extraction.expected_fluxes.utils import compute_continuum\n", + "\n", + "# Initial values for the eta, var_lss, and fudge parameters\n", + "# Initialisation is equivalent to the initialization in Dr16ExpectedFlux\n", + "num_bins_variance = 20\n", + "log_lambda_var_func_grid = np.log10(np.linspace(\n", + " 10**Forest.log_lambda_grid[0], \n", + " 10**Forest.log_lambda_grid[-1], \n", + " num_bins_variance))\n", + "get_eta = interp1d(\n", + " log_lambda_var_func_grid,\n", + " np.ones_like(log_lambda_var_func_grid),\n", + " fill_value='extrapolate',\n", + " kind='cubic')\n", + "get_var_lss = interp1d(\n", + " log_lambda_var_func_grid,\n", + " np.zeros_like(log_lambda_var_func_grid) + 0.1,\n", + " fill_value='extrapolate',\n", + " kind='cubic')\n", + "get_fudge = interp1d(\n", + " log_lambda_var_func_grid,\n", + " np.zeros_like(log_lambda_var_func_grid),\n", + " fill_value='extrapolate',\n", + " kind='cubic')\n", + "get_mean_cont = interp1d(\n", + " Forest.log_lambda_rest_frame_grid,\n", + " np.ones_like(Forest.log_lambda_rest_frame_grid),\n", + " fill_value=\"extrapolate\")\n", + "use_constant_weight = False # Use constant weight for the continuum fit\n", + "order = 1 # Order of the polynomial fit for the continuum\n", + "\n", + "# get a_q and b_q estimates\n", + "continuum_fit_parameters = {}\n", + "for forest in data_old.forests: \n", + " cont_model, bad_continuum_reason, cont_fit_params = compute_continuum(\n", + " forest, get_mean_cont, get_eta, get_var_lss, get_fudge, use_constant_weight, \n", + " order)\n", + " \n", + " forest.bad_continuum_reason = bad_continuum_reason\n", + " forest.continuum = cont_model\n", + " continuum_fit_parameters[forest.los_id] = cont_fit_params" + ] + }, + { + "cell_type": "markdown", + "id": "7d9683e1", + "metadata": {}, + "source": [ + "## Step 2: Compute mean continuum" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "a0b26236", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "var_lss_mod = 1.0\n", + "def compute_forest_weights(forest, continuum):\n", + " \"\"\"Compute the forest variance following du Mas des Bourboux 2020\n", + "\n", + " Arguments\n", + " ---------\n", + " forest: Forest\n", + " A forest instance where the variance will be computed\n", + "\n", + " continuum: array of float\n", + " Quasar continuum associated with the forest\n", + " \"\"\"\n", + " w = forest.ivar > 0\n", + " weights = np.empty_like(forest.log_lambda)\n", + " weights[~w] = 0.0\n", + "\n", + " var_pipe = 1. / forest.ivar[w] / continuum[w]**2\n", + " var_lss = get_var_lss(forest.log_lambda[w])\n", + " eta = get_eta(forest.log_lambda[w])\n", + " fudge = get_fudge(forest.log_lambda[w])\n", + " weights[w] = 1.0/(\n", + " eta * var_pipe + var_lss_mod*var_lss + fudge / var_pipe)\n", + "\n", + " return weights\n", + "\n", + "mean_cont = np.zeros_like(Forest.log_lambda_rest_frame_grid)\n", + "mean_cont_weight = np.zeros_like(Forest.log_lambda_rest_frame_grid)\n", + "\n", + "# first compute in bins. C=Cont_old*spectrum_dependent_fitting_fct\n", + "# (and Cont_old is constant for all spectra in a bin), thus we actually\n", + "# compute\n", + "# 1/Cont_old * \n", + "for forest in data_old.forests:\n", + " if forest.bad_continuum_reason is not None:\n", + " continue\n", + " bins = Forest.find_bins( # pylint: disable=not-callable\n", + " forest.log_lambda - np.log10(1 + forest.z),\n", + " Forest.log_lambda_rest_frame_grid)\n", + "\n", + " weights = compute_forest_weights(forest, forest.continuum)\n", + " mean_cont += np.bincount(\n", + " bins,\n", + " weights=forest.continuum * weights,\n", + " minlength=mean_cont.size)\n", + " mean_cont_weight += np.bincount(\n", + " bins,\n", + " weights=weights,\n", + " minlength=mean_cont.size)\n", + "\n", + "w = mean_cont_weight > 0\n", + "mean_cont[w] /= mean_cont_weight[w]\n", + "mean_cont /= mean_cont[w].mean()\n", + "log_lambda_cont = Forest.log_lambda_rest_frame_grid[w]\n", + "\n", + "# the new mean continuum is multiplied by the previous one to recover\n", + "# \n", + "new_cont = get_mean_cont(log_lambda_cont) * mean_cont[w]\n", + "get_mean_cont = interp1d(log_lambda_cont,\n", + " new_cont,\n", + " fill_value=\"extrapolate\")\n", + "get_mean_cont_weight = interp1d(log_lambda_cont,\n", + " mean_cont_weight[w],\n", + " fill_value=0.0,\n", + " bounds_error=False)\n", + "\n", + "mean_cont_old = get_mean_cont(Forest.log_lambda_rest_frame_grid)" + ] + }, + { + "cell_type": "markdown", + "id": "ed5e69bc", + "metadata": {}, + "source": [ + "# New formalism (lambda only)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "84872438", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import numba\n", + "\n", + "@numba.njit()\n", + "def interp_coeff(rf_wavelength, rf_wavelength_grid):\n", + " \"\"\"Compute the interpolation coefficients for a given rest-frame wavelength.\n", + "\n", + " Arguments\n", + " ---------\n", + " rf_wavelength: float\n", + " Rest-frame wavelength in Angstroms\n", + " rf_wavelength_grid: np.ndarray\n", + " Rest-frame wavelength nodes where the interpolation is defined\n", + "\n", + " Returns\n", + " -------\n", + " coeff: np.ndarray\n", + " Interpolation coefficients for the given rest-frame wavelength\n", + "\n", + " rf_wavelength_bin: int or np.ndarray\n", + " Indices of the rf_wavelength bins for the given rf_wavelength value\n", + " \"\"\"\n", + " rf_wavelength_bin = np.digitize(rf_wavelength, rf_wavelength_grid) - 1\n", + " rf_wavelength_low = rf_wavelength_grid[rf_wavelength_bin]\n", + " rf_wavelength_high = rf_wavelength_grid[rf_wavelength_bin + 1]\n", + "\n", + " coeff = (rf_wavelength_high - rf_wavelength) / (rf_wavelength_high - rf_wavelength_low)\n", + "\n", + " return coeff, rf_wavelength_bin" + ] + }, + { + "cell_type": "markdown", + "id": "49226143", + "metadata": {}, + "source": [ + "## Step 0: Load test spectra" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "6bc76b55", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of objects in the catalogue: 63\n" + ] + } + ], + "source": [ + "from configparser import ConfigParser\n", + "from picca.delta_extraction.astronomical_objects.forest import Forest\n", + "from picca.delta_extraction.data_catalogues.desi_healpix import DesiHealpix, defaults\n", + "\n", + "PICCA_TEST_DIR = \"$PICCA/py/picca/tests/delta_extraction\"\n", + "\n", + "config = ConfigParser()\n", + "config.read_dict({\"data\": {\n", + " \"catalogue\": f\"{PICCA_TEST_DIR}/data/QSO_cat_fuji_dark_healpix.fits.gz\",\n", + " \"keep surveys\": \"all\",\n", + " \"input directory\": f\"{PICCA_TEST_DIR}/data/\",\n", + " \"out dir\": f\"{PICCA_TEST_DIR}/results/\",\n", + " \"num processors\": 1,\n", + " \"analysis type\": \"BAO 3D\"\n", + "}})\n", + "for key, value in defaults.items():\n", + " if key not in config[\"data\"]:\n", + " config[\"data\"][key] = str(value)\n", + "\n", + "data_new = DesiHealpix(config[\"data\"])\n", + "\n", + "print(\"Number of objects in the catalogue:\", len(data_new.forests))" + ] + }, + { + "cell_type": "markdown", + "id": "5000c1c0", + "metadata": {}, + "source": [ + "## Step 1: Compute initial estimates of a_q and b_q for each forest" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "ab938191", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/lib/python3.12/site-packages/iminuit/util.py:177: IMinuitWarning: Assigned errors must be positive. Non-positive values are replaced by a heuristic.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "from scipy.interpolate import interp1d\n", + "from picca.delta_extraction.expected_fluxes.utils import compute_continuum\n", + "\n", + "# Initial values for the eta, var_lss, and fudge parameters\n", + "# Initialisation is equivalent to the initialization in Dr16ExpectedFlux\n", + "num_bins_variance = 20\n", + "log_lambda_var_func_grid = np.log10(np.linspace(\n", + " 10**Forest.log_lambda_grid[0], \n", + " 10**Forest.log_lambda_grid[-1], \n", + " num_bins_variance))\n", + "get_eta = interp1d(\n", + " log_lambda_var_func_grid,\n", + " np.ones_like(log_lambda_var_func_grid),\n", + " fill_value='extrapolate',\n", + " kind='cubic')\n", + "get_var_lss = interp1d(\n", + " log_lambda_var_func_grid,\n", + " np.zeros_like(log_lambda_var_func_grid) + 0.1,\n", + " fill_value='extrapolate',\n", + " kind='cubic')\n", + "get_fudge = interp1d(\n", + " log_lambda_var_func_grid,\n", + " np.zeros_like(log_lambda_var_func_grid),\n", + " fill_value='extrapolate',\n", + " kind='cubic')\n", + "get_mean_cont = interp1d(\n", + " Forest.log_lambda_rest_frame_grid,\n", + " np.ones_like(Forest.log_lambda_rest_frame_grid),\n", + " fill_value=\"extrapolate\")\n", + "use_constant_weight = False # Use constant weight for the continuum fit\n", + "order = 1 # Order of the polynomial fit for the continuum\n", + "\n", + "# get a_q and b_q estimates\n", + "continuum_fit_parameters = {}\n", + "for forest in data_new.forests: \n", + " cont_model, bad_continuum_reason, cont_fit_params = compute_continuum(\n", + " forest, get_mean_cont, get_eta, get_var_lss, get_fudge, use_constant_weight, \n", + " order)\n", + " \n", + " forest.bad_continuum_reason = bad_continuum_reason\n", + " forest.continuum = cont_model\n", + " continuum_fit_parameters[forest.los_id] = cont_fit_params" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "428a564c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{39633478723044513: (nan, nan, nan, 218),\n", + " 39633485232605672: (0.7239394650666104,\n", + " 1.0554037674739587,\n", + " 530.1126674116957,\n", + " 576),\n", + " 39633480916668425: (0.21921121622545228,\n", + " -0.02287912547987965,\n", + " -241.70526010916456,\n", + " 716),\n", + " 39633485245186634: (0.24986035581069482,\n", + " -0.005879730589912365,\n", + " 147.36388892808338,\n", + " 715),\n", + " 39633487359116079: (0.5149807925213653,\n", + " 0.43992374880471435,\n", + " 363.9738683043372,\n", + " 709),\n", + " 39633483093511065: (0.08923189604275897,\n", + " -0.03431866724710328,\n", + " -1480.7055856116372,\n", + " 606),\n", + " 39633485232604190: (1.457043900077717,\n", + " -0.8560556880389298,\n", + " 351.1606919621877,\n", + " 185),\n", + " 39633485240993119: (0.267601549502827,\n", + " -0.1593618185573225,\n", + " 200.06015724356632,\n", + " 709),\n", + " 39633489464658242: (0.4589606448576034,\n", + " 0.19205148371170663,\n", + " 385.2757126905617,\n", + " 702),\n", + " 39633491536644232: (0.3868982814088713,\n", + " -0.057862837240584754,\n", + " -375.7405926659592,\n", + " 725),\n", + " 616094245882692041: (nan, nan, nan, 492),\n", + " 39633491540839435: (nan, nan, nan, 857),\n", + " 39633493583465214: (0.19265132064986895,\n", + " 0.20844279199694593,\n", + " -884.7348046863103,\n", + " 787),\n", + " 39633491540838097: (0.22818148682295983,\n", + " -0.023802016160615672,\n", + " -538.0102853816593,\n", + " 794),\n", + " 39633493583464408: (4.69976529576295,\n", + " -0.5946405439794422,\n", + " 1233.7372580879319,\n", + " 698),\n", + " 39633493583465123: (1.5953628214045408,\n", + " -1.0912419754541,\n", + " 407.0360930426887,\n", + " 174),\n", + " 39633493579271075: (0.19889290612661648,\n", + " 0.11473613726288821,\n", + " -479.4873062639456,\n", + " 726),\n", + " 39633493579268963: (nan, nan, nan, 848),\n", + " 39633493583463661: (nan, nan, nan, 95),\n", + " 39633489464658033: (0.14811820424706335,\n", + " 0.3315484563039133,\n", + " 345.1951254615125,\n", + " 391),\n", + " 39633489473045106: (nan, nan, nan, 178),\n", + " 39633487371699188: (0.7351966409146072,\n", + " 0.28846671241616323,\n", + " 169.67393934301765,\n", + " 700),\n", + " 616094239675122420: (0.021451289445316317,\n", + " -0.01579877707921619,\n", + " -2100.879822699831,\n", + " 913),\n", + " 39633489468851130: (0.17575483932771602,\n", + " -0.05519754132331513,\n", + " -709.7575813684737,\n", + " 744),\n", + " 39633491540837630: (0.07340129301346944,\n", + " 0.026274060009511817,\n", + " -1914.6754787125974,\n", + " 829),\n", + " 39633497609994880: (0.13798669887167364,\n", + " 0.12310520296994652,\n", + " -778.8266884969782,\n", + " 801),\n", + " 39633495605119752: (0.16118362069299064,\n", + " 0.16644563475850965,\n", + " -674.0146803433395,\n", + " 796),\n", + " 39633493587657805: (nan, nan, nan, 113),\n", + " 39633495605117776: (-0.5348245484041663,\n", + " 2.4521309618820233,\n", + " 424.62996501924385,\n", + " 186),\n", + " 39633497614190289: (-1.2574345869318866,\n", + " 5.159942146290566,\n", + " 462.7661624101064,\n", + " 227),\n", + " 39633499577125885: (2.663556337651875,\n", + " -2.568258121234901,\n", + " 659.0196412129857,\n", + " 346),\n", + " 39633497597413011: (0.11847868130594146,\n", + " -0.03723614997284043,\n", + " -1127.63607586592,\n", + " 581),\n", + " 39633495613507218: (1.5940779144964188,\n", + " 0.34581858447873703,\n", + " 131.18877312020322,\n", + " 785),\n", + " 39633493591851733: (0.6811587703971528,\n", + " 1.5478864530349175,\n", + " 761.0971196993486,\n", + " 374),\n", + " 39633495609312400: (0.16490299278977927,\n", + " 0.1315760170035851,\n", + " -1363.5187251643838,\n", + " 907),\n", + " 39633491545031256: (0.10448564150991523,\n", + " 0.024370806326404395,\n", + " -1847.9123436717023,\n", + " 894),\n", + " 39633497597413664: (nan, nan, nan, 170),\n", + " 39633493591852133: (-0.09299867130352536,\n", + " 0.33087475706068636,\n", + " 367.95765956714695,\n", + " 365),\n", + " 39633497614189735: (0.8042090699441273,\n", + " -0.04738254407440011,\n", + " 273.3572330038894,\n", + " 721),\n", + " 39633499572931368: (0.12404679987901582,\n", + " 1.9277004404706777,\n", + " 591.6228942764745,\n", + " 354),\n", + " 39633499572931945: (3.636058435702364,\n", + " 0.18550020228922862,\n", + " 941.6020938883124,\n", + " 467),\n", + " 39633499572932649: (0.44789665962488134,\n", + " 0.022750633452090937,\n", + " 434.7842786743527,\n", + " 522),\n", + " 39633493587656875: (-0.19081995423218615,\n", + " 2.254413264229899,\n", + " 637.9868916147897,\n", + " 325),\n", + " 39633497601607277: (3.8652142602906445,\n", + " 0.21548856526299942,\n", + " 1406.6752859272895,\n", + " 636),\n", + " 39633491545030702: (0.6008613621211014,\n", + " -0.05504853424140009,\n", + " -908.4547196078003,\n", + " 793),\n", + " 39633497601608817: (nan, nan, nan, 474),\n", + " 39633491545030901: (0.21589003323178863,\n", + " 0.8330810374083518,\n", + " 588.8585526384184,\n", + " 645),\n", + " 39633495617700085: (0.5270121736205813,\n", + " -0.2954869802335071,\n", + " -1062.8338849075149,\n", + " 673),\n", + " 39633497609996860: (0.5687707822303062,\n", + " 3.1720173109890606,\n", + " 381.3223516884327,\n", + " 157),\n", + " 39633497597413949: (0.939930789872183,\n", + " -0.01444351163569091,\n", + " 89.03760107065125,\n", + " 737),\n", + " 39633493591851198: (0.037399116811005335,\n", + " 0.012317364843205784,\n", + " 394.7577879179491,\n", + " 329),\n", + " 39633495605119935: (0.2224934644113866,\n", + " -0.10068050906651146,\n", + " -1438.6284379009246,\n", + " 675),\n", + " 39633559463397282: (1.6345810624971855,\n", + " -0.8126921340614067,\n", + " 388.7659152908713,\n", + " 175),\n", + " 39633559467591522: (3.210445013533286,\n", + " 1.8053955936493171,\n", + " 785.2533827049235,\n", + " 338),\n", + " 39633559467592484: (0.2133566820712212,\n", + " -0.029676041212885668,\n", + " -1366.3067177603984,\n", + " 807),\n", + " 39633560331617316: (1.2289700675383715,\n", + " -0.09751658413235614,\n", + " 362.0345851397634,\n", + " 743),\n", + " 39633561178870058: (0.27209888861840686,\n", + " 0.013765522313588642,\n", + " -682.9920674486712,\n", + " 728),\n", + " 39633560340006508: (0.16282583859961086,\n", + " 0.003578715376160087,\n", + " -1267.6024395883815,\n", + " 799),\n", + " 39633561174674576: (nan, nan, nan, 19),\n", + " 39633562000951961: (87.16465260763411,\n", + " -86.67359328943107,\n", + " 7.633465652597323,\n", + " 8),\n", + " 39633561183060922: (0.7238532448280279,\n", + " 1.7443244839729475,\n", + " 493.4602976571465,\n", + " 502),\n", + " 39633559463398815: (-0.7468104287553387,\n", + " 2.187806528164754,\n", + " 473.3272435892899,\n", + " 343),\n", + " 39632936152073654: (-1.2681985898185202,\n", + " 2.6484958042156386,\n", + " 530.3836526297549,\n", + " 237)}" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "continuum_fit_parameters" + ] + }, + { + "cell_type": "markdown", + "id": "1354e374", + "metadata": {}, + "source": [ + "# Step 2: Compute the mean continuum nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "6809b024", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A_matrix.shape: (201, 201)\n", + "B_matrix.shape: (201,)\n" + ] + } + ], + "source": [ + "A_matrix = np.zeros(\n", + " (Forest.log_lambda_rest_frame_grid.size, Forest.log_lambda_rest_frame_grid.size)\n", + ")\n", + "print(\"A_matrix.shape: \", A_matrix.shape)\n", + "\n", + "B_matrix = np.zeros(Forest.log_lambda_rest_frame_grid.size) \n", + "print(\"B_matrix.shape: \", B_matrix.shape)\n", + "\n", + "for forest in data_new.forests:\n", + " if forest.bad_continuum_reason is not None:\n", + " continue\n", + "\n", + " log_lambda_rf = forest.log_lambda - np.log10(1 + forest.z)\n", + " weights = compute_forest_weights(forest, forest.continuum)\n", + " zero_point, slope, _, _ = continuum_fit_parameters[forest.los_id]\n", + "\n", + " coeffs, rf_wavelength_bin = interp_coeff(\n", + " log_lambda_rf,\n", + " Forest.log_lambda_rest_frame_grid)\n", + " \n", + " w = np.where(forest.continuum > 0)\n", + " B_matrix[rf_wavelength_bin[w]] += weights[w] * coeffs[w] * forest.flux[w] / forest.continuum[w]\n", + " w = np.where((forest.continuum > 0) & (rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1))\n", + " B_matrix[rf_wavelength_bin[w] + 1] += weights[w] * (1 - coeffs[w]) * forest.flux[w] / forest.continuum[w]\n", + "\n", + " try:\n", + " A_matrix[rf_wavelength_bin, rf_wavelength_bin] += weights * coeffs * coeffs\n", + " w = np.where(rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1)\n", + " A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weights[w] * coeffs[w] * (1 - coeffs[w])\n", + " A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weights[w] * coeffs[w] * (1 - coeffs[w])\n", + " A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weights[w] * (1 - coeffs[w]) * (1 - coeffs[w])\n", + "\n", + " except Exception as e:\n", + " print(\"forest.los_id: \", forest.los_id)\n", + " print(\"rf_wavelength_bin: \", rf_wavelength_bin)\n", + " print(\"coeffs: \", coeffs)\n", + " raise e\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "8f0f194f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.77971249, 20.24443117, 23.72206313, 23.47955841,\n", + " 21.66907979, 22.69357071, 25.5344236 , 24.04722173,\n", + " 24.92190705, 26.05057044, 26.65566557, 27.00748148,\n", + " 22.37376183, 25.58227748, 23.57561175, 26.37260684,\n", + " 27.22248028, 27.46275957, 26.76913605, 29.93523447,\n", + " 28.5797931 , 28.18275487, 27.51737563, 30.57768608,\n", + " 30.73210688, 29.02599181, 26.67767629, 28.78831251,\n", + " 28.10407484, 29.94178967, 29.10111548, 29.92463338,\n", + " 30.43723902, 32.46405144, 30.29315637, 32.58261539,\n", + " 31.06079084, 36.14493458, 29.66088237, 31.33077149,\n", + " 31.15220459, 35.36800867, 31.03889996, 32.54477743,\n", + " 34.88958877, 33.35580853, 35.52936574, 35.32962673,\n", + " 34.62909357, 35.46846637, 34.68716493, 35.71101163,\n", + " 30.68338169, 32.74016491, 34.07580473, 36.52497204,\n", + " 33.84194925, 36.60306721, 37.85471571, 37.81544036,\n", + " 38.96975352, 40.77917407, 39.10920655, 42.6120729 ,\n", + " 38.74715549, 41.98455491, 37.80365673, 41.69807793,\n", + " 42.52801133, 40.89634372, 42.7958267 , 42.70860917,\n", + " 44.51485348, 45.03634043, 40.66090581, 44.4283104 ,\n", + " 45.8826688 , 44.59261534, 37.36227962, 47.56541154,\n", + " 42.86519001, 44.98446129, 46.63909347, 47.64129335,\n", + " 47.48632709, 47.97126215, 53.88113366, 49.26222375,\n", + " 47.2038595 , 53.95866692, 52.25569958, 51.51811372,\n", + " 48.6671937 , 53.8066811 , 51.15100826, 52.0153216 ,\n", + " 53.63242496, 55.80436566, 53.50115658, 54.63050634,\n", + " 59.1238043 , 56.96094937, 53.39045286, 55.45334622,\n", + " 54.60604133, 55.18064385, 58.71540959, 55.95036077,\n", + " 57.52896345, 55.2010929 , 63.84296214, 56.47551687,\n", + " 65.95443083, 58.9140937 , 62.06755133, 63.20172109,\n", + " 63.56584178, 59.46985168, 68.18311288, 61.61130612,\n", + " 65.91469822, 61.81725898, 64.38684603, 64.92028116,\n", + " 69.05739216, 68.8172409 , 68.92771894, 68.30701405,\n", + " 73.99342994, 68.711884 , 67.52256308, 67.64265145,\n", + " 70.38747856, 70.60625461, 72.80310573, 65.94831056,\n", + " 76.47376857, 65.82675695, 77.45759647, 71.94209631,\n", + " 75.1516656 , 76.64243986, 75.91083589, 71.60294625,\n", + " 71.27493372, 76.34474728, 73.76872143, 76.20596751,\n", + " 78.63936601, 78.65596247, 81.36815697, 80.7152994 ,\n", + " 86.60795198, 72.55451642, 84.22152282, 82.31096235,\n", + " 78.7987098 , 79.40984937, 83.19258782, 79.78610916,\n", + " 85.66336825, 79.55806222, 83.45615234, 89.23721307,\n", + " 93.66891383, 85.08804102, 89.46156474, 90.22074981,\n", + " 89.83251627, 87.46756537, 92.87391777, 91.7138137 ,\n", + " 92.67711366, 96.7722643 , 91.79726828, 88.31747512,\n", + " 102.24061529, 97.1952202 , 100.64572637, 98.46282685,\n", + " 105.79985061, 101.05485047, 96.15457349, 98.42085693,\n", + " 103.68065347, 97.19537528, 100.51675824, 106.00921301,\n", + " 99.07641881, 96.56191357, 112.22453479, 103.34796272,\n", + " 107.90783654, 102.44870816, 113.26493354, 96.98340895,\n", + " 105.77321812, 102.52366613, 107.5761135 , 113.35592263,\n", + " 103.88055271])" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.diag(A_matrix)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "d9813f89", + "metadata": {}, + "outputs": [], + "source": [ + "w = np.diagonal(A_matrix) == 0\n", + "A_matrix[w, w] = 1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "8aa1ec75", + "metadata": {}, + "outputs": [], + "source": [ + "# Solve the linear system A_matrix * x = B_matrix\n", + "x = np.linalg.solve(A_matrix, B_matrix)\n" + ] + }, + { + "cell_type": "markdown", + "id": "137584ec", + "metadata": {}, + "source": [ + "## Plot results and compare them with the old case" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "052f14e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1.0, 2.0)" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "fig = plt.figure(figsize=(10, 6))\n", + "ax = fig.add_subplot(111)\n", + "ax.set_xlabel('Log Wavelength (Angstroms)')\n", + "ax.set_ylabel('Estimated Continuum Flux')\n", + "ax.plot(Forest.log_lambda_rest_frame_grid, x, label='New Mean Continuum')\n", + "ax.plot(Forest.log_lambda_rest_frame_grid, mean_cont_old, label='Old Mean Continuum')\n", + "ax.legend()\n", + "ax.set_ylim(-1, 2)\n" + ] + }, + { + "cell_type": "markdown", + "id": "17716b79", + "metadata": {}, + "source": [ + "# New formalism (lambda + redshift)" + ] + }, + { + "cell_type": "markdown", + "id": "159897c1", + "metadata": {}, + "source": [ + "## Step 0: Load test spectra" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "bbfd97b8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of objects in the catalogue: 63\n" + ] + } + ], + "source": [ + "from configparser import ConfigParser\n", + "from picca.delta_extraction.astronomical_objects.forest import Forest\n", + "from picca.delta_extraction.data_catalogues.desi_healpix import DesiHealpix, defaults\n", + "\n", + "PICCA_TEST_DIR = \"$PICCA/py/picca/tests/delta_extraction\"\n", + "\n", + "config = ConfigParser()\n", + "config.read_dict({\"data\": {\n", + " \"catalogue\": f\"{PICCA_TEST_DIR}/data/QSO_cat_fuji_dark_healpix.fits.gz\",\n", + " \"keep surveys\": \"all\",\n", + " \"input directory\": f\"{PICCA_TEST_DIR}/data/\",\n", + " \"out dir\": f\"{PICCA_TEST_DIR}/results/\",\n", + " \"num processors\": 1,\n", + " \"analysis type\": \"BAO 3D\"\n", + "}})\n", + "for key, value in defaults.items():\n", + " if key not in config[\"data\"]:\n", + " config[\"data\"][key] = str(value)\n", + "\n", + "data_new_2d = DesiHealpix(config[\"data\"])\n", + "\n", + "print(\"Number of objects in the catalogue:\", len(data_new_2d.forests))" + ] + }, + { + "cell_type": "markdown", + "id": "1d0c7f54", + "metadata": {}, + "source": [ + "## Step 1: Compute initial estimates of a_q and b_q for each forest" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "92b3d311", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/iprafols/Documents/GitHub/picca/py/picca/delta_extraction/least_squares/least_squares_cont_model.py:190: RuntimeWarning: divide by zero encountered in divide\n", + " var_pipe = 1. / forest.ivar[w] / cont_model[w]**2\n", + "/Users/iprafols/Documents/GitHub/picca/py/picca/delta_extraction/least_squares/least_squares_cont_model.py:195: RuntimeWarning: divide by zero encountered in divide\n", + " weights[w] = 1.0 / cont_model[w]**2 / variance\n", + "/Users/iprafols/Documents/GitHub/picca/py/picca/delta_extraction/least_squares/least_squares_cont_model.py:195: RuntimeWarning: invalid value encountered in divide\n", + " weights[w] = 1.0 / cont_model[w]**2 / variance\n", + "/opt/anaconda3/lib/python3.12/site-packages/iminuit/util.py:177: IMinuitWarning: Assigned errors must be positive. Non-positive values are replaced by a heuristic.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "from scipy.interpolate import interp1d, RegularGridInterpolator\n", + "from picca.delta_extraction.expected_fluxes.utils import compute_continuum\n", + "\n", + "from picca.delta_extraction.expected_fluxes.mean_continuum_interp_expected_flux import interp_coeff_lambda, interp_coeff_z\n", + "\n", + "# Setup the redshift bins and centers\n", + "num_z_bins = 3\n", + "z_bins = np.linspace(2.1, 4.0, num_z_bins + 1)\n", + "z_centers = (z_bins[:-1] + z_bins[1:]) / 2\n", + "\n", + "\n", + "\n", + "# Initial values for the eta, var_lss, and fudge parameters\n", + "# Initialisation is equivalent to the initialization in Dr16ExpectedFlux\n", + "num_bins_variance = 20\n", + "log_lambda_var_func_grid = np.log10(np.linspace(\n", + " 10**Forest.log_lambda_grid[0], \n", + " 10**Forest.log_lambda_grid[-1], \n", + " num_bins_variance))\n", + "get_eta = interp1d(\n", + " log_lambda_var_func_grid,\n", + " np.ones_like(log_lambda_var_func_grid),\n", + " fill_value='extrapolate',\n", + " kind='cubic')\n", + "get_var_lss = interp1d(\n", + " log_lambda_var_func_grid,\n", + " np.zeros_like(log_lambda_var_func_grid) + 0.1,\n", + " fill_value='extrapolate',\n", + " kind='cubic')\n", + "get_fudge = interp1d(\n", + " log_lambda_var_func_grid,\n", + " np.zeros_like(log_lambda_var_func_grid),\n", + " fill_value='extrapolate',\n", + " kind='cubic')\n", + "mean_cont = np.ones(\n", + " (z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size))\n", + "get_mean_cont = RegularGridInterpolator(\n", + " (z_centers, Forest.log_lambda_rest_frame_grid), \n", + " mean_cont, bounds_error=False, fill_value=0.0)\n", + "use_constant_weight = False # Use constant weight for the continuum fit\n", + "order = 1 # Order of the polynomial fit for the continuum\n", + "\n", + "# get a_q and b_q estimates\n", + "continuum_fit_parameters = {}\n", + "for forest in data_new_2d.forests: \n", + " cont_model, bad_continuum_reason, cont_fit_params = compute_continuum(\n", + " forest, get_mean_cont, get_eta, get_var_lss, get_fudge, use_constant_weight, \n", + " order)\n", + " \n", + " forest.bad_continuum_reason = bad_continuum_reason\n", + " forest.continuum = cont_model\n", + " continuum_fit_parameters[forest.los_id] = cont_fit_params" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "62d532bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{39633478723044513: (nan, nan, nan, 0),\n", + " 39633485232605672: (nan, nan, nan, 0),\n", + " 39633480916668425: (0.21921121622262565,\n", + " -0.022879125476090396,\n", + " -241.70526010916456,\n", + " 716),\n", + " 39633485245186634: (0.24986035581069482,\n", + " -0.005879730589912365,\n", + " 147.36388892808338,\n", + " 715),\n", + " 39633487359116079: (0.5149807925211669,\n", + " 0.4399237488050771,\n", + " 363.9738683043373,\n", + " 709),\n", + " 39633483093511065: (nan, nan, nan, 0),\n", + " 39633485232604190: (nan, nan, nan, 0),\n", + " 39633485240993119: (0.2676015495011186,\n", + " -0.15936181855496168,\n", + " 200.0601572435662,\n", + " 709),\n", + " 39633489464658242: (0.4589606448564233,\n", + " 0.19205148371359965,\n", + " 385.2757126905615,\n", + " 702),\n", + " 39633491536644232: (0.38689828140895194,\n", + " -0.057862837240697663,\n", + " -375.7405926659592,\n", + " 725),\n", + " 616094245882692041: (nan, nan, nan, 0),\n", + " 39633491540839435: (nan, nan, nan, 857),\n", + " 39633493583465214: (0.1926513206499509,\n", + " 0.2084427919968139,\n", + " -884.7348046863099,\n", + " 787),\n", + " 39633491540838097: (0.22818148682295983,\n", + " -0.023802016160615672,\n", + " -538.0102853816593,\n", + " 794),\n", + " 39633493583464408: (4.699765295761284,\n", + " -0.5946405439745434,\n", + " 1233.7372580879317,\n", + " 698),\n", + " 39633493583465123: (nan, nan, nan, 0),\n", + " 39633493579271075: (0.19889290612685845,\n", + " 0.11473613726240299,\n", + " -479.48730626394547,\n", + " 726),\n", + " 39633493579268963: (nan, nan, nan, 848),\n", + " 39633493583463661: (nan, nan, nan, 0),\n", + " 39633489464658033: (nan, nan, nan, 0),\n", + " 39633489473045106: (nan, nan, nan, 0),\n", + " 39633487371699188: (0.7351966409147075,\n", + " 0.288466712417165,\n", + " 169.67393934301776,\n", + " 700),\n", + " 616094239675122420: (0.021451289445316317,\n", + " -0.01579877707921619,\n", + " -2100.879822699831,\n", + " 913),\n", + " 39633489468851130: (0.1757548393255944,\n", + " -0.055197541322842616,\n", + " -709.7575813684748,\n", + " 744),\n", + " 39633491540837630: (0.07340129301339746,\n", + " 0.026274060009137127,\n", + " -1914.6754787125965,\n", + " 829),\n", + " 39633497609994880: (0.13798669887140888,\n", + " 0.12310520297024066,\n", + " -778.826688496978,\n", + " 801),\n", + " 39633495605119752: (0.16118362069299064,\n", + " 0.16644563475850965,\n", + " -674.0146803433395,\n", + " 796),\n", + " 39633493587657805: (nan, nan, nan, 0),\n", + " 39633495605117776: (nan, nan, nan, 0),\n", + " 39633497614190289: (nan, nan, nan, 0),\n", + " 39633499577125885: (nan, nan, nan, 0),\n", + " 39633497597413011: (nan, nan, nan, 0),\n", + " 39633495613507218: (1.5940779144960708,\n", + " 0.34581858447945124,\n", + " 131.1887731202031,\n", + " 785),\n", + " 39633493591851733: (nan, nan, nan, 0),\n", + " 39633495609312400: (0.1649029927900481,\n", + " 0.13157601700318697,\n", + " -1363.5187251643833,\n", + " 907),\n", + " 39633491545031256: (0.10448564150998924,\n", + " 0.02437080632629913,\n", + " -1847.9123436717027,\n", + " 894),\n", + " 39633497597413664: (nan, nan, nan, 0),\n", + " 39633493591852133: (nan, nan, nan, 0),\n", + " 39633497614189735: (0.8042090699429016,\n", + " -0.04738254407293686,\n", + " 273.35723300388963,\n", + " 721),\n", + " 39633499572931368: (nan, nan, nan, 0),\n", + " 39633499572931945: (nan, nan, nan, 0),\n", + " 39633499572932649: (nan, nan, nan, 0),\n", + " 39633493587656875: (nan, nan, nan, 0),\n", + " 39633497601607277: (3.8652142602883366,\n", + " 0.21548856526540142,\n", + " 1406.6752859272897,\n", + " 636),\n", + " 39633491545030702: (0.6008613621210818,\n", + " -0.055048534241373084,\n", + " -908.4547196078004,\n", + " 793),\n", + " 39633497601608817: (nan, nan, nan, 0),\n", + " 39633491545030901: (0.21589003323206732,\n", + " 0.8330810374080723,\n", + " 588.8585526384184,\n", + " 645),\n", + " 39633495617700085: (nan, nan, nan, 0),\n", + " 39633497609996860: (nan, nan, nan, 0),\n", + " 39633497597413949: (0.9399307898747885,\n", + " -0.01444351164104082,\n", + " 89.03760107065114,\n", + " 737),\n", + " 39633493591851198: (nan, nan, nan, 0),\n", + " 39633495605119935: (nan, nan, nan, 0),\n", + " 39633559463397282: (nan, nan, nan, 0),\n", + " 39633559467591522: (nan, nan, nan, 0),\n", + " 39633559467592484: (0.2133566820712212,\n", + " -0.029676041212885668,\n", + " -1366.3067177603982,\n", + " 807),\n", + " 39633560331617316: (1.2289700675405621,\n", + " -0.09751658413875379,\n", + " 362.03458513976466,\n", + " 743),\n", + " 39633561178870058: (0.2720988886189903,\n", + " 0.01376552231521866,\n", + " -682.9920674486712,\n", + " 728),\n", + " 39633560340006508: (0.16282583859961086,\n", + " 0.003578715376160087,\n", + " -1267.6024395883815,\n", + " 799),\n", + " 39633561174674576: (nan, nan, nan, 0),\n", + " 39633562000951961: (nan, nan, nan, 0),\n", + " 39633561183060922: (nan, nan, nan, 0),\n", + " 39633559463398815: (nan, nan, nan, 0),\n", + " 39632936152073654: (nan, nan, nan, 0)}" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "continuum_fit_parameters" + ] + }, + { + "cell_type": "markdown", + "id": "45a32818", + "metadata": {}, + "source": [ + "# Step 2: Compute the mean continuum nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "49a4df30", + "metadata": {}, + "outputs": [], + "source": [ + "var_lss_mod = 1.0\n", + "def compute_forest_weights(forest, continuum):\n", + " \"\"\"Compute the forest variance following du Mas des Bourboux 2020\n", + "\n", + " Arguments\n", + " ---------\n", + " forest: Forest\n", + " A forest instance where the variance will be computed\n", + "\n", + " continuum: array of float\n", + " Quasar continuum associated with the forest\n", + " \"\"\"\n", + " w = forest.ivar > 0\n", + " weights = np.empty_like(forest.log_lambda)\n", + " weights[~w] = 0.0\n", + "\n", + " var_pipe = 1. / forest.ivar[w] / continuum[w]**2\n", + " var_lss = get_var_lss(forest.log_lambda[w])\n", + " eta = get_eta(forest.log_lambda[w])\n", + " fudge = get_fudge(forest.log_lambda[w])\n", + " weights[w] = 1.0/(\n", + " eta * var_pipe + var_lss_mod*var_lss + fudge / var_pipe)\n", + "\n", + " return weights" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "ebe9b5e5", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# for simplicity we introduce a new index \n", + "# combined_bin = z_bin + N_z_bins * rf_wavelength_bin\n", + "# where z_bin is the index of the redshift bin and rf_wavelength_bin\n", + "# is the index of the rest-frame wavelength bin.\n", + "# This allows us to use a similar logic as in the 1D case.\n", + "matrix_size = num_z_bins * Forest.log_lambda_rest_frame_grid.size\n", + "\n", + "A_matrix = np.zeros(\n", + " (matrix_size, matrix_size)\n", + ")\n", + "B_matrix = np.zeros(matrix_size) \n", + "\n", + "for forest in data_new_2d.forests:\n", + " if forest.bad_continuum_reason is not None:\n", + " continue\n", + "\n", + " log_lambda_rf = forest.log_lambda - np.log10(1 + forest.z)\n", + " weights = compute_forest_weights(forest, forest.continuum)\n", + " rf_wavelength_coeffs, rf_wavelength_bin = interp_coeff_lambda(\n", + " log_lambda_rf,\n", + " Forest.log_lambda_rest_frame_grid)\n", + " z_coeffs, z_bin = interp_coeff_z(\n", + " forest.z,\n", + " z_centers)\n", + " #z_coeffs = np.repeat(z_coeffs, Forest.log_lambda_rest_frame_grid.size)\n", + " \n", + " # combined_bin is the index of the bin in the 2D matrix\n", + " combined_bin = z_bin + num_z_bins * rf_wavelength_bin\n", + " combined_bin_plus_wavelength = z_bin + num_z_bins * (rf_wavelength_bin + 1)\n", + " combined_bin_plus_z = z_bin + 1 + num_z_bins * (rf_wavelength_bin)\n", + " combined_bin_plus_both = z_bin + 1 + num_z_bins * (rf_wavelength_bin + 1)\n", + "\n", + " # Fill the B_matrix\n", + " # diagonal elements\n", + " w = np.where(forest.continuum > 0)\n", + " B_matrix[combined_bin[w]] += weights[w] * z_coeffs * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w]\n", + " # off-diagonal elements\n", + " w = np.where((forest.continuum > 0) & (combined_bin_plus_wavelength < matrix_size - 1))\n", + " B_matrix[combined_bin_plus_wavelength[w] + 1] += weights[w] * z_coeffs * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w]\n", + " w = np.where((forest.continuum > 0) & (combined_bin_plus_z < matrix_size - 1))\n", + " B_matrix[combined_bin_plus_z[w] + 1] += weights[w] * (1 - z_coeffs) * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w]\n", + " w = np.where((forest.continuum > 0) & (combined_bin_plus_both < matrix_size - 1))\n", + " B_matrix[combined_bin_plus_both[w] + 1] += weights[w] * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w]\n", + "\n", + " # Fill the A_matrix\n", + " # diagonal elements\n", + " A_matrix[combined_bin, combined_bin] += weights * z_coeffs * z_coeffs * rf_wavelength_coeffs * rf_wavelength_coeffs\n", + " # off-diagonal elements\n", + " w = np.where(combined_bin_plus_wavelength < matrix_size - 1)\n", + " A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w])\n", + " A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w])\n", + " A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w])\n", + " w = np.where(combined_bin_plus_z < matrix_size - 1)\n", + " A_matrix[combined_bin_plus_z[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w]\n", + " A_matrix[combined_bin[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w]\n", + " A_matrix[combined_bin_plus_z[w], combined_bin_plus_z[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w]\n", + " w = np.where(combined_bin_plus_both < matrix_size - 1)\n", + " A_matrix[combined_bin_plus_both[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w])\n", + " A_matrix[combined_bin[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w])\n", + " A_matrix[combined_bin_plus_both[w], combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w])\n", + "\n", + "\n", + "# Take care of unstable solutions\n", + "# If the diagonal of A_matrix is zero, we set it to 1.0\n", + "# This is a workaround for the case where there is no coverage\n", + "# for some wavelengths.\n", + "w = np.diagonal(A_matrix) == 0\n", + "A_matrix[w, w] = 1.0\n", + "\n", + "# Solve the linear system A_matrix * mean_cont = B_matrix\n", + "mean_cont = np.linalg.solve(A_matrix, B_matrix)\n", + "# Undo the new indexing\n", + "mean_cont = mean_cont.reshape((num_z_bins, Forest.log_lambda_rest_frame_grid.size))\n", + "\n", + "\n", + "# update the interpolator with the mean continuum\n", + "get_mean_cont = RegularGridInterpolator(\n", + " (z_centers, Forest.log_lambda_rest_frame_grid), \n", + " mean_cont, bounds_error=False, fill_value=0.0,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "0120a746", + "metadata": {}, + "source": [ + "# Plot results and compare with previous cases" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "97d4cd3b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1.0, 2.0)" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "fig = plt.figure(figsize=(10, 6))\n", + "ax = fig.add_subplot(111)\n", + "ax.set_xlabel('Log Wavelength (Angstroms)')\n", + "ax.set_ylabel('Estimated Continuum Flux')\n", + "ax.plot(Forest.log_lambda_rest_frame_grid, x, label='New Mean Continuum (1d)')\n", + "ax.plot(Forest.log_lambda_rest_frame_grid, mean_cont_old, label='Old Mean Continuum')\n", + "\n", + "for z in np.linspace(2.1, 4.0, 5):\n", + " # Create a grid of points for the new mean continuum\n", + " # at a specific redshift z\n", + " # We use the log_lambda_rest_frame_grid and the redshift z\n", + " points = np.column_stack([np.full_like(Forest.log_lambda_rest_frame_grid, z), Forest.log_lambda_rest_frame_grid])\n", + " to_plot = get_mean_cont(points)\n", + " ax.plot(Forest.log_lambda_rest_frame_grid, \n", + " to_plot, \n", + " label=f'New Mean Continuum (2d) at z={z:.2f}')\n", + "ax.set_title('Comparison of Mean Continuum Fluxes')\n", + "ax.legend()\n", + "ax.set_ylim(-1, 2)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6eefa689", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/py/picca/delta_extraction/expected_fluxes/utils.py b/py/picca/delta_extraction/expected_fluxes/utils.py index df906e95d..94d4f4c84 100644 --- a/py/picca/delta_extraction/expected_fluxes/utils.py +++ b/py/picca/delta_extraction/expected_fluxes/utils.py @@ -89,6 +89,7 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, zero_point = (forest.flux * forest.ivar).sum() / forest.ivar.sum() slope = 0.0 + error = np.max([np.fabs(zero_point) / 2., 1e-6]) # debugging code import warnings @@ -99,8 +100,8 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, minimizer = iminuit.Minuit(leasts_squares, zero_point=zero_point, slope=slope) - minimizer.errors["zero_point"] = np.max([np.fabs(zero_point) / 10., 1e-6]) - minimizer.errors["slope"] = np.max([np.fabs(slope) / 10., 1e-6]) + minimizer.errors["zero_point"] = error + minimizer.errors["slope"] = error minimizer.errordef = 1. minimizer.print_level = 0 minimizer.fixed["slope"] = order == 0 From 41b8399336056c1187840f4fb05c1972ed5922b8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 12:45:35 +0200 Subject: [PATCH 39/59] more debugging --- .../least_squares/least_squares_cont_model.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py index 07d40885b..f357c3278 100644 --- a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py +++ b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py @@ -180,10 +180,14 @@ def get_continuum_weights(self, forest, cont_model, **kwargs): weights = np.empty_like(forest.log_lambda) weights[~w] = 0 - if np.any(cont_model[w] == 0): - print("w", w) - print("cont_model", cont_model) - print("kwargs", kwargs) + if np.all(cont_model[w] == 0): + import sys + print("id", forest.los_id, file=sys.stderr) + print("w", w, file=sys.stderr) + print("cont_model", cont_model, file=sys.stderr) + print("kwargs", kwargs, file=sys.stderr) + weights[w] = 1 + #return weights raise LeastSquaresError("The continuum model has zero values. " "This will lead to division by zero in the " "weights computation. Please check the " From ed2f6bfe218dc2ca23ef7a9b6ed8d4b8664fdd1b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 12:56:59 +0200 Subject: [PATCH 40/59] added more debugging code --- .../least_squares/least_squares_cont_model.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py index f357c3278..54b18e799 100644 --- a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py +++ b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py @@ -131,6 +131,11 @@ def get_continuum_model(self, forest, zero_point, slope, **kwargs): raise LeastSquaresError("Function get_continuum_model requires " "'mean_cont' in the **kwargs dictionary") mean_cont = kwargs.get("mean_cont") + if np.all(mean_cont == 0): + raise LeastSquaresError("The mean continuum has zero values. " + "This will lead to division by zero later on " + "and should not occur. Please check the mean " + "continuum.") for key in ["log_lambda_max", "log_lambda_min"]: if key not in kwargs: raise LeastSquaresError("Function get_continuum_model requires " From e1a2ccfc1cd432471ca3643f6ca435c701f1304b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 14:11:40 +0200 Subject: [PATCH 41/59] restored least_squares_cont_model to master's version --- .../least_squares/least_squares_cont_model.py | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py index 54b18e799..0e7974614 100644 --- a/py/picca/delta_extraction/least_squares/least_squares_cont_model.py +++ b/py/picca/delta_extraction/least_squares/least_squares_cont_model.py @@ -131,11 +131,6 @@ def get_continuum_model(self, forest, zero_point, slope, **kwargs): raise LeastSquaresError("Function get_continuum_model requires " "'mean_cont' in the **kwargs dictionary") mean_cont = kwargs.get("mean_cont") - if np.all(mean_cont == 0): - raise LeastSquaresError("The mean continuum has zero values. " - "This will lead to division by zero later on " - "and should not occur. Please check the mean " - "continuum.") for key in ["log_lambda_max", "log_lambda_min"]: if key not in kwargs: raise LeastSquaresError("Function get_continuum_model requires " @@ -185,19 +180,6 @@ def get_continuum_weights(self, forest, cont_model, **kwargs): weights = np.empty_like(forest.log_lambda) weights[~w] = 0 - if np.all(cont_model[w] == 0): - import sys - print("id", forest.los_id, file=sys.stderr) - print("w", w, file=sys.stderr) - print("cont_model", cont_model, file=sys.stderr) - print("kwargs", kwargs, file=sys.stderr) - weights[w] = 1 - #return weights - raise LeastSquaresError("The continuum model has zero values. " - "This will lead to division by zero in the " - "weights computation. Please check the " - "continuum model.") - if kwargs.get("use_constant_weight"): weights[w] = 1 else: From 135a3e265cc5c0c8503789f6c6c199b99650294a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 29 Jul 2025 14:11:48 +0200 Subject: [PATCH 42/59] fixed fudge --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 4681cd617..611d8482e 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -8,7 +8,8 @@ from picca.delta_extraction.errors import ExpectedFluxError from picca.delta_extraction.astronomical_objects.forest import Forest -from picca.delta_extraction.expected_fluxes.dr16_expected_flux import Dr16ExpectedFlux, defaults, accepted_options +#from picca.delta_extraction.expected_fluxes.dr16_expected_flux import Dr16ExpectedFlux, defaults, accepted_options +from picca.delta_extraction.expected_fluxes.dr16_fixed_fudge_expected_flux import Dr16FixedFudgeExpectedFlux, defaults, accepted_options from picca.delta_extraction.utils import (update_accepted_options, update_default_options, ABSORBER_IGM) @@ -26,7 +27,7 @@ ACCEPTED_INTERPOLATION_TYPES = ["1D", "2D"] -class MeanContinuumInterpExpectedFlux(Dr16ExpectedFlux): +class MeanContinuumInterpExpectedFlux(Dr16FixedFudgeExpectedFlux): """Class to the expected flux as done in the DR16 SDSS analysys The mean expected flux is calculated iteratively as explained in du Mas des Bourboux et al. (2020) except that the we don't use @@ -154,7 +155,7 @@ def _initialize_mean_continuum_arrays(self): # so we use 0.0 instead self.get_mean_cont = RegularGridInterpolator( (self.z_centers, Forest.log_lambda_rest_frame_grid), - mean_cont, bounds_error=False, fill_value=0 + mean_cont, bounds_error=False, fill_value=0.0 ) elif self.interpolation_type == "1D": self.mean_cont = np.ones(Forest.log_lambda_rest_frame_grid.size) From 64491eeb7d77080b00521fcdcd1fefd38d1f2487 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 30 Jul 2025 18:15:58 +0200 Subject: [PATCH 43/59] added missing terms in A matrix --- .../mean_continuum_interp_expected_flux.py | 34 ++++++++++++------- 1 file changed, 22 insertions(+), 12 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 611d8482e..3d8562e70 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -358,29 +358,39 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu w = np.where(forest.continuum > 0) B_matrix[combined_bin[w]] += weights[w] * z_coeffs * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w] # off-diagonal elements - w = np.where((forest.continuum > 0) & (combined_bin_plus_wavelength < matrix_size - 1)) + w = np.where((forest.continuum > 0) & (combined_bin_plus_wavelength < matrix_size)) B_matrix[combined_bin_plus_wavelength[w] + 1] += weights[w] * z_coeffs * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w] - w = np.where((forest.continuum > 0) & (combined_bin_plus_z < matrix_size - 1)) - B_matrix[combined_bin_plus_z[w] + 1] += weights[w] * (1 - z_coeffs) * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w] - w = np.where((forest.continuum > 0) & (combined_bin_plus_both < matrix_size - 1)) - B_matrix[combined_bin_plus_both[w] + 1] += weights[w] * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w] + w = np.where((forest.continuum > 0) & (combined_bin_plus_z < matrix_size)) + B_matrix[combined_bin_plus_z[w]] += weights[w] * (1 - z_coeffs) * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w] + w = np.where((forest.continuum > 0) & (combined_bin_plus_both < matrix_size)) + B_matrix[combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w] # Fill the A_matrix # diagonal elements A_matrix[combined_bin, combined_bin] += weights * z_coeffs * z_coeffs * rf_wavelength_coeffs * rf_wavelength_coeffs # off-diagonal elements - w = np.where(combined_bin_plus_wavelength < matrix_size - 1) - A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + w = np.where(combined_bin_plus_wavelength < matrix_size) A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) - w = np.where(combined_bin_plus_z < matrix_size - 1) - A_matrix[combined_bin_plus_z[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + w = np.where(combined_bin_plus_z < matrix_size) A_matrix[combined_bin[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_z[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] A_matrix[combined_bin_plus_z[w], combined_bin_plus_z[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] - w = np.where(combined_bin_plus_both < matrix_size - 1) - A_matrix[combined_bin_plus_both[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + w = np.where(combined_bin_plus_both < matrix_size) A_matrix[combined_bin[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_both[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) A_matrix[combined_bin_plus_both[w], combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) + # cross terms + w = np.where((combined_bin_plus_wavelength < matrix_size) & (combined_bin_plus_z < matrix_size)) + A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_z[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + w = np.where((combined_bin_plus_wavelength < matrix_size) & (combined_bin_plus_both < matrix_size)) + A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_both[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) + w = np.where((combined_bin_plus_z < matrix_size) & (combined_bin_plus_both < matrix_size)) + A_matrix[combined_bin_plus_z[w], combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_both[w], combined_bin_plus_z[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) # check that A is symmetric if not np.allclose(A_matrix, A_matrix.T): @@ -431,7 +441,7 @@ def hdu_cont(self, results): log_lam_mesh_grid, mean_cont_2d, ], - names=['Z_CENTERS', 'LOGLAM_REST', 'MEAN_CONT'], + names=['Z_CENTER', 'LOGLAM_REST', 'MEAN_CONT'], units=['', 'log(Angstrom)', Forest.flux_units], extname='CONT') results["CONT"].write_comment("2D mean quasar continuum (z, loglam)") From 966de5397b5692832d3a335929b91ea9328c1341 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 30 Jul 2025 18:46:55 +0200 Subject: [PATCH 44/59] fixed terms, simplified code --- .../mean_continuum_interp_expected_flux.py | 60 ++++++++++--------- 1 file changed, 31 insertions(+), 29 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 3d8562e70..71d2fca62 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -343,9 +343,11 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu rf_wavelength_coeffs, rf_wavelength_bin = interp_coeff_lambda( log_lambda_rf, Forest.log_lambda_rest_frame_grid) + one_minus_rf_wavelength_coeffs = 1 - rf_wavelength_coeffs z_coeffs, z_bin = interp_coeff_z( forest.z, self.z_centers) + one_minus_z_coeffs = 1 - z_coeffs # combined_bin is the index of the bin in the 2D matrix combined_bin = z_bin + self.num_z_bins * rf_wavelength_bin @@ -355,42 +357,42 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu # Fill the B_matrix # diagonal elements - w = np.where(forest.continuum > 0) - B_matrix[combined_bin[w]] += weights[w] * z_coeffs * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w] + w = np.where((forest.continuum > 0) & + (combined_bin < matrix_size) & + (combined_bin_plus_wavelength < matrix_size) & + (combined_bin_plus_z < matrix_size) & + (combined_bin_plus_both < matrix_size)) + flux_over_cont = forest.flux[w] / forest.continuum[w] + B_matrix[combined_bin[w]] += weights[w] * z_coeffs * rf_wavelength_coeffs[w] * flux_over_cont # off-diagonal elements - w = np.where((forest.continuum > 0) & (combined_bin_plus_wavelength < matrix_size)) - B_matrix[combined_bin_plus_wavelength[w] + 1] += weights[w] * z_coeffs * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w] - w = np.where((forest.continuum > 0) & (combined_bin_plus_z < matrix_size)) - B_matrix[combined_bin_plus_z[w]] += weights[w] * (1 - z_coeffs) * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w] - w = np.where((forest.continuum > 0) & (combined_bin_plus_both < matrix_size)) - B_matrix[combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w] + B_matrix[combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * one_minus_rf_wavelength_coeffs[w] * flux_over_cont + B_matrix[combined_bin_plus_z[w]] += weights[w] * one_minus_z_coeffs[w] * rf_wavelength_coeffs[w] * flux_over_cont + B_matrix[combined_bin_plus_both[w]] += weights[w] * one_minus_z_coeffs[w] * one_minus_rf_wavelength_coeffs[w] * flux_over_cont # Fill the A_matrix # diagonal elements A_matrix[combined_bin, combined_bin] += weights * z_coeffs * z_coeffs * rf_wavelength_coeffs * rf_wavelength_coeffs # off-diagonal elements - w = np.where(combined_bin_plus_wavelength < matrix_size) - A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) - A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) - A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) - w = np.where(combined_bin_plus_z < matrix_size) - A_matrix[combined_bin[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] - A_matrix[combined_bin_plus_z[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] - A_matrix[combined_bin_plus_z[w], combined_bin_plus_z[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] - w = np.where(combined_bin_plus_both < matrix_size) - A_matrix[combined_bin[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) - A_matrix[combined_bin_plus_both[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) - A_matrix[combined_bin_plus_both[w], combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + + A_matrix[combined_bin[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_z[w], combined_bin[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_z[w], combined_bin_plus_z[w]] += weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + + A_matrix[combined_bin[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_both[w], combined_bin[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_both[w], combined_bin_plus_both[w]] += weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] # cross terms - w = np.where((combined_bin_plus_wavelength < matrix_size) & (combined_bin_plus_z < matrix_size)) - A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) - A_matrix[combined_bin_plus_z[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) - w = np.where((combined_bin_plus_wavelength < matrix_size) & (combined_bin_plus_both < matrix_size)) - A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) - A_matrix[combined_bin_plus_both[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w]) - w = np.where((combined_bin_plus_z < matrix_size) & (combined_bin_plus_both < matrix_size)) - A_matrix[combined_bin_plus_z[w], combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) - A_matrix[combined_bin_plus_both[w], combined_bin_plus_z[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w]) + A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_z[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + + A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_both[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + + A_matrix[combined_bin_plus_z[w], combined_bin_plus_both[w]] += weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_both[w], combined_bin_plus_z[w]] += weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] # check that A is symmetric if not np.allclose(A_matrix, A_matrix.T): From e9e685390c73fd06986ac0b876b504f475db0323 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 30 Jul 2025 20:23:31 +0200 Subject: [PATCH 45/59] fixed bug, optimized computation --- .../mean_continuum_interp_expected_flux.py | 52 +++++++++++-------- 1 file changed, 31 insertions(+), 21 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 71d2fca62..5c9ed633d 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -356,43 +356,53 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu combined_bin_plus_both = z_bin + 1 + self.num_z_bins * (rf_wavelength_bin + 1) # Fill the B_matrix - # diagonal elements w = np.where((forest.continuum > 0) & (combined_bin < matrix_size) & (combined_bin_plus_wavelength < matrix_size) & (combined_bin_plus_z < matrix_size) & (combined_bin_plus_both < matrix_size)) flux_over_cont = forest.flux[w] / forest.continuum[w] + # diagonal elements B_matrix[combined_bin[w]] += weights[w] * z_coeffs * rf_wavelength_coeffs[w] * flux_over_cont # off-diagonal elements B_matrix[combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * one_minus_rf_wavelength_coeffs[w] * flux_over_cont - B_matrix[combined_bin_plus_z[w]] += weights[w] * one_minus_z_coeffs[w] * rf_wavelength_coeffs[w] * flux_over_cont - B_matrix[combined_bin_plus_both[w]] += weights[w] * one_minus_z_coeffs[w] * one_minus_rf_wavelength_coeffs[w] * flux_over_cont + B_matrix[combined_bin_plus_z[w]] += weights[w] * one_minus_z_coeffs * rf_wavelength_coeffs[w] * flux_over_cont + B_matrix[combined_bin_plus_both[w]] += weights[w] * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[w] * flux_over_cont # Fill the A_matrix # diagonal elements + w = np.where((combined_bin < matrix_size) & + (combined_bin_plus_wavelength < matrix_size) & + (combined_bin_plus_z < matrix_size) & + (combined_bin_plus_both < matrix_size)) A_matrix[combined_bin, combined_bin] += weights * z_coeffs * z_coeffs * rf_wavelength_coeffs * rf_wavelength_coeffs - # off-diagonal elements - A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] - A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + # off-diagonal elements - wl + aux = weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += aux + A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += aux A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] - - A_matrix[combined_bin[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] - A_matrix[combined_bin_plus_z[w], combined_bin[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + # off-diagonal elements - z + aux = weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + A_matrix[combined_bin[w], combined_bin_plus_z[w]] += aux + A_matrix[combined_bin_plus_z[w], combined_bin[w]] += aux A_matrix[combined_bin_plus_z[w], combined_bin_plus_z[w]] += weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] - - A_matrix[combined_bin[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] - A_matrix[combined_bin_plus_both[w], combined_bin[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + # off-diagonal elements - wl + z + aux = weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin[w], combined_bin_plus_both[w]] += aux + A_matrix[combined_bin_plus_both[w], combined_bin[w]] += aux A_matrix[combined_bin_plus_both[w], combined_bin_plus_both[w]] += weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] - # cross terms - A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] - A_matrix[combined_bin_plus_z[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] - - A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] - A_matrix[combined_bin_plus_both[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] - - A_matrix[combined_bin_plus_z[w], combined_bin_plus_both[w]] += weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] - A_matrix[combined_bin_plus_both[w], combined_bin_plus_z[w]] += weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + # cross terms - wl, z + aux = weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_z[w]] += aux + A_matrix[combined_bin_plus_z[w], combined_bin_plus_wavelength[w]] += aux + # cross terms - wl, wl + z + aux = weights[w] * z_coeffs * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_both[w]] += aux + A_matrix[combined_bin_plus_both[w], combined_bin_plus_wavelength[w]] += aux + # cross terms - z, wl + z + aux = weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_z[w], combined_bin_plus_both[w]] += aux + A_matrix[combined_bin_plus_both[w], combined_bin_plus_z[w]] += aux # check that A is symmetric if not np.allclose(A_matrix, A_matrix.T): From 2a8f71a4521f1fe7fd857a081ab7d0ef3c9b0991 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Thu, 31 Jul 2025 08:01:05 +0200 Subject: [PATCH 46/59] added debugging code --- .../mean_continuum_interp_expected_flux.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 5c9ed633d..7c84bac87 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -348,6 +348,19 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu forest.z, self.z_centers) one_minus_z_coeffs = 1 - z_coeffs + + if any(rf_wavelength_coeffs < 0) or any(one_minus_rf_wavelength_coeffs < 0): + raise ExpectedFluxError( + "Negative coefficients found in the rest-frame wavelength interpolation. " + "This should not happen, please report this issue.") + if any(z_coeffs < 0) or any(one_minus_z_coeffs < 0): + raise ExpectedFluxError( + "Negative coefficients found in the redshift interpolation. " + "This should not happen, please report this issue.") + if any(weights < 0): + raise ExpectedFluxError( + "Negative weights found in the forest weights. " + "This should not happen, please report this issue.") # combined_bin is the index of the bin in the 2D matrix combined_bin = z_bin + self.num_z_bins * rf_wavelength_bin From 511a203c5a917a4be17f2cdce1b82c7ef8f754f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Thu, 31 Jul 2025 08:18:22 +0200 Subject: [PATCH 47/59] fixed bug --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 7c84bac87..93f1a63d3 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -353,7 +353,7 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu raise ExpectedFluxError( "Negative coefficients found in the rest-frame wavelength interpolation. " "This should not happen, please report this issue.") - if any(z_coeffs < 0) or any(one_minus_z_coeffs < 0): + if z_coeffs < 0 or one_minus_z_coeffs < 0: raise ExpectedFluxError( "Negative coefficients found in the redshift interpolation. " "This should not happen, please report this issue.") From 206b74f5a1ed574a3452dba89e5ce0fed66b1889 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Thu, 31 Jul 2025 11:02:51 +0200 Subject: [PATCH 48/59] more debugging code --- .../mean_continuum_interp_expected_flux.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 93f1a63d3..f88dd9202 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -358,6 +358,15 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu "Negative coefficients found in the redshift interpolation. " "This should not happen, please report this issue.") if any(weights < 0): + print("\n################################") + print("################################") + print("log_lambda weight ivar continuum eta var_lss fudge") + for weight, ivar, continuum, log_lambda in zip(weights, forest.ivar, forest.continuum, forest.log_lambda): + var_lss = self.get_var_lss(log_lambda) + eta = self.get_eta(log_lambda) + fudge = self.get_fudge(log_lambda) + print(f"{log_lambda:.4f} {weight:.4f} {ivar:.4f} {continuum:.4f} {eta:.4f} {var_lss:.4f} {fudge:.4f}") + raise ExpectedFluxError( "Negative weights found in the forest weights. " "This should not happen, please report this issue.") From 55bdd6ec814586888678d01baa607cc5c1acae8b Mon Sep 17 00:00:00 2001 From: Julien Guy Date: Mon, 25 Aug 2025 11:49:29 -0700 Subject: [PATCH 49/59] interpolate across z bin edges and not z bin centers so that we do not need to extrapolate. also needed to transposed 2d array for RegularGridInterpolator --- .../mean_continuum_interp_expected_flux.py | 116 +++++++++--------- 1 file changed, 55 insertions(+), 61 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index f88dd9202..06a469161 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -21,8 +21,8 @@ defaults = update_default_options( defaults, { "interpolation type": "1D", - "limit z": (1.94, 4.5), - "num z bins": 10, + "limit z": (1.8, 5.), + "num z bins": 3, }) ACCEPTED_INTERPOLATION_TYPES = ["1D", "2D"] @@ -30,18 +30,18 @@ class MeanContinuumInterpExpectedFlux(Dr16FixedFudgeExpectedFlux): """Class to the expected flux as done in the DR16 SDSS analysys The mean expected flux is calculated iteratively as explained in - du Mas des Bourboux et al. (2020) except that the we don't use + du Mas des Bourboux et al. (2020) except that the we don't use the stacking technique to compute the mean quasar continuum. - Instead, we build an interpolator. + Instead, we build an interpolator. Additionally, the mean continuum can be computed in 2D, i.e. the mean continuum is computed as a function of both the wavelength and - the redshift. + the redshift. Methods ------- (see Dr16ExpectedFlux in py/picca/delta_extraction/expected_fluxes/dr16_expected_flux.py) - + Attributes ---------- (see Dr16ExpectedFlux in py/picca/delta_extraction/expected_fluxes/dr16_expected_flux.py) @@ -58,12 +58,8 @@ class MeanContinuumInterpExpectedFlux(Dr16FixedFudgeExpectedFlux): num_z_bins: int Number of redshift bins to use for the analysis. - z_bins: np.ndarray + z_bin_edges: np.ndarray Bins in redshift used to compute the mean continuum. - - z_centers: np.ndarray - Centers of the redshift bins used to compute the mean continuum. - This is used to interpolate the mean continuum and its weights. """ def __init__(self, config): @@ -79,13 +75,12 @@ def __init__(self, config): ExpectedFluxError if Forest class variables are not set """ self.logger = logging.getLogger(__name__) - + # load variables from config self.interpolation_type = None self.limit_z = None self.num_z_bins = None - self.z_bins = None - self.z_centers = None + self.z_bin_edges = None self.__parse_config(config) self.mean_cont = None @@ -115,7 +110,7 @@ def __parse_config(self, config): f"Invalid interpolation type '{self.interpolation_type}' " f"required by MeanContinuum2dExpectedFlux. " f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") - + if self.interpolation_type == "2D": limit_z_string = config.get("limit z") if limit_z_string is None: @@ -138,9 +133,8 @@ def __parse_config(self, config): "Missing argument 'num z bins' required by MeanContinuum2dExpectedFlux") self.num_z_bins = num_z_bins - self.z_bins = np.linspace(self.limit_z[0], self.limit_z[1], + self.z_bin_edges = np.linspace(self.limit_z[0], self.limit_z[1], self.num_z_bins + 1) - self.z_centers = (self.z_bins[:-1] + self.z_bins[1:]) / 2 def _initialize_mean_continuum_arrays(self): """Initialize mean continuum arrays @@ -150,16 +144,16 @@ def _initialize_mean_continuum_arrays(self): # initialize the mean quasar continuum if self.interpolation_type == "2D": mean_cont = np.ones( - (self.z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size)) + (self.z_bin_edges.size, Forest.log_lambda_rest_frame_grid.size)) # fill_value cannot be "extrapolate" for RegularGridInterpolator # so we use 0.0 instead self.get_mean_cont = RegularGridInterpolator( - (self.z_centers, Forest.log_lambda_rest_frame_grid), + (self.z_bin_edges, Forest.log_lambda_rest_frame_grid), mean_cont, bounds_error=False, fill_value=0.0 ) elif self.interpolation_type == "1D": self.mean_cont = np.ones(Forest.log_lambda_rest_frame_grid.size) - + self.get_mean_cont = interp1d( Forest.log_lambda_rest_frame_grid, self.mean_cont, @@ -194,11 +188,11 @@ def compute_mean_cont(self, forests, which_cont=lambda forest: forest.continuum) f"Invalid interpolation type '{self.interpolation_type}' " f"required by MeanContinuum2dExpectedFlux. " f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") - + def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continuum): """Compute the mean quasar continuum over the whole sample. Then updates the value of self.get_mean_cont to contain it - The mean continuum is computed as a function of the rest-frame + The mean continuum is computed as a function of the rest-frame wavelength. Arguments @@ -209,22 +203,22 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu which_cont: Function or lambda Should return what to use as continuum given a forest """ - + """ # numba implementation shows a memory leak when using A_matrix = np.zeros( (Forest.log_lambda_rest_frame_grid.size, Forest.log_lambda_rest_frame_grid.size) ) - B_matrix = np.zeros(Forest.log_lambda_rest_frame_grid.size) + B_matrix = np.zeros(Forest.log_lambda_rest_frame_grid.size) context = multiprocessing.get_context('fork') with context.Pool(processes=self.num_processors) as pool: arguments = [( - Forest.log_lambda_rest_frame_grid, - forest.log_lambda, - forest.flux, - forest.continuum, - forest.z, + Forest.log_lambda_rest_frame_grid, + forest.log_lambda, + forest.flux, + forest.continuum, + forest.z, self.compute_forest_weights(forest, forest.continuum) ) for forest in forests if forest.bad_continuum_reason is None] @@ -243,7 +237,7 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu # Solve the linear system A_matrix * mean_cont = B_matrix self.mean_cont = np.linalg.solve(A_matrix, B_matrix) - + # update the interpolator with the mean continuum self.get_mean_cont = interp1d( Forest.log_lambda_rest_frame_grid, @@ -257,7 +251,7 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu A_matrix = np.zeros( (Forest.log_lambda_rest_frame_grid.size, Forest.log_lambda_rest_frame_grid.size) ) - B_matrix = np.zeros(Forest.log_lambda_rest_frame_grid.size) + B_matrix = np.zeros(Forest.log_lambda_rest_frame_grid.size) for forest in forests: if forest.bad_continuum_reason is not None: @@ -268,13 +262,13 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu coeffs, rf_wavelength_bin = interp_coeff_lambda( log_lambda_rf, Forest.log_lambda_rest_frame_grid) - + w = np.where(forest.continuum > 0) B_matrix[rf_wavelength_bin[w]] += weights[w] * coeffs[w] * forest.flux[w] / forest.continuum[w] - + w = np.where((forest.continuum > 0) & (rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1)) B_matrix[rf_wavelength_bin[w] + 1] += weights[w] * (1 - coeffs[w]) * forest.flux[w] / forest.continuum[w] - + A_matrix[rf_wavelength_bin, rf_wavelength_bin] += weights * coeffs * coeffs w = np.where(rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1) A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weights[w] * coeffs[w] * (1 - coeffs[w]) @@ -299,7 +293,7 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu "This may be due to a lack of coverage for some wavelengths." ) mean_cont, *_ = np.linalg.lstsq(A_matrix, B_matrix, rcond=None) - + # update the interpolator with the mean continuum self.get_mean_cont = interp1d( Forest.log_lambda_rest_frame_grid, @@ -310,7 +304,7 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continuum): """Compute the mean quasar continuum over the whole sample. Then updates the value of self.get_mean_cont to contain it - The mean continuum is computed as a function of the rest-frame + The mean continuum is computed as a function of the rest-frame wavelength and redshift. Arguments @@ -322,17 +316,17 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu Should return what to use as continuum given a forest """ self.logger.debug("Entering compute_mean_cont_2d") - # for simplicity we introduce a new index - # combined_bin = z_bin + N_z_bins * rf_wavelength_bin + # for simplicity we introduce a new index + # combined_bin = z_bin + N_z_bin_edges * rf_wavelength_bin # where z_bin is the index of the redshift bin and rf_wavelength_bin # is the index of the rest-frame wavelength bin. # This allows us to use a similar logic as in the 1D case. - matrix_size = self.num_z_bins * Forest.log_lambda_rest_frame_grid.size + matrix_size = self.z_bin_edges.size * Forest.log_lambda_rest_frame_grid.size A_matrix = np.zeros( (matrix_size, matrix_size) ) - B_matrix = np.zeros(matrix_size) + B_matrix = np.zeros(matrix_size) for forest in forests: if forest.bad_continuum_reason is not None: @@ -346,7 +340,7 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu one_minus_rf_wavelength_coeffs = 1 - rf_wavelength_coeffs z_coeffs, z_bin = interp_coeff_z( forest.z, - self.z_centers) + self.z_bin_edges) one_minus_z_coeffs = 1 - z_coeffs if any(rf_wavelength_coeffs < 0) or any(one_minus_rf_wavelength_coeffs < 0): @@ -370,15 +364,15 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu raise ExpectedFluxError( "Negative weights found in the forest weights. " "This should not happen, please report this issue.") - + # combined_bin is the index of the bin in the 2D matrix - combined_bin = z_bin + self.num_z_bins * rf_wavelength_bin - combined_bin_plus_wavelength = z_bin + self.num_z_bins * (rf_wavelength_bin + 1) - combined_bin_plus_z = z_bin + 1 + self.num_z_bins * (rf_wavelength_bin) - combined_bin_plus_both = z_bin + 1 + self.num_z_bins * (rf_wavelength_bin + 1) + combined_bin = z_bin + self.z_bin_edges.size * rf_wavelength_bin + combined_bin_plus_wavelength = z_bin + self.z_bin_edges.size * (rf_wavelength_bin + 1) + combined_bin_plus_z = z_bin + 1 + self.z_bin_edges.size * (rf_wavelength_bin) + combined_bin_plus_both = z_bin + 1 + self.z_bin_edges.size * (rf_wavelength_bin + 1) # Fill the B_matrix - w = np.where((forest.continuum > 0) & + w = np.where((forest.continuum > 0) & (combined_bin < matrix_size) & (combined_bin_plus_wavelength < matrix_size) & (combined_bin_plus_z < matrix_size) & @@ -446,16 +440,16 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu # Solve the linear system A_matrix * mean_cont = B_matrix mean_cont = np.linalg.solve(A_matrix, B_matrix) - # Undo the new indexing + # Undo the new indexing (needed to add transposition) self.mean_cont = mean_cont.reshape( - (self.num_z_bins, Forest.log_lambda_rest_frame_grid.size)) - + (Forest.log_lambda_rest_frame_grid.size , self.z_bin_edges.size)).T + # update the interpolator with the mean continuum self.get_mean_cont = RegularGridInterpolator( - (self.z_centers, Forest.log_lambda_rest_frame_grid), + (self.z_bin_edges, Forest.log_lambda_rest_frame_grid), self.mean_cont, bounds_error=False, fill_value=0.0, ) - + def hdu_cont(self, results): """Add to the results file an HDU with the continuum information @@ -466,16 +460,16 @@ def hdu_cont(self, results): """ if self.interpolation_type == "2D": # Create meshgrid for evaluation - z_meshgrid, log_lam_mesh_grid = np.meshgrid(self.z_centers, Forest.log_lambda_rest_frame_grid, indexing='ij') + z_meshgrid, log_lam_mesh_grid = np.meshgrid(self.z_bin_edges, Forest.log_lambda_rest_frame_grid, indexing='ij') points = np.stack([z_meshgrid.ravel(), log_lam_mesh_grid.ravel()], axis=-1) mean_cont_2d = self.get_mean_cont(points).reshape(z_meshgrid.shape) - + results.write([ z_meshgrid, log_lam_mesh_grid, mean_cont_2d, ], - names=['Z_CENTER', 'LOGLAM_REST', 'MEAN_CONT'], + names=['Z_BIN_EDGE', 'LOGLAM_REST', 'MEAN_CONT'], units=['', 'log(Angstrom)', Forest.flux_units], extname='CONT') results["CONT"].write_comment("2D mean quasar continuum (z, loglam)") @@ -495,7 +489,7 @@ def hdu_cont(self, results): raise ExpectedFluxError( f"Invalid interpolation type '{self.interpolation_type}' " f"required by MeanContinuum2dExpectedFlux. " - f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") + f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") @numba.njit() @@ -506,7 +500,7 @@ def interp_coeff_lambda(rf_wavelength, rf_wavelength_grid): --------- rf_wavelength: float or np.ndarray Rest-frame wavelength in Angstroms - + rf_wavelength_grid: np.ndarray Rest-frame wavelength nodes where the interpolation is defined @@ -534,7 +528,7 @@ def interp_coeff_z(z, z_grid): --------- z: float Redshift - + z: np.ndarray Redshift grid where the interpolation is defined @@ -558,7 +552,7 @@ def interp_coeff_z(z, z_grid): def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, continuum, redshift, weight): """Compute the mean quasar continuum over the whole sample. Then updates the value of self.get_mean_cont to contain it - The mean continuum is computed as a function of the rest-frame + The mean continuum is computed as a function of the rest-frame wavelength. Arguments @@ -578,7 +572,7 @@ def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, continuum coeffs, rf_wavelength_bin = interp_coeff_lambda( log_lambda_rf, log_lambda_rest_frame_grid) - + w = np.where(continuum > 0) B_matrix[rf_wavelength_bin[w]] += weight[w] * coeffs[w] * flux[w] / continuum[w] @@ -600,4 +594,4 @@ def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, continuum #A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weight[w] * coeffs[w] * (1 - coeffs[w]) #A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weight[w] * (1 - coeffs[w]) * (1 - coeffs[w]) - return A_matrix, B_matrix \ No newline at end of file + return A_matrix, B_matrix From e0b67f1bdc3a14d2416de9259e81f0014c0c82be Mon Sep 17 00:00:00 2001 From: Julien Guy Date: Mon, 25 Aug 2025 17:07:07 -0700 Subject: [PATCH 50/59] fix computation of B_matrix --- .../mean_continuum_interp_expected_flux.py | 20 +++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 06a469161..008b63191 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -8,7 +8,6 @@ from picca.delta_extraction.errors import ExpectedFluxError from picca.delta_extraction.astronomical_objects.forest import Forest -#from picca.delta_extraction.expected_fluxes.dr16_expected_flux import Dr16ExpectedFlux, defaults, accepted_options from picca.delta_extraction.expected_fluxes.dr16_fixed_fudge_expected_flux import Dr16FixedFudgeExpectedFlux, defaults, accepted_options from picca.delta_extraction.utils import (update_accepted_options, update_default_options, @@ -333,6 +332,11 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu continue log_lambda_rf = forest.log_lambda - np.log10(1 + forest.z) + + # get the mean continuum + points = np.column_stack([np.full_like(log_lambda_rf, forest.z), log_lambda_rf]) + forest_mean_cont = self.get_mean_cont(points) + weights = self.compute_forest_weights(forest, forest.continuum) rf_wavelength_coeffs, rf_wavelength_bin = interp_coeff_lambda( log_lambda_rf, @@ -372,12 +376,15 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu combined_bin_plus_both = z_bin + 1 + self.z_bin_edges.size * (rf_wavelength_bin + 1) # Fill the B_matrix - w = np.where((forest.continuum > 0) & + w = np.where((forest.continuum != 0) & (combined_bin < matrix_size) & (combined_bin_plus_wavelength < matrix_size) & (combined_bin_plus_z < matrix_size) & (combined_bin_plus_both < matrix_size)) - flux_over_cont = forest.flux[w] / forest.continuum[w] + + # we should divide only by the qso multiplicative term, not the whole continuum, so we multiply back by the mean continuum + flux_over_cont = (forest.flux[w] / forest.continuum[w]) * forest_mean_cont[w] + # diagonal elements B_matrix[combined_bin[w]] += weights[w] * z_coeffs * rf_wavelength_coeffs[w] * flux_over_cont # off-diagonal elements @@ -387,11 +394,8 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu # Fill the A_matrix # diagonal elements - w = np.where((combined_bin < matrix_size) & - (combined_bin_plus_wavelength < matrix_size) & - (combined_bin_plus_z < matrix_size) & - (combined_bin_plus_both < matrix_size)) - A_matrix[combined_bin, combined_bin] += weights * z_coeffs * z_coeffs * rf_wavelength_coeffs * rf_wavelength_coeffs + + A_matrix[combined_bin[w], combined_bin[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] # off-diagonal elements - wl aux = weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += aux From f653893af0db059069eaa5d5ac9ee398014188d5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 10 Sep 2025 10:40:22 +0200 Subject: [PATCH 51/59] linted code --- .../mean_continuum_interp_expected_flux.py | 358 +++++++++--------- .../delta_extraction/expected_fluxes/utils.py | 3 +- pylintrc | 4 +- 3 files changed, 189 insertions(+), 176 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 008b63191..755d0c01b 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -1,6 +1,5 @@ """This module defines the class MeanContinuumInterpExpectedFlux""" import logging -import multiprocessing import numba import numpy as np @@ -8,24 +7,23 @@ from picca.delta_extraction.errors import ExpectedFluxError from picca.delta_extraction.astronomical_objects.forest import Forest -from picca.delta_extraction.expected_fluxes.dr16_fixed_fudge_expected_flux import Dr16FixedFudgeExpectedFlux, defaults, accepted_options +from picca.delta_extraction.expected_fluxes.dr16_fixed_fudge_expected_flux import ( + Dr16FixedFudgeExpectedFlux, defaults, accepted_options) from picca.delta_extraction.utils import (update_accepted_options, - update_default_options, - ABSORBER_IGM) + update_default_options) -accepted_options = update_accepted_options(accepted_options, [ - "interpolation type", "limit z", "num z bins" -]) +accepted_options = update_accepted_options( + accepted_options, ["interpolation type", "limit z", "num z bins"]) -defaults = update_default_options( - defaults, { - "interpolation type": "1D", - "limit z": (1.8, 5.), - "num z bins": 3, - }) +defaults = update_default_options(defaults, { + "interpolation type": "1D", + "limit z": (1.8, 5.), + "num z bins": 3, +}) ACCEPTED_INTERPOLATION_TYPES = ["1D", "2D"] + class MeanContinuumInterpExpectedFlux(Dr16FixedFudgeExpectedFlux): """Class to the expected flux as done in the DR16 SDSS analysys The mean expected flux is calculated iteratively as explained in @@ -85,7 +83,6 @@ def __init__(self, config): self.mean_cont = None super().__init__(config) - def __parse_config(self, config): """Parse the configuration options @@ -103,7 +100,8 @@ def __parse_config(self, config): self.interpolation_type = config.get("interpolation type") if self.interpolation_type is None: raise ExpectedFluxError( - "Missing argument 'interpolation type' required by MeanContinuum2dExpectedFlux") + "Missing argument 'interpolation type' required by MeanContinuum2dExpectedFlux" + ) if self.interpolation_type not in ACCEPTED_INTERPOLATION_TYPES: raise ExpectedFluxError( f"Invalid interpolation type '{self.interpolation_type}' " @@ -114,7 +112,8 @@ def __parse_config(self, config): limit_z_string = config.get("limit z") if limit_z_string is None: raise ExpectedFluxError( - "Missing argument 'limit z' required by MeanContinuum2dExpectedFlux") + "Missing argument 'limit z' required by MeanContinuum2dExpectedFlux" + ) limit_z = limit_z_string.split(",") if limit_z[0].startswith("(") or limit_z[0].startswith("["): z_min = float(limit_z[0][1:]) @@ -129,11 +128,12 @@ def __parse_config(self, config): num_z_bins = config.getint("num z bins") if num_z_bins is None or num_z_bins < 1: raise ExpectedFluxError( - "Missing argument 'num z bins' required by MeanContinuum2dExpectedFlux") + "Missing argument 'num z bins' required by MeanContinuum2dExpectedFlux" + ) self.num_z_bins = num_z_bins self.z_bin_edges = np.linspace(self.limit_z[0], self.limit_z[1], - self.num_z_bins + 1) + self.num_z_bins + 1) def _initialize_mean_continuum_arrays(self): """Initialize mean continuum arrays @@ -148,24 +148,24 @@ def _initialize_mean_continuum_arrays(self): # so we use 0.0 instead self.get_mean_cont = RegularGridInterpolator( (self.z_bin_edges, Forest.log_lambda_rest_frame_grid), - mean_cont, bounds_error=False, fill_value=0.0 - ) + mean_cont, + bounds_error=False, + fill_value=0.0) elif self.interpolation_type == "1D": self.mean_cont = np.ones(Forest.log_lambda_rest_frame_grid.size) - self.get_mean_cont = interp1d( - Forest.log_lambda_rest_frame_grid, - self.mean_cont, - fill_value='extrapolate' - ) + self.get_mean_cont = interp1d(Forest.log_lambda_rest_frame_grid, + self.mean_cont, + fill_value='extrapolate') # this should never happen, but just in case - else: # pragma: no cover + else: # pragma: no cover raise ExpectedFluxError( f"Invalid interpolation type '{self.interpolation_type}' " f"required by MeanContinuum2dExpectedFlux. " f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") - def compute_mean_cont(self, forests, which_cont=lambda forest: forest.continuum): + def compute_mean_cont(self, + forests): """Compute the mean quasar continuum over the whole sample. Then updates the value of self.get_mean_cont to contain it @@ -173,22 +173,20 @@ def compute_mean_cont(self, forests, which_cont=lambda forest: forest.continuum) --------- forests: List of Forest A list of Forest from which to compute the deltas. - - which_cont: Function or lambda - Should return what to use as continuum given a forest """ if self.interpolation_type == "1D": - self.compute_mean_cont_1d(forests, which_cont) + self.compute_mean_cont_1d(forests) elif self.interpolation_type == "2D": - self.compute_mean_cont_2d(forests, which_cont) + self.compute_mean_cont_2d(forests) # this should never happen, but just in case - else: # pragma: no cover + else: # pragma: no cover raise ExpectedFluxError( f"Invalid interpolation type '{self.interpolation_type}' " f"required by MeanContinuum2dExpectedFlux. " f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") - def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continuum): + def compute_mean_cont_1d(self, + forests): """Compute the mean quasar continuum over the whole sample. Then updates the value of self.get_mean_cont to contain it The mean continuum is computed as a function of the rest-frame @@ -198,58 +196,10 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu --------- forests: List of Forest A list of Forest from which to compute the deltas. - - which_cont: Function or lambda - Should return what to use as continuum given a forest - """ - - """ - # numba implementation shows a memory leak when using - A_matrix = np.zeros( - (Forest.log_lambda_rest_frame_grid.size, Forest.log_lambda_rest_frame_grid.size) - ) - B_matrix = np.zeros(Forest.log_lambda_rest_frame_grid.size) - - context = multiprocessing.get_context('fork') - with context.Pool(processes=self.num_processors) as pool: - arguments = [( - Forest.log_lambda_rest_frame_grid, - forest.log_lambda, - forest.flux, - forest.continuum, - forest.z, - self.compute_forest_weights(forest, forest.continuum) - ) - for forest in forests if forest.bad_continuum_reason is None] - imap_it = pool.starmap(compute_mean_cont_1d, arguments) - - for partial_A_matrix, partial_B_matrix in imap_it: - A_matrix += partial_A_matrix - B_matrix += partial_B_matrix - - # Take care of unstable solutions - # If the diagonal of A_matrix is zero, we set it to 1.0 - # This is a workaround for the case where there is no coverage - # for some wavelengths. - w = np.diagonal(A_matrix) == 0 - A_matrix[w, w] = 1.0 - - # Solve the linear system A_matrix * mean_cont = B_matrix - self.mean_cont = np.linalg.solve(A_matrix, B_matrix) - - # update the interpolator with the mean continuum - self.get_mean_cont = interp1d( - Forest.log_lambda_rest_frame_grid, - self.mean_cont, - fill_value='extrapolate' - ) - - return """ - # Old implementation without numba and without parallelization - A_matrix = np.zeros( - (Forest.log_lambda_rest_frame_grid.size, Forest.log_lambda_rest_frame_grid.size) - ) + # implementation without numba and without parallelization + A_matrix = np.zeros((Forest.log_lambda_rest_frame_grid.size, + Forest.log_lambda_rest_frame_grid.size)) B_matrix = np.zeros(Forest.log_lambda_rest_frame_grid.size) for forest in forests: @@ -259,21 +209,28 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu log_lambda_rf = forest.log_lambda - np.log10(1 + forest.z) weights = self.compute_forest_weights(forest, forest.continuum) coeffs, rf_wavelength_bin = interp_coeff_lambda( - log_lambda_rf, - Forest.log_lambda_rest_frame_grid) + log_lambda_rf, Forest.log_lambda_rest_frame_grid) w = np.where(forest.continuum > 0) - B_matrix[rf_wavelength_bin[w]] += weights[w] * coeffs[w] * forest.flux[w] / forest.continuum[w] - - w = np.where((forest.continuum > 0) & (rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1)) - B_matrix[rf_wavelength_bin[w] + 1] += weights[w] * (1 - coeffs[w]) * forest.flux[w] / forest.continuum[w] - - A_matrix[rf_wavelength_bin, rf_wavelength_bin] += weights * coeffs * coeffs - w = np.where(rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1) - A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weights[w] * coeffs[w] * (1 - coeffs[w]) - A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weights[w] * coeffs[w] * (1 - coeffs[w]) - A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weights[w] * (1 - coeffs[w]) * (1 - coeffs[w]) - + B_matrix[rf_wavelength_bin[w]] += weights[w] * coeffs[ + w] * forest.flux[w] / forest.continuum[w] + + w = np.where((forest.continuum > 0) & ( + rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1)) + B_matrix[rf_wavelength_bin[w] + 1] += weights[w] * ( + 1 - coeffs[w]) * forest.flux[w] / forest.continuum[w] + + A_matrix[rf_wavelength_bin, + rf_wavelength_bin] += weights * coeffs * coeffs + w = np.where( + rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1) + A_matrix[rf_wavelength_bin[w] + 1, + rf_wavelength_bin[w]] += weights[w] * coeffs[w] * ( + 1 - coeffs[w]) + A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + + 1] += weights[w] * coeffs[w] * (1 - coeffs[w]) + A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + + 1] += weights[w] * (1 - coeffs[w]) * (1 - coeffs[w]) # Take care of unstable solutions # If the diagonal of A_matrix is zero, we set it to 1.0 @@ -283,24 +240,21 @@ def compute_mean_cont_1d(self, forests, which_cont=lambda forest: forest.continu A_matrix[w, w] = 1.0 # Solve the linear system A_matrix * mean_cont = B_matrix - self.mean_cont = np.linalg.solve(A_matrix, B_matrix) try: - mean_cont = np.linalg.solve(A_matrix, B_matrix) - except np.linalg.LinAlgError: + self.mean_cont = np.linalg.solve(A_matrix, B_matrix) + except np.linalg.LinAlgError as error: raise ExpectedFluxError( "The linear system could not be solved. " - "This may be due to a lack of coverage for some wavelengths." - ) - mean_cont, *_ = np.linalg.lstsq(A_matrix, B_matrix, rcond=None) + "This may be due to a lack of coverage for some " + "wavelengths.") from error # update the interpolator with the mean continuum - self.get_mean_cont = interp1d( - Forest.log_lambda_rest_frame_grid, - self.mean_cont, - fill_value='extrapolate' - ) + self.get_mean_cont = interp1d(Forest.log_lambda_rest_frame_grid, + self.mean_cont, + fill_value='extrapolate') - def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continuum): + def compute_mean_cont_2d(self, + forests): """Compute the mean quasar continuum over the whole sample. Then updates the value of self.get_mean_cont to contain it The mean continuum is computed as a function of the rest-frame @@ -310,9 +264,6 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu --------- forests: List of Forest A list of Forest from which to compute the deltas. - - which_cont: Function or lambda - Should return what to use as continuum given a forest """ self.logger.debug("Entering compute_mean_cont_2d") # for simplicity we introduce a new index @@ -322,9 +273,7 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu # This allows us to use a similar logic as in the 1D case. matrix_size = self.z_bin_edges.size * Forest.log_lambda_rest_frame_grid.size - A_matrix = np.zeros( - (matrix_size, matrix_size) - ) + A_matrix = np.zeros((matrix_size, matrix_size)) B_matrix = np.zeros(matrix_size) for forest in forests: @@ -334,20 +283,19 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu log_lambda_rf = forest.log_lambda - np.log10(1 + forest.z) # get the mean continuum - points = np.column_stack([np.full_like(log_lambda_rf, forest.z), log_lambda_rf]) + points = np.column_stack( + [np.full_like(log_lambda_rf, forest.z), log_lambda_rf]) forest_mean_cont = self.get_mean_cont(points) weights = self.compute_forest_weights(forest, forest.continuum) rf_wavelength_coeffs, rf_wavelength_bin = interp_coeff_lambda( - log_lambda_rf, - Forest.log_lambda_rest_frame_grid) + log_lambda_rf, Forest.log_lambda_rest_frame_grid) one_minus_rf_wavelength_coeffs = 1 - rf_wavelength_coeffs - z_coeffs, z_bin = interp_coeff_z( - forest.z, - self.z_bin_edges) + z_coeffs, z_bin = interp_coeff_z(forest.z, self.z_bin_edges) one_minus_z_coeffs = 1 - z_coeffs - if any(rf_wavelength_coeffs < 0) or any(one_minus_rf_wavelength_coeffs < 0): + if any(rf_wavelength_coeffs < 0) or any( + one_minus_rf_wavelength_coeffs < 0): raise ExpectedFluxError( "Negative coefficients found in the rest-frame wavelength interpolation. " "This should not happen, please report this issue.") @@ -359,11 +307,16 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu print("\n################################") print("################################") print("log_lambda weight ivar continuum eta var_lss fudge") - for weight, ivar, continuum, log_lambda in zip(weights, forest.ivar, forest.continuum, forest.log_lambda): + for weight, ivar, continuum, log_lambda in zip( + weights, forest.ivar, forest.continuum, + forest.log_lambda): var_lss = self.get_var_lss(log_lambda) eta = self.get_eta(log_lambda) fudge = self.get_fudge(log_lambda) - print(f"{log_lambda:.4f} {weight:.4f} {ivar:.4f} {continuum:.4f} {eta:.4f} {var_lss:.4f} {fudge:.4f}") + print( + f"{log_lambda:.4f} {weight:.4f} {ivar:.4f} {continuum:.4f} " + f"{eta:.4f} {var_lss:.4f} {fudge:.4f}" + ) raise ExpectedFluxError( "Negative weights found in the forest weights. " @@ -371,9 +324,12 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu # combined_bin is the index of the bin in the 2D matrix combined_bin = z_bin + self.z_bin_edges.size * rf_wavelength_bin - combined_bin_plus_wavelength = z_bin + self.z_bin_edges.size * (rf_wavelength_bin + 1) - combined_bin_plus_z = z_bin + 1 + self.z_bin_edges.size * (rf_wavelength_bin) - combined_bin_plus_both = z_bin + 1 + self.z_bin_edges.size * (rf_wavelength_bin + 1) + combined_bin_plus_wavelength = z_bin + self.z_bin_edges.size * ( + rf_wavelength_bin + 1) + combined_bin_plus_z = z_bin + 1 + self.z_bin_edges.size * ( + rf_wavelength_bin) + combined_bin_plus_both = z_bin + 1 + self.z_bin_edges.size * ( + rf_wavelength_bin + 1) # Fill the B_matrix w = np.where((forest.continuum != 0) & @@ -382,45 +338,81 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu (combined_bin_plus_z < matrix_size) & (combined_bin_plus_both < matrix_size)) - # we should divide only by the qso multiplicative term, not the whole continuum, so we multiply back by the mean continuum - flux_over_cont = (forest.flux[w] / forest.continuum[w]) * forest_mean_cont[w] + # we should divide only by the qso multiplicative term, not the + # whole continuum, so we multiply back by the mean continuum + flux_over_cont = (forest.flux[w] / + forest.continuum[w]) * forest_mean_cont[w] # diagonal elements - B_matrix[combined_bin[w]] += weights[w] * z_coeffs * rf_wavelength_coeffs[w] * flux_over_cont + B_matrix[combined_bin[w]] += weights[ + w] * z_coeffs * rf_wavelength_coeffs[w] * flux_over_cont # off-diagonal elements - B_matrix[combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * one_minus_rf_wavelength_coeffs[w] * flux_over_cont - B_matrix[combined_bin_plus_z[w]] += weights[w] * one_minus_z_coeffs * rf_wavelength_coeffs[w] * flux_over_cont - B_matrix[combined_bin_plus_both[w]] += weights[w] * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[w] * flux_over_cont + B_matrix[combined_bin_plus_wavelength[ + w]] += weights[w] * z_coeffs * one_minus_rf_wavelength_coeffs[ + w] * flux_over_cont + B_matrix[combined_bin_plus_z[ + w]] += weights[w] * one_minus_z_coeffs * rf_wavelength_coeffs[ + w] * flux_over_cont + B_matrix[combined_bin_plus_both[w]] += weights[ + w] * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[ + w] * flux_over_cont # Fill the A_matrix # diagonal elements - A_matrix[combined_bin[w], combined_bin[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + A_matrix[combined_bin[w], combined_bin[w]] += weights[ + w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[ + w] * rf_wavelength_coeffs[w] # off-diagonal elements - wl - aux = weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + aux = weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[ + w] * one_minus_rf_wavelength_coeffs[w] A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += aux A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += aux - A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[ + combined_bin_plus_wavelength[w], + combined_bin_plus_wavelength[w]] += weights[ + w] * z_coeffs * z_coeffs * one_minus_rf_wavelength_coeffs[ + w] * one_minus_rf_wavelength_coeffs[w] # off-diagonal elements - z - aux = weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + aux = weights[ + w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[ + w] * rf_wavelength_coeffs[w] A_matrix[combined_bin[w], combined_bin_plus_z[w]] += aux A_matrix[combined_bin_plus_z[w], combined_bin[w]] += aux - A_matrix[combined_bin_plus_z[w], combined_bin_plus_z[w]] += weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_z[w], combined_bin_plus_z[w]] += weights[ + w] * one_minus_z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[ + w] * rf_wavelength_coeffs[w] # off-diagonal elements - wl + z - aux = weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + aux = weights[ + w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[ + w] * one_minus_rf_wavelength_coeffs[w] A_matrix[combined_bin[w], combined_bin_plus_both[w]] += aux A_matrix[combined_bin_plus_both[w], combined_bin[w]] += aux - A_matrix[combined_bin_plus_both[w], combined_bin_plus_both[w]] += weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[ + combined_bin_plus_both[w], + combined_bin_plus_both[w]] += weights[ + w] * one_minus_z_coeffs * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[ + w] * one_minus_rf_wavelength_coeffs[w] # cross terms - wl, z - aux = weights[w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] - A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_z[w]] += aux - A_matrix[combined_bin_plus_z[w], combined_bin_plus_wavelength[w]] += aux + aux = weights[ + w] * z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[ + w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_wavelength[w], + combined_bin_plus_z[w]] += aux + A_matrix[combined_bin_plus_z[w], + combined_bin_plus_wavelength[w]] += aux # cross terms - wl, wl + z - aux = weights[w] * z_coeffs * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] - A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_both[w]] += aux - A_matrix[combined_bin_plus_both[w], combined_bin_plus_wavelength[w]] += aux + aux = weights[ + w] * z_coeffs * one_minus_z_coeffs * one_minus_rf_wavelength_coeffs[ + w] * one_minus_rf_wavelength_coeffs[w] + A_matrix[combined_bin_plus_wavelength[w], + combined_bin_plus_both[w]] += aux + A_matrix[combined_bin_plus_both[w], + combined_bin_plus_wavelength[w]] += aux # cross terms - z, wl + z - aux = weights[w] * one_minus_z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[w] * one_minus_rf_wavelength_coeffs[w] + aux = weights[ + w] * one_minus_z_coeffs * one_minus_z_coeffs * rf_wavelength_coeffs[ + w] * one_minus_rf_wavelength_coeffs[w] A_matrix[combined_bin_plus_z[w], combined_bin_plus_both[w]] += aux A_matrix[combined_bin_plus_both[w], combined_bin_plus_z[w]] += aux @@ -446,12 +438,14 @@ def compute_mean_cont_2d(self, forests, which_cont=lambda forest: forest.continu mean_cont = np.linalg.solve(A_matrix, B_matrix) # Undo the new indexing (needed to add transposition) self.mean_cont = mean_cont.reshape( - (Forest.log_lambda_rest_frame_grid.size , self.z_bin_edges.size)).T + (Forest.log_lambda_rest_frame_grid.size, self.z_bin_edges.size)).T # update the interpolator with the mean continuum self.get_mean_cont = RegularGridInterpolator( (self.z_bin_edges, Forest.log_lambda_rest_frame_grid), - self.mean_cont, bounds_error=False, fill_value=0.0, + self.mean_cont, + bounds_error=False, + fill_value=0.0, ) def hdu_cont(self, results): @@ -464,8 +458,13 @@ def hdu_cont(self, results): """ if self.interpolation_type == "2D": # Create meshgrid for evaluation - z_meshgrid, log_lam_mesh_grid = np.meshgrid(self.z_bin_edges, Forest.log_lambda_rest_frame_grid, indexing='ij') - points = np.stack([z_meshgrid.ravel(), log_lam_mesh_grid.ravel()], axis=-1) + z_meshgrid, log_lam_mesh_grid = np.meshgrid( + self.z_bin_edges, + Forest.log_lambda_rest_frame_grid, + indexing='ij') + points = np.stack([z_meshgrid.ravel(), + log_lam_mesh_grid.ravel()], + axis=-1) mean_cont_2d = self.get_mean_cont(points).reshape(z_meshgrid.shape) results.write([ @@ -473,23 +472,24 @@ def hdu_cont(self, results): log_lam_mesh_grid, mean_cont_2d, ], - names=['Z_BIN_EDGE', 'LOGLAM_REST', 'MEAN_CONT'], - units=['', 'log(Angstrom)', Forest.flux_units], - extname='CONT') - results["CONT"].write_comment("2D mean quasar continuum (z, loglam)") + names=['Z_BIN_EDGE', 'LOGLAM_REST', 'MEAN_CONT'], + units=['', 'log(Angstrom)', Forest.flux_units], + extname='CONT') + results["CONT"].write_comment( + "2D mean quasar continuum (z, loglam)") results["CONT"].write_checksum() elif self.interpolation_type == "1D": results.write([ Forest.log_lambda_rest_frame_grid, self.get_mean_cont(Forest.log_lambda_rest_frame_grid), ], - names=['LOGLAM_REST', 'MEAN_CONT'], - units=['log(Angstrom)', Forest.flux_units], - extname='CONT') + names=['LOGLAM_REST', 'MEAN_CONT'], + units=['log(Angstrom)', Forest.flux_units], + extname='CONT') results["CONT"].write_comment("Mean quasar continuum") results["CONT"].write_checksum() # this should never happen, but just in case - else: # pragma: no cover + else: # pragma: no cover raise ExpectedFluxError( f"Invalid interpolation type '{self.interpolation_type}' " f"required by MeanContinuum2dExpectedFlux. " @@ -520,10 +520,12 @@ def interp_coeff_lambda(rf_wavelength, rf_wavelength_grid): rf_wavelength_low = rf_wavelength_grid[rf_wavelength_bin] rf_wavelength_high = rf_wavelength_grid[rf_wavelength_bin + 1] - coeff = (rf_wavelength_high - rf_wavelength) / (rf_wavelength_high - rf_wavelength_low) + coeff = (rf_wavelength_high - rf_wavelength) / (rf_wavelength_high - + rf_wavelength_low) return coeff, rf_wavelength_bin + @numba.njit() def interp_coeff_z(z, z_grid): """Compute the interpolation coefficients for a given redshift. @@ -552,8 +554,10 @@ def interp_coeff_z(z, z_grid): return coeff, z_bin + @numba.njit() -def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, continuum, redshift, weight): +def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, + continuum, redshift, weight): """Compute the mean quasar continuum over the whole sample. Then updates the value of self.get_mean_cont to contain it The mean continuum is computed as a function of the rest-frame @@ -568,32 +572,38 @@ def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, continuum Should return what to use as continuum given a forest """ A_matrix = np.zeros( - (log_lambda_rest_frame_grid.size, log_lambda_rest_frame_grid.size) - ) + (log_lambda_rest_frame_grid.size, log_lambda_rest_frame_grid.size)) B_matrix = np.zeros(log_lambda_rest_frame_grid.size) log_lambda_rf = log_lambda - np.log10(1 + redshift) - coeffs, rf_wavelength_bin = interp_coeff_lambda( - log_lambda_rf, - log_lambda_rest_frame_grid) + coeffs, rf_wavelength_bin = interp_coeff_lambda(log_lambda_rf, + log_lambda_rest_frame_grid) w = np.where(continuum > 0) - B_matrix[rf_wavelength_bin[w]] += weight[w] * coeffs[w] * flux[w] / continuum[w] + B_matrix[ + rf_wavelength_bin[w]] += weight[w] * coeffs[w] * flux[w] / continuum[w] - w = np.where((continuum > 0) & (rf_wavelength_bin < log_lambda_rest_frame_grid.size - 1)) - B_matrix[rf_wavelength_bin[w] + 1] += weight[w] * (1 - coeffs[w]) * flux[w] / continuum[w] + w = np.where((continuum > 0) & + (rf_wavelength_bin < log_lambda_rest_frame_grid.size - 1)) + B_matrix[rf_wavelength_bin[w] + + 1] += weight[w] * (1 - coeffs[w]) * flux[w] / continuum[w] # diagonal elements #A_matrix[rf_wavelength_bin, rf_wavelength_bin] += weight * coeffs * coeffs for index in range(rf_wavelength_bin.size): - A_matrix[rf_wavelength_bin[index], rf_wavelength_bin[index]] += weight[index] * coeffs[index] * coeffs[index] + A_matrix[rf_wavelength_bin[index], rf_wavelength_bin[index]] += weight[ + index] * coeffs[index] * coeffs[index] # Off-diagonal elements w = np.where(rf_wavelength_bin < log_lambda_rest_frame_grid.size - 1) for index in w[0]: - A_matrix[rf_wavelength_bin[index] + 1, rf_wavelength_bin[index]] += weight[index] * coeffs[index] * (1 - coeffs[index]) - A_matrix[rf_wavelength_bin[index], rf_wavelength_bin[index] + 1] += weight[index] * coeffs[index] * (1 - coeffs[index]) - A_matrix[rf_wavelength_bin[index] + 1, rf_wavelength_bin[index] + 1] += weight[index] * (1 - coeffs[index]) * (1 - coeffs[index]) + A_matrix[rf_wavelength_bin[index] + 1, + rf_wavelength_bin[index]] += weight[index] * coeffs[index] * ( + 1 - coeffs[index]) + A_matrix[rf_wavelength_bin[index], rf_wavelength_bin[index] + + 1] += weight[index] * coeffs[index] * (1 - coeffs[index]) + A_matrix[rf_wavelength_bin[index] + 1, rf_wavelength_bin[index] + + 1] += weight[index] * (1 - coeffs[index]) * (1 - coeffs[index]) #A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weight[w] * coeffs[w] * (1 - coeffs[w]) #A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weight[w] * coeffs[w] * (1 - coeffs[w]) #A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weight[w] * (1 - coeffs[w]) * (1 - coeffs[w]) diff --git a/py/picca/delta_extraction/expected_fluxes/utils.py b/py/picca/delta_extraction/expected_fluxes/utils.py index 94d4f4c84..0c9a8f736 100644 --- a/py/picca/delta_extraction/expected_fluxes/utils.py +++ b/py/picca/delta_extraction/expected_fluxes/utils.py @@ -1,4 +1,6 @@ """This module defines the method compute_continuum to compute the quasar continua""" +import warnings + import iminuit import numpy as np from scipy.interpolate import RegularGridInterpolator @@ -92,7 +94,6 @@ def compute_continuum(forest, get_mean_cont, get_eta, get_var_lss, get_fudge, error = np.max([np.fabs(zero_point) / 2., 1e-6]) # debugging code - import warnings warnings.filterwarnings("error", category=iminuit.util.IMinuitWarning) with warnings.catch_warnings(): warnings.filterwarnings("error", category=iminuit.util.IMinuitWarning) diff --git a/pylintrc b/pylintrc index a40654f48..c4863a5d7 100644 --- a/pylintrc +++ b/pylintrc @@ -256,7 +256,7 @@ indent-after-paren=4 indent-string=' ' # Maximum number of characters on a single line. -max-line-length=100 +max-line-length=120 # Maximum number of lines in a module. max-module-lines=2000 @@ -376,6 +376,8 @@ good-names=i, t6, pk, ax, + A_matrix, + B_matrix, ExpectedFluxType, CorrectionType, DataType, From 875867a8b5238b0fd17f6d81356c1f2525ae7365 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 10 Sep 2025 11:01:27 +0200 Subject: [PATCH 52/59] removed new tests The file was using previous schemes and all the tests there had bugs. We need to add the new test file at some point --- .../delta_extraction/mean_cont2d_tests.py | 839 ------------------ 1 file changed, 839 deletions(-) delete mode 100644 py/picca/tests/delta_extraction/mean_cont2d_tests.py diff --git a/py/picca/tests/delta_extraction/mean_cont2d_tests.py b/py/picca/tests/delta_extraction/mean_cont2d_tests.py deleted file mode 100644 index b0da334eb..000000000 --- a/py/picca/tests/delta_extraction/mean_cont2d_tests.py +++ /dev/null @@ -1,839 +0,0 @@ -"""This file contains tests related to ExpectedFlux and its childs""" -from configparser import ConfigParser -import copy -import os -import unittest - -import numpy as np -from scipy.interpolate import interp1d, RegularGridInterpolator - -from picca.delta_extraction.errors import ExpectedFluxError -from picca.delta_extraction.data_catalogues.desi_healpix import DesiHealpix -from picca.delta_extraction.data_catalogues.desi_healpix import defaults as defaults_desi_healpix -from picca.delta_extraction.data_catalogues.sdss_data import SdssData -from picca.delta_extraction.data_catalogues.sdss_data import defaults as defaults_sdss_data -from picca.delta_extraction.expected_fluxes.dr16_expected_flux import ( - compute_continuum) -from picca.delta_extraction.expected_fluxes.dr16_expected_flux import ( - defaults as defaults_dr16_expected_flux) -from picca.delta_extraction.expected_fluxes.mean_continuum2d_expected_flux import ( - MeanContinuum2dExpectedFlux, defaults as defaults_mean_continuum2d_expected_flux) -from picca.tests.delta_extraction.abstract_test import AbstractTest -from picca.tests.delta_extraction.test_utils import setup_forest, reset_forest -from picca.tests.delta_extraction.test_utils import desi_healpix_kwargs -from picca.tests.delta_extraction.test_utils import sdss_data_kwargs - -THIS_DIR = os.path.dirname(os.path.abspath(__file__)) - -class ExpectedFluxTest(AbstractTest): - """Test class ExpectedFlux and its childs. - Methods - ------- - compare_ascii (from AbstractTest) - compare_fits (from AbstractTest) - setUp - tearDown - test_expected_flux - test_dr16_expected_flux - test_dr16_expected_flux_compute_continuum - test_dr16_expected_flux_compute_delta_stack - test_dr16_expected_flux_compute_expected_flux - test_dr16_expected_flux_compute_mean_cont_lin - test_dr16_expected_flux_compute_mean_cont_log - test_dr16_expected_flux_compute_var_stats - test_dr16_expected_flux_populate_los_ids - test_dr16_expected_flux_save_iteration_step - """ - def test_mean_continuum2d_expected_flux(self): - """Test constructor for class MeanContinuum2dExpectedFlux - Load an MeanContinuum2dExpectedFlux instance. - """ - config = ConfigParser() - config.read_dict( - {"expected flux": { - "iter out prefix": "iter_out_prefix", - "limit z": "(1.94, 4.5)", - "num processors": 1, - "num z bins": 2, - "out dir": f"{THIS_DIR}/results/", - }}) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - # this should raise an error as Forest variables are not defined - expected_message = ( - "Forest class variables need to be set before initializing " - "variables here.") - with self.assertRaises(ExpectedFluxError) as context_manager: - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - self.compare_error_message(context_manager, expected_message) - - # setup Forest variables; case: logarithmic wavelength solution - setup_forest("log", rebin=3) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - self.assertTrue(isinstance(expected_flux.get_eta, interp1d)) - self.assertTrue(isinstance(expected_flux.get_fudge, interp1d)) - self.assertTrue(isinstance(expected_flux.get_mean_cont, RegularGridInterpolator)) - self.assertTrue(isinstance(expected_flux.get_var_lss, interp1d)) - self.assertTrue(isinstance(expected_flux.log_lambda_var_func_grid, np.ndarray)) - - # setup Forest variables; case: linear wavelength solution - reset_forest() - setup_forest("lin") - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - self.assertTrue(isinstance(expected_flux.get_eta, interp1d)) - self.assertTrue(isinstance(expected_flux.get_fudge, interp1d)) - self.assertTrue(isinstance(expected_flux.get_mean_cont, RegularGridInterpolator)) - self.assertTrue(isinstance(expected_flux.get_var_lss, interp1d)) - self.assertTrue(isinstance(expected_flux.log_lambda_var_func_grid, np.ndarray)) - - def test_mean_continuum2d_expected_flux_compute_continuum_lin(self): - """Test method compute_continuum for class MeanContinuum2dExpectedFlux for - linear wavelength solution""" - setup_forest("lin") - - out_file = f"{THIS_DIR}/results/continua_2d_lin.txt" - test_file = f"{THIS_DIR}/data/continua_2d_lin.txt" - - # initialize DesiHealpix and MeanContinuum2dExpectedFlux instances - config = ConfigParser() - config.read_dict({ - "data": desi_healpix_kwargs, - "expected flux": { - "iter out prefix": "iter_out_prefix", - "out dir": f"{THIS_DIR}/results/", - "num processors": 1, - }, - }) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - for key, value in defaults_desi_healpix.items(): - if key not in config["data"]: - config["data"][key] = str(value) - data = DesiHealpix(config["data"]) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - # compute the forest continua - for forest in data.forests: - (cont_model, bad_continuum_reason, - continuum_fit_parameters) = compute_continuum(forest, - expected_flux.get_mean_cont, - expected_flux.get_eta, - expected_flux.get_var_lss, - expected_flux.get_fudge, - expected_flux.use_constant_weight, - expected_flux.order) - forest.bad_continuum_reason = bad_continuum_reason - forest.continuum = cont_model - - # save the results - f = open(out_file, "w") - f.write("# thingid cont[0] ... cont[N]\n") - for forest in data.forests: - f.write(f"{forest.los_id} ") - if forest.continuum is not None: - for item in forest.continuum: - f.write(f"{item} ") - f.write("\n") - f.close() - - # load expected forest continua - continua = {} - f = open(test_file) - for line in f.readlines(): - if line.startswith("#"): - continue - cols = line.split() - los_id = int(cols[0]) - if len(cols) == 1: - continuum = None - else: - continuum = np.array([float(item) for item in cols[1:]]) - continua[los_id] = continuum - f.close() - - # compare the results - correct_forests = 0 - for forest in data.forests: - if forest.continuum is None: - if continua.get(forest.los_id) is not None: - print(f"For forest with los_id {forest.los_id}, new continuum " - "is None. Expected continua:") - print(continua.get(forest.los_id)) - self.assertTrue(continua.get(forest.los_id) is None) - elif continua.get(forest.los_id) is None: - self.assertTrue(forest.continuum is None) - else: - if not np.allclose(forest.continuum, continua.get(forest.los_id)): - print("Difference found in forest.continuum") - print(f"forest.los_id: {forest.los_id}") - print(f"result test are_close result-test") - for i1, i2 in zip(forest.continuum, continua.get(forest.los_id)): - print(i1, i2, np.isclose(i1, i2), i1-i2) - self.assertTrue( - np.allclose(forest.continuum, continua.get(forest.los_id))) - correct_forests += 1 - - # check that we loaded all quasars - self.assertTrue(correct_forests == len(continua)) - - def test_mean_continuum2d_expected_flux_compute_continuum_log(self): - """Test method compute_continuum for class MeanContinuum2dExpectedFlux for - logarithmic wavelength solution""" - setup_forest("log", rebin=3) - - out_file = f"{THIS_DIR}/results/continua_2d_log.txt" - test_file = f"{THIS_DIR}/data/continua_2d_log.txt" - - # initialize Data and MeanContinuum2dExpectedFlux instances - config = ConfigParser() - config.read_dict({ - "data": sdss_data_kwargs, - "expected flux": { - "iter out prefix": "iter_out_prefix", - "out dir": f"{THIS_DIR}/results/", - "num processors": 1, - }, - }) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - for key, value in defaults_sdss_data.items(): - if key not in config["data"]: - config["data"][key] = str(value) - data = SdssData(config["data"]) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - # compute the forest continua - for forest in data.forests: - (cont_model, bad_continuum_reason, - continuum_fit_parameters) = compute_continuum(forest, - expected_flux.get_mean_cont, - expected_flux.get_eta, - expected_flux.get_var_lss, - expected_flux.get_fudge, - expected_flux.use_constant_weight, - expected_flux.order) - forest.bad_continuum_reason = bad_continuum_reason - forest.continuum = cont_model - - # save the results - f = open(out_file, "w") - f.write("# thingid cont[0] ... cont[N]\n") - for forest in data.forests: - f.write(f"{forest.los_id} ") - for item in forest.continuum: - f.write(f"{item} ") - f.write("\n") - f.close() - - # load expected forest continua - continua = {} - f = open(test_file) - for line in f.readlines(): - if line.startswith("#"): - continue - cols = line.split() - los_id = int(cols[0]) - continuum = np.array([float(item) for item in cols[1:]]) - continua[los_id] = continuum - f.close() - - # compare the results - correct_forests = 0 - for forest in data.forests: - if not np.allclose(forest.continuum, continua.get(forest.los_id)): - print("Difference found in forest.continuum") - print(f"forest.los_id: {forest.los_id}") - print(f"result test are_close result-test") - for i1, i2 in zip(forest.continuum, continua.get(forest.los_id)): - print(i1, i2, np.isclose(i1, i2), i1-i2) - self.assertTrue( - np.allclose(forest.continuum, continua.get(forest.los_id))) - correct_forests += 1 - - # check that we loaded all quasars - self.assertTrue(correct_forests == len(continua)) - - def test_mean_continuum2d_expected_flux_compute_delta_stack_lin(self): - """Test method compute_delta_stack for class MeanContinuum2dExpectedFlux for - linear wavelength solution""" - setup_forest("lin") - - out_file = f"{THIS_DIR}/results/delta_stack_lin.txt" - test_file = f"{THIS_DIR}/data/delta_stack_lin.txt" - - # initialize Data and Dr16ExpectedFlux instances - config = ConfigParser() - config.read_dict({ - "data": desi_healpix_kwargs, - "expected flux": { - "iter out prefix": "iter_out_prefix", - "out dir": f"{THIS_DIR}/results/", - "num processors": 1, - "var lss mod": 1.0, - }, - }) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - for key, value in defaults_desi_healpix.items(): - if key not in config["data"]: - config["data"][key] = str(value) - data = DesiHealpix(config["data"]) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - # compute the forest continua - for forest in data.forests: - (cont_model, bad_continuum_reason, - continuum_fit_parameters) = compute_continuum(forest, - expected_flux.get_mean_cont, - expected_flux.get_eta, - expected_flux.get_var_lss, - expected_flux.get_fudge, - expected_flux.use_constant_weight, - expected_flux.order) - forest.bad_continuum_reason = bad_continuum_reason - forest.continuum = cont_model - - # compute variance functions and statistics - expected_flux.compute_delta_stack(data.forests) - - # save results - f = open(out_file, "w") - f.write("# log_lambda delta\n") - for log_lambda in np.arange(3.5563025, 3.7123025 + 3e-4, 3e-4): - f.write(f"{log_lambda} {expected_flux.get_stack_delta(log_lambda)}\n") - f.close() - - # load expected delta stack - expectations = np.genfromtxt(test_file, names=True) - - # compare with obtained results - stack_delta = expected_flux.get_stack_delta(expectations["log_lambda"]) - if not np.allclose(stack_delta, expectations["delta"]): - print(f"\nOriginal file: {test_file}") - print(f"New file: {out_file}") - print("Difference found in delta stack") - print(f"result test are_close result-test") - for i1, i2 in zip(stack_delta, expectations["delta"]): - print(i1, i2, np.isclose(i1, i2), i1-i2) - self.assertTrue(np.allclose(stack_delta, expectations["delta"])) - - def test_mean_continuum2d_expected_flux_compute_delta_stack_log(self): - """Test method compute_delta_stack for class MeanContinuum2dExpectedFlux for - logarithmic wavelength solution""" - setup_forest("log", rebin=3) - - out_file = f"{THIS_DIR}/results/delta_stack_2d_log.txt" - test_file = f"{THIS_DIR}/data/delta_stack_2d_log.txt" - - # initialize Data and MeanContinuum2dExpectedFlux instances - config = ConfigParser() - config.read_dict({ - "data": sdss_data_kwargs, - "expected flux": { - "iter out prefix": "iter_out_prefix", - "out dir": f"{THIS_DIR}/results/", - "num processors": 1 - }, - }) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - for key, value in defaults_sdss_data.items(): - if key not in config["data"]: - config["data"][key] = str(value) - data = SdssData(config["data"]) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - # compute the forest continua - for forest in data.forests: - (cont_model, bad_continuum_reason, - continuum_fit_parameters) = compute_continuum(forest, - expected_flux.get_mean_cont, - expected_flux.get_eta, - expected_flux.get_var_lss, - expected_flux.get_fudge, - expected_flux.use_constant_weight, - expected_flux.order) - forest.bad_continuum_reason = bad_continuum_reason - forest.continuum = cont_model - - # compute variance functions and statistics - expected_flux.compute_delta_stack(data.forests) - - # save results - f = open(out_file, "w") - f.write("# log_lambda delta\n") - for log_lambda in np.arange(3.5563025, 3.7123025 + 3e-4, 3e-4): - f.write(f"{log_lambda} {expected_flux.get_stack_delta(log_lambda)}\n") - f.close() - - # load expected delta stack - expectations = np.genfromtxt(test_file, names=True) - - # compare with obtained results - stack_delta = expected_flux.get_stack_delta(expectations["log_lambda"]) - if not np.allclose(stack_delta, expectations["delta"]): - print(f"\nOriginal file: {test_file}") - print(f"New file: {out_file}") - print("Difference found in delta stack") - print(f"result test are_close result-test") - for i1, i2 in zip(stack_delta, expectations["delta"]): - print(i1, i2, np.isclose(i1, i2), i1-i2) - self.assertTrue(np.allclose(stack_delta, expectations["delta"])) - - def test_mean_continuum2d_expected_flux_compute_expected_flux_lin(self): - """Test method compute_var_stats for class MeanContinuum2dExpectedFlux for - linear wavelength solution""" - setup_forest("lin") - - out_file = f"{THIS_DIR}/results/Log/iter_out_prefix_compute_expected_flux_2d_lin.fits.gz" - test_file = f"{THIS_DIR}/data/iter_out_prefix_compute_expected_flux_2d_lin.fits.gz" - - # initialize Data and MeanContinuum2dExpectedFlux instances - config = ConfigParser() - config.read_dict({ - "data": desi_healpix_kwargs, - "expected flux": { - "iter out prefix": "iter_out_prefix_compute_expected_flux_2d_lin", - "out dir": f"{THIS_DIR}/results/", - "num processors": 1, - }, - }) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - for key, value in defaults_desi_healpix.items(): - if key not in config["data"]: - config["data"][key] = str(value) - data = DesiHealpix(config["data"]) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - # compute the expected flux - expected_flux.compute_expected_flux(data.forests) - - # check the results - for iteration in range(1, 5): - self.compare_fits( - test_file.replace(".fits", f"_iteration{iteration}.fits"), - out_file.replace(".fits", f"_iteration{iteration}.fits")) - self.compare_fits(test_file, out_file) - - def test_mean_continuum2d_expected_flux_compute_expected_flux_log(self): - """Test method compute_var_stats for class MeanContinuum2dExpectedFlux for - logarithmic wavelength solution""" - setup_forest("log", rebin=3) - - out_file = f"{THIS_DIR}/results/Log/iter_out_prefix_compute_expected_flux_2d_log.fits.gz" - test_file = f"{THIS_DIR}/data/iter_out_prefix_compute_expected_flux_2d_log.fits.gz" - - # initialize Data and Dr16ExpectedFlux instances - config = ConfigParser() - config.read_dict({ - "data": sdss_data_kwargs, - "expected flux": { - "iter out prefix": "iter_out_prefix_compute_expected_flux_2d_log", - "out dir": f"{THIS_DIR}/results/", - "num processors": 1 - }, - }) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - for key, value in defaults_sdss_data.items(): - if key not in config["data"]: - config["data"][key] = str(value) - data = SdssData(config["data"]) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - # compute the expected flux - expected_flux.compute_expected_flux(data.forests) - - # check the results - for iteration in range(1, 5): - self.compare_fits( - test_file.replace(".fits", f"_iteration{iteration}.fits"), - out_file.replace(".fits", f"_iteration{iteration}.fits")) - self.compare_fits(test_file, out_file) - - def test_mean_continuum2d_expected_flux_compute_mean_cont_lin(self): - """Test method compute_mean_cont_lin for class MeanContinuum2dExpectedFlux - for linear wavelength solution""" - setup_forest("lin") - - out_file = f"{THIS_DIR}/results/mean_cont_2d_lin.txt" - test_file = f"{THIS_DIR}/data/mean_cont_2d_lin.txt" - - # initialize Data and MeanContinuum2dExpectedFlux instances - config = ConfigParser() - config.read_dict({ - "data": desi_healpix_kwargs, - "expected flux": { - "iter out prefix": "iter_out_prefix", - "out dir": f"{THIS_DIR}/results/", - "num processors": 1, - }, - }) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - for key, value in defaults_desi_healpix.items(): - if key not in config["data"]: - config["data"][key] = str(value) - data = DesiHealpix(config["data"]) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - # compute the forest continua - for forest in data.forests: - (cont_model, bad_continuum_reason, - continuum_fit_parameters) = compute_continuum(forest, - expected_flux.get_mean_cont, - expected_flux.get_eta, - expected_flux.get_var_lss, - expected_flux.get_fudge, - expected_flux.use_constant_weight, - expected_flux.order) - forest.bad_continuum_reason = bad_continuum_reason - forest.continuum = cont_model - - # compute mean quasar continuum - expected_flux.compute_mean_cont(data.forests) - - # save results - f = open(out_file, "w") - f.write("# log_lambda mean_cont\n") - for log_lambda in np.arange(3.0171, 3.079 + 3e-4, 3e-4): - f.write(f"{log_lambda} {expected_flux.get_mean_cont(log_lambda)}\n") - f.close() - - # load the expected results - expectations = np.genfromtxt(test_file, names=True) - - # compare with obtained results - mean_cont = expected_flux.get_mean_cont(expectations["log_lambda"]) - if not np.allclose(mean_cont, expectations["mean_cont"]): - print(f"\nOriginal file: {test_file}") - print(f"New file: {out_file}") - print("Difference found in mean_cont") - print(f"result test are_close result-test") - for i1, i2 in zip(mean_cont, expectations["mean_cont"]): - print(i1, i2, np.isclose(i1, i2), i1-i2) - self.assertTrue(np.allclose(mean_cont, expectations["mean_cont"])) - - def test_mean_continuum2d_expected_flux_compute_mean_cont_log(self): - """Test method compute_mean_cont_log for class MeanContinuum2dExpectedFlux for - logarithmic wavelength solution""" - setup_forest("log", rebin=3) - - out_file = f"{THIS_DIR}/results/mean_cont_2d_log.txt" - test_file = f"{THIS_DIR}/data/mean_cont_2d_log.txt" - - # initialize Data and MeanContinuum2dExpectedFlux instances - config = ConfigParser() - config.read_dict({ - "data": sdss_data_kwargs, - "expected flux": { - "iter out prefix": "iter_out_prefix", - "out dir": f"{THIS_DIR}/results/", - "num processors": 1 - }, - }) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - for key, value in defaults_sdss_data.items(): - if key not in config["data"]: - config["data"][key] = str(value) - data = SdssData(config["data"]) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - # compute the forest continua - for forest in data.forests: - (cont_model, bad_continuum_reason, - continuum_fit_parameters) = compute_continuum(forest, - expected_flux.get_mean_cont, - expected_flux.get_eta, - expected_flux.get_var_lss, - expected_flux.get_fudge, - expected_flux.use_constant_weight, - expected_flux.order) - forest.bad_continuum_reason = bad_continuum_reason - forest.continuum = cont_model - - # compute mean quasar continuum - expected_flux.compute_mean_cont(data.forests) - - # save results - f = open(out_file, "w") - f.write("# log_lambda mean_cont\n") - for log_lambda in np.arange(3.0171, 3.079 + 3e-4, 3e-4): - f.write(f"{log_lambda} {expected_flux.get_mean_cont(log_lambda)}\n") - f.close() - - # load the expected results - expectations = np.genfromtxt(test_file, names=True) - - # compare with obtained results - mean_cont = expected_flux.get_mean_cont(expectations["log_lambda"]) - if not np.allclose(mean_cont, expectations["mean_cont"]): - print(f"\nOriginal file: {test_file}") - print(f"New file: {out_file}") - print("Difference found in mean_cont") - print(f"result test are_close result-test") - for i1, i2 in zip(mean_cont, expectations["mean_cont"]): - print(i1, i2, np.isclose(i1, i2), i1-i2) - self.assertTrue(np.allclose(mean_cont, expectations["mean_cont"])) - - def test_mean_continuum2d_expected_flux_compute_var_stats_lin(self): - """Test method compute_var_stats for class MeanContinuum2dExpectedFlux with - linear wavelength solution - """ - setup_forest("lin") - - out_file = f"{THIS_DIR}/results/var_stats_2d_lin.txt" - test_file = f"{THIS_DIR}/data/var_stats_2d_lin.txt" - - # initialize Data and MeanContinuum2dExpectedFlux instances - config = ConfigParser() - config.read_dict({ - "data": desi_healpix_kwargs, - "expected flux": { - "iter out prefix": "iter_out_prefix", - "out dir": f"{THIS_DIR}/results/", - "num processors": 1, - }, - }) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - for key, value in defaults_desi_healpix.items(): - if key not in config["data"]: - config["data"][key] = str(value) - data = DesiHealpix(config["data"]) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - # compute the forest continua - for forest in data.forests: - (cont_model, bad_continuum_reason, - continuum_fit_parameters) = compute_continuum(forest, - expected_flux.get_mean_cont, - expected_flux.get_eta, - expected_flux.get_var_lss, - expected_flux.get_fudge, - expected_flux.use_constant_weight, - expected_flux.order) - forest.bad_continuum_reason = bad_continuum_reason - forest.continuum = cont_model - - # compute variance functions and statistics - expected_flux.compute_var_stats(data.forests) - - # save results - f = open(out_file, "w") - f.write("#log_lambda eta var_lss fudge num_pixels valid_fit\n") - for log_lambda in expected_flux.log_lambda_var_func_grid: - f.write(f"{log_lambda} ") - f.write(f"{expected_flux.get_eta(log_lambda)} ") - f.write(f"{expected_flux.get_var_lss(log_lambda)} ") - f.write(f"{expected_flux.get_fudge(log_lambda)} ") - f.write(f"{expected_flux.get_num_pixels(log_lambda)} ") - f.write(f"{expected_flux.get_valid_fit(log_lambda)} ") - f.write("\n") - f.close() - - # load the expected results - expectations = np.genfromtxt(test_file, names=True) - - # compare with obtained results - eta = expected_flux.get_eta(expectations["log_lambda"]) - var_lss = expected_flux.get_var_lss(expectations["log_lambda"]) - fudge = expected_flux.get_fudge(expectations["log_lambda"]) - num_pixels = expected_flux.get_num_pixels(expectations["log_lambda"]) - valid_fit = expected_flux.get_valid_fit(expectations["log_lambda"]) - self.assertTrue(np.allclose(eta, expectations["eta"])) - self.assertTrue(np.allclose(var_lss, expectations["var_lss"])) - self.assertTrue(np.allclose(fudge, expectations["fudge"])) - self.assertTrue(np.allclose(num_pixels, expectations["num_pixels"])) - self.assertTrue(np.allclose(valid_fit, expectations["valid_fit"])) - - def test_mean_continuum2d_expected_flux_compute_var_stats_log(self): - """Test method compute_var_stats for class MeanContinuum2dExpectedFlux with - logarithmic wavelength solution - """ - setup_forest("log", rebin=3) - - out_file = f"{THIS_DIR}/results/var_stats_2d_log.txt" - test_file = f"{THIS_DIR}/data/var_stats_2d_log.txt" - - # initialize Data and MeanContinuum2dExpectedFlux instances - config = ConfigParser() - config.read_dict({ - "data": sdss_data_kwargs, - "expected flux": { - "iter out prefix": "iter_out_prefix", - "out dir": f"{THIS_DIR}/results/", - "num processors": 1 - }, - }) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - for key, value in defaults_sdss_data.items(): - if key not in config["data"]: - config["data"][key] = str(value) - data = SdssData(config["data"]) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - # compute the forest continua - for forest in data.forests: - (cont_model, bad_continuum_reason, - continuum_fit_parameters) = compute_continuum(forest, - expected_flux.get_mean_cont, - expected_flux.get_eta, - expected_flux.get_var_lss, - expected_flux.get_fudge, - expected_flux.use_constant_weight, - expected_flux.order) - forest.bad_continuum_reason = bad_continuum_reason - forest.continuum = cont_model - - # compute variance functions and statistics - expected_flux.compute_var_stats(data.forests) - - # save results - f = open(out_file, "w") - f.write("#log_lambda eta var_lss fudge num_pixels valid_fit\n") - for log_lambda in expected_flux.log_lambda_var_func_grid: - f.write(f"{log_lambda} ") - f.write(f"{expected_flux.get_eta(log_lambda)} ") - f.write(f"{expected_flux.get_var_lss(log_lambda)} ") - f.write(f"{expected_flux.get_fudge(log_lambda)} ") - f.write(f"{expected_flux.get_num_pixels(log_lambda)} ") - f.write(f"{expected_flux.get_valid_fit(log_lambda)} ") - f.write("\n") - f.close() - - # load the expected results - expectations = np.genfromtxt(test_file, names=True) - - # compare with obtained results - eta = expected_flux.get_eta(expectations["log_lambda"]) - var_lss = expected_flux.get_var_lss(expectations["log_lambda"]) - fudge = expected_flux.get_fudge(expectations["log_lambda"]) - num_pixels = expected_flux.get_num_pixels(expectations["log_lambda"]) - valid_fit = expected_flux.get_valid_fit(expectations["log_lambda"]) - self.assertTrue(np.allclose(eta, expectations["eta"])) - self.assertTrue(np.allclose(var_lss, expectations["var_lss"])) - self.assertTrue(np.allclose(fudge, expectations["fudge"])) - self.assertTrue(np.allclose(num_pixels, expectations["num_pixels"])) - self.assertTrue(np.allclose(valid_fit, expectations["valid_fit"])) - - def test_mean_continuum2d_expected_flux_parse_config(self): - """Test method __parse_config for class MeanContinuum2dExpectedFlux""" - # Forest variables need to be initialize to finish ExpectedFlux.__init__ - setup_forest("log", rebin=3) - - # create a MeanContinuum2dExpectedFlux with missing 'limit z' - config = ConfigParser() - config.read_dict({"expected_flux": { - }}) - expected_message = ( - "Missing argument 'limit z' required by MeanContinuum2dExpectedFlux" - ) - with self.assertRaises(ExpectedFluxError) as context_manager: - MeanContinuum2dExpectedFlux(config["expected_flux"]) - self.compare_error_message(context_manager, expected_message) - - # create a MeanContinuum2dExpectedFlux with missing 'num z bins' - config = ConfigParser() - config.read_dict({"expected_flux": { - "limit z": "(1.94, 4.5)", - }}) - expected_message = ( - "Missing argument 'num z bins' required by MeanContinuum2dExpectedFlux" - ) - with self.assertRaises(ExpectedFluxError) as context_manager: - MeanContinuum2dExpectedFlux(config["expected_flux"]) - self.compare_error_message(context_manager, expected_message) - - # create a MeanContinuum2dExpectedFlux with missing ExpectedFlux Options - config = ConfigParser() - config.read_dict({"expected_flux": { - "limit z": "(1.94, 4.5)", - "num z bins": 2, - }}) - expected_message = ( - "Missing argument 'iter out prefix' required by ExpectedFlux" - ) - with self.assertRaises(ExpectedFluxError) as context_manager: - MeanContinuum2dExpectedFlux(config["expected_flux"]) - self.compare_error_message(context_manager, expected_message) - - # create a MeanContinuum2dExpectedFlux with missing Dr16ExpectedFlux Options - config = ConfigParser() - config.read_dict({"expected_flux": { - "iter out prefix": f"iter_out_prefix", - "out dir": f"{THIS_DIR}/results/", - "limit z": "(1.94, 4.5)", - "num bins variance": 20, - "num processors": 1, - "num z bins": 2, - "var lss mod": 1.0, - }}) - expected_message = ( - "Missing argument 'force stack delta to zero' required by Dr16ExpectedFlux" - ) - with self.assertRaises(ExpectedFluxError) as context_manager: - MeanContinuum2dExpectedFlux(config["expected_flux"]) - self.compare_error_message(context_manager, expected_message) - - def test_mean_continuum2d_expected_flux_populate_los_ids(self): - """Test method populate_los_ids for class MeanContinuum2dExpectedFlux""" - # setup Forest variables; case: logarithmic wavelength solution - setup_forest("log", rebin=3) - - # initialize Data and MeanContinuum2dExpectedFlux instances - config = ConfigParser() - config.read_dict({ - "data": sdss_data_kwargs, - "expected flux": { - "iter out prefix": "iter_out_prefix_2d_log", - "out dir": f"{THIS_DIR}/results/", - "num processors": 1 - }, - }) - for key, value in defaults_dr16_expected_flux.items(): - if key not in config["expected flux"]: - config["expected flux"][key] = str(value) - for key, value in defaults_sdss_data.items(): - if key not in config["data"]: - config["data"][key] = str(value) - data = SdssData(config["data"]) - expected_flux = MeanContinuum2dExpectedFlux(config["expected flux"]) - - # compute the forest continua - for forest in data.forests: - (cont_model, bad_continuum_reason, - continuum_fit_parameters) = compute_continuum(forest, - expected_flux.get_mean_cont, - expected_flux.get_eta, - expected_flux.get_var_lss, - expected_flux.get_fudge, - expected_flux.use_constant_weight, - expected_flux.order) - forest.bad_continuum_reason = bad_continuum_reason - forest.continuum = cont_model - - # compute variance functions and statistics - expected_flux.compute_delta_stack(data.forests) - - # save iter_out_prefix for iteration 0 - expected_flux.populate_los_ids(data.forests) - -if __name__ == '__main__': - unittest.main() From 937c1064727c6e2d4c1427168e2c855d227702b2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 10 Sep 2025 11:05:12 +0200 Subject: [PATCH 53/59] fixing pylint version to avoid bugs --- .github/workflows/pylint.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pylint.yml b/.github/workflows/pylint.yml index bd536fbc2..b4f77274f 100644 --- a/.github/workflows/pylint.yml +++ b/.github/workflows/pylint.yml @@ -25,7 +25,7 @@ jobs: sudo apt-get -y install libbz2-dev python -m pip install --upgrade pip if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - pip install pylint + pip install pylint==3.3.7 - name: This path run: | ls From 14001e8c5d2f8b02481d333f716c197551c78106 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Wed, 17 Sep 2025 10:36:46 +0200 Subject: [PATCH 54/59] Update py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .../expected_fluxes/mean_continuum_interp_expected_flux.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index 755d0c01b..ddacccb4e 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -100,19 +100,19 @@ def __parse_config(self, config): self.interpolation_type = config.get("interpolation type") if self.interpolation_type is None: raise ExpectedFluxError( - "Missing argument 'interpolation type' required by MeanContinuum2dExpectedFlux" + "Missing argument 'interpolation type' required by MeanContinuumInterpExpectedFlux" ) if self.interpolation_type not in ACCEPTED_INTERPOLATION_TYPES: raise ExpectedFluxError( f"Invalid interpolation type '{self.interpolation_type}' " - f"required by MeanContinuum2dExpectedFlux. " + f"required by MeanContinuumInterpExpectedFlux. " f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") if self.interpolation_type == "2D": limit_z_string = config.get("limit z") if limit_z_string is None: raise ExpectedFluxError( - "Missing argument 'limit z' required by MeanContinuum2dExpectedFlux" + "Missing argument 'limit z' required by MeanContinuumInterpExpectedFlux" ) limit_z = limit_z_string.split(",") if limit_z[0].startswith("(") or limit_z[0].startswith("["): From 2bf3e3a27facd3377192a1d460835f62720ca29a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 23 Sep 2025 12:53:37 +0200 Subject: [PATCH 55/59] removed forced pylint version --- .github/workflows/pylint.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pylint.yml b/.github/workflows/pylint.yml index b4f77274f..bd536fbc2 100644 --- a/.github/workflows/pylint.yml +++ b/.github/workflows/pylint.yml @@ -25,7 +25,7 @@ jobs: sudo apt-get -y install libbz2-dev python -m pip install --upgrade pip if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - pip install pylint==3.3.7 + pip install pylint - name: This path run: | ls From 07e62f9275d59c60776f433b69761ac8b85d1747 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 23 Sep 2025 12:59:36 +0200 Subject: [PATCH 56/59] fixed error messages, removed leftover debugging code --- .../mean_continuum_interp_expected_flux.py | 48 +++++++++---------- 1 file changed, 23 insertions(+), 25 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index ddacccb4e..af42655be 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -128,7 +128,7 @@ def __parse_config(self, config): num_z_bins = config.getint("num z bins") if num_z_bins is None or num_z_bins < 1: raise ExpectedFluxError( - "Missing argument 'num z bins' required by MeanContinuum2dExpectedFlux" + "Missing argument 'num z bins' required by MeanContinuumInterpExpectedFlux" ) self.num_z_bins = num_z_bins @@ -161,7 +161,7 @@ def _initialize_mean_continuum_arrays(self): else: # pragma: no cover raise ExpectedFluxError( f"Invalid interpolation type '{self.interpolation_type}' " - f"required by MeanContinuum2dExpectedFlux. " + f"required by MeanContinuumInterpExpectedFlux. " f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") def compute_mean_cont(self, @@ -182,7 +182,7 @@ def compute_mean_cont(self, else: # pragma: no cover raise ExpectedFluxError( f"Invalid interpolation type '{self.interpolation_type}' " - f"required by MeanContinuum2dExpectedFlux. " + f"required by MeanContinuumInterpExpectedFlux. " f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") def compute_mean_cont_1d(self, @@ -304,20 +304,6 @@ def compute_mean_cont_2d(self, "Negative coefficients found in the redshift interpolation. " "This should not happen, please report this issue.") if any(weights < 0): - print("\n################################") - print("################################") - print("log_lambda weight ivar continuum eta var_lss fudge") - for weight, ivar, continuum, log_lambda in zip( - weights, forest.ivar, forest.continuum, - forest.log_lambda): - var_lss = self.get_var_lss(log_lambda) - eta = self.get_eta(log_lambda) - fudge = self.get_fudge(log_lambda) - print( - f"{log_lambda:.4f} {weight:.4f} {ivar:.4f} {continuum:.4f} " - f"{eta:.4f} {var_lss:.4f} {fudge:.4f}" - ) - raise ExpectedFluxError( "Negative weights found in the forest weights. " "This should not happen, please report this issue.") @@ -492,7 +478,7 @@ def hdu_cont(self, results): else: # pragma: no cover raise ExpectedFluxError( f"Invalid interpolation type '{self.interpolation_type}' " - f"required by MeanContinuum2dExpectedFlux. " + f"required by MeanContinuumInterpExpectedFlux. " f"Accepted values are {ACCEPTED_INTERPOLATION_TYPES}") @@ -535,7 +521,7 @@ def interp_coeff_z(z, z_grid): z: float Redshift - z: np.ndarray + z_grid: np.ndarray Redshift grid where the interpolation is defined Returns @@ -568,8 +554,20 @@ def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, log_lambda_rest_frame_grid: np.ndarray A 1D array of rest-frame wavelengths (in Angstroms) where the continuum is defined. - which_cont: Function or lambda - Should return what to use as continuum given a forest + log_lambda: np.ndarray + A 1D array of observed wavelengths (in Angstroms). + + flux: np.ndarray + A 1D array of observed fluxes. + + continuum: np.ndarray + A 1D array of quasar continua. + + redshift: float + The redshift of the quasar. + + weight: np.ndarray + A 1D array of weights for each pixel. """ A_matrix = np.zeros( (log_lambda_rest_frame_grid.size, log_lambda_rest_frame_grid.size)) @@ -595,6 +593,9 @@ def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, index] * coeffs[index] * coeffs[index] # Off-diagonal elements + #A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weight[w] * coeffs[w] * (1 - coeffs[w]) + #A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weight[w] * coeffs[w] * (1 - coeffs[w]) + #A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weight[w] * (1 - coeffs[w]) * (1 - coeffs[w]) w = np.where(rf_wavelength_bin < log_lambda_rest_frame_grid.size - 1) for index in w[0]: A_matrix[rf_wavelength_bin[index] + 1, @@ -604,8 +605,5 @@ def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, 1] += weight[index] * coeffs[index] * (1 - coeffs[index]) A_matrix[rf_wavelength_bin[index] + 1, rf_wavelength_bin[index] + 1] += weight[index] * (1 - coeffs[index]) * (1 - coeffs[index]) - #A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weight[w] * coeffs[w] * (1 - coeffs[w]) - #A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weight[w] * coeffs[w] * (1 - coeffs[w]) - #A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weight[w] * (1 - coeffs[w]) * (1 - coeffs[w]) - + return A_matrix, B_matrix From a66b97d18ec9424672d9a7c775fa434f7cc4c609 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 23 Sep 2025 14:50:51 +0200 Subject: [PATCH 57/59] fixed spelling, removed unused function --- .../mean_continuum_interp_expected_flux.py | 70 +------------------ 1 file changed, 1 insertion(+), 69 deletions(-) diff --git a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py index af42655be..10a67615a 100644 --- a/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py +++ b/py/picca/delta_extraction/expected_fluxes/mean_continuum_interp_expected_flux.py @@ -25,7 +25,7 @@ class MeanContinuumInterpExpectedFlux(Dr16FixedFudgeExpectedFlux): - """Class to the expected flux as done in the DR16 SDSS analysys + """Class to compute the expected flux as done in the DR16 SDSS analysis The mean expected flux is calculated iteratively as explained in du Mas des Bourboux et al. (2020) except that the we don't use the stacking technique to compute the mean quasar continuum. @@ -539,71 +539,3 @@ def interp_coeff_z(z, z_grid): coeff = (z_high - z) / (z_high - z_low) return coeff, z_bin - - -@numba.njit() -def compute_mean_cont_1d(log_lambda_rest_frame_grid, log_lambda, flux, - continuum, redshift, weight): - """Compute the mean quasar continuum over the whole sample. - Then updates the value of self.get_mean_cont to contain it - The mean continuum is computed as a function of the rest-frame - wavelength. - - Arguments - --------- - log_lambda_rest_frame_grid: np.ndarray - A 1D array of rest-frame wavelengths (in Angstroms) where the continuum is defined. - - log_lambda: np.ndarray - A 1D array of observed wavelengths (in Angstroms). - - flux: np.ndarray - A 1D array of observed fluxes. - - continuum: np.ndarray - A 1D array of quasar continua. - - redshift: float - The redshift of the quasar. - - weight: np.ndarray - A 1D array of weights for each pixel. - """ - A_matrix = np.zeros( - (log_lambda_rest_frame_grid.size, log_lambda_rest_frame_grid.size)) - B_matrix = np.zeros(log_lambda_rest_frame_grid.size) - - log_lambda_rf = log_lambda - np.log10(1 + redshift) - coeffs, rf_wavelength_bin = interp_coeff_lambda(log_lambda_rf, - log_lambda_rest_frame_grid) - - w = np.where(continuum > 0) - B_matrix[ - rf_wavelength_bin[w]] += weight[w] * coeffs[w] * flux[w] / continuum[w] - - w = np.where((continuum > 0) & - (rf_wavelength_bin < log_lambda_rest_frame_grid.size - 1)) - B_matrix[rf_wavelength_bin[w] + - 1] += weight[w] * (1 - coeffs[w]) * flux[w] / continuum[w] - - # diagonal elements - #A_matrix[rf_wavelength_bin, rf_wavelength_bin] += weight * coeffs * coeffs - for index in range(rf_wavelength_bin.size): - A_matrix[rf_wavelength_bin[index], rf_wavelength_bin[index]] += weight[ - index] * coeffs[index] * coeffs[index] - - # Off-diagonal elements - #A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weight[w] * coeffs[w] * (1 - coeffs[w]) - #A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weight[w] * coeffs[w] * (1 - coeffs[w]) - #A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weight[w] * (1 - coeffs[w]) * (1 - coeffs[w]) - w = np.where(rf_wavelength_bin < log_lambda_rest_frame_grid.size - 1) - for index in w[0]: - A_matrix[rf_wavelength_bin[index] + 1, - rf_wavelength_bin[index]] += weight[index] * coeffs[index] * ( - 1 - coeffs[index]) - A_matrix[rf_wavelength_bin[index], rf_wavelength_bin[index] + - 1] += weight[index] * coeffs[index] * (1 - coeffs[index]) - A_matrix[rf_wavelength_bin[index] + 1, rf_wavelength_bin[index] + - 1] += weight[index] * (1 - coeffs[index]) * (1 - coeffs[index]) - - return A_matrix, B_matrix From 05e4a974ff57413a70e134978c80763f8d8fbeb7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Tue, 23 Sep 2025 15:37:18 +0200 Subject: [PATCH 58/59] fixed pylint issue related to scipy 1.16 --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index d7503b970..e7cf4c6b1 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy>=2.0.0 -scipy>=1.14.0 +scipy==1.15.3 iminuit>=2.26.0 healpy>=1.17.1 fitsio>=1.2.4 From f0c062a225f197fa9ab8e19c5f008674c1b1477e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ignasi=20P=C3=A9rez-R=C3=A0fols?= Date: Thu, 25 Sep 2025 11:48:32 +0200 Subject: [PATCH 59/59] removed lingering debugging notebook --- .../expected_fluxes/tests.ipynb | 1344 ----------------- 1 file changed, 1344 deletions(-) delete mode 100644 py/picca/delta_extraction/expected_fluxes/tests.ipynb diff --git a/py/picca/delta_extraction/expected_fluxes/tests.ipynb b/py/picca/delta_extraction/expected_fluxes/tests.ipynb deleted file mode 100644 index bc9d3ba8f..000000000 --- a/py/picca/delta_extraction/expected_fluxes/tests.ipynb +++ /dev/null @@ -1,1344 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "eb062d72", - "metadata": {}, - "source": [ - "# Compute mean continuum using the old formalism to compare results" - ] - }, - { - "cell_type": "markdown", - "id": "b1ca67a3", - "metadata": {}, - "source": [ - "## Step 0: Load tests spectra" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "b9baecd8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of objects in the catalogue: 63\n" - ] - } - ], - "source": [ - "from configparser import ConfigParser\n", - "from picca.delta_extraction.astronomical_objects.forest import Forest\n", - "from picca.delta_extraction.data_catalogues.desi_healpix import DesiHealpix, defaults\n", - "\n", - "PICCA_TEST_DIR = \"$PICCA/py/picca/tests/delta_extraction\"\n", - "\n", - "config = ConfigParser()\n", - "config.read_dict({\"data\": {\n", - " \"catalogue\": f\"{PICCA_TEST_DIR}/data/QSO_cat_fuji_dark_healpix.fits.gz\",\n", - " \"keep surveys\": \"all\",\n", - " \"input directory\": f\"{PICCA_TEST_DIR}/data/\",\n", - " \"out dir\": f\"{PICCA_TEST_DIR}/results/\",\n", - " \"num processors\": 1,\n", - " \"analysis type\": \"BAO 3D\"\n", - "}})\n", - "for key, value in defaults.items():\n", - " if key not in config[\"data\"]:\n", - " config[\"data\"][key] = str(value)\n", - "\n", - "data_old = DesiHealpix(config[\"data\"])\n", - "\n", - "print(\"Number of objects in the catalogue:\", len(data_old.forests))" - ] - }, - { - "cell_type": "markdown", - "id": "a7530c7d", - "metadata": {}, - "source": [ - "## Step 1: Compute initial estimates of a_q and b_q for each forest" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "48cf7881", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/lib/python3.12/site-packages/iminuit/util.py:177: IMinuitWarning: Assigned errors must be positive. Non-positive values are replaced by a heuristic.\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "from scipy.interpolate import interp1d\n", - "from picca.delta_extraction.expected_fluxes.utils import compute_continuum\n", - "\n", - "# Initial values for the eta, var_lss, and fudge parameters\n", - "# Initialisation is equivalent to the initialization in Dr16ExpectedFlux\n", - "num_bins_variance = 20\n", - "log_lambda_var_func_grid = np.log10(np.linspace(\n", - " 10**Forest.log_lambda_grid[0], \n", - " 10**Forest.log_lambda_grid[-1], \n", - " num_bins_variance))\n", - "get_eta = interp1d(\n", - " log_lambda_var_func_grid,\n", - " np.ones_like(log_lambda_var_func_grid),\n", - " fill_value='extrapolate',\n", - " kind='cubic')\n", - "get_var_lss = interp1d(\n", - " log_lambda_var_func_grid,\n", - " np.zeros_like(log_lambda_var_func_grid) + 0.1,\n", - " fill_value='extrapolate',\n", - " kind='cubic')\n", - "get_fudge = interp1d(\n", - " log_lambda_var_func_grid,\n", - " np.zeros_like(log_lambda_var_func_grid),\n", - " fill_value='extrapolate',\n", - " kind='cubic')\n", - "get_mean_cont = interp1d(\n", - " Forest.log_lambda_rest_frame_grid,\n", - " np.ones_like(Forest.log_lambda_rest_frame_grid),\n", - " fill_value=\"extrapolate\")\n", - "use_constant_weight = False # Use constant weight for the continuum fit\n", - "order = 1 # Order of the polynomial fit for the continuum\n", - "\n", - "# get a_q and b_q estimates\n", - "continuum_fit_parameters = {}\n", - "for forest in data_old.forests: \n", - " cont_model, bad_continuum_reason, cont_fit_params = compute_continuum(\n", - " forest, get_mean_cont, get_eta, get_var_lss, get_fudge, use_constant_weight, \n", - " order)\n", - " \n", - " forest.bad_continuum_reason = bad_continuum_reason\n", - " forest.continuum = cont_model\n", - " continuum_fit_parameters[forest.los_id] = cont_fit_params" - ] - }, - { - "cell_type": "markdown", - "id": "7d9683e1", - "metadata": {}, - "source": [ - "## Step 2: Compute mean continuum" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "a0b26236", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "var_lss_mod = 1.0\n", - "def compute_forest_weights(forest, continuum):\n", - " \"\"\"Compute the forest variance following du Mas des Bourboux 2020\n", - "\n", - " Arguments\n", - " ---------\n", - " forest: Forest\n", - " A forest instance where the variance will be computed\n", - "\n", - " continuum: array of float\n", - " Quasar continuum associated with the forest\n", - " \"\"\"\n", - " w = forest.ivar > 0\n", - " weights = np.empty_like(forest.log_lambda)\n", - " weights[~w] = 0.0\n", - "\n", - " var_pipe = 1. / forest.ivar[w] / continuum[w]**2\n", - " var_lss = get_var_lss(forest.log_lambda[w])\n", - " eta = get_eta(forest.log_lambda[w])\n", - " fudge = get_fudge(forest.log_lambda[w])\n", - " weights[w] = 1.0/(\n", - " eta * var_pipe + var_lss_mod*var_lss + fudge / var_pipe)\n", - "\n", - " return weights\n", - "\n", - "mean_cont = np.zeros_like(Forest.log_lambda_rest_frame_grid)\n", - "mean_cont_weight = np.zeros_like(Forest.log_lambda_rest_frame_grid)\n", - "\n", - "# first compute in bins. C=Cont_old*spectrum_dependent_fitting_fct\n", - "# (and Cont_old is constant for all spectra in a bin), thus we actually\n", - "# compute\n", - "# 1/Cont_old * \n", - "for forest in data_old.forests:\n", - " if forest.bad_continuum_reason is not None:\n", - " continue\n", - " bins = Forest.find_bins( # pylint: disable=not-callable\n", - " forest.log_lambda - np.log10(1 + forest.z),\n", - " Forest.log_lambda_rest_frame_grid)\n", - "\n", - " weights = compute_forest_weights(forest, forest.continuum)\n", - " mean_cont += np.bincount(\n", - " bins,\n", - " weights=forest.continuum * weights,\n", - " minlength=mean_cont.size)\n", - " mean_cont_weight += np.bincount(\n", - " bins,\n", - " weights=weights,\n", - " minlength=mean_cont.size)\n", - "\n", - "w = mean_cont_weight > 0\n", - "mean_cont[w] /= mean_cont_weight[w]\n", - "mean_cont /= mean_cont[w].mean()\n", - "log_lambda_cont = Forest.log_lambda_rest_frame_grid[w]\n", - "\n", - "# the new mean continuum is multiplied by the previous one to recover\n", - "# \n", - "new_cont = get_mean_cont(log_lambda_cont) * mean_cont[w]\n", - "get_mean_cont = interp1d(log_lambda_cont,\n", - " new_cont,\n", - " fill_value=\"extrapolate\")\n", - "get_mean_cont_weight = interp1d(log_lambda_cont,\n", - " mean_cont_weight[w],\n", - " fill_value=0.0,\n", - " bounds_error=False)\n", - "\n", - "mean_cont_old = get_mean_cont(Forest.log_lambda_rest_frame_grid)" - ] - }, - { - "cell_type": "markdown", - "id": "ed5e69bc", - "metadata": {}, - "source": [ - "# New formalism (lambda only)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "84872438", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import numba\n", - "\n", - "@numba.njit()\n", - "def interp_coeff(rf_wavelength, rf_wavelength_grid):\n", - " \"\"\"Compute the interpolation coefficients for a given rest-frame wavelength.\n", - "\n", - " Arguments\n", - " ---------\n", - " rf_wavelength: float\n", - " Rest-frame wavelength in Angstroms\n", - " rf_wavelength_grid: np.ndarray\n", - " Rest-frame wavelength nodes where the interpolation is defined\n", - "\n", - " Returns\n", - " -------\n", - " coeff: np.ndarray\n", - " Interpolation coefficients for the given rest-frame wavelength\n", - "\n", - " rf_wavelength_bin: int or np.ndarray\n", - " Indices of the rf_wavelength bins for the given rf_wavelength value\n", - " \"\"\"\n", - " rf_wavelength_bin = np.digitize(rf_wavelength, rf_wavelength_grid) - 1\n", - " rf_wavelength_low = rf_wavelength_grid[rf_wavelength_bin]\n", - " rf_wavelength_high = rf_wavelength_grid[rf_wavelength_bin + 1]\n", - "\n", - " coeff = (rf_wavelength_high - rf_wavelength) / (rf_wavelength_high - rf_wavelength_low)\n", - "\n", - " return coeff, rf_wavelength_bin" - ] - }, - { - "cell_type": "markdown", - "id": "49226143", - "metadata": {}, - "source": [ - "## Step 0: Load test spectra" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "6bc76b55", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of objects in the catalogue: 63\n" - ] - } - ], - "source": [ - "from configparser import ConfigParser\n", - "from picca.delta_extraction.astronomical_objects.forest import Forest\n", - "from picca.delta_extraction.data_catalogues.desi_healpix import DesiHealpix, defaults\n", - "\n", - "PICCA_TEST_DIR = \"$PICCA/py/picca/tests/delta_extraction\"\n", - "\n", - "config = ConfigParser()\n", - "config.read_dict({\"data\": {\n", - " \"catalogue\": f\"{PICCA_TEST_DIR}/data/QSO_cat_fuji_dark_healpix.fits.gz\",\n", - " \"keep surveys\": \"all\",\n", - " \"input directory\": f\"{PICCA_TEST_DIR}/data/\",\n", - " \"out dir\": f\"{PICCA_TEST_DIR}/results/\",\n", - " \"num processors\": 1,\n", - " \"analysis type\": \"BAO 3D\"\n", - "}})\n", - "for key, value in defaults.items():\n", - " if key not in config[\"data\"]:\n", - " config[\"data\"][key] = str(value)\n", - "\n", - "data_new = DesiHealpix(config[\"data\"])\n", - "\n", - "print(\"Number of objects in the catalogue:\", len(data_new.forests))" - ] - }, - { - "cell_type": "markdown", - "id": "5000c1c0", - "metadata": {}, - "source": [ - "## Step 1: Compute initial estimates of a_q and b_q for each forest" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "ab938191", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/lib/python3.12/site-packages/iminuit/util.py:177: IMinuitWarning: Assigned errors must be positive. Non-positive values are replaced by a heuristic.\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "from scipy.interpolate import interp1d\n", - "from picca.delta_extraction.expected_fluxes.utils import compute_continuum\n", - "\n", - "# Initial values for the eta, var_lss, and fudge parameters\n", - "# Initialisation is equivalent to the initialization in Dr16ExpectedFlux\n", - "num_bins_variance = 20\n", - "log_lambda_var_func_grid = np.log10(np.linspace(\n", - " 10**Forest.log_lambda_grid[0], \n", - " 10**Forest.log_lambda_grid[-1], \n", - " num_bins_variance))\n", - "get_eta = interp1d(\n", - " log_lambda_var_func_grid,\n", - " np.ones_like(log_lambda_var_func_grid),\n", - " fill_value='extrapolate',\n", - " kind='cubic')\n", - "get_var_lss = interp1d(\n", - " log_lambda_var_func_grid,\n", - " np.zeros_like(log_lambda_var_func_grid) + 0.1,\n", - " fill_value='extrapolate',\n", - " kind='cubic')\n", - "get_fudge = interp1d(\n", - " log_lambda_var_func_grid,\n", - " np.zeros_like(log_lambda_var_func_grid),\n", - " fill_value='extrapolate',\n", - " kind='cubic')\n", - "get_mean_cont = interp1d(\n", - " Forest.log_lambda_rest_frame_grid,\n", - " np.ones_like(Forest.log_lambda_rest_frame_grid),\n", - " fill_value=\"extrapolate\")\n", - "use_constant_weight = False # Use constant weight for the continuum fit\n", - "order = 1 # Order of the polynomial fit for the continuum\n", - "\n", - "# get a_q and b_q estimates\n", - "continuum_fit_parameters = {}\n", - "for forest in data_new.forests: \n", - " cont_model, bad_continuum_reason, cont_fit_params = compute_continuum(\n", - " forest, get_mean_cont, get_eta, get_var_lss, get_fudge, use_constant_weight, \n", - " order)\n", - " \n", - " forest.bad_continuum_reason = bad_continuum_reason\n", - " forest.continuum = cont_model\n", - " continuum_fit_parameters[forest.los_id] = cont_fit_params" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "428a564c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{39633478723044513: (nan, nan, nan, 218),\n", - " 39633485232605672: (0.7239394650666104,\n", - " 1.0554037674739587,\n", - " 530.1126674116957,\n", - " 576),\n", - " 39633480916668425: (0.21921121622545228,\n", - " -0.02287912547987965,\n", - " -241.70526010916456,\n", - " 716),\n", - " 39633485245186634: (0.24986035581069482,\n", - " -0.005879730589912365,\n", - " 147.36388892808338,\n", - " 715),\n", - " 39633487359116079: (0.5149807925213653,\n", - " 0.43992374880471435,\n", - " 363.9738683043372,\n", - " 709),\n", - " 39633483093511065: (0.08923189604275897,\n", - " -0.03431866724710328,\n", - " -1480.7055856116372,\n", - " 606),\n", - " 39633485232604190: (1.457043900077717,\n", - " -0.8560556880389298,\n", - " 351.1606919621877,\n", - " 185),\n", - " 39633485240993119: (0.267601549502827,\n", - " -0.1593618185573225,\n", - " 200.06015724356632,\n", - " 709),\n", - " 39633489464658242: (0.4589606448576034,\n", - " 0.19205148371170663,\n", - " 385.2757126905617,\n", - " 702),\n", - " 39633491536644232: (0.3868982814088713,\n", - " -0.057862837240584754,\n", - " -375.7405926659592,\n", - " 725),\n", - " 616094245882692041: (nan, nan, nan, 492),\n", - " 39633491540839435: (nan, nan, nan, 857),\n", - " 39633493583465214: (0.19265132064986895,\n", - " 0.20844279199694593,\n", - " -884.7348046863103,\n", - " 787),\n", - " 39633491540838097: (0.22818148682295983,\n", - " -0.023802016160615672,\n", - " -538.0102853816593,\n", - " 794),\n", - " 39633493583464408: (4.69976529576295,\n", - " -0.5946405439794422,\n", - " 1233.7372580879319,\n", - " 698),\n", - " 39633493583465123: (1.5953628214045408,\n", - " -1.0912419754541,\n", - " 407.0360930426887,\n", - " 174),\n", - " 39633493579271075: (0.19889290612661648,\n", - " 0.11473613726288821,\n", - " -479.4873062639456,\n", - " 726),\n", - " 39633493579268963: (nan, nan, nan, 848),\n", - " 39633493583463661: (nan, nan, nan, 95),\n", - " 39633489464658033: (0.14811820424706335,\n", - " 0.3315484563039133,\n", - " 345.1951254615125,\n", - " 391),\n", - " 39633489473045106: (nan, nan, nan, 178),\n", - " 39633487371699188: (0.7351966409146072,\n", - " 0.28846671241616323,\n", - " 169.67393934301765,\n", - " 700),\n", - " 616094239675122420: (0.021451289445316317,\n", - " -0.01579877707921619,\n", - " -2100.879822699831,\n", - " 913),\n", - " 39633489468851130: (0.17575483932771602,\n", - " -0.05519754132331513,\n", - " -709.7575813684737,\n", - " 744),\n", - " 39633491540837630: (0.07340129301346944,\n", - " 0.026274060009511817,\n", - " -1914.6754787125974,\n", - " 829),\n", - " 39633497609994880: (0.13798669887167364,\n", - " 0.12310520296994652,\n", - " -778.8266884969782,\n", - " 801),\n", - " 39633495605119752: (0.16118362069299064,\n", - " 0.16644563475850965,\n", - " -674.0146803433395,\n", - " 796),\n", - " 39633493587657805: (nan, nan, nan, 113),\n", - " 39633495605117776: (-0.5348245484041663,\n", - " 2.4521309618820233,\n", - " 424.62996501924385,\n", - " 186),\n", - " 39633497614190289: (-1.2574345869318866,\n", - " 5.159942146290566,\n", - " 462.7661624101064,\n", - " 227),\n", - " 39633499577125885: (2.663556337651875,\n", - " -2.568258121234901,\n", - " 659.0196412129857,\n", - " 346),\n", - " 39633497597413011: (0.11847868130594146,\n", - " -0.03723614997284043,\n", - " -1127.63607586592,\n", - " 581),\n", - " 39633495613507218: (1.5940779144964188,\n", - " 0.34581858447873703,\n", - " 131.18877312020322,\n", - " 785),\n", - " 39633493591851733: (0.6811587703971528,\n", - " 1.5478864530349175,\n", - " 761.0971196993486,\n", - " 374),\n", - " 39633495609312400: (0.16490299278977927,\n", - " 0.1315760170035851,\n", - " -1363.5187251643838,\n", - " 907),\n", - " 39633491545031256: (0.10448564150991523,\n", - " 0.024370806326404395,\n", - " -1847.9123436717023,\n", - " 894),\n", - " 39633497597413664: (nan, nan, nan, 170),\n", - " 39633493591852133: (-0.09299867130352536,\n", - " 0.33087475706068636,\n", - " 367.95765956714695,\n", - " 365),\n", - " 39633497614189735: (0.8042090699441273,\n", - " -0.04738254407440011,\n", - " 273.3572330038894,\n", - " 721),\n", - " 39633499572931368: (0.12404679987901582,\n", - " 1.9277004404706777,\n", - " 591.6228942764745,\n", - " 354),\n", - " 39633499572931945: (3.636058435702364,\n", - " 0.18550020228922862,\n", - " 941.6020938883124,\n", - " 467),\n", - " 39633499572932649: (0.44789665962488134,\n", - " 0.022750633452090937,\n", - " 434.7842786743527,\n", - " 522),\n", - " 39633493587656875: (-0.19081995423218615,\n", - " 2.254413264229899,\n", - " 637.9868916147897,\n", - " 325),\n", - " 39633497601607277: (3.8652142602906445,\n", - " 0.21548856526299942,\n", - " 1406.6752859272895,\n", - " 636),\n", - " 39633491545030702: (0.6008613621211014,\n", - " -0.05504853424140009,\n", - " -908.4547196078003,\n", - " 793),\n", - " 39633497601608817: (nan, nan, nan, 474),\n", - " 39633491545030901: (0.21589003323178863,\n", - " 0.8330810374083518,\n", - " 588.8585526384184,\n", - " 645),\n", - " 39633495617700085: (0.5270121736205813,\n", - " -0.2954869802335071,\n", - " -1062.8338849075149,\n", - " 673),\n", - " 39633497609996860: (0.5687707822303062,\n", - " 3.1720173109890606,\n", - " 381.3223516884327,\n", - " 157),\n", - " 39633497597413949: (0.939930789872183,\n", - " -0.01444351163569091,\n", - " 89.03760107065125,\n", - " 737),\n", - " 39633493591851198: (0.037399116811005335,\n", - " 0.012317364843205784,\n", - " 394.7577879179491,\n", - " 329),\n", - " 39633495605119935: (0.2224934644113866,\n", - " -0.10068050906651146,\n", - " -1438.6284379009246,\n", - " 675),\n", - " 39633559463397282: (1.6345810624971855,\n", - " -0.8126921340614067,\n", - " 388.7659152908713,\n", - " 175),\n", - " 39633559467591522: (3.210445013533286,\n", - " 1.8053955936493171,\n", - " 785.2533827049235,\n", - " 338),\n", - " 39633559467592484: (0.2133566820712212,\n", - " -0.029676041212885668,\n", - " -1366.3067177603984,\n", - " 807),\n", - " 39633560331617316: (1.2289700675383715,\n", - " -0.09751658413235614,\n", - " 362.0345851397634,\n", - " 743),\n", - " 39633561178870058: (0.27209888861840686,\n", - " 0.013765522313588642,\n", - " -682.9920674486712,\n", - " 728),\n", - " 39633560340006508: (0.16282583859961086,\n", - " 0.003578715376160087,\n", - " -1267.6024395883815,\n", - " 799),\n", - " 39633561174674576: (nan, nan, nan, 19),\n", - " 39633562000951961: (87.16465260763411,\n", - " -86.67359328943107,\n", - " 7.633465652597323,\n", - " 8),\n", - " 39633561183060922: (0.7238532448280279,\n", - " 1.7443244839729475,\n", - " 493.4602976571465,\n", - " 502),\n", - " 39633559463398815: (-0.7468104287553387,\n", - " 2.187806528164754,\n", - " 473.3272435892899,\n", - " 343),\n", - " 39632936152073654: (-1.2681985898185202,\n", - " 2.6484958042156386,\n", - " 530.3836526297549,\n", - " 237)}" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "continuum_fit_parameters" - ] - }, - { - "cell_type": "markdown", - "id": "1354e374", - "metadata": {}, - "source": [ - "# Step 2: Compute the mean continuum nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "id": "6809b024", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "A_matrix.shape: (201, 201)\n", - "B_matrix.shape: (201,)\n" - ] - } - ], - "source": [ - "A_matrix = np.zeros(\n", - " (Forest.log_lambda_rest_frame_grid.size, Forest.log_lambda_rest_frame_grid.size)\n", - ")\n", - "print(\"A_matrix.shape: \", A_matrix.shape)\n", - "\n", - "B_matrix = np.zeros(Forest.log_lambda_rest_frame_grid.size) \n", - "print(\"B_matrix.shape: \", B_matrix.shape)\n", - "\n", - "for forest in data_new.forests:\n", - " if forest.bad_continuum_reason is not None:\n", - " continue\n", - "\n", - " log_lambda_rf = forest.log_lambda - np.log10(1 + forest.z)\n", - " weights = compute_forest_weights(forest, forest.continuum)\n", - " zero_point, slope, _, _ = continuum_fit_parameters[forest.los_id]\n", - "\n", - " coeffs, rf_wavelength_bin = interp_coeff(\n", - " log_lambda_rf,\n", - " Forest.log_lambda_rest_frame_grid)\n", - " \n", - " w = np.where(forest.continuum > 0)\n", - " B_matrix[rf_wavelength_bin[w]] += weights[w] * coeffs[w] * forest.flux[w] / forest.continuum[w]\n", - " w = np.where((forest.continuum > 0) & (rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1))\n", - " B_matrix[rf_wavelength_bin[w] + 1] += weights[w] * (1 - coeffs[w]) * forest.flux[w] / forest.continuum[w]\n", - "\n", - " try:\n", - " A_matrix[rf_wavelength_bin, rf_wavelength_bin] += weights * coeffs * coeffs\n", - " w = np.where(rf_wavelength_bin < Forest.log_lambda_rest_frame_grid.size - 1)\n", - " A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w]] += weights[w] * coeffs[w] * (1 - coeffs[w])\n", - " A_matrix[rf_wavelength_bin[w], rf_wavelength_bin[w] + 1] += weights[w] * coeffs[w] * (1 - coeffs[w])\n", - " A_matrix[rf_wavelength_bin[w] + 1, rf_wavelength_bin[w] + 1] += weights[w] * (1 - coeffs[w]) * (1 - coeffs[w])\n", - "\n", - " except Exception as e:\n", - " print(\"forest.los_id: \", forest.los_id)\n", - " print(\"rf_wavelength_bin: \", rf_wavelength_bin)\n", - " print(\"coeffs: \", coeffs)\n", - " raise e\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "8f0f194f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0.77971249, 20.24443117, 23.72206313, 23.47955841,\n", - " 21.66907979, 22.69357071, 25.5344236 , 24.04722173,\n", - " 24.92190705, 26.05057044, 26.65566557, 27.00748148,\n", - " 22.37376183, 25.58227748, 23.57561175, 26.37260684,\n", - " 27.22248028, 27.46275957, 26.76913605, 29.93523447,\n", - " 28.5797931 , 28.18275487, 27.51737563, 30.57768608,\n", - " 30.73210688, 29.02599181, 26.67767629, 28.78831251,\n", - " 28.10407484, 29.94178967, 29.10111548, 29.92463338,\n", - " 30.43723902, 32.46405144, 30.29315637, 32.58261539,\n", - " 31.06079084, 36.14493458, 29.66088237, 31.33077149,\n", - " 31.15220459, 35.36800867, 31.03889996, 32.54477743,\n", - " 34.88958877, 33.35580853, 35.52936574, 35.32962673,\n", - " 34.62909357, 35.46846637, 34.68716493, 35.71101163,\n", - " 30.68338169, 32.74016491, 34.07580473, 36.52497204,\n", - " 33.84194925, 36.60306721, 37.85471571, 37.81544036,\n", - " 38.96975352, 40.77917407, 39.10920655, 42.6120729 ,\n", - " 38.74715549, 41.98455491, 37.80365673, 41.69807793,\n", - " 42.52801133, 40.89634372, 42.7958267 , 42.70860917,\n", - " 44.51485348, 45.03634043, 40.66090581, 44.4283104 ,\n", - " 45.8826688 , 44.59261534, 37.36227962, 47.56541154,\n", - " 42.86519001, 44.98446129, 46.63909347, 47.64129335,\n", - " 47.48632709, 47.97126215, 53.88113366, 49.26222375,\n", - " 47.2038595 , 53.95866692, 52.25569958, 51.51811372,\n", - " 48.6671937 , 53.8066811 , 51.15100826, 52.0153216 ,\n", - " 53.63242496, 55.80436566, 53.50115658, 54.63050634,\n", - " 59.1238043 , 56.96094937, 53.39045286, 55.45334622,\n", - " 54.60604133, 55.18064385, 58.71540959, 55.95036077,\n", - " 57.52896345, 55.2010929 , 63.84296214, 56.47551687,\n", - " 65.95443083, 58.9140937 , 62.06755133, 63.20172109,\n", - " 63.56584178, 59.46985168, 68.18311288, 61.61130612,\n", - " 65.91469822, 61.81725898, 64.38684603, 64.92028116,\n", - " 69.05739216, 68.8172409 , 68.92771894, 68.30701405,\n", - " 73.99342994, 68.711884 , 67.52256308, 67.64265145,\n", - " 70.38747856, 70.60625461, 72.80310573, 65.94831056,\n", - " 76.47376857, 65.82675695, 77.45759647, 71.94209631,\n", - " 75.1516656 , 76.64243986, 75.91083589, 71.60294625,\n", - " 71.27493372, 76.34474728, 73.76872143, 76.20596751,\n", - " 78.63936601, 78.65596247, 81.36815697, 80.7152994 ,\n", - " 86.60795198, 72.55451642, 84.22152282, 82.31096235,\n", - " 78.7987098 , 79.40984937, 83.19258782, 79.78610916,\n", - " 85.66336825, 79.55806222, 83.45615234, 89.23721307,\n", - " 93.66891383, 85.08804102, 89.46156474, 90.22074981,\n", - " 89.83251627, 87.46756537, 92.87391777, 91.7138137 ,\n", - " 92.67711366, 96.7722643 , 91.79726828, 88.31747512,\n", - " 102.24061529, 97.1952202 , 100.64572637, 98.46282685,\n", - " 105.79985061, 101.05485047, 96.15457349, 98.42085693,\n", - " 103.68065347, 97.19537528, 100.51675824, 106.00921301,\n", - " 99.07641881, 96.56191357, 112.22453479, 103.34796272,\n", - " 107.90783654, 102.44870816, 113.26493354, 96.98340895,\n", - " 105.77321812, 102.52366613, 107.5761135 , 113.35592263,\n", - " 103.88055271])" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.diag(A_matrix)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "d9813f89", - "metadata": {}, - "outputs": [], - "source": [ - "w = np.diagonal(A_matrix) == 0\n", - "A_matrix[w, w] = 1.0" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "8aa1ec75", - "metadata": {}, - "outputs": [], - "source": [ - "# Solve the linear system A_matrix * x = B_matrix\n", - "x = np.linalg.solve(A_matrix, B_matrix)\n" - ] - }, - { - "cell_type": "markdown", - "id": "137584ec", - "metadata": {}, - "source": [ - "## Plot results and compare them with the old case" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "id": "052f14e1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-1.0, 2.0)" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "fig = plt.figure(figsize=(10, 6))\n", - "ax = fig.add_subplot(111)\n", - "ax.set_xlabel('Log Wavelength (Angstroms)')\n", - "ax.set_ylabel('Estimated Continuum Flux')\n", - "ax.plot(Forest.log_lambda_rest_frame_grid, x, label='New Mean Continuum')\n", - "ax.plot(Forest.log_lambda_rest_frame_grid, mean_cont_old, label='Old Mean Continuum')\n", - "ax.legend()\n", - "ax.set_ylim(-1, 2)\n" - ] - }, - { - "cell_type": "markdown", - "id": "17716b79", - "metadata": {}, - "source": [ - "# New formalism (lambda + redshift)" - ] - }, - { - "cell_type": "markdown", - "id": "159897c1", - "metadata": {}, - "source": [ - "## Step 0: Load test spectra" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "bbfd97b8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of objects in the catalogue: 63\n" - ] - } - ], - "source": [ - "from configparser import ConfigParser\n", - "from picca.delta_extraction.astronomical_objects.forest import Forest\n", - "from picca.delta_extraction.data_catalogues.desi_healpix import DesiHealpix, defaults\n", - "\n", - "PICCA_TEST_DIR = \"$PICCA/py/picca/tests/delta_extraction\"\n", - "\n", - "config = ConfigParser()\n", - "config.read_dict({\"data\": {\n", - " \"catalogue\": f\"{PICCA_TEST_DIR}/data/QSO_cat_fuji_dark_healpix.fits.gz\",\n", - " \"keep surveys\": \"all\",\n", - " \"input directory\": f\"{PICCA_TEST_DIR}/data/\",\n", - " \"out dir\": f\"{PICCA_TEST_DIR}/results/\",\n", - " \"num processors\": 1,\n", - " \"analysis type\": \"BAO 3D\"\n", - "}})\n", - "for key, value in defaults.items():\n", - " if key not in config[\"data\"]:\n", - " config[\"data\"][key] = str(value)\n", - "\n", - "data_new_2d = DesiHealpix(config[\"data\"])\n", - "\n", - "print(\"Number of objects in the catalogue:\", len(data_new_2d.forests))" - ] - }, - { - "cell_type": "markdown", - "id": "1d0c7f54", - "metadata": {}, - "source": [ - "## Step 1: Compute initial estimates of a_q and b_q for each forest" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "92b3d311", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/iprafols/Documents/GitHub/picca/py/picca/delta_extraction/least_squares/least_squares_cont_model.py:190: RuntimeWarning: divide by zero encountered in divide\n", - " var_pipe = 1. / forest.ivar[w] / cont_model[w]**2\n", - "/Users/iprafols/Documents/GitHub/picca/py/picca/delta_extraction/least_squares/least_squares_cont_model.py:195: RuntimeWarning: divide by zero encountered in divide\n", - " weights[w] = 1.0 / cont_model[w]**2 / variance\n", - "/Users/iprafols/Documents/GitHub/picca/py/picca/delta_extraction/least_squares/least_squares_cont_model.py:195: RuntimeWarning: invalid value encountered in divide\n", - " weights[w] = 1.0 / cont_model[w]**2 / variance\n", - "/opt/anaconda3/lib/python3.12/site-packages/iminuit/util.py:177: IMinuitWarning: Assigned errors must be positive. Non-positive values are replaced by a heuristic.\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "from scipy.interpolate import interp1d, RegularGridInterpolator\n", - "from picca.delta_extraction.expected_fluxes.utils import compute_continuum\n", - "\n", - "from picca.delta_extraction.expected_fluxes.mean_continuum_interp_expected_flux import interp_coeff_lambda, interp_coeff_z\n", - "\n", - "# Setup the redshift bins and centers\n", - "num_z_bins = 3\n", - "z_bins = np.linspace(2.1, 4.0, num_z_bins + 1)\n", - "z_centers = (z_bins[:-1] + z_bins[1:]) / 2\n", - "\n", - "\n", - "\n", - "# Initial values for the eta, var_lss, and fudge parameters\n", - "# Initialisation is equivalent to the initialization in Dr16ExpectedFlux\n", - "num_bins_variance = 20\n", - "log_lambda_var_func_grid = np.log10(np.linspace(\n", - " 10**Forest.log_lambda_grid[0], \n", - " 10**Forest.log_lambda_grid[-1], \n", - " num_bins_variance))\n", - "get_eta = interp1d(\n", - " log_lambda_var_func_grid,\n", - " np.ones_like(log_lambda_var_func_grid),\n", - " fill_value='extrapolate',\n", - " kind='cubic')\n", - "get_var_lss = interp1d(\n", - " log_lambda_var_func_grid,\n", - " np.zeros_like(log_lambda_var_func_grid) + 0.1,\n", - " fill_value='extrapolate',\n", - " kind='cubic')\n", - "get_fudge = interp1d(\n", - " log_lambda_var_func_grid,\n", - " np.zeros_like(log_lambda_var_func_grid),\n", - " fill_value='extrapolate',\n", - " kind='cubic')\n", - "mean_cont = np.ones(\n", - " (z_bins.size - 1, Forest.log_lambda_rest_frame_grid.size))\n", - "get_mean_cont = RegularGridInterpolator(\n", - " (z_centers, Forest.log_lambda_rest_frame_grid), \n", - " mean_cont, bounds_error=False, fill_value=0.0)\n", - "use_constant_weight = False # Use constant weight for the continuum fit\n", - "order = 1 # Order of the polynomial fit for the continuum\n", - "\n", - "# get a_q and b_q estimates\n", - "continuum_fit_parameters = {}\n", - "for forest in data_new_2d.forests: \n", - " cont_model, bad_continuum_reason, cont_fit_params = compute_continuum(\n", - " forest, get_mean_cont, get_eta, get_var_lss, get_fudge, use_constant_weight, \n", - " order)\n", - " \n", - " forest.bad_continuum_reason = bad_continuum_reason\n", - " forest.continuum = cont_model\n", - " continuum_fit_parameters[forest.los_id] = cont_fit_params" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "id": "62d532bd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{39633478723044513: (nan, nan, nan, 0),\n", - " 39633485232605672: (nan, nan, nan, 0),\n", - " 39633480916668425: (0.21921121622262565,\n", - " -0.022879125476090396,\n", - " -241.70526010916456,\n", - " 716),\n", - " 39633485245186634: (0.24986035581069482,\n", - " -0.005879730589912365,\n", - " 147.36388892808338,\n", - " 715),\n", - " 39633487359116079: (0.5149807925211669,\n", - " 0.4399237488050771,\n", - " 363.9738683043373,\n", - " 709),\n", - " 39633483093511065: (nan, nan, nan, 0),\n", - " 39633485232604190: (nan, nan, nan, 0),\n", - " 39633485240993119: (0.2676015495011186,\n", - " -0.15936181855496168,\n", - " 200.0601572435662,\n", - " 709),\n", - " 39633489464658242: (0.4589606448564233,\n", - " 0.19205148371359965,\n", - " 385.2757126905615,\n", - " 702),\n", - " 39633491536644232: (0.38689828140895194,\n", - " -0.057862837240697663,\n", - " -375.7405926659592,\n", - " 725),\n", - " 616094245882692041: (nan, nan, nan, 0),\n", - " 39633491540839435: (nan, nan, nan, 857),\n", - " 39633493583465214: (0.1926513206499509,\n", - " 0.2084427919968139,\n", - " -884.7348046863099,\n", - " 787),\n", - " 39633491540838097: (0.22818148682295983,\n", - " -0.023802016160615672,\n", - " -538.0102853816593,\n", - " 794),\n", - " 39633493583464408: (4.699765295761284,\n", - " -0.5946405439745434,\n", - " 1233.7372580879317,\n", - " 698),\n", - " 39633493583465123: (nan, nan, nan, 0),\n", - " 39633493579271075: (0.19889290612685845,\n", - " 0.11473613726240299,\n", - " -479.48730626394547,\n", - " 726),\n", - " 39633493579268963: (nan, nan, nan, 848),\n", - " 39633493583463661: (nan, nan, nan, 0),\n", - " 39633489464658033: (nan, nan, nan, 0),\n", - " 39633489473045106: (nan, nan, nan, 0),\n", - " 39633487371699188: (0.7351966409147075,\n", - " 0.288466712417165,\n", - " 169.67393934301776,\n", - " 700),\n", - " 616094239675122420: (0.021451289445316317,\n", - " -0.01579877707921619,\n", - " -2100.879822699831,\n", - " 913),\n", - " 39633489468851130: (0.1757548393255944,\n", - " -0.055197541322842616,\n", - " -709.7575813684748,\n", - " 744),\n", - " 39633491540837630: (0.07340129301339746,\n", - " 0.026274060009137127,\n", - " -1914.6754787125965,\n", - " 829),\n", - " 39633497609994880: (0.13798669887140888,\n", - " 0.12310520297024066,\n", - " -778.826688496978,\n", - " 801),\n", - " 39633495605119752: (0.16118362069299064,\n", - " 0.16644563475850965,\n", - " -674.0146803433395,\n", - " 796),\n", - " 39633493587657805: (nan, nan, nan, 0),\n", - " 39633495605117776: (nan, nan, nan, 0),\n", - " 39633497614190289: (nan, nan, nan, 0),\n", - " 39633499577125885: (nan, nan, nan, 0),\n", - " 39633497597413011: (nan, nan, nan, 0),\n", - " 39633495613507218: (1.5940779144960708,\n", - " 0.34581858447945124,\n", - " 131.1887731202031,\n", - " 785),\n", - " 39633493591851733: (nan, nan, nan, 0),\n", - " 39633495609312400: (0.1649029927900481,\n", - " 0.13157601700318697,\n", - " -1363.5187251643833,\n", - " 907),\n", - " 39633491545031256: (0.10448564150998924,\n", - " 0.02437080632629913,\n", - " -1847.9123436717027,\n", - " 894),\n", - " 39633497597413664: (nan, nan, nan, 0),\n", - " 39633493591852133: (nan, nan, nan, 0),\n", - " 39633497614189735: (0.8042090699429016,\n", - " -0.04738254407293686,\n", - " 273.35723300388963,\n", - " 721),\n", - " 39633499572931368: (nan, nan, nan, 0),\n", - " 39633499572931945: (nan, nan, nan, 0),\n", - " 39633499572932649: (nan, nan, nan, 0),\n", - " 39633493587656875: (nan, nan, nan, 0),\n", - " 39633497601607277: (3.8652142602883366,\n", - " 0.21548856526540142,\n", - " 1406.6752859272897,\n", - " 636),\n", - " 39633491545030702: (0.6008613621210818,\n", - " -0.055048534241373084,\n", - " -908.4547196078004,\n", - " 793),\n", - " 39633497601608817: (nan, nan, nan, 0),\n", - " 39633491545030901: (0.21589003323206732,\n", - " 0.8330810374080723,\n", - " 588.8585526384184,\n", - " 645),\n", - " 39633495617700085: (nan, nan, nan, 0),\n", - " 39633497609996860: (nan, nan, nan, 0),\n", - " 39633497597413949: (0.9399307898747885,\n", - " -0.01444351164104082,\n", - " 89.03760107065114,\n", - " 737),\n", - " 39633493591851198: (nan, nan, nan, 0),\n", - " 39633495605119935: (nan, nan, nan, 0),\n", - " 39633559463397282: (nan, nan, nan, 0),\n", - " 39633559467591522: (nan, nan, nan, 0),\n", - " 39633559467592484: (0.2133566820712212,\n", - " -0.029676041212885668,\n", - " -1366.3067177603982,\n", - " 807),\n", - " 39633560331617316: (1.2289700675405621,\n", - " -0.09751658413875379,\n", - " 362.03458513976466,\n", - " 743),\n", - " 39633561178870058: (0.2720988886189903,\n", - " 0.01376552231521866,\n", - " -682.9920674486712,\n", - " 728),\n", - " 39633560340006508: (0.16282583859961086,\n", - " 0.003578715376160087,\n", - " -1267.6024395883815,\n", - " 799),\n", - " 39633561174674576: (nan, nan, nan, 0),\n", - " 39633562000951961: (nan, nan, nan, 0),\n", - " 39633561183060922: (nan, nan, nan, 0),\n", - " 39633559463398815: (nan, nan, nan, 0),\n", - " 39632936152073654: (nan, nan, nan, 0)}" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "continuum_fit_parameters" - ] - }, - { - "cell_type": "markdown", - "id": "45a32818", - "metadata": {}, - "source": [ - "# Step 2: Compute the mean continuum nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "49a4df30", - "metadata": {}, - "outputs": [], - "source": [ - "var_lss_mod = 1.0\n", - "def compute_forest_weights(forest, continuum):\n", - " \"\"\"Compute the forest variance following du Mas des Bourboux 2020\n", - "\n", - " Arguments\n", - " ---------\n", - " forest: Forest\n", - " A forest instance where the variance will be computed\n", - "\n", - " continuum: array of float\n", - " Quasar continuum associated with the forest\n", - " \"\"\"\n", - " w = forest.ivar > 0\n", - " weights = np.empty_like(forest.log_lambda)\n", - " weights[~w] = 0.0\n", - "\n", - " var_pipe = 1. / forest.ivar[w] / continuum[w]**2\n", - " var_lss = get_var_lss(forest.log_lambda[w])\n", - " eta = get_eta(forest.log_lambda[w])\n", - " fudge = get_fudge(forest.log_lambda[w])\n", - " weights[w] = 1.0/(\n", - " eta * var_pipe + var_lss_mod*var_lss + fudge / var_pipe)\n", - "\n", - " return weights" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "ebe9b5e5", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# for simplicity we introduce a new index \n", - "# combined_bin = z_bin + N_z_bins * rf_wavelength_bin\n", - "# where z_bin is the index of the redshift bin and rf_wavelength_bin\n", - "# is the index of the rest-frame wavelength bin.\n", - "# This allows us to use a similar logic as in the 1D case.\n", - "matrix_size = num_z_bins * Forest.log_lambda_rest_frame_grid.size\n", - "\n", - "A_matrix = np.zeros(\n", - " (matrix_size, matrix_size)\n", - ")\n", - "B_matrix = np.zeros(matrix_size) \n", - "\n", - "for forest in data_new_2d.forests:\n", - " if forest.bad_continuum_reason is not None:\n", - " continue\n", - "\n", - " log_lambda_rf = forest.log_lambda - np.log10(1 + forest.z)\n", - " weights = compute_forest_weights(forest, forest.continuum)\n", - " rf_wavelength_coeffs, rf_wavelength_bin = interp_coeff_lambda(\n", - " log_lambda_rf,\n", - " Forest.log_lambda_rest_frame_grid)\n", - " z_coeffs, z_bin = interp_coeff_z(\n", - " forest.z,\n", - " z_centers)\n", - " #z_coeffs = np.repeat(z_coeffs, Forest.log_lambda_rest_frame_grid.size)\n", - " \n", - " # combined_bin is the index of the bin in the 2D matrix\n", - " combined_bin = z_bin + num_z_bins * rf_wavelength_bin\n", - " combined_bin_plus_wavelength = z_bin + num_z_bins * (rf_wavelength_bin + 1)\n", - " combined_bin_plus_z = z_bin + 1 + num_z_bins * (rf_wavelength_bin)\n", - " combined_bin_plus_both = z_bin + 1 + num_z_bins * (rf_wavelength_bin + 1)\n", - "\n", - " # Fill the B_matrix\n", - " # diagonal elements\n", - " w = np.where(forest.continuum > 0)\n", - " B_matrix[combined_bin[w]] += weights[w] * z_coeffs * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w]\n", - " # off-diagonal elements\n", - " w = np.where((forest.continuum > 0) & (combined_bin_plus_wavelength < matrix_size - 1))\n", - " B_matrix[combined_bin_plus_wavelength[w] + 1] += weights[w] * z_coeffs * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w]\n", - " w = np.where((forest.continuum > 0) & (combined_bin_plus_z < matrix_size - 1))\n", - " B_matrix[combined_bin_plus_z[w] + 1] += weights[w] * (1 - z_coeffs) * rf_wavelength_coeffs[w] * forest.flux[w] / forest.continuum[w]\n", - " w = np.where((forest.continuum > 0) & (combined_bin_plus_both < matrix_size - 1))\n", - " B_matrix[combined_bin_plus_both[w] + 1] += weights[w] * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * forest.flux[w] / forest.continuum[w]\n", - "\n", - " # Fill the A_matrix\n", - " # diagonal elements\n", - " A_matrix[combined_bin, combined_bin] += weights * z_coeffs * z_coeffs * rf_wavelength_coeffs * rf_wavelength_coeffs\n", - " # off-diagonal elements\n", - " w = np.where(combined_bin_plus_wavelength < matrix_size - 1)\n", - " A_matrix[combined_bin_plus_wavelength[w], combined_bin[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w])\n", - " A_matrix[combined_bin[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w])\n", - " A_matrix[combined_bin_plus_wavelength[w], combined_bin_plus_wavelength[w]] += weights[w] * z_coeffs * z_coeffs * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w])\n", - " w = np.where(combined_bin_plus_z < matrix_size - 1)\n", - " A_matrix[combined_bin_plus_z[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w]\n", - " A_matrix[combined_bin[w], combined_bin_plus_z[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w]\n", - " A_matrix[combined_bin_plus_z[w], combined_bin_plus_z[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * rf_wavelength_coeffs[w] * rf_wavelength_coeffs[w]\n", - " w = np.where(combined_bin_plus_both < matrix_size - 1)\n", - " A_matrix[combined_bin_plus_both[w], combined_bin[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w])\n", - " A_matrix[combined_bin[w], combined_bin_plus_both[w]] += weights[w] * z_coeffs * (1 - z_coeffs) * rf_wavelength_coeffs[w] * (1 - rf_wavelength_coeffs[w])\n", - " A_matrix[combined_bin_plus_both[w], combined_bin_plus_both[w]] += weights[w] * (1 - z_coeffs) * (1 - z_coeffs) * (1 - rf_wavelength_coeffs[w]) * (1 - rf_wavelength_coeffs[w])\n", - "\n", - "\n", - "# Take care of unstable solutions\n", - "# If the diagonal of A_matrix is zero, we set it to 1.0\n", - "# This is a workaround for the case where there is no coverage\n", - "# for some wavelengths.\n", - "w = np.diagonal(A_matrix) == 0\n", - "A_matrix[w, w] = 1.0\n", - "\n", - "# Solve the linear system A_matrix * mean_cont = B_matrix\n", - "mean_cont = np.linalg.solve(A_matrix, B_matrix)\n", - "# Undo the new indexing\n", - "mean_cont = mean_cont.reshape((num_z_bins, Forest.log_lambda_rest_frame_grid.size))\n", - "\n", - "\n", - "# update the interpolator with the mean continuum\n", - "get_mean_cont = RegularGridInterpolator(\n", - " (z_centers, Forest.log_lambda_rest_frame_grid), \n", - " mean_cont, bounds_error=False, fill_value=0.0,\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "id": "0120a746", - "metadata": {}, - "source": [ - "# Plot results and compare with previous cases" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "97d4cd3b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-1.0, 2.0)" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "fig = plt.figure(figsize=(10, 6))\n", - "ax = fig.add_subplot(111)\n", - "ax.set_xlabel('Log Wavelength (Angstroms)')\n", - "ax.set_ylabel('Estimated Continuum Flux')\n", - "ax.plot(Forest.log_lambda_rest_frame_grid, x, label='New Mean Continuum (1d)')\n", - "ax.plot(Forest.log_lambda_rest_frame_grid, mean_cont_old, label='Old Mean Continuum')\n", - "\n", - "for z in np.linspace(2.1, 4.0, 5):\n", - " # Create a grid of points for the new mean continuum\n", - " # at a specific redshift z\n", - " # We use the log_lambda_rest_frame_grid and the redshift z\n", - " points = np.column_stack([np.full_like(Forest.log_lambda_rest_frame_grid, z), Forest.log_lambda_rest_frame_grid])\n", - " to_plot = get_mean_cont(points)\n", - " ax.plot(Forest.log_lambda_rest_frame_grid, \n", - " to_plot, \n", - " label=f'New Mean Continuum (2d) at z={z:.2f}')\n", - "ax.set_title('Comparison of Mean Continuum Fluxes')\n", - "ax.legend()\n", - "ax.set_ylim(-1, 2)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6eefa689", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.2" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}