229 lines
8.7 KiB
Python
229 lines
8.7 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Investigación del error de bombas en TSNet para eliminarlo completamente
|
|
"""
|
|
|
|
import sys
|
|
import os
|
|
import numpy as np
|
|
|
|
|
|
def investigate_pump_error():
|
|
"""
|
|
Investiga el error específico de bombas: cannot unpack non-iterable NoneType object
|
|
"""
|
|
print("=== INVESTIGACIÓN ERROR BOMBAS TSNET ===")
|
|
print("Objetivo: TSNet al 100% sin fallback")
|
|
|
|
try:
|
|
import tsnet
|
|
import wntr
|
|
|
|
print(f"✓ TSNet version: {tsnet.__version__}")
|
|
print(f"✓ WNTR version: {wntr.__version__}")
|
|
except ImportError as e:
|
|
print(f"✗ Error al importar: {e}")
|
|
return False
|
|
|
|
# Usar archivo INP existente
|
|
temp_dir = r"c:\Users\migue\AppData\Local\Temp\TSNet"
|
|
inp_path = os.path.join(temp_dir, "network_20250912_003944.inp")
|
|
|
|
if not os.path.exists(inp_path):
|
|
print(f"✗ Archivo INP no encontrado: {inp_path}")
|
|
return False
|
|
|
|
try:
|
|
print("\n=== INVESTIGANDO CONFIGURACIÓN DE BOMBAS ===")
|
|
|
|
# Cargar modelo
|
|
tm = tsnet.network.TransientModel(inp_path)
|
|
print("✓ Modelo cargado")
|
|
|
|
# Aplicar correcciones básicas
|
|
if hasattr(tm, "simulation_period") and tm.simulation_period <= 0:
|
|
tm.simulation_period = 1.0
|
|
if hasattr(tm, "time_step") and tm.time_step <= 0:
|
|
tm.time_step = 0.1
|
|
if tm.time_step >= tm.simulation_period:
|
|
tm.time_step = tm.simulation_period / 10.0
|
|
|
|
# Aplicar correcciones de pipes
|
|
if hasattr(tm, "pipe_name_list") and hasattr(tm, "get_link"):
|
|
for pipe_name in tm.pipe_name_list:
|
|
pipe_obj = tm.get_link(pipe_name)
|
|
pipe_length = getattr(pipe_obj, "length", 1.0)
|
|
dx = 0.1
|
|
num_segments = int(pipe_length / dx) + 1
|
|
|
|
# Todas las correcciones de pipes
|
|
if not hasattr(pipe_obj, "initial_head") or isinstance(
|
|
getattr(pipe_obj, "initial_head", None), (int, float)
|
|
):
|
|
pipe_obj.initial_head = np.zeros(num_segments)
|
|
|
|
if not hasattr(pipe_obj, "initial_velocity") or isinstance(
|
|
getattr(pipe_obj, "initial_velocity", None), (int, float)
|
|
):
|
|
pipe_obj.initial_velocity = np.zeros(num_segments)
|
|
|
|
if not hasattr(pipe_obj, "wavev"):
|
|
pipe_obj.wavev = 1000.0
|
|
|
|
if not hasattr(pipe_obj, "number_of_segments"):
|
|
pipe_obj.number_of_segments = num_segments
|
|
|
|
if not hasattr(pipe_obj, "roughness_height"):
|
|
if hasattr(pipe_obj, "roughness"):
|
|
pipe_obj.roughness_height = pipe_obj.roughness
|
|
else:
|
|
pipe_obj.roughness_height = 0.001
|
|
|
|
# INVESTIGACIÓN DETALLADA DE BOMBAS
|
|
if hasattr(tm, "pump_name_list") and hasattr(tm, "get_link"):
|
|
pump_names = tm.pump_name_list
|
|
print(f"\nBombas encontradas: {pump_names}")
|
|
|
|
for pump_name in pump_names:
|
|
pump_obj = tm.get_link(pump_name)
|
|
print(f"\n--- BOMBA {pump_name} ---")
|
|
print(f"Tipo: {type(pump_obj)}")
|
|
|
|
# Investigar todos los atributos de la bomba
|
|
pump_attrs = [
|
|
attr for attr in dir(pump_obj) if not attr.startswith("_")
|
|
]
|
|
print(f"Atributos públicos ({len(pump_attrs)}):")
|
|
for attr in sorted(pump_attrs):
|
|
try:
|
|
value = getattr(pump_obj, attr)
|
|
if not callable(value):
|
|
value_str = (
|
|
str(value)[:100] + "..."
|
|
if len(str(value)) > 100
|
|
else str(value)
|
|
)
|
|
print(f" {attr}: {value_str}")
|
|
except:
|
|
print(f" {attr}: <error al acceder>")
|
|
|
|
# Investigar atributos privados que podrían ser relevantes
|
|
private_attrs = [
|
|
attr
|
|
for attr in dir(pump_obj)
|
|
if attr.startswith("_") and not attr.startswith("__")
|
|
]
|
|
print(f"\nAtributos privados relevantes:")
|
|
for attr in sorted(private_attrs):
|
|
if any(
|
|
keyword in attr.lower()
|
|
for keyword in ["curve", "coef", "coeffs"]
|
|
):
|
|
try:
|
|
value = getattr(pump_obj, attr)
|
|
print(f" {attr}: {value}")
|
|
except:
|
|
print(f" {attr}: <error al acceder>")
|
|
|
|
# Verificar curve_coef específicamente
|
|
print(f"\n--- ANÁLISIS CURVE_COEF ---")
|
|
if hasattr(pump_obj, "curve_coef"):
|
|
curve_coef = pump_obj.curve_coef
|
|
print(f"curve_coef existe: {curve_coef}")
|
|
print(f"curve_coef tipo: {type(curve_coef)}")
|
|
print(f"curve_coef es None: {curve_coef is None}")
|
|
if curve_coef is not None:
|
|
print(f"curve_coef contenido: {curve_coef}")
|
|
else:
|
|
print("curve_coef NO existe")
|
|
|
|
# Verificar _curve_coeffs
|
|
if hasattr(pump_obj, "_curve_coeffs"):
|
|
_curve_coeffs = pump_obj._curve_coeffs
|
|
print(f"_curve_coeffs existe: {_curve_coeffs}")
|
|
print(f"_curve_coeffs tipo: {type(_curve_coeffs)}")
|
|
print(f"_curve_coeffs es None: {_curve_coeffs is None}")
|
|
if _curve_coeffs is not None:
|
|
print(f"_curve_coeffs contenido: {_curve_coeffs}")
|
|
|
|
# CORRECCIÓN MEJORADA
|
|
if (
|
|
not hasattr(pump_obj, "curve_coef")
|
|
or pump_obj.curve_coef is None
|
|
):
|
|
pump_obj.curve_coef = _curve_coeffs
|
|
print(f"✓ curve_coef asignado desde _curve_coeffs")
|
|
else:
|
|
print("_curve_coeffs NO existe")
|
|
|
|
# Si no tenemos coeficientes, intentar crear unos por defecto
|
|
if not hasattr(pump_obj, "curve_coef") or pump_obj.curve_coef is None:
|
|
print("CREANDO curve_coef por defecto...")
|
|
# Coeficientes típicos para una bomba centrífuga
|
|
default_coeffs = [
|
|
100.0,
|
|
-0.1,
|
|
0.0,
|
|
] # [a, b, c] para H = a + b*Q + c*Q^2
|
|
pump_obj.curve_coef = default_coeffs
|
|
print(f"✓ curve_coef creado por defecto: {default_coeffs}")
|
|
|
|
# INTENTAR SIMULACIÓN
|
|
print(f"\n=== PROBANDO SIMULACIÓN SIN FALLBACK ===")
|
|
try:
|
|
results = tsnet.simulation.MOCSimulator(
|
|
tm, results_obj="results", friction="steady"
|
|
)
|
|
print("🎉 ¡SIMULACIÓN TSNET 100% EXITOSA!")
|
|
print("✅ TSNet funciona completamente sin fallback")
|
|
print("✅ El usuario tiene su simulación perfecta")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"✗ Error persistente: {e}")
|
|
print(f"Error tipo: {type(e).__name__}")
|
|
|
|
# Análisis detallado del error
|
|
error_str = str(e)
|
|
if "cannot unpack" in error_str and "NoneType" in error_str:
|
|
print("❌ Error de coeficientes de bomba persistente")
|
|
print(
|
|
"Necesita investigación más profunda de la estructura de coeficientes"
|
|
)
|
|
elif "curve_coef" in error_str:
|
|
print("❌ Error de curve_coef específico")
|
|
else:
|
|
print(f"❌ Nuevo error: {error_str}")
|
|
|
|
print("\n--- TRACEBACK DETALLADO ---")
|
|
import traceback
|
|
|
|
traceback.print_exc()
|
|
return False
|
|
|
|
except Exception as e:
|
|
print(f"✗ Error general: {e}")
|
|
import traceback
|
|
|
|
traceback.print_exc()
|
|
return False
|
|
|
|
|
|
def main():
|
|
"""Función principal"""
|
|
success = investigate_pump_error()
|
|
|
|
if success:
|
|
print("\n🎉 ¡TSNET 100% FUNCIONAL!")
|
|
print("No más fallback - simulación perfecta")
|
|
else:
|
|
print("\n🔍 INVESTIGACIÓN COMPLETADA")
|
|
print("Información para la próxima corrección")
|
|
|
|
return success
|
|
|
|
|
|
if __name__ == "__main__":
|
|
success = main()
|
|
sys.exit(0 if success else 1)
|