metablate 0.1.0__py3-none-any.whl

metablate/__init__.py

@@ -0,0 +1,16 @@
+'''
+# Meteoroid Ablation Models
+'''
+
+from .models import *
+
+from . import physics
+from . import models
+from . import atmosphere
+from . import material
+
+from .atmosphere import Atmosphere
+from .ablation_model import AblationModel
+from .ode import ScipyODESolve
+
+from .version import __version__

metablate/ablation_model.py

@@ -0,0 +1,40 @@
+"""The basic class structures for implementing a ablation model.
+
+"""
+
+from abc import abstractmethod
+import logging
+from configparser import ConfigParser
+from typing import Union
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class AblationModel:
+    """Base-class for ablation models
+
+    The `run` method is expected to return the results from the ablation modelling
+    """
+
+    DEFAULT_CONFIG = {}
+
+    def __init__(self, config: Union[dict, str, Path, ConfigParser]):
+        self.config = ConfigParser(allow_no_value=True)
+        self.config.read_dict(self.DEFAULT_CONFIG)
+
+        if isinstance(config, ConfigParser):
+            for section in config.sections():
+                config.read_dict({
+                    section: {key: val for key, val in config.items(section=section)}
+                })
+        elif isinstance(config, dict):
+            self.config.read_dict(config)
+        elif isinstance(config, (str, Path)):
+            self.config.read_file(config)
+        else:
+            raise TypeError(f"Unexpected config type: {type(config)}")
+
+    @abstractmethod
+    def run(self, *args, **kwargs):
+        pass

metablate/atmosphere/__init__.py

@@ -0,0 +1,8 @@
+'''
+Meteoroid Ablation Models - Atmospheric models
+===============================================
+
+'''
+from .atmosphere import Atmosphere
+from .atm_msise00 import AtmMSISE00
+from .atm_pymsis import AtmPymsis

metablate/atmosphere/atm_msise00.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+
+"""msis00
+
+"""
+import scipy.constants
+from .atmosphere import Atmosphere
+import numpy.typing as npt
+
+try:
+    import msise00
+except ImportError:
+    msise00 = None
+
+
+class AtmMSISE00(Atmosphere):
+    def __init__(self):
+        super().__init__(
+            supported_species=["He", "O", "N2", "O2", "Ar", "H", "N"],
+        )
+
+    def density(
+        self,
+        time: npt.ArrayLike,
+        lat: npt.ArrayLike,
+        lon: npt.ArrayLike,
+        alt: npt.ArrayLike,
+        f107: float = 80.0,
+        f107s: float = 80.0,
+        Ap: float = 4.0,
+        mass_densities: bool = False,
+        **kwargs
+    ):
+        """TODO: Write docstring
+
+        returns density in [m^-3]
+
+        """
+        if msise00 is None:
+            raise ImportError("msis00 is not installed")
+
+        result = msise00.run(
+            time=time,
+            altkm=alt * 1e-3,
+            glat=lat,
+            glon=lon,
+            indices=dict(
+                f107=f107,
+                f107s=f107s,
+                Ap=Ap,
+            ),
+            **kwargs
+        )
+        result["alt_km"] = result["alt_km"]*1e3
+        result = result.rename({
+            "alt_km": "alt",
+            "Tn": "Temperature",
+        })
+        result = result.transpose("time", "lon", "lat", "alt")
+        result.attrs["mass_densities"] = mass_densities
+
+        if mass_densities:
+            for symbol, s in self.species.items():
+                weight = scipy.constants.u * s.A
+                result[symbol] = result[symbol] * weight
+
+        return result

