HDF5 para datos de simulación: E/S en paralelo y almacenamiento a largo plazo

Reading Time: 12 minutes

HDF5 es el estándar de facto para almacenar datos de simulación científica a gran escala. Su estructura jerárquica, sus capacidades de E/S paralelas a través de MPI y su compresión incorporada lo hacen ideal para entornos informáticos de alto rendimiento. Sin embargo, el uso inadecuado, especialmente las malas opciones de fragmentación y los patrones de acceso paralelos incorrectos, pueden provocar una grave degradación del rendimiento o una corrupción de datos. Esta guía cubre la arquitectura HDF5, la implementación de E/S en paralelo en Python, las técnicas de optimización del rendimiento y las mejores prácticas de conservación para el almacenamiento a largo plazo.

Introducción: El desafío de los datos de simulación

Las simulaciones científicas generan rutinariamente terabytes de datos en miles de pasos de tiempo y múltiples campos físicos. Administrar este diluvio requiere más que un formato de archivo: exige un sistema que pueda manejar:

Escala: gigabytes a petabytes de matrices multidimensionales
Rendimiento: lectura/escritura eficiente en sistemas HPC con sistemas de archivos paralelos
Organización: Estructuras de autodenominación que siguen siendo comprensibles años después
Durabilidad: Preservación a largo plazo sin obsolescencia de formato
acceso: subconfiguración rápida sin leer conjuntos de datos completos

HDF5 (formato de datos jerárquico versión 5) aborda estos desafíos a través de una combinación de modelado de datos flexible, soporte de E/S paralelo e integración de metadatos. Ampliamente adoptado por la NASA, NOAA, laboratorios e instituciones de investigación, HDF5 se ha convertido en la columna vertebral de los archivos de datos científicos en todo el mundo[^1][^2].

¿Qué es HDF5? Arquitectura y conceptos básicos

HDF5 es un formato de archivo y una biblioteca de software que proporciona un contenedor para datos científicos heterogéneos. Su arquitectura se basa en seis entidades fundamentales[^3]:

Grupo: Objetos de contenedor análogos a los directorios, organizando datos jerárquicamente
Conjunto de datos: matrices multidimensionales que contienen datos numéricos o estructurados reales
Espacio de datos: describe las dimensiones del conjunto de datos (forma, rango y extensión)
DataType: especifica tipos de elementos (enteros, flotadores, cadenas, compuestos)
Atributo: Pequeños metadatos adjuntos a grupos o conjuntos de datos
link: conecta objetos dentro de la jerarquía (enlaces duros y blandos)

La estructura jerárquica

Un archivo HDF5 es un gráfico dirigido con un solo grupo raíz (/). Los grupos pueden contener otros grupos y conjuntos de datos, lo que permite una anidación profunda arbitraria. Esta estructura refleja un sistema de archivos pero con diferencias clave:

Auto-descripción: todos los metadatos (tipos de datos, dimensiones) viajan con los datos
Portable: formato binario independiente de la plataforma
Extensible: los conjuntos de datos se pueden redimensionar y se pueden agregar grupos/datos de datos dinámicamente
comprimido: el almacenamiento basado en fragmentos permite filtros de compresión por fragmentos

/simulation
├── metadata
│   ├── title (attribute)
│   ├── creation_date (attribute)
│   └── parameters (group)
│       ├── mesh_size (dataset)
│       └── time_step (dataset)
├── fields
│   ├── temperature (dataset, 3D [x,y,z,time])
│   ├── velocity (dataset, 4D [x,y,z,time,component])
│   └── pressure (dataset, 3D)
└── output
    ├── checkpoint_001.h5 (external link)
    └── checkpoint_002.h5 (external link)

¿Por qué HDF5 para la simulación científica?

En comparación con los formatos de texto sin formato (CSV, JSON) o los formatos binarios más simples, HDF5 ofrece ventajas críticas:

