rubin-sim 2.6.1.dev2__py3-none-any.whl

rubin_sim/maf/maps/create_gaia_density_map.py

@@ -0,0 +1,158 @@
+import glob
+import sys
+
+# from rubin_sim.utils import ObservationMetaData
+import healpy as hp
+import numpy as np
+
+# Modifying createStarDensityMap to use GAIA DR1 catalog
+
+# Use the catsim framework to loop over a healpy map and generate a
+# stellar density map
+
+# Connect to fatboy with: ssh -L 51433:fatboy.phys.washington.edu:1433
+# gateway.astro.washington.edu
+# If non-astro user, use simsuser@gateway.astro.washington.edu
+
+# NOTE: fatboy is no longer operative
+
+if __name__ == "__main__":
+    # Hide imports here so documentation builds
+    from lsst.sims.catalogs.db import DBObject
+    from lsst.sims.utils import angular_separation, halfSpaceFromRaDec
+
+    # from lsst.sims.catalogs.generation.db import CatalogDBObject
+    # Import the bits needed to get the catalog to work
+    # from rubin_sim.catUtils.baseCatalogModels import *
+    # from rubin_sim.catUtils.exampleCatalogDefinitions import *
+    # connect to fatboy
+    gaia_db = DBObject(
+        database="LSSTCATSIM",
+        host="fatboy.phys.washington.edu",
+        port=1433,
+        driver="mssql+pymssql",
+    )
+
+    # get all of the column names for the gaia table in a list
+    gaia_columns = gaia_db.get_column_names(tableName="gaia_2016")
+
+    # Set up healpy map and ra, dec centers
+    nside = 64
+
+    # Set the min to 15 since we saturate there. CatSim max is 28
+    mag_max = 15.2
+    bins = np.arange(0.0, mag_max, 0.2)
+    star_density = np.zeros((hp.nside2npix(nside), np.size(bins) - 1), dtype=float)
+    over_max_mask = np.zeros(hp.nside2npix(nside), dtype=bool)
+    lat, ra = hp.pix2ang(nside, np.arange(0, hp.nside2npix(nside)))
+    dec = np.pi / 2.0 - lat
+    ra = np.degrees(ra)
+    dec = np.degrees(dec)
+
+    # Square root of pixel area.
+    hpsize_deg = hp.nside2resol(nside, arcmin=True) / 60.0
+
+    # Limit things to a 10 arcmin radius
+    hpsize_deg = np.min([10.0 / 60.0, hpsize_deg])
+
+    indx_min = 0
+
+    restore_file = glob.glob("gaiaStarDensity_nside_%i.npz" % (nside))
+    if len(restore_file) > 0:
+        data = np.load(restore_file[0])
+        star_density = data["star_density"].copy()
+        indx_min = data["icheck"].copy()
+        over_max_mask = data["over_max_mask"].copy()
+
+    print("")
+    # Look at a circular area the same area as the healpix it's centered on.
+    bound_length = hpsize_deg / np.pi**0.5
+    radius = bound_length
+
+    block_area = hpsize_deg**2  # sq deg
+
+    checksize = 1000
+    printsize = 10
+    npix = float(hp.nside2npix(nside))
+
+    # If the area has more than this number of objects, flag it as a max
+    break_limit = 1e6
+    chunk_size = 10000
+    for i in np.arange(indx_min, int(npix)):
+        last_cp = ""
+        # wonder what the units of bound_length are...degrees!
+        # And it's a radius
+        # The newer interface:
+        # obs_metadata = ObservationMetaData(bound_type='circle',
+        ##                                   pointing_ra=np.degrees(ra[i]),
+        #                                   pointing_dec=np.degrees(dec[i]),
+        #                                   bound_length=bound_length,
+        #                                   mjd=5700)
+
+        # t = dbobj.getCatalog('ref_catalog_star', obs_metadata=obs_metadata)
+        hs = halfSpaceFromRaDec(ra[i], dec[i], radius)
+        current_level = 7
+        n_bits_off = 2 * (21 - current_level)
+
+        tx_list = hs.findAllTrixels(current_level)
+
+        # actually construct the query
+        query = "SELECT ra, dec, phot_g_mean_mag "
+        query += "FROM gaia_2016 "
+        query += "WHERE "
+        for i_pair, pair in enumerate(tx_list):
+            min_tx = int(pair[0] << n_bits_off)
+            max_tx = int((pair[1] + 1) << n_bits_off)
+            query += "(htmid>=%d AND htmid<=%d)" % (min_tx, max_tx)
+            if i_pair < len(tx_list) - 1:
+                query += " OR "
+
+        dtype = np.dtype([("ra", float), ("dec", float), ("mag", float)])
+
+        results = gaia_db.get_arbitrary_chunk_iterator(query, dtype=dtype, chunk_size=10000)
+        result = list(results)[0]
+
+        distances = angular_separation(result["ra"], result["dec"], ra[i], dec[i])
+        result = result[np.where(distances < radius)]
+
+        # I could think of setting the chunksize to something really large,
+        # then only doing one chunk?
+        # Or maybe setting up a way to break out of the loop if
+        # everything gets really dense?
+        temp_hist = np.zeros(np.size(bins) - 1, dtype=float)
+        counter = 0
+        col_name = "phot_g_mean_mag"
+        for chunk in results:
+            chunk_hist, bins = np.histogram(chunk[col_name], bins)
+            temp_hist += chunk_hist
+            counter += chunk_size
+            if counter >= break_limit:
+                over_max_mask[i] = True
+                break
+
+        star_density[i] = np.add.accumulate(temp_hist) / block_area
+
+        # Checkpoint
+        if (i % checksize == 0) & (i != 0):
+            np.savez(
+                "gaiaStarDensity_nside_%i.npz" % (nside),
+                starDensity=star_density,
+                bins=bins,
+                icheck=i,
+                overMaxMask=over_max_mask,
+            )
+            last_cp = "Checkpointed at i=%i of %i" % (i, npix)
+        if i % printsize == 0:
+            sys.stdout.write("\r")
+            per_complete = float(i) / npix * 100
+            sys.stdout.write(r"%.2f%% complete. " % (per_complete) + last_cp)
+            sys.stdout.flush()
+
+    np.savez(
+        "gaiaStarDensity_nside_%i.npz" % (nside),
+        starDensity=star_density,
+        bins=bins,
+        overMaxMask=over_max_mask,
+    )
+    print("")
+    print("Completed!")

