From 0147e010d30dc3105796a77dc6b1714ada387baa Mon Sep 17 00:00:00 2001
From: Miguel <miguel.vera.csa@gmail.com>
Date: Fri, 5 Sep 2025 15:41:17 +0200
Subject: [PATCH] Refactor hydraulic components: Updated osHydPump and added
 osHydTank class with dynamic level and pressure management. Enhanced XAML for
 tank visualization and implemented converters for UI binding. Improved error
 handling in converters and added tests for hydraulic component detection.

---
 App.xaml                                      |  12 +-
 Controls/osVisFilter.xaml.cs                  |  22 +-
 Converters/TankLevelToHeightConverter.cs      | 121 +++
 Documentation/MemoriadeEvolucion.md           |  98 ++-
 FilterDebugTest.cs                            |  43 +
 .../Tests/QuickHydraulicTest.cs               |  46 -
 ObjetosSim/HydraulicComponents/osHydPipe.cs   |   1 +
 ObjetosSim/HydraulicComponents/osHydPump.cs   |  40 +-
 ObjetosSim/HydraulicComponents/osHydTank.cs   | 790 ++++++++++++++++++
 ObjetosSim/HydraulicComponents/ucHydTank.xaml | 135 +++
 .../HydraulicComponents/ucHydTank.xaml.cs     | 126 +++
 XAMLhelpers.cs                                |  74 +-
 test_osBaseItemsSource.cs                     |   7 +
 13 files changed, 1436 insertions(+), 79 deletions(-)
 create mode 100644 Converters/TankLevelToHeightConverter.cs
 create mode 100644 FilterDebugTest.cs
 delete mode 100644 HydraulicSimulator/Tests/QuickHydraulicTest.cs
 create mode 100644 ObjetosSim/HydraulicComponents/ucHydTank.xaml
 create mode 100644 ObjetosSim/HydraulicComponents/ucHydTank.xaml.cs

diff --git a/App.xaml b/App.xaml
index 2da8429..bd9f193 100644
--- a/App.xaml
+++ b/App.xaml
@@ -1,7 +1,9 @@
 <Application x:Class="CtrEditor.App" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="clr-namespace:CtrEditor"
         xmlns:osExtraccion="clr-namespace:CtrEditor.ObjetosSim.Extraccion_Datos"
-        xmlns:os="clr-namespace:CtrEditor.ObjetosSim" StartupUri="MainWindow.xaml">
+        xmlns:os="clr-namespace:CtrEditor.ObjetosSim" 
+        xmlns:converters="clr-namespace:CtrEditor.Converters"
+        StartupUri="MainWindow.xaml">
 
     <Application.Resources>
         <local:MeterToPixelConverter x:Key="MeterToPixelConverter" />
@@ -24,6 +26,14 @@
         <local:SubclassFilterConverter x:Key="SubclassFilterConverterosVMMotor" TargetType="{x:Type os:osVMmotorSim}" />
         <local:UnsavedChangesConverter x:Key="UnsavedChangesConverter"/>
         <local:BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter"/>
+        <converters:TankLevelToHeightConverter x:Key="TankLevelToHeightConverter"/>
+        
+        <!-- DropShadowEffect para efectos de sombra en texto -->
+        <DropShadowEffect x:Key="DropShadowEffect" 
+                          Color="Black" 
+                          BlurRadius="3" 
+                          ShadowDepth="1" 
+                          Opacity="0.5"/>
         
         <!-- Estilo global para TreeViewItem para evitar errores de binding -->
         <Style TargetType="TreeViewItem">
diff --git a/Controls/osVisFilter.xaml.cs b/Controls/osVisFilter.xaml.cs
index 643c57b..ed7ca1c 100644
--- a/Controls/osVisFilter.xaml.cs
+++ b/Controls/osVisFilter.xaml.cs
@@ -193,11 +193,20 @@ namespace CtrEditor.Controls
                     var newFilter = new TypeFilterItem(type)
                     {
                         DisplayName = GetTypeDisplayName(type),
-                        IsSelected = true
+                        IsSelected = true  // Nuevos tipos empiezan seleccionados por defecto
                     };
                     SubscribeToTypeFilter(newFilter);
                     TypeFilters.Add(newFilter);
                 }
+                else
+                {
+                    // Asegurar que los tipos existentes de componentes hidráulicos estén seleccionados
+                    var existingFilter = TypeFilters.FirstOrDefault(tf => tf.Type == type);
+                    if (existingFilter != null && IsHydraulicComponentType(type) && !existingFilter.IsSelected)
+                    {
+                        existingFilter.IsSelected = true;
+                    }
+                }
             }
         }
 
@@ -286,6 +295,17 @@ namespace CtrEditor.Controls
                 methodInfo.Invoke(null, null)?.ToString() :
                 type.Name;
         }
+
+        /// <summary>
+        /// Verifica si un tipo es un componente hidráulico
+        /// </summary>
+        private bool IsHydraulicComponentType(Type type)
+        {
+            // Verificar si el tipo implementa IHydraulicComponent o está en el namespace de componentes hidráulicos
+            return type.Namespace != null && 
+                   (type.Namespace.Contains("HydraulicComponents") || 
+                    type.GetInterfaces().Any(i => i.Name.Contains("Hydraulic")));
+        }
     }
 
     /// <summary>
