xdust 1.0__py3-none-any.whl

xdust/__init__.py

@@ -0,0 +1,5 @@
+from . import helpers
+from . import graindist
+from . import scatteringmodel
+from . import halos
+from .grainpop import *

xdust/graindist/__init__.py

@@ -0,0 +1,6 @@
+
+from . import sizedist
+from . import composition
+from . import shape
+
+from .graindist import *

xdust/graindist/composition/__init__.py

@@ -0,0 +1,165 @@
+import os
+import numpy as np
+import astropy.units as u
+
+GTYPES = ['Graphite', 'Silicate', 'Drude']
+
+def _find_cmfile(name):
+    root_path = os.path.dirname(__file__).rstrip('composition')
+    data_path = root_path + 'tables/'
+    return data_path + name
+
+class Composition(object):
+    """
+    Composition class for storing information about grain material
+    
+    Attributes
+    ----------
+    cmtype : str
+        Label for the compound.
+
+    rho : float
+        Density of the material [g cm^-3].
+
+    citation : str
+        Citation for the optical constants loaded.
+
+    wavel : astropy.units.Quantity
+        Wavelength grid for optical constants.
+
+    revals : numpy.ndarray
+        Real part of the complex index of refraction.
+
+    imvals : numpy.ndarray
+        Imaginary part of the complex index of refraction.
+    """
+    def __init__(self):
+        self.cmtype = None
+        self.rho = None
+        self.citation = None
+        self.wavel = None
+        self.revals = 1.0
+        self.imvals = 0.0
+    
+    def rp(self, x):
+        """
+        Interpolate over the input wavelength grid to get the real part of the 
+        complex index of refraction.
+
+        Parameters
+        ----------
+        x : astropy.units.Quantity or numpy.ndarray
+            Wavelength or energy; if an ``astropy.units.Quantity``, converted to
+            the same units as ``self.wavel``; if a plain array, keV units are assumed.
+
+        Returns
+        -------
+        numpy.ndarray
+            ``np.interp(x, self.wavel, self.revals, left=1.0, right=1.0)``
+        """
+        # If the input is an astropy quantity, convert it to the same unit as wavel
+        if isinstance(x, u.Quantity):
+            new_x = x.to(self.wavel.unit, equivalencies=u.spectral()).value
+        # Otherwise, assume the unit is keV
+        else:
+            new_x = (x * u.keV).to(self.wavel.unit, equivalencies=u.spectral()).value
+        return np.interp(new_x, self.wavel.value, self.revals, left=1.0, right=1.0)
+    
+    def ip(self, x):
+        """
+        Interpolate over the input wavelength grid to get the imaginary part of the 
+        complex index of refraction.
+
+        Parameters
+        ----------
+        x : astropy.units.Quantity or numpy.ndarray
+            Wavelength or energy; if an ``astropy.units.Quantity``, converted to
+            the same units as ``self.wavel``; if a plain array, keV units are assumed.
+
+        Returns
+        -------
+        numpy.ndarray
+            ``np.interp(x, self.wavel, self.imvals, left=0.0, right=0.0)``
+        """
+        # If the input is an astropy quantity, convert it to the same unit as wavel
+        if isinstance(x, u.Quantity):
+            new_x = x.to(self.wavel.unit, equivalencies=u.spectral()).value
+        # Otherwise, assume the unit is keV
+        else:
+            new_x = (x * u.keV).to(self.wavel.unit, equivalencies=u.spectral()).value
+        return np.interp(new_x, self.wavel.value, self.imvals, left=0.0, right=0.0)
+    
+    def cm(self, x):
+        """
+        Returns the complex index of refraction using Python complex numbers
+
+        Parameters
+        ----------
+        x : astropy.units.Quantity or numpy.ndarray
+            Wavelength or energy; if an ``astropy.units.Quantity``, converted to
+            the same units as ``self.wavel``; if a plain array, keV units are assumed.
+
+        Returns
+        -------
+        complex or numpy.ndarray of complex
+            Complex index of refraction :math:`n = n_r + i n_i`.
+        """
+        return self.rp(x) + 1j * self.ip(x)
+    
+    def plot(self, ax, lam=None, rppart=True, impart=True, xunit=None, label=''):
+        """
+        Plots the different parts of the complex index of refraction on a matplotlib axis
+
+        Parameters
+        ----------
+        ax : matplotlib.pyplot.Axes
+            The axes on which to plot.
+
+        lam : astropy.units.Quantity or numpy.ndarray, optional
+            If ``None``, plots using the default ``self.wavel`` grid; otherwise
+            interpolates onto the provided grid. Plain arrays are assumed to be
+            in keV.
+
+        rppart : bool
+            If ``True`` (default), plot the real part :math:`|Re(m)-1|`.
+
+        impart : bool
+            If ``True`` (default), plot the imaginary part :math:`Im(m)`.
+
+        xunit : str, optional
+            Unit string for the x-axis. Defaults to ``self.wavel.unit``.
+
+        label : str
+            Prefix string appended to legend labels.
+        """
+        if xunit is None:
+            xunit = self.wavel.unit
+        # If no grid specified, plot the default one
+        if lam is None:
+            rp_m1 = np.abs(self.revals - 1.0)
+            ip = self.imvals
+            x  = self.wavel.to(xunit, equivalencies=u.spectral()).value
+        # Else, plot the interpolated values
+        else:
+            rp_m1 = np.abs(self.rp(lam)-1.0)
+            ip = self.ip(lam)
+            # Check if the input value had units
+            if isinstance(lam, u.Quantity):
+                x = lam.to(xunit, equivalencies=u.spectral()).value
+            # If not, assume keV units
+            else:
+                x = (lam * u.keV).to(xunit, equivalencies=u.spectral()).value
+        # If the user wants to plot Real Part
+        if rppart:
+            ax.plot(x, rp_m1, ls='-', label='{} |Re(m-1)|'.format(label))
+        # If the user wants to plot Imaginary Part
+        if impart:
+            ax.plot(x, ip, ls='--', label='{} Im(m)'.format(label))
+        ax.set_xlabel(xunit)
+        ax.legend()
+
+
+
+from .cmdrude import CmDrude
+from .cmsilicate import CmSilicate
+from .cmgraphite import CmGraphite

