pa3py 1.0.0__py3-none-any.whl

pa3py/__init__.py

@@ -0,0 +1,65 @@
+"""
+PA3Py - Pebble Accretion 3 in Python
+"""
+
+__version__ = "1.0.0"
+
+from .data import load_tripodpy_hdf5, DiskData
+from .composition import CompositionModel, SimpleWaterComposition, MultiSnowlineComposition, FunctionComposition
+from .pebble_accretion import PebbleAccretionModule3
+from .snowline import generate_rsnow_array, get_rsnow_from_mdot_au, mdot_time, r_snow_time_cgs
+from .plotting import plot_hovmoller
+from .core import PA3Py
+from . import constants
+
+def easy_run(data_dir: str, embryos_au: list, m_seed_me: float = 1e-4) -> dict:
+    """
+    Ruta rápida para correr el simulador PA3Py con el modelo por defecto.
+    
+    Asume:
+      - Snowline dinámica basada en Oka et al. (2011) y Hartmann.
+      - Composición: 100% Silicatos (dentro de snowline) y 50% H2O / 50% Silicatos (fuera).
+      
+    Parámetros:
+    -----------
+    data_dir : str
+        Ruta al directorio con los HDF5 de TripodPy.
+    embryos_au : list
+        Lista con las posiciones iniciales de los embriones en AU (ej: [3.0, 5.0, 10.0]).
+    m_seed_me : float
+        Masa semilla inicial de los embriones en Masas Terrestres.
+        
+    Retorna:
+    --------
+    dict
+        Diccionario con la historia de crecimiento de cada embrión.
+    """
+    # 1. Cargar datos
+    disk = load_tripodpy_hdf5(data_dir)
+    
+    # 2. Configurar snowline y composición clásica
+    rsnow = generate_rsnow_array(disk.times)
+    comp = SimpleWaterComposition(rsnow)
+    
+    # 3. Inicializar simulador y correr
+    sim = PebbleAccretionModule3(disk, comp_model=comp)
+    results = sim.run_growth(embryos_au, M0_g=m_seed_me * sim.M_EARTH)
+    
+    # 4. Mostrar resumen automáticamente
+    sim.summary(results)
+    return results
+
+__all__ = [
+    "load_tripodpy_hdf5",
+    "DiskData",
+    "CompositionModel",
+    "SimpleWaterComposition",
+    "MultiSnowlineComposition",
+    "FunctionComposition",
+    "PebbleAccretionModule3",
+    "generate_rsnow_array",
+    "easy_run",
+    "plot_hovmoller",
+    "PA3Py",
+    "constants"
+]

pa3py/composition.py

@@ -0,0 +1,117 @@
+"""
+composition.py - Modelos de composición química.
+"""
+
+from typing import Dict, List, Optional, Callable
+import numpy as np
+from abc import ABC, abstractmethod
+
+class CompositionModel(ABC):
+    """Clase base para modelos de composición."""
+    
+    @abstractmethod
+    def get_fractions(self, r: float, t_sec: float, t_idx: int) -> Dict[str, float]:
+        """
+        Dado un radio orbital `r` (en cm), el tiempo físico `t_sec` (s), y el índice temporal `t_idx`, 
+        devuelve un diccionario con las fracciones de masa de cada elemento químico que se está acretando. 
+        Las fracciones deben sumar 1.0.
+        """
+        pass
+
+    @abstractmethod
+    def get_species(self) -> List[str]:
+        """Devuelve la lista de nombres de las especies químicas rastreadas."""
+        pass
+
+
+class SimpleWaterComposition(CompositionModel):
+    """
+    Modelo clásico PA3Py:
+    - 100% silicatos interior a la snowline.
+    - 50% silicatos, 50% H2O exterior a la snowline.
+    """
+    def __init__(self, rsnow_h2o_array: np.ndarray):
+        self.rsnow = rsnow_h2o_array
+        
+    def get_fractions(self, r: float, t_sec: float, t_idx: int) -> Dict[str, float]:
+        r_snow = float(self.rsnow[t_idx]) if not np.isnan(self.rsnow[t_idx]) else 0.0
+        
+        if r >= r_snow:
+            return {"silicates": 0.5, "H2O": 0.5}
+        else:
+            return {"silicates": 1.0, "H2O": 0.0}
+            
+    def get_species(self) -> List[str]:
+        return ["silicates", "H2O"]
+
+
+class MultiSnowlineComposition(CompositionModel):
+    """Zonas estáticas separadas por snowlines pre-calculadas."""
+    def __init__(self, snowlines: Dict[str, np.ndarray], zone_abundances: List[Dict[str, float]]):
+        self.snowline_names = list(snowlines.keys())
+        self.snowlines = snowlines
+        self.zone_abundances = zone_abundances
+        
+        if len(zone_abundances) != len(snowlines) + 1:
+            raise ValueError("Debes proveer exactamente N+1 diccionarios de abundancias para N snowlines.")
+            
+        self.species = list(set().union(*(abund.keys() for abund in self.zone_abundances)))
+
+    def get_fractions(self, r: float, t_sec: float, t_idx: int) -> Dict[str, float]:
+        zone_idx = 0
+        for name in self.snowline_names:
+            r_snow = float(self.snowlines[name][t_idx]) if not np.isnan(self.snowlines[name][t_idx]) else 0.0
+            if r >= r_snow:
+                zone_idx += 1
+            else:
+                break
+                
+        raw_fracs = self.zone_abundances[zone_idx]
+        total = sum(raw_fracs.values())
+        if total > 0:
+            return {k: v / total for k, v in raw_fracs.items()}
+        return {sp: 0.0 for sp in self.species}
+        
+    def get_species(self) -> List[str]:
+        return self.species
+
+
+class FunctionComposition(CompositionModel):
+    """Química dinámica definida por el usuario mediante una función Python."""
+    def __init__(self, user_func: Callable[[float, float], Dict[str, float]], species: Optional[List[str]] = None):
+        """
+        Parámetros:
+        -----------
+        user_func: callable
+            Función del usuario. Debe recibir `r` (en cm) y `t` (en segundos)
+            y retornar un diccionario con las fracciones, ej: {"silicates": 0.4, "H2O": 0.6}.
+        species: List[str], opcional
+            Lista explícita de las especies químicas. Si no se provee, PA3Py la deducirá
+            automáticamente ejecutando la función con un valor de prueba (r=1.0, t=0.0).
+        """
+        self.user_func = user_func
+        
+        if species is None:
+            try:
+                res_sets = [set(self.user_func(r, t).keys()) 
+                            for r in [1e11, 1e12, 1e13, 1e14, 1e15, 1e16] 
+                            for t in [0.0, 1e10, 1e12, 1e14]]
+                self.species = list(set.union(*res_sets)) if res_sets else []
+                if not self.species:
+                    raise ValueError("La función devolvió diccionarios vacíos en todos los tests.")
+            except AttributeError:
+                raise ValueError("La función debe retornar un dict (con el método .keys()).")
+            except Exception as e:
+                raise RuntimeError(f"Fallo en la auto-detección de especies: {e}\nProvee 'species' explícitamente.")
+        else:
+            self.species = species
+        
+    def get_fractions(self, r: float, t_sec: float, t_idx: int) -> Dict[str, float]:
+        raw_fracs = self.user_func(r, t_sec)
+        total = sum(raw_fracs.values())
+        if total > 0:
+            return {sp: raw_fracs.get(sp, 0.0) / total for sp in self.species}
+        return {sp: 0.0 for sp in self.species}
+
+    def get_species(self) -> List[str]:
+        return self.species

