# Prompt para Claude Code — Proyecto **AR-ShipDesign** > **Instrucciones para Álvaro (no para Code):** > Copia este documento ENTERO y pégalo como **primer mensaje** en una nueva conversación de Claude Code. Antes de pegarlo, abre Code en una carpeta neutra (no dentro de `D:/AR-ShipDesign` — él la usará). Si tienes Python 3.11+ instalado en Windows, mejor. --- ## 1. Quién eres y qué vas a construir Eres mi co-arquitecto naval y desarrollador senior en Python. Vamos a construir **AR-ShipDesign**, una aplicación de escritorio para Windows que sea la herramienta de diseño naval que siempre quise tener: **lo mejor de Maxsurf (rigurosidad técnica, suite de módulos integrados, transformación paramétrica) con la UX amigable de DELFTship (árbol de capas a la izquierda, vista 3D al centro, propiedades a la derecha, hidrostáticos siempre visibles abajo, wizards paso a paso).** El software debe cubrir el ciclo de diseño preliminar completo de un buque, abarcando tanto **embarcaciones a motor (desplazamiento, semi-planeo, planeo)** como **veleros (monocascos y multicascos)**, e incluyendo todos los sistemas del buque: propulsión y potencia, eléctrico, combustible y lubricación, agua dulce y sanitario, lastre y achique, gobierno, contraincendios, HVAC. **Es un proyecto a largo plazo. No tienes que terminar todo en una sesión.** Trabajaremos por hitos (sprints). Tu primera tarea es entender este documento, prepararme el entorno, y luego ejecutar el **Sprint 0** (esqueleto del proyecto + ventana principal vacía + sistema de proyecto funcional). Después, sprint por sprint según el orden que está al final. --- ## 2. Ubicación del proyecto **Todo va en `D:/AR-ShipDesign/`.** - La carpeta ya existe vacía. Úsala. - Si tiene contenido previo, **pregúntame antes de tocar nada.** - Inicializa Git desde el primer commit. Cada sprint termina con un commit etiquetado (`v0.1-sprint0`, `v0.2-sprint1`, etc.). --- ## 3. Pila tecnológica | Capa | Herramienta | Por qué | |------|-------------|---------| | Lenguaje | Python 3.11+ | Ecosistema científico maduro | | GUI | **PySide6** (Qt 6) | Profesional, gratis (LGPL), look nativo Windows | | Visualización 3D | **PyVista + VTK** embebido en Qt | Calidad pro sin escribir OpenGL crudo | | Gráficos 2D | **pyqtgraph** | Más rápido que matplotlib para interactivo | | NURBS / B-splines | **geomdl** (NURBS-Python) | Pura Python, sin dependencias compiladas | | Geometría avanzada / IGES-STEP | **pythonocc-core** | Opcional (si está instalado), behind feature flag | | Cálculo numérico | **numpy**, **scipy** | Estándar | | Tabular | **pandas** | Estándar | | Excel | **openpyxl** | Lectura/escritura | | DXF | **ezdxf** | Lectura/escritura | | Mallas / STL / OBJ | **trimesh** | Operaciones booleanas, cierre de mallas | | PDF | **reportlab** | Reportes técnicos | | Persistencia proyecto | Formato propio **`.arsd`** | ZIP con JSONs + meshes binarios | | Empaquetado final | **PyInstaller** | `.exe` distribuible | | Tests | **pytest** + benchmarks | Validación contra cascos canónicos | **Reglas de implementación:** - **SI estricto internamente** (m, kg, s, N, Pa, W). Conversión a unidades imperiales solo en la UI cuando el usuario lo pida. - **Idioma**: español por defecto, inglés como segunda opción. Strings centralizados en `arshipdesign/ui/i18n/es.json` y `en.json`. - **Type hints obligatorios** en todos los módulos del core. - **Docstrings estilo NumPy** con referencia bibliográfica al final cuando se implementa una fórmula del estado del arte. - **Sin red, sin telemetría, sin licencias online.** El software corre offline. - **Logging** con `logging` estándar, niveles configurables, archivo rotativo en `%APPDATA%/ARShipDesign/logs/`. - **Configuración del usuario** vía `QSettings` (preferencias, recientes, idioma, tema). - **Soporta proyectos con archivos relativos** (que el `.arsd` se pueda mover entre PCs sin romper referencias). --- ## 4. Estructura de carpetas del proyecto Crea exactamente esta estructura. Cuando un módulo aún no esté implementado, crea el archivo con un docstring que diga "Stub. Implementación en Sprint X" y un `raise NotImplementedError`. Esto deja la navegación del proyecto coherente desde el día 1. ``` D:/AR-ShipDesign/ ├── README.md ├── LICENSE.txt ├── CHANGELOG.md ├── pyproject.toml ├── requirements.txt ├── requirements-dev.txt ├── .gitignore ├── .env.example ├── main.py # entry point │ ├── arshipdesign/ │ ├── __init__.py # versión: __version__ │ │ │ ├── core/ # MODELO DE DATOS (sin UI) │ │ ├── project.py # raíz del proyecto, serialización .arsd │ │ ├── ship.py # clase Ship (raíz del modelo) │ │ ├── hull.py # geometría del casco (NURBS) │ │ ├── appendage.py # quilla, timón, bulbo, skeg, foils │ │ ├── superstructure.py │ │ ├── offsets.py # tabla de offsets │ │ ├── waterplane.py │ │ ├── section.py │ │ ├── compartment.py # bodegas, espacios secos │ │ ├── tank.py # tanques con líquido │ │ ├── liquid.py # base de datos de líquidos │ │ ├── weight_item.py # ítem de peso puntual │ │ ├── lightship.py # peso en rosca │ │ ├── loadcase.py # condiciones de carga │ │ ├── rig.py # aparejo del velero (mástil, jarcia, velas) │ │ ├── sail.py # velas individuales (main, jib, spi…) │ │ ├── engine.py # motor (datos del fabricante, curva) │ │ ├── propeller.py # hélice │ │ ├── gear.py # reductora │ │ ├── generator.py # genset │ │ ├── battery.py # banco de baterías │ │ ├── electrical_load.py # consumidor eléctrico │ │ ├── pipe.py # tubería de un sistema │ │ ├── valve.py │ │ ├── pump.py │ │ ├── system.py # sistema del buque (combustible, fw, etc.) │ │ └── units.py # conversiones SI ↔ imperial │ │ │ ├── geometry/ # OPERACIONES GEOMÉTRICAS │ │ ├── nurbs_surface.py # wrapper sobre geomdl │ │ ├── nurbs_curve.py │ │ ├── mesh.py # malla triangular para cálculos │ │ ├── slicer.py # corte por planos │ │ ├── intersection.py │ │ ├── fairing.py # análisis de curvatura │ │ ├── boolean.py # operaciones booleanas con trimesh │ │ └── fitting.py # ajuste de NURBS a offsets │ │ │ ├── hydrostatics/ # MOTOR DE CÁLCULO PRINCIPAL │ │ ├── integrator.py # Simpson 1/3, 3/8, trapezoidal, Gauss │ │ ├── upright.py # hidrostáticos en posición vertical │ │ ├── heeled.py # equilibrio escorado │ │ ├── trim.py # equilibrio con asiento │ │ ├── free_floating.py # equilibrio libre 3DOF │ │ ├── coefficients.py # Cb, Cp, Cw, Cm, Cws │ │ ├── curves_of_form.py # las "Curvas Hidrostáticas" │ │ └── bonjean.py # curvas de Bonjean │ │ │ ├── stability/ │ │ ├── intact.py # estabilidad intacta, GZ vs heel │ │ ├── damage.py # estabilidad en avería │ │ ├── criteria.py # IMO IS Code 2008, MSC.267(85) │ │ ├── floodable_length.py │ │ ├── downflooding.py │ │ └── weather.py # criterio meteorológico │ │ │ ├── tanks/ # MÓDULO DE TANQUES (DELFTship-style) │ │ ├── tank_definition.py │ │ ├── sounding_table.py # tablas de sondaje │ │ ├── ullage.py # tablas de vacío │ │ ├── fsm.py # Free Surface Moment │ │ ├── capacity_plan.py # plan de capacidades │ │ ├── trim_correction.py # corrección por trim │ │ ├── temperature_correction.py │ │ └── tank_calibration.py │ │ │ ├── resistance/ │ │ ├── holtrop_mennen.py # Holtrop & Mennen 1984 (motor) │ │ ├── savitsky.py # planeadores │ │ ├── van_oortmerssen.py # embarcaciones pequeñas │ │ ├── compton.py # semi-planeo │ │ ├── dsyhs.py # Delft Systematic Yacht Hull Series (veleros) │ │ ├── effective_power.py # PE = RT · V │ │ └── added_resistance.py # resistencia añadida en olas │ │ │ ├── propulsion/ │ │ ├── wageningen_b.py # Serie B Wageningen (KT, KQ, η) │ │ ├── propeller_design.py # diseño/selección de hélice │ │ ├── propeller_matching.py # matching motor-hélice │ │ ├── cavitation.py # criterios de cavitación (Burrill, Keller) │ │ ├── shaft_line.py # eje, soportes, alineación │ │ ├── waterjet.py # propulsión por chorro │ │ ├── pod.py # propulsión azimutal │ │ └── electric_drive.py # propulsión eléctrica/híbrida │ │ │ ├── engines/ # CATÁLOGO DE MOTORES Y SELECCIÓN │ │ ├── engine_db.py # catálogo (datos genéricos por familia) │ │ ├── engine_curve.py # curva BHP vs RPM, SFOC vs carga │ │ ├── engine_selection.py # algoritmo de selección por potencia │ │ ├── fuel_consumption.py # consumo en cada modo operativo │ │ ├── nox_emissions.py # emisiones IMO Tier I/II/III │ │ └── operating_profile.py # perfil operativo (% tiempo a cada velocidad) │ │ │ ├── sailing/ # MÓDULO PARA VELEROS │ │ ├── vpp.py # Velocity Prediction Program (núcleo) │ │ ├── aero_model.py # modelo aerodinámico (ORC-style) │ │ ├── hydro_model.py # hidrodinámica del velero (DSYHS) │ │ ├── sail_coefficients.py # CL, CD por tipo de vela y AWA │ │ ├── rig_geometry.py # geometría del aparejo │ │ ├── stability_sailing.py # momento adrizante, ángulo de escora │ │ ├── polar_diagram.py # diagrama polar de velocidad │ │ ├── handicap_orc.py # cálculo de rating ORC simplificado │ │ └── multihull.py # catamarán/trimarán específico │ │ │ ├── seakeeping/ │ │ ├── strip_theory.py # Salvesen-Tuck-Faltinsen │ │ ├── rao.py # Response Amplitude Operators │ │ ├── spectra.py # ITTC, JONSWAP, Pierson-Moskowitz │ │ ├── short_term.py # respuestas en mar corto │ │ ├── slamming.py # probabilidad de pantocazo │ │ ├── deck_wetness.py │ │ └── motion_sickness.py # MSI según ISO 2631 │ │ │ ├── systems/ # SISTEMAS DEL BUQUE │ │ ├── electrical/ │ │ │ ├── load_analysis.py # EPLA por modo operativo │ │ │ ├── generator_sizing.py # selección de gensets │ │ │ ├── battery_sizing.py # banco de baterías │ │ │ ├── one_line_diagram.py # diagrama unifilar │ │ │ ├── cable_sizing.py # dimensionamiento de cables │ │ │ ├── short_circuit.py # cortocircuito básico │ │ │ └── shore_power.py │ │ ├── fuel/ │ │ │ ├── fuel_system.py # diagrama, capacidades, autonomía │ │ │ ├── autonomy.py # cálculo de autonomía (rango) │ │ │ ├── transfer_pumps.py │ │ │ └── day_tank.py │ │ ├── lub_oil/ │ │ │ └── lub_oil_system.py │ │ ├── freshwater/ │ │ │ ├── fw_system.py # consumo, tanques, hidróforo │ │ │ ├── hot_water.py │ │ │ └── watermaker.py # osmosis inversa │ │ ├── sanitary/ │ │ │ ├── greywater.py │ │ │ ├── blackwater.py │ │ │ └── stp.py # planta de tratamiento │ │ ├── ballast/ │ │ │ ├── ballast_system.py │ │ │ └── ballast_pumps.py │ │ ├── bilge/ │ │ │ ├── bilge_system.py # achique │ │ │ ├── oily_water_separator.py │ │ │ └── bilge_pumps.py │ │ ├── firefighting/ │ │ │ ├── fire_main.py # agua salada presurizada │ │ │ ├── foam_system.py │ │ │ ├── co2_system.py │ │ │ ├── sprinkler.py │ │ │ ├── detection.py │ │ │ └── classification.py # zonas A60, B15, etc. │ │ ├── hvac/ │ │ │ ├── heat_balance.py # cargas térmicas por espacio │ │ │ ├── duct_sizing.py │ │ │ ├── chiller_sizing.py │ │ │ └── ventilation.py │ │ ├── steering/ │ │ │ ├── rudder_design.py # área, perfil, fuerza │ │ │ ├── steering_gear.py # potencia del servo │ │ │ └── thrusters.py # impulsores transversales │ │ ├── anchoring/ │ │ │ ├── anchor_selection.py │ │ │ ├── chain_locker.py │ │ │ └── windlass.py │ │ └── compressed_air/ │ │ └── compressed_air.py │ │ │ ├── io/ # IMPORT / EXPORT │ │ ├── offsets_csv.py │ │ ├── offsets_excel.py │ │ ├── dxf_reader.py │ │ ├── dxf_writer.py │ │ ├── iges_reader.py # con pythonocc, opcional │ │ ├── iges_writer.py │ │ ├── step_io.py │ │ ├── stl_export.py │ │ ├── obj_export.py │ │ ├── rhino_3dm.py # opcional (rhino3dm-py) │ │ ├── delftship_fbm.py # importar .fbm de DELFTship │ │ ├── maxsurf_msd.py # importar .msd si es posible (puede ser parcial) │ │ ├── project_serializer.py # formato .arsd │ │ └── pdf_export.py │ │ │ ├── parametric/ # GENERACIÓN PARAMÉTRICA │ │ ├── wizard_workboat.py # casco con espejo │ │ ├── wizard_cruiser.py # crucero a motor │ │ ├── wizard_sailing_mono.py # velero monocasco │ │ ├── wizard_sailing_cat.py # catamarán │ │ ├── wizard_planing.py # planeador │ │ ├── series60.py # generador serie 60 │ │ ├── wigley.py # casco matemático Wigley │ │ ├── kcs.py # KRISO Container Ship │ │ ├── dtmb5415.py # DTMB 5415 (caso militar) │ │ └── lackenby_transform.py # transformación paramétrica │ │ │ ├── reports/ │ │ ├── hydrostatic_report.py │ │ ├── stability_booklet.py # booklet completo │ │ ├── capacity_plan_report.py │ │ ├── lines_plan.py # plano de líneas (PDF y DXF) │ │ ├── general_arrangement.py # plano de disposición general │ │ ├── resistance_powering.py │ │ ├── electrical_balance.py # balance eléctrico │ │ ├── system_diagrams.py # P&IDs simplificados │ │ ├── vpp_report.py # polar diagram + tabla para velero │ │ └── pdf_builder.py # constructor común │ │ │ ├── ui/ # TODA LA UI Qt │ │ ├── main_window.py │ │ ├── i18n/ │ │ │ ├── es.json │ │ │ └── en.json │ │ ├── themes/ │ │ │ ├── light.qss │ │ │ └── dark.qss │ │ ├── icons/ # SVG │ │ ├── widgets/ │ │ │ ├── viewer_3d.py │ │ │ ├── viewer_lines.py # plano de líneas 2D │ │ │ ├── viewer_polar.py # polar diagram velero │ │ │ ├── tree_panel.py │ │ │ ├── properties_panel.py │ │ │ ├── hydrostatics_panel.py # panel fijo abajo, siempre visible │ │ │ ├── offsets_editor.py │ │ │ ├── tank_editor.py │ │ │ ├── loadcase_editor.py │ │ │ ├── rig_editor.py │ │ │ ├── engine_picker.py │ │ │ ├── propeller_designer.py │ │ │ ├── electrical_load_table.py │ │ │ ├── system_diagram_canvas.py # canvas para diagramas unifilares y P&ID │ │ │ └── curve_plotter.py │ │ ├── dialogs/ │ │ │ ├── new_project.py │ │ │ ├── wizards.py │ │ │ ├── stability_criteria_picker.py │ │ │ ├── liquid_picker.py │ │ │ ├── preferences.py │ │ │ └── about.py │ │ ├── commands/ # patrón Command para Undo/Redo │ │ │ ├── command.py │ │ │ ├── modify_hull.py │ │ │ ├── add_tank.py │ │ │ └── ... │ │ └── shortcuts.py # atajos de teclado centralizados │ │ │ └── utils/ │ ├── logger.py │ ├── settings.py │ ├── async_runner.py # QThreadPool para cálculos largos │ └── validation.py │ ├── data/ │ ├── liquids.json │ ├── stability_criteria.json │ ├── engine_catalog.json # catálogo genérico de motores │ ├── propeller_series/ │ │ └── wageningen_b.json │ ├── steel_grades.json │ ├── benchmarks/ # cascos de validación │ │ ├── wigley_hull.csv │ │ ├── series60_cb070.csv │ │ ├── kcs.csv │ │ ├── dtmb5415.csv │ │ ├── delft_372.csv # Delft Systematic Yacht Series │ │ └── README.md │ ├── icons_class/ # iconos para diagramas (bombas, válvulas, etc.) │ └── templates/ │ ├── lightship_workboat.json │ ├── lightship_yacht.json │ └── default_loadcases.json │ ├── tests/ │ ├── conftest.py │ ├── test_integrator.py │ ├── test_hydrostatics_wigley.py │ ├── test_hydrostatics_series60.py │ ├── test_gz_curve_imo.py │ ├── test_holtrop.py │ ├── test_savitsky.py │ ├── test_dsyhs.py │ ├── test_vpp.py │ ├── test_tank_calculations.py │ ├── test_capacity_plan.py │ ├── test_offsets_io.py │ ├── test_dxf_io.py │ ├── test_project_serialization.py │ ├── test_propeller_matching.py │ ├── test_electrical_load.py │ └── test_engine_selection.py │ └── docs/ ├── user_manual.md ├── theory_manual.md # FÓRMULAS + REFERENCIAS BIBLIOGRÁFICAS ├── validation_report.md # validación contra cascos canónicos ├── developer_guide.md └── changelog_internal.md ``` --- ## 5. Layout de la ventana principal (UX inspirada en DELFTship) ``` ┌──────────────────────────────────────────────────────────────────────────┐ │ Archivo | Editar | Ver | Modelo | Análisis | Sistemas | Reportes | Ayuda │ ├──────────────────────────────────────────────────────────────────────────┤ │ 🗎 💾 ↩ ↪ | 🔍 🚢 wizard | ⚙ unidades | ☀/🌙 tema | español ▾ │ ├────────────┬──────────────────────────────────────┬──────────────────────┤ │ │ │ │ │ 📁 Project │ │ Propiedades del │ │ ▾ Ship │ │ ítem seleccionado │ │ ▾ Casco │ │ │ │ Surf 1 │ Vista 3D principal (PyVista) │ Loa : 24.50 m │ │ Surf 2 │ │ Lpp : 23.40 m │ │ ▾ Apend. │ • orbit / zoom / pan │ B : 6.00 m │ │ Quilla │ • toggle waterlines │ T : 3.20 m │ │ Timón │ • toggle sections │ D : 3.80 m │ │ ▾ Tanques│ • shaded / wireframe / hidden │ ... │ │ FO 1 P │ • measure tool │ │ │ FO 1 S │ • clipping plane │ │ │ FW 1 │ │ │ │ ▾ Bodeg. │ │ │ │ ▾ Casos │ │ │ │ Light │ │ │ │ Full │ │ │ │ Ballast │ │ │ │ ▾ Aparejo│ │ │ │ Mástil │ │ │ │ Mayor │ │ │ │ ▾ Motor │ │ │ │ ▾ Sist. │ │ │ │ Eléct. │ │ │ │ Combust │ │ │ │ F.W. │ │ │ │ Achique │ │ │ │ Lastre │ │ │ │ CI │ │ │ │ HVAC │ │ │ ├────────────┴──────────────────────────────────────┴──────────────────────┤ │ HIDROSTÁTICOS EN VIVO (siempre visible): │ │ T=[3.20 m ▾] Δ=2845 t LCB=12.30 KB=1.85 KMT=4.20 GMT=1.05 │ │ TPC=8.2 t/cm MCT=42.5 Cb=0.682 Cw=0.821 Cm=0.985 ⚠ IMO OK │ ├──────────────────────────────────────────────────────────────────────────┤ │ Tabs: [3D] [Líneas] [Offsets] [Curvas] [Tanques] [Capacidad] │ │ [Estabilidad GZ] [Resistencia] [Propulsión] [VPP] [Movimientos] │ │ [Eléctrico] [Combustible] [F.W.] [Achique] [CI] [HVAC] [Reporte] │ └──────────────────────────────────────────────────────────────────────────┘ ``` **Reglas de UX irrenunciables:** 1. **Auto-recálculo** del panel hidrostático en <200 ms al cambiar el calado o el modelo. 2. **Undo/Redo robusto** (Ctrl+Z hasta 50 pasos, historial visible). 3. **Unidades configurables en UI**, SI internamente. 4. **Tooltips con la fórmula** en hover de cualquier campo calculado (p.ej. KMT → "KMT = KB + IT/∇"). 5. **Drag & drop** de offsets, IGES, DXF sobre la ventana. 6. **Wizards paso a paso** para cada tipo de embarcación. 7. **Validación visual** del modelo: panel rojo con problemas concretos + botón "intentar corregir". 8. **Hidrostáticos en vivo** abajo, siempre visible, no se puede ocultar (en lateral si la pantalla es chica). 9. **Indicador "⚠ IMO"** en verde/amarillo/rojo según cumplimiento del último caso de carga activo. --- ## 6. Módulo HIDROSTÁTICOS (el motor que alimenta todo) Para cualquier calado/asiento/escora, sobre la malla triangular del casco con **regla de Simpson 1/3** (fallback 3/8 cuando estaciones no son impares, trapezoidal para mallas irregulares): | Símbolo | Nombre | Fórmula | |---------|--------|---------| | ∇ | Volumen desplazado | ∫∫∫ dV | | Δ | Desplazamiento | ρ · ∇ | | Aw | Área del plano de flotación | ∫∫ dA en z=T | | Cw | Coef. plano flotación | Aw / (Lwl · B) | | Am | Área cuaderna maestra | ∫ y dz en x=Lpp/2 | | Cm | Coef. cuaderna maestra | Am / (B · T) | | Cb | Coef. de bloque | ∇ / (Lwl · B · T) | | Cp | Coef. prismático | Cb / Cm | | S | Superficie mojada | ∫∫ dS | | LCB | Centro long. carena | ∫∫∫ x dV / ∇ | | KB (VCB) | Centro vert. carena | ∫∫∫ z dV / ∇ | | LCF | Centro long. flotación | ∫∫ x dA / Aw | | IT | Inercia transv. de Aw | ∫∫ y² dA | | IL | Inercia long. de Aw | ∫∫ (x−xF)² dA | | BMT | Radio metac. transv. | IT / ∇ | | BML | Radio metac. long. | IL / ∇ | | KMT | Altura metac. transv. | KB + BMT | | KML | Altura metac. long. | KB + BML | | TPC | Toneladas por cm inmersión | Aw · ρ / 100 | | MCT (MTC) | Momento para cambiar asiento 1 cm | Δ · GML / (100 · Lpp) | | WSA | Wetted Surface Area | S | | Cws | Coef. superficie mojada | S / √(∇ · Lwl) | **Salidas obligatorias del módulo:** - **Curvas de Forma** (los 12-15 parámetros vs calado en una gráfica multi-escala). - **Curvas de Bonjean** (área seccional vs calado, por estación). - **Resolutor de equilibrio libre 3 GDL** (heave + trim + heel) con `scipy.optimize.fsolve` o Newton-Raphson, tolerancia configurable. --- ## 7. Estabilidad y curva GZ - **GZ vs escora** de 0° a 90° en pasos de 5° (configurable). En cada ángulo: mantener Δ constante, reequilibrar trim, calcular B', GZ = brazo horizontal G→vertical de B'. - Salidas: curva GZ, GZmax y ángulo, rango de estabilidad positiva, ángulo de inundación progresiva, área bajo curva. - **Criterios IMO IS Code 2008 (MSC.267(85))**: - A(0→30°) ≥ 0.055 m·rad - A(0→40°) ≥ 0.090 m·rad - A(30→40°) ≥ 0.030 m·rad - GZ(30°) ≥ 0.20 m - Ángulo de GZmax ≥ 25° - GMT inicial ≥ 0.15 m - **Criterio meteorológico** A.749(18). - Criterios extra: USCG, ABS, RINA — configurables en `data/stability_criteria.json`. - **Estabilidad en avería** (determinística): por compartimento, permeabilidad configurable, método de pérdida de flotabilidad. - **Floodable length curve**. --- ## 8. TANQUES (lo bueno de DELFTship) Esta es la parte donde el software gratuito típicamente flojea. Hacerla bien. ### 8.1 Definición de tanque - **Geometría**: - **Prismático** (6 planos): caso fácil. - **Con forma de casco** (límite exterior = superficie del casco): wing tanks, double bottom. - **Arbitrario** (malla triangular cerrada): casos complejos. - **Tipo**: HFO, MGO, LO, FW, SW lastre, agua gris, agua negra, sentina, carga líquida, vacío. - **Líquido** desde `data/liquids.json` (ver §8.4), override permitido. - **Capacidad 100%** (volumen geométrico calculado). - **Capacidad operativa** (98% combustibles, 95% agua, 100% carga estiba). - **Nivel actual** (intercambiable: % / m³ / t / sondaje). - **Posición de boca de medición** (para que las tablas de sondaje reflejen el sensor real). - **Permeabilidad** (avería): 0.95 líquidos, 0.85 carga seca, 0.95 máquinas, 0.60 acomodación. ### 8.2 Cálculos por tanque 1. **Tabla de sondaje**: cada cm (config) desde el fondo: V, peso, LCG, TCG, VCG del contenido, FSM, IT del líquido. 2. **Tabla de ullage** (equivalente desde el techo). 3. **Curva de FSM vs nivel**. 4. **Corrección por trim** (las tablas dependen del asiento). 5. **Corrección por temperatura** (para combustibles, expansión). 6. **Validación**: detección de intersecciones entre tanques, tanques fuera del casco, mal cerrados. ### 8.3 Integración con estabilidad En cada `LoadCase`: - Sumar pesos (lightship + cargas + líquidos). - Calcular LCG/TCG/VCG combinado. - **GG' (corrección FSM)** = Σ(FSMi · ρi) / Δ. - **GMT corregido** = GMT − GG'. - Reportar equilibrio + estabilidad + cumplimiento criterios. ### 8.4 `data/liquids.json` precarga ```json { "HFO": {"name": "Heavy Fuel Oil", "density_kg_m3": 991, "viscosity_cSt": 380}, "MGO": {"name": "Marine Gas Oil", "density_kg_m3": 890, "viscosity_cSt": 6}, "MDO": {"name": "Marine Diesel Oil", "density_kg_m3": 870, "viscosity_cSt": 11}, "LSFO": {"name": "Low Sulphur Fuel Oil", "density_kg_m3": 985, "viscosity_cSt": 180}, "LO": {"name": "Lubricating Oil", "density_kg_m3": 920, "viscosity_cSt": 100}, "HO": {"name": "Hydraulic Oil", "density_kg_m3": 875, "viscosity_cSt": 46}, "FW": {"name": "Fresh Water", "density_kg_m3": 1000, "viscosity_cSt": 1.0}, "SW": {"name": "Sea Water (ballast)", "density_kg_m3": 1025, "viscosity_cSt": 1.05}, "DW": {"name": "Distilled Water", "density_kg_m3": 999, "viscosity_cSt": 1.0}, "SLP": {"name": "Slop / Bilge", "density_kg_m3": 1010, "viscosity_cSt": 5}, "SEW": {"name": "Sewage", "density_kg_m3": 1010, "viscosity_cSt": 3}, "URE": {"name": "Urea 40% (SCR)", "density_kg_m3": 1090, "viscosity_cSt": 1.4} } ``` --- ## 9. RESISTENCIA — múltiples métodos según tipo de buque Selección automática del método según parámetros (con override manual): | Método | Aplicabilidad | |--------|--------------| | **Holtrop & Mennen 1984** | Cascos de desplazamiento convencionales, 0.05 < Fr < 0.45 | | **Van Oortmerssen 1971** | Embarcaciones pequeñas Lwl 8–80 m, desplazamiento | | **Compton 1986** | Semi-planeo 0.4 < Fr < 0.9 | | **Savitsky 1964** | Planeadores prismáticos, Fr_∇ > 1.0 | | **Delft Systematic Yacht Hull Series (DSYHS)** | Veleros (Keuning–Sonnenberg) | | **Mercier–Savitsky** | Round bilge planing | ### 9.1 Holtrop & Mennen 1984 (detalle obligatorio) Implementar con todos los componentes: - **RF** (ITTC-57): CF = 0.075 / (log₁₀ Rn − 2)² - **(1+k)** factor de forma (fórmula de Holtrop, c14) - **RAPP** apéndices (con factores 1+k2 por apéndice) - **RW** olas (con c1…c17 según Fr y Cp) - **RB** bulbo de proa - **RTR** espejo de popa - **RA** corrección modelo-buque (CA) - **RT = (1+k)·RF + RAPP + RW + RB + RTR + RA** - **PE = RT · V** Inputs derivados automáticamente del modelo: L, B, T, Cb, Cp, Cm, Cw, ∇, S, LCB%, AT (transom), ABT y hB (bulbo). Salida: curva RT y PE vs V (Fr 0.05 → 0.45 o rango definido). Referencia: Holtrop J., 1984, *"A statistical re-analysis of resistance and propulsion data"*, ISP Vol. 31. ### 9.2 DSYHS (veleros) Para veleros usar la regresión de Delft (Keuning–Sonnenberg 1998 y actualizaciones): - Resistencia residual del casco desnudo (upright). - Incremento por escora (heel drag). - Resistencia inducida por sideforce (apéndices). - Resistencia añadida en olas. Parámetros geométricos requeridos: Lwl, Bwl, Tc (canoe body), ∇c, LCB%, LCF%, Cp, Aw, S, BTR (beam-to-draft ratio). --- ## 10. PROPULSIÓN ### 10.1 Serie B Wageningen Implementar coeficientes KT, KQ vs J para: - Número de palas Z = 2, 3, 4, 5, 6, 7 - Relación área expandida/disco AE/A0 = 0.30 → 1.05 - Relación paso/diámetro P/D = 0.5 → 1.4 Fórmulas polinómicas Oosterveld–van Oossanen (con corrección de Reynolds). ### 10.2 Matching motor-hélice Algoritmo: 1. Dado RT(V) y selección de hélice (D, P/D, AE/A0, Z). 2. Calcular wake fraction w y thrust deduction t (Holtrop). 3. Resolver punto de operación: T(1−t) = RT, encontrar n (rpm de hélice). 4. Calcular Q, PD (delivered power), aplicar eficiencias (η_S eje, η_R relativo rotacional, η_G reductora). 5. **PB (brake power)** = PD / (η_S · η_G). 6. Comparar con curva del motor a ese rpm. Salida: punto de operación óptimo, curvas de KT, KQ, η, demanda vs disponible. ### 10.3 Cavitación - **Criterio de Burrill** (gráfico σ vs τc). - **Criterio de Keller** (mínimo AE/A0 para evitar cavitación). - Alerta visual cuando el diseño viola alguno. ### 10.4 Otros propulsores - **Waterjet**: cálculo simplificado de empuje vs caudal y velocidad. - **Pod azimutal**: con factor de degradación frente a hélice convencional. - **Propulsión eléctrica/híbrida**: cálculo de potencia eléctrica requerida, factor de carga, eficiencia de motor eléctrico, gestión de batería. --- ## 11. MOTORES y dimensionamiento ### 11.1 Catálogo `data/engine_catalog.json` Catálogo **genérico por familia** (no fabricante específico para evitar IP). Datos típicos: ```json { "high_speed_diesel": { "rpm_range": [1500, 2400], "bhp_range_kw": [50, 1500], "sfoc_at_85_kw_kwh": 215, "weight_kg_per_kw": 3.5, "applications": ["yates", "workboats", "patrulleras"] }, "medium_speed_diesel": { "rpm_range": [600, 1200], "bhp_range_kw": [500, 8000], "sfoc_at_85_kw_kwh": 195, "weight_kg_per_kw": 12, "applications": ["ferries", "OSV", "cargo pequeño"] }, "low_speed_two_stroke": { "rpm_range": [70, 180], "bhp_range_kw": [3000, 80000], "sfoc_at_85_kw_kwh": 165, "weight_kg_per_kw": 38, "applications": ["bulk carrier", "tanker", "container"] }, "outboard_petrol": {...}, "outboard_electric": {...}, "gas_turbine": {...}, "dual_fuel": {...}, "fuel_cell_h2": {...} } ``` ### 11.2 Algoritmo de selección Inputs: PB requerida al MCR, velocidad de servicio, perfil operativo (% del tiempo a cada V). Salida ranked: 1. Familia recomendada. 2. Cantidad de motores (1, 2, 4). 3. Rango de rpm óptimo para matching con hélice. 4. SFOC promedio sobre el perfil operativo → **consumo en t/día** y **rango / autonomía**. 5. Peso seco estimado. ### 11.3 Curva de consumo SFOC vs % carga del motor (curva en U típica con mínimo cerca del 80%). Salidas: - Consumo en cada modo (en puerto, maniobra, navegación, full ahead). - **Autonomía**: rango_nm = (capacidad_FO · 1000 / consumo_horario · ηtransfer) · V_servicio - **CO₂ emitido por viaje** (factor 3.114 kg CO₂ / kg HFO). - **NOx**: comparación con límite IMO Tier I/II/III según año y zona. --- ## 12. VELEROS — Módulo VPP completo ### 12.1 Arquitectura del VPP Sigue el esquema clásico (ORC y Maxsurf VPP): **Loop de equilibrio para cada (TWS, TWA):** 1. Estimar velocidad inicial Vboat. 2. Calcular AWA y AWS (viento aparente) a partir de TWS, TWA, Vboat. 3. **Modelo aerodinámico** → fuerza propulsiva, fuerza lateral (heeling force), momento escorante. 4. **Modelo hidrodinámico** → resistencia total (upright + heel + induced + added wave) y sideforce de apéndices. 5. **Balance de fuerzas**: - ΣFlongitudinal = 0 → F_drive = R_total - ΣFlateral = 0 → F_side_sails = F_side_apéndices (define leeway angle β) - ΣMroll = 0 → Heeling moment = Righting moment (define φ ángulo de escora) 6. Si no balancea, ajustar Vboat y volver al paso 2. 7. Para optimizar VMG, iterar también sobre reef (rizado) y flat (planitud de vela). ### 12.2 Modelo aerodinámico (estilo ORC) Coeficientes CL y CD por tipo de vela vs AWA: - **Main + jib** (upwind) - **Main + genoa** - **Main + spinnaker** (downwind asimétrico) - **Main + code zero** Cada vela: `Cl_max`, `Cd_min`, curvas tabuladas. Compatible con la documentación pública del ORC VPP 2023. Escalado con altura del centro de esfuerzo (CE), corrección por gradiente de viento (perfil logarítmico atmosférico). ### 12.3 Modelo hidrodinámico - **DSYHS** (Keuning–Sonnenberg) para resistencia upright del canoe body. - **Heel drag** por incremento de WSA y cambio de forma de carena al escorar. - **Induced drag** del keel y timón (teoría de Glauert). - **Added wave resistance** (regresión de Gerritsma). ### 12.4 Estabilidad del velero Momento adrizante con corrección por: - Velocidad (loss of stability with speed). - Movimiento de tripulación (crew on rail). - Vela arrizada / flat factor. ### 12.5 Salidas - **Polar diagram** interactivo (TWA radial, V boat radial, TWS curvas). - **Tabla de velocidades** TWS × TWA (igual que ORC). - **VMG upwind y downwind** con TWA óptimo. - **Curvas de target speed** para regata. - **Rating ORC simplificado** (estimación, no certificado). ### 12.6 Multicascos Catamarán/trimarán: balance lateral diferente (no escora, levanta casco a barlovento). Hidrodinámica por casco individual + interferencia. Momento de vuelco (capsize moment) en lugar de adrizamiento. --- ## 13. SEAKEEPING (predicción de movimientos) **Strip theory Salvesen–Tuck–Faltinsen (1970)** para los 6 GDL. Outputs: - **RAOs** por modo, vs ω y rumbo respecto a olas. - Espectros: ITTC, Pierson–Moskowitz, JONSWAP (parametrizable Hs, Tp, γ). - Respuestas a corto plazo: significant motion, máximo esperado en N ciclos. - Probabilidad de **slamming**, **deck wetness**, **propeller emergence**. - **MSI** (Motion Sickness Incidence) según ISO 2631. - Gráficas polares de movimientos vs rumbo. --- ## 14. SISTEMAS DEL BUQUE Cada sistema tiene su propia tab en la UI, su propio modelo de datos en `core/`, su propio motor de cálculo en `systems/`, y su propio reporte en `reports/`. ### 14.1 Sistema ELÉCTRICO **Electrical Power Load Analysis (EPLA)** clásico: - Lista de consumidores eléctricos (luces, bombas, motores auxiliares, electrónica, HVAC, cocina, etc.) con: - Potencia conectada (kW) - Tensión (24V DC / 230V AC / 400V AC / 690V AC) - Factor de carga (LF) por modo operativo - Factor de simultaneidad - **Modos operativos** configurables: - En puerto, sin carga - En puerto, cargando/descargando - Maniobra - Navegación normal - Navegación con mal tiempo - Emergencia - **Cálculo automático** por modo: ΣP · LF · KS = demanda eléctrica del modo. - **Selección de generadores**: número, potencia, redundancia (uno fuera de servicio debe cubrir el modo crítico). - **Banco de baterías** (yates, eléctricos): capacidad Ah, autonomía a hotel load, recarga. - **Diagrama unifilar** dibujado en canvas Qt: barras principal/emergencia, breakers, transformadores, consumidores agrupados. - **Cable sizing** simplificado por corriente de carga, longitud y caída de tensión (≤3% en main, ≤1% en lighting). - **Cortocircuito** básico (Icc en barras principales). - **Reporte** "Electrical Load Balance" estilo clasificadora. ### 14.2 Sistema de COMBUSTIBLE - Tanques de almacenamiento + tanque de servicio diario (day tank) + tanque de sedimentación. - Bombas de trasiego (capacidad mínima: llenar day tank en 30 min). - Separadoras (purificadoras) — capacidad según caudal de motor + margen. - Tubería con diámetros calculados por velocidad de fluido (~1 m/s succión, ~2 m/s descarga). - **Autonomía**: con perfil operativo y consumo de motor → días de navegación, rango en mn. - Diagrama P&ID simplificado. ### 14.3 Sistema de LUBRICACIÓN - Carter del motor + tanque de almacenamiento + tanque de lodos. - Bomba de lubricación, enfriador, filtros. - Cálculo de tiempo entre cambios según horas de operación. ### 14.4 Sistema de AGUA DULCE - Consumo per cápita: 120-200 L/persona/día (configurable según tipo de buque). - Tanques + hidróforo + calentador. - **Watermaker (osmosis inversa)**: caudal vs consumo + margen, energía consumida (~3-4 kWh/m³). - Dimensionamiento de tanques para autonomía con/sin watermaker. ### 14.5 Sistema SANITARIO (aguas grises y negras) - Tanques de retención (capacidad mínima según MARPOL Anexo IV). - STP (Sewage Treatment Plant) o tanque de retención + descarga en puerto. - Conexiones a tierra. ### 14.6 Sistema de LASTRE - Tanques de lastre + bombas de lastre. - **Diagrama de lastre** para transición entre casos de carga. - Cumplimiento Ballast Water Management Convention (D-1/D-2) — solo nota informativa. ### 14.7 Sistema de ACHIQUE (BILGE) - Bomba principal + emergencia. - **Capacidad** mínima según clasificadora (típico: vaciar el compartimento más grande en 2 horas). - Separador de sentinas (OWS) — 15 ppm IMO. - Diagrama de tuberías por compartimento. ### 14.8 Sistema CONTRAINCENDIOS - **Fire main** (agua salada presurizada): bombas principales + emergencia, hidrantes, mangueras, lanzas, presión mínima en hidrante más alejado (típico 3.5 bar). - **Sistema fijo**: CO₂ para cámara de máquinas (5-7% volumen), espuma para tanques de combustible. - **Sprinklers** en acomodaciones (clase B). - **Detección**: humo, calor, llama; zonas A60/A30/B15. - Esquema de clasificación de mamparos por zona. - **Cálculo**: capacidad de bomba CI = mínimo 2 chorros simultáneos en hidrante más desfavorable. ### 14.9 Sistema HVAC - **Heat balance** por espacio: cargas sensibles + latentes + ganancia/pérdida por mamparos. - Condiciones ambientales: ASHRAE (verano 35°C/27°C húmedo, invierno -10°C) — configurables. - Caudal de aire por espacio (renovaciones/hora según uso). - **Dimensionamiento de chiller**: kW frigoríficos + margen 15%. - **Ductos**: velocidades 4-6 m/s en main, 2-3 m/s en ramificaciones. - Reporte de cargas por compartimento. ### 14.10 Sistema de GOBIERNO - **Diseño del timón**: área (regla típica A_R = c · L · T donde c = 1.5–2.5% para mercante, 4-6% para velero). - **Fuerza en el timón** a velocidad máxima (fórmula de Joessel modificada). - **Steering gear**: torque requerido, potencia hidráulica, tiempo de banda-a-banda (≤28 s a max ahead según SOLAS). - **Thrusters** transversales: empuje requerido para vientos cruzados típicos. --- ## 15. IMPORTACIÓN / EXPORTACIÓN ### 15.1 Tabla de offsets Aceptar CSV/Excel en dos formatos: 1. **Largo** (3 columnas: Station, Waterline, HalfBreadth). 2. **Matricial** (filas = estaciones, columnas = WL, celdas = semi-mangas). Wizard: previsualización con detección automática del formato; si falla, asistente paso a paso. Ajustar superficies NURBS por mínimos cuadrados con `geomdl.fitting.approximate_surface`. ### 15.2 Otros formatos - **IGES**: lectura/escritura con pythonocc-core (opcional). - **STEP**: lectura/escritura idem. - **DXF**: polylines 3D que representan WL/sections/buttocks → reconstrucción por skinning. - **STL/OBJ**: malla triangular (export para CFD externo o impresión). - **Rhino 3DM**: con `rhino3dm-py` (opcional). - **DELFTship .fbm**: lectura best-effort (formato binario propio). - **Maxsurf .msd**: lectura parcial best-effort. ### 15.3 Wizards paramétricos - Casco con espejo (workboat). - Crucero a motor (yate de desplazamiento). - Planeador (semi-V, hard chine). - Velero monocasco moderno. - Catamarán. - Serie 60 (Cb objetivo). - Wigley (validación). - DTMB 5415 (validación militar). ### 15.4 Exportación - DXF 2D (plano de líneas con cajetín, escala, cotas, estilo astillero). - DXF 3D (wireframe). - IGES, STEP, STL, OBJ, CSV. - PDF de reportes. --- ## 16. CASOS DE CARGA (`LoadCase`) Cada `LoadCase` agrega: - **Lightship**: peso en rosca con LCG/TCG/VCG, radios de giro (kxx, kyy, kzz). - **Deadweight items**: lista de pesos (tripulación, provisiones, equipo, stores) con posición. - **Cargo**: bodegas con peso y CG o densidad y nivel. - **Tanques**: nivel de cada uno. - **Trim correctors / constants**. Motor → equilibrio + reporte: - Calado en proa, popa, medio, en perpendiculares. - Trim, heel. - Δ, GMT, GMT corregido por FSM. - Reserva de flotabilidad. - Cumplimiento criterios IMO (verde/amarillo/rojo). Plantillas predefinidas: Lightship, Departure full, Arrival full, Departure ballast, Arrival ballast. --- ## 17. VALIDACIÓN CONTRA BENCHMARKS Antes de marcar un módulo como completo, validar contra cascos con valores publicados: | Casco | Origen | Validar | |-------|--------|---------| | **Wigley** | Casco matemático | ∇, S, Cb, Cp analíticos | | **Series 60 Cb 0.70** | Todd 1963 | Hidrostáticos + Holtrop | | **KCS (KRISO Container Ship)** | Tokyo 2015 workshop | Holtrop + CFD ref | | **DTMB 5415** | Combatant naval | Hidrostáticos + seakeeping | | **Delft 372** | DSYHS (velero) | Resistencia upright + heel | Cada test guarda el resultado en `tests/benchmark_results/` y compara con tolerancia (±2% típicamente). --- ## 18. PLAN DE SPRINTS (ejecuta en este orden) Cada sprint termina con: tests pasando, commit etiquetado, entrada en `CHANGELOG.md`, sección añadida a `docs/user_manual.md`. ### Sprint 0 — Setup (esta sesión, esperable 1-2 horas) - Crear estructura completa de carpetas con stubs. - `pyproject.toml`, `requirements.txt`, `.gitignore`, `LICENSE` (MIT por defecto, pregúntame si quieres otra). - `main.py` que abra una ventana Qt vacía con menú base. - `core/project.py` con clase `Project` y serialización `.arsd` (vacía pero funcional). - `core/units.py` con conversiones SI ↔ imperial. - `ui/main_window.py` con el layout descrito en §5 (paneles vacíos pero presentes). - `tests/conftest.py` y un test trivial que valide que arranca. - Git init + primer commit `v0.1-sprint0`. - **Entregable**: la app abre, se ve el layout, archivo nuevo / guardar / abrir funcionan con `.arsd` vacío. ### Sprint 1 — Geometría y offsets - `geometry/nurbs_surface.py`, `geometry/mesh.py`, `geometry/slicer.py`. - `io/offsets_csv.py`, `io/offsets_excel.py`. - `ui/widgets/offsets_editor.py`, `ui/widgets/viewer_3d.py`. - Wizard Wigley (caso de validación inmediata). - **Entregable**: cargar tabla de offsets, ver casco en 3D, ver waterlines/sections. ### Sprint 2 — Hidrostáticos básicos - `hydrostatics/integrator.py` (Simpson 1/3, 3/8, trap). - `hydrostatics/upright.py`, `coefficients.py`, `curves_of_form.py`. - `ui/widgets/hydrostatics_panel.py` (panel inferior siempre visible). - Tests contra Wigley analítico y Series 60. - **Entregable**: panel hidrostático abajo recalcula al cambiar calado. ### Sprint 3 — Equilibrio libre y estabilidad GZ - `hydrostatics/free_floating.py`, `heeled.py`, `trim.py`. - `stability/intact.py`, `criteria.py`. - `ui/widgets/curve_plotter.py` (pyqtgraph). - **Entregable**: curva GZ + cumplimiento IMO con semáforo. ### Sprint 4 — Tanques completo - `core/tank.py`, `core/liquid.py`. - `tanks/*` (todos los módulos). - `ui/widgets/tank_editor.py`. - `core/loadcase.py` + integración con estabilidad. - **Entregable**: definir tanques, generar tablas de sondaje, ver capacity plan, estabilidad con FSM. ### Sprint 5 — Resistencia y propulsión - `resistance/holtrop_mennen.py`, `savitsky.py`, `van_oortmerssen.py`. - `propulsion/wageningen_b.py`, `propeller_matching.py`. - `engines/engine_db.py`, `engine_selection.py`. - **Entregable**: curva RT/V, selección hélice, selección motor con consumo. ### Sprint 6 — Veleros y VPP - `core/rig.py`, `core/sail.py`. - `sailing/vpp.py`, `aero_model.py`, `hydro_model.py`. - `resistance/dsyhs.py`. - `ui/widgets/viewer_polar.py`. - **Entregable**: polar diagram completo, tabla de velocidades estilo ORC. ### Sprint 7 — Sistemas del buque - `systems/electrical/*` con EPLA y diagrama unifilar. - `systems/fuel/*` con autonomía. - `systems/freshwater/*`, `bilge/*`, `ballast/*`. - `ui/widgets/system_diagram_canvas.py`. - **Entregable**: balance eléctrico completo, autonomía calculada, diagramas básicos. ### Sprint 8 — CI, HVAC, gobierno - `systems/firefighting/*`, `hvac/*`, `steering/*`, `anchoring/*`. - **Entregable**: dimensionamiento de timón, servo, CI, HVAC. ### Sprint 9 — Seakeeping - `seakeeping/strip_theory.py`, `rao.py`, `spectra.py`. - **Entregable**: RAOs, espectros, MSI. ### Sprint 10 — Reportes profesionales - Todos los `reports/*` con plantillas PDF estilo astillero. - Stability Booklet completo. - Capacity Plan. - Lines Plan en PDF y DXF. ### Sprint 11 — IGES/STEP, paramétricos avanzados - `io/iges_*`, `step_io.py` con pythonocc. - `parametric/lackenby_transform.py`. - Wizards completos para todos los tipos. ### Sprint 12 — Empaquetado y distribución - `PyInstaller` config para `.exe`. - Splash screen, icono, installer (NSIS). - Manual de usuario PDF. --- ## 19. REGLAS DE TRABAJO ENTRE TÚ Y YO 1. **Antes de cada sprint**, resúmeme en 3-5 líneas qué vas a hacer y pídeme go/no-go. 2. **Si una decisión técnica afecta el roadmap** (cambiar librería, refactor grande), pregúntame antes. 3. **Si encuentras que algo de este documento es ambiguo o contradictorio**, dilo. No asumas. 4. **Si una fórmula del estado del arte tiene varias versiones publicadas**, escoge la más citada o la más reciente (preferentemente Holtrop 1984 sobre Holtrop 1982; ORC VPP 2023 sobre versiones anteriores) y deja referencia explícita en el docstring. 5. **No instales dependencias pesadas** (pythonocc, rhino3dm) hasta el sprint que las necesite. 6. **Commits frecuentes**, mensajes descriptivos, en español. 7. **Tests obligatorios** para cualquier fórmula numérica antes de declarar el sprint terminado. 8. **Documenta a medida que avanzas**: `docs/theory_manual.md` se llena en paralelo al código, no al final. 9. Si un cálculo es lento (>2 s) en un caso típico, **muévelo a un QThreadPool** para no congelar la UI. 10. **Validación visual**: cualquier resultado numérico que se muestre en la UI debe poder graficarse al lado, o tener una vista que ayude a interpretarlo (el usuario debe saber leer una curva, no solo un número). --- ## 20. Empezamos Cuando hayas leído este documento por completo: 1. Confírmame en 5 líneas máximo qué entendiste, qué dudas tienes (si las hay), y qué vas a entregar al final del **Sprint 0**. 2. Cuando te diga "go", ejecuta Sprint 0 completo y muéstrame al final cómo abrir la app y qué deberíamos ver. ¿Listo? Empecemos.