xdust/graindist/composition/cmdrude.py

@@ -0,0 +1,72 @@
+import numpy as np
+import astropy.units as u
+import astropy.constants as c
+
+from . import Composition
+
+__all__ = ['CmDrude']
+
+RHO_DRUDE  = 3.0  # g cm^-3
+
+## -- Some constants to use for the calculation
+# Classical electron radius
+RE_CM = 2.8179403227e-15 * u.m.to('cm')
+# Mass of proton
+MP_G = c.m_p.to('g').value 
+
+class CmDrude(Composition):
+    """
+    Optical constants under the Drude approximation.
+    """
+    def __init__(self, rho=RHO_DRUDE):  # Returns a CM using the Drude approximation
+        Composition.__init__(self)
+        self.cmtype = 'Drude'
+        self.rho    = rho
+        self.citation = "Using the Drude approximation.\nBohren, C. F. & Huffman, D. R., 1983, Absorption and Scattering of Light by Small Particles (New York: Wiley)"
+
+        # Set up default values so that inherited plotting method from Composition will work
+        self.wavel = np.linspace(1.0, 10.0, 50) * u.keV
+        self.revals = self.rp(self.wavel)
+        self.imvals = self.ip(self.wavel)
+
+    def rp(self, x):
+        """
+        Calculate the real part of the complex index of refraction under the Drude approximation.
+
+        Parameters
+        ----------
+        x : astropy.units.Quantity or numpy.ndarray
+            Wavelength or energy; plain arrays are assumed to be in keV.
+
+        Returns
+        -------
+        numpy.ndarray
+            :math:`1 + (\\rho / 2 m_p)(r_e / 2\\pi)\\lambda^2`
+        """
+        if isinstance(x, u.Quantity):
+            lam_cm = x.to('cm', equivalencies=u.spectral()).value
+        else:
+            lam_cm = (x * u.keV).to('cm', equivalencies=u.spectral()).value
+
+        mm1 = self.rho / (2.0*MP_G) * RE_CM/(2.0*np.pi) * np.power(lam_cm, 2)
+        return mm1 + 1.0
+
+    def ip(self, x):
+        """
+        Gives the imaginary part of the complex index of refraction under the Drude approximation.
+
+        Parameters
+        ----------
+        x : astropy.units.Quantity or numpy.ndarray
+            Wavelength or energy; plain arrays are assumed to be in keV.
+
+        Returns
+        -------
+        float or numpy.ndarray
+            ``0.0`` for scalar input; array of zeros matching the length of ``x``
+            for array input.
+        """
+        if np.size(x) > 1:
+            return np.zeros(np.size(x))
+        else:
+            return 0.0