pa3py/constants.py

@@ -0,0 +1,19 @@
+"""
+Constants used for Pebble Accretion calculations in PA3Py.
+All values are in CGS units (cm, g, s).
+"""
+
+# Gravitational constant [cm^3 g^-1 s^-2]
+G = 6.6743e-8
+
+# Solar mass [g]
+M_SUN = 1.988409870698051e33
+
+# Earth mass [g]
+M_EARTH = 5.972167867791379e27
+
+# Astronomical Unit [cm]
+AU = 1.495978707e13
+
+# Julian Year [s]
+YEAR = 3.15576e7

pa3py/core.py

@@ -0,0 +1,109 @@
+"""
+core.py - Interfaz principal (Facade).
+"""
+
+from typing import List, Callable, Optional
+import h5py
+
+from .data import load_tripodpy_hdf5
+from .composition import CompositionModel, SimpleWaterComposition, FunctionComposition
+from .pebble_accretion import PebbleAccretionModule3
+from .snowline import generate_rsnow_array
+from .plotting import plot_hovmoller
+from . import constants as c
+
+class PA3Py:
+    """
+    Centraliza flujo de PA3Py: Datos HDF5, química, acreción y gráficas.
+    """
+    def __init__(self, data_dir: str, comp_model: Optional[CompositionModel] = None):
+        """
+        Inicializa la simulación y carga los datos.
+        
+        Parámetros:
+        -----------
+        data_dir : str
+            Ruta a archivos HDF5.
+        comp_model : CompositionModel, opcional
+            Modelo de composición. Por defecto: Agua simple + migración snowline.
+        """
+        self.data_dir = data_dir
+        self.disk = load_tripodpy_hdf5(data_dir)
+        self.comp = comp_model or SimpleWaterComposition(generate_rsnow_array(self.disk.times))
+        self.engine = PebbleAccretionModule3(self.disk, comp_model=self.comp)
+        
+    def set_custom_chemistry(self, user_func: Callable, species: Optional[List[str]] = None):
+        """
+        Atajo para redefinir la química con una función Python.
+        
+        Ejemplo:
+            sim.set_custom_chemistry(mi_funcion, ["silicatos", "H2O"])
+        """
+        self.comp = FunctionComposition(user_func, species)
+        self.engine = PebbleAccretionModule3(self.disk, comp_model=self.comp)
+        
+    def run_growth(self, embryos_au: list, m_seed_me: float = 1e-3) -> dict:
+        """
+        Corre la simulación de acreción para los embriones dados.
+        
+        Parámetros:
+        -----------
+        embryos_au : list
+            Lista de radios iniciales en AU (ej: [1.0, 5.0, 15.0]).
+        m_seed_me : float
+            Masa semilla en Masas Terrestres. Default: 1e-3.
+            
+        Retorna:
+        --------
+        dict
+            Resultados de la evolución de masa en el tiempo.
+        """
+        results = self.engine.run_growth(embryos_au, M0_g=m_seed_me * c.M_EARTH)
+        self.engine.summary(results)
+        return results
+
+    def plot_hovmoller(self, field: str = 'dust_Sigma', show_snowlines: bool = True, **kwargs):
+        """
+        Genera el diagrama de Hovmöller (Radio vs Tiempo).
+        field puede ser 'dust_Sigma', 'gas_Sigma', o 'epsilon'.
+        """
+        return plot_hovmoller(self.disk, field=field, show_snowlines=show_snowlines, **kwargs)
+        
+    def calculate_isolation_mass_map(self):
+        """Calcula el mapa teórico de masa de aislamiento en todo el disco."""
+        return self.engine.calculate_isolation_mass_map()
+
+    def plot_population(self, results: dict, **kwargs):
+        """
+        Grafica la población sintética de planetas (Masa Final vs Posición Inicial).
+        """
+        from .plotting import plot_population
+        M_iso_map = self.calculate_isolation_mass_map()
+        return plot_population(self.disk, results, M_iso_map=M_iso_map, **kwargs)
+
+    def save_results(self, results: dict, filename: str):
+        """Guarda tracks de crecimiento en HDF5."""
+        with h5py.File(filename, 'w') as f:
+            # Encode species como bytes para compatibilidad h5py
+            f.attrs['tracked_species'] = [s.encode('ascii') for s in self.engine.tracked_species]
+            f.attrs['M_EARTH'] = c.M_EARTH
+            
+            tracks = f.create_group('tracks')
+            for r_au, track_data in results.items():
+                dset = tracks.create_dataset(f"embryo_{r_au:.4f}_AU", data=track_data)
+                dset.attrs['r_au'] = float(r_au)
+
+    @staticmethod
+    def load_results(filename: str) -> tuple[dict, list]:
+        """Carga tracks de crecimiento desde HDF5. Retorna (results_dict, species_list)."""
+        results = {}
+        with h5py.File(filename, 'r') as f:
+            raw_species = list(f.attrs['tracked_species'])
+            tracked_species = [s.decode('ascii') if isinstance(s, bytes) else s for s in raw_species]
+            
+            tracks = f['tracks']
+            for key in tracks.keys():
+                r_au = float(tracks[key].attrs['r_au'])
+                results[r_au] = tracks[key][:]
+                
+        return results, tracked_species