metablate/atmosphere/atm_pymsis.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+
+"""pymsis
+
+"""
+from typing import Union
+import scipy.constants
+from .atmosphere import Atmosphere
+import numpy as np
+import numpy.typing as npt
+import xarray as xr
+
+try:
+    from pymsis import msis
+except ImportError:
+    msis = None
+
+
+class AtmPymsis(Atmosphere):
+    """
+    # TODO: docstring
+
+    ndarray (ndates, nlons, nlats, nalts, 11) or (ndates, 11) | 
+    The data calculated at each grid point: 
+    | [Total mass density (kg/m3) | N2 # density (m-3), | O2 # density (m-3), | 
+    O # density (m-3), | He # density (m-3), | H # density (m-3), | 
+    Ar # density (m-3), | N # density (m-3), | 
+    Anomalous oxygen # density (m-3), | NO # density (m-3), 
+    | Temperature (K)]
+    """
+    def __init__(self):
+        super().__init__(
+            supported_species=["He", "O", "N2", "O2", "Ar", "H", "N"],
+        )
+
+    def density(
+        self,
+        time: npt.ArrayLike,
+        lat: npt.ArrayLike,
+        lon: npt.ArrayLike,
+        alt: npt.ArrayLike,
+        f107: npt.ArrayLike = None,
+        f107s: npt.ArrayLike = None,
+        aps: npt.ArrayLike = None,
+        mass_densities: bool = False,
+        version: Union[float, str] = 2.1,
+        **kwargs
+    ):
+        """TODO: Write docstring
+
+        returns density in [m^-3]
+
+        """
+        if msis is None:
+            raise ImportError("pymsis is not installed")
+
+        time = np.array(time) if not isinstance(time, np.ndarray) else time
+        lon = np.array(lon) if not isinstance(lon, np.ndarray) else lon
+        lat = np.array(lat) if not isinstance(lat, np.ndarray) else lat
+        alt = np.array(alt) if not isinstance(alt, np.ndarray) else alt
+
+        for inp in [time, lon, lat, alt]:
+            if len(inp.shape) == 0:
+                inp.shape = (1,)
+
+        result = msis.run(
+            dates=time,
+            lons=lon,
+            lats=lat,
+            alts=alt * 1e-3,
+            f107s=f107,
+            f107as=f107s,
+            aps=aps,
+            version=version,
+            **kwargs,
+        )
+        if len(result.shape) == 2:
+            result = result.reshape(result.shape[0], 1, 1, 1, result.shape[1])
+
+        result = xr.Dataset(
+            {
+                "Total": (["time", "lon", "lat", "alt"], result[:, :, :, :, 0]),
+                "N2": (["time", "lon", "lat", "alt"], result[:, :, :, :, 1]),
+                "O2": (["time", "lon", "lat", "alt"], result[:, :, :, :, 2]),
+                "O": (["time", "lon", "lat", "alt"], result[:, :, :, :, 3]),
+                "He": (["time", "lon", "lat", "alt"], result[:, :, :, :, 4]),
+                "H": (["time", "lon", "lat", "alt"], result[:, :, :, :, 5]),
+                "Ar": (["time", "lon", "lat", "alt"], result[:, :, :, :, 6]),
+                "N": (["time", "lon", "lat", "alt"], result[:, :, :, :, 7]),
+                "AnomalousO": (["time", "lon", "lat", "alt"], result[:, :, :, :, 8]),
+                "NO": (["time", "lon", "lat", "alt"], result[:, :, :, :, 9]),
+                "Temperature": (["time", "lon", "lat", "alt"], result[:, :, :, :, 10]),
+            },
+            coords={
+                "time": time,
+                "lon": lon,
+                "lat": lat,
+                "alt": alt,
+            },
+            attrs=dict(
+                f107 = f107,
+                f107s = f107s,
+                aps = aps,
+                mass_densities = mass_densities,
+                version = version,
+            )
+        )
+
+        if mass_densities:
+            for symbol, s in self.species.items():
+                weight = scipy.constants.u * s.A
+                result[symbol] = result[symbol] * weight
+
+        return result

metablate/atmosphere/atmosphere.py