rubin_sim/maf/maps/dust_map.py

@@ -0,0 +1,66 @@
+__all__ = ("DustMap",)
+
+import warnings
+
+from rubin_sim.maf.maps import BaseMap
+
+from .ebv_hp import eb_vhp
+
+
+class DustMap(BaseMap):
+    """Add the E(B-V) values to the slice points.
+
+    Primarily, this calls eb_vhp to read a healpix map of E(B-V) values over
+    the sky, then assigns ebv values to each slice_point.
+    If the slicer is a healpix slicer, this is trivial.
+    Otherwise, it either uses the nearest healpix grid point or interpolates.
+
+    The key added to the slice points is `ebv`.
+
+    Parameters
+    ----------
+    interp : `bool`, opt
+        Interpolate the dust map at each slice_point (True)
+        or just use the nearest value (False).
+        Default is False.
+    nside : `int`, opt
+        Default nside value to read the dust map from disk.
+        Primarily useful if the slicer is not a healpix slicer.
+        Default 128.
+    map_path : `str`, opt
+        Define a path to the directory holding the dust map files.
+        Default None, which uses RUBIN_SIM_DATA_DIR.
+    """
+
+    def __init__(self, interp=False, nside=128, map_path=None):
+        self.keynames = ["ebv"]
+        self.interp = interp
+        self.nside = nside
+        self.map_path = map_path
+
+    def run(self, slice_points):
+        # If the slicer has nside,
+        # it's a healpix slicer so we can read the map directly
+        if "nside" in slice_points:
+            if slice_points["nside"] != self.nside:
+                warnings.warn(
+                    f"Slicer value of nside {slice_points['nside']} different "
+                    f"from map value {self.nside}, using slicer value"
+                )
+            slice_points["ebv"] = eb_vhp(
+                slice_points["nside"],
+                pixels=slice_points["sid"],
+                map_path=self.map_path,
+            )
+        # Not a healpix slicer,
+        # look up values based on RA,dec with possible interpolation
+        else:
+            slice_points["ebv"] = eb_vhp(
+                self.nside,
+                ra=slice_points["ra"],
+                dec=slice_points["dec"],
+                interp=self.interp,
+                map_path=self.map_path,
+            )
+
+        return slice_points

rubin_sim/maf/maps/dust_map_3d.py

