#!/usr/bin/perl
# lanzador: la etapa 2 de Simusol, sin la capa de Simusol. Se llamo
# corre-sceptre hasta el 19/10/2026 (el nombre viejo sigue, como enlace):
# paso a llamarse asi cuando dejo de correr solo SCEPTRE (pedido del autor:
# "el lanzador debiera incorporar a siru y spice").
#
#     lanzador caso.d                 corre SCEPTRE y deja caso.sim al lado
#     lanzador --motor siru caso.d    corre siru: deja caso.simul directo
#     lanzador --motor spice caso.cir corre ngspice: deja caso.simul
#     lanzador --motor maxima caso.M.dsa   resuelve ANALITICAMENTE con Maxima
#                                     el par M/DU: las condiciones iniciales
#                                     salen de los DATOS del DU. Deja
#                                     caso.analitica (la formula) y caso.simul
#     lanzador --motor maxima caso.d  lo mismo desde un .d
#     lanzador --motor siru caso.cir  un netlist de SPICE con siru, traducido
#                                     antes con cir2ds (con SCEPTRE no: lo que
#                                     escribe cir2ds es el dialecto de siru)
#     lanzador -n caso.d              dice lo que haria y no corre
#     lanzador -d caso.d              con traza
#
# Los motores (MOTORES.md): 'sceptre' (los dos SCEPTRE, el viejo y el nuevo,
# por el contrato de INVOCACION-SCEPTRE.md), 'siru' (Simul2, siru/bin/siru),
# 'spice' (ngspice) y 'maxima', que no simula: resuelve el sistema en forma
# CERRADA. Se elige con --motor o con MOTOR= en el entorno; sin nada, SCEPTRE.
# La entrada es el par M.dsa + DU.dsa --el modelo de hoy, y SIEMPRE separado
# en M y DU (pedido del autor, 04/11/2026)-- o un .d de Simusol mientras
# queden. Los .ds no entran mas: ya no existen (PLAN-SIN-DS.md, pedido del
# autor del 03/11/2026, "no hay motivo para que exista un .ds"). Un .d lo
# corren SCEPTRE, siru y maxima; para SPICE el netlist .cir lo escribe
# dat2cir desde el dato, de un .d o de un par .dsa (18/11/2026). El par
# M.dsa + DU.dsa entra por SCEPTRE, Siru, Maxima y Spice.
#
# maxima no sabe de circuitos: las ecuaciones son las de siru. El circuito lo
# pasa a ecuaciones d2datdinc --din, como siempre --con sus lazos y cortes--,
# y bin/din2mac lleva ese .din a un .mac con las condiciones iniciales de los
# estados. Por eso la respuesta es del mismo modelo y no de otro.
#
# Con llaves no hay UN sistema sino uno por configuracion (d2datdinc
# --llaves, el que divide por casos para Calcula), y la solucion se arma
# intervalo por intervalo: el horario de las llaves, cada intervalo con sus
# condiciones iniciales y el trasvase instantaneo de carga o de flujo al
# conmutar. La condicion de cada llave se evalua al comenzar cada paso de la
# malla, como en siru, asi que el instante de conmutacion es un punto de la
# malla. Ver con_llaves, abajo.
#
# Hace las cuatro cosas de la etapa 2 y nada mas:
#
#   1. prepara: ubica sceptre y sus bibliotecas (modellib.dat, usrlib.a),
#      las deja donde SCEPTRE las busca y verifica el funciones.for del
#      usuario si el .d lo necesita;
#   2. corre SCEPTRE sobre una copia sin la seccion PARAPLOT, en el
#      subdirectorio sceptre/, y trae las salidas;
#   3. interpreta lo que devolvio: el codigo de salida, **el .ls1 y el .ls2**
#      --los mensajes de error con su severidad, las variables no definidas,
#      la condicion de terminacion y los datos de cada corrida--, el .ls4 del
#      compilador y el .res;
#   4. informa que archivos quedaron.
#
# NO arma el .simul: eso es de nuevosimplot, que lo hace con este .sim mas
# el .paraplot (decision del autor, 13/10/2026; ver LEEME.md).
#
# Por que existe: lolisol_sceptre.pl hacia esto en 909 lineas apoyado en
# catorce modulos de Simusol, de los que no usaba ninguna funcion de la
# fisica del circuito: solo trazas, avisos y el manejo de archivos con la
# clasificacion en diez directorios. Aca la infraestructura es Infra.pm y
# los archivos quedan donde esta la entrada.
#
# Copyright (C) Diego Saravia <dsa@unsa.edu.ar>
# GPL version 3 o posterior.
use strict;
use warnings;
use File::Basename qw(basename dirname);
use File::Spec;
use Cwd qw(abs_path getcwd);
use Getopt::Long;
# Infra.pm, al lado en el arbol de fuentes (bin/../lib) o instalado en
# share/lanzador/lib (bin/../share/lanzador/lib): los dos relativos al
# prefijo, asi que no hay ninguna ruta fija. No va a /usr/share/perl5 porque
# el nombre es generico y hay otro Infra.pm en simusol y en nuevosimplot
# (ver INFRA.md); lo instalado lo dice lanzador.summa.
use FindBin qw($RealBin);
use lib $RealBin . '/../lib',
        $RealBin . '/../share/lanzador/lib';
use Infra;
use JSON::PP qw(decode_json encode_json);
use Encode qw(decode FB_CROAK);
use File::Temp qw(tempdir);
# El nombre del log de esta parte de la cadena. El modulo es el mismo que usa
# simusol --un solo Infra.pm-- y trae 'sim.log' por omision.
$Infra::EXTLOG = 'sceptre.log';

my ($ensayo, $ayuda, $motor_opt) = (0, 0, undef);
my $tipo_salida;
my ($puntos_opt, $paso_opt) = (undef, undef);
my $nombre_dia;
my $trabajo_dia;
my $directorio_inicial=getcwd();
END { chdir $directorio_inicial if defined $trabajo_dia; }
GetOptions('n|ensayo' => \$ensayo, 'd|debug' => \$Infra::debug,
           'h|help' => \$ayuda, 'motor=s' => \$motor_opt,
           'nombre=s' => \$nombre_dia,
           'salida=s' => \$tipo_salida, 'puntos=i' => \$puntos_opt, 'paso=s' => \$paso_opt) or $ayuda = 1;