@@ -0,0 +1,80 @@
+from abc import abstractmethod
+from dataclasses import dataclass
+import logging
+from copy import copy
+
+import scipy.constants as constants
+import numpy as np
+import numpy.typing as npt
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Species:
+    symbol: str
+    A: float
+    Z: float
+
+
+SPECIES = {
+    "He": Species(
+        symbol="He",
+        A=4.002602,
+        Z=2,
+    ),
+    "O": Species(
+        symbol="O",
+        A=15.999,
+        Z=8,
+    ),
+    "N2": Species(
+        symbol="N2",
+        A=14.007 * 2,
+        Z=14,
+    ),
+    "O2": Species(
+        symbol="O2",
+        A=15.999 * 2,
+        Z=16,
+    ),
+    "Ar": Species(
+        symbol="Ar",
+        A=39.948,
+        Z=18,
+    ),
+    "H": Species(
+        symbol="H",
+        A=1.0079,
+        Z=1,
+    ),
+    "N": Species(
+        symbol="N",
+        A=14.007,
+        Z=7,
+    ),
+}
+
+
+# TODO: get a a hold of other atm models to figure out how to generalize interface better
+class Atmosphere:
+    def __init__(self, supported_species):
+        self.species = {}
+        for s in supported_species:
+            if isinstance(s, Species):
+                self.species[s.symbol] = s
+            else:
+                self.species[s] = copy(SPECIES[s])
+
+        self.mean_mass = np.array([x.A for _, x in self.species.items()]).mean() * constants.u  # [kg]
+
+    @abstractmethod
+    def density(
+        self,
+        time: npt.ArrayLike,
+        lat: npt.ArrayLike,
+        lon: npt.ArrayLike,
+        alt: npt.ArrayLike,
+        **kwargs
+    ):
+        pass

metablate/coordinates.py

