mwdust 1.6__cp314-cp314-win_amd64.whl

mwdust/Green19.py

@@ -0,0 +1,84 @@
+###############################################################################
+#
+#   Green17: extinction model from Green et al. (2019)
+#
+###############################################################################
+import os, os.path
+import numpy
+import h5py
+from mwdust.util.download import dust_dir, downloader
+from mwdust.HierarchicalHealpixMap import HierarchicalHealpixMap
+_DEGTORAD= numpy.pi/180.
+_greendir= os.path.join(dust_dir, 'green19')
+class Green19(HierarchicalHealpixMap):
+    """extinction model from Green et al. (2019)"""
+    def __init__(self,filter=None,sf10=True,load_samples=False,
+                 interpk=1):
+        """
+        NAME:
+           __init__
+        PURPOSE:
+           Initialize the Green et al. (2019) dust map
+	   The reddening vector is not the one used in Green et al. (2015)
+	   But instead: Schlafly et al. (2016)
+        INPUT:
+           filter= filter to return the extinction in
+           sf10= (True) if True, use the Schlafly & Finkbeiner calibrations
+           load_samples= (False) if True, also load the samples
+           interpk= (1) interpolation order
+        OUTPUT:
+           object
+        HISTORY:
+           2019-10-09 - Adopted - Rybizki (MPIA)
+        """
+        HierarchicalHealpixMap.__init__(self,filter=filter,sf10=sf10)
+        #Read the map
+        with h5py.File(os.path.join(_greendir,'bayestar2019.h5'),'r') \
+                as greendata:
+            self._pix_info= greendata['/pixel_info'][:]
+            if load_samples:
+                self._samples= greendata['/samples'][:]
+            self._best_fit= greendata['/best_fit'][:]
+        # Utilities
+        self._distmods= numpy.linspace(4,18.875,120)
+        self._minnside= numpy.amin(self._pix_info['nside'])
+        self._maxnside= numpy.amax(self._pix_info['nside'])
+        nlevels= int(numpy.log2(self._maxnside//self._minnside))+1
+        self._nsides= [self._maxnside//2**ii for ii in range(nlevels)]
+        self._indexArray= numpy.arange(len(self._pix_info['healpix_index']))
+        # For the interpolation
+        self._intps= numpy.zeros(len(self._pix_info['healpix_index']),
+                                 dtype='object') #array to cache interpolated extinctions
+        self._interpk= interpk
+        return None
+
+    def substitute_sample(self,samplenum):
+        """
+        NAME:
+           substitute_sample
+        PURPOSE:
+           substitute a sample for the best fit to get the extinction from a sample with the same tools; need to have setup the instance with load_samples=True
+        INPUT:
+           samplenum - sample's index to load
+        OUTPUT:
+           (none; just resets the instance to use the sample rather than the best fit; one cannot go back to the best fit after this))
+        HISTORY:
+           2019-10-09 - Adopted - Rybizki (MPIA)
+        """
+        # Substitute the sample
+        self._best_fit= self._samples[:,samplenum,:]
+        # Reset the cache
+        self._intps= numpy.zeros(len(self._pix_info['healpix_index']),
+                                 dtype='object') #array to cache interpolated extinctions
+        return None
+
+    @classmethod
+    def download(cls, test=False):
+        # Download Green et al. 2019 PanSTARRS data
+        green19_path = os.path.join(dust_dir, "green19", "bayestar2019.h5")
+        if not os.path.exists(green19_path):
+            if not os.path.exists(os.path.join(dust_dir, "green19")):
+                os.mkdir(os.path.join(dust_dir, "green19"))
+            _GREEN19_URL = "https://dataverse.harvard.edu/api/access/datafile/:persistentId?persistentId=doi:10.7910/DVN/2EJ9TX/1CUGA1"
+            downloader(_GREEN19_URL, green19_path, cls.__name__, test=test)
+        return None

mwdust/HierarchicalHealpixMap.py

@@ -0,0 +1,224 @@
+###############################################################################
+#
+#   HierarchicalHealpixMap: General class for extinction maps given as
+#                           a hierarchical HEALPix pixelation (e.g., Green
+#                           et al. 2015)
+#
+###############################################################################
+import numpy
+from scipy import interpolate
+from mwdust.util.healpix import ang2pix
+from mwdust.util.extCurves import aebv
+from mwdust.DustMap3D import DustMap3D
+_DEGTORAD= numpy.pi/180.
+class HierarchicalHealpixMap(DustMap3D):
+    """General class for extinction maps given as a hierarchical HEALPix 
+    pixelation (e.g., Green et al. 2015) """
+    def __init__(self,filter=None,sf10=True, **download_kwargs):
+        """
+        NAME:
+           __init__
+        PURPOSE:
+           Initialize the combined dust map
+        INPUT:
+           filter= filter to return the extinction in
+           sf10= (True) if True, use the Schlafly & Finkbeiner calibrations
+        OUTPUT:
+           object
+        HISTORY:
+           2015-07-28 - Started - Bovy (UofT)
+        """
+        super(HierarchicalHealpixMap, self).__init__(filter=filter, **download_kwargs)
+        self._sf10 = sf10
+        return None
+
+
+    def _evaluate(self, ls, bs, ds):
+        """
+        NAME:
+           _evaluate
+        PURPOSE:
+           evaluate the dust-map for array input
+        INPUT:
+           l- Galactic longitude (deg) can be array
+           b- Galactic latitude (deg) can be array
+           d- distance (kpc) can be array
+        OUTPUT:
+           extinction E(B-V)
+        HISTORY:
+           2015-03-02 - Started - Bovy (IAS)
+           2023-07-05 - Vectorized - Henry Leung (UofT)
+        """
+        ls = numpy.atleast_1d(ls)
+        bs = numpy.atleast_1d(bs)
+        ds = numpy.atleast_1d(ds)
+
+        distmod= 5.*numpy.log10(ds)+10.
+        lbIndx= self._lbIndx(ls, bs)
+        if len(ls) == 1 and len(ds) > 1:
+            lbIndx = numpy.tile(lbIndx, len(ds))
+
+        result = numpy.zeros_like(ds)
+        for counter, i, d in zip(numpy.arange(len(result)), lbIndx, distmod):
+            if self._intps[i] != 0:
+                out= self._intps[i](d)
+            else:
+                interpData=\
+                    interpolate.InterpolatedUnivariateSpline(self._distmods,
+                                                            self._best_fit[i],
+                                                            k=self._interpk)
+                out= interpData(d)
+                self._intps[i]= interpData
+            result[counter] = out
+        if self._filter is not None:
+            result =  result * aebv(self._filter,sf10=self._sf10)
+        # set nan for invalid indices
+        result[lbIndx==-1] = numpy.nan
+        return result
+
+
+    def dust_vals_disk(self,lcen,bcen,dist,radius):
+        """
+        NAME:
+           dust_vals_disk
+        PURPOSE:
+           return the distribution of extinction within a small disk as samples
+        INPUT:
+           lcen, bcen - Galactic longitude and latitude of the center of the disk (deg)
+           dist - distance in kpc
+           radius - radius of the disk (deg)
+        OUTPUT:
+           (pixarea,extinction) - arrays of pixel-area in sq rad and extinction value
+        HISTORY:
+           2015-03-06 - Written - Bovy (IAS)
+        """
+        try:
+            import healpy
+        except ImportError:
+            raise ModuleNotFoundError("This function requires healpy to be installed")
+        # Convert the disk center to a HEALPIX vector
+        vec= healpy.pixelfunc.ang2vec((90.-bcen)*_DEGTORAD,lcen*_DEGTORAD)
+        distmod= 5.*numpy.log10(dist)+10.
+        # Query the HEALPIX map for pixels that lie within the disk
+        pixarea= []
+        extinction= []
+        for nside in self._nsides:
+            # Find the pixels at this resolution that fall within the disk
+            ipixs= healpy.query_disc(nside,vec,radius*_DEGTORAD,
+                                    inclusive=False,nest=True)
+            # Get indices of all pixels within the disk at current nside level
+            nsideindx= self._pix_info['nside'] == nside
+            potenIndxs= self._indexArray[nsideindx]
+            nsidepix= self._pix_info['healpix_index'][nsideindx]
+            # Loop through the pixels in the (small) disk
+            tout= []
+            for ii,ipix in enumerate(ipixs):
+                lbIndx= potenIndxs[ipix == nsidepix]
+                if numpy.sum(lbIndx) == 0: continue
+                if self._intps[lbIndx] != 0:
+                    tout.append(self._intps[lbIndx][0](distmod))
+                else:
+                    interpData=\
+                        interpolate.InterpolatedUnivariateSpline(self._distmods,
+                                                                 self._best_fit[lbIndx],
+                                                                 k=self._interpk)
+                    tout.append(interpData(distmod))
+                    self._intps[lbIndx]= interpData
+            tarea= healpy.pixelfunc.nside2pixarea(nside)
+            tarea= [tarea for ii in range(len(tout))]
+            pixarea.extend(tarea)
+            extinction.extend(tout)
+        pixarea= numpy.array(pixarea)
+        extinction= numpy.array(extinction)
+        if not self._filter is None:
+            extinction= extinction*aebv(self._filter,sf10=self._sf10)        
+        return (pixarea,extinction)
+
+    def _lbIndx(self, ls, bs):
+        """Return the indices in the _combineddata array corresponding to arrays of (l, b)"""
+        stop_mask = numpy.zeros(len(ls), dtype=bool)  # mask to be accumulated when looping through nside
+        indx_result = numpy.ones(len(ls), dtype=int) * -1  # -1 for bad star, int array has no nan
+        for nside in self._nsides:
+            tpix = ang2pix(nside, (90.-bs)*_DEGTORAD, ls*_DEGTORAD, nest=True)
+            nside_idx = numpy.where(self._pix_info['nside'] == nside)[0]
+            healpix_index_nside = self._pix_info['healpix_index'][nside_idx]
+            sorted_order = numpy.argsort(healpix_index_nside)
+            # use searchsorted to find the index of tpix in healpix_index_nside efficiently
+            result = numpy.searchsorted(healpix_index_nside, tpix, sorter=sorted_order)
+            # need to deal with indices where they are larger than the largest healpix_index_nside
+            known_bad_idx = (result == len(nside_idx))
+            result[known_bad_idx] = 0  # wrap around
+            result = sorted_order[result]  # reverse the sorting before indexing
+            result = nside_idx[result]
+            good_result_idx = ((self._pix_info['healpix_index'][result] == tpix) & (self._pix_info['nside'][result] == nside) & (~known_bad_idx))
+            indx_result = numpy.where(~stop_mask & good_result_idx, result, indx_result)
+            indx_result = numpy.where(known_bad_idx & ~stop_mask, -1, indx_result)  # set bad star to -1
+            stop_mask = stop_mask | good_result_idx  # update mask for the next nside
+        return indx_result
+
+    def plot_mollweide(self,d,**kwargs):
+        """
+        NAME:
+           plot_mollweide
+        PURPOSE:
+           plot the extinction across the sky in Galactic coordinates  out to a given distance using a Mollweide projection
+        INPUT:
+           d - distance in kpc (nearest distance to this in the map is plotted)
+           nside_plot= (2048) nside of the plotted map
+           healpy.visufunc.mollview kwargs
+        OUTPUT:
+           plot to output device
+        HISTORY:
+           2019-12-06 - Written - Bovy (UofT)
+        """
+        try:
+            import healpy
+        except ImportError:
+            raise ModuleNotFoundError("This function requires healpy to be installed")
+        # Distance modulus
+        dm= 5.*numpy.log10(d)+10.
+        # Get factor to apply to map to obtain extinction in object's filter
+        filter_fac= aebv(self._filter,sf10=self._sf10) \
+                    if not self._filter is None else 1.
+        # Map the dust map to a common nside, first find nearest distance pixel
+        tpix= numpy.argmin(numpy.fabs(dm-self._distmods))
+        # Construct an empty map at the highest HEALPix resolution present in the map; code snippets adapted from http://argonaut.skymaps.info/usage
+        nside_max= numpy.max(self._pix_info['nside'])
+        npix= healpy.pixelfunc.nside2npix(nside_max)
+        pix_val= numpy.empty(npix,dtype='f8')
+        pix_val[:] = healpy.UNSEEN
+        # Fill the upsampled map
+        for nside in numpy.unique(self._pix_info['nside']):
+            # Get indices of all pixels at current nside level
+            indx= self._pix_info['nside'] == nside
+            # Extract A_X of each selected pixel
+            pix_val_n= filter_fac*self._best_fit[indx,tpix]
+            # Determine nested index of each selected pixel in upsampled map
+            mult_factor = (nside_max//nside)**2
+            pix_idx_n = self._pix_info['healpix_index'][indx]*mult_factor
+            # Write the selected pixels into the upsampled map
+            for offset in range(mult_factor):
+                pix_val[pix_idx_n+offset] = pix_val_n[:]
+        # If the desired nside is less than the maximum nside in the map, degrade
+        nside_plot= kwargs.get('nside_plot',2048)
+        if not nside_plot is None and nside_plot < nside_max:
+            pix_val= healpy.pixelfunc.ud_grade(pix_val,
+                                               nside_plot,pess=False,
+                                               order_in='NEST', 
+                                               order_out='NEST')
+        pix_val[pix_val == healpy.UNSEEN]= -1.
+
+        if not self._filter is None:
+            kwargs['unit']= r'$A_{%s}\,(\mathrm{mag})$' % (self._filter.split(' ')[-1])
+        else:
+            kwargs['unit']= r'$E(B-V)\,(\mathrm{mag})$'
+        kwargs['title']= kwargs.get('title',"")
+        healpy.visufunc.mollview(pix_val,
+                                 nest=True,
+                                 xsize=4000,
+                                 min=0.,
+                                 max=numpy.quantile(pix_val,0.99),
+                                 format=r'$%g$',
+                                 cmap='gist_yarg',
+                                 **kwargs)
+        return None

mwdust/Marshall06.py

@@ -0,0 +1,265 @@
+###############################################################################
+#
+#   Marshall06: extinction model from Marshall et al. 2006 2006A&A...453..635M
+#
+###############################################################################
+import os, os.path
+import sys
+import gzip
+import numpy
+from scipy import interpolate
+from astropy.io import ascii
+from mwdust.util.extCurves import aebv
+from mwdust.util.tools import cos_sphere_dist
+from mwdust.util.download import dust_dir, downloader
+from mwdust.DustMap3D import DustMap3D
+
+try:
+    from galpy.util import plot as bovy_plot
+    _BOVY_PLOT_LOADED= True
+except ImportError:
+    _BOVY_PLOT_LOADED= False
+from matplotlib import pyplot
+_DEGTORAD= numpy.pi/180.
+_marshalldir= os.path.join(dust_dir,'marshall06')
+_ERASESTR= "                                                                                "
+class Marshall06(DustMap3D):
+    """extinction model from Marshall et al. 2006 2006A&A...453..635M"""
+    def __init__(self,filter=None,sf10=True):
+        """
+        NAME:
+           __init__
+        PURPOSE:
+           Initialize the Marshall06 dust map
+        INPUT:
+           filter= filter to return the extinction in
+           sf10= (True) if True, use the Schlafly & Finkbeiner calibrations
+        OUTPUT:
+           object
+        HISTORY:
+           2013-11-24 - Started - Bovy (IAS)
+        """
+        DustMap3D.__init__(self,filter=filter)
+        self._sf10= sf10
+        #Read the maps
+        sys.stdout.write('\r'+"Reading Marshall et al. (2006) data file ...\r")
+        sys.stdout.flush()
+        self._marshalldata= ascii.read(os.path.join(_marshalldir,
+                                                         'table1.dat'),
+                                            readme=os.path.join(_marshalldir,
+                                                                'ReadMe'),
+                                            guess=False, format='cds',
+                                            fill_values=[('', '-999')])
+        sys.stdout.write('\r'+_ERASESTR+'\r')
+        sys.stdout.flush()
+        #Sort the data on l and then b
+        negIndx= self._marshalldata['GLON'] > 180.
+        self._marshalldata['GLON'][negIndx]= self._marshalldata['GLON'][negIndx]-360.
+        sortIndx= numpy.arange(len(self._marshalldata))
+        keyArray= (self._marshalldata['GLON']+self._marshalldata['GLAT']/100.).data
+        sortIndx= sorted(sortIndx,key=lambda x: keyArray[x])
+        self._marshalldata= self._marshalldata[sortIndx]
+        self._dl= 0.25
+        self._db= 0.25
+        self._intps= numpy.zeros(len(self._marshalldata),dtype='object') #array to cache interpolated extinctions
+        return None
+
+    def _evaluate(self,l,b,d):
+        """
+        NAME:
+           _evaluate
+        PURPOSE:
+           evaluate the dust-map
+        INPUT:
+           l- Galactic longitude (deg)
+           b- Galactic latitude (deg)
+           d- distance (kpc) can be array
+        OUTPUT:
+           extinction
+        HISTORY:
+           2013-12-12 - Started - Bovy (IAS)
+        """
+        if isinstance(l,numpy.ndarray) or isinstance(b,numpy.ndarray):
+            raise NotImplementedError("array input for l and b for Marshall06 dust map not implemented")
+        lbIndx= self._lbIndx(l,b)
+        if self._intps[lbIndx] != 0:
+            out= self._intps[lbIndx](d)
+        else:
+            tlbData= self.lbData(l,b,addBC=True)
+            interpData=\
+                interpolate.InterpolatedUnivariateSpline(tlbData['dist'],
+                                                         tlbData['aks'],
+                                                         k=1)
+            out= interpData(d)
+            self._intps[lbIndx]= interpData
+        if self._filter is None:
+            return out/aebv('2MASS Ks',sf10=self._sf10)
+        else:
+            return out/aebv('2MASS Ks',sf10=self._sf10)\
+                *aebv(self._filter,sf10=self._sf10)
+
+    def dust_vals_disk(self,lcen,bcen,dist,radius):
+        """
+        NAME:
+           dust_vals_disk
+        PURPOSE:
+           return the distribution of extinction within a small disk as samples
+        INPUT:
+           lcen, bcen - Galactic longitude and latitude of the center of the disk (deg)
+           dist - distance in kpc
+           radius - radius of the disk (deg)
+        OUTPUT:
+           (pixarea,extinction) - arrays of pixel-area in sq rad and extinction value
+        HISTORY:
+           2015-03-07 - Written - Bovy (IAS)
+        """
+        # Find all of the (l,b) of the pixels within radius of (lcen,bcen)
+        lmin= round((lcen-radius-self._dl)/self._dl)*self._dl
+        lmax= round((lcen+radius+self._dl)/self._dl)*self._dl
+        bmin= round((bcen-radius-self._db)/self._db)*self._db
+        bmax= round((bcen+radius+self._db)/self._db)*self._db
+        ls= numpy.arange(lmin,lmax+self._dl,self._dl)
+        bs= numpy.arange(bmin,bmax+self._db,self._db)
+        ll,bb= numpy.meshgrid(ls,bs,indexing='ij')
+        ll= ll.flatten()
+        bb= bb.flatten()
+        indx= cos_sphere_dist(numpy.sin((90.-bb)*_DEGTORAD),
+                              numpy.cos((90.-bb)*_DEGTORAD),
+                              numpy.sin(ll*_DEGTORAD),
+                              numpy.cos(ll*_DEGTORAD),
+                              numpy.sin((90.-bcen)*_DEGTORAD),
+                              numpy.cos((90.-bcen)*_DEGTORAD),
+                              numpy.sin(lcen*_DEGTORAD),
+                              numpy.cos(lcen*_DEGTORAD)) \
+                              >= numpy.cos(radius*_DEGTORAD)
+        ll= ll[indx]
+        bb= bb[indx]
+        # Now get the extinctions for these pixels
+        pixarea= self._dl*self._db*_DEGTORAD**2.+numpy.zeros(numpy.sum(indx))
+        extinction= []
+        for l,b in zip(ll,bb):
+            extinction.append(self._evaluate(l,b,dist))
+        extinction= numpy.array(extinction)
+        return (pixarea,extinction)
+               
+    def dmax(self,l,b):
+        """
+        NAME:
+           dmax
+        PURPOSE:
+           return the maximum distance for which there is Marshall et al. 
+           (2006) data
+        INPUT:
+           l- Galactic longitude (deg)
+           b- Galactic latitude (deg)
+        OUTPUT:
+           maximum distance in kpc
+        HISTORY:
+           2013-12-19 - Started - Bovy (IAS)
+        """
+        tlbData= self.lbData(l,b,addBC=False)
+        return tlbData['dist'][-1]
+
+    def lbData(self,l,b,addBC=False):
+        """
+        NAME:
+           lbData
+        PURPOSE:
+           return the Marshall et al. (2006) data corresponding to a given
+           line of sight
+        INPUT:
+           l- Galactic longitude (deg)
+           b- Galactic latitude (deg)
+           addBC= (False) if True, add boundary conditions (extinction is zero at zero distance; extinction is constant after last data point)
+        OUTPUT:
+        HISTORY:
+           2013-12-13 - Written - Bovy (IAS)
+        """
+        #Find correct entry
+        lbIndx= self._lbIndx(l,b)
+        #Build output array
+        out= numpy.recarray((self._marshalldata[lbIndx]['nb']+2*addBC,),
+                            dtype=[('dist', 'f8'),
+                                   ('e_dist', 'f8'),
+                                   ('aks', 'f8'),
+                                   ('e_aks','f8')])
+        if addBC:
+            #Add boundary conditions
+            out[0]['dist']= 0.
+            out[0]['e_dist']= 0.
+            out[0]['aks']= 0.
+            out[0]['e_aks']= 0.
+            out[-1]['dist']= 30.
+            out[-1]['e_dist']= 0.
+            out[-1]['aks']= self._marshalldata[lbIndx]['ext%i' % (self._marshalldata[lbIndx]['nb'])]
+            out[-1]['e_aks']=  self._marshalldata[lbIndx]['e_ext%i' % (self._marshalldata[lbIndx]['nb'])]
+        for ii in range(self._marshalldata[lbIndx]['nb']):
+            out[ii+addBC]['dist']= self._marshalldata[lbIndx]['r%i' % (ii+1)]
+            out[ii+addBC]['e_dist']= self._marshalldata[lbIndx]['e_r%i' % (ii+1)]
+            out[ii+addBC]['aks']= self._marshalldata[lbIndx]['ext%i' % (ii+1)]
+            out[ii+addBC]['e_aks']= self._marshalldata[lbIndx]['e_ext%i' % (ii+1)]
+        return out
+
+    def plotData(self,l,b,*args,**kwargs):
+        """
+        NAME:
+           plotData
+        PURPOSE:
+           plot the Marshall et al. (2006) extinction values 
+           along a given line of sight as a function of 
+           distance
+        INPUT:
+           l,b - Galactic longitude and latitude (degree)
+           bovy_plot.plot args and kwargs
+        OUTPUT:
+           plot to output device
+        HISTORY:
+           2013-12-15 - Written - Bovy (IAS)
+        """
+        if not _BOVY_PLOT_LOADED:
+            raise NotImplementedError("galpy.util.bovy_plot could not be loaded, so there is no plotting; might have to install galpy (http://github.com/jobovy/galpy) for plotting")
+        #First get the data
+        tdata= self.lbData(l,b)
+        #Filter
+        if self._filter is None:
+            filterFac= 1./aebv('2MASS Ks',sf10=self._sf10)
+        else:
+            filterFac= 1./aebv('2MASS Ks',sf10=self._sf10)\
+                *aebv(self._filter,sf10=self._sf10)
+        #Plot
+        out= bovy_plot.plot(tdata['dist'],tdata['aks']*filterFac,
+                            *args,**kwargs)
+        #uncertainties
+        pyplot.errorbar(tdata['dist'],tdata['aks']*filterFac,
+                        xerr=tdata['e_dist'],
+                        yerr=tdata['e_aks']*filterFac,
+                        ls='none',marker=None,color='k')
+        return out
+
+    def _lbIndx(self,l,b):
+        """Return the index in the _marshalldata array corresponding to this (l,b)"""
+        if l <= -100.125 or l >= 100.125 or b <= -10.125 or b >= 10.125:
+            raise IndexError("Given (l,b) pair not within the region covered by the Marshall et al. (2006) dust map")
+        lIndx= int(round((l+100.)/self._dl))
+        bIndx= int(round((b+10.)/self._db))
+        return lIndx*81+bIndx
+
+    @classmethod
+    def download(cls, test=False):
+        marshall_folder_path = os.path.join(dust_dir, "marshall06")
+        marshall_path = os.path.join(marshall_folder_path, "table1.dat.gz")
+        marshall_readme_path = os.path.join(dust_dir, "marshall06", "ReadMe")
+        if not os.path.exists(marshall_path[:-3]):
+            if not os.path.exists(marshall_folder_path):
+                os.mkdir(marshall_folder_path)
+            _MARSHALL_URL= "https://cdsarc.cds.unistra.fr/ftp/J/A+A/453/635/table1.dat.gz"
+            downloader(_MARSHALL_URL, marshall_path, cls.__name__, test=test)
+            if not test:
+                with open(marshall_path, "rb") as inf, open(os.path.join(marshall_folder_path, "table1.dat"), "w", encoding="utf8") as tof:
+                    decom_str = gzip.decompress(inf.read()).decode("utf-8")
+                    tof.write(decom_str)
+                os.remove(marshall_path)
+        if not os.path.exists(marshall_readme_path):
+            _MARSHALL_README_URL= "https://cdsarc.cds.unistra.fr/ftp/J/A+A/453/635/ReadMe"
+            downloader(_MARSHALL_README_URL, marshall_readme_path, f"{cls.__name__} (ReadMe)", test=test)
+        return None

mwdust/SFD.py

@@ -0,0 +1,72 @@
+###############################################################################
+#
+#   SFD: Schlegel, Finkbeiner, & Davis (1998) dust map (2D)
+#
+###############################################################################
+import os
+import numpy
+from mwdust.util.download import downloader
+from mwdust.util.read_SFD import read_SFD_EBV
+from mwdust.util.extCurves import aebv
+from mwdust.util.download import downloader, dust_dir
+from mwdust.DustMap3D import DustMap3D
+
+class SFD(DustMap3D):
+    """Schlegel, Finkbeiner, & Davis (1998) dust map (2D)"""
+    def __init__(self,filter=None,sf10=True,interp=True,noloop=False):
+        """
+        NAME:
+           __init__
+        PURPOSE:
+           Initialize the SFD dust map
+        INPUT:
+           sf10= (True) if True, use the Schlafly & Finkbeiner calibrations
+           filter= filter to return the extinction in
+           interp= (True) if True, interpolate using the nearest pixels
+           noloop= (False) if True, don't loop through the glons
+        OUTPUT:
+           object
+        HISTORY:
+           2013-11-24 - Started - Bovy (IAS)
+        """
+        DustMap3D.__init__(self,filter=filter)
+        self._sf10= sf10
+        self._interp= interp
+        self._noloop= noloop
+        return None
+
+    def _evaluate(self,l,b,d):
+        """
+        NAME:
+           _evaluate
+        PURPOSE:
+           evaluate the dust-map
+        INPUT:
+           l- Galactic longitude (deg)
+           b- Galactic latitude (deg)
+           d- distance (kpc)
+        OUTPUT:
+           extinction
+        HISTORY:
+           2013-11-24 - Started - Bovy (IAS)
+        """
+        tebv= read_SFD_EBV(l,b,interp=self._interp,
+                           noloop=self._noloop,verbose=False)
+        if self._filter is None:
+            return tebv*numpy.ones_like(d)
+        else:
+            return tebv*aebv(self._filter,sf10=self._sf10)*numpy.ones_like(d)
+
+    @classmethod
+    def download(cls, test=False):
+        sfd_ngp_path = os.path.join(dust_dir, "maps", "SFD_dust_4096_ngp.fits")
+        if not os.path.exists(sfd_ngp_path):
+            if not os.path.exists(os.path.join(dust_dir, "maps")):
+                os.mkdir(os.path.join(dust_dir, "maps"))
+            _SFD_URL_NGP= "https://svn.sdss.org/public/data/sdss/catalogs/dust/trunk/maps/SFD_dust_4096_ngp.fits"
+            downloader(_SFD_URL_NGP, sfd_ngp_path, "SFD (NGP)", test=test)
+        sfd_sgp_path = os.path.join(dust_dir, "maps", "SFD_dust_4096_sgp.fits")
+        if not os.path.exists(sfd_sgp_path):
+            _SFD_URL_SGP= "https://svn.sdss.org/public/data/sdss/catalogs/dust/trunk/maps/SFD_dust_4096_sgp.fits"
+            downloader(_SFD_URL_SGP, sfd_sgp_path, "SFD (SGP)", test=test)
+        return None