From b2f74c7cfd8290660e8eaabaa798db8e2c535658 Mon Sep 17 00:00:00 2001 From: Tomas Kontrimas Date: Wed, 28 Oct 2026 19:35:20 +0100 Subject: [PATCH 1/2] Fix flux conversion in likelihood scan tutorial (#336) --- doc/sphinx/tutorials/likelihood_scan.ipynb | 121 +++++++++++---------- 1 file changed, 62 insertions(+), 59 deletions(-) diff --git a/doc/sphinx/tutorials/likelihood_scan.ipynb b/doc/sphinx/tutorials/likelihood_scan.ipynb index 6369b4f94e..3d67312951 100644 --- a/doc/sphinx/tutorials/likelihood_scan.ipynb +++ b/doc/sphinx/tutorials/likelihood_scan.ipynb @@ -28,12 +28,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 33/33 [00:00<00:00, 508.00it/s]\n", - "100%|██████████| 33/33 [00:00<00:00, 554.51it/s]\n", - "100%|██████████| 33/33 [00:00<00:00, 490.63it/s]\n", - "100%|██████████| 33/33 [00:00<00:00, 554.87it/s]\n", - "100%|██████████| 4/4 [00:21<00:00, 5.33s/it]\n", - "100%|██████████| 136/136 [00:00<00:00, 10233.13it/s]\n" + "100%|██████████| 33/33 [00:00<00:00, 549.83it/s]\n", + "100%|██████████| 33/33 [00:00<00:00, 501.57it/s]\n", + "100%|██████████| 33/33 [00:00<00:00, 553.65it/s]\n", + "100%|██████████| 33/33 [00:00<00:00, 561.94it/s]\n", + "100%|██████████| 4/4 [00:21<00:00, 5.35s/it]\n", + "100%|██████████| 136/136 [00:00<00:00, 10202.56it/s]\n" ] } ], @@ -111,7 +111,7 @@ "source": [ "We need to evaluate the log-likelihood ratio function to generate a likelihood contour plot. The `Analysis` instance has the property `llhratio` which holds the instance of the log-likelihood ratio function. This instance has the method `evaluate`. The method takes an array of the fit parameter values as argument at which the LLH ratio function will be evaluated. It returns the value of the LLH ratio function at the given point and its gradients w.r.t. the fit parameters.\n", "\n", - "In our case this is the number of signal events, $n_{\\mathrm{s}}$ and the spectral index $\\gamma$. If we evaluate the LLH ratio function at the maximum, the gradients should be close to zero." + "In our case this is the number of signal events, $n_{\\mathrm{s}}$ and the spectral index $\\gamma$. If we evaluate the LLH ratio function at the maximum, the gradients should be close to zero. The test statistic is defined as $\\mathrm{TS} = 2 \\log\\Lambda$, i.e. twice the value of the LLH ratio function at the maximum." ] }, { @@ -126,16 +126,20 @@ "text": [ "Help on method evaluate in module skyllh.core.llhratio:\n", "\n", - "evaluate(fitparam_values, src_params_recarray=None, tl=None) method of skyllh.core.llhratio.MultiDatasetTCLLHRatio instance\n", + "evaluate(\n", + " fitparam_values: np.ndarray,\n", + " src_params_recarray: np.ndarray | None = None,\n", + " tl: TimeLord | None = None\n", + ") -> tuple[float, np.ndarray] method of skyllh.core.llhratio.MultiDatasetTCLLHRatio instance\n", " Evaluates the composite log-likelihood-ratio function and returns its\n", " value and global fit parameter gradients.\n", "\n", " Parameters\n", " ----------\n", - " fitparam_values : instance of numpy ndarray\n", + " fitparam_values\n", " The (N_fitparams,)-shaped numpy 1D ndarray holding the current\n", " values of the global fit parameters.\n", - " src_params_recarray : instance of numpy record ndarray | None\n", + " src_params_recarray\n", " The numpy record ndarray of length N_sources holding the parameter\n", " names and values of all sources.\n", " See the documentation of the\n", @@ -144,16 +148,16 @@ " It case it is ``None``, it will be created automatically from the\n", " ``fitparam_values`` argument using the\n", " :class:`~skyllh.core.parameters.ParameterModelMapper` instance.\n", - " tl : instance of TimeLord | None\n", + " tl\n", " The optional instance of TimeLord that should be used for timing\n", " measurements.\n", "\n", " Returns\n", " -------\n", - " log_lambda : float\n", + " log_lambda\n", " The calculated log-lambda value of the composite\n", " log-likelihood-ratio function.\n", - " grads : instance of numpy ndarray\n", + " grads\n", " The (N_fitparams,)-shaped 1D ndarray holding the gradient value of\n", " the composite log-likelihood-ratio function for each global fit\n", " parameter.\n", @@ -175,17 +179,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "llhratio_value = 14.383\n", - "grad_ns = -0.001\n", - "grad_gamma = -0.143\n" + "llhratio_value = 14.384\n", + "grad_ns = 0.000\n", + "grad_gamma = 0.000\n", + "2 * llhratio_value = 28.767 (TS = 28.767)\n" ] } ], "source": [ - "(llhratio_value, (grad_ns, grad_gamma)) = ana.llhratio.evaluate([80.09, 3.21])\n", + "(llhratio_value, (grad_ns, grad_gamma)) = ana.llhratio.evaluate([fitparam_values['ns'], fitparam_values['gamma']])\n", "print(f'llhratio_value = {llhratio_value:.3f}')\n", "print(f'grad_ns = {grad_ns:.3f}')\n", - "print(f'grad_gamma = {grad_gamma:.3f}')" + "print(f'grad_gamma = {grad_gamma:.3f}')\n", + "print(f'2 * llhratio_value = {2 * llhratio_value:.3f} (TS = {ts:.3f})')" ] }, { @@ -195,19 +201,19 @@ "source": [ "Using the `evaluate` method of the `LLHRatio` class we can scan the log-likelihood ratio space and create a contour plot showing the best fit and the 68%, 90%, and 95% quantile assuming Wilks' theorem.\n", "\n", - "Please be aware that this is an illustraative example. Whether the conditions that satisfy Wilks' theorem hold is left to the user as it will depend on the specific analysis being run and on the signal strength.\n", + "Please be aware that this is an illustrative example. Whether the conditions that satisfy Wilks' theorem hold is left to the user as it will depend on the specific analysis being run and on the signal strength.\n", "\n", - "To produce a likelihood scan, we create a grid of flux normalization and spectral index values. Then we convert the flux normalization values into mean number of signal events, which is what we can evaluate the LH on. Finally, we evalutate the LLH ratio at each grid point $(n_{\\mathrm{s}}, \\gamma)$.\n", + "To produce a likelihood scan, we create a grid of flux normalization and spectral index values. Then we convert the flux normalization values into mean number of signal events, which is what we can evaluate the LLH on. Since the detector signal yield depends on the spectral index, this conversion factor has to be calculated separately for each $\\gamma$ value of the grid. Finally, we evaluate the LLH ratio at each grid point $(n_{\\mathrm{s}}, \\gamma)$.\n", "\n", - "The log-likelihood ratio is then given by\n", + "The log-likelihood ratio with respect to the best fit is then given by\n", "\n", - "$$\\Delta\\log\\mathcal{L} = \\log\\mathcal{L}(\\hat{n}_{\\mathrm{s}}, \\hat\\gamma) - \\log\\mathcal{L}(n_{\\mathrm{s}}, \\gamma)$$\n", + "$$\\Delta\\log\\mathcal{L} = \\log\\mathcal{L}(n_{\\mathrm{s}}, \\gamma) - \\log\\mathcal{L}(\\hat{n}_{\\mathrm{s}}, \\hat\\gamma)$$\n", "\n", - "where $(\\hat{n}_{\\mathrm{s}}, \\hat\\gamma)$ are the maximum likelihood estimators.\n", + "where $(\\hat{n}_{\\mathrm{s}}, \\hat\\gamma)$ are the maximum likelihood estimators, so that $\\Delta\\log\\mathcal{L} \\leq 0$.\n", "\n", - "Conveniently, the $\\Delta\\log\\mathcal{L}$ can also be written as\n", + "Since the test statistic is defined as $\\mathrm{TS}(n_{\\mathrm{s}}, \\gamma) = 2\\log\\frac{\\mathcal{L}(n_{\\mathrm{s}}, \\gamma)}{\\mathcal{L}(n_{\\mathrm{s}}=0)}$, the quantity $-2\\Delta\\log\\mathcal{L}$ can be written as\n", "\n", - "$$\\log\\mathcal{L}(\\hat{n}_{\\mathrm{s}}, \\hat\\gamma) - \\log\\mathcal{L}(n_{\\mathrm{s}}, \\gamma) = \\log\\frac{\\mathcal{L}(\\hat{n}_{\\mathrm{s}}, \\hat\\gamma)}{\\mathcal{L}(n_{\\mathrm{s}}=0)} - \\log\\frac{\\mathcal{L}(n_{\\mathrm{s}}, \\gamma)}{\\mathcal{L}(n_{\\mathrm{s}}=0)} = \\mathrm{TS}(\\hat{n}_{\\mathrm{s}}, \\hat\\gamma) - \\mathrm{TS}(n_{\\mathrm{s}}, \\gamma)$$\n", + "$$-2\\Delta\\log\\mathcal{L} = 2\\log\\frac{\\mathcal{L}(\\hat{n}_{\\mathrm{s}}, \\hat\\gamma)}{\\mathcal{L}(n_{\\mathrm{s}}=0)} - 2\\log\\frac{\\mathcal{L}(n_{\\mathrm{s}}, \\gamma)}{\\mathcal{L}(n_{\\mathrm{s}}=0)} = \\mathrm{TS}(\\hat{n}_{\\mathrm{s}}, \\hat\\gamma) - \\mathrm{TS}(n_{\\mathrm{s}}, \\gamma) = \\Delta\\mathrm{TS}$$\n", "\n", "So we can directly evaluate our test statistics at the values of interest:" ] @@ -223,30 +229,27 @@ "(gamma_min, gamma_max, gamma_step) = (2.0, 4.0, 0.05)\n", "\n", "flux_edges = np.logspace(flux_min, flux_max, int((flux_max - flux_min) / flux_step) + 1)\n", - "flux_vals = 0.5 * (flux_edges[1:] + flux_edges[:-1])\n", + "flux_vals = np.sqrt(flux_edges[1:] * flux_edges[:-1])\n", "\n", - "gamma_edges_flux = np.linspace(gamma_min, gamma_max, int((gamma_max - gamma_min) / gamma_step + 1))\n", - "gamma_vals_flux = 0.5 * (gamma_edges_flux[1:] + gamma_edges_flux[:-1])\n", + "gamma_edges = np.linspace(gamma_min, gamma_max, int((gamma_max - gamma_min) / gamma_step + 1))\n", + "gamma_vals = 0.5 * (gamma_edges[1:] + gamma_edges[:-1])\n", "\n", - "flux_scaling_factor = ana.calculate_fluxmodel_scaling_factor(\n", - " fitparam_values=[fitparam_values['ns'], fitparam_values['gamma']]\n", - ")\n", + "# The TS value at the best fit is the unblinded TS value.\n", + "ts_best = ts\n", "\n", - "delta_ts_flux = np.empty((len(flux_vals), len(gamma_vals_flux)), dtype=np.double)\n", - "for flux_i, flux in enumerate(flux_vals):\n", - " ns = flux / flux_scaling_factor\n", - " for gamma_i, gamma in enumerate(gamma_vals_flux):\n", - " delta_ts_flux[flux_i, gamma_i] = ana.calculate_test_statistic(\n", - " ana.llhratio.evaluate([fitparam_values['ns'], fitparam_values['gamma']])[0],\n", - " [fitparam_values['ns'], fitparam_values['gamma']],\n", - " ) - ana.calculate_test_statistic(ana.llhratio.evaluate([ns, gamma])[0], [ns, gamma])\n", + "delta_ts = np.empty((len(flux_vals), len(gamma_vals)), dtype=np.double)\n", + "for gamma_i, gamma in enumerate(gamma_vals):\n", + " # The factor converting a number of signal events into a flux normalization\n", + " # depends on the spectral index, but not on the number of signal events.\n", + " flux_scaling_factor = ana.calculate_fluxmodel_scaling_factor(fitparam_values=[1, gamma])\n", + " for flux_i, flux in enumerate(flux_vals):\n", + " ns = flux / flux_scaling_factor\n", + " (log_lambda, _) = ana.llhratio.evaluate([ns, gamma])\n", + " delta_ts[flux_i, gamma_i] = ts_best - ana.calculate_test_statistic(log_lambda, [ns, gamma])\n", "\n", - "# Determine the best fit flux and gamma values from the scan.\n", - "index_max = np.argmin(delta_ts_flux)\n", - "flux_i_max = int(index_max / len(gamma_vals_flux))\n", - "gamma_i_max_flux = index_max % len(gamma_vals_flux)\n", - "flux_best = flux_vals[flux_i_max]\n", - "gamma_best_flux = gamma_vals_flux[gamma_i_max_flux]" + "# The best fit flux normalization and spectral index.\n", + "gamma_best = fitparam_values['gamma']\n", + "flux_best = ana.mu2flux(fitparam_values['ns'], fitparam_values=[fitparam_values['ns'], fitparam_values['gamma']])" ] }, { @@ -254,7 +257,7 @@ "id": "a1fb8272", "metadata": {}, "source": [ - "The contours are computed assuming that the Wilks' theorem holds true. That is the TS distribution follows the $\\chi^2$ distribution with 2 degrees of freedom, in this example." + "The contours are computed assuming that the Wilks' theorem holds true. That is the $-2\\Delta\\log\\mathcal{L}$ distribution follows the $\\chi^2$ distribution with 2 degrees of freedom, in this example." ] }, { @@ -264,9 +267,9 @@ "metadata": {}, "outputs": [], "source": [ - "chi2_68_quantile_flux = scipy.stats.chi2.ppf(0.68, df=2)\n", - "chi2_90_quantile_flux = scipy.stats.chi2.ppf(0.90, df=2)\n", - "chi2_95_quantile_flux = scipy.stats.chi2.ppf(0.95, df=2)" + "chi2_68_quantile = scipy.stats.chi2.ppf(0.68, df=2)\n", + "chi2_90_quantile = scipy.stats.chi2.ppf(0.90, df=2)\n", + "chi2_95_quantile = scipy.stats.chi2.ppf(0.95, df=2)" ] }, { @@ -277,7 +280,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -288,19 +291,19 @@ ], "source": [ "fig, ax = plt.subplots(1, 1, figsize=(6, 5))\n", - "im = ax.pcolormesh(gamma_edges_flux, flux_edges, delta_ts_flux, vmin=0, vmax=10, cmap='GnBu_r')\n", + "im = ax.pcolormesh(gamma_edges, flux_edges, delta_ts, vmin=0, vmax=10, cmap='GnBu_r')\n", "cbar = plt.colorbar(im)\n", - "cbar.set_label(r'$\\Delta$TS')\n", + "cbar.set_label(r'$-2\\Delta\\log\\mathcal{L}$')\n", "\n", - "ax.scatter([gamma_best_flux], [flux_best], color='w', marker='x', s=100, label='Best Fit')\n", + "ax.scatter([gamma_best], [flux_best], color='w', edgecolor='k', marker='X', s=100, label='Best Fit')\n", "contour_68 = ax.contour(\n", - " gamma_vals_flux, flux_vals, delta_ts_flux, levels=[chi2_68_quantile_flux], colors='w', linestyles='-', linewidths=2\n", + " gamma_vals, flux_vals, delta_ts, levels=[chi2_68_quantile], colors='w', linestyles='-', linewidths=2\n", ")\n", "contour_90 = ax.contour(\n", - " gamma_vals_flux, flux_vals, delta_ts_flux, levels=[chi2_90_quantile_flux], colors='w', linestyles='--', linewidths=2\n", + " gamma_vals, flux_vals, delta_ts, levels=[chi2_90_quantile], colors='w', linestyles='--', linewidths=2\n", ")\n", "contour_95 = ax.contour(\n", - " gamma_vals_flux, flux_vals, delta_ts_flux, levels=[chi2_95_quantile_flux], colors='w', linestyles=':', linewidths=2\n", + " gamma_vals, flux_vals, delta_ts, levels=[chi2_95_quantile], colors='w', linestyles=':', linewidths=2\n", ")\n", "\n", "ax.set_xlabel(r'Spectral Index $\\gamma$')\n", @@ -309,9 +312,9 @@ "ax.set_yscale('log')\n", "ax.set_ylim(5e-15, 1e-13)\n", "\n", - "ax.clabel(contour_68, fmt={chi2_68_quantile_flux: '68% CL'}, fontsize=10, inline=True, inline_spacing=5, manual=False)\n", - "ax.clabel(contour_90, fmt={chi2_90_quantile_flux: '90% CL'}, fontsize=10, inline=True, inline_spacing=5, manual=False)\n", - "ax.clabel(contour_95, fmt={chi2_95_quantile_flux: '95% CL'}, fontsize=10, inline=True, inline_spacing=5, manual=False)\n", + "ax.clabel(contour_68, fmt={chi2_68_quantile: '68% CL'}, fontsize=10, inline=True, inline_spacing=5, manual=False)\n", + "ax.clabel(contour_90, fmt={chi2_90_quantile: '90% CL'}, fontsize=10, inline=True, inline_spacing=5, manual=False)\n", + "ax.clabel(contour_95, fmt={chi2_95_quantile: '95% CL'}, fontsize=10, inline=True, inline_spacing=5, manual=False)\n", "\n", "plt.legend(loc='upper right')\n", "plt.show()" From 52de2ee4974d668fa5cdaf8f040db7fbfcb42732 Mon Sep 17 00:00:00 2001 From: Tomas Kontrimas Date: Mon, 2 Nov 2026 20:36:43 +0100 Subject: [PATCH 2/2] Move `test_detsigyield_follows_source_without_rebuilding_detsigyield_service` to #338 PR --- .../test_detsigyield_change_source.py | 131 ++++++++++++++++++ 1 file changed, 131 insertions(+) create mode 100644 tests/publicdata_ps/test_detsigyield_change_source.py diff --git a/tests/publicdata_ps/test_detsigyield_change_source.py b/tests/publicdata_ps/test_detsigyield_change_source.py new file mode 100644 index 0000000000..151ed6ede1 --- /dev/null +++ b/tests/publicdata_ps/test_detsigyield_change_source.py @@ -0,0 +1,131 @@ +import os +import tempfile +import unittest + +import numpy as np + +from skyllh.analyses.i3.publicdata_ps.detsigyield import PDSingleParamFluxPointLikeSourceI3DetSigYieldBuilder +from skyllh.core.config import Config +from skyllh.core.dataset import Dataset, DatasetData +from skyllh.core.flux_model import PowerLawEnergyFluxProfile, SteadyPointlikeFFM +from skyllh.core.parameters import Parameter +from skyllh.core.services import DetSigYieldService, SrcDetSigYieldWeightsService +from skyllh.core.source_hypo_grouping import SourceHypoGroup, SourceHypoGroupManager +from skyllh.core.source_model import PointLikeSource + +DEC_BINEDGES_DEG = np.array([-90.0, -60.0, -30.0, -10.0, 0.0, 10.0, 30.0, 60.0, 90.0]) +LOG10_ENU_BINEDGES = np.array([2.0, 3.0, 4.0, 5.0, 6.0]) + +LIVETIME_DAYS = 100.0 +PHI0 = 1.0 +E0 = 1e3 +GAMMA = 2.0 + + +def _aeff_value(dec_idx, log10_enu_idx): + """Returns the synthetic effective area in cm^2, which depends strongly on the declination bin.""" + return (1.0 + dec_idx) ** 3 * 10.0 ** (0.5 * log10_enu_idx) + + +def _write_aeff_file(pathfilename): + """Writes a synthetic effective area file in the public data format.""" + with open(pathfilename, 'w') as f: + f.write('# log10(E_nu/GeV)_min log10(E_nu/GeV)_max Dec_nu_min[deg] Dec_nu_max[deg] A_Eff[cm^2]\n') + f.writelines( + f'{LOG10_ENU_BINEDGES[e_idx]} {LOG10_ENU_BINEDGES[e_idx + 1]} ' + f'{DEC_BINEDGES_DEG[dec_idx]} {DEC_BINEDGES_DEG[dec_idx + 1]} ' + f'{_aeff_value(dec_idx, e_idx)}\n' + for dec_idx in range(len(DEC_BINEDGES_DEG) - 1) + for e_idx in range(len(LOG10_ENU_BINEDGES) - 1) + ) + + +class ChangeSourceDetSigYieldTestCase(unittest.TestCase): + """Tests that the source detector signal yield weights follow a change of + the source, as done by ``Analysis.change_source``, with and without + re-building the detector signal yield service. + """ + + @classmethod + def setUpClass(cls): + cls.tmpdir = tempfile.TemporaryDirectory() + _write_aeff_file(os.path.join(cls.tmpdir.name, 'aeff.csv')) + + cls.cfg = Config() + + cls.ds = Dataset( + cfg=cls.cfg, + name='synthetic', + exp_pathfilenames=None, + mc_pathfilenames=None, + livetime=LIVETIME_DAYS, + default_sub_path_fmt='', + version=1, + base_path=cls.tmpdir.name, + ) + cls.ds.add_aux_data_definition('eff_area_datafile', 'aeff.csv') + cls.data = DatasetData(data_exp=None, data_mc=None, livetime=LIVETIME_DAYS) + + cls.fluxmodel = SteadyPointlikeFFM( + Phi0=PHI0, + energy_profile=PowerLawEnergyFluxProfile(E0=E0, gamma=GAMMA, cfg=cls.cfg), + cfg=cls.cfg, + ) + cls.param_gamma = Parameter(name='gamma', initial=GAMMA, valmin=1.0, valmax=4.0) + + @classmethod + def tearDownClass(cls): + cls.tmpdir.cleanup() + + def _create_shg_mgr(self, dec): + builder = PDSingleParamFluxPointLikeSourceI3DetSigYieldBuilder( + cfg=self.cfg, param_grid=self.param_gamma.as_linear_grid(delta=0.1), ncpu=1 + ) + return SourceHypoGroupManager( + SourceHypoGroup( + sources=PointLikeSource(ra=0.0, dec=dec), + fluxmodel=self.fluxmodel, + detsigyield_builders=builder, + ) + ) + + def test_detsigyield_follows_source_without_rebuilding_detsigyield_service(self): + """Changing the source declination and updating only the source + detector signal yield weights service (as ``update_detsigyield_service=False`` + does) must yield the same values as re-building the detector signal + yield service, because the detector signal yield is a function of the + source declination. + """ + src_params_recarray = np.array([(GAMMA, 1)], dtype=[('gamma', np.float64), ('gamma:gpidx', np.int32)]) + + shg_mgr = self._create_shg_mgr(dec=np.radians(5.0)) + detsigyield_service = DetSigYieldService(shg_mgr=shg_mgr, dataset_list=[self.ds], data_list=[self.data]) + weights_service = SrcDetSigYieldWeightsService(detsigyield_service=detsigyield_service) + + weights_service.calculate(src_params_recarray) + (a_jk_initial, _) = weights_service.get_weights() + assert a_jk_initial is not None + + # Change the source in-place and update only the weights service, like + # Analysis.change_source(update_detsigyield_service=False) does. + shg_mgr.shg_list[0].source_list[0] = PointLikeSource(ra=0.0, dec=np.radians(45.0)) + weights_service.change_shg_mgr(shg_mgr=shg_mgr) + weights_service.calculate(src_params_recarray) + (a_jk_new, _) = weights_service.get_weights() + assert a_jk_new is not None + + # The effective area depends strongly on the declination. + self.assertFalse(np.allclose(a_jk_new, a_jk_initial)) + + # Re-building the detector signal yield service must give the same. + detsigyield_service.change_shg_mgr(shg_mgr=shg_mgr) + weights_service.change_shg_mgr(shg_mgr=shg_mgr) + weights_service.calculate(src_params_recarray) + (a_jk_rebuilt, _) = weights_service.get_weights() + assert a_jk_rebuilt is not None + + np.testing.assert_allclose(a_jk_new, a_jk_rebuilt, rtol=1e-12) + + +if __name__ == '__main__': + unittest.main()