scripts/gradient_analyzer.py

#!/usr/bin/env python3
"""
Analisador de Gradientes Térmicos
Calcula τ_eq (tempo de equilibração clássico) vs. observado
"""

import numpy as np
from dataclasses import dataclass

@dataclass
class GradientAnalysis:
    characteristic_length_m: float
    thermal_diffusivity_m2s: float
    tau_eq_classical_s: float
    tau_observed_s: float
    ratio_observed_to_classical: float
    falsifies_classical: bool

class GradientAnalyzer:
    """
    Análise de sustentação de gradientes térmicos.
    
    Clássico: τ_eq = L²/α (difusão térmica)
    Observado: τ_obs >> τ_eq em regime de fluxo ativo
    """
    
    # Difusividade térmica da água
    ALPHA_WATER = 1.4e-7  # m²/s
    
    def __init__(self, alpha: float = None):
        self.alpha = alpha or self.ALPHA_WATER
    
    def analyze(self, length_m: float, tau_observed_s: float) -> GradientAnalysis:
        """
        Compara tempo de equilibração clássico com observado.
        """
        tau_eq = length_m**2 / self.alpha
        ratio = tau_observed_s / tau_eq
        
        return GradientAnalysis(
            characteristic_length_m=length_m,
            thermal_diffusivity_m2s=self.alpha,
            tau_eq_classical_s=tau_eq,
            tau_observed_s=tau_observed_s,
            ratio_observed_to_classical=ratio,
            falsifies_classical=ratio > 2.0  # Fator 2+ já é anômalo
        )
    
    def entropy_deficit_rate(self, delta_S_J_per_K: float, 
                            duration_s: float) -> float:
        """
        Taxa de déficit de entropia (negentropy).
        dS/dt < 0 indica organização estrutural sustentada.
        """
        return delta_S_J_per_K / duration_s


# Análise do Experimento 1
if __name__ == "__main__":
    analyzer = GradientAnalyzer()
    
    # Experimento 1: Iceberg
    exp1 = analyzer.analyze(
        length_m=0.15,  # 15 cm
        tau_observed_s=730  # >12 minutos
    )
    
    print("Experimento 1 - The Iceberg:")
    print(f"  L = {exp1.characteristic_length_m*100:.1f} cm")
    print(f"  τ_eq (clássico) = {exp1.tau_eq_classical_s:.1f} s")
    print(f"  τ_observado = {exp1.tau_observed_s:.1f} s")
    print(f"  Razão = {exp1.ratio_observed_to_classical:.2f}×")
    print(f"  FALSIFICA clássico? {exp1.falsifies_classical}")
    
    # Déficit de entropia
    dS_dt = analyzer.entropy_deficit_rate(
        delta_S_J_per_K=180,  # ΔS ≈ 180 J/K
        duration_s=730
    )
    print(f"  Taxa de déficit entropico: {dS_dt:.3f} J/(K·s)")