pa3py/data.py

@@ -0,0 +1,122 @@
+"""
+data.py - Módulo para la carga y manejo de datos del disco protoplanetario.
+"""
+
+import os
+import glob
+import h5py
+import numpy as np
+from dataclasses import dataclass
+from typing import Dict
+from . import constants as c
+
+@dataclass
+class DiskData:
+    """Contenedor de propiedades físicas del disco (gas y polvo)."""
+    times: np.ndarray        # (Nt,) Tiempos en segundos
+    r: np.ndarray            # (Nr,) Grilla radial en cm
+    
+    # Gas: shape (Nt, Nr)
+    gas_Sigma: np.ndarray    # Densidad superficial del gas
+    gas_T: np.ndarray        # Temperatura del gas
+    gas_cs: np.ndarray       # Velocidad del sonido
+    gas_eta: np.ndarray      # Gradiente de presión
+    gas_nu: np.ndarray       # Viscosidad cinemática
+    gas_alpha: np.ndarray    # Parámetro alpha de Shakura-Sunyaev
+    gas_Hp: np.ndarray       # Escala de altura del gas
+    
+    # Dust: shape (Nt, Nr, Nd) donde Nd=5 (o Nd=1 si ya se colapsó)
+    dust_Sigma: np.ndarray   # Densidad superficial del polvo
+    dust_vr: np.ndarray      # Velocidad radial del polvo
+    dust_St: np.ndarray      # Número de Stokes
+    dust_H: np.ndarray       # Escala de altura del polvo
+    
+    # Derivados / Auxiliares
+    Omega_K: np.ndarray      # Frecuencia kepleriana local (Nt, Nr) o (Nr,)
+    M_star: float            # Masa estelar en masas solares
+    
+    # Snowlines pre-calculadas presentes en el HDF5 (Opcional, útil para fallback)
+    # Formato: {"H2O": array(Nt,)}
+    hdf5_snowlines: Dict[str, np.ndarray]
+
+    @property
+    def Nt(self):
+        return len(self.times)
+
+    @property
+    def Nr(self):
+        return len(self.r)
+
+
+def load_tripodpy_hdf5(datadir: str, M_star: float = 1.0, t_min_yr: float = 0.0) -> DiskData:
+    """Convierte archivos HDF5 de tripodpy a un objeto DiskData."""
+    
+    files = sorted(glob.glob(os.path.join(datadir, 'data*.hdf5')))
+    if not files:
+        raise FileNotFoundError(f"No HDF5 files found in {datadir}")
+
+    print(f"[load_tripodpy_hdf5] Reading {len(files)} snapshots from {datadir}...")
+    
+    times_list, OmegaK_list = [], []
+    rsnow = {'H2O': []}
+    r_grid = None
+    
+    gas_keys = ['Sigma', 'T', 'cs', 'eta', 'nu', 'alpha', 'Hp']
+    dust_keys = ['Sigma', 'v/rad', 'St', 'H']
+    gas_data = {k: [] for k in gas_keys}
+    dust_data = {k: [] for k in dust_keys}
+
+    for fpath in files:
+        with h5py.File(fpath, 'r') as f:
+            t_s = float(f['t'][()])
+            if t_s < t_min_yr * c.YEAR:
+                continue
+
+            times_list.append(t_s)
+
+            if r_grid is None:
+                r_grid = f['grid/r'][:]
+
+            # Cargar arrays
+            for k in gas_keys: gas_data[k].append(f[f'gas/{k}'][:])
+            for k in dust_keys: dust_data[k].append(f[f'dust/{k}'][:])
+
+            # OmegaK
+            if 'grid/OmegaK' in f:
+                OmegaK_list.append(f['grid/OmegaK'][:])
+
+            # Snowline dinámica de H2O original de la corrida
+            if 'dust/r_snow' in f:
+                rsnow['H2O'].append(float(f['dust/r_snow'][()]))
+            else:
+                rsnow_key = 'grid/rsnow_H2O'
+                rsnow['H2O'].append(float(f[rsnow_key][()]) if rsnow_key in f else np.nan)
+
+    times = np.array(times_list)
+    
+    # OmegaK: 2D del HDF5 o analítico 1D
+    if OmegaK_list:
+        Omega_K = np.array(OmegaK_list)
+    else:
+        Omega_K = np.sqrt(c.G * M_star * c.M_SUN / r_grid**3)
+
+    rsnow['H2O'] = np.array(rsnow['H2O'])
+
+    return DiskData(
+        times=times,
+        r=r_grid,
+        gas_Sigma=np.array(gas_data['Sigma']),
+        gas_T=np.array(gas_data['T']),
+        gas_cs=np.array(gas_data['cs']),
+        gas_eta=np.array(gas_data['eta']),
+        gas_nu=np.array(gas_data['nu']),
+        gas_alpha=np.array(gas_data['alpha']),
+        gas_Hp=np.array(gas_data['Hp']),
+        dust_Sigma=np.array(dust_data['Sigma']),
+        dust_vr=np.array(dust_data['v/rad']),
+        dust_St=np.array(dust_data['St']),
+        dust_H=np.array(dust_data['H']),
+        Omega_K=Omega_K,
+        M_star=M_star,
+        hdf5_snowlines=rsnow
+    )