E/S parciales: solo lectura de subconjuntos necesarios sin cargar conjuntos de datos completos
Compresión: la compresión sin pérdidas (GZIP, SZIP, LZF) reduce el almacenamiento en 2–10×
Acceso en paralelo: varios procesos pueden leer/escribir simultáneamente a través de MPI-IO
Richness de metadatos: Atribuye unidades de documento, descripciones y procedencias
Soporte de archivos grandes: maneja archivos que superan los 2 GB (a diferencia de HDF4 anterior)
plataforma cruzada: funciona en Linux, macOS, Windows; Compatible con Python, C, C++, Fortran, MATLAB, R

Para los flujos de trabajo de simulación, donde los archivos de puntos de control, las salidas de series de tiempo y los datos de malla deben persistir durante años, estas características no son opcionales; son esenciales.

Comprender la organización de datos HDF5

Grupos y conjuntos de datos: los bloques de construcción

Grupos Proporcionan espacios de nombres y organización lógica. Cada archivo tiene un grupo raíz (/), y puede crear grupos anidados de forma arbitraria. Los propios grupos no almacenan datos; Contienen enlaces a conjuntos de datos y otros grupos.

Conjuntos de datos es donde viven los resultados de la simulación. Un conjunto de datos es una matriz multidimensional con dimensiones fijas o extensibles. Patrones comunes para datos de simulación:

Campos 3D: matrices (nx, ny, nz) para variables espaciales
series de tiempo 4D: matrices (nx, ny, nz, nt) con el tiempo como cuarta dimensión
2D Slices: (nx, nt) para sondas de línea o datos de sensores
Datos estructurados: Tipos de datos compuestos para propiedades de partículas (posición, velocidad, masa)

Espacios de datos: moldeando sus datos

Un espacio de datos define el diseño lógico de un conjunto de datos. Compatible con HDF5:

escalar: valor único (0-D)
Simple: matriz n-dimensional regular con dimensiones fijas o ilimitadas
complejo: selecciones arbitrarias usando HypersLabs

Dimensiones ilimitadas (ejes extensibles) son cruciales para las salidas de simulación donde se desconoce de antemano el número de pasos de tiempo.

Atributos: El poder autodescriptivo

Los atributos son pequeños objetos de metadatos adjuntos a grupos o conjuntos de datos. Son el mecanismo principal para documentar sus datos[^4]. Usa atributos para almacenar:

Unidades físicas ("m/s", "K", "Pa")
Descripción Cadenas
marcas de tiempo
parámetros de simulación
Información de la cita
Versión de software utilizada

# Example: Adding attributes with h5py
import h5py

with h5py.File('simulation.h5', 'w') as f:
    grp = f.create_group('temperature')
    dset = grp.create_dataset('field', data=temperature_array)
    
    dset.attrs['units'] = 'Kelvin'
    dset.attrs['long_name'] = 'Temperature field'
    dset.attrs['simulation_time'] = 1234.56

E/S en paralelo con HDF5

¿Qué es el HDF5 paralelo?

Paralelo HDF5 (PHDF5) amplía la biblioteca estándar con compatibilidad con MPI-IO, permitiendo que múltiples procesos accedan al mismo archivo HDF5 al mismo tiempo. Esto es esencial para simulaciones a gran escala que se ejecutan en clústeres de HPC donde el trabajo de cómputo abarca cientos o miles de núcleos[^5].

Cómo funciona?

Bajo el capó, PhDF5 usa MPi-IO (el subsistema de E/S paralelo de MPI) para coordinar el acceso. Al abrir un archivo en modo paralelo, todos los procesos del comunicador de MPI comparten el mismo identificador de archivo y coordenadas de lecturas/escrituras.

# Parallel HDF5 example (requires h5py built with MPI support)
from mpi4py import MPI
import h5py

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()

