mwdust 1.6__cp312-cp312-macosx_10_13_x86_64.whl

mwdust/Combined15.py

@@ -0,0 +1,61 @@
+###############################################################################
+#
+#   Combined15: extinction model obtained from a combination of Marshall et al.
+#               (2006), Green et al. (2015), and Drimmel et al. (2003)
+#
+###############################################################################
+import os, os.path
+import numpy
+import h5py
+from mwdust.util.download import downloader, dust_dir
+from mwdust.HierarchicalHealpixMap import HierarchicalHealpixMap
+_DEGTORAD= numpy.pi/180.
+_combineddir= os.path.join(dust_dir, 'combined15')
+class Combined15(HierarchicalHealpixMap):
+    """extinction model obtained from a combination of Marshall et al.
+    (2006), Green et al. (2015), and Drimmel et al. (2003)"""
+    def __init__(self,filter=None,sf10=True,load_samples=False,
+                 interpk=1):
+        """
+        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
+           interpk= (1) interpolation order
+        OUTPUT:
+           object
+        HISTORY:
+           2015-07-28 - Started - Bovy (UofT)
+        """
+        HierarchicalHealpixMap.__init__(self,filter=filter,sf10=sf10)
+        #Read the map
+        with h5py.File(os.path.join(_combineddir,'dust-map-3d.h5'),'r') \
+                as combineddata:
+            self._pix_info= combineddata['/pixel_info'][:]
+            self._best_fit= combineddata['/best_fit'][:]
+        # Utilities
+        self._distmods= numpy.linspace(4.,19.,31)
+        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
+    
+    @classmethod
+    def download(cls, test=False):
+        # Download the combined map of Bovy et al. (2015): Marshall+Green+Drimmel for full sky coverage
+        combined15_path = os.path.join(dust_dir, "combined15", "dust-map-3d.h5")
+        if not os.path.exists(combined15_path):
+                if not os.path.exists(os.path.join(dust_dir, "combined15")):
+                    os.mkdir(os.path.join(dust_dir, "combined15"))
+                _COMBINED15_URL = "https://zenodo.org/record/31262/files/dust-map-3d.h5"
+                downloader(_COMBINED15_URL, combined15_path, cls.__name__, test=test)
+        return None

mwdust/Combined19.py

