xdust 1.0__tar.gz

xdust-1.0/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2017, Lia Corrales
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

xdust-1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: xdust
+Version: 1.0
+Summary: Library of dust scattering codes
+Author-email: Lia Corrales <liac@umich.edu>
+License: BSD 2-clause
+Project-URL: Homepage, https://github.com/eblur/xdust
+Project-URL: Documentation, https://eblur.github.io/xdust
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: astropy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7.0; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
+Requires-Dist: sphinx-autobuild; extra == "docs"
+Requires-Dist: myst-nb; extra == "docs"
+Dynamic: license-file
+
+# Xdust
+
+
+*Previously eblur/newdust* 
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7500048.svg)](https://doi.org/10.5281/zenodo.7500048) 
+
+This package calculates extinction curves and small-angle scattering halos from a user-defined dust grain size distribution. It calculates scattering and absorption from first principles (optical constants of the material, Mie or Rayleigh-Gans scattering).
+
+**Updated 2026.06** to by installable via PyPI and documented with Sphinx
+
+**Documentation:** https://eblur.github.io/xdust
+
+## Installation
+
+### Typical installation
+
+```
+pip install xdust
+```
+
+### For developers
+
+If you need to stay up to date with development versions of xdust, use:
+
+```
+git clone https://github.com/eblur/xdust.git
+
+cd xdust
+
+pip install -e .
+```
+
+## To invoke:
+
+```
+import xdust
+```
+
+## How to use:
+
+See the jupyter notebooks in **examples/** 
+for examples of setting up grain populations and modeling scattering halos from Galactic dust.

xdust-1.0/README.md

@@ -0,0 +1,43 @@
+# Xdust
+
+
+*Previously eblur/newdust* 
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7500048.svg)](https://doi.org/10.5281/zenodo.7500048) 
+
+This package calculates extinction curves and small-angle scattering halos from a user-defined dust grain size distribution. It calculates scattering and absorption from first principles (optical constants of the material, Mie or Rayleigh-Gans scattering).
+
+**Updated 2026.06** to by installable via PyPI and documented with Sphinx
+
+**Documentation:** https://eblur.github.io/xdust
+
+## Installation
+
+### Typical installation
+
+```
+pip install xdust
+```
+
+### For developers
+
+If you need to stay up to date with development versions of xdust, use:
+
+```
+git clone https://github.com/eblur/xdust.git
+
+cd xdust
+
+pip install -e .
+```
+
+## To invoke:
+
+```
+import xdust
+```
+
+## How to use:
+
+See the jupyter notebooks in **examples/** 
+for examples of setting up grain populations and modeling scattering halos from Galactic dust.

xdust-1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xdust"
+version = "1.0"
+description = "Library of dust scattering codes"
+authors = [
+    { name = "Lia Corrales", email = "liac@umich.edu" }
+]
+readme = "README.md"
+license = { text = "BSD 2-clause" }
+requires-python = ">=3.7"
+dependencies = [
+    "numpy",
+    "astropy",
+    "scipy",
+    "matplotlib"
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+docs = [
+    "sphinx>=7.0",
+    "furo",
+    "sphinx-autodoc-typehints",
+    "sphinx-autobuild",
+    "myst-nb"
+]
+
+[project.urls]
+Homepage = "https://github.com/eblur/xdust"
+Documentation = "https://eblur.github.io/xdust"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+xdust = [
+    "graindist/tables/*",
+    "scatteringmodel/tables/*",
+]

xdust-1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xdust-1.0/setup.py

@@ -0,0 +1,5 @@
+
+#! /usr/bin/env python
+# Configuration has moved to pyproject.toml
+from setuptools import setup
+setup()

xdust-1.0/src/xdust/__init__.py

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

xdust-1.0/src/xdust/graindist/__init__.py

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

xdust-1.0/src/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-1.0/src/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-1.0/src/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-1.0/src/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-1.0/src/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