Comb acciones

Aplicación de escritorio (Tkinter) que automatiza, dentro de SAP2000, el modelado 2D de cajones hincados (box culverts) ferroviarios multi-celda y la generación de las combinaciones de acciones según la norma IAPF (Instrucción sobre las Acciones a considerar en el Proyecto de Puentes de Ferrocarril).

La aplicación no dibuja nada por sí sola en pantalla: pilota SAP2000 a través de su API COM (comtypes), por lo que SAP2000 tiene que estar ya abierto con un modelo (aunque sea vacío) antes de lanzar la aplicación.

Requisitos

• SAP2000 instalado y abierto antes de ejecutar la aplicación (la aplicación se conecta a la instancia ya abierta; no lo abre por ti).
• Python 3.x.
• Dependencias de requirements.txt (comtypes, pandas, numpy, openpyxl). tkinter es de la librería estándar y no hace falta instalarlo aparte.

Instalación de dependencias:

pip install -r requirements.txt

Nota sobre comtypes.gen.SAP2000v1: no es un paquete de PyPI, es el "binding" que comtypes genera automáticamente la primera vez que se conecta a la type library de SAP2000 instalada localmente en la máquina. Por eso hace falta tener SAP2000 instalado (no basta con pip install comtypes).

Cómo ejecutar

Con SAP2000 ya abierto:

python "Comb_acciones.py"

Si no se encuentra ninguna instancia de SAP2000 abierta, la aplicación muestra un aviso y termina; ábrela primero y vuelve a lanzar el script.

Flujo de trabajo recomendado

Desde la ventana principal, en este orden:

1. Datos del Proyecto — hormigón del proyecto y ancho de sección (único para todas las secciones, justo debajo del hormigón), luces horizontales (celdas), altura (LV), espesores, huecos, retranqueos, vigas auxiliares, etc. Las celdas (lista "LH") no tienen límite de cantidad: la primera siempre está presente, y se añaden/quitan por el final con "+ Añadir celda" / "Quitar última celda" (se muestran en una lista vertical compacta). Los muros interiores (lista "M") tampoco tienen límite: se reconstruyen automáticamente para que siempre haya exactamente nº de celdas - 1 (la misma regla que usa la geometría real). Las vigas auxiliares (VA1-3) no dependen de nada: se añaden o quitan a mano con los botones "+ Añadir viga auxiliar" / "Quitar viga", hasta un máximo de 3. Al final de la ventana está el bloque "Datos geotécnicos", que edita el apartado datos_geotecnicos del JSON (los datos del terreno, ver más abajo).

2. Definición de Geometría — al abrir la ventana se crean en SAP2000 el hormigón del proyecto (si no existe) y una sección rectangular armada por elemento (canto = espesor "e" del elemento, ancho = el "Ancho de sección" único del proyecto, ver sections.py). Cada desplegable lista todas las secciones del modelo y viene preseleccionado con la que le toca al elemento según los Datos del Proyecto, así que normalmente solo hay que pulsar "Crear geometría", que construye las barras (losa inferior LI, losa superior LS, hastiales HI/HD y los muros interiores M1, M2... que correspondan, sin límite de cantidad) con el layout multi-celda calculado a partir de los Datos del Proyecto. Los elementos con el mismo espesor comparten sección (el nombre sale del canto, p.ej. Losa 0.35 m), así que no se duplican en SAP2000. Los cantos y anchos se escriben siempre con 2 decimales como mínimo, y con todos los que tengan si son más (Losa 0.135 m); ver sections.formato_dimension.

   Ya no hace falta pasar por "Materiales y Secciones" antes de la geometría. Ese botón sigue disponible como extra manual y opcional para crear a mano secciones que no salen de los datos del cajón.

3. Definición de Cargas — define los casos de carga (H1, H2, H3...) que se usarán en las combinaciones.

4. Asignación de Cargas a la Geometría — para cada carga definida en el paso 3 se elige un tipo de cálculo (uno de los scripts de la carpeta calculo/), se rellenan las celdas editables que ese script declara, y se asigna el resultado a las barras del modelo. Cada script propone las barras a las que suele aplicarse (la selección se puede cambiar a mano) y puede imponer el eje o un reparto en tramos a medida. La configuración de cada carga (script + celdas + barras + eje) se guarda en el JSON del proyecto, así que "Asignar todas las guardadas" repite el trabajo de una vez. Para añadir un tipo de cálculo nuevo basta con copiar calculo/_plantilla.py: aparece solo en el desplegable, sin registrar nada (ver calculo/README.md).

5. Matriz de Incompatibilidades — marca qué pares de casos de carga no pueden coexistir en una misma combinación.

6. Configuración de Combinaciones — crea las combinaciones según la norma IAPF, lanza el cálculo ("Calcular") y extrae los resultados (combinaciones, flechas, esfuerzos) a Excel.

El JSON del proyecto

Todo el proyecto vive en un único archivo .json con estos apartados de primer nivel:

Apartado	Contenido
loads	casos de carga (H1, H2, H3…).
compatibility	matriz de incompatibilidades entre casos de carga.
misc	listas de valores permitidos (tipo, dirección, acción).
datos_proyecto	geometría del cajón (LH, LV, LS, LI, HI, HD, M, VA1-3, hormigón, ancho de sección).
datos_geotecnicos	datos del terreno (ver abajo).
load_assignments	asignación de cargas guardada (script + celdas + barras por carga).

datos_geotecnicos es un apartado hermano de datos_proyecto, no va dentro de él. Contiene:

• los datos del terreno sueltos (talud_relleno, talud_h, peso_específico, peso_sumergido, ang_roz, prof_nf);
• vias: lista de vías de longitud variable y sin límite (la 1ª siempre presente, se añaden/quitan por el final con "+ Añadir vía" / "Quitar última vía"). Cada vía es un dict, con el mismo patrón que los muros interiores M, y sus campos están en project_data.VIA_CAMPOS_DEFECTO: ancho (m), cota_carril (cota del carril de esa vía, m), tipo_carril y tipo_traviesa. Los dos últimos son desplegables: están en project_data.CAMPOS_OPCION_VIA, que apunta a la tabla del apartado misc con sus opciones (misc["tipos_carril"] y misc["tipos_traviesas"], cuyas claves son los tipos y cuyos valores son los datos de cada tipo). Se guardan como texto; opciones_de_campo_via(misc, campo) da la lista de opciones y datos_de_opcion_via(misc, campo, valor) los datos del tipo elegido. Para añadir un dato más por vía basta con ponerlo en VIA_CAMPOS_DEFECTO, etiquetarlo en LABELS_VIAS y —si es un desplegable— apuntar su tabla de misc en CAMPOS_OPCION_VIA: la ventana dibuja la columna sola y normalizar_vias completa los proyectos ya guardados. Los antiguos campos sueltos cota_min / cota_max ya no existen: la cota es un dato por vía y el rango global se obtiene con project_data.rango_cotas_carril (o ctx.rango_cotas_carril en los scripts);
• D_vias: las distancias entre vías consecutivas, con el mismo patrón que los muros interiores M: siempre nº de vías - 1 valores, y la lista se reconstruye sola al cambiar el nº de vías (D_vias[i] es la distancia entre la vía i+1 y la vía i+2).

"datos_geotecnicos": {
  "talud_relleno": 0.25,
  "talud_h": 1.0,
  "peso_específico": 0.0,
  "peso_sumergido": 0.0,
  "ang_roz": 0.0,
  "prof_nf": 0.0,
  "vias": [
    {"ancho": 1.668, "cota_carril": 3.20,
     "tipo_carril": "UIC_60", "tipo_traviesa": "iberico_h_mono"},
    {"ancho": 1.668, "cota_carril": 3.20,
     "tipo_carril": "UIC_60", "tipo_traviesa": "iberico_h_mono"}
  ],
  "D_vias": [4.0]
}

La aplicación entera ya sabe manejarlo (se edita en "Datos del Proyecto", se guarda en el JSON y llega a los scripts de calculo/ como ctx.geotecnico("…") / ctx.numero_geotecnico("…") / ctx.datos_geotecnicos y, para las vías, ctx.vias / ctx.n_vias / ctx.anchos_vias / ctx.cotas_carril / ctx.rango_cotas_carril / ctx.via(i) / ctx.distancias_vias). Para añadir, quitar o renombrar un dato del terreno basta con tocar DEFAULT_DATOS_GEOTECNICOS y LABELS_DATOS_GEOTECNICOS (project_data.py): la ventana se dibuja recorriendo esas claves, así que no hay que tocar nada de la interfaz.

Los proyectos guardados antes de que existiera este apartado se completan solos al abrirlos (igual que se migran los antiguos LH_1..LH_4 / M1..M3), y save_project conserva los apartados que no gestiona (load_assignments), así que ninguna ventana pisa el trabajo de otra al guardar.

Limitaciones conocidas

• El armado de las secciones generadas automáticamente es fijo (B500 SD y recubrimiento 0,05 m, ver MATERIAL_ARMADO / RECUBRIMIENTO_ARMADO en project_data.py): no se puede elegir por proyecto todavía.

• La norma IAP (instrucción para puentes de carretera, distinta de la IAPF de ferrocarril) no está implementada: solo está disponible IAPF en el selector de norma. El código de combinations.py conserva la rama "IAP" intacta como referencia para un futuro mapeo, pero de momento no genera combinaciones.

• Los datos geotécnicos (huecos dummy, vías y distancias entre vías) se guardan y llegan a los scripts de cálculo, pero ningún cálculo los usa todavía, y las vías tampoco se dibujan en el modelo de SAP2000.

• Los huecos, retranqueos y vigas auxiliares (VA1, VA2, VA3) definidos en "Datos del Proyecto" se guardan como datos pero todavía no se modelan geométricamente: la geometría generada es la caja continua (sin huecos ni retranqueos).

• La carpeta calculo/ arranca solo con el script "Valor manual": de momento, cualquier carga (H1-H9 incluidas) se asigna introduciendo el valor ya calculado a mano (kN/m, kN/m² o kN según la distribución elegida). Las fórmulas normativas (peso propio, empuje de tierras, reparto UIC en hastiales H5.1-H5.4, arranque/frenado H6.1-H6.2...) se van añadiendo como scripts nuevos en esa carpeta, uno por archivo.

Estructura del código

Archivo / carpeta	Responsabilidad
Comb_acciones.py	punto de entrada (conecta con SAP2000 y abre la ventana principal).
project_data.py	modelo de datos del proyecto (geometría + terreno) y lectura/escritura del JSON.
sap_connection.py	conexión con la instancia abierta de SAP2000.
geometry.py	layout multi-celda (puro) y creación de las barras en SAP2000.
sections.py	material y secciones automáticas a partir de los Datos del Proyecto.
combinations.py	combinaciones de acciones según IAPF.
extraer_comb.py	extracción de resultados a Excel.
informe_h1.py	informe H1 (peso propio) en Word.
calculo/	scripts de cálculo de cargas (un archivo por tipo de cálculo). Ver calculo/README.md.
load_assignment.py	capa SAP2000 de la asignación de cargas (escribe los tramos en el modelo).
ui/	una ventana de Tkinter por archivo.