@@ -0,0 +1,62 @@
+###############################################################################
+#
+#   Combined19: extinction model obtained from a combination of Marshall et al.
+#               (2006), Green et al. (2019), and Drimmel et al. (2003)
+#
+###############################################################################
+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.
+_combineddir= os.path.join(dust_dir,'combined19')
+class Combined19(HierarchicalHealpixMap):
+    """extinction model obtained from a combination of Marshall et al.
+    (2006), Green et al. (2019), and Drimmel et al. (2003)"""
+    def __init__(self,filter=None,sf10=True,load_samples=False,
+                 interpk=1):
+        """
+        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
+           interpk= (1) interpolation order
+        OUTPUT:
+           object
+        HISTORY:
+           2015-07-28 - Started - Bovy (UofT)
+           2019-09-12 - Updated - Rybizki (MPIA)	   
+        """
+        HierarchicalHealpixMap.__init__(self,filter=filter,sf10=sf10)
+        #Read the map
+        with h5py.File(os.path.join(_combineddir,'combine19.h5'),'r') \
+                as combineddata:
+            self._pix_info= combineddata['/pixel_info'][:]
+            self._best_fit= combineddata['/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
+
+    @classmethod
+    def download(cls, test=False):
+        # Download the combined map: Marshall+Green19+Drimmel for full sky coverage
+        combined19_path = os.path.join(dust_dir, "combined19", "combine19.h5")
+        if not os.path.exists(combined19_path):
+            if not os.path.exists(os.path.join(dust_dir, "combined19")):
+                os.mkdir(os.path.join(dust_dir, "combined19"))
+            _COMBINED19_URL = "https://zenodo.org/record/3566060/files/combine19.h5"
+            downloader(_COMBINED19_URL, combined19_path, cls.__name__, test=test)
+        return None

mwdust/Drimmel03.py

@@ -0,0 +1,293 @@
+###############################################################################
+#
+#   Drimmel03: extinction model from Drimmel et al. 2003 2003A&A...409..205D
+#
+###############################################################################
+import os
+import copy
+import numpy
+import tarfile
+import inspect
+from scipy.ndimage import map_coordinates
+from scipy import optimize
+try:
+    import healpy
+except ImportError: pass
+from mwdust.util.extCurves import aebv
+from mwdust.util import read_Drimmel
+from mwdust.util.tools import cos_sphere_dist
+from mwdust.util.download import  dust_dir, downloader
+from mwdust.DustMap3D import DustMap3D
+
+_DEGTORAD= numpy.pi/180.
+class Drimmel03(DustMap3D):
+    """extinction model from Drimmel et al. 2003 2003A&A...409..205D"""
+    def __init__(self,filter=None,sf10=True):
+        """
+        NAME:
+           __init__
+        PURPOSE:
+           Initialize the Drimmel03 dust map
+        INPUT:
+           filter= filter to return the extinction in
+           sf10= (True) if True, use the Schlafly & Finkbeiner calibrations
+        OUTPUT:
+           object
+        HISTORY:
+           2013-12-10 - Started - Bovy (IAS)
+        """
+        DustMap3D.__init__(self,filter=filter)
+        self._sf10= sf10
+        #Read the maps
+        drimmelMaps= read_Drimmel.readDrimmelAll()
+        self._drimmelMaps= drimmelMaps
+        #Sines and cosines of sky positions of COBE pixels
+        self._rf_sintheta= numpy.sin(numpy.pi/2.-self._drimmelMaps['rf_glat']*_DEGTORAD)
+        self._rf_costheta= numpy.cos(numpy.pi/2.-self._drimmelMaps['rf_glat']*_DEGTORAD)
+        self._rf_sinphi= numpy.sin(self._drimmelMaps['rf_glon']*_DEGTORAD)
+        self._rf_cosphi= numpy.cos(self._drimmelMaps['rf_glon']*_DEGTORAD)
+        #Various setups
+        self._xsun= -8.
+        self._zsun= 0.015
+        #Global grids
+        self._nx_disk, self._ny_disk, self._nz_disk= 151, 151, 51
+        self._dx_disk, self._dy_disk, self._dz_disk= 0.2, 0.2, 0.02
+        self._nx_ori, self._ny_ori, self._nz_ori= 76, 151, 51
+        self._dx_ori, self._dy_ori, self._dz_ori= 0.05, 0.05, 0.02
+        #Local grids
+        self._nx_diskloc, self._ny_diskloc, self._nz_diskloc= 31, 31, 51
+        self._dx_diskloc, self._dy_diskloc, self._dz_diskloc= 0.05, 0.05, 0.02
+        self._nx_ori2, self._ny_ori2, self._nz_ori2= 101, 201, 51
+        self._dx_ori2, self._dy_ori2, self._dz_ori2= 0.02, 0.02, 0.02
+        return None
+
+    def _evaluate(self,l,b,d,norescale=False,
+                  _fd=1.,_fs=1.,_fo=1.):
+        """
+        NAME:
+           _evaluate
+        PURPOSE:
+           evaluate the dust-map
+        INPUT:
+           l- Galactic longitude (deg)
+           b- Galactic latitude (deg)
+           d- distance (kpc) can be array
+           norescale= (False) if True, don't apply re-scalings
+           _fd, _fs, _fo= (1.) amplitudes of the different components
+        OUTPUT:
+           extinction
+        HISTORY:
+           2013-12-10 - Started - Bovy (IAS)
+        """
+        if isinstance(l,numpy.ndarray) or isinstance(b,numpy.ndarray):
+            raise NotImplementedError("array input for l and b for Drimmel dust map not implemented")
+
+        cl= numpy.cos(l*_DEGTORAD)
+        sl= numpy.sin(l*_DEGTORAD)
+        cb= numpy.cos(b*_DEGTORAD)
+        sb= numpy.sin(b*_DEGTORAD)
+
+        #Setup arrays
+        avori= numpy.zeros_like(d)
+        avspir= numpy.zeros_like(d)
+        avdisk= numpy.zeros_like(d)
+
+        #Find nearest pixel in COBE map for the re-scaling
+        rfIndx= numpy.argmax(cos_sphere_dist(self._rf_sintheta,
+                                             self._rf_costheta,
+                                             self._rf_sinphi,
+                                             self._rf_cosphi,
+                                             numpy.sin(numpy.pi/2.-b*_DEGTORAD),
+                                             numpy.cos(numpy.pi/2.-b*_DEGTORAD),
+                                             sl,cl))
+
+        rfdisk, rfspir, rfori= 1., 1., 1,
+        if self._drimmelMaps['rf_comp'][rfIndx] == 1 and not norescale:
+            rfdisk= self._drimmelMaps['rf'][rfIndx]
+        elif self._drimmelMaps['rf_comp'][rfIndx] == 2 and not norescale:
+            rfspir= self._drimmelMaps['rf'][rfIndx]
+        elif self._drimmelMaps['rf_comp'][rfIndx] == 3 and not norescale:
+            rfori= self._drimmelMaps['rf'][rfIndx]
+
+        #Find maximum distance
+        dmax= 100.
+        if b != 0.: dmax= .49999/numpy.fabs(sb) - self._zsun/sb
+        if cl != 0.:
+            tdmax= (14.9999/numpy.fabs(cl)-self._xsun/cl)
+            if tdmax < dmax: dmax= tdmax
+        if sl != 0.:
+            tdmax = 14.9999/numpy.fabs(sl)
+            if tdmax < dmax: dmax= tdmax
+        d= copy.copy(d)
+        d[d > dmax]= dmax
+        
+        #Rectangular coordinates
+        X= d*cb*cl
+        Y= d*cb*sl
+        Z= d*sb+self._zsun
+
+        #Local grid
+        #Orion
+        locIndx= (numpy.fabs(X) < 1.)*(numpy.fabs(Y) < 2.)
+        if numpy.sum(locIndx) > 0:
+            xi = X[locIndx]/self._dx_ori2+float(self._nx_ori2-1)/2.
+            yj = Y[locIndx]/self._dy_ori2+float(self._ny_ori2-1)/2.
+            zk = Z[locIndx]/self._dz_ori2+float(self._nz_ori2-1)/2.
+            avori[locIndx]= map_coordinates(self._drimmelMaps['avori2'],
+                                            [xi,yj,zk],
+                                            mode='constant',cval=0.)
+        #local disk
+        locIndx= (numpy.fabs(X) < 0.75)*(numpy.fabs(Y) < 0.75)
+        if numpy.sum(locIndx) > 0:
+            xi = X[locIndx]/self._dx_diskloc+float(self._nx_diskloc-1)/2.
+            yj = Y[locIndx]/self._dy_diskloc+float(self._ny_diskloc-1)/2.
+            zk = Z[locIndx]/self._dz_diskloc+float(self._nz_diskloc-1)/2.
+            avdisk[locIndx]= map_coordinates(self._drimmelMaps['avdloc'],
+                                             [xi,yj,zk],
+                                             mode='constant',cval=0.)
+        
+        #Go to Galactocentric coordinates
+        X= X+self._xsun
+
+        #Stars beyond the local grid
+        #Orion
+        globIndx= True^(numpy.fabs(X-self._xsun) < 1.)*(numpy.fabs(Y) < 2.)
+        if numpy.sum(globIndx) > 0:
+            #Orion grid is different from other global grids, so has its own dmax
+            dmax= 100.
+            if b != 0.: dmax= .49999/numpy.fabs(sb) - self._zsun/sb
+            if cl > 0.:
+                tdmax = (2.374999/numpy.fabs(cl))
+                if tdmax < dmax: dmax= tdmax
+            if cl < 0.:
+                tdmax = (1.374999/numpy.fabs(cl))
+                if tdmax < dmax: dmax= tdmax
+            if sl != 0.:
+                tdmax = (3.749999/numpy.fabs(sl))
+                if tdmax < dmax: dmax= tdmax
+            dori= copy.copy(d)
+            dori[dori > dmax]= dmax
+            Xori= dori*cb*cl+self._xsun
+            Yori= dori*cb*sl
+            Zori= dori*sb+self._zsun
+
+            xi = Xori[globIndx]/self._dx_ori + 2.5*float(self._nx_ori-1)
+            yj = Yori[globIndx]/self._dy_ori + float(self._ny_ori-1)/2.
+            zk = Zori[globIndx]/self._dz_ori + float(self._nz_ori-1)/2.
+
+            avori[globIndx]= map_coordinates(self._drimmelMaps['avori'],
+                                             [xi,yj,zk],
+                                             mode='constant',cval=0.)
+        #disk & spir
+        xi = X/self._dx_disk+float(self._nx_disk-1)/2.
+        yj = Y/self._dy_disk+float(self._ny_disk-1)/2.
+        zk = Z/self._dz_disk+float(self._nz_disk-1)/2.
+        avspir= map_coordinates(self._drimmelMaps['avspir'],
+                                [xi,yj,zk],
+                                mode='constant',cval=0.)
+        globIndx= True^(numpy.fabs(X-self._xsun) < 0.75)*(numpy.fabs(Y) < 0.75)
+        if numpy.sum(globIndx) > 0:
+            avdisk[globIndx]= map_coordinates(self._drimmelMaps['avdisk'],
+                                              [xi,yj,zk],
+                                              mode='constant',
+                                              cval=0.)[globIndx]
+        
+        #Return
+        out=_fd*rfdisk*avdisk+_fs*rfspir*avspir+_fo*rfori*avori
+        if self._filter is None: # From Rieke & Lebovksy (1985); if sf10, first put ebv on SFD scale
+            return out/3.09/((1-self._sf10)+self._sf10*0.86)
+        else: 
+            return out/3.09/((1-self._sf10)+self._sf10*0.86)\
+                *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)
+        """
+        # Convert the disk center to a HEALPIX vector
+        vec= healpy.pixelfunc.ang2vec((90.-bcen)*_DEGTORAD,lcen*_DEGTORAD)
+        # We pixelize the map with a HEALPIX grid with nside=256, to somewhat
+        # oversample the Drimmel resolution
+        nside= 256
+        # Find the pixels at this resolution that fall within the disk
+        ipixs= healpy.query_disc(nside,vec,radius*_DEGTORAD,
+                                 inclusive=False,nest=False)
+        # Query the HEALPIX map for pixels that lie within the disk
+        pixarea= healpy.pixelfunc.nside2pixarea(nside)+numpy.zeros(len(ipixs))
+        extinction= []
+        for ii, ipix in enumerate(ipixs):
+            # Get glon and glat
+            b9, l= healpy.pixelfunc.pix2ang(nside,ipix,nest=False)
+            b= 90.-b9/_DEGTORAD
+            l/= _DEGTORAD
+            # Now evaluate
+            extinction.append(self._evaluate(l,b,dist))
+        extinction= numpy.array(extinction)
+        return (pixarea,extinction)
+
+    def fit(self,l,b,dist,ext,e_ext):
+        """
+        NAME:
+           fit
+        PURPOSE:
+           fit the amplitudes of the disk, spiral, and Orion parts of the
+           Drimmel map to other data
+        INPUT:
+           l,b- Galactic longitude and latitude in degree
+           dist - distance in kpc
+           ext - extinction at dist
+           e_ext - error in extinction
+        OUTPUT:
+           (fd,fs,fo,dist_stretch) amplitudes of disk, spiral, and Orion parts
+           and a 'distance stretch' applied to the model
+           (applied as self(l,b,dist*dist_stretch))
+        HISTORY:
+           2013-12-16 - Written - Bovy (IAS)
+        """
+        #Fit consists of 
+        #a) overall amplitude A
+        #b) relative amplitude fd/A, fs/A
+        #c) distance stretch
+        pars= numpy.array([0.,numpy.log(1./3.),numpy.log(1./3.),0.])
+        pars=\
+            optimize.fmin_powell(_fitFunc,pars,args=(self,l,b,dist,ext,e_ext))
+        amp= numpy.exp(pars[0])
+        fd= amp*numpy.exp(pars[1])
+        fs= amp*numpy.exp(pars[2])
+        fo= amp*(1.-fd-fs)
+        return (fd,fs,fo,numpy.exp(pars[3]))
+
+    @classmethod
+    def download(cls, test=False):
+        drimmel_folder_path = os.path.abspath(os.path.join(inspect.getfile(cls), "..", "util", "drimmeldata"))
+        drimmel_path = os.path.join(drimmel_folder_path, "data-for.tar.gz")
+        if not os.path.exists(drimmel_path):
+            if not os.path.exists(drimmel_folder_path):
+                os.mkdir(drimmel_folder_path)
+            _DRIMMEL_URL= "https://zenodo.org/record/7340108/files/data-for.tar.gz"
+            downloader(_DRIMMEL_URL, drimmel_path, cls.__name__, test=test)
+            if not test:
+                drim_file = tarfile.open(drimmel_path)
+                drim_file.extractall(drimmel_folder_path)
+                drim_file.close()
+        return None
+
+def _fitFunc(pars,drim,l,b,dist,ext,e_ext):
+    amp= numpy.exp(pars[0])
+    fd= amp*numpy.exp(pars[1])
+    fs= amp*numpy.exp(pars[2])
+    fo= amp*(1.-fd-fs)
+    dist_stretch= numpy.exp(pars[3])
+    model_ext= drim(l,b,dist*dist_stretch,_fd=fd,_fs=fs,_fo=fo)
+    return 0.5*numpy.sum((model_ext-ext)**2./e_ext**2.)

mwdust/DustMap3D.py

@@ -0,0 +1,99 @@
+###############################################################################
+#
+#   DustMap3D: top-level class for a 3D dust map; all other dust maps inherit
+#              from this
+#
+###############################################################################
+import numpy
+try:
+    from galpy.util import plot as bovy_plot
+    _BOVY_PLOT_LOADED= True
+except ImportError:
+    _BOVY_PLOT_LOADED= False
+
+class DustMap3D(object):
+    """top-level class for a 3D dust map; all other dust maps inherit from this"""
+    def __init__(self, filter=None, **download_kwargs):
+        """
+        NAME:
+           __init__
+        PURPOSE:
+           Initialize the dust map
+        INPUT:
+           filter= filter to return the extinction in when called
+        OUTPUT:
+        HISTORY:
+           2013-11-24 - Started - Bovy (IAS)
+        """
+        self._filter= filter
+        if hasattr(self, "download"):
+            self.download(**download_kwargs) # download the map
+
+    def __call__(self,*args,**kwargs):
+        """
+        NAME:
+           __call__
+        PURPOSE:
+           evaluate the dust map
+        INPUT:
+           Either:
+              (l,b,d) -  Galactic longitude, latitude (deg), and distance (kpc)
+        OUTPUT:
+        HISTORY:
+           2013-11-24 - Started - Bovy (IAS)
+        """
+        if True: #(l,b,d)
+            l,b,d= args
+            if isinstance(d,(int,float,numpy.float32,numpy.float64)):
+                d= numpy.array([d])
+            try:
+                return self._evaluate(l,b,d,**kwargs)
+            except AttributeError:
+                raise NotImplementedError("'_evaluate' for this DustMap3D not implemented yet")
+
+    def plot(self,l,b,*args,**kwargs):
+        """
+        NAME:
+           plot
+        PURPOSE:
+           plot the extinction along a given line of sight as a function of 
+           distance
+        INPUT:
+           l,b - Galactic longitude and latitude (degree)
+           range= distance range in kpc
+           distmod= (False) if True, plot as a function of distance modulus (range is distmod range)
+           bovy_plot.plot args and kwargs
+        OUTPUT:
+           plot to output device
+        HISTORY:
+           2013-12-11 - 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")
+        distmod= kwargs.pop('distmod',False)
+        range= kwargs.pop('range',None)
+        if range is None and distmod:
+            range= [4.,19.]
+        else:
+            range= [0.,12.]
+        nds= kwargs.get('nds',101)
+        #First evaluate the dust map
+        ds= numpy.linspace(range[0],range[1],nds)
+        if distmod:
+            adust= self(l,b,10.**(ds/5.-2.))
+        else:
+            adust= self(l,b,ds)
+        #Add labels
+        if distmod:
+            kwargs['xlabel']= r'$\mathrm{Distance\ modulus}$'
+        else:
+            kwargs['xlabel']= r'$D\,(\mathrm{kpc})$'
+        if not self._filter is None:
+            kwargs['ylabel']= r'$A_{%s}\,(\mathrm{mag})$' % (self._filter.split(' ')[-1])
+        else:
+            kwargs['ylabel']= r'$E(B-V)\,(\mathrm{mag})$'
+        return bovy_plot.plot(ds,adust,*args,**kwargs)
+
+    @classmethod
+    def download(cls, test=False):
+        pass