pa3py/pebble_accretion.py

@@ -0,0 +1,228 @@
+"""
+PA3Py/pebble_accretion.py — Módulo de acreción de pebbles (Ormel 2017 & Drążkowska et al. 2023)
+=====================================================================================
+
+Física implementada y referencias:
+  - M_PA_onset = St * η³ * M_star             (Drążkowska et al. 2023 Eq. 3, Ormel 2017 Eq 7.11)
+  - M_hw/sh   = v_hw³ / (8 G Ω_K t_stop)      (Ormel 2017 Eq 7.9)
+  - Ṁ_2D_hw   = √(8GM t_stop v_hw) Σ_peb      (Ormel 2017 Eq 7.13 Headwind)
+  - Ṁ_2D_sh   = 2 R_H² Ω_K St^(2/3) Σ_peb     (Ormel 2017 Eq 7.13 Shear, Drążkowska et al. 2023 Eq 5)
+  - Ṁ_3D      = 2π G M t_stop ρ_peb           (Ormel 2017 Eq 7.12)
+  - Transición = Ṁ_2D * b_col / (b_col + H_peb √(8/π)) (Ormel 2017 Eq 7.24)
+  - M_iso_peb = 25 M⊕ (H_gas/r / 0.05)³ (M_star/M_sun) (Drążkowska et al. 2023 Eq 6)
+  - M < M_onset: Acreción de Safronov Balística (Ormel 2017 Eq 7.14)
+
+Unidades internas: CGS (g, cm, s).
+"""
+
+import numpy as np
+
+from .data import DiskData
+from .composition import CompositionModel, SimpleWaterComposition
+from . import constants as c
+
+
+class PebbleAccretionModule3:
+    """Motor físico de acreción agnóstico a HDF5 (Ormel 2017 & Drążkowska 2023)."""
+
+    # Índice único de pebbles. (El último bin de polvo representa los pebbles)
+    peb_idx = -1
+
+    def __init__(self, disk_data: DiskData, comp_model: CompositionModel = None):
+        """
+        Inicializa el simulador con los datos del disco y un modelo de composición.
+        
+        Parámetros:
+        -----------
+        disk_data : DiskData
+            Contenedor con todas las propiedades radiales y temporales del disco.
+        comp_model : CompositionModel, opcional
+            Modelo que define las snowlines y abundancias por regiones.
+            Si no se provee, se usará el modelo clásico de PA3Py (SimpleWaterComposition)
+            usando la snowline de agua que venga del HDF5 (si existe).
+        """
+        self.data = disk_data
+        if comp_model is None:
+            rsnow_h2o = self.data.hdf5_snowlines.get('H2O', np.zeros(self.data.Nt))
+            self.comp = SimpleWaterComposition(rsnow_h2o)
+        else:
+            self.comp = comp_model
+        self.tracked_species = self.comp.get_species()
+
+    # ══════════════════════════════════════════════════════════════════════
+    # Helpers Interp
+    # ══════════════════════════════════════════════════════════════════════
+
+    def _interp(self, field_1d: np.ndarray, r_emb: float) -> float:
+        """
+        Interpola logarítmicamente un campo radial 1D.
+        """
+        return float(np.interp(np.log(r_emb), np.log(self.data.r), field_1d))
+
+    def _local(self, t: int, r_emb: float) -> dict:
+        """Extrae e interpola las propiedades locales del disco."""
+        I = lambda arr: self._interp(arr[t], r_emb)
+        
+        Sigma_peb = self._interp(self.data.dust_Sigma[t, :, self.peb_idx], r_emb)
+        eta   = I(self.data.gas_eta)
+        St    = self._interp(self.data.dust_St[t, :, self.peb_idx], r_emb)
+        H_gas = I(self.data.gas_Hp)
+        H_peb = self._interp(self.data.dust_H[t, :, self.peb_idx], r_emb)
+        
+        if self.data.Omega_K.ndim == 2:
+            omega_1d = self.data.Omega_K[t]
+        else:
+            omega_1d = self.data.Omega_K
+            
+        Omega = float(np.interp(np.log(r_emb), np.log(self.data.r), omega_1d))
+        v_K   = Omega * r_emb
+        v_hw  = eta * v_K
+        
+        return dict(
+            Sigma_peb=Sigma_peb, eta=eta, St=St, H_gas=H_gas, H_peb=H_peb, 
+            Omega=Omega, v_K=v_K, v_hw=v_hw
+        )
+
+    # ══════════════════════════════════════════════════════════════════════
+    # Física Ormel 2017 & Drążkowska et al. 2023
+    # ══════════════════════════════════════════════════════════════════════
+
+    def _pebble_flux(self, t: int, r_emb: float) -> float:
+        """Ṁ_peb = 2π r Σ_peb |v_r|"""
+        Sigma_peb = self._interp(self.data.dust_Sigma[t, :, self.peb_idx], r_emb)
+        v_r       = self._interp(self.data.dust_vr[t, :, self.peb_idx], r_emb)
+        return 2 * np.pi * r_emb * Sigma_peb * abs(v_r)
+
+    def _isolation_mass(self, r_emb: float, t: int) -> float:
+        """Drążkowska 2023 Eq.6: M_iso = 25 M⊕ (h/0.05)³ (M★/M☉)"""
+        h_gas = self._interp(self.data.gas_Hp[t], r_emb) / r_emb
+        M_iso = 25 * (h_gas / 0.05)**3 * self.data.M_star * c.M_EARTH
+        return max(M_iso, 0.1 * c.M_EARTH)
+
+    def _accretion_rate(self, M_core: float, r_emb: float, t: int) -> float:
+        if M_core <= 0: return 0.0
+        p = self._local(t, r_emb)
+        if p['Sigma_peb'] < 1e-30: return 0.0
+
+        G, M, Omega = c.G, M_core, p['Omega']
+        St, v_hw, Sigma = p['St'], p['v_hw'], p['Sigma_peb']
+        
+        t_stop = St / Omega
+        M_PA_onset = St * (p['eta']**3) * (self.data.M_star * c.M_SUN)
+        H_peb = max(p['H_peb'], 1e-10 * p['H_gas'])
+        rho_peb = Sigma / (np.sqrt(2 * np.pi) * H_peb)
+
+        # Safronov (Balístico)
+        if M < M_PA_onset:
+            rho_core = 3.0  # g/cm3
+            R_pl = (3 * M / (4 * np.pi * rho_core))**(1/3)
+            v_impact = max(v_hw, 1.0) 
+            return (2 * np.pi * R_pl * G * M / v_impact) * rho_peb
+
+        # Transición Headwind/Shear
+        M_hw_sh = (v_hw**3) / (8 * G * Omega * St)
+
+        # Regímenes 2D
+        if M < M_hw_sh:
+            Mdot_2D = np.sqrt(8 * G * M * t_stop * v_hw) * Sigma
+            b_col   = np.sqrt(2 * G * M * t_stop / max(v_hw, 1e-5))
+        else:
+            R_H     = r_emb * (M / (3 * self.data.M_star * c.M_SUN))**(1/3)
+            Mdot_2D = 2 * R_H**2 * Omega * St**(2/3) * Sigma
+            b_col   = (St**(1/3)) * R_H
+            
+        # Transición 2D-3D turbulencia suave
+        denominator = b_col + H_peb * np.sqrt(8.0 / np.pi)
+        Mdot_eff = Mdot_2D * (b_col / denominator)
+        
+        return max(Mdot_eff, 0.0)
+
+    # ══════════════════════════════════════════════════════════════════════
+    # API / Loop Principal
+    # ══════════════════════════════════════════════════════════════════════
+
+    def run_growth(self, embryo_locations_AU: list, M0_g: float = None) -> dict:
+        r_min_au, r_max_au = self.data.r[0] / c.AU, self.data.r[-1] / c.AU
+        for r_au in embryo_locations_AU:
+            if not (r_min_au <= r_au <= r_max_au):
+                raise ValueError(f"El embrión en {r_au:.2f} AU fuera del disco ({r_min_au:.2f}–{r_max_au:.2f} AU).")
+
+        if M0_g is None:
+            M0_g = 1e-3 * c.M_EARTH
+            
+        locs_outer_to_inner = sorted(embryo_locations_AU, reverse=True)
+        M_core = {r: float(M0_g) for r in locs_outer_to_inner}
+        primary_rock = "silicates" if "silicates" in self.tracked_species else self.tracked_species[0]
+        
+        M_X = {r: {sp: float(M0_g) if sp == primary_rock else 0.0 for sp in self.tracked_species} for r in locs_outer_to_inner}
+            
+        histories= {r: [] for r in locs_outer_to_inner}
+
+        for i in range(self.data.Nt):
+            dt = float(self.data.times[i] - (self.data.times[i-1] if i > 0 else 0.0))
+            if dt <= 0: continue
+
+            flux_consumed = 0.0
+
+            for r_au in locs_outer_to_inner:
+                r_emb = r_au * c.AU
+
+                M_iso = self._isolation_mass(r_emb, i)
+                
+                if M_core[r_au] < M_iso:
+                    Mdot_peb_disk  = self._pebble_flux(i, r_emb)
+                    Mdot_peb_avail = max(0.0, Mdot_peb_disk - flux_consumed)
+
+                    Mdot_core_r = self._accretion_rate(M_core[r_au], r_emb, i)
+                    Mdot_core_r = min(Mdot_core_r, Mdot_peb_avail)
+
+                    dM = Mdot_core_r * dt
+                    dM = min(dM, max(0.0, M_iso - M_core[r_au]))
+                    flux_consumed += Mdot_core_r
+
+                    fractions = self.comp.get_fractions(r_emb, self.data.times[i], i)
+                    for sp in self.tracked_species:
+                        M_X[r_au][sp] += fractions.get(sp, 0.0) * dM
+
+                    M_core[r_au] += dM
+
+                histories[r_au].append([self.data.times[i], M_core[r_au], M_iso] + [M_X[r_au].get(sp, 0.0) for sp in self.tracked_species])
+
+        results = {
+            r_au: (np.array(histories[r_au]) if histories[r_au] else np.empty((0, 3 + len(self.tracked_species))))
+            for r_au in embryo_locations_AU
+        }
+        return results
+
+    def summary(self, results: dict):
+        """Imprime tabla resumen de la composición final."""
+        col_widths = [max(10, len(f"f_{sp}[%]") + 2) for sp in self.tracked_species]
+        SEP = '-' * (35 + sum(col_widths))
+        print(f"\n{SEP}")
+        header = f"{'r [AU]':>8} {'M_tot [ME]':>11} {'M_iso [ME]':>11}"
+        header += "".join(f"{f'f_{sp}[%]':>{w}}" for sp, w in zip(self.tracked_species, col_widths))
+        print(header)
+        print(SEP)
+        
+        for r_au, hist in results.items():
+            if len(hist) == 0:
+                print(f"{r_au:>8.2f}  -- no accretion")
+                continue
+            
+            _, M, M_iso, *M_species = hist[-1]
+            
+            M_total = sum(M_species)
+            
+            line = f"{r_au:>8.2f}  {M/c.M_EARTH:>11.3f}  {M_iso/c.M_EARTH:>11.2f}"
+            for i, m_sp in enumerate(M_species):
+                f_sp = 0.0 if M_total <= 0 else 100 * m_sp / M_total
+                line += f"{f_sp:>{col_widths[i]}.1f}"
+                
+            print(line)
+        print(f"{SEP}\n")
+
+    def calculate_isolation_mass_map(self) -> np.ndarray:
+        """Calcula el mapa de masa de aislamiento teórico 2D."""
+        h_gas = self.data.gas_Hp / self.data.r
+        M_iso = 25 * (h_gas / 0.05)**3 * self.data.M_star * c.M_EARTH
+        return np.maximum(M_iso, 0.1 * c.M_EARTH)