# Each process opens the file collectively
with h5py.File('parallel_output.h5', 'w', driver='mpio', comm=comm) as f:
    # Create a dataset distributed across all processes
    # Each process writes its chunk of the global array
    local_data = compute_local_chunk(rank, size)
    dset = f.create_dataset('field', (global_nx, global_ny), dtype='f8')
    # Write using hyperslabs
    dset[local_slice] = local_data

E/S colectivas vs independientes

Una distinción de rendimiento crítico en HDF5 paralelo:

E/S colectivas: todos los procesos participan en la misma operación de E/S. La biblioteca MPI puede optimizar el movimiento de los datos, la agregación y el striping. Utilice esto siempre que sea posible.
E/S independientes: Cada proceso abre, lee y escribe de forma independiente. Esto conduce a un bajo rendimiento debido a la contención del sistema de archivos y oportunidades de optimización perdidas[^6].

Mejor práctica: estructura tu código para que todos los procesos llamen a read() o write() al mismo tiempo con selecciones compatibles de HyperSlab. Evite la E/S condicional que solo se ejecuten algunos procesos.

Consejos paralelas de rendimiento HDF5

Escribe el agregado: escribe en grandes trozos contiguos, no muchas piezas pequeñas
Utilice el almacenamiento en búfer colectivo: deje que el caché de la biblioteca MPI y coalesce escriba
Alinee los fragmentos con la descomposición del proceso: haga coincidir la fragmentación del conjunto de datos con la descomposición de su dominio
Evitar el thrashing del sistema de archivos: usa un archivo por paso de salida, no un archivo por proceso
Configure el tamaño de caché de fragmentos apropiado: Aumente la memoria caché para los conjuntos de datos accedidos con frecuencia

HDF5 con Python: la biblioteca H5PY

El paquete H5PY proporciona la interfaz más pitónica a HDF5[^7].

operaciones básicas

import h5py
import numpy as np

# Writing data
with h5py.File('output.h5', 'w') as f:
    # Create a dataset
    data = np.random.randn(1000, 1000)
    dset = f.create_dataset('temperature', data=data, compression='gzip')
    
    # Add attributes
    dset.attrs['units'] = 'K'
    dset.attrs['description'] = 'Temperature at final time step'
    
    # Create groups for organization
    grp = f.create_group('initial_conditions')
    grp.create_dataset('velocity', data=velocity_field)

# Reading data
with h5py.File('output.h5', 'r') as f:
    temp = f['temperature'][:]  # Load entire dataset
    # Or read a slice
    slice_ = f['temperature'][100:200, 300:400]
    
    # Access attributes
    units = f['temperature'].attrs['units']

Escribir salida de simulación de manera eficiente

Para simulaciones dependientes del tiempo, utilice conjuntos de datos extensibles con una dimensión de tiempo ilimitada:

with h5py.File('time_series.h5', 'w') as f:
    # Create dataset with unlimited maxshape
    dset = f.create_dataset(
        'temperature', 
        shape=(0, nx, ny), 
        maxshape=(None, nx, ny),  # Unlimited time dimension
        dtype='f8',
        chunks=(1, nx, ny)  # Chunk along time axis
    )
    
    # Append each time step
    for t in range(num_steps):
        current_temp = simulate_step(t)
        dset.resize((t+1, nx, ny))  # Extend dataset
        dset[t, :, :] = current_temp

Modo de anexión para puntos de control

Utilice el modo de adición ('a') para agregar una nueva salida a los archivos existentes sin sobrescribir:

with h5py.File('run_001.h5', 'a') as f:
    if 'checkpoint_002' not in f:
        f.create_dataset('checkpoint_002', data=new_data)

Optimización del rendimiento: fragmentación y compresión

Fragmento: la clave del rendimiento

HDF5 almacena conjuntos de datos en chunks: hiperrectángulos de tamaño fijo que son la unidad de E/S y compresión[^8]. La fragmentación es requerido para:

