pa3py 1.0.0__tar.gz

pa3py-1.0.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,73 @@
+# 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/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pa3py"
+version = "1.0.0"
+authors = [
+  { name="Maximiliano Valderrama", email="mvalderrav@uc.cl" },
+]
+description = "Post-processing tool for pebble accretion onto planetary embryos from TripodPy hydrodynamic simulations."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT License" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Astronomy",
+]
+dependencies = [
+    "numpy>=1.20",
+    "scipy>=1.7",
+    "h5py>=3.0",
+    "matplotlib>=3.4",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "jupyter>=1.0"]
+
+[project.urls]
+"Homepage"   = "https://github.com/mmmaxii/PA3Py"
+"Bug Tracker" = "https://github.com/mmmaxii/PA3Py/issues"
+"Documentation" = "https://pa3py.readthedocs.io"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pa3py-1.0.0/setup.cfg

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

pa3py-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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
+    )