metablate 0.1.0__py3-none-any.whl

metablate/models/dimant_oppenheim_2017.py

@@ -0,0 +1,293 @@
+import ctypes
+import numpy as np
+import scipy.special as scs
+import scipy.integrate as sci
+import scipy.constants as consts
+from tqdm import tqdm
+import multiprocessing as mp
+
+
+def ablated_thermal_speed_bronshten_1983(meteoroid_surface_temperature, meteoroid_molecular_mass):
+    return np.sqrt(
+        3 * consts.R * meteoroid_surface_temperature / (meteoroid_molecular_mass * consts.N_A)
+    )
+
+
+def plasma_frequency(electron_density):
+    return np.sqrt(electron_density * consts.e**2 / (consts.epsilon_0 * consts.m_e)) / (2 * np.pi)
+
+
+def critical_plasma_density(critical_plasma_frequency):
+    return (
+        (critical_plasma_frequency * 2 * np.pi) ** 2 * consts.epsilon_0 * consts.m_e / (consts.e**2)
+    )
+
+
+def mean_free_path(
+    ablated_thermal_speed,
+    total_atmospheric_number_density,
+    collisional_cross_section,
+    meteoroid_velocity,
+):
+    return ablated_thermal_speed / (
+        total_atmospheric_number_density * collisional_cross_section * meteoroid_velocity
+    )
+
+
+def collisional_cross_section_bronshten_1983(relative_velocity):
+    vrel = relative_velocity * 1e-3  # requires km/s
+    return 5.61e-19 * vrel ** (-0.8)
+
+
+def ionization_probability_Na_vondrak_2008(relative_velocity):
+    vrel = relative_velocity * 1e-3  # requires km/s
+    return 0.933 * (vrel - 8.86) ** 2 * vrel ** (-1.94)
+
+
+def _worker(
+    inds, tind, Func3_1, Func3_2, low_lim, up_lim, Rlam23, costh, sinth, pbar, quad_abs_tol
+):
+    if pbar:
+        tqdm_bar = tqdm(
+            desc=f"computing electron density process {tind}",
+            total=len(inds),
+            position=tind,
+        )
+    f31 = np.empty(inds.shape, dtype=costh.dtype)
+    f32 = np.empty(inds.shape, dtype=costh.dtype)
+    for lind, ind in enumerate(inds):
+        f31[lind] = do_int_1_quad(low_lim[ind], up_lim[ind], Rlam23[ind], costh[ind], quad_abs_tol)
+        f32[lind] = do_int_2_quad(
+            low_lim[ind], up_lim[ind], Rlam23[ind], costh[ind], sinth[ind], quad_abs_tol
+        )
+        if pbar:
+            tqdm_bar.update(1)
+    with Func3_1.get_lock():
+        shared_f31 = np.ndarray(costh.shape, dtype=np.float64, buffer=Func3_1.get_obj())
+        shared_f31[inds] = f31
+    with Func3_2.get_lock():
+        shared_f32 = np.ndarray(costh.shape, dtype=np.float64, buffer=Func3_2.get_obj())
+        shared_f32[inds] = f32
+    if pbar:
+        tqdm_bar.close()
+
+
+def _do_integral_1(ksi, rlam23, cth):
+    return (
+        np.sqrt(1 + 2 * rlam23 * ksi ** (2 / 3) / np.pi)
+        * np.exp(-3 * rlam23 * ksi ** (2 / 3) / 2)
+        * np.sqrt((ksi**2 - cth**2) / (1 - ksi**2))
+    )
+
+
+def _do_integral_2(ksi, rlam23, cth, sth):
+    return (
+        np.sqrt(1 + 2 * rlam23 * ksi ** (2 / 3) / np.pi)
+        * np.exp(-3 * rlam23 * ksi ** (2 / 3) / 2)
+        * np.arcsin(np.sqrt(1 - ksi**2) * np.abs(cth) / (ksi * np.abs(sth)))
+    )
+
+
+def do_int_1_quad(a, b, rlam23, cth, quad_abs_tol):
+    int1 = sci.quad(
+        _do_integral_1,
+        a,
+        b,
+        args=(rlam23, cth),
+        epsrel=0,
+        epsabs=quad_abs_tol,
+    )
+    return int1[0]
+
+
+def do_int_2_quad(a, b, rlam23, cth, sth, quad_abs_tol):
+    int2 = sci.quad(
+        _do_integral_2,
+        a,
+        b,
+        args=(rlam23, cth, sth),
+        epsrel=0,
+        epsabs=quad_abs_tol,
+    )
+    return int2[0]
+
+
+def plasma_distribution_morphology(
+    x_grid,
+    y_grid,
+    quad_abs_tol=1e-7,
+    upper_limit_delta=1e-6,
+    threads=None,
+    pbar=True,
+):
+    """The plasma distribution morphology component of the Dimant and Oppenheim model, that is
+    scaled by mean free path and independent of meteor parameters.
+
+    grid is in units of mean free path
+    """
+    # Generate density distribution
+    # Solve for a 2D plane
+    [Xlam, Ylam] = np.meshgrid(x_grid, y_grid)
+
+    Rlam = np.sqrt(Xlam**2 + Ylam**2)
+    Rlam[Rlam == 0] = np.nan
+
+    costh = Xlam / Rlam
+    sinth = Ylam / Rlam
+    Rlam23 = Rlam ** (2 / 3)
+
+    Func1 = np.sqrt(2 * np.pi / 3) / Rlam * scs.erf(
+        np.sqrt(3 / 2) * Rlam ** (1 / 3) * np.abs(costh) ** (1 / 3)
+    ) - np.exp(-3 / 2 * Rlam23 * np.abs(costh) ** (2 / 3)) * (
+        (4 - np.pi)
+        * np.abs(costh)
+        / (2 * np.sqrt((1 + (4 - np.pi) ** 2 * Rlam23 * np.abs(costh) ** (2 / 3)) / (2 * np.pi)))
+        + 2 * np.abs(costh) ** (1 / 3) / Rlam23
+    )
+
+    Func2 = np.sqrt(2 * np.pi / 3) / Rlam * scs.erf(np.sqrt(3 * Rlam23 / 2)) - (
+        1 + 2 / Rlam23
+    ) * np.exp(-3 * Rlam23 / 2)
+
+    orig_shape = costh.shape
+    new_shape = (costh.size,)
+    costh = costh.reshape(new_shape)
+    sinth = sinth.reshape(new_shape)
+    Rlam23 = Rlam23.reshape(new_shape)
+    low_lim = np.abs(costh)  # Lower limit of integration |cosθ|
+    up_lim = np.full_like(
+        costh, 1 - upper_limit_delta
+    )  # Upper limit of integration 1 (avoid singularity at exactly 1)
+
+    # todo: hack to make sure integration limits are sane
+    low_lim[low_lim > up_lim] = up_lim[low_lim > up_lim] - upper_limit_delta
+
+    # TODO: skip problematic points in the calc
+    if threads is None:
+        if pbar:
+            tqdm_bar = tqdm(desc="computing electron density", total=len(costh))
+        Func3_1 = np.empty_like(costh)
+        Func3_2 = np.empty_like(costh)
+        for ind in range(len(costh)):
+            Func3_1[ind] = do_int_1_quad(
+                low_lim[ind],
+                up_lim[ind],
+                Rlam23[ind],
+                costh[ind],
+                quad_abs_tol,
+            )
+            Func3_2[ind] = do_int_2_quad(
+                low_lim[ind],
+                up_lim[ind],
+                Rlam23[ind],
+                costh[ind],
+                sinth[ind],
+                quad_abs_tol,
+            )
+            if pbar:
+                tqdm_bar.update(1)
+        if pbar:
+            tqdm_bar.close()
+    else:
+        th = []
+        chunks = np.array_split(np.arange(len(costh)), threads)
+
+        f31 = mp.Array(ctypes.c_double, costh.size)
+        f32 = mp.Array(ctypes.c_double, costh.size)
+        for tind, chunk in enumerate(chunks):
+            t = mp.Process(
+                target=_worker,
+                args=(
+                    chunk,
+                    tind,
+                    f31,
+                    f32,
+                    low_lim,
+                    up_lim,
+                    Rlam23,
+                    costh,
+                    sinth,
+                    pbar,
+                    quad_abs_tol,
+                ),
+            )
+            th.append(t)
+            t.start()
+
+        for t in th:
+            t.join()
+        print("\n" * threads)
+        Func3_1 = np.ndarray(costh.shape, dtype=np.float64, buffer=f31.get_obj())
+        Func3_2 = np.ndarray(costh.shape, dtype=np.float64, buffer=f32.get_obj())
+    Func3_1 = Func3_1.reshape(orig_shape)
+    Func3_2 = Func3_2.reshape(orig_shape)
+
+    costh = costh.reshape(orig_shape)
+    sinth = sinth.reshape(orig_shape)
+
+    t1 = np.abs(costh) * Func1
+    t2 = costh * Func2
+    t3 = np.abs(costh) * Func3_2 + Func3_1
+    t3[np.isnan(t3)] = 0
+
+    ne_morph = np.abs(t1 + t2 + t3)
+
+    # todo: this is to fix some numerical shenanigans, can probably be solved better
+    zero_point = np.argmin(np.abs(y_grid))
+    if y_grid[zero_point] < 1e-3:
+        ne_morph[zero_point, :] = (ne_morph[zero_point - 1, :] + ne_morph[zero_point + 1, :]) / 2
+
+    return Xlam, Ylam, Rlam, ne_morph
+
+
+def plasma_distribution(
+    total_atmospheric_number_density,
+    meteoroid_velocity,
+    meteoroid_radius,
+    plasma_source_density,
+    collisional_cross_section,
+    ionization_probability,
+    base_plasma_distribution_function,
+    R_lambda,
+    ablated_thermal_speed=951,
+    atmospheric_species_mass=4.7e-26,
+    ablated_species_mass=3.8e-26,
+):
+    """Calculate meteor head plasma distribution using model from Dimant and
+    Oppenheim 2017
+
+    Originally developed by Tarnecki, Liane et al. 20 June 2020
+    Code available at https://zenodo.org/records/4723667
+    Paper available at https://doi.org/10.1029/2021JA029525
+    Ported to Python by Daniel Kastinen 2025
+
+    ablated_thermal_speed = 951  #thermal speed of ablated particles, m/s
+    # Set meteoroid and atmospheric characteristics
+    # atmospheric_species_mass = 4.7e-26  #atmospheric species mass (N2), kg
+    # ablated_species_mass = 3.8e-26  #ablated species mass (Na), kg
+    """
+
+    # mean free path
+    lamT = ablated_thermal_speed / (
+        total_atmospheric_number_density * collisional_cross_section * meteoroid_velocity
+    )
+
+    # Calculate the ionizing cross section Gion(meteoroid_velocity)
+    Gcoll = collisional_cross_section / (4 * np.pi)  # net differential cross section
+    Gion = Gcoll * ionization_probability
+
+    coeff_const = (
+        8
+        * np.pi
+        * meteoroid_radius**2
+        * plasma_source_density
+        * total_atmospheric_number_density
+        / np.sqrt(3)
+        * (1 + ablated_species_mass / atmospheric_species_mass)
+        * Gion
+    )  # Density coefficient
+
+    coeff = coeff_const / (R_lambda * lamT)
+
+    ne2D = coeff * base_plasma_distribution_function
+    return ne2D