Compresión del conjunto de datos
Conjuntos de datos extensibles
Lecturas/escrituras parciales eficientes
E/S paralelo

Tamaño de fragmentos afecta dramáticamente el rendimiento:

Demasiado pequeño: sobrecarga de metadatos excesivos, malas relaciones de compresión, altas sobrecargas de llamadas del sistema
Demasiado grande: leer un pequeño subconjunto carga toda la parte en la memoria, desperdiciando el ancho de banda de E/S

Regla de pulgar: elija trozos que coincidan con su patrón de acceso típico. Para las series de tiempo 3D a las que se accede plano por plano, partición como (1, nx, ny) o (nt, nx, 1) dependiendo de qué dimensión varía más rápido.

# Optimal chunking for 3D time-series where we read full XY planes
dset = f.create_dataset(
    'field',
    shape=(nt, nx, ny),
    chunks=(1, nx, ny),  # Each time step is one chunk
    compression='gzip'
)

# Reading one time step only decompresses one chunk
time_step_50 = dset[50, :, :]

Compresión: Almacenamiento comercial para CPU

HDF5 admite varios filtros de compresión sin pérdida:

Gzip: universal, buena compresión (2–5×), intensiva en CPU
szip: rápido, acelerado por hardware en algunos sistemas, menos portátil
LZF: compresión muy rápida y moderada (2×)
Bloc: de alto rendimiento, multiproceso (a través de una biblioteca externa)

Cuándo comprimir:

Almacenamiento de archivo donde el tamaño importa más que la velocidad de escritura
Cargas de trabajo enlazadas con E/S donde la sobrecarga de descompresión es menor que el tiempo de lectura del disco
Cuando los datos tienen redundancia (campos lisos, valores repetidos)

Cuándo evitar la compresión:

Rutas de escritura de ultra alto rendimiento (intervalos de punto de control < 1 segundo)
Datos que ya están comprimidos (imágenes, vídeos)
Cuando se utiliza E/S en paralelo con tamaños de fragmentos que no coinciden

# Compression examples
dset = f.create_dataset('data', data=data, compression='gzip', compression_opts=4)  # gzip level 4
dset = f.create_dataset('data', data=data, compression='lzf')  # Fast LZF

Configuración de caché

La biblioteca HDF5 mantiene dos cachés:

Caché de metadatos: almacena información sobre grupos, conjuntos de datos, atributos
Caché de fragmentos: contiene fragmentos de datos accedidos recientemente

Para las cargas de trabajo críticas con el rendimiento, sintonice estos cachés a través de h5py:

with h5py.File('file.h5', 'w', libver='latest') as f:
    f.swmr_mode = True  # Enable Single-Writer-Multiple-Reader for concurrent access
    
# Configure chunk cache when opening
with h5py.File('file.h5', 'r', rdcc_nbytes=1024**3, rdcc_w0=0.75) as f:
    # 1 GB chunk cache, 75% preemption policy
    pass

Mejores prácticas de organización de datos

Patrones de estructura de archivos

Simple-archivo por ejecución: Almacene todos los resultados de una simulación en un solo archivo HDF5 con jerarquía de grupo clara. Ventajas:

Unidad de transferencia/archivadora única
Actualizaciones atómicas (todos los datos están escritos o ninguno)
Más fácil de validar la integridad

Puntos de control de varios archivos: Separe los archivos de puntos de control de la salida final. Utilice enlaces suaves para conectarlos:

run_001.h5
├── /initial (link to checkpoint_000.h5:/data)
├── /final
│   └── field (dataset)
└── /checkpoints (group)
    ├── checkpoint_000.h5 (external link)
    ├── checkpoint_001.h5 (external link)
    └── checkpoint_002.h5 (external link)

Documentar todo con atributos

Los archivos HDF5 pueden volverse impenetrables sin documentación completa. Cada conjunto de datos y grupo debe tener atributos descriptivos[^9]:

dset.attrs['units'] = 'm/s'
dset.attrs['long_name'] = 'Fluid velocity vector'
dset.attrs['standard_name'] = 'velocity'
dset.attrs['positive'] = 'up'  # For vertical components
dset.attrs['grid_mapping'] = '/mesh/x_grid'  # Link to coordinate variables
dset.attrs['comment'] = 'Computed using second-order upwind scheme'
dset.attrs['software'] = 'FiPy 3.4'
dset.attrs['git_commit'] = 'abc123def'

Considere adoptar las convenciones de clima y pronóstico (CF) para simulaciones geofísicas o estándares de metadatos específicos de dominio cuando estén disponibles.

Evitar la proliferación del conjunto de datos

Mientras que HDF5 permite millones de conjuntos de datos, el rendimiento se degrada con números excesivos[^10]. Prefiero:

Menos conjuntos de datos grandes en muchos de los pequeños
Tipos de datos compuestos para campos escalares relacionados (por ejemplo, posición de partícula + velocidad + masa)
Agrupar pequeños arreglos similares en un solo conjunto de datos estructurado

Archivos grandes desfragmentados

Con el tiempo, los archivos HDF5 se pueden fragmentar a medida que se crean y eliminan los conjuntos de datos. Use h5repack para reescribir archivos de forma óptima:

h5repack -f GZIP=4 input.h5 output_compressed.h5
h5repack -l CHUNK=100x100x100 input.h5 rechunked.h5

HDF5 vs Alternativas: netCDF4, ZARR, CSV

Resumen de comparación

Característica	HDF5	netcdf-4	zarza	CSV/JSON
E/S paralelas	✅ MPI-IO	✅ MPI-IO	✅ (optimizado en la nube)	❌
compresión	Múltiples filtros	GZip/szip	Múltiple (blosc, gzip)	❌
archivo único	✅	✅	❌ (Directorio)	✅
Nativo de la nube	⚠️ (con HSD)	⚠️	✅	✅
Python-primero	⚠️ (h5py)	✅ (netcdf4)	✅	✅
Metadatos	Atributos ricos	Convenciones de CF	Atributos ricos	Limitado
Curva de aprendizaje	Escarpado	Moderar	Fácil	Trivial
Conservación	✅Excelente	✅Excelente	⚠️Evolucionando	✅ Legible por humanos

Cuándo elegir HDF5

Entornos de HPC: simulaciones paralelas basadas en MPI
Archivos a largo plazo: formato probado con más de 20 años de historia.[^1]
jerarquías complejas: estructuras de grupos profundos, tipos de datos mixtos
Grandes datos binarios: imágenes, campos 3D, matrices
Idioma cruzado: necesita compatibilidad con C/Fortran/Matlab

Cuando netcdf-4 o zarr puede ser mejor

Clima/Ciencia atmosférica: netCDF-4 con convenciones de CF es el estándar comunitario
Almacenamiento en la nube: el diseño de directorio fragmentado de Zar funciona mejor con almacenes de objetos (S3, GCS)
Series de tiempo simples: Zar o netcdf4 ofrecen API más simples
Rapid Prototyping: la implementación de Pure-Python de Zar tiene cero dependencias en tiempo de compilación

Para la mayoría de los proyectos de simulación científica, especialmente aquellos que involucran a los solucionadores de PDE como Fipy, HDF5 sigue siendo la opción más capaz y ampliamente admitida[^11].

Almacenamiento y conservación a largo plazo

Por qué HDF5 es de calidad de archivo

La biblioteca del Congreso y Archivos Nacionales reconocen HDF5 como un formato adecuado para la conservación a largo plazo[^1]. Factores clave:

Norma abierta: no patentada, mantenida por el grupo HDF (sin fines de lucro)
Autodescripción: No se necesitan archivos de esquema externos para interpretar datos
Independiente de la plataforma: el formato binario funciona en cualquier arquitectura
Adopción amplia: utilizada por la NASA, NOAA, DOE, ESA; Existen miles de herramientas
Especificación estable: HDF5 1.10+ es compatible con versiones anteriores; Los cambios de formato son raros

Mejores prácticas de conservación

Utilice formatos numéricos IEEE: evite los formatos «nativos» que vincule los datos a la endianidad del hardware específico[^1]
Documento a fondo: Incluya unidades, descripciones, versiones de software y citas como atributos
Incluir un archivo README: almacenar documentación legible por humanos ya sea como un atributo o un archivo complementario
Validar archivos: use h5dump o h5py para verificar la integridad antes de archivar
Conservar el software: archivar la versión exacta de la biblioteca HDF5 (o un contenedor de Docker) que se utiliza para crear el archivo
Evitar la compresión exótica: el Gzip estándar es el más seguro; Los filtros personalizados no pueden ser compatibles en 20 años

Trampas comunes que corren el riesgo de datos

Sin diario: HDF5 carece de registros de transacciones. Si un proceso se bloquea durante la escritura, el archivo puede ser corrompido e irrecuperable[^12]. Siempre escriba en un archivo temporal y cambie el nombre al finalizar.
Escritos en paralelo: Múltiples escritores sin sincronización adecuada causan corrupción. Utilice el modo SWMR o E/S colectiva.
Tipos de datos no coincidentes: La lectura de un conjunto de datos con el DType incorrecto distorsiona los datos. Siempre verifique dtype coincidencias entre escritor y lector.
La eliminación de conjuntos de datos no reduce los archivos: HDF5 marca el espacio como libre de forma interna pero no reduce el tamaño del archivo. Utilice h5repack para recuperar espacio en disco.

Lista de verificación práctica: HDF5 para proyectos de simulación

Antes de usar HDF5 en su flujo de trabajo de simulación:

Elegir tamaños de fragmento basado en patrones de acceso típicos (no arbitrarios)
Habilitar compresión para salidas de archivo, deshabilitado para datos de puntos de control en caliente
Documente cada conjunto de datos con unidades, descripciones y software de creación
Utilice conjuntos de datos extensibles para las series de tiempo para evitar preasignación
Validar escrituras paralelas con operaciones colectivas, no E/S independientes
Cerrar todos los controladores de archivo (Utilice gestores de contexto: with h5py.File(...))
Copia de seguridad de copias de seguridad para separar el almacenamiento antes del procesamiento posterior
Recuperación de prueba: simular bloqueos para garantizar que se detecten archivos parciales
Considere netcdf-4 si su comunidad ya usa convenciones CF
Para el almacenamiento en la nube, evalúe Zarr como un formato alternativo

Enlace interno y guías relacionadas

Comprender HDF5 es crucial para administrar los resultados de la simulación en varias guías de MatForge:

Gestión de problemas de PDE a gran escala Cubre las estrategias de HPC donde HDF5 es paralelo E/S sobresale.
usando fipy para el modelado de campo de fase muestra guardar los resultados de la simulación a HDF5 para un análisis posterior.
Visualizar los resultados de la simulación de manera efectiva muestra cómo leer las salidas HDF5 para el procesamiento posterior con Paraview o Matplotlib.
La reproducibilidad y su papel en la depuración explica cómo la naturaleza autodescriptiva de HDF5 ayuda a la investigación reproducible.

recomendaciones y cuándo elegir qué

Para la mayoría de las simulaciones basadas en PDE (incluidos los usuarios de FIPY):

Comienza con HDF5 + H5PY por su madurez y soporte MPI
Utilice la compresión GZIP en el nivel 4–6 para las salidas de archivo (buen equilibrio de velocidad/tamaño)
Tiro a lo largo de la dimensión de tiempo como (1, nx, ny) para series de tiempo 3D
almacenar matrices de coordenadas (x, y, z) como conjuntos de datos separados con atributos de unidades
Agregue un grupo /metadata con parámetros de simulación, versiones de software y hashes de Git