@@ -0,0 +1,190 @@
+__all__ = ("DustMap3D",)
+
+import warnings
+
+import numpy as np
+
+from rubin_sim.maf.maps import BaseMap
+from rubin_sim.phot_utils import DustValues
+
+from .ebv_3d_hp import ebv_3d_hp, get_x_at_nearest_y
+
+
+class DustMap3D(BaseMap):
+    """Add 3-d E(B-V) values to the slice points.
+
+    See "notes" below for a discussion of the content of the map keys,
+    and functionality that can be accessed by calling
+    `DustMap3d.distance_at_mag` with the key values at a given slice point.
+
+    Parameters
+    ----------
+    nside : `int`
+        Healpixel resolution (2^x) to read from disk.
+    map_file : `str`, opt
+        Path to dust map file.
+    interp : `bool`, opt
+        Should returned values be interpolated (True)
+        or just nearest neighbor (False).
+        Default True, but is ignored if 'pixels' is provided.
+    filtername : 'str', opt
+        Name of the filter (to match the lsst filter names in
+        rubin_sim.photUtils.DustValues) in which to calculate dust
+        extinction magnitudes
+    dist_pc : `float`, opt
+        Distance at which to precalculate the nearest ebv value (pc)
+    d_mag : `float`, opt
+        Calculate the maximum distance which matches this `d_mag`
+        d_mag == m-mO (dust extinction + distance modulus)
+    r_x : `dict` {`str`: `float`}, opt
+        Per-filter dust extinction curve coefficients.
+        Calculated by rubin_sim.photUtils.DustValues if "None".
+
+    Notes
+    -----
+    The slice point dictionary keys are expanded with the following keys:
+    ebv3d_dists -
+    the distances from the 3d dust map at each slice_point (in pc)
+    `ebv3d_ebvs` -
+    the E(B-V) values corresponding to each distance at each slice_point
+    `ebv3d_ebv_at_<dist_pc>` -
+    the (single) ebv value at the nearest distance to dist_pc
+    `ebv3d_dist_at_<d_mag>` -
+    the (single) distance value corresponding to where extinction and
+    distance modulus combine to create a m-Mo value of d_mag, for the filter
+    specified in filtername (in pc).
+    Note that <dist_pc> and <d_mag> will be formatted with a
+    single decimal place.
+
+    The additional method 'distance_at_mag' can be called either with the
+    distances and ebv values for the entire map or with the values from a
+    single slice_point, in order to calculate the distance at which
+    extinction and distance modulus combine to create a m-Mo value closest
+    to 'dmag' in any filter. This is the same value as would be reported in
+    ebv3d_dist_at_<d_mag>, but can be calculated on the fly,
+    allowing variable filters and dmag values.
+    """
+
+    def __init__(
+        self,
+        nside=64,
+        map_file=None,
+        interp=True,
+        filtername="r",
+        dist_pc=3000,
+        d_mag=15.2,
+        r_x=None,
+    ):
+        self.nside = nside
+        self.interp = interp
+        self.map_file = map_file
+        self.filtername = filtername
+        self.dist_pc = dist_pc
+        self.d_mag = d_mag
+        # r_x is the extinction coefficient (A_v = R_v * E(B-V) ..
+        # A_x = r_x * E(B-V)) per filter
+        # This is equivalent to calculating A_x
+        # (using rubin_sim.photUtils.Sed.addDust) in each
+        # filter and setting E(B-V) to 1 [so similar to the values
+        # calculated in DustValues.
+        if r_x is None:
+            self.r_x = DustValues().r_x.copy()
+        else:
+            self.r_x = r_x
+        # The values that will be added to the slicepoints
+        self.keynames = [
+            "ebv3d_ebvs",
+            "ebv3d_dists",
+            f"ebv3d_ebv_at_{self.dist_pc:.1f}",
+            f"ebv3d_dist_at_{self.d_mag:.1f}",
+        ]
+
+    def run(self, slice_points):
+        # If the slicer has nside,
+        # it's a healpix slicer so we can read the map directly
+        if "nside" in slice_points:
+            if slice_points["nside"] != self.nside:
+                warnings.warn(
+                    f"Slicer value of nside {slice_points['nside']} different "
+                    f"from map value {self.nside}, will use correct slicer value here."
+                )
+            dists, ebvs = ebv_3d_hp(
+                slice_points["nside"],
+                pixels=slice_points["sid"],
+                map_file=self.map_file,
+            )
+        # Not a healpix slicer,
+        # look up values based on RA,dec with possible interpolation
+        else:
+            dists, ebvs = ebv_3d_hp(
+                self.nside,
+                ra=slice_points["ra"],
+                dec=slice_points["dec"],
+                interp=self.interp,
+                map_file=self.map_file,
+            )
+
+        # Calculate the map ebv and dist values at the initialized distance
+        dist_closest, ebv_at_dist = get_x_at_nearest_y(dists, ebvs, self.dist_pc)
+
+        # Calculate the distances at which m_minus_Mo values
+        # of 'dmag' are reached
+        dist_dmag = self.distance_at_dmag(self.d_mag, dists, ebvs, self.filtername)
+
+        slice_points["ebv3d_dists"] = dists
+        slice_points["ebv3d_ebvs"] = ebvs
+        slice_points[f"ebv3d_ebv_at_{self.dist_pc:.1f}"] = ebv_at_dist
+        slice_points[f"ebv3d_dist_at_{self.d_mag:.1f}"] = dist_dmag
+
+        return slice_points
+
+    def distance_at_dmag(self, dmag, dists, ebvs, filtername=None):
+        """Calculate the distance at which a given change of magnitude would
+        occur (including distance modulus and dust extinction).
+
+        Parameters
+        ----------
+        dmag : `float`
+            The magnitude change expected.
+        dists : `np.ndarray`, (N,)
+            The distances corresponding to the ebv values.
+        ebvs : `np.ndarray`, (N,)
+            The ebv values at each distance.
+        filtername : `str` or None
+            The filter in which to evaluate the magnitude change.
+            If None, uses the default filter for the map.
+            The filter translates ebv into magnitudes of extinction.
+
+        Returns
+        -------
+        dist_dmag : `float`
+            The distance at which the specified dmag occurs.
+        """
+        # Provide this as a method which could be used for a single
+        # slice_point as well as for whole map
+        # (single slice_point means you could calculate this for any
+        # arbitrary magnitude or filter if needed)
+        # This method is here because some metrics require it.
+        if filtername is None:
+            filtername = self.filtername
+        # calculate distance modulus for each distance
+        dmods = 5.0 * np.log10(dists) - 5.0
+        # calculate dust extinction at each distance, for the filtername
+        a_x = self.r_x[filtername] * ebvs
+        # calculate the (m-Mo) = distmod + a_x -- combination of extinction
+        # due to distance and dust
+        m_minus__mo = dmods + a_x
+
+        # Maximum distance for the given m-Mo (dmag) value
+        # first do the 'within the map' closest distance
+        m_minus__mo_at_mag, dist_closest = get_x_at_nearest_y(m_minus__mo, dists, dmag)
+        # calculate distance modulus for an object with the maximum dust
+        # extinction (and then the distance)
+        if a_x.ndim == 2:
+            dist_mods_far = dmag - a_x[:, -1]
+        else:
+            dist_mods_far = dmag - a_x.max()
+        dists_far = 10.0 ** (0.2 * dist_mods_far + 1.0)
+        # Use furthest of the two
+        dist_dmag = np.where(dists_far > dist_closest, dists_far, dist_closest)
+        return dist_dmag