xdust/graindist/composition/cmgraphite.py

@@ -0,0 +1,61 @@
+import numpy as np
+from astropy.io import ascii
+from astropy import units as u
+
+from . import _find_cmfile
+from . import Composition
+
+__all__ = ['CmGraphite']
+
+RHO_GRA       = 2.2  # g cm^-3
+
+class CmGraphite(Composition):
+    """
+    Optical constants for Graphite from
+    `Draine (2003), ApJ 598, 1026 <http://adsabs.harvard.edu/abs/2003ApJ...598.1026D>`_
+
+    Attributes
+    ----------
+    size : str
+        ``'big'`` gives results for 0.1 um sized graphite grains at 20 K;
+        ``'small'`` gives results for 0.01 um sized grains at 20 K.
+
+    orient : str
+        ``'perp'`` gives results for E-field perpendicular to the c-axis;
+        ``'para'`` gives results for E-field parallel to the c-axis.
+    """
+    def __init__(self, rho=RHO_GRA, size='big', orient='perp'):
+        Composition.__init__(self)
+        self.cmtype = 'Graphite'
+        self.rho    = rho
+        self.citation = "Using optical constants for graphite,\nDraine, B. T. 2003, ApJ, 598, 1026\nhttp://adsabs.harvard.edu/abs/2003ApJ...598.1026D"
+        # Additional info not in default class
+        self.size   = size
+        self.orient = orient
+        
+        # Populate the wavelength and optical constants info
+        if size == 'big':
+            D03file_para = _find_cmfile('callindex.out_CpaD03_0.10')
+            D03file_perp = _find_cmfile('callindex.out_CpeD03_0.10')
+        if size == 'small':
+            D03file_para = _find_cmfile('callindex.out_CpaD03_0.01')
+            D03file_perp = _find_cmfile('callindex.out_CpeD03_0.01')
+
+        D03dat_para = ascii.read(D03file_para, header_start=4, data_start=5)
+        D03dat_perp = ascii.read(D03file_perp, header_start=4, data_start=5)
+
+        # The wavelength grid needs to be in ascending order 
+        # for np.interp to run correctly
+        if orient == 'perp':
+            wavel = D03dat_perp['wave(um)'] * u.micron
+            wsort = np.argsort(wavel.value)
+            self.wavel = wavel[wsort]
+            self.revals  = 1.0 + D03dat_perp['Re(n)-1'][wsort]
+            self.imvals  = D03dat_perp['Im(n)'][wsort]
+
+        if orient == 'para':
+            wavel = D03dat_para['wave(um)'] * u.micron
+            wsort = np.argsort(wavel)
+            self.wavel = wavel[wsort]
+            self.revals  = 1.0 + D03dat_para['Re(n)-1'][wsort]
+            self.imvals  = D03dat_para['Im(n)'][wsort]

xdust/graindist/composition/cmsilicate.py

@@ -0,0 +1,32 @@
+import numpy as np
+from astropy.io import ascii
+from astropy import units as u
+
+from . import _find_cmfile
+from . import Composition
+
+__all__ = ['CmSilicate']
+
+RHO_SIL       = 3.8  # g cm^-3
+
+class CmSilicate(Composition):
+    """
+    Optical constants for Silicate from
+    `Draine (2003), ApJ 598, 1026 <http://adsabs.harvard.edu/abs/2003ApJ...598.1026D>`_
+    """
+    def __init__(self, rho=RHO_SIL):
+        Composition.__init__(self)
+        self.cmtype = 'Silicate'
+        self.rho    = rho
+        self.citation = "Using optical constants for astrosilicate,\nDraine, B. T. 2003, ApJ, 598, 1026\nhttp://adsabs.harvard.edu/abs/2003ApJ...598.1026D"
+
+        D03file = _find_cmfile('callindex.out_sil.D03')
+        D03dat  = ascii.read(D03file, header_start=4, data_start=5)
+
+        # The wavelength grid needs to be in ascending order for np.interp to run correctly
+        wavel = D03dat['wave(um)'] * u.micron
+        wsort = np.argsort(wavel.value)
+
+        self.wavel = wavel[wsort]
+        self.revals = 1.0 + D03dat['Re(n)-1'][wsort]
+        self.imvals = D03dat['Im(n)'][wsort]