@@ -0,0 +1,149 @@
+"""
+# Coordinate functions
+"""
+import logging
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+# Constants defined by the World Geodetic System 1984 (WGS84)
+WGS84_a = 6378.137 * 1e3
+WGS84_b = 6356.7523142 * 1e3
+WGS84_esq = 6.69437999014 * 0.001
+WGS84_e1sq = 6.73949674228 * 0.001
+
+
+def geodetic2ecef(lat, lon, alt):
+    """Convert WGS84 geodetic coordinates to ECEF coordinates [^1].
+
+    [^1]: J. Zhu, "Conversion of Earth-centered Earth-fixed coordinates to geodetic coordinates,"
+        IEEE Transactions on Aerospace and Electronic Systems, vol. 30, pp. 957-961, 1994.
+
+    Parameters
+    ----------
+    lat : float
+        Geographic latitude [deg]
+    lon : float
+        Geographic longitude [deg]
+    alt : float
+        Geographic altitude [deg]
+
+    Returns
+    -------
+    numpy.ndarray
+        [x, y, z] in ECEF coordinates
+
+    """
+    lat, lon = np.radians(lat), np.radians(lon)
+    xi = np.sqrt(1 - WGS84_esq * np.sin(lat) ** 2)
+    x = (WGS84_a / xi + alt) * np.cos(lat) * np.cos(lon)
+    y = (WGS84_a / xi + alt) * np.cos(lat) * np.sin(lon)
+    z = (WGS84_a / xi * (1 - WGS84_esq) + alt) * np.sin(lat)
+    return np.array([x, y, z])
+
+
+def ecef2geodetic(x, y, z):
+    """Convert ECEF coordinates to WGS84 geodetic coordinates [^1].
+
+    [^1]: J. Zhu, "Conversion of Earth-centered Earth-fixed coordinates to geodetic coordinates,"
+        IEEE Transactions on Aerospace and Electronic Systems, vol. 30, pp. 957-961, 1994.
+
+    Parameters
+    ----------
+    x : float
+        Position along prime meridian [m]
+    y : float
+        Position along prime meridian + 90 degrees [m]
+    z : float
+        Position along earth rotation axis [m]
+
+    Returns
+    -------
+    numpy.ndarray
+        [lat [deg], lon [deg], alt [m]] in WGS84 geodetic coordinates
+
+    """
+    r = np.sqrt(x * x + y * y)
+    if r < 1e-9:
+        h = np.abs(z) - WGS84_b
+        lat = np.sign(z) * np.pi / 2
+        lon = 0.0
+    else:
+        Esq = WGS84_a * WGS84_a - WGS84_b * WGS84_b
+        F = 54 * WGS84_b * WGS84_b * z * z
+        G = r * r + (1 - WGS84_esq) * z * z - WGS84_esq * Esq
+        C = (WGS84_esq * WGS84_esq * F * r * r) / (np.power(G, 3))
+        S = np.cbrt(1 + C + np.sqrt(C * C + 2 * C))
+        P = F / (3 * np.power((S + 1 / S + 1), 2) * G * G)
+        Q = np.sqrt(1 + 2 * WGS84_esq * WGS84_esq * P)
+        r_0 = -(P * WGS84_esq * r) / (1 + Q) + np.sqrt(
+            0.5 * WGS84_a * WGS84_a * (1 + 1.0 / Q)
+            - P * (1 - WGS84_esq) * z * z / (Q * (1 + Q))
+            - 0.5 * P * r * r
+        )
+        U = np.sqrt(np.power((r - WGS84_esq * r_0), 2) + z * z)
+        V = np.sqrt(np.power((r - WGS84_esq * r_0), 2) + (1 - WGS84_esq) * z * z)
+        Z_0 = WGS84_b * WGS84_b * z / (WGS84_a * V)
+        h = U * (1 - WGS84_b * WGS84_b / (WGS84_a * V))
+        lat = np.arctan((z + WGS84_e1sq * Z_0) / r)
+        lon = np.arctan2(y, x)
+
+    return np.array([np.degrees(lat), np.degrees(lon), h])
+
+
+def enu2ecef(lat, lon, alt, e, n, u):
+    """NEU (north/east/up) to ECEF coordinate system conversion. Degrees are used."""
+    return ned2ecef(lat, lon, alt, n, e, -u)
+
+
+def ned2ecef(lat, lon, alt, n, e, d):
+    """NED (north/east/down) to ECEF coordinate system conversion. Degrees are used."""
+    lat, lon = np.radians(lat), np.radians(lon)
+    mx = np.array(
+        [
+            [-np.sin(lon), -np.sin(lat) * np.cos(lon), np.cos(lat) * np.cos(lon)],
+            [np.cos(lon), -np.sin(lat) * np.sin(lon), np.cos(lat) * np.sin(lon)],
+            [0, np.cos(lat), np.sin(lat)],
+        ]
+    )
+    enu = np.array([e, n, -1.0 * d])
+    res = np.dot(mx, enu)
+    return res
+
+
+def ecef2ned(lat, lon, alt, x, y, z):
+    """NED (east,north,up) from ECEF coordinate system conversion."""
+    lat, lon = np.radians(lat), np.radians(lon)
+    mx = np.array(
+        [
+            [-np.sin(lon), -np.sin(lat) * np.cos(lon), np.cos(lat) * np.cos(lon)],
+            [np.cos(lon), -np.sin(lat) * np.sin(lon), np.cos(lat) * np.sin(lon)],
+            [0, np.cos(lat), np.sin(lat)],
+        ]
+    )
+    enu = np.array([x, y, z])
+    res = np.dot(np.linalg.inv(mx), enu)
+    return res
+
+
+def cart_to_azel(vec):
+    """Convert from Cartesian coordinates to spherical in a degrees east of north and elevation fashion"""
+    x = vec[0]
+    y = vec[1]
+    z = vec[2]
+    r_ = np.sqrt(x**2 + y**2)
+    if r_ < 1e-9:
+        el = np.sign(z) * np.pi * 0.5
+        az = 0.0
+    else:
+        el = np.arctan(z / r_)
+        az = np.pi / 2 - np.arctan2(y, x)
+    return np.degrees(az), np.degrees(el), np.sqrt(x**2 + y**2 + z**2)
+
+
+def azel_to_cart(az, el, r):
+    """Convert from spherical coordinates to Cartesian in a degrees east of north and elevation fashion"""
+    _az = np.radians(az)
+    _el = np.radians(el)
+    return r * np.array([np.sin(_az) * np.cos(_el), np.cos(_az) * np.cos(_el), np.sin(_el)])

metablate/material.py