rubin_sim/maf/maps/ebv_3d_hp.py

@@ -0,0 +1,170 @@
+__all__ = ("ebv_3d_hp", "get_x_at_nearest_y")
+
+import os
+import warnings
+
+import healpy as hp
+import numpy as np
+from astropy.io import fits
+from rubin_scheduler.data import get_data_dir
+
+from rubin_sim.maf.utils import radec2pix
+
+
+def ebv_3d_hp(
+    nside,
+    map_file=None,
+    ra=None,
+    dec=None,
+    pixels=None,
+    interp=False,
+):
+    """Reads and saves a 3d dust extinction file from disk, return extinction
+    at  specified points (ra/dec/ or pixels).
+
+    Parameters
+    ----------
+    nside : `int`
+        Healpixel resolution (2^x).
+    map_file : `str`, opt
+        Path to dust map file.
+    ra : `np.ndarray` or `float`, opt
+        RA (can take numpy array).
+        Default None sets up healpix array of nside. Radians.
+    dec : `np.ndarray` or `float`, opt
+        Dec (can take numpy array).
+        Default None set up healpix array of nside. Radians.
+    pixels : `np.ndarray`, opt
+        Healpixel IDs, to sub-select particular healpix points.
+        Default uses all points.
+        Easiest way to access healpix values.
+        Note that the pixels in the healpix array MUST come from a h
+        ealpix grid with the same nside as the ebv_3d_hp map.
+        Using different nsides can potentially fail silently.
+    interp : `bool`, opt
+        Should returned values be interpolated (True)
+        or just nearest neighbor (False).
+        Default False.
+    """
+    if (ra is None) & (dec is None) & (pixels is None):
+        raise RuntimeError("Need to set ra,dec or pixels.")
+
+    # Set up path to map data
+    if map_file is None:
+        if nside == 64:
+            map_name = "merged_ebv3d_nside64_defaults.fits"
+            map_file = os.path.join(get_data_dir(), "maps/DustMaps3D", map_name)
+        elif nside == 128:
+            map_name = "merged_ebv3d_nside128_defaults.fits"
+            map_file = os.path.join(get_data_dir(), "maps/DustMaps3D", map_name)
+        else:
+            raise Exception(
+                f"map_file not specified, and nside {nside} not one of 64 or 128. "
+                "Please specify a known map_file, as a basis for interpolation."
+            )
+    else:
+        # Check if user specified map name but not full map path
+        if not os.path.isfile(map_file):
+            test_path = os.path.join(get_data_dir(), "maps/DustMaps3D", map_file)
+            if os.path.isfile(test_path):
+                map_file = test_path
+    # Keep track of what nside and what map_file we're using
+    if not hasattr(ebv_3d_hp, "map_file"):
+        ebv_3d_hp.mapFile = map_file
+        ebv_3d_hp.nside = nside
+
+    # Do we need to re-read from disk?
+    if (not hasattr(ebv_3d_hp, "ebvs")) | (not hasattr(ebv_3d_hp, "dists")) | (map_file != ebv_3d_hp.mapFile):
+        ebv_3d_hp.mapFile = map_file
+        ebv_3d_hp.nside = nside
+        # Read map from disk
+        hdul = fits.open(map_file)
+        # hpids = hdul[0].data
+        dists = hdul[1].data
+        ebvs = hdul[2].data
+        hdr = hdul[0].header
+        # Close map file
+        hdul.close()
+
+        # Check additional healpix information from the header
+        map_nside = hdr["NSIDE"]
+        nested = hdr["NESTED"]
+        if nside != map_nside:
+            warnings.warn(
+                f"Map nside {map_nside} did not match expected nside {nside}; "
+                f"Will use nside from map data."
+            )
+            if pixels is not None:
+                # We're just going to raise an exception here
+                # because this could mean bad things.
+                raise ValueError(
+                    f"Map nside {map_nside} did not match expected nside {nside}, "
+                    f"and pixels provided; this can potentially indicate a serious "
+                    f"error. Make nsides match or specify ra/dec instead of pixels."
+                )
+            nside = map_nside
+        # Nested healpix data will not match the healpix arrays
+        # for the slicers (at this time)
+        if nested:
+            warnings.warn("Map has nested (not ring order) data; will reorder.")
+            for i in np.arange(0, len(dists[0])):
+                dists[:, i] = hp.reorder(dists[:, i], "nest", "ring")
+                ebvs[:, i] = hp.reorder(ebvs[:, i], "nest", "ring")
+        ebv_3d_hp.dists = dists
+        ebv_3d_hp.ebvs = ebvs
+        print(f"Read map {map_file} from disk")
+
+    if pixels is not None:
+        # Assume if pixels is set, then interp is irrelevant
+        dists = ebv_3d_hp.dists[pixels]
+        ebvs = ebv_3d_hp.ebvs[pixels]
+    # BUT, if we were provided ra/dec then have to see if we should interpolate
+    else:
+        if interp:  # find interpolated values at given ra/dec
+            distlen = len(ebv_3d_hp.dists[0])
+            dists = np.zeros([len(ra), distlen], float)
+            ebvs = np.zeros([len(ra), distlen], float)
+            for i in np.arange(0, distlen):
+                dists[:, i] = hp.get_interp_val(ebv_3d_hp.dists[:, i], np.pi / 2.0 - dec, ra)
+                ebvs[:, i] = hp.get_interp_val(ebv_3d_hp.ebvs[:, i], np.pi / 2.0 - dec, ra)
+        else:  # just fine nearest neighbor pixel value and return those
+            pixels = radec2pix(nside, ra, dec)
+            dists = ebv_3d_hp.dists[pixels]
+            ebvs = ebv_3d_hp.ebvs[pixels]
+
+    return dists, ebvs
+
+
+def get_x_at_nearest_y(x, y, x_goal):
+    """Given a goal x value, find y values at the closest x value.
+
+    This could be used to fetch the nearest ebv value at a given distance,
+    or the nearest distance to a given m-Mo value, for example.
+
+    Parameters
+    ----------
+    x : `np.array`
+        Can be either a map with x at each point in the map (2d array) or
+        the x at a single point of the map (1d array)
+    y : `np.array`
+        Can be either a map with y at each point in the map (2d array) or
+        the y at a single point of the map (1d array) -
+        but should match x dimensionality
+    x_goal : `float'
+        The goal x value to look for the nearest y value
+
+    Returns
+    -------
+    x_closest, y_closest : `np.array`, `np.array`
+        1-d array of x and y (single value or over map).
+    """
+    if x.ndim == 2:
+        idx_min = np.argmin(np.abs(x - x_goal), axis=1)
+        i_expand = np.expand_dims(idx_min, axis=-1)
+        x_closest = np.take_along_axis(x, i_expand, axis=-1).squeeze()
+        y_closest = np.take_along_axis(y, i_expand, axis=-1).squeeze()
+    else:
+        idx_min = np.argmin(np.abs(x - x_goal))
+        x_closest = x[idx_min]
+        y_closest = y[idx_min]
+    return x_closest, y_closest