metablate/models/kero_szasz_2008.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python
+
+"""Model implemented in:
+
+Kero, J., Szasz, C., Pellinen-Wannberg, A., Wannberg, G., Westman, A., and Meisel, D. D. (2008). 
+Determination of meteoroid physical properties from tristatic radar observations.
+Annales Geophysicae
+"""
+
+import logging
+from typing import Union
+import numpy as np
+import scipy
+from scipy import constants
+import xarray
+
+from ..ode import ScipyODESolve
+from .. import physics
+from .. import coordinates
+from ..atmosphere import AtmPymsis, AtmMSISE00
+
+logger = logging.getLogger(__name__)
+
+
+class KeroSzasz2008(ScipyODESolve):
+    """Ablation model
+
+    Keyword arguments:
+
+    - temperature0 = 290 [K]: Meteoroid temperature at starting height
+    - shape_factor = 1.21 [1]: Shape is assumed to be a sphere.
+    - emissivity = 0.9 [1]: Hill et al.; Love & Brownlee: 1; (metal oxides)
+    - sputtering = True [bool]: If sputtering is used in mass loss calculation.
+    - Gamma = None [1]: Drag coefficient, if :code:`None` it is dynamically
+        calculated assuming a transition from (and including) free molecular
+        flow to a (and not including) shock regime. Otherwise assumed a
+        constant with the given value.
+    - Lambda = None [1]: Heat transfer coefficient, if :code:`None` it is
+        dynamically calculated assuming a transition from (and including)
+        free molecular flow to a (and not including) shock regime.
+        Otherwise assumed a constant with the given value.
+
+    """
+
+    DEFAULT_CONFIG = {
+        "options": {
+            "temperature0": 290,
+            "shape_factor": 1.21,
+            "emissivity": 0.9,
+            "sputtering": False,
+            "Gamma": None,
+            "Lambda": None,
+            "integral_resolution": 100,
+        },
+        "atmosphere": {
+            "f107": None,
+            "f107s": None,
+            "version": 2.1,
+        },
+        "integrate": {
+            "minimum_mass_kg": 1e-11,
+            "max_step_size_sec": 1e-1,
+            "max_time_sec": 100.0,
+            "method": "RK45",
+        },
+        "method_options": {},
+    }
+
+    def __init__(self, atmosphere: Union[AtmPymsis, AtmMSISE00], *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._G = constants.G
+        self._M = 5.9742e24  # [kg] mass of earth
+        self.atmosphere = atmosphere
+
+    def rhs(
+        self,
+        t,
+        mass,
+        y,
+        material_data,
+        Lambda,
+        Gamma,
+        epoch,
+        reference_ecef,
+        v_dir_ecef,
+    ):
+        """The right hand side of the differential equation to be integrated, i.e:
+
+        .. math::
+
+            \\frac{\\mathrm{d}v}{\\mathrm{d}t} = \\\\
+            \\\\
+            \\frac{\\mathrm{d}m}{\\mathrm{d}t} = \\\\
+            \\\\
+            \\frac{\\mathrm{d}s}{\\mathrm{d}t} = \\\\
+            \\\\
+            \\frac{\\mathrm{d}T}{\\mathrm{d}t} = 
+
+
+        The numpy vector is structured as follows (numbers indicating index):
+
+            0. dvdt
+            1. dmdt
+            2. dsdt
+            3. dTdt
+
+        """
+        vel, s, T = y
+
+        # meteoroid height above earth surface
+        traj = reference_ecef - v_dir_ecef * s
+        lat, lon, alt = coordinates.ecef2geodetic(*traj.tolist())
+
+        ecef = coordinates.geodetic2ecef(lat, lon, alt)
+        r = np.linalg.norm(ecef)
+
+        # logger.debug(f'Position: {ecef*1e-3} km')
+        # logger.debug(f'lat = {lat}, lon = {lon}, {alt*1e-3} km')
+
+        # logger.debug(f't0 + {t} s: ')
+        # logger.debug(f'vel = {vel*1e-3} km/s, traj-s = {s*1e-3} km, mass = {mass} kg, temp = {T} K')
+        # logger.debug(f'altitude = {alt*1e-3} km')
+
+        f107 = self.config.get("atmosphere", "f107")
+        if f107 is not None:
+            f107 = float(f107)
+        f107s = self.config.get("atmosphere", "f107s")
+        if f107s is not None:
+            f107s = float(f107s)
+
+        atm = self.atmosphere.density(
+            time=epoch + np.timedelta64(int(t * 1e6), "us"),
+            lat=lat,
+            lon=lon,
+            alt=alt,
+            f107=f107,
+            f107s=f107s,
+            mass_densities=False,
+            version=self.config.getfloat("atmosphere", "version"),
+        )
+
+        rho_tot = atm["Total"].values.squeeze()
+        N_rho_tot = rho_tot / self.atmosphere.mean_mass
+
+        if self.config.getboolean("options", "sputtering"):
+            dmdt_s = physics.sputtering.sputtering(
+                mass=mass,
+                velocity=vel,
+                material_data=material_data,
+                density=atm,
+            )
+        else:
+            dmdt_s = 0.0
+
+        dmdt_a = physics.thermal_ablation.thermal_ablation_hill_et_al_2005(
+            mass=mass,
+            temperature=T,
+            material_data=material_data,
+            shape_factor=self.config.getfloat("options", "shape_factor"),
+        )
+
+        # logger.debug(f'dmdt sputtering: {dmdt_s} kg/s')
+        # logger.debug(f'dmdt ablation  : {dmdt_a} kg/s')
+
+        if Lambda is None:
+            Lambda = physics.thermal_ablation.heat_transfer_bronshten_1983(
+                mass=mass,
+                velocity=vel,
+                temperature=T,
+                material_data=material_data,
+                atm_total_number_density=N_rho_tot,
+                mass_loss_thermal_ablation=dmdt_a,
+                atm_mean_mass=self.atmosphere.mean_mass,
+                res=self.config.getint("options", "integral_resolution"),
+            )
+
+        if Gamma is None:
+            Gamma = physics.thermal_ablation.drag_coefficient_bronshten_1983(
+                mass=mass,
+                velocity=vel,
+                temperature=T,
+                material_data=material_data,
+                atm_total_number_density=N_rho_tot,
+                atm_mean_mass=self.atmosphere.mean_mass,
+                res=self.config.getint("options", "integral_resolution"),
+            )
+
+        # -- Differential equation for the velocity to solve
+        dvdt_d = (
+            -Gamma
+            * self.config.getfloat("options", "shape_factor")
+            * rho_tot
+            * vel**2
+            / (mass ** (1.0 / 3.0) * material_data["rho_m"] ** (2.0 / 3.0))
+        )  # [m/s2] drag equation (because of conservation of linear momentum):
+        # decelearation=Drag_coeff*shape_factor*atm_dens*vel/(mass^1/2 * meteoroid_dens^2/3)
+        dvdt_g = self._G * self._M / (r**2)  # [m/s2] acceleration due to earth gravitaion
+        dvdt = dvdt_d + dvdt_g
+
+        # -- Differential equation for the height to solve
+        dsdt = -vel  # range from the common volume along the meteoroid trajectory
+
+        dTdt = physics.thermal_ablation.temperature_rate_hill_et_al_2005(
+            mass=mass,
+            velocity=vel,
+            temperature=T,
+            material_data=material_data,
+            shape_factor=self.config.getfloat("options", "shape_factor"),
+            atm_total_mass_density=rho_tot,
+            mass_loss_thermal_ablation=-dmdt_a,
+            Lambda=Lambda,
+            atm_temperature=self.config.getfloat("options", "temperature0"),
+            emissivity=self.config.getfloat("options", "emissivity"),
+        )
+
+        dmdt = dmdt_a + dmdt_s  # total mass loss
+
+        ret = np.array([dmdt, dvdt, dsdt, dTdt], dtype=np.float64)
+
+        # logging.debug(
+        #   f"DERIVS: vel = {dvdt*1e-3} km/s^2, traj-s = {dsdt*1e-3}"
+        #   f"km/s, mass = {dmdt} kg/s, temp = {dTdt} K/s"
+        # )
+
+        return ret
+
+    def run(
+        self,
+        velocity0,
+        mass0,
+        altitude0,
+        zenith_ang,
+        azimuth_ang,
+        material_data,
+        time,
+        lat,
+        lon,
+        alt,
+    ):
+        """Runs the ablation model.
+
+        Parameters
+        ----------
+        velocity0 : float or numpy.ndarray
+            Meteoroid initial velocity [m/s]
+        mass0 : float or numpy.ndarray
+            Meteoroid initial mass [kg]
+        altitude0 : float or numpy.ndarray
+            Meteoroid initial altitude [m]
+        zenith_ang : float or numpy.ndarray
+            Zenith angle of the trajectory (-velocity vector) w.r.t reference point [deg]
+        azimuth_ang : float or numpy.ndarray
+            Azimuthal angle east of north of the trajectory (-velocity vector) w.r.t reference point [deg]
+        material_data : dict
+            Meteoroid material data, see [`material_data`][ablate.functions.material.material_data].
+        lat : float or numpy.ndarray
+            Geographic latitude in degrees of reference point on the meteoroid trajectory
+        lon : float or numpy.ndarray
+            Geographic longitude in degrees of reference point on the meteoroid trajectory
+        alt : float or numpy.ndarray
+            Altitude above geoid in meters of reference point on the meteoroid trajectory
+
+        Returns
+        -------
+        xarray.Dataset
+            mass, velocity, position, temperature, ecef_x, ecef_y, ecef_z, altitude as variables.
+
+        Notes
+        -----
+        This function is based on calc_sput.m which was used to verify the
+        sputtering described in Rogers et al.: Mass loss due to sputtering and
+        thermal processes in meteoroid ablation,
+        Planetary and Space Science 53 p. 1341-1354 (2005).
+
+        TODO: Add additional dynamical parameters to data structure e.g.
+        lambda and gamma if they are not constant
+
+        """
+        logger.debug(f"Running {self.__class__} model")
+
+        reference_ecef = coordinates.geodetic2ecef(lat, lon, alt)
+        v_dir = -1.0 * coordinates.azel_to_cart(azimuth_ang, zenith_ang, 1.0)
+        v_dir_ecef = coordinates.enu2ecef(lat, lon, alt, *v_dir.tolist())
+
+        def s_to_geo(s):
+            traj = reference_ecef - v_dir_ecef * s
+            geo = coordinates.ecef2geodetic(*traj.tolist())
+            return geo
+
+        s0 = scipy.optimize.minimize_scalar(lambda s: np.abs(s_to_geo(s)[2] - altitude0)).x
+        t0 = self.config.getfloat("options", "temperature0")
+        y0 = np.array(
+            [mass0, velocity0, s0, t0],
+            dtype=np.float64,
+        )
+
+        Lambda = self.config.get("options", "Lambda")
+        if Lambda is not None:
+            Lambda = float(Lambda)
+        Gamma = self.config.get("options", "Gamma")
+        if Gamma is not None:
+            Gamma = float(Gamma)
+
+        ivp_result = self.integrate(
+            y0,
+            material_data,
+            Lambda,
+            Gamma,
+            time,
+            reference_ecef,
+            v_dir_ecef,
+        )
+        t = ivp_result.t
+        _data = {}
+        variables = [
+            "mass",
+            "velocity",
+            "position",
+            "temperature",
+            "ecef_x",
+            "ecef_y",
+            "ecef_z",
+            "altitude",
+        ]
+        for key in variables:
+            _data[key] = (["t"], np.empty(t.shape, dtype=np.float64))
+
+        results = xarray.Dataset(
+            _data,
+            coords={"t": t},
+            attrs={key: val for key, val in self.config.items("options")},
+        )
+
+        results["mass"][:] = ivp_result.y[0, :]
+        results["velocity"][:] = ivp_result.y[1, :]
+        results["position"][:] = ivp_result.y[2, :]
+        results["temperature"][:] = ivp_result.y[3, :]
+
+        ecef = ivp_result.y[2, :]
+        ecef = reference_ecef[:, None] - v_dir_ecef[:, None] * ecef[None, :]
+        alts = np.array([s_to_geo(_s)[2] for _s in ivp_result.y[2, :]])
+
+        results["ecef_x"][:] = ecef[0, :]
+        results["ecef_y"][:] = ecef[1, :]
+        results["ecef_z"][:] = ecef[2, :]
+        results["altitude"][:] = alts
+
+        return results