@@ -0,0 +1,155 @@
+'''
+# Meteoroid material physics
+
+List of properties:
+ - `m2`: mean atomic mass [1]
+ - `u0`: surface binding energy [eV]
+ - `k`: average atomic number [1]
+ - `CA`, CB: Clausius-Clapeyron coeff [K]
+ - `mu`: mean molecular mass of ablated vapour [kg]
+ - `k`: Botzmann constant [J/K]
+ - `rho_m`: meteoroid density [kg/m3]
+ - `c`: specific heat of meteoroid [J/(K*kg)]
+ - `L`: latent heat of fusion + vapourization [J/kg]
+
+# TODO: list references for material data
+
+[Fe SiO2 C C] mean molecular mass per target atoms corresponding
+to the different meteoroid densities, see Rogers p. 1344 values
+are from Tielens et al.
+
+Mean molecular mass of ablated vapor assuming that all products
+liberated from the meteoroid by thermal ablation were released
+in complete molecular form.
+
+'''
+from dataclasses import dataclass, asdict
+import logging
+from copy import copy
+from scipy import constants
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Material:
+    """Container for material properties
+
+    TODO: proper names for all vars
+
+List of properties:
+ - `m2`: mean atomic mass [1]
+ - `u0`: surface binding energy [eV]
+ - `k`: average atomic number [1]
+ - `CA`, CB: Clausius-Clapeyron coeff [K]
+ - `mu`: mean molecular mass of ablated vapour [kg]
+ - `k`: Botzmann constant [J/K]
+ - `rho_m`: meteoroid density [kg/m3]
+ - `c`: specific heat of meteoroid [J/(K*kg)]
+ - `L`: latent heat of fusion + vapourization [J/kg]
+    """
+    rho_m: float
+    mu: float
+    m2: float
+    CA: float
+    CB: float
+    u0: float
+    k: float
+    z2: float
+    c: float
+    L: float
+
+
+MATERIALS = {}
+
+iron = Material(
+    rho_m = 7800.0,
+    mu = 56.0*constants.u,
+    m2 = 56.0*constants.u,
+    CA = 10.6,
+    CB = 16120.,
+    u0 = 4.1,
+    k = 0.35,
+    z2 = 26,
+    c = 1200,
+    L = 6.0E6,
+)
+MATERIALS["iron"] = iron
+
+asteroidal = Material(
+    rho_m = 3300.0,
+    mu = 50.0*constants.u,
+    m2 = 20.0*constants.u,
+    CA = 10.6,
+    CB = 13500.,
+    u0 = 6.4,
+    k = 0.1,
+    z2 = 10,
+    c = 1200,
+    L = 6.0E6,
+)
+MATERIALS["asteroidal"] = asteroidal
+
+cometary = Material(
+    rho_m = 1000.0,
+    mu = 20.0*constants.u,
+    m2 = 12.0*constants.u,
+    CA = 10.6,
+    CB = 13500.,
+    u0 = 4.0,
+    k = 0.65,
+    z2 = 6,
+    c = 1200,
+    L = 6.0E6,
+)
+MATERIALS["cometary"] = cometary
+
+porous = Material(
+    rho_m = 300.0,
+    mu = 20.0*constants.u,
+    m2 = 12.0*constants.u,
+    CA = 10.6,
+    CB = 13500.,
+    u0 = 4.0,
+    k = 0.65,
+    z2 = 6,
+    c = 1200,
+    L = 6.0E6,
+)
+MATERIALS["porous"] = porous
+
+
+def available():
+    '''List currently available meteoroid materials.
+    '''
+    return list(MATERIALS.keys())
+
+
+def get(material, as_dict=True):
+    '''Returns the physical parameters of the meteoroid based on its material.
+
+    # TODO: figure out if we keep as dict or keep as material???
+
+    Parameters
+    ----------
+    material : str
+        name of material
+    as_dict : bool
+        Return data as dict instead of as a Material instance
+
+    Returns
+    -------
+    Material or dict
+        Dictionary of all available material parameters (float or None)
+    '''
+
+    _material = material.lower().strip()
+    if _material not in MATERIALS:
+        raise ValueError(
+            f'No data exists for material "{_material}"\n'
+            f'Avalible materials are: {available()}'
+        )
+    if as_dict:
+        return asdict(MATERIALS[_material])
+    else:
+        return copy(MATERIALS[_material])

metablate/models/__init__.py

@@ -0,0 +1,5 @@
+from .kero_szasz_2008 import KeroSzasz2008
+
+__all__ = [
+    'KeroSzasz2008'
+]