wasp-ocean 0.1.0__tar.gz

wasp_ocean-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 WASP Contributors
+
+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.

wasp_ocean-0.1.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: wasp-ocean
+Version: 0.1.0
+Summary: WAve Spectra Partitioning
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jtcarvalho/wasp
+Project-URL: Repository, https://github.com/jtcarvalho/wasp
+Project-URL: Documentation, https://github.com/jtcarvalho/wasp/blob/main/README.md
+Project-URL: Issues, https://github.com/jtcarvalho/wasp/issues
+Keywords: waves,oceanography,SAR,WaveWatch3,spectral partitioning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3.0.0,>=2.1.0
+Requires-Dist: pandas<3.0.0,>=2.2.0
+Requires-Dist: scipy<2.0.0,>=1.14.0
+Requires-Dist: xarray>=2024.11.0
+Requires-Dist: netCDF4<2.0.0,>=1.5.4
+Requires-Dist: matplotlib<4.0.0,>=3.8.0
+Requires-Dist: scikit-image<1.0.0,>=0.22.0
+Requires-Dist: tqdm<5.0.0,>=4.65.0
+Dynamic: license-file
+
+# **WASP** - **WA**ve **S**pectra **P**artitioning
+
+Watershed Algorithm for partitioning the ocean wave spectra from WW3 and SAR (Sentinel
+
+<!--
+
+**🔗 Companion Repository:** For analysis and validation of partitioned spectra, see [**HIVE** (Hierarchical Integration of Verified wavE partitions)](https://github.com/jtcarvalho/hive)
+
+-->
+
+## 📋 What is WASP?
+
+WASP focuses exclusively on **spectral partitioning** - the process of separating ocean wave spectra into individual wave systems (partitions). Each partition represents a distinct wave system characterized by significant wave height (Hs), peak period (Tp), and direction (Dp).
+
+**WASP handles:**
+
+- ✅ Spectral partitioning using watershed algorithm
+- ✅ Processing SAR (Sentinel) and WW3 model spectra
+- ✅ Extracting wave parameters (Hs, Tp, Dp) for each partition
+
+👉 **For analysis and validation**, use the repository [**HIVE**](https://github.com/jtcarvalho/hive)
+
+## 🚀 Installation
+
+### Método 1: Instalação Local (Desenvolvimento)
+
+Instale o pacote em modo editável para desenvolvimento ou uso local:
+
+```bash
+# Clone o repositório
+git clone https://github.com/jtcarvalho/wasp.git
+cd wasp
+
+# Instale em modo editável (recomendado)
+pip install -e .
+```
+
+### Método 2: Ambiente Virtual Tradicional
+
+```bash
+# Clone o repositório
+git clone https://github.com/jtcarvalho/wasp.git
+cd wasp
+
+# Crie ambiente virtual
+python -m venv venv
+
+# Ative o ambiente virtual
+# No macOS/Linux:
+source venv/bin/activate
+# No Windows:
+# venv\Scripts\activate
+
+# Instale o pacote
+pip install -e .
+```
+
+### Verificar Instalação
+
+```bash
+# Teste a importação
+python -c "import wasp; print(f'WASP version: {wasp.__version__}')"
+
+# Teste as funções principais
+python -c "from wasp import partition_spectrum, calculate_wave_parameters; print('✓ Instalação bem-sucedida!')"
+```
+
+## 📦 Key Dependencies
+
+- **NumPy >= 2.1.0** (required for `np.trapezoid`)
+- pandas >= 2.2.0
+- xarray >= 2024.11.0
+- matplotlib >= 3.8.0
+- scipy >= 1.14.0
+- scikit-image >= 0.22.0
+- netCDF4 >= 1.5.4
+
+> ⚠️ **Importante:** NumPy < 2.1.0 causará erros pois `np.trapezoid` não está disponível.
+
+## 💡 Uso Rápido
+
+### Como Biblioteca Python
+
+```python
+import numpy as np
+from wasp import partition_spectrum, calculate_wave_parameters
+
+# Seu espectro 2D (freq x dir)
+E = np.array(...)  # matriz de energia espectral [m²/Hz/rad]
+freq = np.array(...)  # frequências [Hz]
+dirs = np.array(...)  # direções [graus, convenção oceanográfica]
+
+# Particionar o espectro
+partitions = partition_spectrum(
+    E, freq, dirs,
+    energy_threshold=1e-6,
+    max_partitions=3
+)
+
+# Calcular parâmetros de cada partição
+for i, partition in enumerate(partitions):
+    params = calculate_wave_parameters(partition, freq, dirs)
+    print(f"Partição {i+1}:")
+    print(f"  Hs = {params['Hs']:.2f} m")
+    print(f"  Tp = {params['Tp']:.1f} s")
+    print(f"  Dp = {params['Dp']:.1f} deg")
+```
+
+### Scripts de Exemplo
+
+Veja a pasta [examples/](examples/) para scripts completos:
+
+- **01_partition_sar.py**: Processar espectros SAR (Sentinel-1)
+- **02_partition_ww3.py**: Processar espectros WaveWatch III
+- **03_partition_ndbc.py**: Template para processar dados de bóia NDBC
+- **04_validate.py**: Comparar e validar resultados SAR vs WW3
+
+```bash
+cd examples/
+python 01_partition_sar.py
+```

wasp_ocean-0.1.0/README.md

@@ -0,0 +1,121 @@
+# **WASP** - **WA**ve **S**pectra **P**artitioning
+
+Watershed Algorithm for partitioning the ocean wave spectra from WW3 and SAR (Sentinel
+
+<!--
+
+**🔗 Companion Repository:** For analysis and validation of partitioned spectra, see [**HIVE** (Hierarchical Integration of Verified wavE partitions)](https://github.com/jtcarvalho/hive)
+
+-->
+
+## 📋 What is WASP?
+
+WASP focuses exclusively on **spectral partitioning** - the process of separating ocean wave spectra into individual wave systems (partitions). Each partition represents a distinct wave system characterized by significant wave height (Hs), peak period (Tp), and direction (Dp).
+
+**WASP handles:**
+
+- ✅ Spectral partitioning using watershed algorithm
+- ✅ Processing SAR (Sentinel) and WW3 model spectra
+- ✅ Extracting wave parameters (Hs, Tp, Dp) for each partition
+
+👉 **For analysis and validation**, use the repository [**HIVE**](https://github.com/jtcarvalho/hive)
+
+## 🚀 Installation
+
+### Método 1: Instalação Local (Desenvolvimento)
+
+Instale o pacote em modo editável para desenvolvimento ou uso local:
+
+```bash
+# Clone o repositório
+git clone https://github.com/jtcarvalho/wasp.git
+cd wasp
+
+# Instale em modo editável (recomendado)
+pip install -e .
+```
+
+### Método 2: Ambiente Virtual Tradicional
+
+```bash
+# Clone o repositório
+git clone https://github.com/jtcarvalho/wasp.git
+cd wasp
+
+# Crie ambiente virtual
+python -m venv venv
+
+# Ative o ambiente virtual
+# No macOS/Linux:
+source venv/bin/activate
+# No Windows:
+# venv\Scripts\activate
+
+# Instale o pacote
+pip install -e .
+```
+
+### Verificar Instalação
+
+```bash
+# Teste a importação
+python -c "import wasp; print(f'WASP version: {wasp.__version__}')"
+
+# Teste as funções principais
+python -c "from wasp import partition_spectrum, calculate_wave_parameters; print('✓ Instalação bem-sucedida!')"
+```
+
+## 📦 Key Dependencies
+
+- **NumPy >= 2.1.0** (required for `np.trapezoid`)
+- pandas >= 2.2.0
+- xarray >= 2024.11.0
+- matplotlib >= 3.8.0
+- scipy >= 1.14.0
+- scikit-image >= 0.22.0
+- netCDF4 >= 1.5.4
+
+> ⚠️ **Importante:** NumPy < 2.1.0 causará erros pois `np.trapezoid` não está disponível.
+
+## 💡 Uso Rápido
+
+### Como Biblioteca Python
+
+```python
+import numpy as np
+from wasp import partition_spectrum, calculate_wave_parameters
+
+# Seu espectro 2D (freq x dir)
+E = np.array(...)  # matriz de energia espectral [m²/Hz/rad]
+freq = np.array(...)  # frequências [Hz]
+dirs = np.array(...)  # direções [graus, convenção oceanográfica]
+
+# Particionar o espectro
+partitions = partition_spectrum(
+    E, freq, dirs,
+    energy_threshold=1e-6,
+    max_partitions=3
+)
+
+# Calcular parâmetros de cada partição
+for i, partition in enumerate(partitions):
+    params = calculate_wave_parameters(partition, freq, dirs)
+    print(f"Partição {i+1}:")
+    print(f"  Hs = {params['Hs']:.2f} m")
+    print(f"  Tp = {params['Tp']:.1f} s")
+    print(f"  Dp = {params['Dp']:.1f} deg")
+```
+
+### Scripts de Exemplo
+
+Veja a pasta [examples/](examples/) para scripts completos:
+
+- **01_partition_sar.py**: Processar espectros SAR (Sentinel-1)
+- **02_partition_ww3.py**: Processar espectros WaveWatch III
+- **03_partition_ndbc.py**: Template para processar dados de bóia NDBC
+- **04_validate.py**: Comparar e validar resultados SAR vs WW3
+
+```bash
+cd examples/
+python 01_partition_sar.py
+```

wasp_ocean-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wasp-ocean"
+version = "0.1.0"
+description = "WAve Spectra Partitioning"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    {name = "Your Name", email = "your.email@example.com"}
+]
+keywords = ["waves", "oceanography", "SAR", "WaveWatch3", "spectral partitioning"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Atmospheric Science",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "numpy>=2.1.0,<3.0.0",
+    "pandas>=2.2.0,<3.0.0",
+    "scipy>=1.14.0,<2.0.0",
+    "xarray>=2024.11.0",
+    "netCDF4>=1.5.4,<2.0.0",
+    "matplotlib>=3.8.0,<4.0.0",
+    "scikit-image>=0.22.0,<1.0.0",
+    "tqdm>=4.65.0,<5.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/jtcarvalho/wasp"
+Repository = "https://github.com/jtcarvalho/wasp"
+Documentation = "https://github.com/jtcarvalho/wasp/blob/main/README.md"
+Issues = "https://github.com/jtcarvalho/wasp/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+wasp = ["*.py"]

wasp_ocean-0.1.0/setup.cfg

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

wasp_ocean-0.1.0/src/wasp/__init__.py

@@ -0,0 +1,45 @@
+"""
+WASP - Wave Analysis from Sentinel and WaveWatch III Partitioning
+==================================================================
+
+A Python package for spectral wave partitioning from SAR, WaveWatch III, and buoy data.
+
+Core modules:
+- partition: Spectral partitioning algorithms (Hanson & Phillips 2001)
+- wave_params: Wave parameter calculations (Hs, Tp, Dir, etc.)
+- io_sar: SAR data input/output
+- io_ww3: WaveWatch III data input/output
+- plotting: Visualization tools
+- utils: Utility functions
+
+Example usage:
+-------------
+    from wasp.partition import partition_spectrum
+    from wasp.wave_params import calculate_wave_parameters
+    
+    # Partition a 2D spectrum
+    partitions = partition_spectrum(
+        E, freq, dirs, 
+        energy_threshold=1e-6,
+        max_partitions=3
+    )
+    
+    # Calculate wave parameters for each partition
+    for i, partition in enumerate(partitions):
+        params = calculate_wave_parameters(partition, freq, dirs)
+        print(f"Partition {i+1}: Hs={params['Hs']:.2f}m, Tp={params['Tp']:.1f}s")
+"""
+
+__version__ = "0.1.0"
+__author__ = "Your Name"
+
+# Import main functions for easy access
+from .partition import partition_spectrum
+from .wave_params import calculate_wave_parameters
+from .utils import spectrum1d_from_2d
+
+__all__ = [
+    'partition_spectrum',
+    'calculate_wave_parameters',
+    'spectrum1d_from_2d',
+]

wasp_ocean-0.1.0/src/wasp/io_sar.py

@@ -0,0 +1,203 @@
+"""
+Funções para leitura e conversão de dados SAR (Sentinel-1)
+"""
+
+import numpy as np
+import pandas as pd
+
+
+def convert_sar_energy_units(E_sar, k, phi):
+    """
+    Converte espectro SAR de número de onda para frequência em m²·s·rad⁻¹ (padrão WW3).
+    
+    Aplica conversão usando o jacobiano da relação de dispersão:
+    E(f,θ) [m²·s·rad⁻¹] = E(k,θ) [m⁴] × |dk/df| × (π/180)
+    
+    Onde:
+    - |dk/df| = 8π²f/g  (jacobiano da relação de dispersão ω² = gk)
+    - π/180 converte de θ[graus] para θ[radianos]
+    
+    Parameters:
+    -----------
+    E_sar : ndarray
+        Espectro SAR em número de onda [m⁴]
+    k : ndarray
+        Números de onda [rad/m]
+    phi : ndarray
+        Direções [graus]
+    
+    Returns:
+    --------
+    E_m2_s_rad : ndarray (NF, ND)
+        Espectro convertido [m²·s·rad⁻¹]
+    freq : ndarray (NF,)
+        Frequências [Hz]
+    phi_oceanographic : ndarray (ND,)
+        Direções oceanográficas [graus]
+    dirs_rad : ndarray (ND,)
+        Direções em radianos
+    """
+    g = 9.81
+    omega = np.sqrt(g * k)
+    freq = omega / (2 * np.pi)
+    
+    # Jacobiano da transformação k -> f
+    # Da relação de dispersão: ω² = gk, onde ω = 2πf
+    # dk/df = 8π²f/g
+    dkdf = 8 * np.pi**2 * freq / g
+    dkdf_matrix = dkdf.reshape(-1, 1)
+    
+    # Conversão de direção: graus -> radianos na densidade espectral
+    # E(θ_rad) = E(θ_deg) × (π/180)
+    deg_to_rad_factor = np.pi / 180.0
+    
+    # E(k,θ) [m⁴] -> E(f,θ) [m²·s·rad⁻¹]
+    E_m2_s_rad = E_sar * dkdf_matrix * deg_to_rad_factor
+    
+    # Ajuste shape para (NF, ND)
+    if E_m2_s_rad.shape[0] != len(freq):
+        E_m2_s_rad = E_m2_s_rad.T
+    
+    # Dados SAR já estão em convenção oceanográfica (direção PARA onde vai)
+    phi_oceanographic = phi
+    dirs_rad = np.radians(phi_oceanographic)
+    
+    # Diagnóstico: calcular m0 e Hs
+    ddir = 2 * np.pi / len(phi)
+    m0 = 0
+    for j in range(len(phi)):
+        E_clean = np.where(np.isfinite(E_m2_s_rad[:, j]) & (E_m2_s_rad[:, j] >= 0), 
+                          E_m2_s_rad[:, j], 0)
+        m0 += np.trapezoid(E_clean, freq) * ddir
+    hs = 4 * np.sqrt(m0)
+    
+    print(f"╔══════════════════════════════════════════════════════════════╗")
+    print(f"║         CONVERSÃO SAR: m⁴ → m²·s·rad⁻¹ (WW3 units)          ║")
+    print(f"╠══════════════════════════════════════════════════════════════╣")
+    print(f"║ Shape: {str(E_sar.shape):>52} ║")
+    print(f"║ Frequências: {len(freq):>2d} bins | Direções: {len(phi):>2d} bins              ║")
+    print(f"║ Freq range: {freq[0]:.4f} - {freq[-1]:.4f} Hz                       ║")
+    print(f"║ Dir range: {phi[0]:.1f}° - {phi[-1]:.1f}°                            ║")
+    print(f"╟──────────────────────────────────────────────────────────────╢")
+    print(f"║ Jacobiano dk/df: {np.min(dkdf):.4f} - {np.max(dkdf):.4f}                   ║")
+    print(f"║ Fator angular (π/180): {deg_to_rad_factor:.6f}                      ║")
+    print(f"╟──────────────────────────────────────────────────────────────╢")
+    print(f"║ Parâmetros integrados:                                       ║")
+    print(f"║   m0 = {m0:>10.6f} m²                                          ║")
+    print(f"║   Hs = {hs:>10.6f} m                                           ║")
+    print(f"╚══════════════════════════════════════════════════════════════╝")
+    
+    return E_m2_s_rad, freq, phi_oceanographic, dirs_rad
+
+
+def load_sar_spectrum(ds, date_time=None, index=0):
+    """
+    Carrega espectro SAR para data/hora específica.
+    
+    Compatível com arquivos preprocessados Sentinel-1A/B (CMEMS).
+    Converte automaticamente de SAR (m⁴) para m²·s·rad⁻¹ (padrão WW3).
+    
+    Parameters:
+    -----------
+    ds : xarray.Dataset
+        Dataset SAR aberto
+    date_time : str or pd.Timestamp, optional
+        Data/hora específica para buscar. Se None, usa index.
+    index : int
+        Índice da observação a carregar (usado se date_time=None)
+    
+    Returns:
+    --------
+    E2d : ndarray (NF, ND)
+        Espectro direcional 2D [m²·s·rad⁻¹]
+    freq : ndarray (NF,)
+        Frequências [Hz]
+    dirs : ndarray (ND,)
+        Direções [graus]
+    dirs_rad : ndarray (ND,)
+        Direções [radianos]
+    actual_time : pd.Timestamp
+        Timestamp da observação carregada
+    """
+    print("Variáveis disponíveis no arquivo SAR:", list(ds.variables.keys()))
+    
+    # Função auxiliar para buscar variável por múltiplos nomes possíveis
+    def get_var(ds, varnames):
+        for var in varnames:
+            if var in ds.variables:
+                return ds[var].values
+        raise ValueError(f"Nenhuma das variáveis {varnames} encontrada no arquivo SAR.")
+
+    # Nomes possíveis para cada variável
+    wave_spec_names = ['wave_spec', 'obs_params/wave_spec', 'wave_spectrum', 
+                       'obs_params/wave_spectrum']
+    k_names = ['wavenumber_spec', 'obs_params/wavenumber_spec']
+    phi_names = ['direction_spec', 'obs_params/direction_spec']
+    time_names = ['time', 'obs_params/time', 'TIME', 'obs_time', 
+                  'acquisition_time', 'time_center', 'valid_time', 't']
+
+    try:
+        # Tentar formato preprocessado CMEMS
+        E_sar = get_var(ds, wave_spec_names)  # (NF, ND, Nobs)
+        k = get_var(ds, k_names)  # (NF,)
+        phi = get_var(ds, phi_names)  # (ND,)
+        
+        # Buscar tempo
+        times = None
+        for tname in time_names:
+            if tname in ds.variables:
+                times = ds[tname].values
+                break
+        
+        # Selecionar observação específica
+        nobs = E_sar.shape[2] if E_sar.ndim == 3 else 1
+        if nobs > 1:
+            if date_time is not None and times is not None:
+                if isinstance(date_time, str):
+                    date_time = pd.to_datetime(date_time)
+                idx = abs(times - np.datetime64(date_time)).argmin()
+                actual_time = pd.to_datetime(times[idx])
+            else:
+                idx = index
+                actual_time = pd.to_datetime(times[idx]) if times is not None else None
+            E_sar = np.squeeze(E_sar[:, :, idx])
+        else:
+            E_sar = np.squeeze(E_sar)
+            actual_time = pd.to_datetime(times[0]) if times is not None else None
+        
+        print(f"Usando arquivo preprocessado (CMEMS), shape E_sar: {E_sar.shape}")
+    
+    except Exception as e:
+        # Tentar formato antigo (oswPolSpec)
+        if 'oswPolSpec' in ds.variables:
+            if 'time' in ds and len(ds.time) > 1:
+                if date_time is not None:
+                    if isinstance(date_time, str):
+                        date_time = pd.to_datetime(date_time)
+                    idx = abs(ds.time.values - np.datetime64(date_time)).argmin()
+                    actual_time = pd.to_datetime(ds.time.values[idx])
+                else:
+                    idx = index
+                    actual_time = pd.to_datetime(ds.time.values[idx])
+                E_sar = np.squeeze(ds.oswPolSpec.values[idx])
+            else:
+                E_sar = np.squeeze(ds.oswPolSpec.values)
+                if 'time' in ds:
+                    timestamp = ds.time.values[0]
+                    actual_time = pd.to_datetime(timestamp)
+                else:
+                    actual_time = None
+            k = ds.oswK.values
+            phi = ds.oswPhi.values
+            print(f"Usando arquivo SAR antigo, shape E_sar: {E_sar.shape}")
+        else:
+            raise ValueError("Arquivo SAR não possui variáveis reconhecidas "
+                           "(nem wave_spec nem oswPolSpec)")
+
+    print(f"Shape k: {k.shape}")
+    print(f"Shape phi: {phi.shape}")
+    
+    # Converter SAR (m⁴) para m²·s·rad⁻¹ (padrão WW3)
+    E2d, freq, dirs, dirs_rad = convert_sar_energy_units(E_sar, k, phi)
+    
+    return E2d, freq, dirs, dirs_rad, actual_time

wasp_ocean-0.1.0/src/wasp/io_ww3.py

@@ -0,0 +1,80 @@
+"""
+Funções para leitura e processamento de dados WW3
+"""
+
+import numpy as np
+import pandas as pd
+import xarray as xr
+
+
+def find_closest_time(file_path, target_time_dt):
+    """
+    Encontra o timestamp mais próximo no dataset WW3 ao tempo alvo.
+    
+    Parameters:
+    -----------
+    file_path : str
+        Caminho do arquivo NetCDF do WW3
+    target_time_dt : pd.Timestamp
+        Tempo alvo para buscar
+    
+    Returns:
+    --------
+    itime : int
+        Índice do tempo mais próximo
+    closest_time : pd.Timestamp
+        Timestamp mais próximo encontrado
+    time_diff_hours : float
+        Diferença temporal em horas
+    """
+    ds_temp = xr.open_dataset(file_path)
+    ww3_times = pd.to_datetime(ds_temp.time.values)
+    
+    time_diffs = np.abs(ww3_times - target_time_dt)
+    itime = np.argmin(time_diffs)
+    closest_time = ww3_times[itime]
+    time_diff_hours = time_diffs[itime].total_seconds() / 3600
+    
+    ds_temp.close()
+    
+    return itime, closest_time, time_diff_hours
+
+
+def load_ww3_spectrum(file_path, time_index):
+    """
+    Carrega espectro direcional 2D do WW3 e coordenadas.
+    
+    Parameters:
+    -----------
+    file_path : str
+        Caminho do arquivo NetCDF do WW3
+    time_index : int
+        Índice temporal a carregar
+    
+    Returns:
+    --------
+    E2d : ndarray (NF, ND)
+        Espectro direcional 2D [m²·s·rad⁻¹]
+    freq : ndarray (NF,)
+        Frequências [Hz]
+    dirs : ndarray (ND,)
+        Direções [graus]
+    dirs_rad : ndarray (ND,)
+        Direções [radianos]
+    lon : float
+        Longitude do ponto
+    lat : float
+        Latitude do ponto
+    """
+    ds = xr.open_dataset(file_path)
+    
+    E2d = ds.efth[time_index, 0, :, :].values
+    freq = ds.frequency.values
+    dirs = ds.direction.values
+    dirs_rad = np.radians(dirs)
+    lon = ds.longitude.values[0]
+    lat = ds.latitude.values[0]
+    
+    ds.close()
+    
+    return E2d, freq, dirs, dirs_rad, lon, lat