xdust/graindist/composition/minerals.py

@@ -0,0 +1,91 @@
+#
+# minerals.py -- Some tables for ISM abundances and depletion factors
+# that are useful for calculating dust mass and dust-to-gas ratios
+#
+# 2016.01.22 - lia@space.mit.edu
+##----------------------------------------------------------------
+
+import numpy as np
+
+amu   = {'H':1.008,'He':4.0026,'C':12.011,'N':14.007,'O':15.999,'Ne':20.1797,
+         'Na':22.989,'Mg':24.305,'Al':26.981,'Si':28.085,'P':30.973,'S':32.06,
+         'Cl':35.45,'Ar':39.948,'Ca':40.078,'Ti':47.867,'Cr':51.9961,'Mn':54.938,
+         'Fe':55.845,'Co':58.933,'Ni':58.6934}
+amu_g = 1.661e-24  # g
+mp    = 1.673e-24  # g (proton mass)
+
+wilms = {'H':12.0, 'He':10.99, 'C':8.38, 'N':7.88, 'O':8.69, 'Ne':7.94,
+         'Na':6.16, 'Mg':7.40, 'Al':6.33, 'Si':7.27, 'P':5.42, 'S':7.09,
+         'Cl':5.12, 'Ar':6.41, 'Ca':6.20, 'Ti':4.81, 'Cr':5.51, 'Mn':5.34,
+         'Fe':7.43, 'Co':4.92, 'Ni':6.05}  # 12 + log A_z
+
+# Fraction of elements still in gas form
+wilms_1mbeta = {'H':1.0, 'He':1.0, 'C':0.5, 'N':1.0, 'O':0.6, 'Ne':1.0, 'Na':0.25,
+                'Mg':0.2, 'Al':0.02, 'Si':0.1, 'P':0.6, 'S':0.6, 'Cl':0.5, 'Ar':1.0,
+                'Ca':0.003, 'Ti':0.002, 'Cr':0.03, 'Mn':0.07, 'Fe':0.3, 'Co':0.05,
+                'Ni':0.04}
+
+class Mineral(object):
+    """
+    | Use a dictionary to define the composition.
+    | e.g. Olivines of pure MgFe^{2+}SiO_4 composition would be
+    | olivine_halfMg = Mineral( {'Mg':1.0, 'Fe':1.0, 'Si':1.0, 'O':4.0} )
+    | self.composition : dictionary containing elements and their weights
+    |
+    | @property
+    | self._weight_amu : amu weight of unit crystal
+    | self.weight_g    : g weight of unit crystal
+    """
+    def __init__(self, comp):
+        self.composition = comp
+
+    @property
+    def weight_amu(self):
+        result = 0.0
+        for atom in self.composition.keys():
+            result += self.composition[atom] * amu[atom]
+        return result
+
+    @property
+    def weight_g(self):
+        return self.weight_amu * amu_g
+
+def calc_mass_conversion(elem, mineral):
+    """
+    | Returns the number of atoms per gram of a particular mineral object
+    | Useful for converting mass column to a number density column for an element
+    """
+    assert type(mineral) == Mineral
+    assert type(elem) == str
+    return mineral.composition[elem] / mineral.weight_g  # g^{-1}
+
+
+def calc_element_column(NH, fmineral, atom, mineral, d2g=0.009):
+    """
+    Calculate the column density of an element for a particular NH value,
+    assuming a dust-to-gas ratio (d2g) and the fraction of dust in that
+    particular mineral species (fmineral)
+    """
+    dust_mass = NH * mp * d2g * fmineral  # g cm^{-2}
+    print('Dust mass = %.3e g cm^-2' % (dust_mass))
+    return calc_mass_conversion(atom, mineral) * dust_mass  # cm^{-2}
+
+
+def get_ISM_abund(elem, abund_table=wilms):
+    """
+    Given an abundance table, calculate the number per H atom of a
+    given element in any ISM form
+    """
+    assert type(elem) == str
+    assert type(abund_table) == dict
+    return np.power(10.0, abund_table[elem] - 12.0)  # number per H atom
+
+def get_dust_abund(elem, abund_table=wilms, gas_ratio=wilms_1mbeta):
+    """
+    Given an abundance table (dict) and a table of gas ratios (dict),
+    calculate the number per H atom of a given ISM element in *solid* form
+    """
+    assert type(elem) == str
+    assert type(abund_table) == dict
+    assert type(gas_ratio) == dict
+    return get_ISM_abund(elem, abund_table) * (1.0 - gas_ratio[elem])  # number per H atom