diff --git a/Converters/TankLevelToHeightConverter.cs b/Converters/TankLevelToHeightConverter.cs
new file mode 100644
index 0000000..63a993f
--- /dev/null
+++ b/Converters/TankLevelToHeightConverter.cs
@@ -0,0 +1,121 @@
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.Windows.Data;
+
+namespace CtrEditor.Converters
+{
+    /// <summary>
+    /// Converter para calcular la altura del nivel de líquido en un tanque
+    /// basado en el porcentaje de llenado y el tamaño del tanque
+    /// </summary>
+    public class TankLevelToHeightConverter : IMultiValueConverter
+    {
+        public TankLevelToHeightConverter()
+        {
+            Console.WriteLine("TankLevelToHeightConverter: Constructor called");
+        }
+
+        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
+        {
+            // Debug: Registrar valores de entrada
+            Console.WriteLine($"TankLevelToHeightConverter.Convert: values.Length={values?.Length ?? 0}");
+            if (values != null)
+            {
+                for (int i = 0; i < values.Length; i++)
+                {
+                    Console.WriteLine($"  values[{i}]: {values[i]} (Type: {values[i]?.GetType().Name ?? "null"})");
+                }
+            }
+
+            if (values.Length != 2)
+            {
+                Console.WriteLine("TankLevelToHeightConverter.Convert: Returning 0.0 - wrong values count");
+                return 0.0;
+            }
+
+            // Convertir flexiblemente los valores a double
+            if (!TryConvertToDouble(values[0], out double fillPercentage) ||
+                !TryConvertToDouble(values[1], out double tankSize))
+            {
+                Console.WriteLine("TankLevelToHeightConverter.Convert: Conversion failed - unable to convert values to double");
+                return 0.0;
+            }
+
+            Console.WriteLine($"TankLevelToHeightConverter.Convert: fillPercentage={fillPercentage}, tankSize={tankSize}");
+
+            try
+            {
+                // Calcular altura basada en el porcentaje de llenado
+                // tankSize está en metros, convertir a píxeles (aproximación: 100 píxeles por metro)
+                var tankHeightPixels = tankSize * 100.0;
+                
+                // Altura del líquido = porcentaje de llenado * altura total del tanque
+                var liquidHeight = (fillPercentage / 100.0) * tankHeightPixels;
+                
+                // Aplicar margen interno (restar 8 píxeles para los márgenes del XAML)
+                var availableHeight = tankHeightPixels - 8.0; // 4px arriba + 4px abajo
+                var adjustedHeight = (fillPercentage / 100.0) * availableHeight;
+                
+                // Asegurar que la altura sea positiva y no exceda el contenedor
+                var result = Math.Max(0.0, Math.Min(adjustedHeight, availableHeight));
+                Console.WriteLine($"TankLevelToHeightConverter.Convert: Returning {result}");
+                return result;
+            }
+            catch (Exception ex)
+            {
+                // En caso de error, retornar 0
+                Console.WriteLine($"TankLevelToHeightConverter.Convert: Exception - {ex.Message}");
+                return 0.0;
+            }
+        }
+
+        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
+        {
+            throw new NotImplementedException("TankLevelToHeightConverter no soporta conversión inversa");
+        }
+
+        /// <summary>
+        /// Convierte un valor a double de manera flexible
+        /// </summary>
+        private static bool TryConvertToDouble(object value, out double result)
+        {
+            result = 0.0;
+
+            if (value == null)
+                return false;
+
+            if (value is double d)
+            {
+                result = d;
+                return true;
+            }
+
+            if (value is float f)
+            {
+                result = f;
+                return true;
+            }
+
+            if (value is int i)
+            {
+                result = i;
+                return true;
+            }
+
+            if (value is decimal dec)
+            {
+                result = (double)dec;
+                return true;
+            }
+
+            // Intentar conversión de string
+            if (value is string str && double.TryParse(str, out result))
+            {
+                return true;
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/Documentation/MemoriadeEvolucion.md b/Documentation/MemoriadeEvolucion.md
index d4431df..d6053b3 100644
--- a/Documentation/MemoriadeEvolucion.md
+++ b/Documentation/MemoriadeEvolucion.md
@@ -360,7 +360,7 @@ Aunque la simulación funcionaba correctamente y los valores se calculaban bien,
 <!-- DataContext se establece desde el objeto padre, no aquí -->
 ```
 
-### Resultado Final
+### Resultado Final del Sistema Hidráulico
 Sistema hidráulico completamente funcional:
 - ✅ Convergencia estable del solver con residuales < 1e-3
 - ✅ Registro único de objetos (sin duplicados)
@@ -369,6 +369,102 @@ Sistema hidráulico completamente funcional:
 - ✅ Bomba genera flujo y presión reales según configuración
 - ✅ **UserControl muestra valores actualizados en tiempo real**
 
+## Nuevo Tanque Hidráulico Avanzado (osHydTank)
+
+### Arquitectura Modular Implementada
+
+Se siguió el enfoque arquitectónico de **"Tanques como Terminales + Pipes como Conectores"** para crear un sistema más realista y mantenible:
+
+```
+[Tanque Succión] → [Pipe] → [Bomba] → [Pipe] → [Válvula] → [Pipe] → [Tanque Descarga]
+```
+
+### Características del osHydTank
+
+**Gestión Dinámica de Nivel:**
+- Nivel calculado en base a flujos de entrada y salida
+- Seguimiento de volumen actual vs. máximo/mínimo
+- Indicadores visuales de estado del tanque
+- Detección automática de desbordamiento y vaciado
+
+**Presión Configurable:**
+- Presión independiente del nivel (simulando PID externo)
+- Opción de presión fija o variable
+- Diferentes tipos de tanque: Succión, Intermedio, Almacenamiento, Proceso
+
+**Interfaces Hidráulicas:**
+- `IHydraulicComponent`: Integración con red hidráulica
+- `IHydraulicFlowReceiver`: Recepción de flujos calculados
+- `IHydraulicPressureReceiver`: Actualización de presiones
+
+**UserControl Avanzado:**
+- Visualización en tiempo real del nivel de líquido
+- Indicadores de tipo de tanque y conexiones
+- Balance de flujo con códigos de color
+- Conversión automática de TankLevelToHeightConverter
+
+## Solución de Problemas de Visualización osHydTank
+
+### Problema
+El componente `osHydTank` no se mostraba correctamente en el canvas a pesar de registrarse exitosamente en el sistema hidráulico. Los logs mostraban errores de binding en el MultiBinding del rectángulo de nivel del líquido.
+
+### Análisis
+1. **Error de Converter**: El XAML usaba `TankLevelToHeightConverter` que tenía incompatibilidades de tipos
+2. **Falta de inicialización**: El UserControl `ucHydTank` no llamaba a `ucLoaded()`/`ucUnLoaded()` como otros componentes
+3. **Binding incorrecto**: No se convertía `Tamano` a píxeles antes del MultiBinding
+
+### Solución Implementada
+1. **Cambio de Converter**: Reemplazamos `TankLevelToHeightConverter` por `LevelToHeightMultiConverter` (que funciona en otros componentes)
+2. **Conversión a Píxeles**: Agregamos `MeterToPixelConverter` a `Tamano` antes del MultiBinding
+3. **Ciclo de Vida**: Implementamos las llamadas correctas a `ucLoaded()`/`ucUnLoaded()` en `ucHydTank.xaml.cs`
+
+### Cambios Técnicos
+- **XAML**: `<Binding Path="Tamano" Converter="{StaticResource MeterToPixelConverter}"/>`
+- **UserControl**: Agregado `Unloaded += OnUserControlUnloaded` y llamadas a `ucLoaded()`/`ucUnLoaded()`
+- **Converter Corregido**: `LevelToHeightMultiConverter` ahora usa `System.Convert.ToDouble()` para flexibilidad de tipos
+- **Patrón consistente** con `ucHydPump`, `ucHydDischargeTank` y `ucHydPipe`
+
+### Detalle del Error del Converter
+El `LevelToHeightMultiConverter` esperaba tipos específicos (`float` y `double`) pero recibía tipos invertidos:
+- `FillPercentage`: `double` (esperaba `float`)
+- `MeterToPixelConverter` output: `float` (esperaba `double`)
+
+**Solución**: Implementar función `TryConvertToDouble()` robusta que maneja:
+- Valores especiales de WPF (`DependencyProperty.UnsetValue`, `MS.Internal.NamedObject`)
+- Múltiples tipos numéricos (`double`, `float`, `int`, `decimal`)
+- Conversión segura de strings
+- Verificación `IConvertible` antes de usar `System.Convert.ToDouble()`
+
+### Validación de Arquitectura
+
+El sistema ahora requiere que:
+- Todo circuito hidráulico **inicie con un tanque**
+- Todo circuito hidráulico **termine con un tanque**
+- Los `pipes` sean los únicos conectores entre componentes
+- Cada componente tenga **responsabilidad única**
+
+### Beneficios del Nuevo Diseño
+
+**Realismo Físico:** 
+- Refleja sistemas hidráulicos reales donde tanques son puntos de referencia
+- Presión independiente del nivel (como en sistemas industriales)
+- Gestión de volumen dinámica
+
+**Escalabilidad:**
+- Patrón consistente para nuevos componentes hidráulicos
+- Fácil conexión de válvulas, filtros, intercambiadores de calor
+- Sistema preparado para redes complejas
+
+**Mantenibilidad:**
+- Principio de responsabilidad única por componente
+- Interfaces claras y bien definidas
+- Debugging simplificado con logging detallado
+
+**Flexibilidad:**
+- Diferentes tipos de tanques para diferentes funciones
+- Configuración de presión independiente
+- Conectividad modular via pipes
+
 La bomba ahora debe mostrar correctamente:
 - **Presión actual** en bar (ej: "1.0 bar") 
 - **Caudal actual** en L/min (ej: "165.8 L/min")
diff --git a/FilterDebugTest.cs b/FilterDebugTest.cs
new file mode 100644
index 0000000..02d5c8a
--- /dev/null
+++ b/FilterDebugTest.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Linq;
+using CtrEditor.ObjetosSim.HydraulicComponents;
+
+namespace CtrEditor.Test
+{
+    class FilterDebugTest
+    {
+        static void TestHydraulicComponentDetection()
+        {
+            // Test hydraulic component detection logic like in osVisFilter
+            var tankType = typeof(osHydTank);
+            var pipeType = typeof(osHydPipe);
+            
+            Console.WriteLine("=== Tank Type Analysis ===");
+            Console.WriteLine($"Tank Type: {tankType.FullName}");
+            Console.WriteLine($"Tank Namespace: {tankType.Namespace}");
+            Console.WriteLine($"Has HydraulicComponents in namespace: {tankType.Namespace?.Contains("HydraulicComponents")}");
+            Console.WriteLine($"Tank Interfaces: {string.Join(", ", tankType.GetInterfaces().Select(i => i.Name))}");
+            Console.WriteLine($"Has Hydraulic interface: {tankType.GetInterfaces().Any(i => i.Name.Contains("Hydraulic"))}");
+            
+            Console.WriteLine("\n=== Pipe Type Analysis ===");
+            Console.WriteLine($"Pipe Type: {pipeType.FullName}");
+            Console.WriteLine($"Pipe Namespace: {pipeType.Namespace}");
+            Console.WriteLine($"Has HydraulicComponents in namespace: {pipeType.Namespace?.Contains("HydraulicComponents")}");
+            Console.WriteLine($"Pipe Interfaces: {string.Join(", ", pipeType.GetInterfaces().Select(i => i.Name))}");
+            Console.WriteLine($"Has Hydraulic interface: {pipeType.GetInterfaces().Any(i => i.Name.Contains("Hydraulic"))}");
+            
+            // Test the exact logic from IsHydraulicComponentType
+            Console.WriteLine("\n=== IsHydraulicComponentType Logic Test ===");
+            bool tankIsHydraulic = tankType.Namespace != null && 
+                                   (tankType.Namespace.Contains("HydraulicComponents") || 
+                                    tankType.GetInterfaces().Any(i => i.Name.Contains("Hydraulic")));
+            
+            bool pipeIsHydraulic = pipeType.Namespace != null && 
+                                   (pipeType.Namespace.Contains("HydraulicComponents") || 
+                                    pipeType.GetInterfaces().Any(i => i.Name.Contains("Hydraulic")));
+                                    
+            Console.WriteLine($"Tank IsHydraulicComponentType: {tankIsHydraulic}");
+            Console.WriteLine($"Pipe IsHydraulicComponentType: {pipeIsHydraulic}");
+        }
+    }
+}
diff --git a/HydraulicSimulator/Tests/QuickHydraulicTest.cs b/HydraulicSimulator/Tests/QuickHydraulicTest.cs
deleted file mode 100644
index 9e58603..0000000
--- a/HydraulicSimulator/Tests/QuickHydraulicTest.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System;
-using CtrEditor.HydraulicSimulator.Examples;
-
-namespace CtrEditor.HydraulicSimulator.Tests
-{
-    /// <summary>
-    /// Clase para probar rápidamente los componentes hidráulicos
-    /// Ejecutar desde el método Main o desde tests unitarios
-    /// </summary>
-    public static class QuickHydraulicTest
-    {
-        /// <summary>
-        /// Ejecuta una prueba rápida del sistema hidráulico
-        /// </summary>
-        public static void RunQuickTest()
-        {
-            try
-            {
-                Console.WriteLine("🧪 PRUEBA RÁPIDA DEL SISTEMA HIDRÁULICO");
-                Console.WriteLine("═══════════════════════════════════════");
-                Console.WriteLine();
-                
-                // Ejecutar ejemplo simple
-                SimpleHydraulicSystemExample.RunExample();
-                
-                // Mostrar información de integración
-                SimpleHydraulicSystemExample.ShowGraphicObjectsIntegration();
-                
-                Console.WriteLine();
-                Console.WriteLine("✅ Prueba completada exitosamente!");
-                Console.WriteLine();
-                Console.WriteLine("📝 PRÓXIMOS PASOS:");
-                Console.WriteLine("1. Agregar los componentes al editor visual");
-                Console.WriteLine("2. Configurar conexiones entre componentes");
-                Console.WriteLine("3. Integrar con HydraulicSimulationManager");
-                Console.WriteLine("4. Probar simulación en tiempo real");
-                
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"❌ Error en la prueba: {ex.Message}");
-                Console.WriteLine($"Stack trace: {ex.StackTrace}");
-            }
-        }
-    }
-}
diff --git a/ObjetosSim/HydraulicComponents/osHydPipe.cs b/ObjetosSim/HydraulicComponents/osHydPipe.cs
index 92a3917..c362532 100644
--- a/ObjetosSim/HydraulicComponents/osHydPipe.cs
+++ b/ObjetosSim/HydraulicComponents/osHydPipe.cs
@@ -441,6 +441,7 @@ namespace CtrEditor.ObjetosSim.HydraulicComponents
         public osHydPipe()
         {
             PipeId = Guid.NewGuid().ToString();
+            IsVisFilter = true; // Asegurar que el componente hidráulico sea visible en filtros
         }
 
         #endregion
diff --git a/ObjetosSim/HydraulicComponents/osHydPump.cs b/ObjetosSim/HydraulicComponents/osHydPump.cs
index 6f9a2b9..332024d 100644
--- a/ObjetosSim/HydraulicComponents/osHydPump.cs
+++ b/ObjetosSim/HydraulicComponents/osHydPump.cs
@@ -17,9 +17,9 @@ namespace CtrEditor.ObjetosSim.HydraulicComponents
     /// Bomba hidráulica que implementa las interfaces del simulador hidráulico
     /// </summary>
     public partial class osHydPump : osBase, IHydraulicPump, IosBase
-    {
-        public static string NombreCategoria() => "Hidraulico";
-        
+    {        
+        public static string NombreCategoria() => "Componentes Hidráulicos";
+
         public static string NombreClase()
         {
             return "Bomba Hidráulica";
@@ -53,30 +53,12 @@ namespace CtrEditor.ObjetosSim.HydraulicComponents
         private double _currentFlow = 0.0;
         private double _currentPressure = 0.0;
         
-        // Propiedades visuales
-        [ObservableProperty]
-        [property: Category("🎨 Apariencia")]
-        [property: Description("Ancho de la bomba en metros")]
-        [property: Name("Ancho")]
-        private float ancho = 0.15f;
-
-        [ObservableProperty]
-        [property: Category("🎨 Apariencia")]
-        [property: Description("Alto de la bomba en metros")]
-        [property: Name("Alto")]
-        private float alto = 0.10f;
-
+        // Propiedades visuales específicas de la bomba
         [ObservableProperty]
         [property: Category("🎨 Apariencia")]
         [property: Description("Color visual de la bomba")]
         [property: Name("Color")]
         private Brush colorButton_oculto = Brushes.Blue;
-
-        [ObservableProperty]
-        [property: Category("🎨 Apariencia")]
-        [property: Description("Ángulo de rotación de la bomba en grados")]
-        [property: Name("Ángulo")]
-        private float angulo = 0f;
         
         [Category("🔧 Bomba Hidráulica")]
         [DisplayName("Cabeza de bomba")]
@@ -209,15 +191,19 @@ namespace CtrEditor.ObjetosSim.HydraulicComponents
             set => SetProperty(ref nombre, value);
         }
 
-        public override void OnMove(float LeftPixels, float TopPixels)
-        {
-            // Los objetos hidráulicos no necesitan actualizar geometría física
-        }
-
         public osHydPump()
         {
             Nombre = "Bomba Hidráulica";
             Tamano = 0.30f;
+            // Inicializar dimensiones usando las propiedades de osBase
+            Ancho = 0.15f;
+            Alto = 0.10f;
+            Angulo = 0f;
+            // Asegurar que el movimiento esté habilitado
+            Lock_movement = false;
+            // Inicializar posición por defecto
+            Left = 0.0f;
+            Top = 0.0f;
             ImageSource_oculta = ImageFromPath("/imagenes/pump_stop.png");
         }
 
diff --git a/ObjetosSim/HydraulicComponents/osHydTank.cs b/ObjetosSim/HydraulicComponents/osHydTank.cs
index e69de29..60a7662 100644
--- a/ObjetosSim/HydraulicComponents/osHydTank.cs
+++ b/ObjetosSim/HydraulicComponents/osHydTank.cs
@@ -0,0 +1,790 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Windows.Media;
+using CtrEditor.HydraulicSimulator;
+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.HydraulicComponents
+{
+    /// <summary>
+    /// Tanque hidráulico con gestión dinámica de nivel y presión configurable
+    /// </summary>
+    public partial class osHydTank : osBase, IHydraulicComponent, IHydraulicFlowReceiver, IHydraulicPressureReceiver, IosBase
+    {
+        public static string NombreCategoria() => "Componentes Hidráulicos";
+        
+        public static string NombreClase() => "Tanque Hidráulico";
+
+        // Private Fields
+        
+        private double _tankPressure = 101325.0; // Pa (1 atm por defecto)
+        private double _currentLevel = 1.0; // m
+        private double _maxLevel = 2.0; // m
+        private double _minLevel = 0.1; // m
+        private double _crossSectionalArea = 1.0; // m²
+        private double _currentVolume = 1.0; // m³
+        private double _maxVolume = 2.0; // m³
+        private double _inletFlow = 0.0; // m³/s
+        private double _outletFlow = 0.0; // m³/s
+        private double _currentPressure = 101325.0; // Pa
+        private bool _isFixedPressure = true;
+        private HydraulicTankType _tankType = HydraulicTankType.Intermediate;
+        private string _connectedInletPipe = "";
+        private string _connectedOutletPipe = "";
+        private double _lastUpdateTime = 0.0;
+        private readonly object _levelLock = new object();
+        private PropertyChangedEventHandler? inletPropertyChangedHandler;
+        private PropertyChangedEventHandler? outletPropertyChangedHandler;
+        
+
+        // Enums
+        public enum HydraulicTankType
+        {
+            [Description("Tanque de succión (inicio del sistema)")]
+            Suction,
+            [Description("Tanque intermedio (buffer)")]
+            Intermediate,
+            [Description("Tanque de almacenamiento")]
+            Storage,
+            [Description("Tanque de proceso")]
+            Process
+        }
+        
+
+        // Properties
+
+        [ObservableProperty]
+        [property: JsonIgnore]
+        [property: Category("Apariencia")]
+        [property: Description("Imagen visual")]
+        [property: Name("Imagen")]
+        public ImageSource imageSource_oculta;
+
+        [ObservableProperty]
+        [property: Category("🎨 Apariencia")]
+        [property: Description("Tamaño visual del tanque")]
+        [property: Name("Tamaño")]
+        public float tamano;
+
+        // Propiedades visuales específicas del tanque
+        [ObservableProperty]
+        [property: Category("🎨 Apariencia")]
+        [property: Description("Color visual del tanque")]
+        [property: Name("Color")]
+        private Brush colorButton_oculto = Brushes.LightBlue;
+
+        
+
+        // Constructor
+        public osHydTank()
+        {
+            Nombre = "Tanque Hidráulico";
+            Tamano = 1.0f; // Usar un tamaño mayor para mayor visibilidad
+            // Inicializar dimensiones usando las propiedades de osBase
+            Ancho = 0.30f;
+            Alto = 0.40f;
+            Angulo = 0f;
+            // Asegurar que el movimiento esté habilitado
+            Lock_movement = false;
+            // Inicializar posición por defecto
+            ImageSource_oculta = ImageFromPath("/imagenes/tank.png");
+            _currentVolume = _currentLevel * _crossSectionalArea;
+            _maxVolume = _maxLevel * _crossSectionalArea;
+            IsVisFilter = true; // Asegurar que el componente hidráulico sea visible en filtros
+            UpdateTankPressure();
+            
+            // Debug: Confirmar que el constructor se ejecuta
+            Debug.WriteLine($"osHydTank Constructor: Nombre='{Nombre}', Tamaño={Tamano}, ZIndex={zIndex_fromFrames}, IsVisFilter={IsVisFilter}, Lock_movement={Lock_movement}");
+        }
+        
+
+        // Constructor y Métodos Base
+
+        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 OnResize(float Delta_Width, float Delta_Height)
+        {
+            Tamano += Delta_Width + Delta_Height;
+        }
+
+        public override void UpdateGeometryStart()
+        {
+            // Los objetos hidráulicos se registran automáticamente 
+            // cuando inicia la simulación a través de las interfaces
+        }
+
+        public override void UpdateGeometryStep()
+        {
+            // Los objetos hidráulicos actualizan sus resultados 
+            // a través de ApplyHydraulicResults()
+        }
+
+        public override void UpdateControl(int elapsedMilliseconds)
+        {
+            // Actualizar el color según el estado del tanque
+            var percentage = FillPercentage;
+            if (percentage < 20)
+                ColorButton_oculto = Brushes.Red;
+            else if (percentage < 50)
+                ColorButton_oculto = Brushes.Orange;
+            else if (percentage < 80)
+                ColorButton_oculto = Brushes.Yellow;
+            else
+                ColorButton_oculto = Brushes.LightBlue;
+        }
+
+        
+
+        // Properties - Configuration
+
+        [Category("🏗️ Configuración del Tanque")]
+        [DisplayName("Tipo de tanque")]
+        [Description("Función del tanque en el sistema hidráulico")]
+        public HydraulicTankType TankType
+        {
+            get => _tankType;
+            set
+            {
+                if (SetProperty(ref _tankType, value))
+                {
+                    UpdateTankConfiguration();
+                    InvalidateHydraulicNetwork();
+                }
+            }
+        }
+
+        [Category("🏗️ Configuración del Tanque")]
+        [DisplayName("Área sección transversal")]
+        [Description("Área de la sección transversal del tanque (m²)")]
+        public double CrossSectionalArea
+        {
+            get => _crossSectionalArea;
+            set
+            {
+                if (SetProperty(ref _crossSectionalArea, Math.Max(0.1, value)))
+                {
+                    UpdateVolumeCalculations();
+                    InvalidateHydraulicNetwork();
+                }
+            }
+        }
+
+        [Category("🏗️ Configuración del Tanque")]
+        [DisplayName("Nivel máximo")]
+        [Description("Nivel máximo permitido en el tanque (m)")]
+        public double MaxLevel
+        {
+            get => _maxLevel;
+            set
+            {
+                if (SetProperty(ref _maxLevel, Math.Max(0.2, value)))
+                {
+                    if (_currentLevel > _maxLevel)
+                        CurrentLevel = _maxLevel;
+                    UpdateVolumeCalculations();
+                }
+            }
+        }
+
+        [Category("🏗️ Configuración del Tanque")]
+        [DisplayName("Nivel mínimo")]
+        [Description("Nivel mínimo permitido en el tanque (m)")]
+        public double MinLevel
+        {
+            get => _minLevel;
+            set
+            {
+                if (SetProperty(ref _minLevel, Math.Max(0.0, Math.Min(value, _maxLevel - 0.1))))
+                {
+                    if (_currentLevel < _minLevel)
+                        CurrentLevel = _minLevel;
+                    UpdateVolumeCalculations();
+                }
+            }
+        }
+
+        
+
+        // Properties - Pressure
+
+        [Category("🔧 Sistema de Presión")]
+        [DisplayName("Presión fija")]
+        [Description("Si está habilitado, la presión se mantiene constante")]
+        public bool IsFixedPressure
+        {
+            get => _isFixedPressure;
+            set
+            {
+                if (SetProperty(ref _isFixedPressure, value))
+                {
+                    UpdateTankPressure();
+                    InvalidateHydraulicNetwork();
+                }
+            }
+        }
+
+        [Category("🔧 Sistema de Presión")]
+        [DisplayName("Presión del tanque")]
+        [Description("Presión mantenida en el tanque (Pa). En sistemas reales controlada por PID")]
+        public double TankPressure
+        {
+            get => _tankPressure;
+            set
+            {
+                if (SetProperty(ref _tankPressure, Math.Max(0, value)))
+                {
+                    UpdateTankPressure();
+                    InvalidateHydraulicNetwork();
+                }
+            }
+        }
+
+        [Category("🔧 Sistema de Presión")]
+        [DisplayName("Presión (bar)")]
+        [Description("Presión del tanque en bar")]
+        [JsonIgnore]
+        public double TankPressureBar
+        {
+            get => TankPressure / 100000.0;
+            set => TankPressure = value * 100000.0;
+        }
+
+        
+
+        // Properties - Current State
+
+        [Category("📊 Estado Actual")]
+        [DisplayName("Nivel actual")]
+        [Description("Nivel actual de líquido en el tanque (m)")]
+        [JsonIgnore]
+        public double CurrentLevel
+        {
+            get => _currentLevel;
+            private set
+            {
+                lock (_levelLock)
+                {
+                    var clampedLevel = Math.Max(_minLevel, Math.Min(_maxLevel, value));
+                    if (SetProperty(ref _currentLevel, clampedLevel))
+                    {
+                        UpdateVolumeCalculations();
+                        OnPropertyChanged(nameof(FillPercentage));
+                    }
+                }
+            }
+        }
+
+        [Category("📊 Estado Actual")]
+        [DisplayName("Volumen actual")]
+        [Description("Volumen actual de líquido en el tanque (m³)")]
+        [JsonIgnore]
+        public double CurrentVolume
+        {
+            get => _currentVolume;
+            private set => SetProperty(ref _currentVolume, value);
+        }
+
+        [Category("📊 Estado Actual")]
+        [DisplayName("Volumen máximo")]
+        [Description("Volumen máximo del tanque (m³)")]
+        [JsonIgnore]
+        public double MaxVolume
+        {
+            get => _maxVolume;
+            private set => SetProperty(ref _maxVolume, value);
+        }
+
+        [Category("📊 Estado Actual")]
+        [DisplayName("Porcentaje llenado")]
+        [Description("Porcentaje de llenado del tanque")]
+        [JsonIgnore]
+        public double FillPercentage => (_currentLevel - _minLevel) / (_maxLevel - _minLevel) * 100.0;
+
+        [Category("📊 Estado Actual")]
+        [DisplayName("Flujo entrada")]
+        [Description("Flujo de entrada actual (m³/s)")]
+        [JsonIgnore]
+        public double InletFlow
+        {
+            get => _inletFlow;
+            private set => SetProperty(ref _inletFlow, value);
+        }
+
+        [Category("📊 Estado Actual")]
+        [DisplayName("Flujo salida")]
+        [Description("Flujo de salida actual (m³/s)")]
+        [JsonIgnore]
+        public double OutletFlow
+        {
+            get => _outletFlow;
+            private set => SetProperty(ref _outletFlow, value);
+        }
+
+        [Category("📊 Estado Actual")]
+        [DisplayName("Balance flujo")]
+        [Description("Balance de flujo (entrada - salida) (m³/s)")]
+        [JsonIgnore]
+        public double FlowBalance => InletFlow - OutletFlow;
+
+        [Category("📊 Estado Actual")]
+        [DisplayName("Presión actual")]
+        [Description("Presión actual en el tanque (Pa)")]
+        [JsonIgnore]
+        public double CurrentPressure
+        {
+            get => _currentPressure;
+            private set => SetProperty(ref _currentPressure, value);
+        }
+
+        [Category("📊 Estado Actual")]
+        [DisplayName("Presión actual (bar)")]
+        [Description("Presión actual en bar")]
+        [JsonIgnore]
+        public double CurrentPressureBar => CurrentPressure / 100000.0;
+
+        
+
+        // Properties - Connections
+
+        [Category("🔗 Conexiones")]
+        [DisplayName("Tubería entrada")]
+        [Description("Nombre de la tubería conectada a la entrada")]
+        public string ConnectedInletPipe
+        {
+            get => _connectedInletPipe;
+            set
+            {
+                if (SetProperty(ref _connectedInletPipe, value ?? ""))
+                {
+                    ManageInletConnection();
+                    InvalidateHydraulicNetwork();
+                }
+            }
+        }
+
+        [Category("🔗 Conexiones")]
+        [DisplayName("Tubería salida")]
+        [Description("Nombre de la tubería conectada a la salida")]
+        public string ConnectedOutletPipe
+        {
+            get => _connectedOutletPipe;
+            set
+            {
+                if (SetProperty(ref _connectedOutletPipe, value ?? ""))
+                {
+                    ManageOutletConnection();
+                    InvalidateHydraulicNetwork();
+                }
+            }
+        }
+
+        
+
+        // IHydraulicComponent Implementation
+
+        [JsonIgnore]
+        public bool HasHydraulicComponents => true;
+
+        public List<HydraulicNodeDefinition> GetHydraulicNodes()
+        {
+            var nodes = new List<HydraulicNodeDefinition>();
+
+            // El tanque siempre es un nodo de presión fija si está configurado así
+            if (IsFixedPressure)
+            {
+                nodes.Add(new HydraulicNodeDefinition(Nombre, true, TankPressure, GetTankDescription()));
+                Debug.WriteLine($"Tanque {Nombre}: Nodo de presión fija creado - {TankPressure:F0} Pa ({TankPressureBar:F2} bar)");
+            }
+            else
+            {
+                nodes.Add(new HydraulicNodeDefinition(Nombre, false, null, GetTankDescription()));
+                Debug.WriteLine($"Tanque {Nombre}: Nodo de presión libre creado");
+            }
+
+            return nodes;
+        }
+
+        public List<HydraulicElementDefinition> GetHydraulicElements()
+        {
+            // Los tanques no generan elementos hidráulicos, solo nodos
+            return new List<HydraulicElementDefinition>();
+        }
+
+        public void UpdateHydraulicProperties()
+        {
+            // Actualizar propiedades antes de la simulación
+            UpdateTankPressure();
+            UpdateVolumeCalculations();
+        }
+
+        public void ApplyHydraulicResults(Dictionary<string, double> flows, Dictionary<string, double> pressures)
+        {
+            var deltaTime = GetDeltaTime();
+            
+            // Obtener flujos conectados
+            UpdateFlowsFromConnectedPipes(flows);
+            
+            // Actualizar presión
+            if (pressures.ContainsKey(Nombre))
+            {
+                CurrentPressure = pressures[Nombre];
+            }
+            
+            // Actualizar nivel basado en balance de flujo
+            UpdateLevelFromFlowBalance(deltaTime);
+            
+            if (VerboseLogging())
+            {
+                Debug.WriteLine($"Tanque {Nombre}: Nivel={CurrentLevel:F2}m ({FillPercentage:F1}%), " +
+                              $"Flujo_entrada={InletFlow:F6}m³/s, Flujo_salida={OutletFlow:F6}m³/s, " +
+                              $"Balance={FlowBalance:F6}m³/s, Presión={CurrentPressure:F0}Pa");
+            }
+        }
+
+        
+
+        // UI Properties
+        
+        /// <summary>
+        /// Color del nivel de líquido
+        /// </summary>
+        [JsonIgnore]
+        public SolidColorBrush LevelColor
+        {
+            get
+            {
+                var percentage = FillPercentage;
+                if (percentage < 20) return new SolidColorBrush(Colors.Red);
+                if (percentage < 50) return new SolidColorBrush(Colors.Orange);
+                if (percentage < 80) return new SolidColorBrush(Colors.Yellow);
+                return new SolidColorBrush(Colors.LightBlue);
+            }
+        }
+
+        /// <summary>
+        /// Color del borde del nivel de líquido
+        /// </summary>
+        [JsonIgnore]
+        public SolidColorBrush LevelBorderColor
+        {
+            get
+            {
+                var percentage = FillPercentage;
+                if (percentage < 20) return new SolidColorBrush(Colors.DarkRed);
+                if (percentage < 50) return new SolidColorBrush(Colors.DarkOrange);
+                if (percentage < 80) return new SolidColorBrush(Colors.DarkGoldenrod);
+                return new SolidColorBrush(Colors.DarkBlue);
+            }
+        }
+
+        /// <summary>
+        /// Indica si hay conexión de entrada
+        /// </summary>
+        [JsonIgnore]
+        public bool HasInletConnection => !string.IsNullOrEmpty(ConnectedInletPipe);
+
+        /// <summary>
+        /// Indica si hay conexión de salida
+        /// </summary>
+        [JsonIgnore]
+        public bool HasOutletConnection => !string.IsNullOrEmpty(ConnectedOutletPipe);
+
+        /// <summary>
+        /// Indicador del tipo de tanque
+        /// </summary>
+        [JsonIgnore]
+        public string TankTypeIndicator
+        {
+            get
+            {
+                return TankType switch
+                {
+                    HydraulicTankType.Suction => "S",
+                    HydraulicTankType.Intermediate => "I",
+                    HydraulicTankType.Storage => "A",
+                    HydraulicTankType.Process => "P",
+                    _ => "T"
+                };
+            }
+        }
+
+        /// <summary>
+        /// Balance de flujo en L/min
+        /// </summary>
+        [JsonIgnore]
+        public double FlowBalanceLMin => FlowBalance * 60000; // m³/s a L/min
+
+        /// <summary>
+        /// Color del balance de flujo
+        /// </summary>
+        [JsonIgnore]
+        public SolidColorBrush FlowBalanceColor
+        {
+            get
+            {
+                var balance = FlowBalance;
+                if (Math.Abs(balance) < 0.0001) return new SolidColorBrush(Colors.Gray);
+                return balance > 0 ? new SolidColorBrush(Colors.Green) : new SolidColorBrush(Colors.Red);
+            }
+        }
+        
+        /// <summary>
+        /// Posición Y de la línea de nivel medio (50%)
+        /// </summary>
+        [JsonIgnore]
+        public double MidLevelY
+        {
+            get
+            {
+                var tankHeight = Tamano * 100; // Convertir a píxeles aproximados
+                return tankHeight * 0.5; // 50% de altura
+            }
+        }
+
+        /// <summary>
+        /// Posición Y de la línea de nivel mínimo
+        /// </summary>
+        [JsonIgnore]
+        public double MinLevelY
+        {
+            get
+            {
+                var tankHeight = Tamano * 100; // Convertir a píxeles aproximados
+                var minPercentage = (MinLevel - MinLevel) / (MaxLevel - MinLevel) * 100;
+                return tankHeight - (tankHeight * (minPercentage + 10) / 100); // 10% del nivel mínimo
+            }
+        }
+
+        
+
+        // Private Methods
+
+        private string GetTankDescription()
+        {
+            return TankType switch
+            {
+                HydraulicTankType.Suction => "Tanque de succión",
+                HydraulicTankType.Intermediate => "Tanque intermedio", 
+                HydraulicTankType.Storage => "Tanque de almacenamiento",
+                HydraulicTankType.Process => "Tanque de proceso",
+                _ => "Tanque hidráulico"
+            };
+        }
+
+        private void UpdateTankConfiguration()
+        {
+            // Configuración automática según el tipo de tanque
+            switch (TankType)
+            {
+                case HydraulicTankType.Suction:
+                    // Tanques de succión típicamente a presión atmosférica
+                    if (TankPressure < 50000) // Si no se ha configurado manualmente
+                        TankPressure = 101325.0; // 1 atm
+                    IsFixedPressure = true;
+                    break;
+                    
+                case HydraulicTankType.Intermediate:
+                case HydraulicTankType.Storage:
+                case HydraulicTankType.Process:
+                    // Estos pueden tener presión variable o fija según el proceso
+                    break;
+            }
+        }
+
+        private void UpdateVolumeCalculations()
+        {
+            CurrentVolume = CurrentLevel * CrossSectionalArea;
+            MaxVolume = MaxLevel * CrossSectionalArea;
+        }
+
+        private void UpdateTankPressure()
+        {
+            if (IsFixedPressure)
+            {
+                CurrentPressure = TankPressure;
+            }
+        }
+
+        private void UpdateFlowsFromConnectedPipes(Dictionary<string, double> flows)
+        {
+            InletFlow = 0.0;
+            OutletFlow = 0.0;
+
+            // Buscar flujos en las ramas conectadas
+            foreach (var flow in flows)
+            {
+                if (flow.Key.Contains(Nombre))
+                {
+                    // Determinar si es flujo de entrada o salida según la dirección
+                    if (flow.Key.EndsWith($" -> {Nombre}"))
+                    {
+                        InletFlow += Math.Max(0, flow.Value); // Solo flujos positivos hacia el tanque
+                    }
+                    else if (flow.Key.StartsWith($"{Nombre} -> "))
+                    {
+                        OutletFlow += Math.Max(0, flow.Value); // Solo flujos positivos desde el tanque
+                    }
+                }
+            }
+        }
+
+        private void UpdateLevelFromFlowBalance(double deltaTime)
+        {
+            if (deltaTime <= 0) return;
+
+            // Balance de masa: cambio_volumen = (flujo_entrada - flujo_salida) * tiempo
+            var volumeChange = FlowBalance * deltaTime;
+            var levelChange = volumeChange / CrossSectionalArea;
+            
+            // Actualizar nivel con límites
+            CurrentLevel = Math.Max(MinLevel, Math.Min(MaxLevel, CurrentLevel + levelChange));
+        }
+
+        private double GetDeltaTime()
+        {
+            var currentTime = Environment.TickCount64 / 1000.0; // segundos
+            var deltaTime = _lastUpdateTime > 0 ? currentTime - _lastUpdateTime : 0.0;
+            _lastUpdateTime = currentTime;
+            
+            // Limitar delta time para evitar saltos grandes
+            return Math.Min(deltaTime, 0.1); // máximo 100ms
+        }
+
+        private bool VerboseLogging()
+        {
+            return _mainViewModel?.hydraulicSimulationManager?.VerboseOutput ?? false;
+        }
+
+        private void ManageInletConnection()
+        {
+            // Gestionar conexión de entrada
+            // Implementar lógica de conexión específica si es necesario
+        }
+
+        private void ManageOutletConnection()
+        {
+            // Gestionar conexión de salida  
+            // Implementar lógica de conexión específica si es necesario
+        }
+
+        private void InvalidateHydraulicNetwork()
+        {
+            _mainViewModel?.hydraulicSimulationManager?.InvalidateNetwork();
+        }
+
+        
+
+        // IHydraulicFlowReceiver Implementation
+
+        public void SetFlow(double flow)
+        {
+            // Este método puede ser llamado por tuberías conectadas
+            // La lógica de flujo se maneja en ApplyHydraulicResults
+        }
+
+        public double GetFlow()
+        {
+            return FlowBalance;
+        }
+
+        
+
+        // IHydraulicPressureReceiver Implementation
+
+        public void SetPressure(double pressure)
+        {
+            if (!IsFixedPressure)
+            {
+                CurrentPressure = pressure;
+            }
+        }
+
+        public double GetPressure()
+        {
+            return CurrentPressure;
+        }
+
+        
+
+        // ZIndex Implementation
+        
+        public int zIndex_fromFrames { get; set; } = 2;
+        
+        public ZIndexEnum ZIndex_Base()
+        {
+            return ZIndexEnum.Estaticos;
+        }
+        
+        
+
+        // IosBase Implementation
+
+        public void Start()
+        {
+            // Inicialización del tanque para la simulación
+            UpdateVolumeCalculations();
+            UpdateTankPressure();
+        }
+
+        public void Inicializar(int valorInicial)
+        {
+            // Inicialización con valor inicial
+            UpdateVolumeCalculations();
+            UpdateTankPressure();
+        }
+
+        public void Disposing()
+        {
+            // Desconectar event handlers si existen
+            if (inletPropertyChangedHandler != null)
+            {
+                // Aquí se desconectarían los handlers cuando se implementen las conexiones
+                // Similar a como lo hace osHydDischargeTank
+            }
+            
+            if (outletPropertyChangedHandler != null)
+            {
+                // Desconectar outlet handler cuando se implemente
+            }
+        }
+
+        
+
+        // osBase Overrides
+
+        public override void ucLoaded()
+        {
+            // Inicialización cuando se carga el UserControl
+            UpdateVolumeCalculations();
+            UpdateTankPressure();
+            
+            // Debug: Confirmar que el UserControl se está cargando
+            Debug.WriteLine($"osHydTank.ucLoaded(): Tanque '{Nombre}' cargado - Tamaño: {Tamano}, ZIndex: {zIndex_fromFrames}");
+        }
+
+        public override void ucUnLoaded()
+        {
+            // Los tanques hidráulicos no tienen geometría que limpiar
+        }
+
+        
+    }
+}
diff --git a/ObjetosSim/HydraulicComponents/ucHydTank.xaml b/ObjetosSim/HydraulicComponents/ucHydTank.xaml
new file mode 100644
index 0000000..08ef26b
--- /dev/null
+++ b/ObjetosSim/HydraulicComponents/ucHydTank.xaml
@@ -0,0 +1,135 @@
+<UserControl x:Class="CtrEditor.ObjetosSim.HydraulicComponents.ucHydTank"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:CtrEditor.ObjetosSim"
+             xmlns:vm="clr-namespace:CtrEditor.ObjetosSim.HydraulicComponents"
+             mc:Ignorable="d">
+
+    <!-- DataContext se establece desde el objeto padre, no aquí -->
+
+    <Canvas RenderTransformOrigin="0,0">
+        <Canvas.RenderTransform>
+            <TransformGroup>
+                <ScaleTransform />
+                <SkewTransform />
+                <RotateTransform Angle="{Binding Angulo}" />
+                <TranslateTransform />
+            </TransformGroup>
+        </Canvas.RenderTransform>
+
+        <!-- Contenedor principal del tanque -->
+        <Grid Width="{Binding Tamano, Converter={StaticResource MeterToPixelConverter}}"
+              Height="{Binding Tamano, Converter={StaticResource MeterToPixelConverter}}"
+              Canvas.Left="0" Canvas.Top="0">
+            
+            <!-- Fondo del tanque (contenedor vacío) -->
+            <Rectangle x:Name="rectTankContainer"
+                       Fill="LightGray" 
+                       Stroke="DarkGray" 
+                       StrokeThickness="2"
+                       RadiusX="5" 
+                       RadiusY="5"/>
+
+            <!-- Nivel del líquido -->
+            <Rectangle x:Name="rectLevel"
+                       Fill="{Binding LevelColor}"
+                       Stroke="{Binding LevelBorderColor}"
+                       StrokeThickness="1"
+                       RadiusX="3" 
+                       RadiusY="3"
+                       VerticalAlignment="Bottom"
+                       Margin="4,4,4,4">
+                            <Rectangle.Height>
+                <MultiBinding Converter="{StaticResource LevelToHeightMultiConverter}">
+                    <Binding Path="FillPercentage"/>
+                    <Binding Path="Tamano" Converter="{StaticResource MeterToPixelConverter}"/>
+                </MultiBinding>
+            </Rectangle.Height>
+            </Rectangle>
+
+            <!-- Líneas de nivel (marcas visuales) -->
+            <Canvas>
+                <!-- Línea de nivel máximo -->
+                <Line X1="0" Y1="8" X2="{Binding ActualWidth, ElementName=rectTankContainer}" Y2="8"
+                      Stroke="Red" StrokeThickness="1" StrokeDashArray="2,2" Opacity="0.7"/>
+                
+                <!-- Línea de nivel medio -->
+                <Line X1="0" Y1="{Binding MidLevelY}" X2="{Binding ActualWidth, ElementName=rectTankContainer}" Y2="{Binding MidLevelY}"
+                      Stroke="Orange" StrokeThickness="1" StrokeDashArray="2,2" Opacity="0.5"/>
+                
+                <!-- Línea de nivel mínimo -->
+                <Line X1="0" Y1="{Binding MinLevelY}" X2="{Binding ActualWidth, ElementName=rectTankContainer}" Y2="{Binding MinLevelY}"
+                      Stroke="Red" StrokeThickness="1" StrokeDashArray="2,2" Opacity="0.7"/>
+            </Canvas>
+
+            <!-- Indicadores de conexión -->
+            <!-- Entrada (parte superior) -->
+            <Ellipse Width="8" Height="8" 
+                     Fill="Green" 
+                     Stroke="DarkGreen" 
+                     StrokeThickness="1"
+                     HorizontalAlignment="Left" 
+                     VerticalAlignment="Top"
+                     Margin="2,2,0,0"
+                     Visibility="{Binding HasInletConnection, Converter={StaticResource BooleanToVisibilityConverter}}"/>
+            
+            <!-- Salida (parte inferior) -->
+            <Ellipse Width="8" Height="8" 
+                     Fill="Blue" 
+                     Stroke="DarkBlue" 
+                     StrokeThickness="1"
+                     HorizontalAlignment="Right" 
+                     VerticalAlignment="Bottom"
+                     Margin="0,0,2,2"
+                     Visibility="{Binding HasOutletConnection, Converter={StaticResource BooleanToVisibilityConverter}}"/>
+
+            <!-- Texto del porcentaje de llenado -->
+            <TextBlock Text="{Binding FillPercentage, StringFormat='{}{0:F0}%'}" 
+                       HorizontalAlignment="Center" 
+                       VerticalAlignment="Center"
+                       Foreground="White" 
+                       FontWeight="Bold" 
+                       FontSize="10"
+                       Effect="{StaticResource DropShadowEffect}"/>
+
+            <!-- Indicador de tipo de tanque -->
+            <TextBlock Text="{Binding TankTypeIndicator}" 
+                       HorizontalAlignment="Left" 
+                       VerticalAlignment="Top"
+                       Foreground="Navy" 
+                       FontWeight="Bold" 
+                       FontSize="8"
+                       Margin="2,0,0,0"/>
+        </Grid>
+
+        <!-- Panel de información -->
+        <Grid Canvas.Top="{Binding Tamano, Converter={StaticResource MeterToPixelConverter}, ConverterParameter=1.05}"
+              Width="{Binding Tamano, Converter={StaticResource MeterToPixelConverter}}"
+              Canvas.Left="0">
+            <StackPanel Orientation="Horizontal" 
+                        HorizontalAlignment="Center"
+                        Margin="0,2,0,0">
+            
+            <!-- Presión actual -->
+            <TextBlock Text="{Binding CurrentPressureBar, StringFormat='{}{0:F1} bar'}" 
+                       Foreground="White" Background="Blue" 
+                       Padding="2" Margin="1" FontSize="8"/>
+            
+            <!-- Nivel actual -->
+            <TextBlock Text="{Binding CurrentLevel, StringFormat='{}{0:F2} m'}" 
+                       Foreground="White" Background="Green" 
+                       Padding="2" Margin="1" FontSize="8"/>
+            
+            <!-- Balance de flujo -->
+            <TextBlock Text="{Binding FlowBalanceLMin, StringFormat='{}{0:F1} L/min'}" 
+                       Foreground="White" 
+                       Background="{Binding FlowBalanceColor}"
+                       Padding="2" Margin="1" FontSize="8"/>
+            
+            </StackPanel>
+        </Grid>
+    </Canvas>
+    
+</UserControl>
diff --git a/ObjetosSim/HydraulicComponents/ucHydTank.xaml.cs b/ObjetosSim/HydraulicComponents/ucHydTank.xaml.cs
new file mode 100644
index 0000000..7e9aebf
--- /dev/null
+++ b/ObjetosSim/HydraulicComponents/ucHydTank.xaml.cs
@@ -0,0 +1,126 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Newtonsoft.Json;
+using System.Diagnostics;
+using CtrEditor.ObjetosSim;
+using CtrEditor.FuncionesBase;
+
+namespace CtrEditor.ObjetosSim.HydraulicComponents
+{
+    /// <summary>
+    /// UserControl para el tanque hidráulico osHydTank
+    /// </summary>
+    public partial class ucHydTank : UserControl, IDataContainer
+    {
+        #region IDataContainer Implementation
+        
+        [JsonIgnore]
+        public osBase? Datos { get; set; }
+        
+        public int zIndex_fromFrames { get; set; } = 0;
+        
+        private bool _isHighlighted = false;
+        
+        #endregion
+        
+        public ucHydTank()
+        {
+            InitializeComponent();
+            Loaded += OnUserControlLoaded;
+            Unloaded += OnUserControlUnloaded;
+            DataContextChanged += OnDataContextChanged;
+            
+            // Debug: Confirmar que el UserControl se está creando
+            Debug.WriteLine("ucHydTank Constructor: UserControl del tanque hidráulico creado");
+        }
+
+        private void OnUserControlUnloaded(object sender, RoutedEventArgs e)
+        {
+            Datos?.ucUnLoaded();
+        }
+        
+        private void OnDataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
+        {
+            if (DataContext is osHydTank tank)
+            {
+                Datos = tank;
+            }
+        }
+
+        private void OnUserControlLoaded(object sender, RoutedEventArgs e)
+        {
+            // Debug: Confirmar que el UserControl se está cargando
+            Debug.WriteLine($"ucHydTank.OnUserControlLoaded: DataContext = {DataContext?.GetType().Name ?? "null"}");
+            
+            // Llamar a ucLoaded() usando la propiedad Datos
+            Datos?.ucLoaded();
+            
+            // Asegurar que el DataContext esté configurado correctamente
+            if (Datos is osHydTank tank)
+            {
+                Debug.WriteLine($"ucHydTank.OnUserControlLoaded: Tanque '{tank.Nombre}' conectado - Tamaño: {tank.Tamano}");
+                // Suscribirse a cambios de propiedades para actualizar la UI
+                tank.PropertyChanged += Tank_PropertyChanged;
+                UpdateVisualProperties();
+            }
+            else
+            {
+                Debug.WriteLine("ucHydTank.OnUserControlLoaded: ERROR - Datos no es osHydTank o es null");
+            }
+        }
+
+        private void Tank_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+        {
+            // Actualizar propiedades visuales cuando cambien propiedades relevantes
+            if (e.PropertyName == nameof(osHydTank.FillPercentage) ||
+                e.PropertyName == nameof(osHydTank.CurrentLevel) ||
+                e.PropertyName == nameof(osHydTank.FlowBalance) ||
+                e.PropertyName == nameof(osHydTank.TankType) ||
+                e.PropertyName == nameof(osHydTank.ConnectedInletPipe) ||
+                e.PropertyName == nameof(osHydTank.ConnectedOutletPipe))
+            {
+                UpdateVisualProperties();
+            }
+        }
+
+        private void UpdateVisualProperties()
+        {
+            if (Datos is osHydTank tank)
+            {
+                // Forzar actualización del UI - las propiedades se actualizan automáticamente
+                // cuando cambian las propiedades base gracias al binding
+                this.InvalidateVisual();
+            }
+        }
+        
+        #region IDataContainer Implementation Methods
+        
+        public void Highlight(bool state)
+        {
+            _isHighlighted = state;
+            
+            if (state)
+            {
+                // Resaltar el contenedor del tanque con borde amarillo y más grueso
+                rectTankContainer.Stroke = new SolidColorBrush(Colors.Yellow);
+                rectTankContainer.StrokeThickness = 4;
+            }
+            else
+            {
+                // Volver al estado normal
+                rectTankContainer.Stroke = new SolidColorBrush(Colors.DarkGray);
+                rectTankContainer.StrokeThickness = 2;
+            }
+        }
+        
+        public ZIndexEnum ZIndex_Base()
+        {
+            return ZIndexEnum.Estaticos;
+        }
+        
+        #endregion
+    }
+}
diff --git a/XAMLhelpers.cs b/XAMLhelpers.cs
index ea29a9f..b84839a 100644
--- a/XAMLhelpers.cs
+++ b/XAMLhelpers.cs
@@ -380,11 +380,79 @@ namespace CtrEditor
     {
         public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
         {
-            if (values[0] is float level && values[1] is double containerHeight)
+            if (values?.Length >= 2)
             {
-                return containerHeight * (level / 100);
+                // Verificar que los valores sean válidos antes de convertir
+                if (!TryConvertToDouble(values[0], out double level) ||
+                    !TryConvertToDouble(values[1], out double containerHeight))
+                {
+                    return 0.0; // Retornar 0 si no se pueden convertir los valores
+                }
+                
+                var result = containerHeight * (level / 100.0);
+                return result;
             }
-            return 0;
+            return 0.0;
+        }
+
+        private static bool TryConvertToDouble(object value, out double result)
+        {
+            result = 0.0;
+
+            // Verificar valores nulos o especiales de WPF
+            if (value == null || 
+                value == DependencyProperty.UnsetValue || 
+                value.GetType().Name.Contains("NamedObject"))
+            {
+                return false;
+            }
+
+            // Intentar conversión directa para tipos numéricos
+            if (value is double d)
+            {
+                result = d;
+                return true;
+            }
+
+            if (value is float f)
+            {
+                result = f;
+                return true;
+            }
+
+            if (value is int i)
+            {
+                result = i;
+                return true;
+            }
+
+            if (value is decimal dec)
+            {
+                result = (double)dec;
+                return true;
+            }
+
+            // Intentar conversión de string
+            if (value is string str && double.TryParse(str, out result))
+            {
+                return true;
+            }
+
+            // Último intento: usar Convert.ToDouble solo si es IConvertible
+            if (value is IConvertible)
+            {
+                try
+                {
+                    result = System.Convert.ToDouble(value, CultureInfo.InvariantCulture);
+                    return true;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+
+            return false;
         }
 
         public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
diff --git a/test_osBaseItemsSource.cs b/test_osBaseItemsSource.cs
index 5fe4ee3..82c20c4 100644
--- a/test_osBaseItemsSource.cs
+++ b/test_osBaseItemsSource.cs
@@ -17,16 +17,23 @@ namespace CtrEditor.Test
             var pipe = new osHydPipe();
             var tank = new osHydDischargeTank();
             var pump = new osHydPump();
+            var hydTank = new osHydTank();
             
             // Probar la corrección - debería ser true para todos
             Console.WriteLine($"osHydPipe implements IHydraulicComponent: {typeof(IHydraulicComponent).IsAssignableFrom(pipe.GetType())}");
             Console.WriteLine($"osHydDischargeTank implements IHydraulicComponent: {typeof(IHydraulicComponent).IsAssignableFrom(tank.GetType())}");
             Console.WriteLine($"osHydPump implements IHydraulicComponent: {typeof(IHydraulicComponent).IsAssignableFrom(pump.GetType())}");
+            Console.WriteLine($"osHydTank implements IHydraulicComponent: {typeof(IHydraulicComponent).IsAssignableFrom(hydTank.GetType())}");
+            
+            // Verificar NombreCategoria y NombreClase
+            Console.WriteLine($"osHydTank.NombreCategoria(): {osHydTank.NombreCategoria()}");
+            Console.WriteLine($"osHydTank.NombreClase(): {osHydTank.NombreClase()}");
             
             // La comparación anterior que fallaba
             Console.WriteLine($"osHydPipe.GetType() == typeof(IHydraulicComponent): {pipe.GetType() == typeof(IHydraulicComponent)}");
             Console.WriteLine($"osHydDischargeTank.GetType() == typeof(IHydraulicComponent): {tank.GetType() == typeof(IHydraulicComponent)}");
             Console.WriteLine($"osHydPump.GetType() == typeof(IHydraulicComponent): {pump.GetType() == typeof(IHydraulicComponent)}");
+            Console.WriteLine($"osHydTank.GetType() == typeof(IHydraulicComponent): {hydTank.GetType() == typeof(IHydraulicComponent)}");
         }
     }
 }