815 lines
30 KiB
C#
815 lines
30 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.ComponentModel;
|
||
using System.Diagnostics;
|
||
using System.Linq;
|
||
using System.Windows.Media;
|
||
using CtrEditor.HydraulicSimulator;
|
||
using CtrEditor.HydraulicSimulator.TSNet.Components;
|
||
using CtrEditor.ObjetosSim;
|
||
using CtrEditor.FuncionesBase;
|
||
using HydraulicSimulator.Models;
|
||
using Newtonsoft.Json;
|
||
using Xceed.Wpf.Toolkit.PropertyGrid.Attributes;
|
||
using CommunityToolkit.Mvvm.ComponentModel;
|
||
using LibS7Adv;
|
||
|
||
namespace CtrEditor.ObjetosSim
|
||
{
|
||
/// <summary>
|
||
/// Tubería hidráulica que conecta componentes del sistema hidráulico
|
||
/// </summary>
|
||
public partial class osHydPipe : osBase, IHydraulicComponent, IHydraulicFlowReceiver, IHydraulicPressureReceiver, IosBase
|
||
{
|
||
// TSNet Integration
|
||
[JsonIgnore]
|
||
public TSNetPipeAdapter TSNetAdapter { get; private set; }
|
||
|
||
// Properties
|
||
|
||
private double _length = 1.0; // metros
|
||
private double _diameter = 0.05; // metros (50mm)
|
||
private double _roughness = 4.5e-5; // metros - rugosidad del acero comercial
|
||
private double _currentFlow = 0.0;
|
||
private double _pressureDrop = 0.0;
|
||
|
||
// Propiedades visuales
|
||
[ObservableProperty]
|
||
[property: Category("🎨 Apariencia")]
|
||
[property: Description("Ancho visual de la tubería en metros")]
|
||
[property: Name("Ancho")]
|
||
private float ancho = 1.0f;
|
||
|
||
[ObservableProperty]
|
||
[property: Category("🎨 Apariencia")]
|
||
[property: Description("Alto visual de la tubería en metros")]
|
||
[property: Name("Alto")]
|
||
private float alto = 0.05f;
|
||
|
||
[ObservableProperty]
|
||
[property: Category("🎨 Apariencia")]
|
||
[property: Description("Color visual de la tubería")]
|
||
[property: Name("Color")]
|
||
private Brush colorButton_oculto = Brushes.Gray;
|
||
|
||
[ObservableProperty]
|
||
[property: Category("🎨 Apariencia")]
|
||
[property: Description("Ángulo de rotación de la tubería en grados")]
|
||
[property: Name("Ángulo")]
|
||
private float angulo = 0f;
|
||
|
||
[Category("🔧 Tubería Hidráulica")]
|
||
[Description("Longitud de la tubería en metros")]
|
||
[Name("Longitud (m)")]
|
||
public double Length
|
||
{
|
||
get => _length;
|
||
set => SetProperty(ref _length, Math.Max(0.1, value));
|
||
}
|
||
|
||
[Category("🔧 Tubería Hidráulica")]
|
||
[Description("Diámetro interno de la tubería en metros")]
|
||
[Name("Diámetro (m)")]
|
||
public double Diameter
|
||
{
|
||
get => _diameter;
|
||
set => SetProperty(ref _diameter, Math.Max(0.001, value));
|
||
}
|
||
|
||
[Category("🔧 Tubería Hidráulica")]
|
||
[Description("Rugosidad del material en metros")]
|
||
[Name("Rugosidad (m)")]
|
||
public double Roughness
|
||
{
|
||
get => _roughness;
|
||
set => SetProperty(ref _roughness, Math.Max(1e-6, value));
|
||
}
|
||
|
||
[ObservableProperty]
|
||
[property: Category("🔗 Conexiones")]
|
||
[property: Description("Primer componente hidráulico conectado")]
|
||
[property: Name("Componente A")]
|
||
[property: ItemsSource(typeof(osBaseItemsSource<IHydraulicComponent>))]
|
||
private string id_ComponenteA = "";
|
||
|
||
[ObservableProperty]
|
||
[property: Category("🔗 Conexiones")]
|
||
[property: Description("Segundo componente hidráulico conectado")]
|
||
[property: Name("Componente B")]
|
||
[property: ItemsSource(typeof(osBaseItemsSource<IHydraulicComponent>))]
|
||
private string id_ComponenteB = "";
|
||
|
||
[Category("📊 Estado")]
|
||
[Description("Flujo actual a través de la tubería en m³/s")]
|
||
[Name("Flujo Actual (m³/s)")]
|
||
[ReadOnly(true)]
|
||
public double CurrentFlow
|
||
{
|
||
get => _currentFlow;
|
||
set => SetProperty(ref _currentFlow, value);
|
||
}
|
||
|
||
[Category("📊 Estado")]
|
||
[Description("Pérdida de presión en la tubería en Pa")]
|
||
[Name("Pérdida Presión (Pa)")]
|
||
[ReadOnly(true)]
|
||
public double PressureDrop
|
||
{
|
||
get => _pressureDrop;
|
||
set => SetProperty(ref _pressureDrop, value);
|
||
}
|
||
|
||
// Propiedades adicionales para información de fluido
|
||
private FluidProperties _currentFluid = new FluidProperties(FluidType.Air);
|
||
|
||
[Category("🧪 Fluido Actual")]
|
||
[DisplayName("Tipo de fluido")]
|
||
[Description("Tipo de fluido que atraviesa la tubería")]
|
||
[ReadOnly(true)]
|
||
public FluidType CurrentFluidType
|
||
{
|
||
get => _currentFluid.Type;
|
||
private set
|
||
{
|
||
if (_currentFluid.Type != value)
|
||
{
|
||
_currentFluid.Type = value;
|
||
OnPropertyChanged();
|
||
OnPropertyChanged(nameof(CurrentFluidDescription));
|
||
}
|
||
}
|
||
}
|
||
|
||
[Category("🧪 Fluido Actual")]
|
||
[DisplayName("Descripción")]
|
||
[Description("Descripción completa del fluido actual")]
|
||
[ReadOnly(true)]
|
||
public string CurrentFluidDescription => _currentFluid.Description;
|
||
|
||
[Category("🧪 Fluido Actual")]
|
||
[DisplayName("Temperatura (°C)")]
|
||
[Description("Temperatura del fluido en grados Celsius")]
|
||
[ReadOnly(true)]
|
||
[JsonProperty]
|
||
public double CurrentFluidTemperature => _currentFluid.Temperature;
|
||
|
||
[Category("🧪 Fluido Actual")]
|
||
[DisplayName("Brix (%)")]
|
||
[Description("Concentración en grados Brix (para jarabes)")]
|
||
[ReadOnly(true)]
|
||
[JsonProperty]
|
||
public double CurrentFluidBrix => _currentFluid.Brix;
|
||
|
||
[Category("🧪 Fluido Actual")]
|
||
[DisplayName("Concentración (%)")]
|
||
[Description("Concentración en porcentaje (para químicos)")]
|
||
[ReadOnly(true)]
|
||
[JsonProperty]
|
||
public double CurrentFluidConcentration => _currentFluid.Concentration;
|
||
|
||
[Category("🧪 Fluido Actual")]
|
||
[DisplayName("Densidad (kg/L)")]
|
||
[Description("Densidad del fluido en kg/L")]
|
||
[ReadOnly(true)]
|
||
[JsonProperty]
|
||
public double CurrentFluidDensity => _currentFluid.Density;
|
||
|
||
[Category("🧪 Fluido Actual")]
|
||
[DisplayName("Viscosidad (cP)")]
|
||
[Description("Viscosidad dinámica en centipoise")]
|
||
[ReadOnly(true)]
|
||
[JsonProperty]
|
||
public double CurrentFluidViscosity => _currentFluid.Viscosity;
|
||
|
||
[Category("🧪 Fluido Actual")]
|
||
[DisplayName("Velocidad (m/s)")]
|
||
[Description("Velocidad del fluido en la tubería")]
|
||
[ReadOnly(true)]
|
||
[JsonProperty]
|
||
public double FluidVelocity
|
||
{
|
||
get
|
||
{
|
||
if (Diameter <= 0) return 0;
|
||
var area = Math.PI * Math.Pow(Diameter / 2, 2); // m²
|
||
return Math.Abs(CurrentFlow) / area; // m/s
|
||
}
|
||
}
|
||
|
||
[Category("🧪 Fluido Actual")]
|
||
[DisplayName("Número de Reynolds")]
|
||
[Description("Número de Reynolds (Re = ρ × v × D / μ) - Caracteriza el régimen de flujo")]
|
||
[ReadOnly(true)]
|
||
[JsonProperty]
|
||
public double ReynoldsNumber
|
||
{
|
||
get
|
||
{
|
||
if (CurrentFluidViscosity <= 0 || Diameter <= 0) return 0;
|
||
|
||
// Re = (ρ × v × D) / μ
|
||
// ρ: densidad (kg/m³) - convertir de kg/L
|
||
// v: velocidad (m/s)
|
||
// D: diámetro (m)
|
||
// μ: viscosidad dinámica (Pa·s) - convertir de cP
|
||
|
||
var density_kg_m3 = CurrentFluidDensity * 1000; // kg/L → kg/m³
|
||
var viscosity_pa_s = CurrentFluidViscosity * 0.001; // cP → Pa·s
|
||
|
||
return (density_kg_m3 * FluidVelocity * Diameter) / viscosity_pa_s;
|
||
}
|
||
}
|
||
|
||
[Category("🧪 Fluido Actual")]
|
||
[DisplayName("Régimen de Flujo")]
|
||
[Description("Tipo de régimen basado en Reynolds (Laminar < 2300 < Turbulento)")]
|
||
[ReadOnly(true)]
|
||
[JsonProperty]
|
||
public string FlowRegime
|
||
{
|
||
get
|
||
{
|
||
var re = ReynoldsNumber;
|
||
return re switch
|
||
{
|
||
< 2300 => $"Laminar (Re = {re:F0})",
|
||
> 4000 => $"Turbulento (Re = {re:F0})",
|
||
_ => $"Transición (Re = {re:F0})"
|
||
};
|
||
}
|
||
}
|
||
|
||
// Método para exponer propiedades detalladas en serialización JSON
|
||
[JsonProperty("DetailedFluidProperties")]
|
||
[Browsable(false)]
|
||
public Dictionary<string, object> DetailedFluidProperties => new Dictionary<string, object>
|
||
{
|
||
["CurrentFluidTemperature"] = CurrentFluidTemperature,
|
||
["CurrentFluidBrix"] = CurrentFluidBrix,
|
||
["CurrentFluidConcentration"] = CurrentFluidConcentration,
|
||
["CurrentFluidDensity"] = CurrentFluidDensity,
|
||
["CurrentFluidViscosity"] = CurrentFluidViscosity,
|
||
["FluidVelocity"] = FluidVelocity,
|
||
["ReynoldsNumber"] = ReynoldsNumber,
|
||
["FlowRegime"] = FlowRegime
|
||
};
|
||
|
||
[Category("📊 Estado")]
|
||
[DisplayName("Flujo (L/min)")]
|
||
[Description("Flujo actual en litros por minuto")]
|
||
[ReadOnly(true)]
|
||
public double CurrentFlowLMin => Math.Abs(CurrentFlow) * 60000.0; // Conversión de m³/s a L/min
|
||
|
||
[Category("📊 Estado")]
|
||
[DisplayName("Dirección")]
|
||
[Description("Dirección del flujo")]
|
||
[ReadOnly(true)]
|
||
public string FlowDirection => CurrentFlow > 0 ? $"{Id_ComponenteA} → {Id_ComponenteB}" :
|
||
CurrentFlow < 0 ? $"{Id_ComponenteB} → {Id_ComponenteA}" : "Sin flujo";
|
||
|
||
[JsonIgnore]
|
||
public SolidColorBrush FluidColor
|
||
{
|
||
get
|
||
{
|
||
try
|
||
{
|
||
var colorHex = _currentFluid.Color;
|
||
return new SolidColorBrush((Color)ColorConverter.ConvertFromString(colorHex));
|
||
}
|
||
catch
|
||
{
|
||
return Brushes.Gray;
|
||
}
|
||
}
|
||
}
|
||
|
||
private string pipeId = "";
|
||
public string PipeId
|
||
{
|
||
get => pipeId;
|
||
set => SetProperty(ref pipeId, value);
|
||
}
|
||
|
||
|
||
|
||
// Component References
|
||
|
||
[JsonIgnore]
|
||
private IHydraulicComponent ComponenteA = null;
|
||
|
||
[JsonIgnore]
|
||
private IHydraulicComponent ComponenteB = null;
|
||
|
||
[JsonIgnore]
|
||
private PropertyChangedEventHandler componenteAPropertyChangedHandler;
|
||
|
||
[JsonIgnore]
|
||
private PropertyChangedEventHandler componenteBPropertyChangedHandler;
|
||
|
||
[JsonIgnore]
|
||
public Action<float, float> ActualizarTamaño { get; set; }
|
||
|
||
|
||
|
||
// IHydraulicPipe Implementation
|
||
|
||
// Ya implementadas las propiedades Length, Diameter, Roughness arriba
|
||
|
||
|
||
|
||
// IHydraulicComponent Implementation
|
||
|
||
public bool HasHydraulicComponents => true;
|
||
|
||
public List<HydraulicNodeDefinition> GetHydraulicNodes()
|
||
{
|
||
var nodes = new List<HydraulicNodeDefinition>();
|
||
|
||
// Las tuberías conectan componentes existentes, no crean nodos propios
|
||
// Los nodos son creados por los componentes conectados (tanques, bombas, etc.)
|
||
// La tubería solo actúa como elemento que conecta nodos existentes
|
||
|
||
return nodes;
|
||
}
|
||
|
||
public List<HydraulicElementDefinition> GetHydraulicElements()
|
||
{
|
||
var elements = new List<HydraulicElementDefinition>();
|
||
|
||
// Solo crear elemento si ambos componentes están conectados
|
||
if (!string.IsNullOrEmpty(Id_ComponenteA) && !string.IsNullOrEmpty(Id_ComponenteB))
|
||
{
|
||
// Obtener los nombres de nodos correctos para cada componente
|
||
string fromNodeName = GetNodeNameForComponent(Id_ComponenteA, true); // true = es el nodo origen
|
||
string toNodeName = GetNodeNameForComponent(Id_ComponenteB, false); // false = es el nodo destino
|
||
|
||
if (!string.IsNullOrEmpty(fromNodeName) && !string.IsNullOrEmpty(toNodeName))
|
||
{
|
||
// Crear el elemento Pipe según la documentación
|
||
var pipeElement = new Pipe(Length, Diameter, Roughness);
|
||
|
||
elements.Add(new HydraulicElementDefinition(
|
||
name: $"{Nombre}_Pipe",
|
||
fromNode: fromNodeName,
|
||
toNode: toNodeName,
|
||
element: pipeElement,
|
||
description: $"Tubería {Nombre} - L:{Length:F2}m, D:{Diameter*1000:F0}mm ({fromNodeName} → {toNodeName})"
|
||
));
|
||
}
|
||
}
|
||
|
||
return elements;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Obtiene el nombre del nodo correcto para un componente dado
|
||
/// </summary>
|
||
/// <param name="componentName">Nombre del componente</param>
|
||
/// <param name="isSource">True si es el nodo origen de la tubería, False si es destino</param>
|
||
/// <returns>Nombre del nodo o string vacío si no se encuentra</returns>
|
||
private string GetNodeNameForComponent(string componentName, bool isSource)
|
||
{
|
||
if (string.IsNullOrEmpty(componentName) || _mainViewModel == null)
|
||
return "";
|
||
|
||
// Buscar el componente hidráulico
|
||
var component = _mainViewModel.ObjetosSimulables
|
||
.FirstOrDefault(s => s is IHydraulicComponent comp &&
|
||
((osBase)comp).Nombre == componentName) as IHydraulicComponent;
|
||
|
||
if (component == null)
|
||
return "";
|
||
|
||
// Obtener los nodos que crea este componente
|
||
var nodes = component.GetHydraulicNodes();
|
||
if (nodes == null || !nodes.Any())
|
||
return "";
|
||
|
||
// Determinar qué nodo usar según el tipo de componente
|
||
var componentType = component.GetType();
|
||
|
||
// Para tanques: siempre usar su único nodo
|
||
if (componentType.Name.Contains("Tank"))
|
||
{
|
||
return nodes.FirstOrDefault()?.Name ?? "";
|
||
}
|
||
|
||
// Para bombas: usar nodo de entrada o salida según corresponda
|
||
if (componentType.Name.Contains("Pump"))
|
||
{
|
||
if (isSource)
|
||
{
|
||
// Si la tubería sale desde este componente, usar el nodo de salida de la bomba
|
||
return nodes.FirstOrDefault(n => n.Name.EndsWith("_Out"))?.Name ?? "";
|
||
}
|
||
else
|
||
{
|
||
// Si la tubería llega a este componente, usar el nodo de entrada de la bomba
|
||
return nodes.FirstOrDefault(n => n.Name.EndsWith("_In"))?.Name ?? "";
|
||
}
|
||
}
|
||
|
||
// Para otros tipos de componentes, usar el primer nodo disponible
|
||
return nodes.FirstOrDefault()?.Name ?? "";
|
||
}
|
||
|
||
public void UpdateHydraulicProperties()
|
||
{
|
||
// Actualizar propiedades antes de la simulación si es necesario
|
||
// Por ejemplo, cambios dinámicos en diámetro o rugosidad
|
||
}
|
||
|
||
public void ApplyHydraulicResults(Dictionary<string, double> flows, Dictionary<string, double> pressures)
|
||
{
|
||
try
|
||
{
|
||
// Aplicar resultados a través del TSNet Adapter
|
||
if (TSNetAdapter?.Results != null)
|
||
{
|
||
// Buscar flujo usando el nombre del elemento de TSNet
|
||
string pipeElementName = $"{Nombre}_Pipe";
|
||
|
||
if (flows.ContainsKey(pipeElementName))
|
||
{
|
||
var flowM3s = flows[pipeElementName];
|
||
CurrentFlow = flowM3s;
|
||
TSNetAdapter.Results.CalculatedFlowM3s = flowM3s;
|
||
|
||
Debug.WriteLine($"Pipe {Nombre}: TSNet Flow={flowM3s:F6} m³/s ({CurrentFlowLMin:F2} L/min)");
|
||
}
|
||
else
|
||
{
|
||
// Intentar claves alternativas basadas en componentes conectados
|
||
var alternativeKeys = new[]
|
||
{
|
||
$"{Id_ComponenteA}_{Id_ComponenteB}_Pipe",
|
||
$"Pipe_{Id_ComponenteA}_{Id_ComponenteB}",
|
||
TSNetAdapter.PipeId,
|
||
$"Branch_{Nombre}"
|
||
};
|
||
|
||
bool flowFound = false;
|
||
foreach (string altKey in alternativeKeys)
|
||
{
|
||
if (flows.ContainsKey(altKey))
|
||
{
|
||
var flowM3s = flows[altKey];
|
||
CurrentFlow = flowM3s;
|
||
TSNetAdapter.Results.CalculatedFlowM3s = flowM3s;
|
||
flowFound = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!flowFound)
|
||
{
|
||
CurrentFlow = 0.0;
|
||
TSNetAdapter.Results.CalculatedFlowM3s = 0.0;
|
||
}
|
||
}
|
||
|
||
// Calcular pérdida de presión entre nodos conectados
|
||
if (!string.IsNullOrEmpty(Id_ComponenteA) && !string.IsNullOrEmpty(Id_ComponenteB))
|
||
{
|
||
var fromNodeName = GetNodeNameForComponent(Id_ComponenteA, true);
|
||
var toNodeName = GetNodeNameForComponent(Id_ComponenteB, false);
|
||
|
||
if (pressures.ContainsKey(fromNodeName) && pressures.ContainsKey(toNodeName))
|
||
{
|
||
var pressureA = pressures[fromNodeName];
|
||
var pressureB = pressures[toNodeName];
|
||
PressureDrop = pressureA - pressureB;
|
||
TSNetAdapter.Results.PressureDropBar = PressureDrop;
|
||
|
||
Debug.WriteLine($"Pipe {Nombre}: Pressure drop={PressureDrop:F0} Pa ({fromNodeName} → {toNodeName})");
|
||
}
|
||
}
|
||
|
||
// Actualizar resultados del adapter
|
||
TSNetAdapter.Results.Timestamp = DateTime.Now;
|
||
TSNetAdapter.Results.FlowStatus = $"Flow: {CurrentFlowLMin:F1}L/min, Drop: {PressureDrop:F1}Pa";
|
||
|
||
// Actualizar fluido desde componente fuente
|
||
UpdateFluidFromSource();
|
||
}
|
||
|
||
// Notificar cambios para UI
|
||
OnPropertyChanged(nameof(CurrentFlow));
|
||
OnPropertyChanged(nameof(CurrentFlowLMin));
|
||
OnPropertyChanged(nameof(PressureDrop));
|
||
OnPropertyChanged(nameof(FlowDirection));
|
||
OnPropertyChanged(nameof(FluidVelocity));
|
||
OnPropertyChanged(nameof(ReynoldsNumber));
|
||
OnPropertyChanged(nameof(FlowRegime));
|
||
|
||
// Debug periódico
|
||
if (Environment.TickCount % 2000 < 50) // Cada ~2 segundos
|
||
{
|
||
Debug.WriteLine($"Pipe {Nombre}: Flow={CurrentFlowLMin:F1}L/min, Drop={PressureDrop:F1}Pa, {FlowDirection}");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.WriteLine($"Error en Pipe {Nombre} ApplyHydraulicResults: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
|
||
|
||
// IHydraulicFlowReceiver Implementation
|
||
|
||
public void SetFlow(double flow)
|
||
{
|
||
CurrentFlow = flow;
|
||
}
|
||
|
||
public double GetFlow()
|
||
{
|
||
return CurrentFlow;
|
||
}
|
||
|
||
|
||
|
||
// IHydraulicPressureReceiver Implementation
|
||
|
||
public void SetPressure(double pressure)
|
||
{
|
||
// Para tuberías, la presión se maneja a través de los nodos
|
||
}
|
||
|
||
public double GetPressure()
|
||
{
|
||
return PressureDrop;
|
||
}
|
||
|
||
|
||
|
||
// Connection Management
|
||
|
||
partial void OnId_ComponenteAChanged(string value)
|
||
{
|
||
if (ComponenteA != null && componenteAPropertyChangedHandler != null)
|
||
((INotifyPropertyChanged)ComponenteA).PropertyChanged -= componenteAPropertyChangedHandler;
|
||
|
||
if (_mainViewModel != null && !string.IsNullOrEmpty(value))
|
||
{
|
||
ComponenteA = (IHydraulicComponent)_mainViewModel.ObjetosSimulables
|
||
.FirstOrDefault(s => s is IHydraulicComponent comp &&
|
||
((osBase)comp).Nombre == value);
|
||
|
||
if (ComponenteA != null)
|
||
{
|
||
componenteAPropertyChangedHandler = (sender, e) =>
|
||
{
|
||
if (e.PropertyName == nameof(osBase.Nombre))
|
||
{
|
||
Id_ComponenteA = ((osBase)sender).Nombre;
|
||
}
|
||
};
|
||
((INotifyPropertyChanged)ComponenteA).PropertyChanged += componenteAPropertyChangedHandler;
|
||
}
|
||
}
|
||
}
|
||
|
||
partial void OnId_ComponenteBChanged(string value)
|
||
{
|
||
if (ComponenteB != null && componenteBPropertyChangedHandler != null)
|
||
((INotifyPropertyChanged)ComponenteB).PropertyChanged -= componenteBPropertyChangedHandler;
|
||
|
||
if (_mainViewModel != null && !string.IsNullOrEmpty(value))
|
||
{
|
||
ComponenteB = (IHydraulicComponent)_mainViewModel.ObjetosSimulables
|
||
.FirstOrDefault(s => s is IHydraulicComponent comp &&
|
||
((osBase)comp).Nombre == value);
|
||
|
||
if (ComponenteB != null)
|
||
{
|
||
componenteBPropertyChangedHandler = (sender, e) =>
|
||
{
|
||
if (e.PropertyName == nameof(osBase.Nombre))
|
||
{
|
||
Id_ComponenteB = ((osBase)sender).Nombre;
|
||
}
|
||
};
|
||
((INotifyPropertyChanged)ComponenteB).PropertyChanged += componenteBPropertyChangedHandler;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
// osBase Implementation
|
||
|
||
public static string NombreCategoria() => "Componentes Hidráulicos";
|
||
|
||
public static string NombreClase() => "Tubería Hidráulica";
|
||
|
||
private string nombre = NombreClase();
|
||
|
||
[Category("Identificación")]
|
||
[Description("Nombre identificativo del objeto")]
|
||
[Name("Nombre")]
|
||
public override string Nombre
|
||
{
|
||
get => nombre;
|
||
set => SetProperty(ref nombre, value);
|
||
}
|
||
|
||
public override void AltoChanged(float value)
|
||
{
|
||
ActualizarGeometrias();
|
||
}
|
||
|
||
public override void AnchoChanged(float value)
|
||
{
|
||
ActualizarGeometrias();
|
||
}
|
||
|
||
public void Start()
|
||
{
|
||
// Las tuberías no participan en la simulación física Bepu
|
||
// Solo en el sistema hidráulico
|
||
}
|
||
|
||
public override void UpdateGeometryStart()
|
||
{
|
||
// En el nuevo sistema unificado, el HydraulicSimulationManager se encarga
|
||
// de registrar automáticamente los objetos que implementan IHydraulicComponent
|
||
// No necesitamos crear objetos simHydraulic* separados
|
||
Debug.WriteLine($"[DEBUG] {Nombre}: UpdateGeometryStart() - ComponenteA: '{Id_ComponenteA}', ComponenteB: '{Id_ComponenteB}'");
|
||
ActualizarGeometrias();
|
||
}
|
||
|
||
public override void UpdateGeometryStep()
|
||
{
|
||
// Los objetos hidráulicos actualizan sus resultados
|
||
// a través de ApplyHydraulicResults() desde HydraulicSimulationManager
|
||
}
|
||
|
||
// Método para actualizar fluido desde componente fuente
|
||
public void UpdateFluidFromSource()
|
||
{
|
||
if (_mainViewModel?.ObjetosSimulables == null) return;
|
||
|
||
// Determinar componente fuente basado en dirección del flujo
|
||
string sourceComponentName = CurrentFlow >= 0 ? Id_ComponenteA : Id_ComponenteB;
|
||
|
||
var sourceComponent = _mainViewModel.ObjetosSimulables
|
||
.OfType<IHydraulicComponent>()
|
||
.FirstOrDefault(c => c is osBase osb && osb.Nombre == sourceComponentName);
|
||
|
||
if (sourceComponent is osHydTank tank)
|
||
{
|
||
var sourceFluid = tank.CurrentOutputFluid;
|
||
if (sourceFluid != null)
|
||
{
|
||
_currentFluid = sourceFluid.Clone();
|
||
OnPropertyChanged(nameof(CurrentFluidType));
|
||
OnPropertyChanged(nameof(CurrentFluidDescription));
|
||
OnPropertyChanged(nameof(FluidColor));
|
||
}
|
||
}
|
||
|
||
// Actualizar color visual
|
||
if (Math.Abs(CurrentFlow) > 1e-6) // Hay flujo
|
||
{
|
||
ColorButton_oculto = FluidColor;
|
||
}
|
||
else
|
||
{
|
||
ColorButton_oculto = Brushes.Gray; // Sin flujo
|
||
}
|
||
}
|
||
|
||
public override void UpdateControl(int elapsedMilliseconds)
|
||
{
|
||
// En el nuevo sistema TSNet, los valores provienen exclusivamente de TSNet
|
||
// No realizamos cálculos internos - solo actualizamos propiedades de UI
|
||
|
||
try
|
||
{
|
||
// Los resultados de TSNet ya están aplicados en ApplyHydraulicResults()
|
||
// Solo actualizamos propiedades derivadas y visuales
|
||
|
||
// Actualizar propiedades del fluido cada ciclo
|
||
UpdateFluidFromSource();
|
||
|
||
// Actualizar propiedades de UI calculadas
|
||
OnPropertyChanged(nameof(CurrentFlowLMin));
|
||
OnPropertyChanged(nameof(FlowDirection));
|
||
OnPropertyChanged(nameof(FluidVelocity));
|
||
OnPropertyChanged(nameof(ReynoldsNumber));
|
||
OnPropertyChanged(nameof(FlowRegime));
|
||
|
||
// Actualizar color visual basado en fluido
|
||
UpdatePipeColorFromFluid();
|
||
|
||
// Debug periódico cada 5 segundos
|
||
if (Environment.TickCount % 5000 < elapsedMilliseconds)
|
||
{
|
||
Debug.WriteLine($"Pipe {Nombre}: Flow={CurrentFlowLMin:F1}L/min, Drop={PressureDrop:F1}Pa, {FlowDirection}");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.WriteLine($"Error in Pipe {Nombre} UpdateControl: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
public override void ucLoaded()
|
||
{
|
||
// En el nuevo sistema unificado, no necesitamos crear objetos separados
|
||
base.ucLoaded();
|
||
}
|
||
|
||
public override void ucUnLoaded()
|
||
{
|
||
// En el nuevo sistema unificado, el HydraulicSimulationManager
|
||
// maneja automáticamente el registro/desregistro de objetos
|
||
base.ucUnLoaded();
|
||
}
|
||
|
||
public override void UpdatePLC(PLCViewModel plc, int elapsedMilliseconds)
|
||
{
|
||
// Las tuberías no tienen control PLC directo
|
||
}
|
||
|
||
private void ActualizarGeometrias()
|
||
{
|
||
try
|
||
{
|
||
// Actualizar geometría visual
|
||
if (this.ActualizarTamaño != null)
|
||
this.ActualizarTamaño(Ancho, Alto);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
System.Diagnostics.Debug.WriteLine($"Error actualizando geometría: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
public void Inicializar(int valorInicial)
|
||
{
|
||
PipeId = $"Pipe_{Nombre}_{valorInicial}";
|
||
OnId_ComponenteAChanged(Id_ComponenteA);
|
||
OnId_ComponenteBChanged(Id_ComponenteB);
|
||
}
|
||
|
||
public void Disposing()
|
||
{
|
||
if (ComponenteA != null && componenteAPropertyChangedHandler != null)
|
||
((INotifyPropertyChanged)ComponenteA).PropertyChanged -= componenteAPropertyChangedHandler;
|
||
|
||
if (ComponenteB != null && componenteBPropertyChangedHandler != null)
|
||
((INotifyPropertyChanged)ComponenteB).PropertyChanged -= componenteBPropertyChangedHandler;
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// Actualiza el color de la tubería basado en el fluido que transporta
|
||
/// </summary>
|
||
private void UpdatePipeColorFromFluid()
|
||
{
|
||
try
|
||
{
|
||
if (Math.Abs(CurrentFlow) < 1e-6)
|
||
{
|
||
ColorButton_oculto = Brushes.Gray; // Sin flujo
|
||
return;
|
||
}
|
||
|
||
// Color basado en el fluido actual
|
||
var fluidColor = FluidColor;
|
||
if (fluidColor != null)
|
||
{
|
||
ColorButton_oculto = fluidColor;
|
||
}
|
||
else
|
||
{
|
||
// Color por defecto según dirección de flujo
|
||
ColorButton_oculto = CurrentFlow > 0 ? Brushes.Blue : Brushes.Red;
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
ColorButton_oculto = Brushes.Gray; // Color por defecto en caso de error
|
||
}
|
||
}
|
||
|
||
// Constructor
|
||
|
||
public osHydPipe()
|
||
{
|
||
PipeId = Guid.NewGuid().ToString();
|
||
IsVisFilter = true; // Asegurar que el componente hidráulico sea visible en filtros
|
||
|
||
// No inicializar TSNet Adapter aquí - se creará cuando se registre con TSNetSimulationManager
|
||
// TSNetAdapter = new TSNetPipeAdapter(this);
|
||
}
|
||
|
||
|
||
}
|
||
}
|