rubin_sim/maf/maps/ebv_hp.py

@@ -0,0 +1,64 @@
+__all__ = ("eb_vhp",)
+
+import os
+
+import healpy as hp
+import numpy as np
+from rubin_scheduler.data import get_data_dir
+
+from rubin_sim.maf.utils import radec2pix
+
+
+def eb_vhp(nside, ra=None, dec=None, pixels=None, interp=False, map_path=None):
+    """Read in a healpix dust map and return values for given RA, Dec values.
+
+    This is primarily a tool for the rubin_sim.maf.DustMap class.
+
+    nside : `int`
+        Healpixel resolution (2^x).
+    ra : `np.ndarray` or `float`, opt
+        RA (can take numpy array).
+        Default None sets up healpix array of nside. Radians.
+    dec : `np.ndarray` or `float`, opt
+        Dec (can take numpy array).
+        Default None set up healpix array of nside. Radians.
+    pixels : `np.ndarray`, opt
+        Healpixel IDs, to sub-select particular healpix points.
+        Default uses all points.
+        NOTE - to use a healpix map, set pixels and not ra/dec.
+    interp : `bool`, opt
+        Should returned values be interpolated (True)
+        or just nearest neighbor (False)
+    map_path : `str`, opt
+        Path to directory containing dust map files.
+    """
+
+    if (ra is None) & (dec is None) & (pixels is None):
+        raise RuntimeError("Need to set ra,dec or pixels.")
+
+    # Load the map
+    if map_path is not None:
+        ebv_data_dir = map_path
+    else:
+        ebv_data_dir = os.path.join(get_data_dir(), "maps", "DustMaps")
+    if not hasattr(eb_vhp, "nside"):
+        eb_vhp.nside = nside
+
+    if (not hasattr(eb_vhp, "dustmap")) | (eb_vhp.nside != nside):
+        eb_vhp.nside = nside
+        filename = "dust_nside_%i.npz" % eb_vhp.nside
+        eb_vhp.dustMap = np.load(os.path.join(ebv_data_dir, filename))["ebvMap"]
+
+    # If we are interpolating to arbitrary positions
+    if interp:
+        result = hp.get_interp_val(eb_vhp.dustMap, np.pi / 2.0 - dec, ra)
+    else:
+        # If we know the pixel indices we want
+        if pixels is not None:
+            result = eb_vhp.dustMap[pixels]
+        # Look up
+        else:
+            pixels = radec2pix(eb_vhp.nside, ra, dec)
+            result = eb_vhp.dustMap[pixels]
+
+    return result

rubin_sim/maf/maps/gal_coords_map.py

@@ -0,0 +1,22 @@
+__all__ = ("GalCoordsMap",)
+
+from astropy import units as u
+from astropy.coordinates import SkyCoord
+
+from rubin_sim.maf.maps import BaseMap
+
+
+class GalCoordsMap(BaseMap):
+    """Add `gall` and `galb` (in radians) to the slice point dictionaries."""
+
+    def __init__(self):
+        self.keynames = ["gall", "galb"]
+
+    def run(self, slice_points):
+        coords = SkyCoord(ra=slice_points["ra"] * u.rad, dec=slice_points["dec"] * u.rad)
+        gal = coords.galactic
+        gall = gal.l.rad
+        galb = gal.b.rad
+        slice_points["gall"] = gall
+        slice_points["galb"] = galb
+        return slice_points