mwdust/Green15.py

@@ -0,0 +1,83 @@
+###############################################################################
+#
+#   Green15: extinction model from Green et al. (2015)
+#
+###############################################################################
+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, 'green15')
+class Green15(HierarchicalHealpixMap):
+    """extinction model from Green et al. (2015)"""
+    def __init__(self,filter=None,sf10=True,load_samples=False,
+                 interpk=1):
+        """
+        NAME:
+           __init__
+        PURPOSE:
+           Initialize the Green et al. (2015) dust map
+        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:
+           2015-03-02 - Started - Bovy (IAS)
+        """
+        HierarchicalHealpixMap.__init__(self,filter=filter,sf10=sf10)
+        #Read the map
+        with h5py.File(os.path.join(_greendir,'dust-map-3d.h5'),'r') \
+                as greendata:
+            self._pix_info= greendata['/pixel_info'][:]
+            if load_samples:
+                self._samples= greendata['/samples'][:]
+            self._best_fit= greendata['/best_fit'][:]
+            self._GR= greendata['/GRDiagnostic'][:]
+        # Utilities
+        self._distmods= numpy.linspace(4.,19.,31)
+        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:
+           2015-03-08 - Written - Bovy (IAS)
+        """
+        # 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. PanSTARRS data (alt.: http://dx.doi.org/10.7910/DVN/40C44C)
+        green15_path = os.path.join(dust_dir, "green15", "dust-map-3d.h5")
+        if not os.path.exists(green15_path):
+            if not os.path.exists(os.path.join(dust_dir, "green15")):
+                os.mkdir(os.path.join(dust_dir, "green15"))
+            _GREEN15_URL = "https://dataverse.harvard.edu/api/access/datafile/:persistentId?persistentId=doi:10.7910/DVN/40C44C/TERL5A"
+            downloader(_GREEN15_URL, green15_path, cls.__name__, test=test)
+        return None

mwdust/Green17.py

@@ -0,0 +1,85 @@
+###############################################################################
+#
+#   Green17: extinction model from Green et al. (2017)
+#
+###############################################################################
+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, 'green17')
+class Green17(HierarchicalHealpixMap):
+    """extinction model from Green et al. (2018)"""
+    def __init__(self,filter=None,sf10=True,load_samples=False,
+                 interpk=1):
+        """
+        NAME:
+           __init__
+        PURPOSE:
+           Initialize the Green et al. (2017) 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,'bayestar2017.h5'),'r') \
+                as greendata:
+            self._pix_info= greendata['/pixel_info'][:]
+            if load_samples:
+                self._samples= greendata['/samples'][:]
+            self._best_fit= greendata['/best_fit'][:]
+            self._GR= greendata['/GRDiagnostic'][:]
+        # Utilities
+        self._distmods= numpy.linspace(4,19,31)
+        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. 2018 PanSTARRS data
+        green17_path = os.path.join(dust_dir, "green17", "bayestar2017.h5")
+        if not os.path.exists(green17_path):
+            if not os.path.exists(os.path.join(dust_dir, "green17")):
+                os.mkdir(os.path.join(dust_dir, "green17"))
+            _GREEN17_URL = "https://dataverse.harvard.edu/api/access/datafile/:persistentId?persistentId=doi:10.7910/DVN/LCYHJG/S7MP4P"
+            downloader(_GREEN17_URL, green17_path, cls.__name__, test=test)
+        return None