xdust/graindist/graindist.py

@@ -0,0 +1,190 @@
+import numpy as np
+from . import sizedist
+from . import composition
+from . import shape as sh
+
+MD_DEFAULT = 1.e-4  # g cm^-2
+RHO        = 3.0    # g cm^-3
+AMAX       = 0.3  # um
+
+ALLOWED_SIZES  = ['Grain','Powerlaw','ExpCutoff','Astrodust','WD01']
+ALLOWED_COMPS  = ['Drude', 'Silicate', 'Graphite']
+SHAPES = {'Sphere':sh.Sphere()}
+
+__all__ = ['GrainDist']
+
+class GrainDist(object):
+    """
+    Graindist ties together the size distribution (which has no set column density) 
+    and composition (which contains optical constants and density) and anchors them
+    with dust mass density and a series of convenience functions to get at some of the
+    frequently needed information.
+
+    Parameters
+    ----------
+    dtype : str or xdust.graindist.sizedist object
+        Grain radius distribution. String options: ``'Grain'``, ``'Powerlaw'``,
+        ``'ExpCutoff'``, ``'Astrodust'``, ``'WD01'``.
+
+    cmtype : str or xdust.graindist.composition object
+        Optical constants and compound density. String options: ``'Drude'``,
+        ``'Silicate'``, ``'Graphite'``.
+
+    shape : str
+        Grain shape. ``'Sphere'`` is the only supported option.
+
+    md : float
+        Dust mass column [g cm^-2].
+
+    rho : float, optional
+        If provided, passed to the ``rho`` keyword of the composition object.
+
+    **kwargs
+        Extra inputs passed to ``sizedist.__init__``.
+    
+    Attributes
+    ----------
+    size : :ref:`sizedist` object
+        Grain size distribution.
+
+    comp : :ref:`composition` object
+        Optical constants and material density.
+
+    shape : :ref:`shape` object
+        Grain shape object.
+
+    md : float
+        Dust mass column density [g cm^-2].
+    """
+    def __init__(self, dtype, cmtype, shape='Sphere', md=MD_DEFAULT, rho=None, **kwargs):
+        self.md = md
+
+        if isinstance(dtype, str):
+            self._assign_sizedist_from_string(dtype, **kwargs)
+        else:
+            self.size = dtype
+
+        if isinstance(cmtype, str):
+            self._assign_comp_from_string(cmtype, rho)
+        else:
+            self.comp = cmtype
+
+        if isinstance(shape, str):
+            self._assign_shape_from_string(shape)
+        else:
+            self.shape = shape
+
+    @property
+    def a(self):
+        """
+        Grain radius grid
+
+        Returns
+        -------
+        astropy.units.Quantity
+        """
+        return self.size.a
+
+    @property
+    def ndens(self):
+        """
+        Number column density of dust grains as a function of radius [cm^-2 um^-1], using the dust mass column density in ``self.md`` and the grain material density in ``self.comp.rho``.
+        
+        Returns
+        -------
+        numpy.ndarray
+        """
+        return self.size.ndens(self.md, rho=self.comp.rho, shape=self.shape)
+
+    @property
+    def mdens(self):
+        """
+        Mass column density of dust grains as a function of radius [g cm^-2 um^-1], using the dust mass column density in ``self.md`` and the grain material density in ``self.comp.rho``.
+
+        Returns
+        -------
+        numpy.ndarray
+        """
+        mg = self.shape.vol(self.a) * self.comp.rho  # mass of each dust grain [g]
+        return self.ndens * mg
+
+    @property
+    def rho(self):
+        """
+        Grain material density [g cm^-3]
+
+        Returns
+        -------
+        float
+        """
+        return self.comp.rho
+
+    @property
+    def cgeo(self):
+        """
+        Geometric cross section of the grains [float, cm^2].
+
+        Returns
+        -------
+        numpy.ndarray    
+        """
+        return self.shape.cgeo(self.a)
+
+    @property
+    def vol(self):
+        """
+        Volume of the grains [float, cm^3].
+        
+        Returns
+        -------
+        numpy.ndarray
+        """
+        return self.shape.vol(self.a)
+
+    def plot(self, ax, **kwargs):
+        """
+        Plots the grain size distribution on a given matplotlib axis        
+
+        Parameters
+        ----------
+        ax : matplotlib.axes.Axes
+            Axes on which to plot the grain size distribution
+        """
+        ax.plot(self.a.to('micron').value, self.ndens * np.power(self.a.to('micron').value, 4), **kwargs)
+        ax.set_xlabel("Radius (micron)")
+        ax.set_ylabel("$(dn/da) a^4$ (cm$^{-2}$ um$^{3}$)")
+        ax.set_xscale('log')
+        ax.set_yscale('log')
+        return
+
+    def _assign_sizedist_from_string(self, dtype, **kwargs):
+        assert dtype in ALLOWED_SIZES
+        if dtype == 'Grain':
+            self.size = sizedist.Grain(**kwargs)
+        if dtype == 'Powerlaw':
+            self.size = sizedist.Powerlaw(**kwargs)
+        if dtype == 'ExpCutoff':
+            self.size = sizedist.ExpCutoff(**kwargs)
+        if dtype == 'Astrodust':
+            self.size = sizedist.Astrodust(**kwargs)
+        if dtype == 'WD01':
+            self.size = sizedist.WD01(**kwargs)
+        return
+
+    def _assign_comp_from_string(self, cmtype, rho):
+        assert cmtype in ALLOWED_COMPS
+        if cmtype == 'Drude':
+            if rho is not None: self.comp = composition.CmDrude(rho=rho)
+            else: self.comp = composition.CmDrude()
+        if cmtype == 'Silicate':
+            if rho is not None: self.comp = composition.CmSilicate(rho=rho)
+            else: self.comp = composition.CmSilicate()
+        if cmtype == 'Graphite':
+            if rho is not None: self.comp = composition.CmGraphite(rho=rho)
+            else: self.comp = composition.CmGraphite()
+        return
+
+    def _assign_shape_from_string(self, shape):
+        assert shape in SHAPES.keys()
+        self.shape = SHAPES[shape]
+        return

xdust/graindist/shape/__init__.py

@@ -0,0 +1,42 @@
+
+class Shape:
+    """
+    Abstract class for grain shape.
+    """
+    def __init__(self):
+        self.shape = 'Undefined'
+    
+    def vol(self, a):
+        """
+        Volume of the grain as a function of grain size.
+
+        Parameters
+        ----------
+        a : astropy.units.Quantity or float
+            Grain size; plain floats are assumed to be in microns.
+
+        Returns
+        -------
+        numpy.ndarray
+            Volume of the grain [cm^-3]
+        """
+        raise NotImplementedError("Subclasses must implement this method.")
+
+    def cgeo(self, a):
+        """
+        Geometric cross-section of the grain as a function of grain size.
+
+        Parameters
+        ----------
+        a : astropy.units.Quantity or float
+            Grain size; plain floats are assumed to be in microns.
+
+        Returns
+        -------
+        float or numpy.ndarray
+            Geometric cross-section of the grain [cm^2]
+        """
+        raise NotImplementedError("Subclasses must implement this method.")
+
+
+from .sphere import Sphere