if ($ayuda || @ARGV > 1 || (!@ARGV && -t STDIN)) {
    print <<'FIN';
Uso: lanzador [-n] [-d] [--motor MOTOR] [--puntos N|--paso P]
              [caso.dia|caso.M.dsa|caso.d|caso.cir|-]
Sin argumento o con -, lee un .dia por stdin. --nombre CASO fija su nombre.
Simusol traduce el .dia al par M.dsa y DU.dsa para todos los motores.
Stdout entrega PARAPLOT y TABLE; los mensajes se envían a stderr.
  -n        ensayo: dice lo que haria y no corre nada
  -d        traza
  --puntos  (motor maxima) cuantos puntos de la malla donde se evalua la
            formula; 300 intervalos por omision (301 puntos), o SIRU_PASO del DU
  --paso    (motor maxima) el paso de esa malla en lugar de --puntos, exacto
            si se escribe exacto (--paso 1/10). Es tambien el paso con que se
            evaluan las condiciones de las llaves, asi que con el paso de
            siru la conmutacion cae donde cae en siru
  --salida  numerica (predeterminada) o analitica (Maxima, .dat por stdout)
  --motor   prevalece sobre MOTOR = nombre en el deck. Sin ambos: siru.
            Nombres del deck: siru, siru-scipy, siru-sceptre, siru-spice,
            sceptresimusolnuevo, sceptrenovender, sceptresimusolviejo,
            spice, maxima. Sin seleccion: siru. siru-spice resuelve la
            topologia intervalo por intervalo y hace avanzar a ngspice
            mientras las llaves no cambien; siru-sceptre se reconoce pero
            espera su adaptador de intervalos.
            En PARAPLOT: maxima = formulas o maxima = tablas (solo Maxima).
            Alias historicos de linea de comandos:
            sceptre            el SCEPTRE que haya instalado (nuevo o viejo)
            sceptre-dinamico   el nuevo, el circuito como .so (bin/exec2 lo
                               carga; el par .so+datasave se reutiliza)
            sceptre-estatico   el nuevo enlazando un ejecutable por circuito
            sceptre-viejo      el viejo (sceptresimusol)
            siru, siru-scipy, spice (scipy es alias de siru-scipy)
            maxima             no simula: resuelve el sistema en forma cerrada
                               (Maxima/desolve) y evalua la formula
Corre el motor en un subdirectorio (sceptre/, siru/, spice/ o maxima/) sobre una copia
de la entrada y trae las salidas al directorio de la entrada:
  sceptre   caso.sim, el listado caso.log y caso.dirac. Habla con los dos
            SCEPTRE (INVOCACION-SCEPTRE.md): elige el que haya instalado, y se
            fuerza con SCEPTRE=/ruta (el guion 'sceptre' del viejo o el 'sc1'
            del nuevo) o con SCEPTRE_USAR=viejo|nuevo
  siru      caso.simul directo y caso.informe (siru/bin/siru; SIRU=/ruta)
  spice     caso.simul (de la salida .print de ngspice, con tabular2),
            caso.out y caso.err; solo con un .cir (NGSPICE=/ruta)
  maxima    caso.analitica (la solucion en forma cerrada), caso.simul (esa
            formula en la malla de la corrida), caso.mac y caso.din; con
            llaves, una configuracion por intervalo y caso.horario. Toma un
            par M.dsa + DU.dsa (con el DU al lado) o un .d (MAXIMA=/ruta)
Un .cir con siru se traduce antes con cir2ds (CIR2DS=/ruta); con sceptre no.
El log de esta parte, en caso.sceptre.log (ver INFRA.md).
FIN
    exit($ayuda ? 0 : 2);
}
my $documento_stdout;
{
    open $documento_stdout, '>&', \*STDOUT or die "dup stdout: $!\n";
    open STDOUT, '>&', \*STDERR or die "redirigir diagnosticos: $!\n";
}
if (!@ARGV || $ARGV[0] eq '-' || $ARGV[0] =~ /\.dia$/i) {
    ($ARGV[0],$trabajo_dia)=traducir_diagrama($ARGV[0],$nombre_dia,$motor_opt);
}
my $configuracion = leer_configuracion($ARGV[0]);
my $motor = lc($motor_opt // $configuracion->{motor} // 'siru');
my $motor_documental = $motor;
# El nombre heredado scipy designa el recorrido coordinado por Siru.
$motor='siru-scipy' if $motor eq 'scipy';
die "lanzador: MOTOR=$motor reconocido, pero su adaptador de intervalos con Siru aún no está implementado\n"
    if $motor eq 'siru-sceptre';
my $rutina_sceptre;
my $control_integra=($configuracion->{control}//{})->{INTEGRA};
my @selecciones_integracion;
push @selecciones_integracion,{value=>$control_integra->{value},maestra=>1}
    if $control_integra && !$control_integra->{implicito};
for my $r (@{$configuracion->{reruns}//[]}) {
    push @selecciones_integracion,{value=>$r->{INTEGRA},n=>$r->{n}}
        if exists $r->{INTEGRA};
}
if (@selecciones_integracion && $motor ne 'maxima') {
    my $clave=$motor;
    $clave='scipy' if $clave eq 'siru-scipy';
    $clave='spice' if $clave eq 'siru-spice';
    $clave='sceptre' if $clave =~ /^sceptre(?:-(?:nuevo|dinamico|estatico|viejo))?$/;
    require MetodosMotor;
    my $lib_siru=$RealBin.'/../../siru/lib';
    unshift @INC,$lib_siru if -d $lib_siru && !grep {$_ eq $lib_siru} @INC;
    for my $seleccion (@selecciones_integracion) {
        my $valores=$seleccion->{value};
        die "lanzador: INTEGRA requiere una lista no vacía\n" unless ref($valores) eq 'ARRAY' && @$valores;
        die "lanzador: MOTOR $motor admite una sola selección INTEGRA\n"
            if $seleccion->{maestra} && $motor ne 'siru' && @$valores!=1;
        die "lanzador: INTEGRA del RERUN requiere un número por corrida\n"
            if !$seleccion->{maestra} && @$valores != $seleccion->{n};
        for my $id (@$valores) {
            my $m=MetodosMotor->resolver($clave,$id);
            $rutina_sceptre=$m->{nombre} if $seleccion->{maestra} && $clave =~ /^sceptre/;
        }
    }
}

my %alias_motor = (sceptresimusolnuevo=>'sceptre-dinamico',
    sceptrenovender=>'sceptre-novender', sceptresimusolviejo=>'sceptre-viejo');
my $familia_sceptre = exists $alias_motor{$motor} ? $motor : '';
$motor = $alias_motor{$motor} // $motor;
if (!defined $tipo_salida && $motor eq 'maxima') {
    my %formas;
    for my $pp (@{$configuracion->{simplots} // []}) {
        for my $o (@{$pp->{pedido}{ordenes} // []}) {
            $formas{$o->{valor}}=1 if $o->{comando} eq 'maxima';
        }
    }
    die "lanzador: PARAPLOT pide formulas y tablas a la vez; separar las corridas\n" if keys(%formas)>1;
    $tipo_salida = exists $formas{formulas} ? 'analitica' : 'numerica';
}
$tipo_salida //= 'numerica';
# Los SCEPTRE son motores distintos para quien elige (pedido del autor,
# 19/10/2026): sceptre-viejo, sceptre-dinamico (el nuevo, el circuito como
# .so: INVOCACION-SCEPTRE.md 3 bis) y sceptre-estatico (el nuevo enlazando un
# ejecutable por circuito, como siempre); sceptre-nuevo es sceptre-dinamico.
# 'sceptre' a secas sigue siendo el que haya instalado. De la variante salen
# SCEPTRE_USAR (para buscar_sceptre) y el -estatico de sc1.
$motor =~ /^(sceptre(?:-(viejo|nuevo|dinamico|estatico|novender))?|siru|spice|maxima|siru-scipy|siru-spice)\z/
    or die "lanzador: motor '$motor' desconocido: sceptre, sceptre-viejo,"
         . " sceptre-dinamico, sceptre-estatico, siru, siru-scipy, siru-sceptre, siru-spice, spice o maxima\n";
$tipo_salida =~ /\A(?:numerica|analitica)\z/
    or die "lanzador: --salida numerica|analitica\n";
$tipo_salida eq 'analitica' && $motor ne 'maxima'
    and die "lanzador: la salida analitica requiere --motor maxima\n";
my $motor_pedido = $motor_documental;
my ($variante_sceptre) = $motor =~ /^sceptre-(.*)$/;
$variante_sceptre //= '';
my $sceptre_estatico = $variante_sceptre eq 'estatico' ? 1 : 0;
# La malla --donde se evalua la formula, y donde se evaluan las condiciones de
# las llaves-- es solo del motor maxima: los otros tienen su propio paso, que
# sale del uso.
defined $puntos_opt and defined $paso_opt
    and die "lanzador: --puntos y --paso son la misma cosa dicha de dos"
          . " maneras: elija una\n";
# siru-spice tambien los toma: ahi la malla es, como en siru, el paso con que
# se evaluan las condiciones de las llaves y el paso maximo de ngspice.
(defined $puntos_opt or defined $paso_opt) and $motor ne 'maxima' and $motor ne 'siru-spice'
    and die "lanzador: --puntos y --paso son de los motores maxima y siru-spice (la malla"
          . " donde se evalua la formula o la condicion); $motor_pedido toma su paso del uso\n";
if ($variante_sceptre) {
    $motor = 'sceptre';
    $ENV{SCEPTRE_USAR} = $variante_sceptre eq 'viejo' ? 'viejo' : 'nuevo';
}

my $entrada = $ARGV[0];
my $entrada_original = $entrada;   # antes de cualquier cambio de directorio o copia
# el directorio del .d original, ABSOLUTO y calculado ACA, antes del chdir al
# subdirectorio del motor: es donde va el par CASO.so + CASO.datasave (-sodir)
my $sodir = File::Spec->rel2abs(dirname($entrada_original));
# Lo que entra: un .dsa (el par M/DU), un .d mientras queden, o un netlist
# .cir. Los .ds NO entran: ya no existen (PLAN-SIN-DS.md).
$entrada =~ /\.(dsa|d|cir)\z/i
    or die "lanzador: se espera el par caso.M.dsa + caso.DU.dsa, un caso.d o un caso.cir, no $entrada\n";
my $ext_entrada = lc $1;
if ($ext_entrada eq 'dsa') {
    # Un .dsa va SIEMPRE separado en M y DU (pedido del autor, 04/11/2026):
    # se nombra el modelo, caso.M.dsa, y sus DATOS, USOS y RESULTADOS estan
    # en caso.DU.dsa al lado. Un .dsa entero no es una entrada de aca.
    $entrada =~ /\.M\.dsa\z/i
        or die "lanzador: un .dsa va siempre separado en M y DU:"
             . " nombre el modelo, caso.M.dsa, con su caso.DU.dsa al lado, no $entrada\n";

}

-f $entrada or die "lanzador: no existe $entrada\n";
unless (-r $entrada) {
    print " no puedo leer $entrada: revise los permisos\n";
    exit 8;
};
my $dir = dirname(abs_path($entrada));
my $base = basename($entrada, ".$ext_entrada");

# ---- 0. el .d que SCEPTRE puede leer
# El .ds que escribe Simusol lleva la seccion PARAPLOT adentro (el pedido de
# graficos), y SCEPTRE no la entiende: lee cada renglon como un control de
# corrida y los rechaza uno por uno con el mensaje 31, IMPROPER RUN CONTROL
# FORMAT, hasta abortar. Medido con tanque_fun el 13/10/2026. Asi que se
# corre sobre una copia sin esa seccion, en un subdirectorio, y al terminar
# se traen las salidas. La entrada no se toca, y en el subdirectorio queda
# exactamente lo que SCEPTRE leyo.
my $SUBDIR = 'sceptre';
sub filtrar_paraplot {
    my ($entrada, $salida) = @_;
    # sin die: un fallo aca se informa y sale con un estado propio, 8, en
    # lugar del numero arbitrario que deja el die de Perl (era 13, el errno)
    open my $in, '<', $entrada or do {
        avgrav_simple("no pude leer $entrada: $!"); return undef };
    open my $out, '>', $salida or do {
        avgrav_simple("no pude escribir $salida: $!"); return undef };
    my ($en_pp, $saltadas) = (0, 0);
    my ($en_control,$inyectada)=(0,0);
    while (my $l = <$in>) {
        if ($rutina_sceptre && $l =~ /^\s*RUN[ _]CONTROLS\s*$/i) {
            $en_control=1;print {$out} $l, "INTEGRATION ROUTINE = $rutina_sceptre\n";$inyectada=1;next;
        }
        if ($rutina_sceptre && $en_control && $l =~ /^\s*(?:INTEGRA|INTEGRATION[ _]ROUTINE)\s*=/i) {next}
        $en_control=0 if $en_control && $l =~ /^\s*(?:PARAPLOT|END|OUTPUTS|INITIAL CONDITIONS)\b/i;
        if ($l =~ /^\s*MOTOR\s*=/) { next }
        if ($l =~ /^\s*PARAPLOT(?:\s+\S+)?\s*$/i) { $en_pp = 1; $saltadas++; next }
        if ($en_pp) {
            # la seccion termina en el END, que si va para SCEPTRE
            if ($l =~ /^\s*END\s*$/i) { $en_pp = 0; print {$out} $l; next }
            $saltadas++;
            next;
        }
        print {$out} $l;
    }
    close $in; close $out;
    die "lanzador: falta RUN CONTROLS para seleccionar $rutina_sceptre\n" if $rutina_sceptre && !$inyectada;
    return $saltadas;
}

# ---- 1. preparar
my ($sceptre, $tipo_sceptre) = $motor eq 'sceptre' ? buscar_sceptre() : ('', '');
my $libdir = $sceptre ? File::Spec->catdir(dirname(dirname($sceptre)), 'lib') : '';
comfin("com preparar");
if ($motor eq 'sceptre' and not $sceptre) {
    print "lanzador: SCEPTRE no esta instalado (no esta en el PATH).\n";
    print "   Las fuentes estan en siru/sceptre-inenco*, sin compilar.\n";
    exit 3;
}
cambiar_directorio($dir) or exit 4;
# El log de esta parte de la cadena: .sceptre.log (ver nuestro LEEME.md y
# simusol/LOGS.md). Lo que SCEPTRE escriba en sus .ls1 y .ls2 es suyo:
# eso no se toca, es un Fortran de 1977.
# En estas rutas stdout es el documento; todo mensaje, incluso el de
# procesos hijos, va a stderr. El descriptor original recibe solo resultados.
my $log = abrir_log($base);
mensajear(" log: $log") if $log;
# un .cir para SCEPTRE o siru: primero el .ds, con cir2ds, en el subdirectorio
# del motor; de ahi en adelante la entrada es ese .ds
my $fuente = "$base.$ext_entrada";
if ($motor eq 'siru' || $motor eq 'siru-scipy' || $motor eq 'spice' || $motor eq 'maxima'
    || $motor eq 'siru-spice') {
    my $estado = ($motor eq 'siru' || $motor eq 'siru-scipy') ? motor_siru($base, $ext_entrada)
                 : $motor eq 'spice' ? motor_spice($base, $ext_entrada)
                 : $motor eq 'siru-spice' ? motor_siru_spice($base, $ext_entrada)
                                  : motor_maxima($base, $ext_entrada);
    if (!$estado && !$ensayo) {
        my $ok = eval {
            chdir $dir or die "volver a $dir: $!\n";
            emitir_documento_numerico($documento_stdout, $base, $ext_entrada);
            1;
        };
        unless ($ok) { warn "lanzador: $@"; $estado = 7 }
    }
    exit $estado;
}
mensajear(" motor: $motor_pedido, $sceptre (el $tipo_sceptre)");
if ($variante_sceptre and $variante_sceptre ne 'viejo' and $tipo_sceptre ne 'nuevo') {
    avgrav_simple("--motor $motor_pedido pide el SCEPTRE nuevo y lo instalado es el viejo ($sceptre)");
    exit 3;
}
if ($variante_sceptre eq 'viejo' and $tipo_sceptre ne 'viejo') {
    avgrav_simple("--motor sceptre-viejo y lo que hay es el nuevo ($sceptre)");
    exit 3;
}
if ($ext_entrada eq 'cir') {
    # Medido el 19/10/2026 con diodo-rectificador.cir: el .ds que escribe
    # cir2ds es el dialecto de siru (include de la biblioteca, RB/CB/EB con
    # ecuaciones) y SCEPTRE lo rechaza renglon por renglon (22 mensajes). Un
    # netlist se corre con spice o con siru; para SCEPTRE haria falta otra
    # traduccion, que no esta.
    mensajear(" un .cir no se puede correr con SCEPTRE: cir2ds traduce al .ds de siru,"
            . " que SCEPTRE no lee. Use --motor spice o --motor siru");
    cerrar_log(); exit 3;
}

# el .d filtrado, en su subdirectorio
-d $SUBDIR or mkdir $SUBDIR or avgrav_simple("no pude crear $SUBDIR/: $!");
my $base_entrada = $base;
my $deck_sceptre = $fuente;
if ($ext_entrada eq 'dsa') {
    $base =~ s/\.M$//i;
    for my $archivo ($fuente, "$base.DU.dsa") {
        -s $archivo or die "lanzador: falta $archivo\n";
        require File::Copy;
        File::Copy::copy($archivo,"$SUBDIR/$archivo") or die "$archivo: $!\n";
    }
} else {
    defined filtrar_paraplot($fuente, "$SUBDIR/$base.d")
        or die "lanzador: no pude preparar $fuente\n";
}
for my $acompana (qw(extensiones.txt funciones.for modellib.dat)) {
    my $donde = $acompana;
    # Un proyecto de Simusol deja el .d en tmps/ y el funciones.for del
    # usuario en la raiz, al lado del .dia: si no esta junto al .d, se lo
    # busca un nivel arriba (con_FOR del corpus; 14/10/2026).
    if (not -f $donde) {
        my $arriba = File::Spec->catfile('..', $acompana);
        -f $arriba or next;
        $donde = $arriba;
        mensajear(" $acompana lo tome del directorio de arriba");
    };
    unlink "$SUBDIR/$acompana";
    link($donde, "$SUBDIR/$acompana")
      or symlink(File::Spec->rel2abs($donde), "$SUBDIR/$acompana");
    al_log(" tambien va $acompana (de $donde)");
};
cambiar_directorio($SUBDIR) or exit 4;

# SCEPTRE busca modellib.dat en el directorio actual y usrlib.a en su lib.
my @faltan;
for my $b (qw(modellib.dat usrlib.a)) {
    my $origen = File::Spec->catfile($libdir, $b);
    if (-f $origen) {
        if ($b eq 'modellib.dat' && !-e $b) {
            symlink($origen, $b) or avgrav_simple("no pude enlazar $b: $!");
            mensajear(" enlazado $b -> $origen");
        }
    } else { push @faltan, $origen }
}
avgrav_simple("faltan las bibliotecas: @faltan") if @faltan and $tipo_sceptre eq 'viejo';

# El Fortran del usuario: el .d lo pide por nombre de funcion, y SCEPTRE lo
# compila. Solo se avisa si el .d lo necesita y no esta.
if (my @fun = $ext_entrada eq 'd' ? funciones_del_d($deck_sceptre) : ()) {
    if (-f 'funciones.for' or -f File::Spec->catfile('..','funciones.for')) {
        mensajear(" funciones del usuario: @fun (en funciones.for)")
    }
    else { avgrav_simple("el .d usa @fun y no hay funciones.for") }
}

if ($ensayo) { mensajear(" ensayo: no se corre SCEPTRE"); exit 0 }

# ---- 2. correr
#
# La salida del proceso se captura ademas de mostrarse, porque **hay cortes
# que no dejan listado**: con 206 (opciones mal), 207 (nombre que no sirve) y
# 208 (no pudo abrir) no queda ni el .ls1, y el unico lugar donde esta el
# motivo es esto (comprobado, 13/10/2026).
comfin("com correr");
# Las dos fases escriben su listado en UN archivo, CASO.log, en append y en
# orden, porque las dos leen SCEPTRE_LOG (seccion 3 del contrato); con el
# viejo de antes del 18/10/2026 la variable no hace nada y quedan .ls1/.ls2,
# que tambien se leen. El </dev/null es porque si el deck pide algo
# interactivo el programa se queda esperando (seccion 1).
my $LOG_SCEPTRE = "$base.log";
unlink $LOG_SCEPTRE;
local $ENV{SCEPTRE_LOG} = $LOG_SCEPTRE;
# En modo dinamico el par CASO.so + CASO.datasave va JUNTO AL .d ORIGINAL
# (decision del autor): el lanzador corre sobre una copia en sceptre/, que se
# rehace en cada corrida, asi que sin -sodir el par se perderia y nunca se
# reutilizaria.
my $arg = $familia_sceptre eq 'sceptrenovender' ? $deck_sceptre
        : $tipo_sceptre eq 'nuevo'
        ? ($sceptre_estatico ? "-estatico $deck_sceptre" : "-sodir $sodir $deck_sceptre")
        : ($ext_entrada eq 'dsa' ? $deck_sceptre : $base);
mensajear(" corriendo: $sceptre $arg  (SCEPTRE_LOG=$LOG_SCEPTRE)");
my @dijo_al_correr;
my $estado = -1;
if (open my $ph, '-|', "$sceptre $arg 2>&1 </dev/null") {
    while (my $l = <$ph>) {
        print $l;                      # como siempre, en vivo
        chomp $l;
        push @dijo_al_correr, $l if $l =~ /\S/;
    };
    close $ph;
    $estado = $?;
};
my $codigo = $estado == -1 ? -1 : $estado >> 8;
al_log(" --- lo que dijo al correr ---");
al_log("   $_") for @dijo_al_correr;
comfin("fin correr $codigo");

# ---- 3. interpretar
if ($estado == -1)   { avgrav_simple("no pude ejecutar $sceptre: $!"); exit 5 }
if ($estado & 127)   { avgrav_simple("SCEPTRE terminado por la senal ".($estado & 127)); exit 6 }
# Que significa cada codigo de salida. La tabla que manda es
# sceptre2novender/pasos/SALIDAS --un numero por punto de salida, 51 mas los
# 106-109 del viejo-- y se lee de ahi (leer_tabla_salidas); lo de aca son las
# frases del autor en terminos del circuito, que es lo que el usuario puede
# revisar, para los codigos que las tienen. Un codigo sin frase propia toma la
# descripcion de la tabla. Hasta el 18/10/2026 eran nueve codigos y el 1 y el
# 10 los ponia el guion del viejo; hoy el guion sale con 109.
my %QUE_CODIGO = (
    6   => 'no pudo abrir un archivo (fase 2)',
    7   => 'no pudo escribir la base de resultados (fase 2)',
    8   => 'no pudo cerrar un archivo (fase 2)',
    9   => 'no pudo leer la base de resultados (fase 2)',
    101 => 'abortó por errores: reviso todo el .d y la severidad paso de 1',
    102 => 'descarto la simulacion (SIMULATION HAS BEEN DELETED); puede ser'
         . ' por error, o porque se pidio solo la preparacion',
    103 => 'falto modellib.dat pero la corrida siguio con uno vacio (aviso)',
    104 => 'el circuito es contradictorio o imposible: un lazo de fuentes de'
         . ' tension, un elemento en corto, un cut set sin solucion',
    105 => 'falta un archivo que el .d pide (modellib.dat)',
    106 => 'las opciones de la linea de ordenes de sceptre1 estan mal',
    107 => 'el nombre del archivo de entrada no sirve',
    108 => 'no pudo abrir un archivo (fase 1)',
    109 => 'el guion corto: no se genero el programa Fortran, no compilo, o'
         . ' no quedo el ejecutable',
    110 => 'abortó en el acto por un error de severidad 4',
    # las mismas causas que el rango 120, en otros puntos (111-115)
    111 => 'el sistema de ecuaciones no tiene solucion unica (matriz'
         . ' singular, en INVERS)',
    112 => 'la matriz de autovectores es singular (INVRT)',
    113 => 'la matriz XMR es singular (XMRINV)',
    114 => 'el Newton-Raphson no convergio en las pasadas permitidas (INVERS)',
    115 => 'las derivadas piden un paso mas chico que el minimo (EXPO)',
    # Los fallos de la simulacion, cada uno con su codigo desde
    # sceptresimusol r3402 (antes todos terminaban con 0 y lo unico que lo
    # decia era un renglon del .ls2). El texto va en terminos del circuito,
    # que es lo que el usuario puede revisar.
    120 => 'el sistema de ecuaciones no tiene solucion unica (matriz'
         . ' singular): revise nodos sueltos, lazos sin resistencia o'
         . ' elementos repetidos',
    121 => 'el Newton-Raphson no convergio en las pasadas permitidas: el'
         . ' circuito tiene una no linealidad muy brusca, o faltan'
         . ' condiciones iniciales razonables',
    122 => 'el paso minimo no alcanza para las condiciones iniciales: hay'
         . ' constantes de tiempo mucho mas chicas que el paso',
    123 => 'se agoto el limite de pasadas de integracion sin llegar al'
         . ' estado estacionario',
    124 => 'las derivadas piden un paso mas chico que el minimo: baje'
         . ' MINIMUM STEP SIZE o revise los valores de los elementos',
    125 => 'el circuito es inestable: hay un autovalor con parte real'
         . ' positiva',
    126 => 'la integracion IMPLICIT se cancelo: el circuito no tiene'
         . ' elementos de clase 3 o 4 ni derivadas DP',
    127 => 'fallaron las condiciones iniciales del adjunto (analisis de'
         . ' sensibilidad)',
    128 => 'una convolucion esta mal llamada: revise la descripcion de la'
         . ' funcion',
    # los de antes del 18/10/2026, por si corre un sceptresimusol viejo
    206 => 'las opciones de la linea de comandos estan mal',
    207 => 'el nombre del archivo de entrada no sirve',
    208 => 'no pudo abrir un archivo (fase 1)',
);
my %TABLA = leer_tabla_salidas();
# la familia de cada codigo, para agrupar lo que es la misma causa en puntos
# distintos (pasos/SALIDAS, 'las causas que tienen mas de un numero')
my %FAMILIA = (
    (map { $_ => 'el sistema es singular' } 120, 111, 112, 113),
    (map { $_ => 'el Newton agoto sus pasadas' } 121, 114),
    (map { $_ => 'las derivadas piden un paso menor' } 124, 115),
    (map { $_ => 'una tabla se desbordo' } 10 .. 15),
    (map { $_ => 'no se encontro algo del deck' } 40 .. 49),
    (map { $_ => 'un estado que no sabe manejar' } 70 .. 76),
    (map { $_ => 'un error interno de la fase 2' } 77 .. 82),
);
sub que_codigo {
    my ($c) = @_;
    return undef unless defined $c and $c;
    return $QUE_CODIGO{$c} if defined $QUE_CODIGO{$c};
    return "$TABLA{$c}{rutina}: $TABLA{$c}{que}" if $TABLA{$c};
    return undef;
}
# Dos casos, y nada mas (modelo del autor, 13/10/2026): **SCEPTRE se detuvo
# o termino**. Y una advertencia que vale para el segundo: terminar no
# significa que la simulacion ande.
#
# Hasta sceptresimusol 1.0 la fase 2 **solo tenia stop 0**: una matriz
# singular, un Newton que no converge o un paso minimo que no alcanza
# terminaban con 0 y lo unico que lo decia era un renglon del .ls2. Desde
# r3402 cada uno tiene su codigo (120 a 128) y el guion lo devuelve, asi que
# el estado alcanza para saber que paso. Los listados se siguen leyendo en
# los dos casos: con un SCEPTRE anterior el estado todavia es 0, y el .ls2
# da los detalles que el codigo no tiene.
# El nuevo deja el .sim con otro nombre, .simnativo; para lo que sigue en la
# cadena (sim2simul) es el .sim (seccion 7, paso 6: renombrar lo que quedo)
if (-s "$base.simnativo" and not -s "$base.sim") {
    link("$base.simnativo", "$base.sim") or do {
        require File::Copy; File::Copy::copy("$base.simnativo", "$base.sim") };
    al_log(" el .sim es el .simnativo del nuevo");
}
# El listado: si hay CASO.log (SCEPTRE_LOG), las dos fases estan ahi, una
# atras de la otra, y se parte donde empieza la fase 2; si no, .ls1 y .ls2.
my ($ls1, $ls2) = partir_log($LOG_SCEPTRE);
$ls1 //= (-f "$base.ls1" ? "$base.ls1" : undef);
$ls2 //= (-f "$base.ls2" ? "$base.ls2" : undef);
my ($hay_ls1, $hay_ls2) = (defined $ls1, defined $ls2);
my $nombre_ls1 = ref $ls1 ? "$LOG_SCEPTRE (fase 1)" : ($ls1 // "$base.ls1");
my $nombre_ls2 = ref $ls2 ? "$LOG_SCEPTRE (fase 2)" : ($ls2 // "$base.ls2");
# Los renglones 'SCEPTRE: SALIDA | cod | hora | archivo:linea | RUTINA |
# mensaje' que las dos fases escriben antes de cada salida distinta de 0
# (seccion 5 del contrato). Pueden ser varios --un fallo que anota y sigue--
# y el que vale es el de codigo mas alto. Con ellos y el codigo alcanza para
# saber que paso, sin interpretar el resto del listado; lo que sigue mas
# abajo se sigue leyendo porque da la informacion extra (pedido del autor) y
# porque un SCEPTRE anterior no los escribe.
my @salidas = renglones_salida(\@dijo_al_correr, $LOG_SCEPTRE, "$base.ls0", "$base.ls1", "$base.ls2");
my ($salida) = sort { $b->{codigo} <=> $a->{codigo} } @salidas;
# el codigo que cuenta: el del renglon si lo hay (el lanzador del nuevo, sc1,
# todavia devuelve 1 por cualquier fallo de la fase 1), si no el del proceso
my $codigo_proceso = $codigo;
$codigo = $salida->{codigo} if $salida;
if ($salida) {
    mensajear(" SCEPTRE: SALIDA | $salida->{codigo} | $salida->{donde} | $salida->{rutina} | $salida->{que}");
    al_log("   (y $_->{codigo} en $_->{rutina}: $_->{que})") for grep { $_ != $salida } @salidas;
    mensajear(" (el proceso devolvio $codigo_proceso, el renglon dice $codigo)")
        if $codigo_proceso != $codigo;
}
# el 103 es un AVISO --falto modellib.dat y la corrida siguio entera--, no un
# fallo: se dice, y para todo lo demas la corrida vale (contrato, seccion 4)
my $aviso_modellib = ($codigo == 103);
$codigo = 0 if $aviso_modellib;
my $que_cod = que_codigo($codigo);
# lo que se va juntando de las tres fuentes para el diagnostico final
my ($nerr, $peor_error, $simulo, $termino, $condicion, $problema,
    $nocompilo, $avisos) = (0, undef, 0, undef, undef, undef, 0, 0);
my ($nocompilo_texto, $hallazgos_ls1, $errores_ls1) = ('', [], []);
if ($codigo) {
    my $que = $que_cod;
    mensajear(" SCEPTRE SE DETUVO con $codigo" . (defined $que ? ": $que" : ''));
    if ($hay_ls1 or $hay_ls2) {
        mensajear(" dejo " . join(' y ', ($hay_ls1 ? $nombre_ls1 : ()),
                                         ($hay_ls2 ? $nombre_ls2 : ())));
    } else {
        mensajear(" NO dejo listado: no hay $LOG_SCEPTRE, $base.ls1 ni $base.ls2,");
        mensajear(" asi que lo unico que se sabe es lo que dijo al correr");
    };
} else {
    mensajear(" SCEPTRE TERMINO (estado 0). Eso no garantiza que la"
            . " simulacion ande: se revisan los listados");
};

# ---- los listados, que es donde SCEPTRE cuenta de verdad lo que paso
my $peor = 0;
if ($hay_ls1) {
    my ($nivel, $hallazgos) = revisar_ls1($ls1, $deck_sceptre);
    $peor = $nivel;
    my @errores = grep { $_->{tipo} eq 'error' } @$hallazgos;
    $nerr = scalar @errores;
    ($hallazgos_ls1, $errores_ls1) = ($hallazgos, \@errores);
    for my $e (@errores) {
        $peor_error = $e if !$peor_error or $e->{nivel} > $peor_error->{nivel};
    };
    $avisos = grep { $_->{tipo} eq 'aviso' } @$hallazgos;
    if (@errores) {
        mensajear(sprintf " SCEPTRE rechazo %d cosa%s del %s.d:",
                  scalar @errores, (@errores == 1 ? '' : 's'), $base);
        my %vistos;
        for my $e (@errores) {
            my $clave = "$e->{kode} $e->{texto}";
            next if $vistos{$clave}++;           # el mismo error se repite
            mensajear(sprintf "   [%s] %s   (en %s)",
                      $e->{kode}, $e->{texto}, $e->{rutina});
        };
        my $cuantos = keys %vistos;
        al_log(sprintf " %d mensajes de error, %d distintos, severidad mas alta %d",
               scalar @errores, $cuantos, $nivel);
        for my $e (@errores) {
            al_log(" error $e->{kode} nivel $e->{nivel} en $e->{rutina}: $e->{texto}"
                   . " [$e->{severidad}]");
        };
    };
    for my $h (@$hallazgos) {
        next if $h->{tipo} eq 'error';
        if ($h->{tipo} eq 'nodefinida') {
            mensajear(" variable o funcion no definida para SCEPTRE:");
            mensajear("   $h->{texto}");
        } elsif ($h->{tipo} eq 'aviso') {
            mensajear(" aviso de SCEPTRE: $h->{texto}");
        } elsif ($h->{tipo} eq 'dice') {
            # al log siempre; a la pantalla solo si la corrida tuvo
            # problemas, porque en una corrida buena el listado trae ademas
            # las tablas de resultados y los encabezados de cada pagina
            if (@errores or $codigo or $nivel >= 2) {
                mensajear(" SCEPTRE dice: $h->{texto}");
            } else {
                al_log(" SCEPTRE dice: $h->{texto}");
            };
        } elsif ($h->{tipo} eq 'noentro') {
            mensajear(" $h->{texto}") if @errores or $codigo;
            al_log(" $h->{texto}");
        } else {
            al_log(" $h->{texto}");
        };
    };
};

# Si no dejo listado, lo que dijo al correr es la unica fuente
if ($codigo and not ($hay_ls1 or $hay_ls2)) {
    mensajear(" dijo:");
    mensajear("   $_") for grep { /\S/ } @dijo_al_correr;
};

# lo del compilador, que no es SCEPTRE
if (my $probs = revisar_compilacion($base)) {
    @$probs and $nocompilo = scalar @$probs;
    @$probs and $nocompilo_texto = join ' ', map { $_->{texto} } @$probs;
    if (@$probs) {
        mensajear(" el programa Fortran que SCEPTRE genero no se pudo compilar o enlazar:");
        for my $p (@$probs) { mensajear("   [$p->{ext}] $p->{texto}") };
    };
};

# y la corrida misma
if ($hay_ls2) {
    my $corridas = revisar_ls2($ls2, $deck_sceptre);
    for my $n (0 .. $#$corridas) {
        my $c = $corridas->[$n] or next;
        # hubo simulacion si el .ls2 trae al menos una corrida con datos
        $simulo = 1 if defined $c->{integrador} or defined $c->{termino};
        $termino = $c->{termino} if defined $c->{termino};
        $condicion = $c->{condicion} if defined $c->{condicion};
        $problema = $c->{problema} if defined $c->{problema};
        my $cual = @$corridas > 1 ? " (corrida $n)" : '';
        mensajear(" termino$cual: $c->{termino}") if $c->{termino};
        mensajear("   condicion: $c->{condicion}") if $c->{condicion};
        # Los datos de la corrida van **siempre** por pantalla, terminara bien
        # o mal: son la informacion extra del .ls2 (pedido del autor,
        # 13/10/2026: 'en ambos casos dar info extra del ls1 o 2'). Antes
        # salian solo al log.
        my $resumen = sprintf "   integrador %s, llego a %s, %s pasos, %s pasadas%s",
               ($c->{integrador} // '?'), ($c->{tiempo} // '?'),
               ($c->{pasos} // '?'), ($c->{pasadas} // '?'),
               (defined $c->{ultimopaso} ? ", ultimo paso $c->{ultimopaso}" : '');
        mensajear($resumen);
        if ($c->{problema}) {
            mensajear(" problema en la integracion: $c->{problema}");
            my $texto_consejo = consejo($c->{problema});
            mensajear($texto_consejo) if $texto_consejo;
            $peor < 2 and $peor = 2;
        };
        # y lo demas que SCEPTRE dijo de esta corrida, sin filtrar por una
        # lista: si habla, se muestra
        for my $d (@{$c->{dice} // []}) {
            # lo mismo: al log siempre, a la pantalla si hay de que hablar
            my $grave = $d =~ /SINGULAR|PASS LIMIT|STEP SIZE|FAILURE|IMPROPERLY|EXCEEDED|POSITIVE REAL PART|ERROR|ABORT/i;
            if ($grave or $peor >= 2 or $codigo) {
                mensajear(" SCEPTRE dice$cual: $d");
            } else {
                al_log(" SCEPTRE dice$cual: $d");
            };
            my $texto_consejo = consejo($d);
            mensajear($texto_consejo) if $texto_consejo;
            # los que anuncian que no pudo resolver cuentan como problema
            $peor < 2 and $d =~ /SINGULAR|PASS LIMIT|STEP SIZE|FAILURE|IMPROPERLY|EXCEEDED|POSITIVE REAL PART/i
                and $peor = 2;
        };
    };
};

# Si no hay listados, tambien hay que decirlo: en los dos casos la
# informacion extra sale de ahi, y su ausencia es informacion.
unless ($hay_ls1) { mensajear(" (no hay listado de la fase 1: nada que contar de la lectura del circuito)") };
unless ($hay_ls2) { mensajear(" (no hay listado de la fase 2: no hubo simulacion, o no llego a escribirlo)") };

informar_res("$base.res") if -f "$base.res";

# ---- 4. informar
# las salidas vuelven al directorio de la entrada, que es donde las espera
# quien sigue en la cadena (sim2simul, y el que mira los listados)
my @traer = grep { -f } map { "$base.$_" } qw(sim res log ls1 ls2 ls0 ls4 ls5 dirac lso simnativo compila);
for my $f (@traer) {
    unlink "../$f";
    rename($f, "../$f") or avgrav_simple("no pude mover $f: $!");
};
cambiar_directorio('..');
my @quedaron = grep { -f } map { "$base.$_" } qw(sim res log ls1 ls2 dirac lso);
if (open my $fh, '<', "$base.res") {
    al_log(" --- $base.res completo ---");
    while (my $l = <$fh>) { chomp $l; al_log($l) };
    close $fh;
};
if (@quedaron) { mensajear(" quedaron: @quedaron") }
else { avgrav_simple("SCEPTRE no dejo ningun archivo de salida") }
# ---- el diagnostico: por que termino, cruzando el codigo con los listados
#
# Pedido del autor (13/10/2026): «el programa debe informar por que termino
# SCEPTRE basado en su codigo y lo que hay en el ls, discriminando lo mas
# posible». Ninguna de las dos fuentes alcanza sola: el codigo dice que
# fallo pero no que cosa, y el listado dice que cosa pero a veces no existe
# --y la fase 2 sale 0 aunque la simulacion falle--.
my $puntos = '';
if (-f "$base.sim" and open my $fh, '<', "$base.sim") {
    while (my $l = <$fh>) {
        $l =~ /^#no\. of solution points:\s*(\d+)/ and $puntos = $1;
    };
    close $fh;
};
# Las frases son las que dicto el autor, caso por caso (13/10/2026).
my @porque;
# que dice el .ls1 que no sea uno de los 108 mensajes numerados: los avisos
# de la red (lazos de fuentes, nodos sueltos) salen asi, sin numero
my @avisos_red = grep { /SOURCE LOOP|CURRENT SOURCE|IS NOT CONNECTED|NO PATH/i }
                 map { $_->{texto} // '' } @{$hallazgos_ls1 || []};
# el texto de los mensajes numerados, para distinguir entre sintaxis y
# funciones que el simulador no implementa
my $no_soportado = '';
my $sintaxis = 0;
for my $e (@{$errores_ls1 || []}) {
    if ($e->{texto} =~ /NOT SUPPORTED|NOT CODED YET/i) { $no_soportado = $e->{texto} }
    else { $sintaxis++ };
};

# Con el renglon SCEPTRE: SALIDA el codigo dice que paso sin leer el resto;
# el texto del listado sigue afinando la frase donde puede (sintaxis contra
# 'no soportado', el lazo que se nombra, la funcion que falta).
my $sc = $salida ? $salida->{codigo} : 0;
if ($nocompilo) {
    # el enlazador no encontro una funcion del usuario
    my ($cual) = $nocompilo_texto =~ /undefined reference to .(\w+?)_?.|referencia a .(\w+?)_?. sin definir/;
    $cual //= $2 if defined $2;
    push @porque, "funcion declarada no existente"
                . (defined $cual ? ": $cual" : '')
                . " (falta funciones.for, o la funcion no esta ahi)";
} elsif ($sc >= 111 and $sc <= 128) {
    push @porque, "Fallo la integracion: $salida->{que} ($salida->{rutina}"
                . (defined $FAMILIA{$sc} ? ", $FAMILIA{$sc}" : '') . ")";
} elsif ($sc == 104) {
    my $cual = @avisos_red ? $avisos_red[0] : $salida->{que}; $cual =~ s/^\s+|\s+$//g;
    push @porque, "circuito contradictorio: $cual";
    $cual =~ /VOLTAGE SOURCE LOOP/i and $porque[-1] .= " (un lazo de fuentes de"
        . " tension de distinto valor no tiene solucion)";
} elsif ($sc == 105) {
    push @porque, "Falta modellib.dat";
} elsif ($sc >= 106 and $sc <= 109) {
    push @porque, $salida->{que};
} elsif ($sc >= 6 and $sc <= 99) {
    push @porque, "error interno de SCEPTRE, $sc ($salida->{rutina}: $salida->{que}"
                . (defined $FAMILIA{$sc} ? "; $FAMILIA{$sc}" : '') . ")";
} elsif ($no_soportado) {
    if ($no_soportado =~ /CONVOLUTION/i) {
        push @porque, "convolucion no soportada";
    } elsif ($no_soportado =~ /RE-OUTPUT/i) {
        push @porque, "re-output no soportado";
    } else {
        (my $q = $no_soportado) =~ s/\s+IS NOT.*//i; $q =~ s/\s+$//;
        push @porque, "\L$q\E no soportado por esta version de SCEPTRE";
    };
} elsif (@avisos_red) {
    my $cual = $avisos_red[0]; $cual =~ s/^\s+|\s+$//g;
    push @porque, "circuito contradictorio: $cual";
    $cual =~ /VOLTAGE SOURCE LOOP/i and $porque[-1] .= " (un lazo de fuentes de"
        . " tension de distinto valor no tiene solucion)";
} elsif ($sintaxis) {
    my $peor_txt = $peor_error ? " el mas grave, [$peor_error->{kode}]"
                   . " $peor_error->{texto}" : '';
    push @porque, "mala sintaxis del .d: $sintaxis mensaje"
                . ($sintaxis == 1 ? '' : 's') . " en el listado;$peor_txt";
} elsif ($sc == 101 or $sc == 110) {
    push @porque, "mala sintaxis del .d: $salida->{que} ($salida->{rutina}; ver $nombre_ls1)";
} elsif ($problema) {
    push @porque, "Fallo la integracion: $problema";
} elsif ($codigo and not ($hay_ls1 or $hay_ls2)) {
    # corto antes de escribir un listado: el motivo esta en lo que dijo, y
    # casi siempre es un archivo que no pudo abrir
    my @fallas = grep { /could not be opened|no es un archivo/i } @dijo_al_correr;
    # el modellib.dat es el que mas falta, y se nombra aunque haya otros
    my ($modellib) = grep { /modellib\.dat/i } @fallas;
    my ($falta) = @fallas;
    if (defined $modellib) {
        push @porque, "Falta modellib.dat";
    } elsif (defined $falta and $falta =~ m{([\w./-]+\.\w+)}) {
        push @porque, "no pudo abrir $1";
    } else {
        push @porque, "SCEPTRE corto antes de escribir un listado (codigo $codigo"
                    . (defined $que_cod ? ": $que_cod" : '') . ")";
    };
} elsif ($codigo == 102 and not $nerr) {
    push @porque, "sceptre preparo y no simulo porque no se le pidio";
} elsif (($codigo == 6 or $codigo == 8) and $hay_ls2) {
    push @porque, "Fallo un archivo en la fase 2 (codigo $codigo:"
                . " $que_cod): los resultados pueden estar incompletos";
} elsif ($simulo) {
    if (defined $condicion) {
        push @porque, "Termino la simulacion por un terminate: $condicion";
    } elsif (defined $termino and $termino =~ /STOP TIME EXCEEDED/i) {
        push @porque, "Termino la simulacion";
    } else {
        push @porque, "Termino la simulacion, por: "
                    . (defined $termino ? $termino : 'sin condicion declarada');
    };
    if ($puntos ne '') {
        $porque[-1] .= " ($puntos puntos)";
    } elsif (not -f "$base.sim") {
        $porque[-1] .= ", pero no dejo .sim: no hay resultados que leer";
    };
} elsif (not $codigo) {
    push @porque, "sceptre preparo y no simulo porque no se le pidio"
                . " (no hay listado de la fase 2)";
} else {
    push @porque, "no simulo, codigo $codigo"
                . (defined $que_cod ? ": $que_cod" : '');
};
$avisos and push @porque, "con $avisos aviso" . ($avisos == 1 ? '' : 's')
                        . " de SCEPTRE en el listado de la fase 1";
$aviso_modellib and push @porque, "aviso: falto modellib.dat y la corrida siguio con uno vacio (103)";
mensajear(" POR QUE TERMINO: " . join(', ', @porque));

# El estado propio: si SCEPTRE escribio errores en su listado, la corrida no
# sirve aunque el proceso haya terminado con 0 --que es lo que pasa con 102
# de los 108 mensajes--. Va antes del 7, porque dice **por que** no hay .sim.
if ($peor >= 2 or $codigo == 101 or $codigo == 104 or $codigo == 110) {
    mensajear(" la descripcion del circuito tiene errores: revise $nombre_ls1");
    cerrar_log();
    exit 2;
};
# Si el proceso corto, el estado es 1: el 7 queda para el caso en que corrio
# bien y aun asi no dejo el .sim, que es otra cosa. Y los fallos de la
# simulacion --el rango 120, que sceptresimusol r3402 agrego-- tienen su
# propio estado, el 9: lo que pide el autor es poder distinguir "el circuito
# esta mal escrito" (2) de "el circuito no se puede simular" (9), que es
# otra cosa y se arregla de otra manera. El 3 no, que ya es "SCEPTRE no esta
# instalado".
if ($codigo >= 111 and $codigo <= 128) {
    mensajear(" el circuito no se pudo simular"
      . (defined $que_cod ? ": $que_cod" : ''));
    cerrar_log();
    exit 9;
};
if ($codigo) {
    cerrar_log();
    exit 1;
};
unless (-f "$base.sim") {
    avgrav_simple("no hay $base.sim: sin el, nuevosimplot no puede armar el .simul");
    cerrar_log();
    exit 7;
}
cerrar_log();
my $emitido=eval {emitir_documento_numerico($documento_stdout,$base_entrada,$ext_entrada);1};
unless ($emitido) {warn "lanzador: $@";exit 7;}
exit 0;

# ----------------------------------------------------------------------
# Los listados de SCEPTRE. Son texto pensado para leer en papel --el 0 del
# principio de cada renglon es el control de carro de la impresora de los
# 70-- y hay que leerlos por tres razones, ninguna de las cuales es que
# SCEPTRE no avise: **si avisa**. sceptre1.for sale con 101 si abortó por
# errores, 102 si descarto la simulacion, 110 por severidad 4 (via sterr) y
# 206/207/208 al abrir archivos; sale con 0 solo si llego a 'SYSTEM NOW
# ENTERING SIMULATION'. Las tres razones son:
#
#   1. el codigo dice QUE fallo, no QUE cosa fallo: un 102 no distingue entre
#      una variable no definida, un delimitador incorrecto y un control de
#      corrida invalido;
#   2. los avisos de severidad 1 (WARNING ONLY) dejan correr la simulacion, y
#      el proceso termina con 0: esos solo estan en el listado;
#   3. los datos de la corrida --integrador, pasos, condicion de terminacion,
#      el TERMINATE que se cumplio-- no tienen codigo posible.
#
# Ver ERRORES.md.

# El .ls1: el listado de la fase 1. Casi todo es el **eco del .d**, que
# tenemos al lado, con los mensajes de SCEPTRE intercalados.
#
# No se buscan textos conocidos, se descarta el eco: **todo renglon del
# listado que no este en el .d es algo que SCEPTRE dijo**, y va al informe
# aunque no lo sepamos interpretar (pedido del autor, 13/10/2026: «¿por que
# el programa tiene que buscar? ¿no es simplemente informar que salio?»).
# Lo que sigue reconociendo por su forma --los ERROR MESSAGE con su codigo y
# severidad, los IS REFERENCED BY, los WARNING-- es para poder ordenarlos,
# contarlos y decidir el estado de salida, no para elegir que mostrar.
sub renglones_del_d {
    my ($archd) = @_;
    my %del_d;
    open my $fh, '<', $archd or return \%del_d;
    while (my $l = <$fh>) {
        chomp $l;
        $l =~ s/\s+//g;
        $l =~ s/^;+//;          # SCEPTRE imprime los comentarios sin el ';'
        length $l and $del_d{$l} = 1;
    };
    close $fh;
    return \%del_d;
}

# un archivo, o los renglones ya leidos (cuando vienen del log unico)
sub leer_renglones {
    my ($que) = @_;
    return @$que if ref $que;
    open my $fh, '<', $que or return ();
    my @r = <$fh>; close $fh;
    return @r;
}

sub revisar_ls1 {
    my ($archivo, $archd) = @_;
    my (@hallazgos, $nivelmax, $entro, @renglones);
    $nivelmax = 0; $entro = 0;
    @renglones = leer_renglones($archivo) or return (0, []);
    my $del_d = renglones_del_d($archd // '');
    for my $i (0 .. $#renglones) {
        my $l = $renglones[$i];
        chomp $l;
        next if $l =~ /SCEPTRE: SALIDA \|/;     # esos se leen aparte (renglones_salida)
        # el viejo escribe '0*** SCEPTRE ERROR MESSAGE NO. 51 - ERROR SEVERITY = ...   ELMPRS'
        # y el nuevo ' ELMPRS  : *** SCEPTRE ERROR MESSAGE NO. 51 - ERROR SEVERITY = ...'
        if ($l =~ /^[01]?\s*(?:(\S+)\s*:\s*)?\*\*\*\s*SCEPTRE ERROR MESSAGE NO\.\s*(\d+)\s*-\s*ERROR SEVERITY\s*=\s*(.*?)(?:\s{2,}(\S+))?\s*$/) {
            my ($kode, $severidad, $rutina) = ($2, $3, $1 // $4 // '?');
            $severidad =~ s/\s+$//;
            # el texto del mensaje viene en el renglon siguiente (el nuevo
            # deja uno en blanco en el medio y lo prefija con 'ERROR   : ')
            my $j = $i + 1;
            $j++ while defined $renglones[$j] and $renglones[$j] !~ /\S/;
            my $texto = defined $renglones[$j] ? $renglones[$j] : '';
            chomp $texto;
            $texto =~ s/^0//; $texto =~ s/^\s*[A-Z0-9_]+\s*:\s*//; $texto =~ s/^\s+|\s+$//g;
            my $nivel = $severidad =~ /ABORTED/i      ? 4
                      : $severidad =~ /SYSTEM ERROR/i ? 3
                      : $severidad =~ /DELETED/i      ? 2
                      :                                 1;
            $nivel > $nivelmax and $nivelmax = $nivel;
            push @hallazgos, { tipo => 'error', kode => $kode, nivel => $nivel,
                               rutina => $rutina, texto => $texto,
                               severidad => $severidad };
        } elsif ($l =~ /IS REFERENCED BY/) {
            $nivelmax < 2 and $nivelmax = 2;
            (my $limpio = $l) =~ s/^0//;
            push @hallazgos, { tipo => 'nodefinida', texto => $limpio };
        } elsif ($l =~ /WARNING/) {
            (my $limpio = $l) =~ s/^0//;
            push @hallazgos, { tipo => 'aviso', texto => $limpio };
        } elsif ($l =~ /SYSTEM NOW ENTERING SIMULATION/) {
            $entro = 1;
        } else {
            # todo lo que no sea el eco del .d es algo que SCEPTRE dijo
            # el control de carro de la impresora: 0 = renglon nuevo,
            # 1 = pagina nueva. Lo que empieza con 1 es un encabezado de
            # pagina ('1PROCESSING INPUT FILE  13.10.26 - 13:26'), no un
            # mensaje: lleva la fecha y cambia en cada corrida
            next if $l =~ /^1/;
            (my $comparable = $l) =~ s/^\s*\d+\s{2,}//;   # el nuevo numera el eco
            $comparable =~ s/\s+//g;
            $comparable =~ s/^[01]//;
            $comparable =~ s/^;+//;
            next if $comparable eq '';
            next if $del_d->{$comparable};
            # el texto de un mensaje ya se recogio con su encabezado (en el
            # nuevo, con un renglon en blanco en el medio)
            next if $i > 0 && $renglones[$i-1] =~ /ERROR MESSAGE NO\./;
            next if $i > 1 && $renglones[$i-2] =~ /ERROR MESSAGE NO\./ && $renglones[$i-1] !~ /\S/;
            (my $limpio = $l) =~ s/^0//; $limpio =~ s/\s+$//;
            push @hallazgos, { tipo => 'dice', texto => $limpio };
        }
    }
    push @hallazgos, { tipo => 'noentro',
        texto => 'SCEPTRE no llego a entrar en la simulacion' } unless $entro;
    return ($nivelmax, \@hallazgos);
}

# El .ls2: el listado de la fase 2, lo que paso en la corrida. Casi todo
# numeros, uno por corrida (rerun).
sub revisar_ls2 {
    my ($archivo, $archd) = @_;
    my (@corridas, $n);
    $n = 0;
    for my $l (leer_renglones($archivo)) {
        chomp $l;
        next if $l =~ /SCEPTRE: SALIDA \|/;     # esos se leen aparte
        $l =~ s/^0//;
        $l =~ s/^\s+//;                          # el nuevo sangra los controles
        $l =~ s/(\d)D([\+\-]\d)/$1e$2/g;      # el Fortran escribe 1.0D+04
        if    ($l =~ /^RUN\/RERUN NUMBER\s+(\d+)/i)        { $n = $1 }
        elsif ($l =~ /^INTEGRATION ROUTINE\s+(\S+)/i)      { $corridas[$n]{integrador} = $1 }
        elsif ($l =~ /^CURRENT SIMULATION TIME\s+(\S+)/i)  { $corridas[$n]{tiempo} = $1 }
        elsif ($l =~ /^INTEGRATION STEP COUNTER\s+(\S+)/i) { $corridas[$n]{pasos} = $1 }
        elsif ($l =~ /^INTEGRATION PASS COUNTER\s+(\S+)/i) { $corridas[$n]{pasadas} = $1 }
        elsif ($l =~ /^LAST STEP SIZE\s+(\S+)/i)           { $corridas[$n]{ultimopaso} = $1 }
        elsif ($l =~ /^TERMINATION CONDITION\s+(.*\S)/i)   { $corridas[$n]{termino} = $1 }
        elsif ($l =~ /^OPTIONAL TERMINATION CODE IS\s*(\d+)/i) {
            $corridas[$n]{codigo} = $1;
            $corridas[$n]{condicion} = terminate_del_d($archd, $1);
        }
        elsif ($l =~ /^(?:no\.|_|S C E P T R E|directory of|end of post|TRANSIENT|INITIAL AND FINAL|EIGENVALUE SUM)/i) {
            # rotulos y encabezados del informe: no son mensajes
        }
        elsif ($l =~ /[A-Za-z]{4}/) {
            # Cualquier otro renglon con palabras es **algo que SCEPTRE dijo
            # sobre la corrida**, y va al informe aunque no lo sepamos
            # interpretar: la matriz singular, el Newton que no convergio, el
            # paso que no alcanza, el autovalor con parte real positiva...
            # Antes esto era una lista de textos conocidos y lo que no
            # estuviera en la lista se perdia (pedido del autor, 13/10/2026).
            push @{$corridas[$n]{dice}}, $l;
        }
    }
    return \@corridas;
}

# El log unico de las dos fases, partido donde empieza la fase 2: en el
# viejo, la pagina 'TRANSIENT SOLUTION CONTROLS AFTER SIMULATION' (o la
# cabecera que la fase 2 escriba primero); en el nuevo, 'SC1 - EXEC2'.
# Devuelve dos referencias a renglones, o undef donde no hay nada.
sub partir_log {
    my ($log) = @_;
    -s $log or return (undef, undef);
    my @r = leer_renglones($log);
    my $corte;
    for my $i (0 .. $#r) {
        if ($r[$i] =~ /^SC1 - EXEC2|^[01]?\s*TRANSIENT solution controls after simulation/i) {
            $corte = $i; last;
        }
    }
    my @f1 = defined $corte ? @r[0 .. $corte-1] : @r;
    my @f2 = defined $corte ? @r[$corte .. $#r] : ();
    # la fase 1 sin eco (SCEPTRE_VERBOSE=1) tambien es fase 1
    return (\@f1, (@f2 ? \@f2 : undef));
}

# Los renglones 'SCEPTRE: SALIDA | cod | hh:mm:ss | archivo:linea | RUTINA |
# mensaje', de donde esten: lo que dijo al correr, el log, los .ls0/.ls1/.ls2
# (seccion 5 del contrato). Uno por codigo distinto; se descartan repetidos.
sub renglones_salida {
    my (@fuentes) = @_;
    my (%vistos, @salidas);
    for my $f (@fuentes) {
        my @r = ref $f ? @$f : (-f $f ? leer_renglones($f) : ());
        for my $l (@r) {
            $l =~ /SCEPTRE: SALIDA \| (\d+) \| ([\d:]+) \| ([^|]+?) \| ([^|]*?) \| (.*?)\s*$/ or next;
            my ($cod, $hora, $donde, $rutina, $que) = ($1, $2, $3, $4, $5);
            next if $vistos{"$cod $rutina $que"}++;
            push @salidas, { codigo => $cod, hora => $hora, donde => $donde,
                             rutina => $rutina, que => $que };
        }
    }
    return @salidas;
}

# El codigo de terminacion opcional que devuelve SCEPTRE es un indice a los
# TERMINATE que Simusol escribio en el .d: sin el .d no se puede saber que
# condicion se cumplio.
sub terminate_del_d {
    my ($archd, $codigo) = @_;
    return '' unless defined $archd and -f $archd and $codigo;
    open my $fh, '<', $archd or return '';
    my @term = grep { /TERMINATE/i } <$fh>;
    close $fh;
    my $texto = $term[$codigo - 1];
    defined $texto or return '';
    chomp $texto; $texto =~ s/^\s+|\s+$//g;
    return $texto;
}

# El consejo, que SCEPTRE no puede dar porque no sabe que hubo un diagrama.
# Los textos vienen de analizar_error2 de lolisol_sceptre.pl.
sub consejo {
    my ($cosa) = @_;
    return '' unless defined $cosa;
    if ($cosa =~ /IMPLICIT integration cancelled/i) {
        return "El metodo de integracion IMPLICIT fue cancelado\n"
             . "   (podria deberse a un circuito con solo resistencias)\n"
             . "   Pruebe a agregar en un cuadro CONTROLES:\n"
             . "       INTEGRATION ROUTINE = TRAP";
    } elsif ($cosa =~ /SMALLER MINIMUM STEP SIZE REQUIRED/i) {
        return "   Pruebe a agregar en un cuadro CONTROLES:\n"
             . "       INTEGRATION ROUTINE = IMPLICIT\n"
             . "          o bien\n"
             . "       MINIMUM STEP SIZE = ...\n"
             . "   o pida un tiempo de simulacion mas chico,\n"
             . "   o que sus variables varien menos bruscamente";
    }
    if ($cosa =~ /MATRIX IS SINGULAR/i) {
        return "   El sistema de ecuaciones no tiene solucion unica:\n"
             . "   revise si hay nodos sueltos, lazos sin resistencia\n"
             . "   o elementos repetidos entre los mismos nodos";
    } elsif ($cosa =~ /NEWTON-RAPHSON PASS LIMIT/i) {
        return "   El metodo no convergio: pruebe condiciones iniciales\n"
             . "   mas cercanas a la solucion, o un paso mas chico";
    } elsif ($cosa =~ /POSITIVE REAL PART/i) {
        return "   El circuito es inestable: la solucion crece sin limite.\n"
             . "   Revise los signos de las fuentes y las realimentaciones";
    } elsif ($cosa =~ /INTEGRATION PASS LIMIT/i) {
        return "   Se agoto el limite de pasadas: pida menos tiempo de\n"
             . "   simulacion, o agrande MAXIMUM INTEGRATION PASSES";
    };
    return '';
}

# El .ls4 y el .ls5 no son de SCEPTRE: son del compilador de Fortran y del
# enlazador, que compilan el programa que SCEPTRE genero.
sub revisar_compilacion {
    my ($base) = @_;
    my @problemas;
    for my $ext ('ls4', 'ls5') {
        my $archivo = "$base.$ext";
        -s $archivo or next;
        open my $fh, '<', $archivo or next;
        while (my $l = <$fh>) {
            chomp $l;
            next unless $l =~ /undefined reference to .(\w+)_?.|[Ee]rror|no se puede encontrar|cannot find/;
            push @problemas, { ext => $ext, texto => $l };
        }
        close $fh;
    }
    return \@problemas;
}

# Cual SCEPTRE, y de que tipo: 'viejo' (sceptresimusol, el guion 'sceptre'
# que toma el caso por argumento y deja .ls1/.ls2) o 'nuevo'
# (sceptre2novender, 'sc1', que copia el deck a input.dat y deja CASO.log y
# CASO.simnativo). Seccion 7 del contrato: se decide por lo que hay
# instalado, y mientras convivan se puede forzar uno para comparar:
#   SCEPTRE=/ruta/al/lanzador     el guion o el sc1, con ruta
#   SCEPTRE_USAR=viejo|nuevo      cual de los dos, buscandolo en el PATH
# El tipo se reconoce por lo que contesta --version: el nuevo dice SC1-SD2.
# La tabla de codigos de sceptre2novender/pasos/SALIDAS: 'codigo fase rutina
# que paso', con renglones de continuacion sangrados. Se busca junto al
# repositorio (este guion vive en siru/lanzador/bin) o donde diga
# SCEPTRE_SALIDAS. Sin ella, quedan las frases de %QUE_CODIGO.
sub leer_tabla_salidas {
    my @donde = ($ENV{SCEPTRE_SALIDAS},
                 $RealBin . '/../../sceptre2novender/pasos/SALIDAS',
                 '/usr/share/sceptre2novender/SALIDAS');
    my ($archivo) = grep { defined and -f } @donde;
    return () unless $archivo;
    open my $fh, '<', $archivo or return ();
    my (%t, $ultimo, $en_tabla);
    while (my $l = <$fh>) {
        chomp $l;
        if ($l =~ /^\s*codigo\s+fase\s+rutina/) { $en_tabla = 1; next }
        next unless $en_tabla;
        last if $l =~ /^Son \d+ puntos/;
        if ($l =~ /^\s*(\d+)\s+(\d[\d,]*)\s+(\S+)\s+(.*\S)\s*$/) {
            $t{$1} = { fase => $2, rutina => $3, que => $4 }; $ultimo = $1;
        } elsif (defined $ultimo and $l =~ /^\s{20,}(\S.*\S)\s*$/) {
            $t{$ultimo}{que} .= " $1";
        } elsif ($l !~ /\S/) { $ultimo = undef }
    }
    close $fh;
    al_log(" tabla de codigos: $archivo, " . scalar(keys %t) . " codigos");
    return %t;
}

sub buscar_sceptre {
    my @candidatos;
    if ($familia_sceptre) {
        my %variable=(sceptresimusolnuevo=>'SCEPTRESIMUSOLNUEVO',
            sceptrenovender=>'SCEPTRENOVENDER', sceptresimusolviejo=>'SCEPTRESIMUSOLVIEJO');
        my $ruta=$ENV{$variable{$familia_sceptre}} // $ENV{SCEPTRE};
        unless ($ruta) {
            $ruta=`command -v $familia_sceptre 2>/dev/null`; chomp $ruta;
        }
        return ('','') unless $ruta && -x $ruta;
        return ($ruta, $familia_sceptre eq 'sceptresimusolviejo' ? 'viejo' : 'nuevo');
    }
    if (defined $ENV{SCEPTRE} and -x $ENV{SCEPTRE}) { @candidatos = ($ENV{SCEPTRE}) }
    else {
        my $usar = lc($ENV{SCEPTRE_USAR} // '');
        my @nombres = $usar eq 'viejo' ? ('sceptre')
                    : $usar eq 'nuevo' ? ('sc1')
                    :                    ('sc1', 'sceptre');
        for my $n (@nombres) {
            my $cual = `which $n 2>/dev/null`; chomp $cual;
            push @candidatos, $cual if $cual && -x $cual;
            push @candidatos, grep { -x } ("/usr/local/bin/$n", "/usr/bin/$n");
        }
    }
    for my $c (@candidatos) {
        my $version = `"$c" --version 2>&1 </dev/null`;
        my $tipo = ($version =~ /SC1-SD2|sceptre2novender/ or $c =~ m{/sc1\z}) ? 'nuevo' : 'viejo';
        return ($c, $tipo);
    }
    return ('', '');
}

# Las funciones del usuario que el .d invoca: en SCEPTRE se declaran en la
# seccion FUNCTIONS y el nombre va seguido de parentesis.
sub funciones_del_d {
    my ($archivo) = @_;
    open my $fh, '<', $archivo or return ();
    my (%fun, $en);
    while (my $l = <$fh>) {
        if ($l =~ /^\s*FUNCTIONS\s*$/i) { $en = 1; next }
        if ($en && $l =~ /^\s*[A-Z][A-Z ]+\s*$/) { $en = 0; next }
        next unless $en;
        # ojo: una funcion definida en el propio .d --'Q3P(X,Y,Z)=(X*Y*Z)'--
        # no necesita Fortran del usuario; solo las declaradas sin definir
        next if $l =~ /=/;
        $fun{$1} = 1 if $l =~ /^\s*([A-Za-z][A-Za-z0-9_]*)\s*\(/;
    }
    close $fh;
    return sort keys %fun;
}

# Del .res, lo que le interesa a quien corrio: cuantos puntos calculo y por
# que paro. No se interpreta mas: el archivo queda para leerlo.
sub informar_res {
    my ($archivo) = @_;
    open my $fh, '<', $archivo or return;
    while (my $l = <$fh>) {
        chomp $l;
        mensajear("   $l") if $l =~ /solution points|TERMINAT|ERROR|RERUN/i;
    }
    close $fh;
    return 1;
}

# ----------------------------------------------------------------------
# Los otros motores. Cada uno corre en su subdirectorio sobre una copia de la
# entrada, lee lo que el motor dice de la corrida, trae las salidas y
# termina con el mismo juego de estados que SCEPTRE: 0 termino, 2 la
# entrada esta mal, 3 el motor no esta, 7 no dejo resultados, 9 fallo la
# simulacion.

# donde esta un programa: una variable de entorno con la ruta, el PATH, y
# los lugares del repositorio (este guion vive en siru/lanzador/bin)
sub buscar_programa {
    my ($nombre, $variable, @en_el_repo) = @_;
    return $ENV{$variable} if defined $ENV{$variable} and -x $ENV{$variable};
    my $cual = `which $nombre 2>/dev/null`; chomp $cual;
    return $cual if $cual and -x $cual;
    my $raiz = $RealBin . '/../..';
    for my $r (@en_el_repo) { my $c = "$raiz/$r"; return abs_path($c) if -x $c }
    return '';
}

# correr una orden capturando lo que dice; devuelve (estado, renglones)
sub correr_capturando {
    my ($orden, $entrada) = @_;
    $entrada //= '/dev/null';
    $entrada =~ s/'/'"'"'/g;
    my @dijo;
    open my $ph, '-|', "$orden 2>&1 <'$entrada'" or return (-1, []);
    while (my $l = <$ph>) { print $l; chomp $l; push @dijo, $l if $l =~ /\S/ }
    close $ph;
    my $estado = $?;
    al_log(" --- lo que dijo al correr ---"); al_log("   $_") for @dijo;
    return ($estado, \@dijo);
}

sub traer_salidas {
    my ($base, @ext) = @_;
    # una extension (sim, log...) o, con '=' adelante, un nombre entero
    my @traer = grep { -f } map { /^=(.*)/ ? $1 : "$base.$_" } @ext;
    for my $f (@traer) { unlink "../$f"; rename($f, "../$f") or avgrav_simple("no pude mover $f: $!") }
    cambiar_directorio('..');
    my @quedaron = grep { -f } map { /^=(.*)/ ? $1 : "$base.$_" } @ext;
    if (@quedaron) { mensajear(" quedaron: @quedaron") }
    else { avgrav_simple("el motor no dejo ningun archivo de salida") }
    return @quedaron;
}

# siru (Simul2): toma el .d o el .ds tal cual --entiende la seccion PARAPLOT,
# es de Simusol-- y deja el .simul directo, sin pasar por el .sim; lo que
# paso lo dice en NOMBRE.informe ('resultado: llega al final', 'NO
# CONVERGE', 'se corta', 'no arranca'; sale siempre con 0, asi que el
# informe es la fuente). -nosimplot porque graficar es de quien sigue.
sub motor_siru {
    my ($base, $ext) = @_;
    my $siru = buscar_programa('siru', 'SIRU', 'siru/bin/siru');
    unless ($siru) { print "lanzador: siru no esta instalado (ni en el PATH ni en siru/bin)\n"; cerrar_log(); return 3 }
    mensajear(" motor: $motor, coordinado por siru ($siru)");
    my $SUB = 'siru';
    -d $SUB or mkdir $SUB or avgrav_simple("no pude crear $SUB/: $!");
    my $fuente = "$base.$ext";
    if ($ext eq 'cir') {
        $fuente = traducir_cir("$base.cir", "$SUB/$base.ds") or do { cerrar_log(); return 8 };
        $fuente = "$base.ds";
    } else {
        unlink "$SUB/$fuente";
        link($fuente, "$SUB/$fuente") or symlink(File::Spec->rel2abs($fuente), "$SUB/$fuente");
    }
    my $du;
    if ($ext eq 'dsa') {
        (my $n=$base)=~s/\.M$//; $du="$n.DU.dsa";
        unless (-f $du) {warn "lanzador: falta $du\n";cerrar_log();return 2}
        unlink "$SUB/$du";
        symlink(File::Spec->rel2abs($du),"$SUB/$du") or die "$du: $!\n";
    }
    if ($ensayo) { mensajear(" ensayo: no se corre siru"); cerrar_log(); return 0 }
    cambiar_directorio($SUB) or return 4;
    unlink "$base.simul", "$base.informe";
    comfin("com correr");
    local $ENV{SIRU_MOTOR}=$motor;
    # El caso tiene M y DU juntos en el directorio del motor.
    # Siru recibe el modelo y lee los datos y usos de su archivo acompañante.
    my ($estado, $dijo) = correr_capturando("$siru -nosimplot --salida $base.simul $fuente");
    comfin("fin correr " . ($estado >> 8));
    if ($estado == -1) { avgrav_simple("no pude ejecutar $siru: $!"); cerrar_log(); return 5 }
    # el informe
    my (%inf);
    if (open my $fh, '<', "$base.informe") {
        while (my $l = <$fh>) { chomp $l; $inf{$1} = $2 if $l =~ /^(\w[\w ]*?):\s*(.*\S)/ }
        close $fh;
        mensajear(" siru dice: $_: $inf{$_}") for grep { exists $inf{$_} } qw(resultado hasta);
    } else {
        mensajear(" siru no dejo $base.informe");
    }
    my $filas = defined $inf{hasta} && $inf{hasta} =~ /(\d+) filas/ ? $1 : '';
    my @porque;
    my $salida = 0;
    my $res = $inf{resultado} // '';
    $res = 'llega al final' if $ext eq 'dsa' && !$estado && -s "$base.simul";
    if ($res =~ /llega al final/) {
        push @porque, "Termino la simulacion ($motor" . ($filas ne '' ? ", $filas filas" : '') . ")";
    } elsif ($res ne '') {
        push @porque, "Fallo la integracion (siru): $res" . ($filas ne '' ? ", llego a $filas filas" : '');
        $salida = 9;
    } else {
        my ($err) = grep { /no declara|no se pudo|error|falta/i } @$dijo;
        push @porque, "siru no corrio" . (defined $err ? ": $err" : " (estado " . ($estado >> 8) . ")");
        $salida = 2;
    }
    mensajear(" POR QUE TERMINO: " . join(', ', @porque));
    my @quedaron = traer_salidas($base, qw(simul informe log));
    if (not $salida and not grep { /\.simul\z/ } @quedaron) {
        avgrav_simple("no hay $base.simul: sin el, simplot no puede graficar"); $salida = 7;
    }
    cerrar_log();
    return $salida;
}

# ngspice: solo con un netlist .cir. 'ngspice -b' escribe las tablas que el
# netlist pide con .print por la salida normal, y tabular2 las exporta al
# .simul (interpola --exportar-simul; ver el README de tabular2, 'Conversion
# comun de SCEPTRE y SPICE a .simul'). ngspice sale con 0 aunque rechace
# renglones --'is not a valid resistor instance line, ignored!'--, asi que lo
# que dice por la salida de error es la fuente.
# Con un .d o .ds de Simusol, primero el netlist con dat2cir (bin/dat2cir, el
# espejo de cir2ds); y el resultado va a un .sim como el de SCEPTRE, con las
# columnas en el orden de OUTPUTS, para que sim2simul le ponga la cabecera del
# pedido igual que siempre. Con un .cir suelto no hay pedido: el .print pasa
# al .simul con tabular2.
sub motor_spice {
    my ($base, $ext) = @_;
    my $ngspice = buscar_programa('ngspice', 'NGSPICE');
    unless ($ngspice) { print "lanzador: ngspice no esta instalado\n"; cerrar_log(); return 3 }
    my $interpola = buscar_programa('interpola', 'INTERPOLA', 'tabular2/src/interpola');
    unless ($interpola or $ext ne 'cir') { print "lanzador: falta interpola (tabular2), que pasa la salida de ngspice a .simul\n"; cerrar_log(); return 3 }
    mensajear(" motor: spice, $ngspice" . ($ext eq 'cir' ? " (y $interpola para el .simul)" : " (con dat2cir)"));
    my $SUB = 'spice';
    -d $SUB or mkdir $SUB or avgrav_simple("no pude crear $SUB/: $!");
    my $desde_deck = ($ext ne 'cir');
    if ($desde_deck) {
        my $dat2cir = File::Spec->catfile($RealBin, 'dat2cir');
        -x $dat2cir or do { print "lanzador: falta $dat2cir\n"; cerrar_log(); return 3 };
        unlink "$SUB/$base.cir";
        my $dijo = `perl "$dat2cir" "$base.$ext" "$SUB/$base.cir" 2>&1 </dev/null`;
        my $est = $? >> 8;
        al_log("   $_") for grep { /\S/ } split /\n/, $dijo;
        if ($est or not -s "$SUB/$base.cir") {
            mensajear(" dat2cir no pudo traducir $base.$ext" . ($dijo =~ /\S/ ? ": " . (split /\n/, $dijo)[-1] : ''));
            mensajear(" POR QUE TERMINO: el .$ext no se puede traducir a SPICE");
            cerrar_log(); return $est == 3 ? 3 : 2;
        }
        mensajear(" traducido: $SUB/$base.cir" . ($dijo =~ /RERUN/ ? " (sin los RERUN)" : ''));
    } else {
        unlink "$SUB/$base.cir";
        link("$base.cir", "$SUB/$base.cir") or symlink(File::Spec->rel2abs("$base.cir"), "$SUB/$base.cir");
    }
    if ($ensayo) { mensajear(" ensayo: no se corre ngspice"); cerrar_log(); return 0 }
    cambiar_directorio($SUB) or return 4;
    unlink "$base.out", "$base.err", "$base.simul", "$base.sim";
    comfin("com correr");
    # la corrida maestra y, si dat2cir dejo reruns, cada uno despues; los .out
    # de los reruns se juntan al .sim con sus trailers
    my @netlists = ("$base.cir", sort { ($a =~ /_rerun(\d+)/)[0] <=> ($b =~ /_rerun(\d+)/)[0] } glob("${base}_rerun*.cir"));
    my $estado = 0;
    for my $i (0 .. $#netlists) {
        my $suf = $i ? "_rerun$i" : '';
        mensajear(" corriendo: $ngspice -b $netlists[$i]");
        system("$ngspice -b $netlists[$i] > $base$suf.out 2> $base$suf.err </dev/null");
        $estado ||= $?;
    }
    comfin("fin correr " . ($estado >> 8));
    my (@errores, @avisos);
    for my $f (map { ("$base$_.err", "$base$_.out") } ('', map { "_rerun$_" } 1 .. $#netlists)) {
        open my $fh, '<', $f or next;
        while (my $l = <$fh>) {
            chomp $l;
            if    ($l =~ /^\s*Error/i)   { push @errores, $l }
            elsif ($l =~ /Interpolated raw file data/) { }   # lo dice siempre con .options interp
            elsif ($l =~ /^\s*Warning/i) { push @avisos, $l }
        }
        close $fh;
    }
    mensajear(" ngspice: $_") for @errores, @avisos;
    my $salida = 0; my @porque;
    if (@errores or $estado) {
        push @porque, "ngspice rechazo el netlist: " . ($errores[0] // "estado " . ($estado >> 8));
        $salida = 2;
    }
    # la salida .print: a un .sim como el de SCEPTRE si venimos de un deck
    # (el pedido esta en el .d y sim2simul hace el resto), o al .simul con
    # tabular2 si era un .cir suelto
    my $puntos = '';
    if ($desde_deck and -s "$base.out") {
        $puntos = tabla_a_sim("$base.sim", map { "$base$_.out" } ('', map { "_rerun$_" } 1 .. $#netlists));
        mensajear($puntos ne '' ? " $puntos puntos en $base.sim" . (@netlists > 1 ? " (" . scalar(@netlists) . " corridas)" : '') : " ngspice no dejo la tabla .print en $base.out");
    } elsif (-s "$base.out") {
        system("$interpola --exportar-simul $base.out > $base.simul 2> $base.exportar.err");
        if (-s "$base.simul") {
            if (open my $fh, '<', "$base.simul") {
                while (my $l = <$fh>) { $l =~ /^# CORRIDA \d+ \((\d+) puntos\)/ and $puntos = $1; last if $l !~ /^#/ }
                close $fh;
            }
        } else {
            my $por = ''; if (open my $fh, '<', "$base.exportar.err") { local $/; $por = <$fh> // ''; close $fh; $por =~ s/\s+/ /g }
            mensajear(" tabular2 no pudo pasar $base.out a .simul" . ($por ? ": $por" : ''));
            mensajear(" (el netlist tiene que pedir las tablas con .print)");
        }
    }
    unless ($salida) {
        if (-s "$base.simul" or -s "$base.sim") {
            push @porque, "Termino la simulacion (ngspice" . ($puntos ne '' ? ", $puntos puntos" : '') . ")";
        } else {
            push @porque, "ngspice corrio y no dejo resultados que leer"; $salida = 7;
        }
    }
    @avisos and push @porque, "con " . scalar(@avisos) . " aviso" . (@avisos == 1 ? '' : 's') . " de ngspice";
    mensajear(" POR QUE TERMINO: " . join(', ', @porque));
    traer_salidas($base, qw(sim simul cir out err), map { ("=${base}_rerun$_.cir", "=${base}_rerun$_.out") } 1 .. $#netlists);
    cerrar_log();
    return $salida;
}

# La tabla que 'ngspice -b' escribe por .print --'Index time v(1) ...',
# paginada, con el encabezado repetido-- a un .sim de SCEPTRE: una fila por
# punto con las columnas despues del Index (el tiempo primero, como SCEPTRE),
# y el trailer '#no. of solution points'. sim2simul no mira los nombres del
# .sim: la cabecera la pone desde el pedido, por posicion, y dat2cir escribe
# las columnas en el orden de OUTPUTS. Devuelve cuantos puntos.
sub tabla_a_sim {
    my ($sim, @outs) = @_;
    my $total = 0;
    open my $o, '>', $sim or return '';
    for my $n (0 .. $#outs) {
        open my $in, '<', $outs[$n] or do {
            close $o; unlink $sim; return '';
        };
        # Cada encabezado distinto aporta otro grupo de columnas. Sus
        # repeticiones son paginas del mismo grupo, no variables nuevas.
        my (%bloques, %filas, @posiciones);
        my $columnas = 0;
        my $error = '';
        while (my $l = <$in>) {
            my @c = split ' ', $l;
            if (@c >= 3 && $c[0] eq 'Index' && lc($c[1]) eq 'time') {
                my $firma = join "\t", @c[2 .. $#c];
                unless (exists $bloques{$firma}) {
                    $bloques{$firma} = [map { ++$columnas } @c[2 .. $#c]];
                }
                @posiciones = @{$bloques{$firma}};
                next;
            }
            next unless @posiciones && @c && $c[0] =~ /^\d+$/;
            if (@c != @posiciones + 2 || grep {
                    !/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?$/
                } @c[1 .. $#c]) {
                $error = "fila numerica incompleta o invalida"; last;
            }
            my ($indice, $tiempo, @valores) = @c;
            my $fila = $filas{$indice} //= [];
            if (defined $fila->[0] && $fila->[0] != $tiempo) {
                $error = "tiempos distintos para el indice $indice"; last;
            }
            $fila->[0] = $tiempo;
            for my $i (0 .. $#posiciones) {
                my $pos = $posiciones[$i];
                if (defined $fila->[$pos] && $fila->[$pos] != $valores[$i]) {
                    $error = "valores contradictorios para el indice $indice"; last;
                }
                $fila->[$pos] = $valores[$i];
            }
            last if $error;
        }
        close $in;
        my @indices = sort { $a <=> $b } keys %filas;
        for my $indice (@indices) {
            my $fila = $filas{$indice};
            $error ||= "faltan columnas para el indice $indice"
                if grep { !defined $fila->[$_] } 0 .. $columnas;
        }
        if ($error || !@indices) {
            warn "lanzador: $outs[$n]: " . ($error || "sin tabla transitoria") . "\n";
            close $o; unlink $sim; return '';
        }
        for my $indice (@indices) {
            print {$o} join(' ', map { sprintf '%12.5e', $_ } @{$filas{$indice}}), "\n";
        }
        printf {$o} "#RUN/RERUN NUMBER %6d\n", $n;
        print {$o} "#no. of solution points: " . scalar(@indices) . "\n";
        $total += @indices;
    }
    close $o;
    unlink $sim unless $total;
    return $total ? $total : '';
}

# un netlist de SPICE al .ds de siru, con cir2ds (slex/examples/11), que
# tambien lee SCEPTRE despues de sacarle el PARAPLOT. La biblioteca de
# elementos va con ruta absoluta, para que el include valga desde el
# subdirectorio.
sub traducir_cir {
    my ($cir, $ds) = @_;
    my $cir2ds = buscar_programa('cir2ds', 'CIR2DS', 'slex/examples/11/cir2ds');
    unless ($cir2ds) { avgrav_simple("falta cir2ds (slex/examples/11), que traduce el netlist a .ds"); return undef }
    my $raiz = $RealBin . '/../..';
    my $bib = $ENV{SIRU_BIBLIOTECA} // abs_path("$raiz/slex/d2datdinc/biblioteca/libraryori.siru") // '';
    unlink $ds;
    my $orden = "$cir2ds $cir $ds" . ($bib ? " -b $bib" : '');
    mensajear(" traduciendo: $orden");
    my $dijo = `$orden 2>&1 </dev/null`;
    if ($? or not -s $ds) {
        avgrav_simple("cir2ds no pudo traducir $cir" . ($dijo =~ /\S/ ? ": $dijo" : ''));
        return undef;
    }
    al_log("   $_") for grep { /\S/ } split /\n/, $dijo;
    return $ds;
}

# maxima: la solucion ANALITICA, en forma cerrada. El modelo pasa a ecuaciones
# por el camino de siempre --el circuito lo arma d2datdinc en el .din, con sus
# lazos y cortes-- y de ahi a Maxima con bin/din2mac. Maxima no sabe de
# circuitos: resuelve el sistema que se le da (desolve, por Laplace), asi que
# las ecuaciones son las de siru y no otras. Deja:
#
#   caso.analitica  la solucion en forma cerrada, una variable por renglon
#   caso.simul      esa formula evaluada en la malla de la corrida, para que
#                   la cadena siga igual que con los otros motores
#   caso.mac        lo que se le dio a Maxima, y caso.tabla lo que devolvio
#
# Solo hay forma cerrada para lo que Maxima sabe resolver: sistemas lineales,
# incluidas las ecuaciones algebraicas del circuito (un DAE de indice 1). Lo
# no lineal y las tablas no tienen formula: se dice y se sale con 3, que es el
# estado de 'esa entrada no va con ese motor'.
sub motor_maxima {
    my ($base, $ext) = @_;
    my $maxima = buscar_programa('maxima', 'MAXIMA');
    unless ($maxima) { print "lanzador: maxima no esta instalado (ni en el PATH ni en MAXIMA=)\n"; cerrar_log(); return 3 }
    my $din2mac = File::Spec->catfile($RealBin, 'din2mac');
    unless (-x $din2mac) { print "lanzador: falta $din2mac, el puente del .din a Maxima\n"; cerrar_log(); return 3 }
    mensajear(" motor: maxima, $maxima (y $din2mac para el .mac)");
    my $SUB = 'maxima';
    -d $SUB or mkdir $SUB or avgrav_simple("no pude crear $SUB/: $!");
    my $fuente = "$base.$ext";
    if ($ext eq 'cir') {
        mensajear(" un .cir todavia no entra por aca: traduzcalo antes (cir2ds) o use --motor spice");
        cerrar_log(); return 3;
    }
    unlink "$SUB/$fuente";
    link($fuente, "$SUB/$fuente") or symlink(File::Spec->rel2abs($fuente), "$SUB/$fuente");
    # el par M/DU: el modelo entra con sus DATOS y USOS al lado (un .dsa
    # siempre viene separado, y el nombre del modelo termina en .M)
    my $du = '';
    if ($ext eq 'dsa') {
        (my $b = $base) =~ s/\.M\z//;
        $du = "$b.DU.dsa";
        unless (-f $du) { mensajear(" falta $du: un .M.dsa necesita sus DATOS y USOS"); cerrar_log(); return 2 }
        unlink "$SUB/$du";
        link($du, "$SUB/$du") or symlink(File::Spec->rel2abs($du), "$SUB/$du");
    }
    if ($ensayo) { mensajear(" ensayo: no se corre maxima"); cerrar_log(); return 0 }
    cambiar_directorio($SUB) or return 4;
    unlink "$base.din", "$base.dat", "$base.mac", "$base.analitica", "$base.tabla", "$base.simul";

    # ---- 1. el modelo, pasado a ecuaciones: el .din
    # Lo arma d2datdinc, el mismo que lo arma para siru y para Calcula: el
    # circuito con sus lazos y cortes, o las ecuaciones del modelo si no hay
    # circuito. Del par M/DU se prepara primero el .dat --el mismo d2datdinc
    # lo lee, con su lector .dsa en C; ahi entran los DATOS del DU, que son
    # las condiciones iniciales-- y ese .dat es su entrada, igual que un .d.
    comfin("com ecuaciones");
    my ($estado_din, $dijo_din);
    my $d2d = $ENV{D2DATDINC} // 'd2datdinc';
    my $raiz = $RealBin . '/../..';
    $d2d = "$raiz/slex/d2datdinc/d2datdinc" if $d2d eq 'd2datdinc' and -x "$raiz/slex/d2datdinc/d2datdinc";
    my $conf = $ENV{D2DATDINC_CONF} // "$raiz/slex/d2datdinc/d2datdinc.slex";
    my $bib  = $ENV{D2DATDINC_BIB}  // "$raiz/slex/d2datdinc/biblioteca";
    my @opc;
    push @opc, "-c $conf" if -f $conf;
    push @opc, "-b $bib"  if -d $bib;
    (my $nombre = $base) =~ s/\.M\z//;
    my $entrada_d2d = $fuente;
    if ($ext eq 'dsa') {
        # EL PAR .dsa LO LEE d2datdinc (05/11/2026, pedido del autor). Su
        # lector es libdsa, en C (slex/dsa, sceptre2novender/PLAN-DSA-EN-C.md),
        # el mismo que enlazan las dos fases de SCEPTRE y el que ya usa sc1: el
        # .M.dsa entra como un .d y sale el dato, y el DU lo busca el mismo
        # d2datdinc al lado del modelo. Hasta hoy esto lo traducia
        # slex/viejos/dsa-python/traducir.py, en python; se saco por lo mismo que sc1
        # --instalado no debe hacer falta python3 ni el traductor-- y porque el
        # dato de d2datdinc trae ademas los CONTROLES y las CONDICIONES del
        # USO, que traducir.py --modelo-calcula dejaba afuera.
        ($estado_din, $dijo_din) = correr_capturando("$d2d @opc $fuente --dat -o $nombre.dat");
        if ($estado_din == -1 or $estado_din >> 8 or not -f "$nombre.dat") {
            my ($err) = grep { /\S/ } reverse @{ $dijo_din // [] };
            mensajear(" el lector .dsa no pudo con $fuente" . (defined $err ? ": $err" : ''));
            mensajear(" POR QUE TERMINO: no se pudo preparar el modelo de $fuente");
            cerrar_log(); return 2;
        }
        $entrada_d2d = "$nombre.dat";
    }
    # el final de la corrida, si no esta en el .dat (ver tiempo_final_del_du)
    my $hasta = tiempo_final_del_du($du, "$nombre.dat");
    my $opc_corrida = $hasta ? " --hasta $hasta" : '';
    mensajear(" el final de la corrida sale de las CONDICIONES del uso: T hasta $hasta") if $hasta;
    # la malla donde se evalua la formula: --paso (de a cuanto) o --puntos
    # (cuantos). Con llaves es tambien el paso con que se evaluan las
    # condiciones, asi que de aca sale donde conmuta cada llave.
    if (defined $paso_opt) {
        $opc_corrida .= " --paso $paso_opt";
        mensajear(" la malla va de a $paso_opt: tambien es el paso con que se evaluan"
                . " las condiciones de las llaves");
    } elsif (defined $puntos_opt) {
        $opc_corrida .= " --puntos $puntos_opt";
        mensajear(" la malla tiene $puntos_opt puntos");
    }
    # Con llaves no hay UN sistema sino uno por configuracion, y la solucion
    # se arma intervalo por intervalo: ese es otro camino (con_llaves). Lo
    # dice la topologia, que informa el mismo d2datdinc.
    my @llaves_circuito = llaves_del_circuito($d2d, \@opc, $entrada_d2d);
    if (@llaves_circuito) {
        if ($tipo_salida eq 'analitica') {
            warn "lanzador: salida analitica por tramos con llaves aun no disponible; use --salida numerica\n";
            cerrar_log(); return 3;
        }
        return con_llaves($base, $nombre, $entrada_d2d, $d2d, \@opc,
                          $din2mac, $maxima, \@llaves_circuito, $opc_corrida);
    }
    if ($ext eq 'dsa') {
        # --din va ULTIMO: lleva un NRO opcional y se come lo que sigue
        ($estado_din, $dijo_din) = correr_capturando("$d2d @opc $entrada_d2d --din");
    } else {
        ($estado_din, $dijo_din) = correr_capturando("$d2d @opc $entrada_d2d --dat -o $nombre.dat --din");
    }
    # d2datdinc firma el sistema que escribe: NOMBRE-de-d2datdinc.din
    for my $cual ("$nombre.din", "$nombre-de-d2datdinc.din") {
        next if -f "$base.din";
        rename($cual, "$base.din") if -f $cual;
    }
    rename("$nombre.dat", "$base.dat") if $nombre ne $base and -f "$nombre.dat" and !-f "$base.dat";
    comfin("fin ecuaciones " . ($estado_din == -1 ? -1 : $estado_din >> 8));
    unless (-f "$base.din") {
        my ($err) = grep { /error|no se|falta|rechaz/i } @$dijo_din;
        mensajear(" no se pudo pasar $fuente a ecuaciones (.din)" . (defined $err ? ": $err" : ''));
        mensajear(" POR QUE TERMINO: no se pudo armar el sistema de ecuaciones de $fuente");
        cerrar_log(); return 2;
    }
    mensajear(" el sistema de ecuaciones: $base.din");

    # ---- 2. el .mac, y Maxima
    my ($estado_puente, $dijo_puente) = correr_capturando(
        "$din2mac" . ($tipo_salida eq 'analitica' ? " --solo-analitica" : '') . (-f "$base.dat" ? " --dat $base.dat" : '') . $opc_corrida
        . " $base.din $base.mac");
    if (($estado_puente >> 8) or not -f "$base.mac") {
        my $motivo = join('; ', grep { /^din2mac:/ } @$dijo_puente) || 'el sistema no se puede llevar a Maxima';
        $motivo =~ s/^din2mac:\s*//;
        mensajear(" POR QUE TERMINO: $motivo");
        traer_salidas($base, qw(din dat));
        cerrar_log(); return 3;
    }
    comfin("com correr");
    # 'maxima -b' repite por pantalla cada renglon del programa, asi que su
    # salida va al listado del caso (caso.maxima.log) y de ahi se lee.
    my $listado = "$base.maxima.log";
    my $estado = system("$maxima --very-quiet -b $base.mac >$listado 2>&1 </dev/null");
    comfin("fin correr " . ($estado == -1 ? -1 : $estado >> 8));
    if ($estado == -1) { avgrav_simple("no pude ejecutar $maxima: $!"); cerrar_log(); return 5 }
    my @dicho;
    if (open my $lf, '<', $listado) { @dicho = <$lf>; close $lf; chomp @dicho }
    my $dijo = \@dicho;
    al_log(" --- lo que dijo maxima ---"); al_log("   $_") for @dicho;

    # ---- 3. que dijo. El .mac escribe un renglon DIN2MAC ESTADO al terminar;
    # sin el, Maxima se corto antes (y entonces el listado es la fuente).
    my ($linea) = grep { /^DIN2MAC ESTADO:/ } @dicho;
    my @porque;
    my $salida = 0;
    if (defined $linea and $linea =~ /resuelto/) {
        push @porque, "Termino la solucion analitica (maxima)";
    } elsif (defined $linea and $linea =~ /sin solucion analitica;\s*(.*)/) {
        push @porque, "No hay solucion analitica (maxima): $1";
        $salida = 3;
    } else {
        my ($err) = grep { /error|incorrect|not .*found/i } @$dijo;
        push @porque, "maxima no termino" . (defined $err ? ": $err" : " (estado " . ($estado >> 8) . ")");
        $salida = 2;
    }

    # ---- 4. el .simul, desde la tabla que dejo Maxima
    if (not $salida and -f "$base.tabla") {
        my $filas = tabla_a_simul("$base.tabla", "$base.simul", $base);
        if (defined $filas) { $porque[0] .= ", $filas filas" }
        else { avgrav_simple("no pude escribir $base.simul desde $base.tabla"); $salida = 7 }
    }
    mensajear(" POR QUE TERMINO: " . join(', ', @porque));
    if (-f "$base.analitica" and open my $a, '<', "$base.analitica") {
        my @f = grep { /\S/ and !/^#/ } <$a>; close $a;
        chomp @f;
        mensajear(" la solucion: $_") for @f;
    }
    my @quedaron = traer_salidas($base, qw(analitica simul mac tabla din dat), '=' . $listado);
    if (not $salida and $tipo_salida eq 'numerica' and not grep { /\.simul\z/ } @quedaron) {
        avgrav_simple("no hay $base.simul: sin el, simplot no puede graficar"); $salida = 7;
    }
    cerrar_log();
    return $salida;
}

# ----------------------------------------------------------------------
# LAS LLAVES, en el motor maxima
#
# Con llaves el modelo no es un sistema sino uno por configuracion --el mismo
# circuito con la llave cerrada o abierta, y con la ley del lazo o del corte
# que eso provoca--, y el que divide por casos es d2datdinc --llaves, el
# mismo que se los prepara a Calcula. Aca la solucion cerrada se arma
# intervalo por intervalo:
#
#   1. el HORARIO: en que intervalos vale cada configuracion. Lo resuelve
#      Maxima sobre las condiciones de las llaves (din2mac --horario),
#      evaluandolas AL COMENZAR CADA PASO de la malla: la configuracion del
#      paso que empieza en t_k vale todo el paso, y donde difiere de la del
#      paso anterior empieza un intervalo nuevo. El instante de conmutacion
#      es por lo tanto un punto de la malla, como en siru --'se evalua al
#      empezar cada paso; si cambia en medio de un paso, la llave cambia en
#      el siguiente' (slex/dsa/doc/GRAMATICA.tex)-- y no la raiz exacta
#      de la condicion (decision del autor, 04/11/2026: "las llaves al
#      comenzar cada paso"). Lo que sigue siendo exacto es todo lo demas: el
#      instante cae en un racional de la malla y los estados se pasan como
#      expresiones;
#   2. cada INTERVALO con el .mdin de su configuracion y los estados del
#      intervalo anterior como condiciones iniciales (din2mac --t0 --fin
#      --estado --estados-fin), exactos: no hay error acumulado;
#   3. el EQUILIBRIO entre dos intervalos: si la configuracion que empieza
#      cierra un lazo de capacitores o abre un corte de bobinas, la carga o
#      el flujo se redistribuyen de golpe. Ese trasvase es el .mdin de
#      equilibrio de la configuracion (NOMBRE-<bits>E.mdin), algebraico, que
#      se resuelve con solve. En el instante de la conmutacion quedan dos
#      renglones en la tabla, el de antes y el de despues, como en siru.

# El tiempo final de la corrida. Lo normal es TIEMPOFINAL en los DATOS del
# DU, que queda en el .dat y de ahi lo lee din2mac. Pero el uso puede fijar
# el final con el limite literal de sus CONDICIONES (T<=2, y entonces el
# .dat no trae TIEMPOFINAL): eso se lee del DU y se le pasa con --hasta.
# Devuelve '' si el .dat ya lo trae o si no hay de donde sacarlo.
sub tiempo_final_del_du {
    my ($du, $dat) = @_;
    return '' unless $du and -f $du;
    if (open my $d, '<', $dat) {
        local $/; my $texto = <$d>; close $d;
        return '' if $texto =~ /"TIEMPOFINAL"\s*:\s*\{\s*"value"/;
    }
    open my $f, '<', $du or return '';
    my ($en, $hasta) = (0, '');
    while (my $l = <$f>) {
        if ($l =~ /^\s*CONDICIONES\s*$/i) { $en = 1; next }
        last if $en and $l =~ /^\s*FIN\s*$/i;
        next unless $en;
        $hasta = $1 if not $hasta and $l =~ /^\s*T\s*<=?\s*([-\d.eEdD+]+)/i;
    }
    close $f;
    $hasta =~ s/[dD]/e/ if $hasta;
    return $hasta;
}

# Que llaves tiene el circuito: la topologia de d2datdinc dice 'llaves S1 S2'
# (vacio si no hay). Va al log y no a la pantalla: es para decidir el camino.
sub llaves_del_circuito {
    my ($d2d, $opc, $entrada) = @_;
    my @dijo = split /\n/, `$d2d @$opc $entrada --topologia 2>&1 </dev/null`;
    al_log(" --- topologia ---"); al_log("   $_") for @dijo;
    for my $l (@dijo) { return split ' ', $1 if $l =~ /^llaves\s+(.*\S)/ }
    return ();
}

# El sistema de una configuracion: lo escribe d2datdinc --llaves S1=0,...
# --din, que deja NOMBRE-<bits>I.mdin (el instante), NOMBRE-<bits>E.mdin (el
# equilibrio, si hay lazo o corte) y NOMBRE-<bits>D.mdin (el punto de
# operacion). Los bits van en el orden en que la topologia nombra las llaves.
# Devuelve (el .mdin del instante o undef, los bits).
sub configuracion_llaves {
    my ($d2d, $opc, $entrada, $nombre, $cuales, $orden) = @_;
    my %valor;
    for my $par (split /,/, $cuales) { $valor{uc $1} = $2 if $par =~ /(\w+)\s*=\s*(\d+)/ }
    my $bits = join '', map { $valor{uc $_} // 0 } @$orden;
    my $mdin = "$nombre-${bits}I.mdin";
    # --din va ULTIMO: lleva un NRO opcional y se come lo que sigue
    correr_capturando("$d2d @$opc $entrada --llaves $cuales --din") unless -f $mdin;
    return (-f $mdin ? $mdin : undef, $bits);
}

# correr un .mac y traer el renglon DIN2MAC ESTADO (el ultimo del listado,
# que se va acumulando corrida a corrida)
sub correr_un_mac {
    my ($maxima, $mac, $listado) = @_;
    my $antes = -s $listado // 0;
    my $estado = system("$maxima --very-quiet -b $mac >>$listado 2>&1 </dev/null");
    return (-1, '') if $estado == -1;
    my @dicho;
    if (open my $lf, '<', $listado) { @dicho = <$lf>; close $lf; chomp @dicho }
    my ($linea) = grep { /^DIN2MAC ESTADO:/ } reverse @dicho;
    # en contexto de lista completa, tambien lo que ESTA corrida dijo con el
    # prefijo DIN2MAC (BITS0, CONMUTA, PARA): lo usa el camino intervalo por
    # intervalo, que necesita mas que el ESTADO final
    my @propias;
    if (wantarray and open my $lf2, '<', $listado) {
        seek $lf2, $antes, 0;
        local $_;
        while (<$lf2>) { chomp; push @propias, $_ if /^DIN2MAC / }
        close $lf2;
    }
    return ($estado, $linea // '', join("\n", @propias));
}

# los estados que dejo Maxima:  estado NOMBRE | VALOR  (el valor, exacto)
sub leer_estados {
    my ($arch) = @_;
    my %e;
    open my $fh, '<', $arch or return %e;
    while (my $l = <$fh>) { chomp $l; $e{$1} = $2 if $l =~ /^estado\s+(\w+)\s*\|\s*(.*\S)/ }
    close $fh;
    return %e;
}

# las tablas de los intervalos, una sola tabla (la cabecera del primero)
sub unir_tablas {
    my ($salida, @tablas) = @_;
    open my $out, '>', $salida or return undef;
    my ($filas, $cabecera) = (0, 0);
    for my $t (@tablas) {
        open my $in, '<', $t or next;
        while (my $l = <$in>) {
            if ($l =~ /^#/) { print {$out} $l unless $cabecera; $cabecera = 1; next }
            next unless $l =~ /\S/;
            print {$out} $l; $filas++;
        }
        close $in;
    }
    close $out or return undef;
    return $filas;
}

# ---------------------------------------------------------------------------
# EL RECORRIDO COORDINADO siru-spice (pedido del autor, 09/11/2026: "se puede
# llegar con siru resolviendo la topologia en cada paso y spice avanzando
# mientras las llaves no cambien"). Es el espejo de con_llaves_iterativo, con
# ngspice en lugar de Maxima:
#
#   1. la topologia la resuelve d2datdinc: que llaves hay y, en la
#      configuracion que se le de, que lazos y que cortes;
#   2. dat2cir --llaves escribe el netlist de esa configuracion con las llaves
#      IDEALES --cerrada un corto, abierta el circuito abierto-- y la
#      condicion de cada llave aparte, como una columna 0/1;
#   3. ngspice avanza desde el comienzo del intervalo hasta donde llegue;
#   4. el primer paso en que alguna columna 0/1 cambia es el fin del
#      intervalo: ahi se toma el estado (la tension de cada condensador y la
#      corriente de cada bobina) y se vuelve al punto 1 con la configuracion
#      nueva.
#
# La llave es ideal: su condicion no entra en la ecuacion. Por eso este
# recorrido no necesita RON/ROFF, al contrario del directo (--motor spice).

# la tabla .print de ngspice: cada grupo de columnas tiene su encabezado
# 'Index time ...' y se repite por paginas. Devuelve [[t, v1, v2, ...], ...]
# en orden de indice, o (undef, motivo).
sub leer_tabla_spice {
    my ($archivo) = @_;
    open my $in, '<', $archivo or return (undef, "no pude leer $archivo: $!");
    my (%bloques, %filas, @posiciones);
    my $columnas = 0;
    while (my $l = <$in>) {
        my @c = split ' ', $l;
        if (@c >= 3 && $c[0] eq 'Index' && lc($c[1]) eq 'time') {
            my $firma = join "\t", @c[2 .. $#c];
            $bloques{$firma} //= [map { ++$columnas } @c[2 .. $#c]];
            @posiciones = @{$bloques{$firma}};
            next;
        }
        next unless @posiciones && @c && $c[0] =~ /^\d+$/;
        return (undef, "fila numerica incompleta o invalida en $archivo")
            if @c != @posiciones + 2
            || grep { !/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?$/ } @c[1 .. $#c];
        my ($indice, $tiempo, @valores) = @c;
        my $fila = $filas{$indice} //= [];
        $fila->[0] = $tiempo;
        $fila->[$posiciones[$_]] = $valores[$_] for 0 .. $#posiciones;
    }
    close $in;
    my @indices = sort { $a <=> $b } keys %filas;
    return (undef, "sin tabla transitoria en $archivo") unless @indices;
    my @salida;
    for my $i (@indices) {
        my $f = $filas{$i};
        return (undef, "faltan columnas para el indice $i en $archivo")
            if grep { !defined $f->[$_] } 0 .. $columnas;
        push @salida, [@{$f}[0 .. $columnas]];
    }
    return (\@salida, '');
}

# el contrato de columnas que deja dat2cir en comentarios del netlist
sub columnas_del_cir {
    my ($cir) = @_;
    my %c = (salidas => [], estados => [], llaves => []);
    open my $f, '<', $cir or return undef;
    while (my $l = <$f>) {
        $l =~ /^\*\s*dat2cir\s+(salidas|estados|llaves):\s*(.*\S)/ or next;
        $c{$1} = [split ' ', $2];
    }
    close $f;
    return \%c;
}

# los bits de una fila, en el orden de @llaves: la columna de cada llave vale
# 1 cuando su condicion se cumple (es una fuente de comportamiento, no una
# interpolacion: el valor es exacto en cada paso que ngspice acepto)
sub bits_de_fila {
    my ($fila, $primera_llave, $cuantas) = @_;
    return join '', map { $fila->[$primera_llave + $_] >= 0.5 ? 1 : 0 } 0 .. $cuantas - 1;
}

# los puntos de la malla de un intervalo, interpolando linealmente la tabla de
# ngspice (que trae los pasos que acepto, no la malla). El ultimo punto es el
# final del intervalo, que es donde conmuta la llave.
sub malla_del_intervalo {
    my ($filas, $t0, $tfin, $paso, $cuantas) = @_;
    my @malla;
    my $n = int(($tfin - $t0) / $paso + 1e-9);
    push @malla, $t0 + $_ * $paso for 0 .. $n;
    push @malla, $tfin if abs($malla[-1] - $tfin) > $paso * 1e-9;
    my @salida;
    my $j = 1;
    for my $t (@malla) {
        if (@$filas < 2) { push @salida, [$t, @{$filas->[0]}[1 .. $cuantas]]; next }
        # EL PRIMER PUNTO DE LA MALLA ES EL COMIENZO DEL INTERVALO y ngspice no
        # guarda el instante inicial: su primer renglon ya avanzo un paso
        # chico. Con los dos primeros renglones se extrapola hacia atras (el
        # factor puede quedar negativo), que da el valor del comienzo; truncar
        # en el primer renglon dejaba VC1=0.012 donde vale 0.
        $j++ while $j < $#$filas && $filas->[$j][0] < $t;
        my ($a, $b) = ($filas->[$j - 1], $filas->[$j]);
        my @v;
        if ($b->[0] == $a->[0]) { @v = @{$b}[1 .. $cuantas] }
        else {
            my $f = ($t - $a->[0]) / ($b->[0] - $a->[0]);
            $f = 1 if $f > 1;
            @v = map { $a->[$_] + ($b->[$_] - $a->[$_]) * $f } 1 .. $cuantas;
        }
        push @salida, [$t, @v];
    }
    return @salida;
}

# EL TRASVASE: el trasvase instantaneo de carga o de flujo al entrar en una
# configuracion con lazo de capacitores o corte de bobinas. No hay que
# derivarlo: d2datdinc --llaves --din deja NOMBRE-<bits>E.mdin, que trae las
# restricciones de la topologia nueva mas la conservacion
# (+(qc1 - pre_qc1) +(qc2 - pre_qc2) = 0), y dice en comentarios sus
# parametros --los datos, con su valor-- y la correspondencia
# estado <- pre_estado. Lo resuelve CALCULA en un punto (pedido del autor,
# 09/11/2026: "armalo con calcula"), que es el que resuelve la topologia
# tambien por el camino de siru.
#
# ngspice conoce el estado en volts y amperes; el sistema, en los estados de
# siru. La corriente de una bobina es la misma; la carga de un condensador es
# q = C*V por la ley de la rama, y ese C es uno de los parametros que el
# propio .mdin declara. Las unidades no se tocan aca: si el deck las
# especifica, d2datdinc ya paso todo a MKS --volts y amperes-- al armar el
# dato y el sistema (pedido del autor: "las unidades unicamente se usan si
# estan especificadas en los decks, si lo estan se calcula al mks o V y A
# para spice").
#
# Devuelve (el estado nuevo en nombres de spice, '') o (undef, motivo).
sub trasvase_calcula {
    my ($calcula, $equi, $estado, $tipo_rama) = @_;
    my (%param, %pre, %valor, $sec, $seccion);
    open my $f, '<', $equi or return (undef, "no pude leer $equi: $!");
    while (my $l = <$f>) {
        chomp $l;
        if ($l =~ /^#\s*(parametros|equilibrio)\s*\z/) { $sec = $1; next }
        if ($sec and $l =~ /^#\s{2,}(\S+)\s+(.*\S)\s*\z/) {
            my ($k, $v) = ($1, $2);
            if ($sec eq 'parametros') { $param{$k} = $v } else { $pre{$k} = (split ' ', $v)[0] }
            next;
        }
        $sec = '' if $l !~ /^\s*#/;
        if ($l =~ /^(funciones|variables|ecuaciones|tablas)\s*\z/) { $seccion = $1; next }
        $valor{$1} = $2 if ($seccion // '') eq 'variables' and $l =~ /^\s+(\S+)\s*=\s*(\S+)/;
    }
    close $f;
    return (undef, "$equi no dice sus estados (falta la seccion # equilibrio)") unless %pre;
    my (@datos, %factor, %enspice);
    push @datos, "$_=$param{$_}" for sort keys %param;
    for my $e (sort keys %pre) {
        my ($clase, $rama) = $e =~ /\A([a-z])([a-z]\w*)\z/ ? ($1, uc $2) : ();
        return (undef, "no entiendo el estado $e del equilibrio") unless defined $clase;
        my $nombre = $clase eq 'i' ? "I$rama" : "V$rama";
        # DE QUE RAMA ES EL ESTADO: spice solo tiene la tension de un
        # condensador y la corriente de una bobina. Un estado de otra rama
        # --por ejemplo la carga acumulada de una fuente, que un .dsa puede
        # declarar con ESTADOS: Q-- no tiene con que reanudar el netlist, y
        # tomarle el valor de la rama como si fuera una capacidad daria un
        # numero equivocado en silencio (el parametro de una fuente es su
        # tension). Se dice por nombre.
        my $tipo = $tipo_rama->{$rama} // '';
        my $fac = 1;
        if ($clase eq 'q' or $clase eq 'v') {
            return (undef, "el estado $e es de $rama, que es "
                         . ($tipo ? "de tipo $tipo" : "una rama que no conozco")
                         . ": por este camino el estado tiene que ser de un condensador")
                unless $tipo =~ /\AC/;
        } elsif ($clase eq 'i') {
            return (undef, "el estado $e es la corriente de $rama, que es "
                         . ($tipo ? "de tipo $tipo" : "una rama que no conozco")
                         . ": por este camino el estado tiene que ser de una bobina")
                unless $tipo =~ /\AL/;
        } else {
            return (undef, "el estado $e no es carga, tension ni corriente: no se pasarlo a spice");
        }
        if ($clase eq 'q') {
            # la carga: q = C*V, con el C que el equilibrio declara como parametro
            my $c = $param{lc $rama};
            return (undef, "el estado $e es una carga y el equilibrio no da el valor de $rama")
                unless defined $c and $c =~ /\A[-+]?[\d.]/ and $c + 0 != 0;
            $fac = $c + 0;
        }
        $factor{$e} = $fac; $enspice{$e} = $nombre;
        # SIN ESTADO DE SPICE --el primer intervalo-- vale el del .mdin, que es
        # el que trae el DU; es lo mismo que hace din2mac --equilibrio
        my $antes = defined $estado->{$nombre} ? $estado->{$nombre} * $fac
                  : $valor{$pre{$e}} // 0;
        push @datos, "$pre{$e}=$antes";
    }
    my ($est, $dijo) = correr_capturando("$calcula -m modulodinamico --dinamico='$equi'"
                                       . " -p '" . join(',', @datos) . "'");
    return (undef, "calcula no pudo resolver $equi") if $est == -1 or $est >> 8;
    my %nuevo;
    for my $l (@$dijo) {
        # 'qc1   1' ; los datos llevan '(dato)' atras y no son la respuesta
        next unless $l =~ /\A\s*(\w+)\s+([-+0-9.eE]+)\s*\z/;
        my ($k, $v) = ($1, $2);
        next unless exists $pre{$k};
        $nuevo{$enspice{$k}} = $v / $factor{$k};
    }
    return (undef, "calcula no dio " . join(' ', sort keys %pre) . " al resolver $equi")
        if keys(%nuevo) != keys(%pre);
    return (\%nuevo, '');
}

sub motor_siru_spice {
    my ($base, $ext) = @_;
    my $ngspice = buscar_programa('ngspice', 'NGSPICE');
    unless ($ngspice) { print "lanzador: ngspice no esta instalado\n"; cerrar_log(); return 3 }
    my $dat2cir = File::Spec->catfile($RealBin, 'dat2cir');
    unless (-x $dat2cir) { print "lanzador: falta $dat2cir\n"; cerrar_log(); return 3 }
    # Calcula solo hace falta si alguna configuracion necesita el trasvase
    # (lazo de capacitores o corte de bobinas): se busca ahora y se reclama
    # recien cuando aparece, para no pedirlo a un circuito que no lo usa.
    my $calcula = buscar_programa('calcula', 'CALCULA', '../calcula/calcula-6.0/src/calcula');
    mensajear(" motor: siru-spice, $ngspice (la topologia se resuelve por intervalo"
            . " y ngspice avanza mientras las llaves no cambien)");
    if ($ext eq 'cir') {
        mensajear(" un .cir no trae llaves con condicion: use --motor spice");
        cerrar_log(); return 3;
    }
    my $SUB = 'siru-spice';
    -d $SUB or mkdir $SUB or avgrav_simple("no pude crear $SUB/: $!");
    my $fuente = "$base.$ext";
    unlink "$SUB/$fuente";
    link($fuente, "$SUB/$fuente") or symlink(File::Spec->rel2abs($fuente), "$SUB/$fuente");
    my $du = '';
    if ($ext eq 'dsa') {
        (my $b = $base) =~ s/\.M\z//;
        $du = "$b.DU.dsa";
        unless (-f $du) { mensajear(" falta $du: un .M.dsa necesita sus DATOS y USOS"); cerrar_log(); return 2 }
        unlink "$SUB/$du";
        link($du, "$SUB/$du") or symlink(File::Spec->rel2abs($du), "$SUB/$du");
    }
    if ($ensayo) { mensajear(" ensayo: no se corre ngspice"); cerrar_log(); return 0 }
    cambiar_directorio($SUB) or return 4;
    (my $nombre = $base) =~ s/\.M\z//;
    unlink "$nombre.dat", "$base.tabla", "$base.simul", "$base.horario";

    # ---- 1. d2datdinc: el dato, de donde sale TODO lo que este recorrido
    # necesita --los tiempos, la topologia y el netlist--. dat2cir lee el mismo
    # .dat, asi que el camino de SPICE no depende de que formato tenia el
    # archivo (un .M.dsa o un .d) y no hay ningun intermedio.
    comfin("com preparar");
    my $d2d = $ENV{D2DATDINC} // 'd2datdinc';
    my $raiz = $RealBin . '/../..';
    $d2d = "$raiz/slex/d2datdinc/d2datdinc" if $d2d eq 'd2datdinc' and -x "$raiz/slex/d2datdinc/d2datdinc";
    my $conf = $ENV{D2DATDINC_CONF} // "$raiz/slex/d2datdinc/d2datdinc.slex";
    my $bib  = $ENV{D2DATDINC_BIB}  // "$raiz/slex/d2datdinc/biblioteca";
    my @opc;
    push @opc, "-c $conf" if -f $conf;
    push @opc, "-b $bib"  if -d $bib;
    my ($ed, $dd) = correr_capturando("$d2d @opc $fuente --dat -o $nombre.dat");
    unless (-f "$nombre.dat") {
        my ($err) = grep { /\S/ } reverse @{ $dd // [] };
        mensajear(" POR QUE TERMINO: no se pudo preparar el .dat de $fuente"
                . (defined $err ? ": $err" : ''));
        cerrar_log(); return 2;
    }
    my $deck = "$nombre.dat";
    my @llaves = llaves_del_circuito($d2d, \@opc, "$nombre.dat");
    # EL TIPO DE CADA RAMA, del dato: lo necesita el trasvase para saber si un
    # estado del sistema es de un condensador (CB, CINC) o de una bobina (LB),
    # que son los dos que spice sabe reanudar
    my %tipo_rama;
    if (open my $f, '<', "$nombre.dat") {
        local $/; my $texto = <$f>; close $f;
        my $g = eval { decode_json($texto)->{GLOBAL} };
        my $r = $g ? $g->{ramas} : undef;
        if (ref $r eq 'HASH') {
            $tipo_rama{uc $_} = $r->{$_}{tipo} // '' for keys %$r;
        }
    }

    # ---- 2. la ventana y la malla: igual que el camino de Maxima, del dato
    my ($t0, $tf) = ('0', undef);
    my $paso_dat;
    if (open my $f, '<', "$nombre.dat") {
        local $/; my $texto = <$f>; close $f;
        $t0 = $1 if $texto =~ /"T"\s*:\s*\{\s*"value"\s*:\s*"?([-\d.eE+]+)"?/;
        $tf = $1 if $texto =~ /"TIEMPOFINAL"\s*:\s*\{\s*"value"\s*:\s*"?([-\d.eE+]+)"?/;
        $paso_dat = $1 if $texto =~ /"SIRU_PASO"\s*:\s*\{\s*"value"\s*:\s*\[\s*([-\d.eE+]+)/;
    }
    $tf //= tiempo_final_del_du($du, "$nombre.dat");
    unless (defined $tf) {
        mensajear(" POR QUE TERMINO: no se sabe hasta cuando correr (falta TIEMPOFINAL o la parada T<N)");
        cerrar_log(); return 2;
    }
    my ($t0_f, $tf_f) = (eval($t0) // 0, eval($tf) // 0);
    unless ($tf_f > $t0_f) {
        mensajear(" POR QUE TERMINO: la corrida va de $t0 a $tf, que no avanza");
        cerrar_log(); return 2;
    }
    my $paso = defined $paso_opt ? $paso_opt + 0
             : defined $puntos_opt && $puntos_opt > 0 ? ($tf_f - $t0_f) / $puntos_opt
             : defined $paso_dat ? $paso_dat + 0
             : ($tf_f - $t0_f) / 300;
    unless ($paso > 0) {
        mensajear(" POR QUE TERMINO: el paso de la malla tiene que ser positivo, no $paso");
        cerrar_log(); return 2;
    }
    mensajear(@llaves ? " llaves (" . join(' ', @llaves) . "): una configuracion por intervalo,"
                      . " conmutando en el paso en que la condicion cambia, como siru"
                      : " el circuito no tiene llaves: un solo intervalo");
    mensajear(" malla de a $paso, de $t0 a $tf");

    # ---- 3. los intervalos
    comfin("com correr");
    my %estado;
    my (@filas_todas, @horario, @nombres_salida);
    my ($salida, @porque) = (0);
    my %bits = map { $_ => 0 } @llaves;
    my ($nro, $tope) = (0, 200);
    my $desde = $t0_f;
    INTERVALO: while (1) {
        if ($nro > $tope) { push @porque, "mas de $tope intervalos: me detengo"; $salida = 3; last }
        my (%visto, %trial, $filas, $col, $resuelto, $corte, $bits_corte, $k);
        ESTABLE: while (1) {
            my $cuales = join(',', map { "$_=$bits{$_}" } @llaves);
            if (@llaves and $visto{$cuales}++) {
                push @porque, "en T=$desde ninguna configuracion es estable (ciclo entre llaves)";
                $salida = 3; last INTERVALO;
            }
            # EL TRASVASE AL ENTRAR en esta configuracion, sobre una copia:
            # si resulta inestable se descarta sin tocar el estado. Igual que
            # con_llaves_iterativo por el camino de Maxima.
            %trial = %estado;
            if (@llaves) {
                my @top = split /\n/, `$d2d @opc $nombre.dat --llaves $cuales --topologia 2>&1 </dev/null`;
                al_log("   $_") for @top;
                my ($lazos)  = map { /^lazos\s+(.*\S)/  ? $1 : () } @top;
                my ($cortes) = map { /^cortes\s+(.*\S)/ ? $1 : () } @top;
                if ($lazos or $cortes) {
                    unless ($calcula) {
                        push @porque, "la configuracion $cuales necesita el trasvase"
                            . " (lazos o cortes) y calcula no esta instalado"
                            . " (ni en el PATH ni en CALCULA=)";
                        $salida = 3; last INTERVALO;
                    }
                    my ($mdin, $btxt) = configuracion_llaves($d2d, \@opc, "$nombre.dat",
                                                             $nombre, $cuales, \@llaves);
                    my $equi = "$nombre-${btxt}E.mdin";
                    unless ($mdin and -f $equi) {
                        push @porque, "la configuracion $cuales tiene "
                            . join(' y ', ($lazos ? "lazos de capacitores ($lazos)" : ()),
                                          ($cortes ? "cortes de bobinas ($cortes)" : ()))
                            . " y no se pudo armar su sistema de equilibrio ($equi)";
                        $salida = 2; last INTERVALO;
                    }
                    my ($nuevo, $motivo) = trasvase_calcula($calcula, $equi, \%trial,
                                                           \%tipo_rama);
                    unless ($nuevo) {
                        push @porque, "no se pudo resolver el trasvase de la configuracion"
                                    . " $cuales en T=$desde: $motivo";
                        $salida = 3; last INTERVALO;
                    }
                    %trial = (%trial, %$nuevo);
                    mensajear(" T=$desde: trasvase de la configuracion $cuales por "
                            . join(' y ', ($lazos ? "lazo de capacitores ($lazos)" : ()),
                                          ($cortes ? "corte de bobinas ($cortes)" : ()))
                            . ": " . join(', ', map { "$_=$nuevo->{$_}" } sort keys %$nuevo));
                }
            }
            my @datos = map { "--estado '$_=$trial{$_}'" } sort keys %trial;
            my $cir = "$base-i$nro.cir";
            unlink $cir;
            # --llaves VA SIEMPRE, aunque el circuito no tenga ninguna: es lo
            # que le dice a dat2cir que escriba el contrato de columnas (las
            # salidas, los estados y las llaves) y que corra el intervalo con
            # origen en 0. Sin llaves la lista va vacia y el intervalo es uno.
            my ($ec, $dc) = correr_capturando("perl $dat2cir --llaves '$cuales'"
                . " --desde '$desde' --hasta '$tf' --paso '$paso' @datos '$deck' '$cir'");
            if ($ec == -1 or $ec >> 8 or not -s $cir) {
                my ($err) = grep { /\S/ } reverse @{ $dc // [] };
                push @porque, "dat2cir no pudo escribir el netlist del intervalo $nro"
                            . (defined $err ? ": $err" : '');
                $salida = 2; last INTERVALO;
            }
            $col = columnas_del_cir($cir);
            unlink "$base-i$nro.out", "$base-i$nro.err";
            system("$ngspice -b $cir > $base-i$nro.out 2> $base-i$nro.err </dev/null");
            my @errores;
            for my $f ("$base-i$nro.err", "$base-i$nro.out") {
                open my $fh, '<', $f or next;
                while (my $l = <$fh>) { chomp $l; push @errores, $l if $l =~ /^\s*Error/i }
                close $fh;
            }
            if (@errores) {
                mensajear(" ngspice: $_") for @errores;
                push @porque, "ngspice rechazo el netlist del intervalo $nro: $errores[0]";
                $salida = 2; last INTERVALO;
            }
            my $motivo;
            ($filas, $motivo) = leer_tabla_spice("$base-i$nro.out");
            unless ($filas) {
                push @porque, "el intervalo $nro no dejo tabla: $motivo";
                $salida = 7; last INTERVALO;
            }
            # EL INTERVALO CORRE CON ORIGEN EN 0 (ngspice simula siempre desde
            # 0; el TSTART de .tran solo dice desde cuando guarda), asi que
            # los tiempos de la tabla se corren al comienzo del intervalo.
            $_->[0] += $desde for @$filas;
            my $ns = scalar @{$col->{salidas}};
            my $ne = scalar @{$col->{estados}};
            my $primera = 1 + $ns + $ne;
            if (@{$filas->[0]} != $primera + scalar(@{$col->{llaves}})) {
                push @porque, "el intervalo $nro trajo " . (scalar(@{$filas->[0]}) - 1)
                            . " columnas y el netlist pide " . ($primera - 1 + scalar(@{$col->{llaves}}));
                $salida = 7; last INTERVALO;
            }
            # LA ESTABILIDAD SOLO EN EL ARRANQUE, donde nadie decidio todavia:
            # en una frontera la decision la tomo el intervalo anterior y vale
            # al menos un paso, igual que en siru y en el camino de Maxima.
            if ($nro == 0 and @llaves) {
                my $b0 = bits_de_fila($filas->[0], $primera, scalar @llaves);
                my $asumidos = join '', map { $bits{$_} } @llaves;
                if ($b0 ne $asumidos) {
                    mensajear(" T=$desde: la configuracion $cuales no es estable (las condiciones"
                            . " dan $b0): se prueba esa");
                    @bits{@llaves} = split //, $b0;
                    next ESTABLE;
                }
            }
            $resuelto = 1;
            last ESTABLE;
        }
        last INTERVALO unless $resuelto;
        # la configuracion quedo firme: el estado del trasvase es el estado
        %estado = %trial;
        my $ns = scalar @{$col->{salidas}};
        my $ne = scalar @{$col->{estados}};
        my $primera = 1 + $ns + $ne;
        @nombres_salida = @{$col->{salidas}} unless @nombres_salida;
        my $asumidos = join '', map { $bits{$_} } @llaves;
        if (@llaves) {
            # LA CONFIGURACION VALE AL MENOS UN PASO DE LA MALLA: la condicion
            # se evalua al comenzar cada paso, que es la regla de siru
            # (GRAMATICA.md). Sin esto el corte caia en el primer paso que
            # ngspice acepta --unos 2e-4, su paso de arranque-- y una llave que
            # vuelve a conmutar enseguida (llave-corriente-bobina: al abrir, el
            # trasvase iguala las corrientes y la condicion se cumple de nuevo)
            # picaba a la cadencia interna de ngspice y no a la de la malla.
            my $minimo = $desde + $paso * (1 - 1e-9);
            for my $i (1 .. $#$filas) {
                next if $filas->[$i][0] < $minimo;
                next if bits_de_fila($filas->[$i], $primera, scalar @llaves) eq $asumidos;
                $k = $i; last;
            }
        }
        my $hasta_f = defined $k ? $filas->[$k][0] + 0 : $tf_f;
        $bits_corte = defined $k ? bits_de_fila($filas->[$k], $primera, scalar @llaves) : undef;
        push @horario, { nro => $nro, desde => $desde, hasta => $hasta_f,
                         llaves => join(',', map { "$_=$bits{$_}" } @llaves) };
        mensajear(" intervalo $nro: de $desde a $hasta_f"
                . (@llaves ? " con " . $horario[-1]{llaves} : ''));
        push @filas_todas, malla_del_intervalo($filas, $desde, $hasta_f, $paso, $ns);
        if (defined $k) {
            # el estado al conmutar: la tension de cada condensador y la
            # corriente de cada bobina en ese paso, que es con lo que arranca
            # la configuracion nueva
            my @nombres = @{$col->{estados}};
            $estado{$nombres[$_]} = $filas->[$k][1 + $ns + $_] for 0 .. $#nombres;
            @bits{@llaves} = split //, $bits_corte;
            $desde = $hasta_f;
            $nro++;
            next INTERVALO;
        }
        push @porque, "Termino la corrida (ngspice por intervalos, " . scalar(@horario)
                    . " intervalo" . (@horario == 1 ? '' : 's') . ")";
        last INTERVALO;
    }
    comfin("fin correr " . scalar(@horario));

    # ---- 4. el horario y la tabla
    if (@horario and open my $h, '>', "$base.horario") {
        print {$h} "#   $base.horario: los intervalos del recorrido coordinado siru-spice.\n",
                   "#   La topologia se resuelve por intervalo y ngspice avanza mientras\n",
                   "#   las llaves no cambian; el intervalo termina en el paso en que\n",
                   "#   alguna condicion cambia de valor.\n";
        print {$h} "intervalo $_->{nro} | $_->{desde} | $_->{hasta} | $_->{llaves}\n" for @horario;
        close $h;
    }
    if (@filas_todas and @nombres_salida) {
        if (open my $t, '>', "$base.tabla") {
            print {$t} '# TIME ' . join(' ', @nombres_salida) . "\n";
            print {$t} join(' ', map { sprintf '%.17g', $_ } @$_), "\n" for @filas_todas;
            close $t;
        }
        my $hechas = tabla_a_simul("$base.tabla", "$base.simul", $base,
            ["#   Archivo $base.simul; producido por ngspice por intervalos (lanzador --motor siru-spice)",
             "#   La topologia la resuelve d2datdinc en cada intervalo y ngspice avanza",
             "#   mientras las llaves no cambian; la malla se interpola de los pasos que",
             "#   ngspice acepto."]);
        if (defined $hechas) {
            unshift @porque, "$hechas filas en $base.simul";
        } else {
            avgrav_simple("no pude escribir $base.simul desde $base.tabla");
            $salida ||= 7;
        }
    } elsif (!$salida) {
        push @porque, "la corrida no dejo tabla numerica"; $salida = 7;
    }
    mensajear(" POR QUE TERMINO: " . join(', ', @porque));
    traer_salidas($base, qw(simul tabla horario dat ds));
    cerrar_log();
    return $salida;
}

sub con_llaves {
    my ($base, $nombre, $entrada, $d2d, $opc, $din2mac, $maxima, $llaves, $opc_corrida) = @_;
    $opc_corrida //= '';
    my $listado = "$base.maxima.log";
    mensajear(" el circuito tiene llaves (" . join(' ', @$llaves) . "): una configuracion"
            . " por intervalo, conmutando al comenzar el paso de la malla,"
            . " como siru");
    # el .dat es la entrada de cada configuracion, y de ahi sale el tiempo final
    my $dat = $entrada =~ /\.dat\z/i ? $entrada : "$nombre.dat";
    unless (-f $dat) {
        correr_capturando("$d2d @$opc $entrada --dat -o $dat");
        unless (-f $dat) {
            mensajear(" POR QUE TERMINO: no se pudo preparar el .dat de $entrada");
            cerrar_log(); return 2;
        }
    }

    # ---- 1. el horario: cualquier configuracion trae las condiciones de
    # todas las llaves, asi que se pide la de todas abiertas para leerlas
    comfin("com horario");
    my $abiertas = join(',', map { "$_=0" } @$llaves);
    my ($mdin0, $bits0) = configuracion_llaves($d2d, $opc, $dat, $nombre, $abiertas, $llaves);
    unless ($mdin0) {
        mensajear(" POR QUE TERMINO: no se pudo armar el sistema de la configuracion $bits0");
        cerrar_log(); return 2;
    }
    my ($ep, $dp) = correr_capturando("$din2mac --dat $dat$opc_corrida --horario $base.horario"
                                    . " $mdin0 $base-horario.mac");
    if (($ep >> 8) or not -f "$base-horario.mac") {
        my $motivo = join('; ', grep { /^din2mac:/ } @{ $dp // [] }) || 'no se pudo leer las condiciones de las llaves';
        $motivo =~ s/^din2mac:\s*//;
        # Una condicion que depende del estado no permite el horario de
        # antemano: se calcula INTERVALO POR INTERVALO, armando el modelo de
        # cada configuracion cuando aparece (pedido del autor, 08/11/2026).
        if ($motivo =~ /depende de .* variable del circuito/) {
            return con_llaves_iterativo($base, $nombre, $dat, $d2d, $opc,
                $din2mac, $maxima, $llaves, $opc_corrida, $listado);
        }
        mensajear(" POR QUE TERMINO: $motivo");
        traer_salidas($base, qw(dat)); cerrar_log(); return 3;
    }
    my ($eh, $lh) = correr_un_mac($maxima, "$base-horario.mac", $listado);
    if ($eh == -1) { avgrav_simple("no pude ejecutar $maxima: $!"); cerrar_log(); return 5 }
    my @intervalos;
    if (open my $h, '<', "$base.horario") {
        while (my $l = <$h>) {
            next unless $l =~ /^intervalo\s/;
            chomp $l;
            my @c = split /\s*\|\s*/, $l;
            next unless @c >= 6;
            my ($nro) = $c[0] =~ /(\d+)/;
            push @intervalos, { nro => $nro // scalar(@intervalos),
                                desde => $c[1], hasta => $c[2],
                                desde_n => $c[3] + 0, hasta_n => $c[4] + 0,
                                llaves => $c[5] };
        }
        close $h;
    }
    comfin("fin horario " . scalar(@intervalos));
    unless (@intervalos) {
        my $motivo = $lh =~ /sin solucion analitica;\s*(.*)/ ? $1
                   : 'no se pudo resolver el horario de las llaves';
        mensajear(" POR QUE TERMINO: $motivo");
        traer_salidas($base, qw(horario dat), "=$listado"); cerrar_log(); return 3;
    }
    mensajear(sprintf(" intervalo %d: de %s a %s con %s",
                      $_->{nro}, $_->{desde}, $_->{hasta}, $_->{llaves})) for @intervalos;

    # ---- 2. intervalo por intervalo, con los estados del anterior
    comfin("com correr");
    my (%estado, @tablas, @analiticas);
    my ($salida, @porque) = (0);
    for my $iv (@intervalos) {
        my $i = $iv->{nro};
        my ($mdin, $bits) = configuracion_llaves($d2d, $opc, $dat, $nombre, $iv->{llaves}, $llaves);
        unless ($mdin) {
            push @porque, "no se pudo armar el sistema de la configuracion $bits";
            $salida = 2; last;
        }
        # el trasvase instantaneo de carga o de flujo, si esta configuracion
        # lo necesita (lazo de capacitores o corte de bobinas)
        my $equi = "$nombre-${bits}E.mdin";
        if (-f $equi) {
            my $arch = "$base-i$i.equilibrio";
            my @datos = map { "--estado 'pre_$_=$estado{$_}'" } sort keys %estado;
            my ($e1, $d1) = correr_capturando("$din2mac --equilibrio $arch @datos"
                                            . " $equi $base-i$i-equilibrio.mac");
            if (not($e1 >> 8) and -f "$base-i$i-equilibrio.mac") {
                my ($e2, $l2) = correr_un_mac($maxima, "$base-i$i-equilibrio.mac", $listado);
                if ($e2 == -1) { avgrav_simple("no pude ejecutar $maxima: $!"); cerrar_log(); return 5 }
            }
            my %nuevo = -f $arch ? leer_estados($arch) : ();
            if (%nuevo) {
                %estado = (%estado, %nuevo);
                mensajear(" T=$iv->{desde}: el trasvase de la configuracion $bits"
                        . " (" . join(', ', sort keys %nuevo) . ")");
            } else {
                push @porque, "no se pudo resolver el trasvase de la configuracion $bits en T=$iv->{desde}";
                $salida = 3; last;
            }
        }
        my @datos = map { "--estado '$_=$estado{$_}'" } sort keys %estado;
        my ($e3, $d3) = correr_capturando("$din2mac --dat $dat$opc_corrida --t0 '$iv->{desde}'"
            . " --fin '$iv->{hasta}' @datos --estados-fin $base-i$i.estados"
            . " $mdin $base-i$i.mac");
        if (($e3 >> 8) or not -f "$base-i$i.mac") {
            my $motivo = join('; ', grep { /^din2mac:/ } @{ $d3 // [] }) || 'el sistema no se puede llevar a Maxima';
            $motivo =~ s/^din2mac:\s*//;
            push @porque, "$motivo (intervalo $i, llaves $iv->{llaves})";
            $salida = 3; last;
        }
        my ($e4, $l4) = correr_un_mac($maxima, "$base-i$i.mac", $listado);
        if ($e4 == -1) { avgrav_simple("no pude ejecutar $maxima: $!"); cerrar_log(); return 5 }
        if ($l4 =~ /sin solucion analitica;\s*(.*)/) {
            push @porque, "No hay solucion analitica (maxima) en el intervalo $i"
                        . " (de $iv->{desde} a $iv->{hasta}, llaves $iv->{llaves}): $1";
            $salida = 3; last;
        }
        unless ($l4 =~ /resuelto/) {
            push @porque, "maxima no termino el intervalo $i (estado " . ($e4 >> 8) . ")";
            $salida = 2; last;
        }
        push @tablas, "$base-i$i.tabla" if -f "$base-i$i.tabla";
        push @analiticas, [$iv, "$base-i$i.analitica"];
        %estado = (%estado, leer_estados("$base-i$i.estados")) if -f "$base-i$i.estados";
    }
    comfin("fin correr " . scalar(@tablas));

    # ---- 3. la solucion de toda la corrida: la de cada intervalo, en orden
    if (@analiticas) {
        if (open my $a, '>', "$base.analitica") {
            print {$a} "#   $base.analitica: la solucion analitica por intervalos (maxima).\n",
                        "#   El circuito tiene llaves (", join(' ', @$llaves), "): cada intervalo\n",
                        "#   es una configuracion, y la conmutacion cae al comenzar un paso\n",
                        "#   de la malla, que es donde siru evalua la condicion de la llave.\n";
            for my $par (@analiticas) {
                my ($iv, $arch) = @$par;
                print {$a} "\n# intervalo $iv->{nro}: de $iv->{desde} a $iv->{hasta},"
                         . " llaves $iv->{llaves} (t es el tiempo del intervalo)\n";
                if (open my $in, '<', $arch) {
                    while (my $l = <$in>) { next if $l =~ /^#/; print {$a} $l }
                    close $in;
                }
            }
            close $a;
        }
    }
    if (@tablas) {
        my $filas = unir_tablas("$base.tabla", @tablas);
        if (defined $filas) {
            my $hechas = tabla_a_simul("$base.tabla", "$base.simul", $base);
            if (defined $hechas) {
                unshift @porque, ($salida ? "Lo que se pudo resolver" : "Termino la solucion analitica (maxima)")
                               . ", " . scalar(@tablas) . " de " . scalar(@intervalos)
                               . " intervalos, $hechas filas";
            } else {
                avgrav_simple("no pude escribir $base.simul desde $base.tabla");
                $salida ||= 7;
            }
        }
    }
    mensajear(" POR QUE TERMINO: " . join(', ', @porque)) if @porque;
    traer_salidas($base, qw(analitica simul tabla horario dat), "=$listado");
    cerrar_log();
    return $salida;
}

# ---- las llaves cuya condicion depende del estado: intervalo por intervalo
# El horario no se puede calcular de antemano --para saber donde termina un
# intervalo hay que haberlo resuelto--, asi que maxima ARMA EL MODELO DE CADA
# CONFIGURACION CUANDO APARECE (pedido del autor, 08/11/2026): corre el
# intervalo con sus bits, din2mac --vigilar evalua las condiciones sobre la
# formula cerrada en cada punto de la malla, y donde los bits difieren corta
# y dice con que configuracion sigue. Al entrar en cada configuracion, el
# mismo trasvase instantaneo que en el camino del horario fijo; y en cada
# frontera se verifica que la configuracion sea estable (BITS0): si al
# resolverla las condiciones dan otra, se prueba esa, y un ciclo se informa.
sub bits_como_hash { my %h = map { my ($r,$v) = split /=/, $_, 2; (uc $r, $v) } split /,/, $_[0]; return %h }
sub con_llaves_iterativo {
    my ($base, $nombre, $dat, $d2d, $opc, $din2mac, $maxima, $llaves, $opc_corrida, $listado) = @_;
    mensajear(" la condicion de una llave depende del estado: el horario se calcula"
            . " intervalo por intervalo, armando el modelo de cada configuracion"
            . " cuando aparece");
    # el comienzo y el final de la corrida, del .dat (como hace din2mac)
    my ($t0, $tf) = ('0', undef);
    if (open my $d, '<', $dat) {
        local $/; my $texto = <$d>; close $d;
        $t0 = $1 if $texto =~ /"T"\s*:\s*\{\s*"value"\s*:\s*"?([-\d.eE+]+)"?/;
        $tf = $1 if $texto =~ /"TIEMPOFINAL"\s*:\s*\{\s*"value"\s*:\s*"?([-\d.eE+]+)"?/;
    }
    $tf = $1 if $opc_corrida =~ /--hasta\s+(\S+)/;
    my $t0_f = eval($t0) // 0;
    my %estado;
    my (@tablas, @analiticas, @horario);
    my ($salida, @porque) = (0);
    my $bits = join(',', map { "$_=0" } @$llaves);   # semilla: todas abiertas
    my ($nro, $tope) = (0, 200);
    INTERVALO: while (1) {
        if ($nro > $tope) { push @porque, "mas de $tope intervalos: me detengo"; $salida = 3; last }
        my (%visto, $corte, $corte_f, $corte_bits, $paro, %trial, $resuelto);
        ESTABLE: while (1) {
            if ($visto{ join(',', map { "$_=" . {bits_como_hash($bits)}->{$_} } sort @$llaves) }++) {
                push @porque, "en T=$t0 ninguna configuracion es estable (ciclo entre llaves)";
                $salida = 3; last INTERVALO;
            }
            my ($mdin, $b) = configuracion_llaves($d2d, $opc, $dat, $nombre, $bits, $llaves);
            unless ($mdin) {
                push @porque, "no se pudo armar el sistema de la configuracion $b";
                $salida = 2; last INTERVALO;
            }
            # el trasvase al ENTRAR en esta configuracion, sobre una copia:
            # si la configuracion resulta inestable se descarta sin tocar nada
            %trial = %estado;
            my $equi = "$nombre-${b}E.mdin";
            if (-f $equi) {
                my $arch = "$base-i$nro.equilibrio";
                my @datos = map { "--estado 'pre_$_=$trial{$_}'" } sort keys %trial;
                my ($e1, $d1) = correr_capturando("$din2mac --equilibrio $arch @datos"
                                                . " $equi $base-i$nro-equilibrio.mac");
                if (not($e1 >> 8) and -f "$base-i$nro-equilibrio.mac") {
                    my ($e2, $l2) = correr_un_mac($maxima, "$base-i$nro-equilibrio.mac", $listado);
                    if ($e2 == -1) { avgrav_simple("no pude ejecutar $maxima: $!"); cerrar_log(); return 5 }
                }
                my %nuevo = -f $arch ? leer_estados($arch) : ();
                unless (%nuevo) {
                    push @porque, "no se pudo resolver el trasvase de la configuracion $b en T=$t0";
                    $salida = 3; last INTERVALO;
                }
                %trial = (%trial, %nuevo);
            }
            my @datos = map { "--estado '$_=$trial{$_}'" } sort keys %trial;
            my ($e3, $d3) = correr_capturando("$din2mac --dat $dat$opc_corrida --t0 '$t0'"
                . " @datos --estados-fin $base-i$nro.estados --vigilar '$bits'"
                . " $mdin $base-i$nro.mac");
            if (($e3 >> 8) or not -f "$base-i$nro.mac") {
                my $motivo = join('; ', grep { /^din2mac:/ } @{ $d3 // [] }) || 'el sistema no se puede llevar a Maxima';
                $motivo =~ s/^din2mac:\s*//;
                push @porque, "$motivo (intervalo $nro, llaves $bits)";
                $salida = 3; last INTERVALO;
            }
            my ($e4, $l4, $din2mac_dijo) = correr_un_mac($maxima, "$base-i$nro.mac", $listado);
            if ($e4 == -1) { avgrav_simple("no pude ejecutar $maxima: $!"); cerrar_log(); return 5 }
            $l4 = $din2mac_dijo if ($din2mac_dijo // '') =~ /^DIN2MAC /m;
            if ($l4 =~ /sin solucion analitica;\s*(.*)/) {
                push @porque, "No hay solucion analitica (maxima) en el intervalo $nro"
                            . " (desde $t0, llaves $bits): $1";
                $salida = 3; last INTERVALO;
            }
            unless ($l4 =~ /resuelto/) {
                push @porque, "maxima no termino el intervalo $nro (estado " . ($e4 >> 8) . ")";
                $salida = 2; last INTERVALO;
            }
            # la configuracion es estable si los bits al comenzar son los asumidos
            my ($bits0) = $l4 =~ /DIN2MAC BITS0:\s*(\S+)/;
            unless (defined $bits0) {
                push @porque, "din2mac no dijo los bits al comenzar (intervalo $nro, llaves $bits)";
                $salida = 2; last INTERVALO;
            }
            # La estabilidad solo se busca en el ARRANQUE, donde nadie decidio
            # todavia. En una frontera la decision ya la tomo el paso anterior
            # --la condicion se evalua al comenzar cada paso, como siru-- y la
            # configuracion nueva vale al menos ese paso: si el trasvase deja
            # la condicion del otro lado, la vigilancia conmuta de nuevo en el
            # paso siguiente, que es exactamente el ciclo que hace siru.
            if ($nro == 0) {
                my %b0 = bits_como_hash($bits0);
                my %asumidos = bits_como_hash($bits);
                if (grep { ($b0{$_} // '?') ne $asumidos{$_} } keys %asumidos) {
                    mensajear(" T=$t0: la configuracion $bits no es estable (las condiciones dan"
                            . " $bits0): se prueba esa");
                    $bits = $bits0;
                    next ESTABLE;
                }
            }
            ($corte, $corte_f, $corte_bits) = $l4 =~ /DIN2MAC CONMUTA:\s*(\S+)\s*\|\s*(\S+)\s*\|\s*(\S+)/;
            ($paro) = $l4 =~ /DIN2MAC PARA:\s*(\S+)/ unless defined $corte;
            $resuelto = 1;
            last ESTABLE;
        }
        last INTERVALO unless $resuelto;
        %estado = %trial;
        my $hasta   = $corte // $paro // (defined $tf ? $tf : '?');
        my $hasta_f = defined $corte_f ? $corte_f + 0 : eval($hasta) // $hasta;
        push @horario, { nro => $nro, desde => $t0, hasta => $hasta,
                         desde_f => $t0_f, hasta_f => $hasta_f, llaves => $bits };
        mensajear(" intervalo $nro: de $t0 a $hasta con $bits");
        push @tablas, "$base-i$nro.tabla" if -f "$base-i$nro.tabla";
        push @analiticas, [$horario[-1], "$base-i$nro.analitica"];
        %estado = (%estado, leer_estados("$base-i$nro.estados")) if -f "$base-i$nro.estados";
        if (defined $paro) { push @porque, "una condicion de parada corto la corrida en T=$paro"; last }
        last unless defined $corte;
        ($t0, $t0_f, $bits) = ($corte, $corte_f + 0, $corte_bits);
        $nro++;
    }
    comfin("fin correr " . scalar(@tablas));

    # el horario, como lo escribe el camino del horario fijo
    if (@horario and open my $h, '>', "$base.horario") {
        print {$h} "# horario de las llaves, calculado INTERVALO POR INTERVALO (la condicion\n",
                   "# depende del estado): la condicion se evalua al comenzar cada paso de la\n",
                   "# malla sobre la formula cerrada del intervalo\n",
                   "# intervalo NRO | desde | hasta | desde (numero) | hasta (numero) | llaves\n";
        printf {$h} "intervalo %d | %s | %s | %s | %s | %s\n",
            @{$_}{qw(nro desde hasta desde_f hasta_f llaves)} for @horario;
        close $h;
    }
    if (@analiticas) {
        if (open my $a, '>', "$base.analitica") {
            print {$a} "#   $base.analitica: la solucion analitica por intervalos (maxima).\n",
                        "#   La condicion de una llave depende del estado: el modelo de cada\n",
                        "#   configuracion se arma cuando aparece, y la conmutacion cae al\n",
                        "#   comenzar un paso de la malla, evaluada sobre la formula cerrada.\n";
            for my $par (@analiticas) {
                my ($iv, $arch) = @$par;
                print {$a} "\n# intervalo $iv->{nro}: de $iv->{desde} a $iv->{hasta},"
                         . " llaves $iv->{llaves} (t es el tiempo del intervalo)\n";
                if (open my $in, '<', $arch) {
                    while (my $l = <$in>) { next if $l =~ /^#/; print {$a} $l }
                    close $in;
                }
            }
            close $a;
        }
    }
    if (@tablas) {
        my $filas = unir_tablas("$base.tabla", @tablas);
        if (defined $filas) {
            my $hechas = tabla_a_simul("$base.tabla", "$base.simul", $base);
            if (defined $hechas) {
                unshift @porque, ($salida ? "Lo que se pudo resolver" : "Termino la solucion analitica (maxima)")
                               . ", " . scalar(@tablas) . " intervalos, $hechas filas";
            } else {
                avgrav_simple("no pude escribir $base.simul desde $base.tabla");
                $salida ||= 7;
            }
        }
    }
    mensajear(" POR QUE TERMINO: " . join(', ', @porque)) if @porque;
    traer_salidas($base, qw(analitica simul tabla horario dat), "=$listado");
    cerrar_log();
    return $salida;
}

# La tabla que deja Maxima --un '# TIME A B' y los numeros-- al .simul de
# Simusol: columnas de 24, las filas de metadatos que la cabecera anuncia
# (siru/lib/Siru/Salida.pm, el escritor del .simul). Devuelve cuantas filas.
sub tabla_a_simul {
    my ($tabla, $simul, $base, $cabecera) = @_;
    open my $in, '<', $tabla or return undef;
    my (@nombres, @filas);
    while (my $l = <$in>) {
        chomp $l;
        if ($l =~ /^#\s*(.*\S)/) { @nombres = split ' ', $1 unless @nombres; next }
        next unless $l =~ /\S/;
        push @filas, [split ' ', $l];
    }
    close $in;
    return undef unless @nombres and @filas;
    open my $out, '>', $simul or return undef;
    my $fila = sub { '# ' . join(' ', map { sprintf '%*s', 24, $_ } @_) . "\n" };
    # LA CABECERA, si la dan: cada motor cuenta lo suyo (el camino coordinado
    # siru-spice no entrega una solucion analitica)
    print {$out} map { "$_\n" } @{ $cabecera // [
                 "#   Archivo $base.simul; producido por maxima (lanzador --motor maxima)",
                 "#   la solucion analitica del sistema de $base.din, evaluada en la malla;",
                 "#   no es una integracion: no tiene paso ni error de truncamiento." ] };
    print {$out} '#  para Simusol: sceptrevars variables', "\n",
                 $fila->(@nombres),
                 $fila->(map { lc } @nombres);
    for my $f (@filas) {
        print {$out} join(' ', map { sprintf '%*s', 24, sprintf('%.17g', $_) } @$f), "\n";
    }
    close $out or return undef;
    return scalar @filas;
}

# Adaptar los archivos internos de los motores al documento de la cadena.
# Se construye entero antes de escribir: un error no deja media TABLE.
sub emitir_documento_numerico {
    my ($out, $base, $ext) = @_;
    my $g = {};
    if ($ext ne 'cir') {
        my $dat = "$base.dat";
        my $tmp;
        if (!-f $dat || $motor eq 'spice') {
            $tmp = tempdir(CLEANUP => 1);
            $dat = "$tmp/entrada.dat";
            my $raiz = $RealBin . '/../..';
            my $d2d = $ENV{D2DATDINC} //
                (-x "$raiz/slex/d2datdinc/d2datdinc" ? "$raiz/slex/d2datdinc/d2datdinc" : 'd2datdinc');
            my @opc;
            my $conf = $ENV{D2DATDINC_CONF} // "$raiz/slex/d2datdinc/d2datdinc.slex";
            my $bib = $ENV{D2DATDINC_BIB} // "$raiz/slex/d2datdinc/biblioteca";
            push @opc, '-c', $conf if -f $conf;
            push @opc, '-b', $bib if -d $bib;
            system($d2d, @opc, "$base.$ext", '--dat', '-o', $dat) == 0
                or die "no se pudo leer el pedido grafico de $base.$ext\n";
        }
        open my $fh, '<', $dat or die "$dat: $!\n";
        local $/; $g = decode_json(<$fh>)->{GLOBAL}; close $fh;
    }
    my @html_pedidos=map {$_->{pedido}//{}} @{$g->{simplots}//[]};
    push @html_pedidos,$g->{pedido_grafico} if $g->{pedido_grafico};
    my $html=grep {($_->{comando}//'') eq 'html' && ($_->{valor}//'') eq 'si'}
        map {@{$_->{ordenes}//[]}} @html_pedidos;
    if ($html) {
        my @archivos=("$base.$ext");
        if ($ext eq 'dsa') {
            (my $du="$base.$ext") =~ s/\.M\.dsa$/.DU.dsa/;
            push @archivos,$du if $du ne "$base.$ext";
        }
        (my $nombre=$base)=~s/\.M$//;
        $g->{informe_html}={nombre=>$nombre,documentos=>[map {
            {nombre=>basename($_),texto=>texto_informe($_)}
        } @archivos],resultados=>[]};
    }
    if ($tipo_salida eq 'analitica') {
        open my $fh, '<', "$base.analitica" or die "$base.analitica: $!\n";
        local $/; my $expresiones = <$fh>; close $fh;
        (my $nombre = $base) =~ s/\.M$//;
        $g->{analitica} = {formato=>'maxima', texto=>$expresiones,
            nombre=>$nombre, documento=>File::Spec->rel2abs("$base.$ext")};
        print {$out} encode_json({GLOBAL=>$g}) . "\n" or die "stdout: $!\n";
        return;
    }
    my $texto = '';
    my $ordinal = 0;
    my @pedidos = @{$g->{simplots} // []};
    @pedidos = ({pedido => $g->{pedido_grafico}})
        if !@pedidos && $g->{pedido_grafico};
    for my $pp (@pedidos) {
        my $nombre = $pp->{nombre} // ++$ordinal;
        $texto .= "PARAPLOT $nombre\n";
        for my $orden (@{$pp->{pedido}{ordenes} // []}) {
            $texto .= $orden->{comando} . ' ';
            $texto .= $orden->{objeto} . ' = ' if defined $orden->{objeto};
            $texto .= '= ' if $orden->{comando} eq 'maxima' || $orden->{comando} eq 'html';
            $texto .= ($orden->{valor} // '') . "\n";
        }
        $texto .= "$_\n" for @{$pp->{pedido}{adicionales} // []};
    }
    (my $nombre = $base) =~ s/\.M$//;
    $nombre =~ /\A[A-Za-z0-9_][A-Za-z0-9_.-]*\z/
        or die "nombre de tabla invalido: $nombre\n";
    $texto .= "TABLE $nombre FORMATO=SIMUL\n";
    if ($motor eq 'sceptre') {
        $texto .= tabla_sceptre("$nombre.sim");
    } elsif (-s "$base.simul") {
        open my $fh, '<', "$base.simul" or die $!;
        local $/; $texto .= <$fh>; close $fh;
    } elsif ($motor eq 'spice' && -s "$base.sim") {
        my @nombres = split /[,:\s]+/, $g->{outs} // '';
        die "faltan nombres de las columnas de Spice\n" unless @nombres > 1;
        $nombres[0] = 'TIME';
        $texto .= "# para Simusol: sceptrevars variables\n# " . join(' ', @nombres)
                . "\n# " . join(' ', map {lc} @nombres) . "\n";
        open my $fh, '<', "$base.sim" or die $!;
        while (my $l = <$fh>) {
            next if $l =~ /^#/;
            my @c = split ' ', $l;
            next unless @c;
            die "cantidad de columnas de Spice distinta del pedido\n" unless @c == @nombres;
            $texto .= $l;
        }
        close $fh;
    } else { die "el motor no dejo tabla numerica\n" }
    if ($html) {
        my $cabecera="TABLE $nombre FORMATO=SIMUL\n";
        my $sim=substr($texto,index($texto,$cabecera)+length($cabecera));
        $sim=decodificar_informe($sim);
        $g->{tablas}{$nombre}={formato=>'simul',texto=>$sim};
        $g->{informe_html}{resultados}=[{nombre=>"$nombre.simul",texto=>$sim}];
        my @modelos=map {$_->{modelo}} @{$g->{simplots}//[]};
        push @modelos,$g->{simplot} if $g->{simplot};
        for my $m (@modelos) {
            for my $f (@{$m->{fuentes}//[]}) {
                $f->{tabla}=$nombre if ($f->{id}//'') eq 'SIMULADO' ||
                    (defined $f->{archivo} && basename($f->{archivo}) eq "$base.simul");
            }
        }
        print {$out} encode_json({GLOBAL=>$g})."\n" or die "stdout: $!\n";
    } else {
        print {$out} $texto or die "escribir documento: $!\n";
    }
}

# El traductor conserva su propia lógica de Dia. Sus mensajes nunca son datos.
sub traducir_diagrama {
    my ($archivo,$nombre,$motor_elegido)=@_;
    my $stdin=!defined($archivo) || $archivo eq '-';
    $nombre //= $stdin ? 'entrada' : basename($archivo,'.dia');
    $nombre =~ s/\.dia$//i;
    $nombre =~ /\A[A-Za-z0-9_][A-Za-z0-9_.-]*\z/
        or die "lanzador: --nombre debe ser un nombre simple, sin ruta\n";
    my $tmp=tempdir('lanzador-dia-XXXXXX',TMPDIR=>1,CLEANUP=>1);
    my $dia="$tmp/$nombre.dia";
    if ($stdin) {
        binmode STDIN; open my $f,'>:raw',$dia or die $!;
        my $n=0; while (read(STDIN,my $buf,65536)) {$n+=length $buf;print {$f} $buf or die $!;}
        close $f or die $!; die "lanzador: entrada DIA vacía\n" unless $n;
    } else {
        require File::Copy;
        File::Copy::copy($archivo,$dia) or die "lanzador: no se pudo leer $archivo: $!\n";
    }
    my $raiz=$RealBin.'/../..';
    my @cmd;
    if ($ENV{SIMUSOL1}) {@cmd=($ENV{SIMUSOL1});}
    elsif (-f "$raiz/simusol/bin/simusol1.pl") {
        @cmd=($^X,'-I',File::Spec->rel2abs("$raiz/simusol/lib"),File::Spec->rel2abs("$raiz/simusol/bin/simusol1.pl"));
    } else {@cmd=('simusol1.pl');}
    # El -n permite traducir para conocer el motor, pero no ejecuta el motor.
    my $pid=fork();die "fork: $!\n" unless defined $pid;
    if (!$pid) {
        chdir $tmp or die $!;
        open STDOUT,'>&',\*STDERR or die $!;
        open STDIN,'<','/dev/null' or die $!;
        exec {$cmd[0]} @cmd,(defined($motor_elegido) ? ('--motor',$motor_elegido) : ()),"$nombre.dia";
        die "lanzador: no se pudo ejecutar Simusol: $!\n";
    }
    waitpid($pid,0);
    die "lanzador: falló la traducción DIA (estado $?)\n" if $?;
    my $deck="$tmp/tmps/$nombre.M.dsa";
    -s $deck or die "lanzador: Simusol no produjo $deck\n";
    die "lanzador: falta $nombre.DU.dsa\n" unless -s "$tmp/tmps/$nombre.DU.dsa";
    # Recursos de un diagrama por archivo: los .d históricos buscan estos
    # acompañantes junto al deck o en el directorio padre.
    if (!$stdin) {
        require File::Copy;
        for my $f (qw(funciones.for modellib.dat extensiones.txt)) {
            my $origen=File::Spec->catfile(dirname(File::Spec->rel2abs($archivo)),$f);
            File::Copy::copy($origen,"$tmp/$f") or die "$origen: $!\n" if -f $origen;
        }
    }
    return ($deck,$tmp);
}

# El .sim nativo pone la cabecera DESPUÉS de las muestras de cada corrida.
# Se transportan los mismos números, sin interpolación ni redondeo.
sub tabla_sceptre {
    my ($archivo)=@_;
    open my $f,'<',$archivo or die "$archivo: $!\n";
    my (@filas,@nombres,$texto);$texto='';my $corrida=0;
    while (my $l=<$f>) {
        if ($l =~ /^#nam\s+(.*)/) {@nombres=split ' ',$1;next;}
        if ($l =~ /^#no\. of solution points:\s*(\d+)/) {
            die "SCEPTRE: cantidad de muestras incompatible en $archivo\n" unless @filas==$1 && @filas && @nombres;
            ++$corrida;
            $texto.="# CORRIDA $corrida (".scalar(@filas)." puntos).\n# para Simusol: sceptrevars variables\n# ".join(' ',@nombres)."\n# ".join(' ',map {lc} @nombres)."\n";
            for my $fila (@filas) {
                my @c=split ' ',$fila;
                die "SCEPTRE: columnas incompatibles en $archivo\n" unless @c==@nombres;
                $texto.=$fila;
            }
            @filas=();@nombres=();next;
        }
        next if $l =~ /^\s*(?:#|$)/;
        my @c=split ' ',$l;
        die "SCEPTRE: resultado no numérico en $archivo\n" if grep {!/\A[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eEdD][+-]?\d+)?\z/} @c;
        $l =~ tr/dD/eE/;
        push @filas,$l;
    }
    die "SCEPTRE: tabla incompleta o vacía en $archivo\n" if @filas || !$corrida;
    return $texto;
}

# Textos del productor incorporados al informe: no rutas para releer en Simplot.
sub decodificar_informe {
    my $bytes=shift; my $copia=$bytes;
    my $texto=eval {decode('UTF-8',$copia,FB_CROAK)};
    return defined($texto) ? $texto : decode('ISO-8859-1',$bytes);
}
sub texto_informe {
    my $ruta=shift; open my $f,'<:raw',$ruta or die "$ruta: $!\n";
    local $/; return decodificar_informe(<$f>);
}

# Una sola lectura comun: MOTOR y PARAPLOT no se adivinan con regexps
# distintas de las del resto del proyecto. El lector expande los INPUT.
sub leer_configuracion {
    my ($entrada)=@_;
    return {} unless $entrada =~ /\.(?:d|dsa)\z/i;
    -f $entrada or die "lanzador: no existe $entrada\n";
    my $tmp=tempdir(CLEANUP=>1);
    my $raiz=$RealBin.'/../..';
    my $d2d=$ENV{D2DATDINC} // (-x "$raiz/slex/d2datdinc/d2datdinc" ? "$raiz/slex/d2datdinc/d2datdinc" : 'd2datdinc');
    my $conf=$ENV{D2DATDINC_CONF} // "$raiz/slex/d2datdinc/d2datdinc.slex";
    my $bib=$ENV{D2DATDINC_BIB} // "$raiz/slex/d2datdinc/biblioteca";
    my @opc;
    push @opc,'-c',$conf if -f $conf;
    push @opc,'-b',$bib if -d $bib;
    open my $salida, '>&', \*STDOUT or die $!;
    open STDOUT, '>&', \*STDERR or die $!;
    my $estado=system($d2d,@opc,$entrada,'--dat','-o',"$tmp/config.dat");
    open STDOUT, '>&', $salida or die $!;
    die "lanzador: no se pudo leer MOTOR/PARAPLOT del deck\n" if $estado;
    open my $f,'<',"$tmp/config.dat" or die $!;
    local $/; return decode_json(<$f>)->{GLOBAL};
}