Considere las alternativas cuando:

Trabajando exclusivamente en Python y necesita almacenamiento nativo de la nube → Zarr
Construcción de modelos climáticos/atmosféricos con convenciones estándar → NETCDF-4
Necesita salidas simples legibles por humanos → CSV/JSON (pero espere tamaños de archivo grandes y E/S lenta)

Conclusión

HDF5 proporciona la base para una sólida gestión de datos científicos. Su combinación de organización jerárquica, E/S paralela, compresión y metadatos enriquecidos lo hace especialmente adecuado para salidas de simulación que deben persistir durante años sin dejar de estar accesible en plataformas y lenguajes de programación.

Sin embargo, el poder del formato viene con la responsabilidad. Las malas opciones de fragmentación, ignorar los patrones de E/S colectivos y los metadatos inadecuados pueden socavar el rendimiento y la usabilidad a largo plazo. Siga las mejores prácticas descritas aquí, especialmente con respecto a la estrategia de fragmentación, la documentación de atributos y los patrones de acceso en paralelo, para garantizar que los datos de la simulación sigan siendo performantes y conservables.

HDF5 no es el formato más nuevo, pero su historial de estabilidad y adopción generalizada de más de 20 años lo convierte en la apuesta más segura para proyectos donde la longevidad de los datos es importante[^1][^2].

Lectura adicional

guía del usuario de hdf5 (documentación oficial)
Documentación H5PY
E/S en paralelo con HDF5 (el blog del grupo HDF)
prácticas recomendadas de NASA HDF5 (NASA Earthdata)

[^1]: Biblioteca del Congreso. «HDF5, formato de datos jerárquico, versión 5». Formato Descripción Documento. Disponible a través de Clarin: https://standards.clarin.eu/sis/views/view-format.xq?id=fhdf5
[^2]: el grupo HDF. «HDF5: una nueva generación de HDF». https://www.hdfgroup.org/solutions/hdf5/
[^3]: Grupo HDF. «Modelo de datos y estructura de archivos HDF5». https://support.hdfgroup.org/documentation/hdf5/latest/_h5_d_m__u_g.html
[^4]: grupo HDF. «Atributos HDF5». https://support.hdfgroup.org/documentation/hdf5/latest/_h5_a__u_g.html
[^5]: NERSC. «Introducción a la E/S científica». https://support.hdfgroup.org/documentation/hdf5-docs/hdf5 _topics/2016_nersc_introduction_to_scientific_io.pdf
[^6]: LRZ. «Guía de mejores prácticas: E/S en paralelo». https://doku.lrz.de/files/10746566/10746567/11/175 5197969103/Best-Practic-Guide-paralel-io.pdf
[^7]: Proyecto H5PY. «Documentación H5PY». https://docs.h5py.org/es/latest/
[^8]: Grupo HDF. «Cruzando en HDF5». https://support.hdfgroup.org/documentation/hdf5-docs/advanced_topics/chunking_in_hdf5.html
[^9]: grupo HDF. «Logrando E/S de alto rendimiento con HDF5». https://support.hdfgroup.org/documentation/hdf5-docs/hdf5_topics/20200206_ecptutorial-final.pdf
[^10]: Foro HDF. «Preguntas sobre el tamaño y el número del conjunto de datos HDF5». https://forum.hdfgroup.org/t/hdf5-dataset-size-and-number-questions/12215
[^11]: Ambatipudi et al. «Una comparación de HDF5, ZARR y netCDF4 en la realización de operaciones de E/S comunes». ARCX:2207.09503, 2022.
[^12]: Foro HDF. «¿HDF5 posible corrupción o pérdida de datos?» https://stackoverflow.com/questions/35837243/hdf5-posible-data-corruption-or-loss