pa3py/plotting.py

@@ -0,0 +1,164 @@
+"""
+plotting.py - Herramientas de visualización (ej: Diagrama Hovmöller)
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.colors import LogNorm
+from .data import DiskData
+from . import constants as c
+
+def plot_hovmoller(disk: DiskData, field: str = 'dust_Sigma', 
+                   cmap: str = 'magma', vmin: float = None, vmax: float = None,
+                   t_unit: str = 'Myr', show_snowlines: bool = True):
+    """Genera un diagrama de Hovmöller (Radio vs Tiempo) para una propiedad."""
+    # 1. Extraer los datos 2D (Tiempo, Radio)
+    if field == 'dust_Sigma':
+        # Sumamos sobre todos los tamaños de polvo (último índice)
+        Z = np.sum(disk.dust_Sigma, axis=-1)
+        title = r"Hovmöller: $\Sigma_{dust}$ [g/cm$^2$]"
+    elif field == 'gas_Sigma':
+        Z = disk.gas_Sigma
+        title = r"Hovmöller: $\Sigma_{gas}$ [g/cm$^2$]"
+    elif field in ['eps', 'epsilon']:
+        dust = np.sum(disk.dust_Sigma, axis=-1)
+        gas = disk.gas_Sigma
+        # Le sumamos 1e-300 al gas para evitar división por cero.
+        Z = dust / (gas + 1e-300)
+        Z = np.clip(Z, 1e-10, None)  # Limitar valores muy pequeños
+        title = r"Hovmöller: Dust-to-gas ratio ($\epsilon = \Sigma_d / \Sigma_g$)"
+    else:
+        raise ValueError("Unsupported field. Options: 'dust_Sigma', 'gas_Sigma', 'epsilon'.")
+
+    # Limpiar ceros para escala log
+    Z = np.clip(Z, 1e-20, None)
+    
+    t_map = {'Myr': (c.YEAR * 1e6, "Time [Myr]"), 'kyr': (c.YEAR * 1e3, "Time [kyr]")}
+    t_factor, t_label = t_map.get(t_unit, (c.YEAR, "Time [Years]"))
+        
+    t_array = disk.times / t_factor
+    r_array = disk.r / c.AU
+
+    # Ejes extendidos robustos para pcolormesh
+    def _log_edges(arr):
+        arr = np.maximum(arr, 1e-10)
+        log_arr = np.log10(arr)
+        mid = (log_arr[:-1] + log_arr[1:]) / 2.0
+        return 10**np.concatenate([[log_arr[0] - (mid[0] - log_arr[0])], mid, [log_arr[-1] + (log_arr[-1] - mid[-1])]])
+
+    # Prevenir log10(0)
+    safe_t = np.maximum(t_array, 1e-6)
+    t_edges = _log_edges(safe_t)
+    r_edges = _log_edges(r_array)
+
+    # Escala de colores automática
+    logZ = np.log10(Z[Z > 1e-20])
+    v_lo = vmin if vmin is not None else 10**np.percentile(logZ, 2)
+    v_hi = vmax if vmax is not None else 10**np.percentile(logZ, 98)
+
+    # 2. Dibujar
+    fig, ax = plt.subplots(figsize=(10, 5))
+    
+    # Transponemos Z porque pcolormesh recibe Y, X -> Z debe ser (Ny, Nx)
+    pcm = ax.pcolormesh(t_edges, r_edges, Z.T, 
+                        norm=LogNorm(vmin=v_lo, vmax=v_hi), 
+                        cmap=cmap, shading='flat')
+    
+    cbar = fig.colorbar(pcm, ax=ax, pad=0.02)
+    cbar.set_label("Logarithmic Scale")
+    
+    ax.set_xscale('log')
+    ax.set_yscale('log')
+    ax.set_xlim(safe_t[0], safe_t[-1])
+    ax.set_ylim(r_array[0], r_array[-1])
+    ax.set_xlabel(t_label)
+    ax.set_ylabel("Radius [AU]")
+    ax.set_title(title, pad=10)
+    
+    if show_snowlines and disk.hdf5_snowlines:
+        colors = ['cyan', 'white', 'lightgreen']
+        for idx, (name, rsnow) in enumerate(disk.hdf5_snowlines.items()):
+            r_au = rsnow / c.AU
+            if np.any(r_au > 0):
+                ax.plot(safe_t, r_au, ls='--', color=colors[idx % len(colors)], lw=2, label=f"Snowline {name}")
+        ax.legend(loc='lower left')
+                
+    fig.tight_layout()
+    return fig, ax
+
+
+
+def plot_population(disk, results: dict, M_iso_map: np.ndarray = None, **kwargs):
+    """
+    Grafica la población sintética de planetas (Masa Final vs Posición Inicial).
+    
+    Parámetros:
+    -----------
+    disk : DiskData
+        El objeto que contiene los datos del disco.
+    results : dict
+        Diccionario con los historiales de crecimiento de cada embrión.
+    M_iso_map : np.ndarray, opcional
+        Mapa 2D de masa de aislamiento calculada para todo el disco.
+    """
+    radii = []
+    final_masses = []
+    water_fractions = []
+
+    for r_au, hist in results.items():
+        if len(hist) == 0:
+            continue
+        
+        radii.append(float(r_au))
+        final_state = hist[-1]
+        total_m = final_state[1] / c.M_EARTH
+        
+        silicate_m = final_state[3]
+        water_m = final_state[4] if len(final_state) > 4 else 0.0
+        M_total = silicate_m + water_m
+        f_water = water_m / M_total if M_total > 0 else 0.0
+        
+        final_masses.append(total_m)
+        water_fractions.append(f_water * 100)
+        
+    radii = np.array(radii)
+    final_masses = np.array(final_masses)
+    water_fractions = np.array(water_fractions)
+    
+    fig, ax = plt.subplots(figsize=(10, 6))
+    
+    # 1. Snowline region
+    if disk.hdf5_snowlines and 'H2O' in disk.hdf5_snowlines:
+        rsnow_array = disk.hdf5_snowlines['H2O'] / c.AU
+        rsnow_valid = rsnow_array[rsnow_array > 0]
+        if len(rsnow_valid) > 0:
+            rsnow_min = np.min(rsnow_valid)
+            rsnow_max = np.max(rsnow_array)
+            ax.axvspan(rsnow_min, rsnow_max, color='cyan', alpha=0.1, label='Snowline Migration')
+            ax.axvline(rsnow_min, color='cyan', linestyle='--', alpha=0.5)
+            ax.axvline(rsnow_max, color='cyan', linestyle='--', alpha=0.5)
+            
+    # 2. Isolation Mass from the full disk grid
+    if M_iso_map is not None:
+        # Usamos el límite en el último paso de tiempo (estado final del disco)
+        iso_mass_final = M_iso_map[-1, :] / c.M_EARTH
+        r_grid_au = disk.r / c.AU
+        ax.plot(r_grid_au, iso_mass_final, color='gray', linestyle='--', alpha=0.7, zorder=1, label='Isolation Mass Limit')
+
+    # 3. Planetas
+    sc = ax.scatter(radii, final_masses, c=water_fractions, cmap='Blues', edgecolor='black', 
+                    s=80, alpha=0.9, zorder=2, vmin=0, vmax=50)
+                    
+    cbar = fig.colorbar(sc, ax=ax)
+    cbar.set_label('Water Mass Fraction [%]', rotation=270, labelpad=15)
+    
+    ax.set_xscale('log')
+    ax.set_yscale('log')
+    ax.set_xlabel('Initial Radius [AU]')
+    ax.set_ylabel('Final Mass [$M_\\oplus$]')
+    ax.set_title('Synthetic Population: Final Mass vs Initial Position')
+    ax.grid(True, which='both', linestyle=':', alpha=0.6)
+    ax.legend(loc='upper right')
+    
+    fig.tight_layout()
+    return fig, ax

pa3py/snowline.py

@@ -0,0 +1,68 @@
+"""
+snowline.py - Cálculo analítico de la posición de la snowline en base a Oka et al. (2011) y Hartmann.
+"""
+
+import os
+import numpy as np
+from scipy.interpolate import interp1d
+from . import constants as c
+
+# ============================================================
+# INICIALIZACIÓN DE LA INTERPOLACIÓN (Ejecutada al importar)
+# ============================================================
+
+# Ruta robusta al CSV (empaquetado junto al módulo)
+_current_dir = os.path.dirname(__file__)
+_csv_path = os.path.join(_current_dir, "data_files", "oka_et_al_2011_data_corrected.csv")
+
+# Leer datos velozmente con NumPy
+_data = np.loadtxt(_csv_path, delimiter=';', skiprows=1)
+_mdot_raw, _rsnow_raw = _data[:, 0], _data[:, 1]
+
+# Asegurar orden monotónico para la interpolación log-log
+_sort_idx = np.argsort(_mdot_raw)
+_mdot_sorted = _mdot_raw[_sort_idx]
+_rsnow_sorted = _rsnow_raw[_sort_idx]
+
+_mdot_unique, _unique_indices = np.unique(_mdot_sorted, return_index=True)
+_rsnow_unique = _rsnow_sorted[_unique_indices]
+
+_log_mdot = np.log10(_mdot_unique)
+_log_rsnow = np.log10(_rsnow_unique)
+
+# Interpolador principal
+_interp_log_rsnow = interp1d(
+    _log_mdot, 
+    _log_rsnow, 
+    kind='linear', 
+    bounds_error=False, 
+    fill_value="extrapolate"
+)
+
+# ============================================================
+# FUNCIONES FÍSICAS PÚBLICAS
+# ============================================================
+
+def get_rsnow_from_mdot_au(mdot_val):
+    """Retorna la posición de snowline en AU dada una tasa de acreción."""
+    log_m = np.log10(mdot_val)
+    log_r = _interp_log_rsnow(log_m)
+    return 10**log_r
+
+def mdot_time(t_myr, eta=1.5):
+    """Calcula la tasa de acreción de gas en el tiempo (Hartmann)."""
+    mdot_1myr = 1e-8
+    # Proteger contra tiempo 0 para evitar singularidades matemáticas
+    t_myr = np.maximum(t_myr, 1e-6) 
+    return mdot_1myr * (t_myr)**(-eta)
+
+def r_snow_time_cgs(t_sec, eta=1.5, r_min_au=0.5):
+    """Posición de la snowline en CGS dado el tiempo en segundos."""
+    t_myr = t_sec / (1e6 * c.YEAR)
+    m_eff = min(mdot_time(t_myr, eta), 1e-7)  # cap para r_snow ≤ 2.73 AU
+    r_au  = np.clip(get_rsnow_from_mdot_au(m_eff), r_min_au, 2.73)
+    return float(r_au * c.AU)
+
+def generate_rsnow_array(times_sec: np.ndarray, eta: float = 1.5, r_min_au: float = 0.5) -> np.ndarray:
+    """Arreglo de posiciones de la snowline en CGS para inyectar en CompositionModels."""
+    return np.array([r_snow_time_cgs(t, eta=eta, r_min_au=r_min_au) for t in times_sec])

pa3py-1.0.0.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: pa3py
+Version: 1.0.0
+Summary: Post-processing tool for pebble accretion onto planetary embryos from TripodPy hydrodynamic simulations.
+Author-email: Maximiliano Valderrama <mvalderrav@uc.cl>
+License: MIT License
+Project-URL: Homepage, https://github.com/mmmaxii/PA3Py
+Project-URL: Bug Tracker, https://github.com/mmmaxii/PA3Py/issues
+Project-URL: Documentation, https://pa3py.readthedocs.io
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7
+Requires-Dist: h5py>=3.0
+Requires-Dist: matplotlib>=3.4
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: jupyter>=1.0; extra == "dev"
+Dynamic: license-file
+
+# PA3Py — Pebble Accretion Post-Processing for TripodPy
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Tests](https://github.com/mmmaxii/PA3Py/actions/workflows/tests.yml/badge.svg)](https://github.com/mmmaxii/PA3Py/actions) [![Documentation Status](https://readthedocs.org/projects/pa3py/badge/?version=latest)](https://pa3py.readthedocs.io/en/latest/?badge=latest)
+
+**PA3Py** is a Python post-processing package for computing pebble accretion growth of planetary embryos from [TripodPy](https://github.com/tripod-code/tripodpy) hydrodynamic disk simulations. It is **not** a standalone disk evolution code — it reads TripodPy HDF5 output snapshots and computes embryo growth on top of them.
+
+The physics follows Ormel (2017) and Drążkowska et al. (2023), including headwind/shear regime switching, 2D–3D turbulence transition, Safronov ballistic onset, and a dynamic isolation mass cap.
+
+Please read the [documentation](https://pa3py.readthedocs.io) for a full description.
+
+## Installation
+
+Clone the repository and install via pip:
+
+```bash
+git clone https://github.com/mmmaxii/PA3Py.git
+cd PA3Py
+pip install .
+```
+
+For an editable installation (recommended during development):
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Requirements
+
+- Python ≥ 3.9
+- [TripodPy](https://github.com/tripod-code/tripodpy) simulation output (HDF5 snapshots)
+- `numpy`, `scipy`, `h5py`, `matplotlib`
+
+## Quick Start
+
+```python
+from pa3py import PA3Py
+
+sim = PA3Py("path/to/tripodpy/output/")
+
+# Run pebble accretion for embryos at 2, 5, 10, 20 AU
+results = sim.run_growth([2.0, 5.0, 10.0, 20.0])
+
+# Hovmöller diagram (dust-to-gas ratio vs time)
+sim.plot_hovmoller(field='epsilon')
+```
+
+For custom chemistry (multi-snowline, 4-species):
+
+```python
+from pa3py import PA3Py, FunctionComposition
+from pa3py import constants as c
+
+def my_chemistry(r_cm, t_sec):
+    if r_cm < 3.0 * c.AU:
+        return {'silicates': 1.0}
+    elif r_cm < 5.0 * c.AU:
+        return {'silicates': 0.5, 'H2O': 0.5}
+    else:
+        return {'silicates': 0.3, 'H2O': 0.3, 'CO2': 0.4}
+
+sim = PA3Py("path/to/output/", comp_model=FunctionComposition(my_chemistry))
+results = sim.run_growth([5.0, 10.0, 20.0])
+```
+
+## Physics & References
+
+- **Ormel (2017)**: *The Emerging Paradigm of Pebble Accretion*
+- **Drążkowska et al. (2023)**: *Planet Formation Theory in the Era of ALMA and Kepler*
+
+## Acknowledgements
+
+PA3Py was developed at the Pontificia Universidad Católica de Chile. 
+Contact: [mvalderrav@uc.cl](mailto:mvalderrav@uc.cl)

pa3py-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pa3py/__init__.py,sha256=iJNsOu2OZGIaezgJj1-EKmWEl8S3gdIsZjjAkLJ0eZ8,2000
+pa3py/composition.py,sha256=W2fnykhQ9w2IpAk1NUa9sYGyrhnWAidZv5m1xLKJzbs,4775
+pa3py/constants.py,sha256=Hw5ngIZ_213OX-9suhGVreZ4uYdmDtkfdgdpe6EGvQ4,342
+pa3py/core.py,sha256=dXoUt4GnctIms4Xue0SNWor-UL1Z-Qk40T2M2X5hdJo,4387
+pa3py/data.py,sha256=f5m3XNsxDt12fmDdLMWveDWtQfAdeYemoh_WO5MFtWk,4067
+pa3py/pebble_accretion.py,sha256=slKaD3Ea8g9eKwOYXTPscNTbwAAApytcvG9ZYDN9650,10605
+pa3py/plotting.py,sha256=eTdGX4AjzN5P_07v6PFNO-71h1WykT4jHiOYUeuUgKk,6301
+pa3py/snowline.py,sha256=Zu3oTM0OjjJf_0CRyNRXlYDyJbk68tX8J-BoppXNcFs,2505
+pa3py-1.0.0.dist-info/licenses/LICENSE,sha256=QPBZoUVz-h3pH3QzXiYxW7KKU99taI3Kkv_elegznnU,1100
+pa3py-1.0.0.dist-info/METADATA,sha256=60sRiNCZ_CBqNu-XaxvzxRoJXM5qVhBsCPUZz5HlIU0,3665
+pa3py-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pa3py-1.0.0.dist-info/top_level.txt,sha256=BzQcdvwZbyD7sGzqakRoLo9-0Jq7zm2sn17ORXanzoI,6
+pa3py-1.0.0.dist-info/RECORD,,

pa3py-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pa3py-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maximiliano Valderrama
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pa3py-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pa3py