icecube-skyreader 1.3.0__tar.gz → 1.3.2__tar.gz

{icecube-skyreader-1.3.0 → icecube-skyreader-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icecube-skyreader
-Version: 1.3.0
+Version: 1.3.2
 Summary: An API for Results Produced by SkyDriver & the Skymap Scanner
 Home-page: https://github.com/icecube/skyreader
 Download-URL: https://pypi.org/project/icecube-skyreader/

{icecube-skyreader-1.3.0 → icecube-skyreader-1.3.2}/icecube_skyreader.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icecube-skyreader
-Version: 1.3.0
+Version: 1.3.2
 Summary: An API for Results Produced by SkyDriver & the Skymap Scanner
 Home-page: https://github.com/icecube/skyreader
 Download-URL: https://pypi.org/project/icecube-skyreader/

{icecube-skyreader-1.3.0 → icecube-skyreader-1.3.2}/icecube_skyreader.egg-info/requires.txt

@@ -2,6 +2,7 @@ astropy
 healpy
 matplotlib
 meander
+mhealpy
 numpy
 pandas
 scipy

{icecube-skyreader-1.3.0 → icecube-skyreader-1.3.2}/setup.cfg

@@ -51,6 +51,7 @@ install_requires =
 	healpy
 	matplotlib
 	meander
+	mhealpy
 	numpy
 	pandas
 	scipy

{icecube-skyreader-1.3.0 → icecube-skyreader-1.3.2}/skyreader/__init__.py

@@ -17,7 +17,7 @@ __all__ = [
 # is zero for an official release, positive for a development branch,
 # or negative for a release candidate or beta (after the base version
 # number has been incremented)
-__version__ = "1.3.0"
+__version__ = "1.3.2"
 version_info = (
     int(__version__.split(".")[0]),
     int(__version__.split(".")[1]),

{icecube-skyreader-1.3.0 → icecube-skyreader-1.3.2}/skyreader/plot/plot.py

@@ -8,8 +8,8 @@ import pickle
 from pathlib import Path
 from typing import List, Union
 
+import copy
 import healpy  # type: ignore[import]
-# import mhealpy
 import matplotlib  # type: ignore[import]
 import meander  # type: ignore[import]
 import numpy as np
@@ -28,7 +28,12 @@ from .plotting_tools import (
 )
 
 from ..utils.areas import calculate_area, get_contour_areas
-from ..utils.handle_map_data import extract_map, get_contour_levels
+from ..utils.handle_map_data import (
+    extract_map,
+    get_contour_levels,
+    prepare_flattened_map,
+    prepare_multiorder_map,
+)
 from ..result import SkyScanResult
 
 LOGGER = logging.getLogger("skyreader.plot")
@@ -92,10 +97,11 @@ class SkyScanPlotter:
         plot_filename = f"{unique_id}.{addition_to_filename}pdf"
         LOGGER.info(f"saving plot to {plot_filename}")
 
-        (
-            grid_value, grid_ra, grid_dec, equatorial_map
-        ) = extract_map(
-            result, llh_map, angular_error_floor, remove_min_val=not llh_map
+        grid_value, grid_ra, grid_dec, equatorial_map, _ = extract_map(
+            result,
+            llh_map,
+            angular_error_floor,
+            remove_min_val=not llh_map,
         )
 
         grid_pix = healpy.ang2pix(max(nsides), np.pi/2. - DEC, RA)
@@ -129,9 +135,17 @@ class SkyScanPlotter:
                 self.PLOT_COLORMAP.name.rstrip('_r')
             ]
             text_colorbar = r"log10$(p)$"
-            vmin = np.min(np.log10(equatorial_map))
-            vmax = np.max(np.log10(equatorial_map))
-            map_to_plot = np.log10(plotting_map)
+            vmin = np.nanmin(
+                np.log10(equatorial_map[equatorial_map != 0.])
+            )
+            vmax = np.nanmax(
+                np.log10(equatorial_map[equatorial_map != 0.])
+            )
+            map_to_plot = copy.copy(plotting_map)
+            map_to_plot[plotting_map != 0.] = np.log10(
+                plotting_map[plotting_map != 0.]
+            )
+            map_to_plot[plotting_map == 0.] = np.nan
         equatorial_map = np.ma.masked_invalid(equatorial_map)
         map_to_plot = np.ma.masked_invalid(map_to_plot)
 
@@ -378,20 +392,20 @@ class SkyScanPlotter:
         return Theta, Phi
 
     def create_plot_zoomed(
-            self,
-            result: SkyScanResult,
-            extra_ra=np.nan,
-            extra_dec=np.nan,
-            extra_radius=np.nan,
-            systematics=False,
-            plot_bounding_box=False,
-            plot_4fgl=False,
-            circular=False,
-            circular_err50=0.2,
-            circular_err90=0.7,
-            angular_error_floor=None,  # if not None, sigma of the
-            # gaussian to convolute the map with in deg.
-            llh_map=True
+        self,
+        result: SkyScanResult,
+        extra_ra=np.nan,
+        extra_dec=np.nan,
+        extra_radius=np.nan,
+        systematics=False,
+        plot_bounding_box=False,
+        plot_4fgl=False,
+        circular=False,
+        circular_err50=0.2,
+        circular_err90=0.7,
+        angular_error_floor=None,  # if not None, sigma of the
+        # gaussian to convolute the map with in deg.
+        llh_map=True
     ):
         """Uses healpy to plot a map."""
 
@@ -427,7 +441,7 @@ class SkyScanPlotter:
             plot_filename = unique_id + ".plot_zoomed.pdf"
 
         (
-            grid_value, grid_ra, grid_dec, equatorial_map
+            grid_value, grid_ra, grid_dec, equatorial_map, uniq_array
         ) = extract_map(result, llh_map, angular_error_floor)
         min_dec = grid_dec[0]
         min_ra = grid_ra[0]
@@ -444,11 +458,24 @@ class SkyScanPlotter:
         sample_points = np.array([np.pi/2 - grid_dec, grid_ra]).T
 
         if not circular:
+            grid_values_for_contours = copy.copy(grid_value)
             if llh_map:
-                grid_values_for_contours = grid_value
+                # get rid of nan values only for the contours
+                # this avoids crashes during plotting
+                grid_values_for_contours[
+                    np.isnan(grid_values_for_contours)
+                ] = np.nanmax(equatorial_map)
                 contour_levels_for_contours = contour_levels
             else:
-                grid_values_for_contours = np.log(grid_value)
+                grid_values_for_contours[
+                    np.logical_or(
+                        np.isnan(grid_values_for_contours),
+                        grid_values_for_contours == 0.
+                    )
+                ] = np.nanmin(equatorial_map[equatorial_map > 0.])
+                grid_values_for_contours = np.log(
+                    grid_values_for_contours
+                )
                 contour_levels_for_contours = np.log(contour_levels)
             # Get contours from healpix map
             contours_by_level = meander.spherical_contours(
@@ -599,8 +626,7 @@ class SkyScanPlotter:
             contour_colors,
             contours_by_level
         ):
-            contour_label = contour_label + ' - area: {0:.2f} sqdeg'.format(
-                contour_area_sqdeg)
+            contour_label = contour_label + f' - area: {contour_area_sqdeg:.2f} sqdeg'
             first = True
             for contour in contours:
                 theta, phi = contour.T
@@ -640,7 +666,6 @@ class SkyScanPlotter:
             rot=(lon, lat, 0),
             bounds=(lower_lon, upper_lon, lower_lat, upper_lat)
         )
-
         if plot_4fgl:
             # Overlay 4FGL sources
             plot_catalog(
@@ -669,13 +694,11 @@ class SkyScanPlotter:
             print(contain_txt)
 
         print(
-            "Contour Area (50%):",
-            contour_areas[0],
+            f"Contour Area (50%): {contour_areas[0]}",
             "square degrees (scaled)"
         )
         print(
-            "Contour Area (90%):",
-            contour_areas[1],
+            f"Contour Area (90%): {contour_areas[1]}",
             "square degrees (scaled)"
         )
 
@@ -712,7 +735,6 @@ class SkyScanPlotter:
             # join end to beginning
             bounding_ras_list.append(bounding_ras_list[0])
             bounding_decs_list.append(bounding_decs_list[0])
-
             bounding_ras: np.ndarray = np.asarray(bounding_ras_list)
             bounding_decs: np.ndarray = np.asarray(bounding_decs_list)
             bounding_phi = np.radians(bounding_ras)
@@ -723,7 +745,7 @@ class SkyScanPlotter:
             # convert to square-degrees
             bounding_contour_area *= (180.*180.)/(np.pi*np.pi)
             contour_label = r'90% Bounding rectangle' + \
-                ' - area: {0:.2f} sqdeg'.format(bounding_contour_area)
+                f' - area: {bounding_contour_area:.2f} sqdeg'
             healpy.projplot(
                 bounding_theta,
                 bounding_phi,
@@ -733,32 +755,6 @@ class SkyScanPlotter:
                 label=contour_label
             )
 
-        # Output contours in RA, dec instead of theta, phi
-        saving_contours: list = []
-        for contours in contours_by_level:
-            saving_contours.append([])
-            for contour in contours:
-                saving_contours[-1].append([])
-                theta, phi = contour.T
-                ras = phi
-                decs = np.pi/2 - theta
-                for tmp_ra, tmp_dec in zip(ras, decs):
-                    saving_contours[-1][-1].append([tmp_ra, tmp_dec])
-
-        # Save the individual contours, send messages
-        for i, val in enumerate(["50", "90"]):
-            ras = list(np.asarray(saving_contours[i][0]).T[0])
-            decs = list(np.asarray(saving_contours[i][0]).T[1])
-            tab = {"ra (rad)": ras, "dec (rad)": decs}
-            savename = unique_id + ".contour_" + val + ".txt"
-            try:
-                LOGGER.info("Dumping to {savename}")
-                ascii.write(tab, savename, overwrite=True)
-            except OSError:
-                LOGGER.error(
-                    "OS Error prevented contours from being written, "
-                    "maybe a memory issue. Error is:\n{err}")
-
         uncertainty = [(ra_minus, ra_plus), (dec_minus, dec_plus)]
         fits_header = format_fits_header(
             (
@@ -776,18 +772,15 @@ class SkyScanPlotter:
 
         # Plot the original online reconstruction location
         if np.sum(np.isnan([extra_ra, extra_dec, extra_radius])) == 0:
-
             # dist = angular_distance(minRA, minDec, extra_ra * np.pi/180.,
             # extra_dec * np.pi/180.)
             # print("Millipede best fit is", dist /(np.pi *
             # extra_radius/(1.177 * 180.)), "sigma from reported best fit")
-
             extra_ra_rad = np.radians(extra_ra)
             extra_dec_rad = np.radians(extra_dec)
             extra_radius_rad = np.radians(extra_radius)
             extra_lon = extra_ra_rad
             extra_lat = extra_dec_rad
-
             healpy.projscatter(
                 np.degrees(extra_lon),
                 np.degrees(extra_lat),
@@ -816,52 +809,34 @@ class SkyScanPlotter:
                     color=cont_col,
                     linestyle=cont_sty
                 )
-
         plt.legend(fontsize=6, loc="lower left")
 
-        # Dump the whole contour
-        path = unique_id + ".contour.pkl"
-        print("Saving contour to", path)
-        with open(path, "wb") as f:
-            pickle.dump(saving_contours, f)
-
-        # logic for multiordermaps -> for future developements
-
-        # save multiorder version of the map
-        # multiorder_map = mhealpy.HealpixMap(
-        #     grid_value, uniq_array
-        # )
-        # multiorder_map.write_map(
-        #     f"{unique_id}.skymap_nside_{mmap_nside}.multiorder.fits.gz",
-        #     column_names=["PROBABILITY"],
-        #     extra_header=fits_header,
-        #     overwrite=True,
-        # )
-
-        if llh_map:
-            column_names = ['2DLLH']
-        else:
-            # avoid excessively heavy data format for the flattened map
-            equatorial_map[
-                equatorial_map < 1e-16
-            ] = np.mean(
-                equatorial_map[equatorial_map < 1e-16]
-            )
-            column_names = ["PROBABILITY"]
-
         # save flattened map
+        equatorial_map, column_names = prepare_flattened_map(
+            equatorial_map, llh_map
+        )
         if llh_map:
             type_map = "llh"
         else:
             type_map = "probability"
+        filename_main = f"{unique_id}.skymap_nside_{mmap_nside}_{type_map}"
         healpy.write_map(
-            f"{unique_id}.skymap_nside_{mmap_nside}_{type_map}.fits.gz",
+            self.output_dir / f"{filename_main}.fits.gz",
             equatorial_map,
             coord='C',
             column_names=column_names,
             extra_header=fits_header,
             overwrite=True
         )
+        multiorder_map, column_names = prepare_multiorder_map(
+            grid_value, uniq_array, llh_map, column_names
+        )
+        multiorder_map.write_map(
+            self.output_dir / f"{filename_main}.multiorder.fits.gz",
+            column_names=column_names,
+            extra_header=fits_header,
+            overwrite=True,
+        )
 
         # Save the figure
         LOGGER.info(f"Saving: {plot_filename}...")
@@ -873,6 +848,40 @@ class SkyScanPlotter:
             bbox_inches='tight'
         )
 
+        self._save_contours(contours_by_level, unique_id)
         LOGGER.info("done.")
 
         plt.close()
+
+    def _save_contours(self, contours_by_level, unique_id) -> None:
+        # Output contours in RA, dec instead of theta, phi
+        saving_contours: list = []
+        for contours in contours_by_level:
+            saving_contours.append([])
+            for contour in contours:
+                saving_contours[-1].append([])
+                theta, phi = contour.T
+                ras = phi
+                decs = np.pi/2 - theta
+                for tmp_ra, tmp_dec in zip(ras, decs):
+                    saving_contours[-1][-1].append([tmp_ra, tmp_dec])
+
+        # Save the individual contours
+        for i, val in enumerate(["50", "90"]):
+            ras = list(np.asarray(saving_contours[i][0]).T[0])
+            decs = list(np.asarray(saving_contours[i][0]).T[1])
+            tab = {"ra (rad)": ras, "dec (rad)": decs}
+            savepath = self.output_dir / f"{unique_id}.contour_{val}.txt"
+            try:
+                LOGGER.info(f"Dumping to {savepath}")
+                ascii.write(tab, savepath, overwrite=True)
+            except OSError:
+                LOGGER.error(
+                    "OS Error prevented contours from being written, "
+                    "maybe a memory issue. Error is:\n{err}")
+
+        # Dump the whole contour
+        path = self.output_dir / f"{unique_id}.contour.pkl"
+        print("Saving contour to", path)
+        with open(path, "wb") as f:
+            pickle.dump(saving_contours, f)

{icecube-skyreader-1.3.0 → icecube-skyreader-1.3.2}/skyreader/plot/plotting_tools.py

@@ -16,7 +16,9 @@ from matplotlib.transforms import Affine2D  # type: ignore[import]
 
 matplotlib.use('agg')
 
-def format_fits_header(event_id_tuple, mjd, ra, dec, uncertainty, llh_map):
+def format_fits_header(
+    event_id_tuple, mjd, ra, dec, uncertainty, llh_map,
+):
     """Prepare some of the relevant event information for a fits file
     header."""
     run_id, event_id, event_type = event_id_tuple
@@ -24,14 +26,14 @@ def format_fits_header(event_id_tuple, mjd, ra, dec, uncertainty, llh_map):
     if llh_map:
         uncertainty_comment = 'Change in 2LLH based on Wilks theorem'
     else:
-        uncertainty_comment = 'Probability-per-pixel (all pixels with same area)'
+        uncertainty_comment = 'Highest posterior density 90% credible region'
 
     header = [
         ('RUNID', run_id),
         ('EVENTID', event_id),
         ('SENDER', 'IceCube Collaboration'),
         ('EventMJD', mjd),
-        ('I3TYPE', '%s'%event_type,'Alert Type'),
+        ('I3TYPE', f'{event_type}','Alert Type'),
         ('RA', np.round(ra,2),'Degree'),
         ('DEC', np.round(dec,2),'Degree'),
         ('RA_ERR_PLUS', np.round(uncertainty[0][1],2),
@@ -42,7 +44,7 @@ def format_fits_header(event_id_tuple, mjd, ra, dec, uncertainty, llh_map):
             '90% containment error high'),
         ('DEC_ERR_MINUS', np.round(np.abs(uncertainty[1][0]),2),
             '90% containment error low'),
-        ('COMMENTS', '50%(90%) uncertainty location' \
+        ('COMMENTS', '90% uncertainty location' \
             + ' => ' + uncertainty_comment),
         ('NOTE', 'Please ignore pixels with infinite or NaN values.' \
             + ' They are rare cases of the minimizer failing to converge')
@@ -97,12 +99,12 @@ def hp_ticklabels(zoom=False, lonra=None, latra=None, rot=None, bounds=None):
     pe = [path_effects.Stroke(linewidth=1.5, foreground='white'),
           path_effects.Normal()]
     for _ in lats:
-        healpy.projtext(lon_offset, _, "{:.0f}$^\circ$".format(_),
+        healpy.projtext(lon_offset, _, f"{_:.0f}$^\\circ$",
                     lonlat=True, path_effects=pe, fontsize=10)
     if zoom:
         for _ in lons:
             healpy.projtext(_, lat_offset,
-                        "{:.0f}$^\circ$".format(_), lonlat=True,
+                        f"{_:.0f}$^\\circ$", lonlat=True,
                         path_effects=pe, fontsize=10)
     else:
         ax.annotate(r"$\bf{-180^\circ}$", xy=(1.7, 0.625), size="medium")

{icecube-skyreader-1.3.0 → icecube-skyreader-1.3.2}/skyreader/result.py

@@ -217,6 +217,10 @@ class SkyScanResult:
         else:
             self.logger.warning("Metadata doesn't seem to exist and will not be used for plotting.")
             return EventMetadata(0, 0, '', 0, False)
+        
+    def get_results_per_nside(self, nside: int) -> np.ndarray:
+        "get the results for the pixels at a given nside"
+        return self.result[f"nside-{nside}"]
 
     def isclose_nside(self,
         other: "SkyScanResult",
@@ -388,7 +392,7 @@ class SkyScanResult:
         try:
             first = next(iter(self.result.values()))
         except StopIteration: # no results yet
-            np.savez(filename, **self.result)
+            np.savez(filename, **self.result)  # type: ignore
             return Path(filename)
 
         try:
@@ -405,9 +409,9 @@ class SkyScanResult:
                 ],
                 dtype=metadata_dtype,
             )
-            np.savez(filename, header=header, **self.result)
+            np.savez(filename, header=header, **self.result)  # type: ignore
         except (TypeError, AttributeError):
-            np.savez(filename, **self.result)
+            np.savez(filename, **self.result)  # type: ignore
 
         return Path(filename)
 

icecube-skyreader-1.3.2/skyreader/utils/handle_map_data.py

@@ -0,0 +1,407 @@
+from typing import Union, Tuple, List
+import logging
+
+import healpy  # type: ignore[import]
+import mhealpy  # type: ignore[import]
+import numpy as np
+
+from ..result import SkyScanResult
+
+LOGGER = logging.getLogger("skyreader.extract_map")
+
+
+def extract_map(
+        result: SkyScanResult,
+        llh_map: bool = True,
+        angular_error_floor: Union[None, float] = None,
+        remove_min_val: bool = True,
+) -> Tuple[
+    np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray
+]:
+    """
+    Extract from the output of skymap_scanner the healpy map
+    args:
+        - result: SkyScanResult. The output of the Skymap Scanner
+        - llh_map: bool = True. If True the likelihood will be plotted,
+            otherwise the probability
+        - angular_error_floor: Union[None, float] = None. if not None,
+            sigma of the gaussian to convolute the map with in deg.
+        - remove_min_val: bool = True. Remove minimum value from -llh
+          no effect if probability map.
+
+    returns:
+        - grid_value: value-per-scanned-pixel (pixels with
+            different nsides)
+        - grid_ra: right ascension for each pixel in grid_value
+        - grid_dec: declination for each pixel in grid_value
+        - equatorial_map: healpix map with maximum nside (all pixels
+            with same nside)
+        - uniq_array: uniqs for all the pixels of the map
+    """
+
+    grid_map = dict()
+
+    nsides = result.nsides
+    max_nside = max(nsides)
+    equatorial_map = np.full(healpy.nside2npix(max_nside), np.nan)
+    uniq_list = []
+
+    for nside in nsides:
+        LOGGER.info(f"constructing map for nside {nside}...")
+        npix = healpy.nside2npix(nside)
+        map_data = result.get_results_per_nside(nside)
+        pixels = map_data['index']
+        values = map_data['llh']
+        this_map = np.full(npix, np.nan)
+        this_map[pixels] = values
+        if nside < max_nside:
+            this_map = healpy.ud_grade(this_map, max_nside)
+        mask = np.logical_and(~np.isnan(this_map), np.isfinite(this_map))
+        equatorial_map[mask] = this_map[mask]
+
+        for pixel_data in result.get_results_per_nside(nside):
+            pixel = pixel_data['index']
+            value = pixel_data['llh']
+            nested_pixel = healpy.ring2nest(nside, pixel)
+            uniq = 4*nside*nside + nested_pixel
+            uniq_list.append(uniq)
+            tmp_theta, tmp_phi = healpy.pix2ang(nside, pixel)
+            tmp_dec = np.pi/2 - tmp_theta
+            tmp_ra = tmp_phi
+            grid_map[(tmp_dec, tmp_ra)] = value
+
+        # In case of pointed scans, it helps filling the first nside
+        # with empty pixels (especially for saving the multiorder map)
+        if nside == nsides[0]:
+            grid_map, uniq_list = _fill_first_nside_empty(
+                nside, result, grid_map, uniq_list
+            )
+
+        LOGGER.info(f"done with map for nside {nside}...")
+
+    grid_dec_list, grid_ra_list, grid_value_list = [], [], []
+
+    for (dec, ra), value in grid_map.items():
+        grid_dec_list.append(dec)
+        grid_ra_list.append(ra)
+        grid_value_list.append(value)
+    grid_dec: np.ndarray = np.asarray(grid_dec_list)
+    grid_ra: np.ndarray = np.asarray(grid_ra_list)
+    grid_value: np.ndarray = np.asarray(grid_value_list)
+    uniq_array: np.ndarray = np.asarray(uniq_list)
+
+    sorting_indices = np.argsort(grid_value)
+    grid_value = grid_value[sorting_indices]
+    grid_dec = grid_dec[sorting_indices]
+    grid_ra = grid_ra[sorting_indices]
+    uniq_array = uniq_array[sorting_indices]
+
+    min_value = grid_value[0]
+
+    if remove_min_val or (not llh_map):
+        # renormalize
+        grid_value = grid_value - min_value
+        min_value = 0.
+
+        # renormalize
+        equatorial_map[np.isinf(equatorial_map)] = np.nan
+        equatorial_map -= np.nanmin(equatorial_map)
+
+    if llh_map:
+        # show 2 * delta_LLH
+        grid_value = grid_value * 2.
+        equatorial_map *= 2.
+    else:
+        # Convert to probability
+        equatorial_map = np.exp(-1. * equatorial_map)
+        equatorial_map = equatorial_map / np.nansum(equatorial_map)
+        min_map = np.nanmin(equatorial_map)
+
+        if angular_error_floor is not None:
+            # convolute with a gaussian. angular_error_floor is the
+            # sigma in deg.
+            # nan values are a problem for the convolution and the contours
+            equatorial_map = healpy.smoothing(
+                np.nan_to_num(equatorial_map),
+                sigma=np.deg2rad(angular_error_floor),
+            )
+
+            # normalize map
+            min_map = np.nanmin(equatorial_map[equatorial_map >= 0.])
+            equatorial_map = equatorial_map.clip(min_map, None)
+            normalization = np.nansum(equatorial_map)
+            equatorial_map = equatorial_map / normalization
+
+        # obtain values for grid map
+        grid_value = healpy.get_interp_val(
+            equatorial_map, np.pi/2 - grid_dec, grid_ra
+        )
+        grid_value = grid_value.clip(min_map, None)
+
+    return grid_value, grid_ra, grid_dec, equatorial_map, uniq_array
+
+
+def _fill_first_nside_empty(
+    nside: int,
+    result: SkyScanResult,
+    grid_map: dict,
+    uniq_list: list,
+):
+    """
+    Fill the grid_map at the first nside with empty pixels
+    """
+    tot_npix = healpy.nside2npix(nside)
+    if tot_npix > len(result.get_results_per_nside(nside)):
+        ring_pixels = np.arange(tot_npix)
+        nest_pixels = healpy.ring2nest(nside, ring_pixels)
+        uniq_pixels = mhealpy.nest2uniq(nside, nest_pixels)
+        for uni, rin in zip(uniq_pixels, ring_pixels):
+            if uni not in uniq_list:
+                uniq_list.append(uni)
+                tmp_theta, tmp_phi = healpy.pix2ang(nside, rin)
+                tmp_dec = np.pi/2 - tmp_theta
+                tmp_ra = tmp_phi
+                grid_map[(tmp_dec, tmp_ra)] = np.nan
+    return grid_map, uniq_list
+
+
+def get_contour_levels(
+    equatorial_map: np.ndarray,
+    llh_map: bool = True,
+    systematics: bool = False,
+):
+    """
+    get contour levels for the desired map
+
+    args:
+        - equatorial_map: np.ndarray. Necessary in case of
+            probability map.
+        - llh_map: bool. If True llh levels, otherwise probability
+            levels.
+        - systematics: bool. Only for llh maps. If True include
+            recalibrated llh values from Pan-Starrs event 127852
+            (IC160427A syst.)
+
+    returns:
+        - contour_levels, levels of the contours
+        - contour_labels, respective labels for the contours
+        - contour_colors, respective colors for the contours
+    """
+
+    # Calculate the contour levels
+    if llh_map:  # likelihood map
+        min_value = np.nanmin(equatorial_map)
+        if systematics:
+            # from Pan-Starrs event 127852
+            # these are values determined from MC by Will on the TS (2*LLH)
+            # Not clear yet how to translate this for the probability map
+            contour_levels = (np.array([22.2, 64.2])+min_value)
+            contour_labels = [
+                r'50% (IC160427A syst.)', r'90% (IC160427A syst.)'
+            ]
+            contour_colors = ['k', 'r']
+        # Wilks
+        else:
+            contour_levels = (
+                np.array([1.39, 4.61, 11.83, 28.74])+min_value
+            )[:3]
+            contour_labels = [
+                r'50%', r'90%', r'3$\sigma$', r'5$\sigma$'
+            ][:3]
+            contour_colors = ['k', 'r', 'g', 'b'][:3]
+    else:  # probability map
+        if systematics:
+            raise AssertionError(
+                "No corrected values for contours in probability maps"
+            )
+        else:
+            sorted_values = np.sort(equatorial_map)[::-1]
+            probability_levels = (
+                np.array([0.5, 0.9, 1-1.35e-3, 1-2.87e-7])
+            )[:3]
+            contour_levels = []
+            for prob in probability_levels:
+                level_index = (
+                    np.nancumsum(sorted_values) >= prob
+                ).tolist().index(True)
+                level = sorted_values[level_index]
+                contour_levels.append(level)
+            contour_labels = [r'50%', r'90%', r'3$\sigma$', r'5$\sigma$'][:3]
+            contour_colors = ['k', 'r', 'g', 'b'][:3]
+
+    return contour_levels, contour_labels, contour_colors
+
+
+def find_pixels_double_nside(
+    nside: int,
+    indexes: np.ndarray,
+):
+    """
+    Given indexes of pixels at a given nside, find which are
+    the pixels inside these pixels with a double nside
+
+    args:
+        - nside: int. nside of the pixels to investigate.
+        - indexes: np.ndarray. indexes on ring ordering of the pixels
+            to investigate.
+
+    returns:
+        - idxs_inside: np.ndarray, array containing an array for each
+            initial pixel which tells which are the pixels with double
+            nside inside that pixel. The pixels are in ring ordering.
+    """
+
+    vecs = healpy.boundaries(nside, indexes)
+    transposed_vecs = np.transpose(vecs, axes=(0,2,1))
+    idxs_inside = np.array(
+        [healpy.query_polygon(nside*2, vs) for vs in transposed_vecs]
+    )
+    return idxs_inside
+
+
+def already_filled_uniqs_for_nside(
+    nside: int,
+    next_nside: int,
+    uniqs: np.ndarray
+):
+    """
+    Check if among the input uniqs there are pixels at a finer nside
+    which are inside other pixels with a bigger nside
+
+    args:
+        -nside: int. nside of the pixels to see if there are finer pixels
+            inside.
+        -next_nside: int. nside of the finer pixes which we want to see
+            if they are inside the coarser pixels
+        -uniqs: np.ndarray. Uniqs for all the pixels in the map
+
+    returns:
+        already_filled_uniqs: np.ndarray. Uniqs of the coarser pixels
+            which are already filled.
+    """
+    nside_per_pixel = mhealpy.uniq2nside(uniqs)
+    uniqs_nside = uniqs[nside_per_pixel == nside]
+    uniqs_next_nside = uniqs[nside_per_pixel == next_nside]
+    pixels_nside = healpy.nest2ring(
+        nside, mhealpy.uniq2nest(uniqs_nside)[1]
+    )
+    idxs_double_nside = find_pixels_double_nside(nside, pixels_nside)
+    already_filled_uniqs = []
+    for uniq_original_nside, idxs_pixel in zip(
+        uniqs_nside, idxs_double_nside
+    ):
+        progressive_nside = nside*2
+        while progressive_nside != next_nside:
+            idxs_pixel = np.concatenate(
+                find_pixels_double_nside(progressive_nside, idxs_pixel)
+            )
+            progressive_nside *= 2
+        uniqs_pixel = mhealpy.nest2uniq(
+            next_nside, healpy.ring2nest(next_nside, idxs_pixel)
+        )
+        pixel_already_filled = False
+        for uniq in uniqs_next_nside:
+            if uniq in uniqs_pixel:
+                pixel_already_filled = True
+                continue
+        if pixel_already_filled:
+            already_filled_uniqs.append(uniq_original_nside)
+    return np.array(already_filled_uniqs)
+
+
+def find_filled_pixels(uniqs: np.ndarray):
+    """
+    given an array of uniqs, finds which pixels already have finer
+    pixels inside and returns array with the indeces of these pixels
+
+    args:
+        - uniqs: np.ndarray. Array of uniqs per each pixel of the map
+
+    returns:
+        - already_filled_indeces: np.ndarray. Array with the indeces
+            of the already_filled_uniqs in the input array
+    """
+    nside_per_pixel = mhealpy.uniq2nside(uniqs)
+    nsides = np.unique(nside_per_pixel)
+    already_filled_uniqs = []
+    for nside_index, nside in enumerate(nsides[:-1]):
+        next_nside = nsides[nside_index + 1]
+        already_filled_uniqs_nside = already_filled_uniqs_for_nside(
+            nside, next_nside, uniqs
+        )
+        already_filled_uniqs.append(already_filled_uniqs_nside)
+    already_filled_uniqs = np.concatenate(already_filled_uniqs)
+    already_filled_indeces = np.array(
+        [np.where(uniqs == uni)[0][0] for uni in already_filled_uniqs]
+    )
+    return already_filled_indeces
+
+
+def clean_data_multiorder_map(
+    grid_value: np.ndarray, uniqs: np.ndarray
+):
+    """
+    Clean a map from the pixels which have a finer scan inside
+
+    args:
+        - grid_value: np.ndarray. Value of probability (likelihood)
+            per each scanned pixel.
+        - uniqs: np.ndarray. Uniqs per each scanned pixel to univocally
+            identify them
+
+    returns:
+        - grid_value: np.ndarray. Cleaned array
+        - uniqs: np.ndarray. Cleaned array
+    """
+    filled_indeces = find_filled_pixels(uniqs)
+    grid_value = np.delete(grid_value, filled_indeces)
+    uniqs = np.delete(uniqs, filled_indeces)
+    return grid_value, uniqs
+
+
+def prepare_flattened_map(
+    equatorial_map: np.ndarray,
+    llh_map: bool,
+) -> Tuple[np.ndarray, List[str]]:
+    """
+    Create the healpix map that needs to be saved keeping
+    into account if it is a probability or a llh map
+    """
+    if llh_map:
+        column_names = ['2DLLH']
+    else:
+        # avoid excessively heavy data format for the flattened map
+        equatorial_map[equatorial_map < 1e-16] = np.nanmean(
+            equatorial_map[equatorial_map < 1e-16]
+        )
+        column_names = ["PROBABILITY"]
+    return equatorial_map, column_names
+
+
+def prepare_multiorder_map(
+    grid_value: np.ndarray,
+    uniq_array: np.ndarray,
+    llh_map: bool,
+    column_names: List[str]
+) -> Tuple[mhealpy.HealpixMap, List[str]]:
+    """
+    Create the mhealpix map that needs to be saved keeping
+    into account if it is a probability or a llh map
+    """
+    # clean from redundant pixels
+    grid_value, uniq_array = clean_data_multiorder_map(
+        grid_value, uniq_array
+    )
+    # save multiorder version of the map
+    if llh_map:
+        multiorder_map = mhealpy.HealpixMap(grid_value, uniq_array)
+    else:
+        all_nsides = mhealpy.uniq2nside(uniq_array)
+        max_nside = np.max(all_nsides)
+        multiorder_map = mhealpy.HealpixMap(
+            grid_value / healpy.nside2pixarea(
+                max_nside, degrees=True,
+            ), uniq_array
+        )
+        column_names = [f"{column_names[0]} DENSITY [deg-2]"]
+    return multiorder_map, column_names

icecube-skyreader-1.3.0/skyreader/utils/handle_map_data.py

@@ -1,202 +0,0 @@
-from typing import Union
-import logging
-
-import healpy  # type: ignore[import]
-import numpy as np
-
-from ..result import SkyScanResult
-
-LOGGER = logging.getLogger("skyreader.extract_map")
-
-
-def extract_map(
-        result: SkyScanResult,
-        llh_map: bool = True,
-        angular_error_floor: Union[None, float] = None,
-        remove_min_val: bool = True,
-):
-    """
-    Extract from the output of skymap_scanner the healpy map
-    args:
-        - result: SkyScanResult. The output of the Skymap Scanner
-        - llh_map: bool = True. If True the likelihood will be plotted,
-            otherwise the probability
-        - angular_error_floor: Union[None, float] = None. if not None,
-            sigma of the gaussian to convolute the map with in deg.
-        - remove_min_val: bool = True. Remove minimum value from -llh
-          no effect if probability map.
-
-    returns:
-        - grid_value: value-per-scanned-pixel (pixels with
-            different nsides)
-        - grid_ra: right ascension for each pixel in grid_value
-        - grid_dec: declination for each pixel in grid_value
-        - equatorial_map: healpix map with maximum nside (all pixels
-            with same nside)
-    """
-
-    grid_map = dict()
-
-    nsides = result.nsides
-    max_nside = max(nsides)
-    equatorial_map = np.full(healpy.nside2npix(max_nside), np.nan)
-
-    for nside in nsides:
-        LOGGER.info(f"constructing map for nside {nside}...")
-        npix = healpy.nside2npix(nside)
-        map_data = result.result[f'nside-{nside}']
-        pixels = map_data['index']
-        values = map_data['llh']
-        this_map = np.full(npix, np.nan)
-        this_map[pixels] = values
-        if nside < max_nside:
-            this_map = healpy.ud_grade(this_map, max_nside)
-        mask = np.logical_and(~np.isnan(this_map), np.isfinite(this_map))
-        equatorial_map[mask] = this_map[mask]
-
-        for pixel_data in result.result[f"nside-{nside}"]:
-            pixel = pixel_data['index']
-            value = pixel_data['llh']
-            if np.isfinite(value) and not np.isnan(value):
-                tmp_theta, tmp_phi = healpy.pix2ang(nside, pixel)
-                tmp_dec = np.pi/2 - tmp_theta
-                tmp_ra = tmp_phi
-                grid_map[(tmp_dec, tmp_ra)] = value
-                # nested_pixel = healpy.ang2pix(
-                #     nside, tmp_theta, tmp_phi, nest=True
-                # )
-                # uniq = 4*nside*nside + nested_pixel
-                # uniq_list.append(uniq)
-        LOGGER.info(f"done with map for nside {nside}...")
-
-    grid_dec_list, grid_ra_list, grid_value_list = [], [], []
-
-    for (dec, ra), value in grid_map.items():
-        grid_dec_list.append(dec)
-        grid_ra_list.append(ra)
-        grid_value_list.append(value)
-    grid_dec: np.ndarray = np.asarray(grid_dec_list)
-    grid_ra: np.ndarray = np.asarray(grid_ra_list)
-    grid_value: np.ndarray = np.asarray(grid_value_list)
-    # uniq_array: np.ndarray = np.asarray(uniq_list)
-
-    sorting_indices = np.argsort(grid_value)
-    grid_value = grid_value[sorting_indices]
-    grid_dec = grid_dec[sorting_indices]
-    grid_ra = grid_ra[sorting_indices]
-    # uniq_array = uniq_array[sorting_indices]
-
-    min_value = grid_value[0]
-
-    if remove_min_val or (not llh_map):
-        # renormalize
-        grid_value = grid_value - min_value
-        min_value = 0.
-
-        # renormalize
-        equatorial_map[np.isinf(equatorial_map)] = np.nan
-        equatorial_map -= np.nanmin(equatorial_map)
-
-    if llh_map:
-        # show 2 * delta_LLH
-        grid_value = grid_value * 2.
-        equatorial_map *= 2.
-    else:
-        # Convert to probability
-        equatorial_map = np.exp(-1. * equatorial_map)
-        equatorial_map = equatorial_map / np.nansum(equatorial_map)
-
-        # nan values are a problem for the convolution and the contours
-        min_map = np.nanmin(equatorial_map)
-        equatorial_map[np.isnan(equatorial_map)] = min_map
-
-        if angular_error_floor is not None:
-            # convolute with a gaussian. angular_error_floor is the
-            # sigma in deg.
-            equatorial_map = healpy.smoothing(
-                equatorial_map,
-                sigma=np.deg2rad(angular_error_floor),
-            )
-
-            # normalize map
-            min_map = np.nanmin(equatorial_map[equatorial_map > 0.0])
-            equatorial_map[np.isnan(equatorial_map)] = min_map
-            equatorial_map = equatorial_map.clip(min_map, None)
-            normalization = np.nansum(equatorial_map)
-            equatorial_map = equatorial_map / normalization
-
-        # obtain values for grid map
-        grid_value = healpy.get_interp_val(
-            equatorial_map, np.pi/2 - grid_dec, grid_ra
-        )
-        grid_value[np.isnan(grid_value)] = min_map
-        grid_value = grid_value.clip(min_map, None)
-
-    return grid_value, grid_ra, grid_dec, equatorial_map
-
-
-def get_contour_levels(
-        equatorial_map: np.ndarray,
-        llh_map: bool = True,
-        systematics: bool = False,
-):
-    """
-    get contour levels for the desired map
-
-    args:
-        - equatorial_map: np.ndarray. Necessary in case of
-            probability map.
-        - llh_map: bool. If True llh levels, otherwise probability
-            levels.
-        - systematics: bool. Only for llh maps. If True include
-            recalibrated llh values from Pan-Starrs event 127852
-            (IC160427A syst.)
-
-    returns:
-        - contour_levels, levels of the contours
-        - contour_labels, respective labels for the contours
-        - contour_colors, respective colors for the contours
-    """
-
-    # Calculate the contour levels
-    if llh_map:  # likelihood map
-        min_value = np.min(equatorial_map)
-        if systematics:
-            # from Pan-Starrs event 127852
-            # these are values determined from MC by Will on the TS (2*LLH)
-            # Not clear yet how to translate this for the probability map
-            contour_levels = (np.array([22.2, 64.2])+min_value)
-            contour_labels = [
-                r'50% (IC160427A syst.)', r'90% (IC160427A syst.)'
-            ]
-            contour_colors = ['k', 'r']
-        # Wilks
-        else:
-            contour_levels = (
-                np.array([1.39, 4.61, 11.83, 28.74])+min_value
-            )[:3]
-            contour_labels = [
-                r'50%', r'90%', r'3$\sigma$', r'5$\sigma$'
-            ][:3]
-            contour_colors = ['k', 'r', 'g', 'b'][:3]
-    else:  # probability map
-        if systematics:
-            raise AssertionError(
-                "No corrected values for contours in probability maps"
-            )
-        else:
-            sorted_values = np.sort(equatorial_map)[::-1]
-            probability_levels = (
-                np.array([0.5, 0.9, 1-1.35e-3, 1-2.87e-7])
-            )[:3]
-            contour_levels = list()
-            for prob in probability_levels:
-                level_index = (
-                    np.nancumsum(sorted_values) >= prob
-                ).tolist().index(True)
-                level = sorted_values[level_index]
-                contour_levels.append(level)
-            contour_labels = [r'50%', r'90%', r'3$\sigma$', r'5$\sigma$'][:3]
-            contour_colors = ['k', 'r', 'g', 'b'][:3]
-
-    return contour_levels, contour_labels, contour_colors