#!/usr/bin/perl
use strict;
use warnings;
use FindBin;
# en el arbol, lib/; instalado (make install o paquete), share/perl5
use lib "$FindBin::Bin/../share/perl5", "$FindBin::Bin/../lib";
use File::Basename qw(dirname);
use File::Spec;
use Getopt::Long qw(GetOptions);
use File::Temp qw(tempdir);
use IO::Handle;
use Siru::Calcula;
use Siru::Integrador;
use Siru::Error;

# NOMBRE.informe, al lado del archivo de entrada: como termino la corrida, por
# cualquiera de los caminos, bien o mal. siru/corpus/clasificar lo lleva al .tipo
# (campo siru). Si no converge, ademas un mensaje que lo diga en la pantalla,
# y no solo el volcado del solver.
our ($INFORME, $FILAS, $TIEMPOFINAL, $ULTIMO_ERROR, %ESTADISTICAS_ROS);
our %ESTADISTICAS_INTEGRACION;
our $PRESERVAR_INFORME;
# las medidas sobre la corrida (bloque MEDIDAS; Siru::Medidas): GLOBAL.medidas
# del dato; se calculan al terminar bien, sobre la tabla que quedo escrita
our $MEDIDAS;
# y lo que la corrida tiene que cumplir (bloque VERIFICACIONES): condiciones
# con las medidas y con las columnas de la tabla; GLOBAL.verificaciones
our $VERIFICACIONES;
our $PARAMETROS_MEDIDAS;     # los parametros del archivo que son un numero
our $ESPECTROS;              # bloque ESPECTROS: GLOBAL.espectros (Siru::Espectro)
our $CURVAS;                 # bloque CURVAS: GLOBAL.curvas (Siru::Curvas)
our $GUION;                  # bloque GUION: GLOBAL.guion (Siru::Guion)
$SIG{__DIE__} = sub { $ULTIMO_ERROR = $_[0] if defined($^S) && !$^S };
END {
    my $estado = $?;
    $estado = Siru::Error::codigo($ULTIMO_ERROR, $estado);
    my @medidas;
    if ($estado == 0 && !defined $ULTIMO_ERROR && ref($ESPECTROS) eq 'HASH' && %$ESPECTROS) {
        # los espectros pedidos, sobre la tabla que quedo: NOMBRE.fft
        no warnings 'once';
        my $tabla = $Siru::Salida::ULTIMA;
        if (defined $tabla && -s $tabla) {
            require Siru::Espectro;
            (my $fft = $tabla) =~ s/\.[^.\/]*\z/.fft/;
            my $n = eval { Siru::Espectro->escribir($tabla, $ESPECTROS, $fft) };
            if ($@) {
                (my $m = $@) =~ s/ at \S+ line \d+\.?\s*\z//;
                print STDERR "siru: los espectros: $m\n";
                $ULTIMO_ERROR = "los espectros: $m";
                $estado = 1;
            } elsif ($n) {
                print "espectros: $n frecuencias en $fft\n";
            }
        }
    }
    if ($estado == 0 && !defined $ULTIMO_ERROR && ref($GUION) eq 'HASH' && %$GUION) {
        # el guion de vectores: sus renglones en orden de nombre (p0001...)
        no warnings 'once';
        my $tabla = $Siru::Salida::ULTIMA;
        if (defined $tabla && -s $tabla) {
            require Siru::Guion;
            (my $ve = $tabla) =~ s/\.[^.\/]*\z/.vectores/;
            my $r = eval { Siru::Guion->escribir($tabla, [ map { $GUION->{$_} } sort keys %$GUION ], $ve) };
            if ($@) {
                (my $m = $@) =~ s/ at \S+ line \d+\.?\s*\z//;
                chomp $m;
                print STDERR "siru: el guion: $m\n";
                $ULTIMO_ERROR = "el guion: $m";
                $estado = 1;
            } else {
                print "guion: $_\n" for @{ $r->{ecos} };
                printf "guion %s = %.10g\n", $_, $r->{escalares}{$_} for sort keys %{ $r->{escalares} };
                my $nv = scalar keys %{ $r->{vectores} };
                print "guion: $nv vectores en $ve\n" if $nv;
            }
        }
    }
    if ($estado == 0 && !defined $ULTIMO_ERROR && ref($CURVAS) eq 'HASH' && %$CURVAS) {
        no warnings 'once';
        my $tabla = $Siru::Salida::ULTIMA;
        if (defined $tabla && -s $tabla) {
            require Siru::Curvas;
            (my $cu = $tabla) =~ s/\.[^.\/]*\z/.curvas/;
            my $n = eval { Siru::Curvas->escribir($tabla, $CURVAS, $cu) };
            if ($@) {
                (my $m = $@) =~ s/ at \S+ line \d+\.?\s*\z//;
                print STDERR "siru: las curvas: $m\n";
                $ULTIMO_ERROR = "las curvas: $m";
                $estado = 1;
            } elsif ($n) { print "curvas: $n filas en $cu\n" }
        }
    }
    my $hay_med = ref($MEDIDAS) eq 'HASH' && %$MEDIDAS;
    my $hay_ver = ref($VERIFICACIONES) eq 'HASH' && %$VERIFICACIONES;
    if ($estado == 0 && !defined $ULTIMO_ERROR && ($hay_med || $hay_ver)) {
        no warnings 'once';
        my $tabla = $Siru::Salida::ULTIMA;
        if (defined $tabla && -s $tabla) {
            require Siru::Medidas;
            @medidas = eval {
                my ($nombres, $filas) = Siru::Medidas->tabla($tabla);
                # el analisis en frecuencia, si lo hubo: NOMBRE.ac al lado
                (my $ac = $tabla) =~ s/\.[^.\/]*\z/.ac/;
                $PARAMETROS_MEDIDAS = { %{ $PARAMETROS_MEDIDAS // {} }, %{ Siru::Medidas->columnas_ac($ac) } }
                    if -s $ac;
                # y los polos y ceros, si los hubo: NOMBRE.pz
                (my $pz = $tabla) =~ s/\.[^.\/]*\z/.pz/;
                $PARAMETROS_MEDIDAS = { %{ $PARAMETROS_MEDIDAS // {} }, %{ Siru::Medidas->columnas_pz($pz) } }
                    if -s $pz;
                (my $rr = $tabla) =~ s/\.[^.\/]*\z/.ruido/;
                $PARAMETROS_MEDIDAS = { %{ $PARAMETROS_MEDIDAS // {} }, %{ Siru::Medidas->columnas_ruido($rr) } }
                    if -s $rr;
                my $r = Siru::Medidas->calcular($nombres, $filas, $hay_med ? $MEDIDAS : {}, $PARAMETROS_MEDIDAS);
                (Siru::Medidas->renglones($r),
                 ($hay_ver ? Siru::Medidas->renglones_verificacion(
                     Siru::Medidas->verificar($nombres, $filas, $r, $VERIFICACIONES, $PARAMETROS_MEDIDAS)) : ()));
            };
            if ($@) {
                (my $m = $@) =~ s/ at \S+ line \d+\.?\s*\z//;
                print STDERR "siru: las medidas: $m\n";
                $ULTIMO_ERROR = "las medidas: $m";
                $estado = 1;
            }
            print @medidas;
        }
    }
    if (defined $INFORME && !$PRESERVAR_INFORME) {
        my ($resultado, $hasta, $error);
        if ($estado == 0 && !defined $ULTIMO_ERROR) {
            $resultado = $ESTADISTICAS_INTEGRACION{parada} ? 'se detuvo por parada' : 'llega al final';
            $hasta = defined $FILAS ? "$FILAS filas" : undef;
            $hasta .= ", TIEMPOFINAL=$TIEMPOFINAL" if defined $hasta && defined $TIEMPOFINAL;
        } else {
            ($error = $ULTIMO_ERROR // "estado $estado") =~ s/\s+\z//;
            $error =~ s/\n.*//s;
            if ($error =~ /^paso (\d+), t=([^:]+): (.*)/) {
                my ($paso, $t, $motivo) = ($1, $2 + 0, $3);
                $resultado = $paso > 0 ? 'NO CONVERGE' : 'no arranca';
                # el tope de pasos no es una falla de Newton: la corrida anduvo
                # hasta ahi (Pared.d con la mitad del paso)
                $resultado = 'se corta' if $motivo =~ /se alcanzo (?:max_pasos|el plazo total)/;
                $hasta = "paso $paso, t=$t" . (defined $TIEMPOFINAL ? " de TIEMPOFINAL=$TIEMPOFINAL" : '');
                $error = $motivo;
                print STDERR "siru: $resultado en t=$t (paso $paso)\n";
            } else {
                $resultado = 'no arranca';
                print STDERR "siru: no arranca\n";
            }
        }
        Siru::Registro::cerrar();
        Siru::Registro::escribe('siru', "resultado: $resultado" . (defined $hasta ? ", $hasta" : '')
                                  . (defined $error ? "; $error" : '') . "\n");
        if (open my $o, '>', $INFORME) {
            print $o "# siru sobre este archivo, escrito por bin/siru al terminar\n";
            print $o "resultado: $resultado\n";
            print $o "hasta: $hasta\n" if defined $hasta;
            print $o "error: $error\n" if defined $error;
            print $o $_ for @medidas;
            if (%ESTADISTICAS_ROS) {
                require JSON::PP;
                print $o "estadisticas ROS: ",JSON::PP->new->canonical->encode(\%ESTADISTICAS_ROS),"\n";
            }
            if (%ESTADISTICAS_INTEGRACION) {
                require JSON::PP;
                print $o "estadisticas ultima integracion: ",
                    JSON::PP->new->canonical->encode(\%ESTADISTICAS_INTEGRACION),"\n";
            }
            # el estado al terminar, para seguir con --continuar
            no warnings 'once';     # se escribe en Circuito y se lee solo aca
            if (my $ef = $Siru::Circuito::ESTADO_FINAL) {
                if ($ef->{continuacion_integra}) {
                    require JSON::PP;
                    print $o "estado coordinador: ",JSON::PP->new->canonical->encode($ef->{continuacion_integra}),"\n";
                }

                print $o "estado final: t=",sprintf("%.17g",$ef->{t}), (map { " $_=".sprintf("%.17g",$ef->{estados}{$_}) } sort keys %{ $ef->{estados} }), "\n";
                print $o "parametros impuestos:", (map { " $_=$ef->{impuestos}{$_}" } sort keys %{ $ef->{impuestos} }), "\n"
                    if %{ $ef->{impuestos} // {} };
            }
            close $o;
        }
    }
    $? = $estado;
}

sub ruta {
    my ($base, $valor) = @_;
    return File::Spec->rel2abs($valor, $base);
}

sub error_uso {
    Siru::Error->lanzar(codigo => 106, mensaje => $_[0]);
}

my ($salida, $calcula, $bibliotecas, $plazo, $ayuda, $continuar, $hasta, $factor, $nosimplot, $documento, $plazo_total, $avance, $solo_punto, $calcula_puntos, $du_stdin, $modelo_du, $filtro_dsa);
my (@lineas_calcula, @archivos_calcula);
my ($tabla_pglm,$motor_pglm,$lineal_pglm,$precondicionador_pglm,@campos_pglm,@particiones_pglm);
my ($guardar_pglm,$retomar_pglm);
my ($dae_residual,$residuo_dae,$guardar_dae,$retomar_dae,$reducir_dae);
my ($lineal_ros,$precondicionador_ros,$rtol_lineal_ros,$iteraciones_ros);
my ($rknum, $integra_modelo, $temporal_netlist, $din_base, $ruta_din_base, $preparador_mtk);
my $uso ="Uso: $0 [--salida ARCHIVO] [--calcula EJECUTABLE] [--bibliotecas DIR] [--plazo SEGUNDOS] [--paso-factor F] [--salida-paso INTERVALO] CIRCUITO.d|.ds|.dat|SISTEMA.din\n"
        . "     $0 --continuar [--hasta T] CIRCUITO.d|.ds|.dat   sigue la corrida terminada (NOMBRE.informe) hasta T, otro bloque en NOMBRE.simul\n"
        . "     $0 --dsa: filtro M+DU por stdin; acepta M ... FIN seguido de varios DU ... FIN y emite un R ... FIN por DU\n"
        . "     -nosimplot: no llamar a Simplot al terminar (por defecto grafica la salida; SIRU_NOSIMPLOT=1 es lo mismo)\n"
        . "     --documento: emitir por stdout el .d/.ds con TABLE NOMBRE (del caso); diagnosticos por stderr\n"
        . "     --solo-punto: resolver solo el punto inicial del .d/.ds, aunque declare evolucion o Runge-Kutta\n"
        . "     --modelo M.dsa|MODELO.dat: evolucion temporal con DU por stdin; --salida recibe sus tablas\n"
        . "     --integra N[,N...]: sustituir INTEGRA de M al preparar el modelo; no se escribe en DU\n"
        . "     --tabla-pglm TABLA.json: con --modelo, bloques generales con paso fijo o estimador adaptativo\n"
        . "     --modelo M.dsa --salida ARCHIVO.simul --continuar --hasta T: retomar casos INTEGRA coordinados sin reenviar DU\n"
        . "     --guardar-pglm ESTADO.json: guardar el extremo final de cada caso PGLM\n"
        . "     --guardar-dae ESTADO.json | --retomar-dae ESTADO.json --hasta T: continuacion residual\n"
        . "     --reducir-dae: evolucion reducida y proyeccion de restricciones\n"
        . "     --dae-residual --residuo-dae TOL: BDF residual con KLU, M/DU e INTEGRA=[1], [20] o [21]\n"
        . "     --lineal-ros denso|klu|gmres|bicgstab: resolvedor de etapas Rosenbrock (por defecto denso)\n"
        . "     --precondicionador-ros escalas|bloques:K|ilu0:B: escalas, Jacobi por bloques o ILU0 de banda\n"
        . "                          bloques:modelo:K|ilu[0-2]:modelo[:rcm]: estructura del modelo y relleno\n"
        . "     --rtol-lineal-ros R --iteraciones-ros N: residuo relativo y limite por etapa (1e-9 y 300)\n"
        . "     --particion-pglm Q1,Q2: grupo de estados por tabla, repetir por particion\n"
        . "     --motor-pglm auto|c|perl: nucleo de residuos y actualizacion PGLM (auto por omision)\n"
        . "     --lineal-pglm denso|gmres|bicgstab: tablas externas o INTEGRA PGLM numerado (249-273 y registros locales)\n"
        . "     --precondicionador-pglm escalas|bloques:K|ilu0:B: aproximacion para Krylov; K=tamano de bloque, B=semiancho de banda\n"
        . "                           bloques:modelo:K|ilu[0-2]:modelo[:rcm]: estructura de etapas, relleno y orden RCM\n"
        . "     --retomar-pglm ESTADO.json --hasta T: retomar los casos guardados, sin leer DU\n"
        . "     --campo-pglm X=FX,Y=FY: particion aditiva; repetir por cada campo de la tabla\n"
        . "     --du-stdin: junto a --calcula-puntos, preparar M.dsa o reutilizar .dat y leer DU de stdin\n"
        . "     --calcula-puntos: usar el .d/.ds/.dsa como modelo y pasar lineas de datos a Calcula sin evolucion\n"
        . "     --plazo-total S: cortar la corrida a los S segundos (SIRU_PLAZO_TOTAL); el .informe dice hasta donde llego\n"
        . "     --avance S: una linea de avance por stderr cada S segundos (SIRU_AVANCE; por omision 30, 0 ninguna)\n"
        . "     .dsa con NETLIST = [\"mtk\"] en el DU: las ecuaciones de la netlist las genera ModelingToolkit (mtk/dsa2din.jl); con llaves, coordina siru\n"
        . "     --rk N: metodo de integracion para ampliar un .din base (si no, el integra de su # corrida)\n";
my $salida_paso;
GetOptions('salida-paso=f' => \$salida_paso, 'salida=s' => \$salida, 'calcula=s' => \$calcula,
    'bibliotecas=s' => \$bibliotecas, 'plazo=f' => \$plazo, 'ayuda|help' => \$ayuda,
    'continuar' => \$continuar, 'hasta=f' => \$hasta, 'paso-factor=f' => \$factor,
    'nosimplot' => \$nosimplot, 'documento' => \$documento, 'solo-punto' => \$solo_punto,
    'modelo=s' => \$modelo_du, 'integra=s' => \$integra_modelo, 'dsa' => \$filtro_dsa, 'du-stdin' => \$du_stdin, 'calcula-puntos' => \$calcula_puntos, 'linea=s' => \@lineas_calcula,
    'datos-archivo=s' => \@archivos_calcula,
    'guardar-pglm=s' => \$guardar_pglm, 'retomar-pglm=s' => \$retomar_pglm,
    'tabla-pglm=s' => \$tabla_pglm, 'campo-pglm=s@' => \@campos_pglm,
    'guardar-dae=s' => \$guardar_dae, 'retomar-dae=s' => \$retomar_dae,
    'reducir-dae!' => \$reducir_dae, 'dae-residual' => \$dae_residual, 'residuo-dae=f' => \$residuo_dae,
    'lineal-ros=s' => \$lineal_ros, 'precondicionador-ros=s' => \$precondicionador_ros,
    'rtol-lineal-ros=f' => \$rtol_lineal_ros, 'iteraciones-ros=i' => \$iteraciones_ros,
    'particion-pglm=s@' => \@particiones_pglm,
    'motor-pglm=s' => \$motor_pglm,
    'lineal-pglm=s' => \$lineal_pglm,
    'precondicionador-pglm=s' => \$precondicionador_pglm,
    'plazo-total=f' => \$plazo_total, 'avance=f' => \$avance,
    'rk=i' => \$rknum)
    or error_uso($uso);
# --plazo-total y --avance (Siru::Plazo, 23/10/2026): que una corrida lenta
# no cuelgue el corpus y diga por donde va. Los programas del corpus ponen
# SIRU_PLAZO_TOTAL.
$plazo_total //= $ENV{SIRU_PLAZO_TOTAL};
$avance //= $ENV{SIRU_AVANCE} // 30;
for (['plazo-total', $plazo_total], ['avance', $avance]) {
    error_uso("--$_->[0] debe ser un numero no negativo\n")
        if defined $_->[1] && $_->[1] !~ /\A\s*(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?\s*\z/;
}
require Siru::Plazo;
Siru::Plazo->poner(total => $plazo_total, avance => $avance);
if ($filtro_dsa) {
    error_uso("--dsa recibe todo por stdin y no admite --modelo, --salida ni archivo posicional\n")
        if @ARGV || defined($modelo_du) || defined($salida) || $continuar || $documento || $calcula_puntos;
    require Siru::FiltroDSA;
    my $bien=eval {
        local $ENV{SIRU_NOSIMPLOT}=1;
        Siru::FiltroDSA->correr(calcula=>$calcula,bibliotecas=>$bibliotecas,plazo=>$plazo);
        1;
    };
    unless ($bien) {my $error=$@;print STDERR $error;exit Siru::Error::codigo($error,2)}
    exit 0;
}
# SIRU_NOSIMPLOT=1: lo mismo que -nosimplot. Lo ponen las pruebas y los
# programas del corpus, que corren cientos de circuitos: cada grafico es una
# ventana de gnuplot (pedido del autor, 20/10/2026: "salvo orden diferente los
# corpus no llamen a gnuplot sino solo lo simulen"; la orden es SIRU_GRAFICOS=1)
$nosimplot ||= $ENV{SIRU_NOSIMPLOT};
# --plazo: cuanto se espera cada respuesta de Calcula (un punto, un paso).
# Por omision 30 s en una corrida y 10 s en un punto; un circuito que Newton
# tarda en resolver (a13z.d, pedido del autor 30/09/2026) necesita mas.
error_uso("--plazo debe ser un numero positivo\n") if defined $plazo && !($plazo > 0);
# --paso-factor F: la corrida con el paso por F (adaptivo: las tolerancias),
# para ver si el resultado cambia al achicarlo; lo aplica Siru::Din
# (SIRU_PASO_FACTOR). Lo usa siru/corpus/convergencia.
if (defined $salida_paso) {
    error_uso("--salida-paso debe ser positivo\n") unless $salida_paso>0;
    $ENV{SIRU_SALIDA_PASO}=$salida_paso;
}
error_uso("--paso-factor debe ser un numero positivo\n") if defined $factor && !($factor > 0);
$ENV{SIRU_PASO_FACTOR} = $factor if defined $factor;
if ($ayuda) { print $uso; exit 0; }
require Siru::LinealROS;
for ([SIRU_ROS_LINEAL=>$lineal_ros],[SIRU_ROS_PRECONDICIONADOR=>$precondicionador_ros],
     [SIRU_ROS_RTOL=>$rtol_lineal_ros],[SIRU_ROS_ITERACIONES=>$iteraciones_ros]) {
    $ENV{$_->[0]}=$_->[1] if defined $_->[1];
}
eval {Siru::LinealROS->opciones;1} or error_uso($@);
error_uso("las opciones ROS no se aplican a --tabla-pglm ni --solo-punto\n")
    if ($tabla_pglm || $solo_punto || $calcula_puntos) && grep {defined $_} ($lineal_ros,$precondicionador_ros,$rtol_lineal_ros,$iteraciones_ros);
error_uso("--particion-pglm requiere --tabla-pglm y no se combina con --campo-pglm\n")
    if @particiones_pglm && (!defined($tabla_pglm) || @campos_pglm);
require Siru::PGLMNumerado;
my %servicios_pglm=map {defined($_->[1])?($_->[0]=>$_->[1]):()}
    [motor=>$motor_pglm],[lineal=>$lineal_pglm],[precondicionador=>$precondicionador_pglm];
eval {Siru::PGLMNumerado->validar_servicios(\%servicios_pglm,1);1} or error_uso($@);
error_uso("los servicios PGLM no se aplican a --solo-punto, --calcula-puntos ni --dae-residual\n")
    if keys(%servicios_pglm) && ($solo_punto || $calcula_puntos || $dae_residual);
if (!defined $tabla_pglm) {
    $ENV{'SIRU_PGLM_'.uc($_)}=$servicios_pglm{$_} for keys %servicios_pglm;
    eval {Siru::PGLMNumerado->entorno;1} or error_uso($@);
}
error_uso("--tabla-pglm requiere --modelo; --campo-pglm requiere --tabla-pglm\n")
    if (defined($tabla_pglm) && !defined($modelo_du)) || (@campos_pglm && !defined($tabla_pglm));
error_uso("--guardar-pglm y --retomar-pglm requieren --tabla-pglm; retomar requiere --hasta\n")
    if ((defined($guardar_pglm) || defined($retomar_pglm)) && !defined($tabla_pglm))
        || (defined($retomar_pglm) && !defined($hasta));
error_uso("--dae-residual requiere --modelo y no se combina con --tabla-pglm ni --lineal-ros\n")
    if $dae_residual && (!defined($modelo_du) || defined($tabla_pglm) || defined($lineal_ros));
error_uso("--reducir-dae requiere --dae-residual\n") if defined($reducir_dae) && !$dae_residual;
error_uso("--residuo-dae requiere --dae-residual y tolerancia positiva\n")
    if defined($residuo_dae) && (!$dae_residual || $residuo_dae<=0);
error_uso("--guardar-dae/--retomar-dae requieren --dae-residual; retomar requiere --hasta\n")
    if ((defined($guardar_dae)||defined($retomar_dae)) && !$dae_residual) || (defined($retomar_dae) && !defined($hasta));
if (defined $modelo_du) {
    error_uso("--modelo temporal requiere M.dsa o un .dat preparado\n") unless $modelo_du =~ /\.(?:dsa|dat)\z/i;
    error_uso("--continuar con --modelo requiere --hasta y no se combina con PGLM/DAE\n")
        if $continuar && (!defined($hasta) || $tabla_pglm || $dae_residual || $retomar_pglm || $retomar_dae);
    error_uso("--modelo temporal no admite archivo posicional, --hasta sin continuacion, --documento, --solo-punto ni --calcula-puntos\n")
        if @ARGV || (defined($hasta) && !defined($retomar_pglm) && !defined($retomar_dae) && !$continuar) || $documento || $solo_punto || $calcula_puntos || @lineas_calcula || @archivos_calcula;
    require Siru::ModeloFuente;
    require Siru::EvolucionDU;
    my $bien=eval {
        my $f=Siru::ModeloFuente->nuevo(archivo=>$modelo_du,solo_modelo=>1,dae_residual=>$dae_residual,integra=>$integra_modelo);
        Siru::EvolucionDU->correr(fuente=>$f,salida=>$salida,calcula=>$calcula//'calcula',
            bibliotecas=>$bibliotecas,plazo=>$plazo//30,continuar_split=>$continuar,hasta_split=>$hasta,dae_residual=>$dae_residual,reducir_dae=>$reducir_dae,residuo_dae=>$residuo_dae,guardar_dae=>$guardar_dae,retomar_dae=>$retomar_dae,hasta_dae=>$hasta,
            (defined($tabla_pglm)?(tabla_pglm=>$tabla_pglm,motor_pglm=>$motor_pglm,lineal_pglm=>$lineal_pglm,precondicionador_pglm=>$precondicionador_pglm,campos_pglm=>\@campos_pglm,particiones_pglm=>\@particiones_pglm,guardar_pglm=>$guardar_pglm,retomar_pglm=>$retomar_pglm,hasta_pglm=>$hasta):()));
        1;
    };
    unless ($bien) {my $error=$@; print STDERR $error; exit Siru::Error::codigo($error,2)}
    exit 0;
}
error_uso("--integra requiere --modelo\n") if defined $integra_modelo;
error_uso("--du-stdin requiere --calcula-puntos o --modelo\n") if $du_stdin && !$calcula_puntos;
error_uso($uso) unless @ARGV == 1;
my $archivo = File::Spec->rel2abs($ARGV[0]);
Siru::Error->lanzar(codigo=>107, archivo=>$archivo, mensaje=>"no existe el archivo de entrada") unless -f $archivo;
# NETLIST = ["mtk"] en el deck (una frase del M.dsa o de su DU.dsa, no una
# opcion de linea de comando): las ecuaciones de la netlist las genera
# ModelingToolkit (mtk/dsa2din.jl) desde el M.dsa; el .din base resultante
# sigue por el camino comun, donde siru le agrega las ecuaciones del metodo
# (Siru::DesdeDin). Sin NETLIST, o con NETLIST = ["siru"], el generador es
# el de siempre.
sub netlist_del_deck {
    my (@rutas) = @_;
    my $netlist;
    for my $ruta (@rutas) {
        next unless defined($ruta) && -f $ruta;
        open my $fh, '<:encoding(UTF-8)', $ruta or die "no se pudo leer $ruta: $!\n";
        while (my $linea = <$fh>) {
            next unless $linea =~ /^\s*NETLIST\s*=\s*\[\s*"?([A-Za-z]+)"?\s*\]\s*$/;
            my $valor = lc $1;
            die "NETLIST admite siru o mtk, no $1 ($ruta)\n"
                unless $valor =~ /\A(?:siru|mtk)\z/;
            die "NETLIST repetido con valores distintos\n"
                if defined($netlist) && $netlist ne $valor;
            $netlist = $valor;
        }
        close $fh;
    }
    return $netlist // 'siru';
}
if ($archivo =~ /\.dsa\z/i && !$continuar && !$documento && !$solo_punto && !$calcula_puntos) {
    (my $du = $archivo) =~ s/\.M\.dsa\z/.DU.dsa/i;
    $du = undef if $du eq $archivo;
    # NETLIST es un control y los controles pertenecen a DU: en un par M/DU
    # se lee el DU, y en un archivo reunido el archivo mismo. En el M no,
    # porque ahi los lectores rechazan los controles.
    my @donde = defined($du) ? ($du) : $archivo =~ /\.M\.dsa\z/i ? () : ($archivo);
    if (netlist_del_deck(@donde) eq 'mtk') {
        # Con llaves hace falta coordinar: el sistema cambia con la
        # configuracion y no hay un .din que sirva para todas. Entonces el
        # camino es el del coordinador, con el preparador del generador mtk;
        # el dato --datos, usos, salidas-- lo sigue dando el lector.
        require Siru::PreparadorMTK;
        my $pm = Siru::PreparadorMTK->nuevo(archivo => $archivo, du => $du);
        if ($pm->llaves) {
            $preparador_mtk = $pm;
        } else {
            # Sin llaves el sistema es uno solo: alcanza con el .din que deja
            # el generador, al que siru le agrega las ecuaciones del metodo.
            ($salida = $archivo) =~ s/(?:\.M)?\.dsa\z/.simul/i unless defined $salida;
            my $mtk = $ENV{SIRU_MTK} // File::Spec->catdir($FindBin::Bin, '..', '..', 'mtk');
            my $programa = File::Spec->catfile($mtk, 'dsa2din.jl');
            die "no se encuentra mtk/dsa2din.jl (indique SIRU_MTK con su directorio)\n"
                unless -f $programa;
            $temporal_netlist = tempdir(CLEANUP => 1);
            (my $nombre = File::Basename::basename($archivo)) =~ s/(?:\.M)?\.dsa\z//i;
            my $din = File::Spec->catfile($temporal_netlist, "$nombre-de-mtk.din");
            my @orden = ('julia', "--project=$mtk", $programa, $archivo,
                (defined($du) && -f $du ? $du : ()), '-o', $din);
            my $estado = system(@orden);
            die "el generador MTK fallo (estado $estado)\n" if $estado;
            die "el generador MTK no dejo el .din\n" unless -f $din;
            $archivo = $din;
        }
    }
}
if ($calcula_puntos) {
    error_uso("--calcula-puntos requiere .d, .ds o .dsa y no admite --continuar ni --salida\n")
        if $continuar || defined($salida) || ($archivo !~ /\.(?:d|ds|dsa)\z/i && !($du_stdin && $archivo =~ /\.dat\z/i));
    require Siru::Circuito;
    require Siru::UnPunto;
    require Siru::Preparador;
    require Siru::ModeloFuente;
    my $fuente = Siru::ModeloFuente->nuevo(archivo => $archivo, solo_modelo=>$du_stdin);
    if ($du_stdin) {
        error_uso("--du-stdin requiere .dsa o .dat preparado y no admite lineas ni archivos de datos adicionales\n")
            if $archivo !~ /\.(?:dsa|dat)\z/i || @lineas_calcula || @archivos_calcula;
        my $bien=eval {$fuente->recibir_du(calcula=>$calcula//'calcula',bibliotecas=>$bibliotecas,plazo=>$plazo//30);1};
        unless ($bien) {my $error=$@; print STDERR $error; exit Siru::Error::codigo($error,2)}
        exit 0;
    }
    my @internas;
    open my $modelo, '<', $archivo or die "no se pudo leer $archivo: $!\n";
    my $en_datos = 0;
    while (my $linea = <$modelo>) {
        if ($linea =~ /^\s*#\s*CALCULA\s+DATOS\s*$/i) { $en_datos = 1; next }
        if ($linea =~ /^\s*#\s*FIN\s+CALCULA\s+DATOS\s*$/i) { $en_datos = 0; next }
        next unless $en_datos;
        $linea =~ s/^\s*#\s?// or die "en CALCULA DATOS cada linea debe comenzar con #\n";
        push @internas, $linea if $linea =~ /\S/ && $linea !~ /^\s*#/;
    }
    close $modelo;
    my $bibliotecas_ruta = defined($bibliotecas) ? File::Spec->rel2abs($bibliotecas) : undef;
    if ($fuente->requiere_coordinacion) {
        my $coord=$fuente->coordinador(calcula=>defined($calcula)?File::Spec->rel2abs($calcula):'calcula',
            bibliotecas=>$bibliotecas_ruta,plazo=>$plazo//30);
        my $n=0;
        my $pasar=sub {
            my ($linea)=@_;$linea =~ s/\r?\n\z//;
            my $r=eval {$coord->evaluar($coord->normalizar_datos($linea))};
            unless ($r) {
                my $error=$@;
                print STDERR $error;
                # Cerrar las sesiones antes de fijar el estado de salida:
                # sus waitpid no deben convertir un fallo en exito.
                eval {$coord->cerrar};
                exit Siru::Error::codigo($error,2);
            }
            print 'Punto: ',++$n,"  Modelo: $archivo  Configuracion: $r->{configuracion}\n";
            for my $e (@{$r->{transiciones}}) {
                for my $v (sort keys %{$e->{antes}}) {
                    next if $e->{antes}{$v}==$e->{despues}{$v};
                    printf "Equilibrio (%s): %s %.17g -> %.17g\n",$e->{configuracion},$v,$e->{antes}{$v},$e->{despues}{$v};
                }
            }
            for my $v (@{$r->{orden}}) {
                printf "%-20s %.17g%s\n",$v,$r->{valores}{$v},exists($r->{datos}{$v})?' (dato del instante)':'';
            }
            print "=================================\n";
        };
        $pasar->($_) for @internas,@lineas_calcula;
        my $stdin_explicitado=0;
        for my $ruta (@archivos_calcula) {
            my $f;
            if ($ruta eq '-') {$f=*STDIN;$stdin_explicitado=1}
            else {open $f,'<',$ruta or die "$ruta: $!\n"}
            while (my $l=<$f>) {$pasar->($l) if $l =~ /\S/ && $l !~ /^\s*#/}
            close $f if $ruta ne '-';
        }
        if (!$stdin_explicitado && !-t STDIN) {
            while (my $l=<STDIN>) {$pasar->($l) if $l =~ /\S/ && $l !~ /^\s*#/}
        }
        $pasar->('') unless $n;
        $coord->cerrar;
        exit 0;
    }
    my ($din, $datos) = $fuente->punto();
    my @orden = (defined($calcula) ? File::Spec->rel2abs($calcula) : 'calcula',
        '-m', 'modulodinamico', '--dinamico=' . $din, '/dev/stdin');
    my $pid = open(my $entrada, '|-');
    die "no se pudo iniciar Calcula: $!\n" unless defined $pid;
    if (!$pid) {
        chdir $fuente->{directorio} or die "no se pudo entrar al directorio del modelo: $!\n";
        if (defined $bibliotecas_ruta) {
            $ENV{LD_LIBRARY_PATH} = $bibliotecas_ruta .
                ($ENV{LD_LIBRARY_PATH} ? ":$ENV{LD_LIBRARY_PATH}" : '');
        }
        exec { $orden[0] } @orden or die "no se pudo ejecutar Calcula: $!\n";
    }
    $entrada->autoflush(1);
    my $n = 0;
    my $pasar = sub {
        my ($linea) = @_;
        $linea =~ s/\r?\n\z//;
        $linea = Siru::UnPunto->completar_entrada($din, $datos, $linea);
        print {$entrada} "$linea\n" or die "Calcula cerro la entrada: $!\n";
        $n++;
    };
    $pasar->($_) for @internas, @lineas_calcula;
    my $stdin_explicitado = 0;
    for my $ruta (@archivos_calcula) {
        my $f;
        if ($ruta eq '-') { $f = *STDIN; $stdin_explicitado = 1 }
        else { open $f, '<', $ruta or die "no se pudo leer $ruta: $!\n" }
        while (my $linea = <$f>) { $pasar->($linea) if $linea =~ /\S/ && $linea !~ /^\s*#/ }
        close $f if $ruta ne '-';
    }
    if (!$stdin_explicitado && !-t STDIN) {
        while (my $linea = <STDIN>) { $pasar->($linea) if $linea =~ /\S/ && $linea !~ /^\s*#/ }
    }
    $pasar->(Siru::UnPunto->entrada_inicial($din, $datos)) unless $n;
    close $entrada or die "Calcula no pudo resolver los datos\n";
    exit 0;
}
error_uso("--solo-punto requiere .d o .ds y no admite --continuar\n")
    if $solo_punto && ($continuar || $archivo !~ /\.(?:d|ds)\z/i);
error_uso("--documento requiere .d o .ds y no admite --continuar\n")
    if $documento && ($continuar || $archivo !~ /\.(?:d|ds)\z/i);
my $stdout_documento;
if ($documento) {
    open $stdout_documento, '>&', \*STDOUT or die "no se pudo guardar stdout: $!\n";
    open STDOUT, '>&', \*STDERR or die "no se pudo separar diagnosticos: $!\n";
}
my $base = dirname($archivo);
($INFORME = $archivo) =~ s/\.[^.\/]+\z//;
require Siru::Registro;
Siru::Registro::abrir("$INFORME.log");     # NOMBRE.log: el stderr de todos
$INFORME .= '.informe';
# Si la salida ya existe no se pisa: se escribe NOMBRE-1.simul, -2... y el
# informe lleva el mismo numero (Siru::Salida->libre).
require Siru::Salida;
sub salida_libre {
    $salida = Siru::Salida->libre($salida);
    ($INFORME = $salida) =~ s/\.[^.\/]+\z//;
    $INFORME .= '.informe';
}
sub graficar {
    return if $nosimplot;
    require Siru::Graficos;
    Siru::Graficos->hacer($archivo, $salida, $_[0]);
}
sub emitir_documento {
    return unless $documento;
    require Siru::Documento;
    open my $f, '<:raw', $archivo or die "no se pudo leer $archivo: $!\n";
    my $fuente = do { local $/; <$f> };
    close $f;
    open my $t, '<:raw', $salida or die "no se pudo leer $salida: $!\n";
    my $tabla = do { local $/; <$t> };
    close $t;
    print {$stdout_documento} Siru::Documento::componer($fuente, $tabla, Siru::Documento::nombre_tabla($archivo))
        or die "no se pudo escribir el documento en stdout: $!\n";
}
if ($continuar) {
    $PRESERVAR_INFORME=1;
    # --continuar: sigue la corrida que termino, desde el estado final que
    # bin/siru dejo en NOMBRE.informe, hasta --hasta T (o lo que diga la
    # seccion CONTINUE del archivo); otro bloque en el mismo NOMBRE.simul
    error_uso("--continuar es para un .d, .ds o .dat\n") unless $archivo =~ /\.(?:d|ds|ds2|dat)\z/i;
    ($salida = $archivo) =~ s/\.[^.]+\z/.simul/ unless defined $salida;
    ($INFORME = $salida) =~ s/\.[^.\/]+\z/.informe/;
    open my $i, '<', $INFORME or die "no hay $INFORME: hay que correr $archivo antes de continuarlo\n";
    my @lineas = <$i>;
    close $i;
    my ($estado) = grep { /^estado final: / } @lineas;
    my ($impuestos) = grep { /^parametros impuestos: / } @lineas;
    my ($coord)=grep { /^estado coordinador: / } @lineas;
    if (defined $coord) {require JSON::PP;$coord=JSON::PP->new->decode($coord =~ s/^estado coordinador: //r)}
    die "$INFORME no trae el estado final (la corrida no termino bien)\n" unless defined $estado;
    my %e = map { split /=/, $_, 2 } split ' ', ($estado =~ s/^estado final: //r);
    my %imp = defined $impuestos ? (map { split /=/, $_, 2 } split ' ', ($impuestos =~ s/^parametros impuestos: //r)) : ();
    my $t = delete $e{t};
    error_uso("--hasta $hasta no es posterior a t=$t\n") if defined $hasta && !($hasta > $t);
    require Siru::Circuito;
    my ($caso, $dato, $preparador) = Siru::Circuito->caso($archivo);
    require Siru::Dibujo;
    Siru::Dibujo->hacer($archivo, $dato);
    die "$archivo es un solo punto, no hay corrida que continuar\n" if $caso == 4;
    my %donde = (calcula => (defined($calcula) ? File::Spec->rel2abs($calcula) : 'calcula'),
        bibliotecas => (defined($bibliotecas) ? File::Spec->rel2abs($bibliotecas) : undef));
    $FILAS = Siru::Circuito->continuar(archivo => $archivo, salida => $salida, dato => $dato, preparador => $preparador,
        estadisticas=>\%ESTADISTICAS_INTEGRACION,
        estado => { t => $t, estados => \%e, impuestos => \%imp, continuacion_integra=>$coord }, hasta => $hasta, cambios => $dato->{GLOBAL}{continuar},
        (defined $plazo ? (plazo => $plazo) : ()), %donde);
    $PRESERVAR_INFORME=0;
    $TIEMPOFINAL = $hasta;
    my $pglm=Siru::PGLMNumerado->resumen(\%ESTADISTICAS_INTEGRACION);print "$pglm\n" if length $pglm;
    graficar($dato);
    exit 0;
}
# El .dsa entra por aca solo en el camino coordinado del generador mtk: el
# dato lo da el lector, y los sistemas, Siru::PreparadorMTK.
# UN PAR .dsa COMO CASO ENTERO (18/11/2026, pedido del autor: mover los .ds
# a viejos). 'siru CASO.M.dsa' es lo que antes era 'siru CASO.ds': el deck
# completo, con el DU del CASO.DU.dsa de al lado (Siru::ModeloFuente lo
# agrega cuando nadie va a dar el DU). Con --modelo el DU sigue viniendo por
# stdin, que es otra cosa.
if ($archivo =~ /\.(?:d|ds|ds2|dat|dsa)\z/i
    || ($preparador_mtk && $archivo =~ /\.dsa\z/i)) {
    # La salida se nombra por el archivo fuente, no por el .din que se arme
    # despues: ese vive en un directorio temporal que se borra. Asi el .simul
    # queda al lado de la fuente y con su nombre por cualquiera de los caminos.
    ($salida = $archivo) =~ s/\.[^.]+\z/.simul/ unless defined $salida;
    salida_libre();
    # El selector (siruviejo/LLAVES.md 12) dice que caso es, sin armar nada:
    #
    #   1. sin circuito, con derivadas
    #   2. con llaves, lazos de C, cortes de L o varios metodos de RK
    #   3. circuito sin nada de eso
    #   4. un solo punto: no hay estados
    #
    # El 1, el 2 y el 3 se integran, y los corre lo mismo: antes de cada paso
    # se prepara el sistema de la configuracion de ese paso, si no estaba. Que
    # terminen usando un sistema o varios sale de la corrida. El 4 no se
    # integra: Calcula lo resuelve una vez.
    require Siru::Circuito;
    my ($caso, $dato, $preparador) = $solo_punto
        ? (4, Siru::Circuito::_dato($archivo), undef)
        : Siru::Circuito->caso($archivo, $preparador_mtk);
    require Siru::Dibujo;
    Siru::Dibujo->hacer($archivo, $dato);
    $TIEMPOFINAL = eval { $dato->{GLOBAL}{defpar}{TIEMPOFINAL}{value} };
    $MEDIDAS = eval { $dato->{GLOBAL}{medidas} };
    {
        # SALIDA_DESDE=[t]: la tabla empieza en t (Siru::Salida)
        # SIN CREAR LA CLAVE AL LEERLA (18/11/2026): el eval protege del undef
        # pero Perl la autovivifica igual, asi que esta corrida le agregaba
        # control.SALIDA_DESDE={value=>[]} al dato, y la FIRMA de la
        # continuacion no coincidia con la guardada: "estado INTEGRA
        # incompatible con modelo, datos o metodos" y --continuar se caia con
        # el codigo 25 en toda la familia e2e.
        my $sd;
        {
            my $c = $dato->{GLOBAL}{control};
            my $v = ref($c) eq 'HASH' ? $c->{SALIDA_DESDE} : undef;
            my $l = ref($v) eq 'HASH' ? $v->{value} : undef;
            $sd = ref($l) eq 'ARRAY' ? $l->[0] : undef;
        }
        if (defined $sd) {
            require Siru::Salida;
            no warnings 'once';
            $Siru::Salida::DESDE = 0 + $sd;
        }
    }
    $VERIFICACIONES = eval { $dato->{GLOBAL}{verificaciones} };
    $ESPECTROS = eval { $dato->{GLOBAL}{espectros} };
    $CURVAS = eval { $dato->{GLOBAL}{curvas} };
    $GUION = eval { $dato->{GLOBAL}{guion} };
    $PARAMETROS_MEDIDAS = eval {
        require Scalar::Util;
        my $dp = $dato->{GLOBAL}{defpar} // {};
        +{ map { my $v = ref($dp->{$_}) eq 'HASH' ? $dp->{$_}{value} : $dp->{$_};
                 defined $v && !ref($v) && Scalar::Util::looks_like_number($v) ? ($_ => 0 + $v) : () } keys %$dp };
    };
    my %donde = (calcula => (defined($calcula) ? File::Spec->rel2abs($calcula) : 'calcula'),
        bibliotecas => (defined($bibliotecas) ? File::Spec->rel2abs($bibliotecas) : undef));
    if ($solo_punto || $caso == 4) {
        warn "siru: no se usan servicios PGLM numerados al resolver un punto\n"
            if keys %{Siru::PGLMNumerado->entorno};
        # No hay tiempo, ni paso, ni Runge-Kutta: entran los datos, sale la
        # solucion, y ahi termina.
        my $dir = tempdir('.siru-din-XXXXXX', DIR => $base, CLEANUP => 1);
        my ($ruta, $datos) = Siru::Circuito->din_punto($archivo, $dir);
        require Siru::UnPunto;
        Siru::UnPunto->correr(din => $ruta, salida => $salida, datos => $datos, dato => $dato,
            origen => $dato->{OTHERINFO}{dsa_origen}//$archivo,
            solo_punto => $solo_punto, %donde,
            (defined $plazo ? (plazo => $plazo) : ()),
            directorio => Siru::Preparador::_directorio($archivo));
        graficar($dato);
        emitir_documento();
        exit 0;
    }
    $FILAS = Siru::Circuito->correr_con_reruns(archivo => $archivo, salida => $salida,
        estadisticas => Siru::ROS->lista($dato) ? \%ESTADISTICAS_ROS : \%ESTADISTICAS_INTEGRACION,
        (defined $plazo ? (plazo => $plazo) : ()),
        dato => $dato, preparador => $preparador, %donde);
    my $pglm=Siru::PGLMNumerado->resumen(\%ESTADISTICAS_INTEGRACION);print "$pglm\n" if length $pglm;
    graficar($dato);
    emitir_documento();
    exit 0;
}
my $config;
if ($archivo =~ /\.din\z/i) {
    warn "siru: no se usan servicios PGLM numerados al ejecutar directamente un .din\n"
        if keys %{Siru::PGLMNumerado->entorno};
    # La corrida esta en el .din, en sus propias secciones de texto llano:
    #
    #   # corrida       desde, hasta, paso, tiempo
    #   # adaptacion    metodo, orden_error, absoluto, relativo, paso_min, paso_max
    #   # parametros    nombre valor
    #   # estados       actual siguiente inicial estimacion [estimacion_e5 estimacion_e3]
    #
    # Van COMENTADAS porque el .din lo lee Calcula, que compila cada linea con
    # ExprTk: lo que no es comentario tiene que ser una ecuacion. Asi la
    # corrida viaja en el mismo archivo sin que Calcula tenga que saber de
    # ella.
    #
    # Sin JSON y sin ninguna ruta: el .din es el archivo que nos dieron, y
    # donde se escribe lo decide quien simula.
    # Un .din BASE (con lineas # @estado y sin estados de integracion) no
    # trae el metodo: siru le agrega las ecuaciones del metodo pedido
    # (integra de su # corrida, o --rk N) y corre el ampliado resultante.
    require Siru::DesdeDin;
    if (my $base_din = Siru::DesdeDin->leer_base($archivo)) {
        my $numero = $rknum // $base_din->integra;
        die "El .din base no dice el metodo (integra en # corrida); indique --rk N\n"
            unless defined $numero;
        ($salida = $archivo) =~ s/\.din\z/.simul/i unless defined $salida;
        $temporal_netlist //= tempdir(CLEANUP => 1);
        ($din_base, $ruta_din_base) = ($base_din, $archivo);
        $archivo = $base_din->escribir_ampliado($numero, $temporal_netlist);
        print "Sistema ampliado con el metodo $numero\n";
    }
    require Siru::Din;
    my $s = Siru::Din->leer($archivo);
    require Siru::BulirschStoer;
    if (Siru::BulirschStoer->de_din($s)) {
        ($salida=$archivo) =~ s/\.din\z/.simul/i unless defined $salida;
        salida_libre();
        $TIEMPOFINAL=$s->{corrida}{hasta};
        $FILAS=Siru::BulirschStoer->correr_din(din=>$archivo,salida=>$salida,
            estadisticas=>\%ESTADISTICAS_INTEGRACION,
            calcula=>defined($calcula)?File::Spec->rel2abs($calcula):'calcula',
            (defined($bibliotecas)?(bibliotecas=>File::Spec->rel2abs($bibliotecas)):()),
            (defined($plazo)?(plazo=>$plazo):()));
        print "Escritas $FILAS filas en $salida\n";
        graficar();
        exit 0;
    }
    require Siru::SPLIT;
    if (Siru::SPLIT->de_din($s)) {
        ($salida=$archivo) =~ s/\.din\z/.simul/i unless defined $salida;
        salida_libre();
        $TIEMPOFINAL=$s->{corrida}{hasta};
        $FILAS=Siru::SPLIT->correr_din(din=>$archivo,salida=>$salida,
            estadisticas=>\%ESTADISTICAS_INTEGRACION,
            calcula=>defined($calcula)?File::Spec->rel2abs($calcula):'calcula',
            (defined($bibliotecas)?(bibliotecas=>File::Spec->rel2abs($bibliotecas)):()),
            (defined($plazo)?(plazo=>$plazo):()));
        print "Escritas $FILAS filas en $salida\n";
        graficar();
        exit 0;
    }
    require Siru::ROS;
    if (Siru::ROS->de_din($s)) {
        ($salida=$archivo) =~ s/\.din\z/.simul/i unless defined $salida;
        salida_libre();
        $TIEMPOFINAL=$s->{corrida}{hasta};
        $FILAS=Siru::ROS->correr_din(din=>$archivo,salida=>$salida,
            estadisticas=>\%ESTADISTICAS_ROS,
            calcula=>defined($calcula)?File::Spec->rel2abs($calcula):'calcula',
            (defined($bibliotecas)?(bibliotecas=>File::Spec->rel2abs($bibliotecas)):()),
            (defined($plazo)?(plazo=>$plazo):()));
        print "Escritas $FILAS filas en $salida\n";
        graficar();
        exit 0;
    }
    # un .din con elementos K no se puede correr solo: la historia de la
    # convolucion (e_k1, r_k1) la da Circuito en cada paso
    die "El .din tiene elementos K (convolucion): corra el .d o el .ds, que guarda la historia; un .din solo no alcanza\n"
        if @{ $s->{convoluciones} || [] };
    my %corrida = %{$s->{corrida}};
    my %adaptacion = %{$s->{adaptacion}};
    my %parametros = %{$s->{parametros}};
    my @estados = Siru::Din->estados_de_integracion($s);
    die "El .din no tiene seccion estados; regenere el ampliado desde el .d\n"
        unless @estados;
    $config = { %corrida, parametros => \%parametros, estados => \@estados };
    $config->{glm} = Siru::Din->glm_de_din($s);
    $config->{descriptor_glm} = $s->{descriptor_glm};
    require Siru::PGLM;
    $config->{pglm} = Siru::PGLM->de_din($s);
    $config->{descriptor_pglm} = $s->{descriptor_pglm};
    # 'tiempo' nombra la variable del sistema que es el tiempo: no es un
    # parametro fijo, el integrador la pone en cada paso.
    $config->{nombre_tiempo} = delete $config->{tiempo}
        if defined $config->{tiempo};
    # 'pasos' nombra la que recibe la cantidad de pasos dados (TICK)
    $config->{nombre_pasos} = delete $config->{pasos}
        if defined $config->{pasos};
    $config->{adaptacion} = \%adaptacion if %adaptacion;
    $config->{dinamico} = $archivo;
    # La salida es siempre un .simul, por cualquiera de los caminos: el
    # formato no depende de si el sistema pasa por din, por mdin o por un
    # punto solo. Lo elige la extension (ver Integrador::correr).
    ($salida = $archivo) =~ s/\.din\z/.simul/i unless defined $salida;
    salida_libre();
    $config->{salida} = $salida;
    $TIEMPOFINAL //= $config->{hasta};
} else { die $uso; }

# El calcula-maquina: --calcula si lo dieron, y si no el del PATH. La
# configuracion no lo dice, a proposito: un archivo generado no lleva adentro
# la ruta de instalacion de quien lo genero.
$config->{ejecutable} = defined($calcula) ? File::Spec->rel2abs($calcula) : 'calcula';
$config->{bibliotecas} = File::Spec->rel2abs($bibliotecas) if defined $bibliotecas;

die "Falta dinamico en la configuracion\n" unless defined($config->{dinamico});
$config->{dinamico} = ruta($base, $config->{dinamico});
$config->{salida} = defined($salida) ? File::Spec->rel2abs($salida)
    : ruta($base, $config->{salida} // die "Falta salida en la configuracion\n");
my %entorno;
if (defined $config->{bibliotecas}) {
    my $ruta = ruta($base, $config->{bibliotecas});
    $entorno{LD_LIBRARY_PATH} = $ruta . ($ENV{LD_LIBRARY_PATH} ? ":$ENV{LD_LIBRARY_PATH}" : '');
}
my ($sesion, $sesion_salidas);
eval {
    $sesion = Siru::Calcula->new(
        origen => $archivo,
        ejecutable => $config->{ejecutable}, dinamico => $config->{dinamico},
        entorno => \%entorno, timeout => $plazo // $config->{timeout} // 10,
    );
    # Las salidas pedidas (# salidas del .din base, los RESULTADOS del DU):
    # el .din base, dados parametros, estados y tiempo, determina el punto,
    # asi que una segunda sesion de Calcula con ese sistema resuelve las
    # salidas de cada fila. La abscisa (la variable tiempo) la escribe el
    # escritor de por si y no se repite como columna.
    my %opcion_salidas;
    if ($din_base && !$config->{glm} && !$config->{pglm}) {
        my @pares = grep { $_->[1] ne $din_base->{tiempo} } @{$din_base->{salidas}};
        if (@pares) {
            $sesion_salidas = Siru::Calcula->new(
                origen => $ruta_din_base,
                ejecutable => $config->{ejecutable}, dinamico => $ruta_din_base,
                entorno => \%entorno, timeout => $plazo // $config->{timeout} // 10,
            );
            my @columnas = map { $_->[1] } @pares;
            my @nombres = map { $_->[0] } @pares;
            my ($parametros, $tiempo) = ($config->{parametros}, $din_base->{tiempo});
            %opcion_salidas = (salidas => {
                columnas => \@columnas, nombres => \@nombres,
                valores => sub {
                    my ($t, $estado) = @_;
                    return $sesion_salidas->evaluar(
                        { %$parametros, %$estado, $tiempo => $t }, \@columnas);
                },
            });
        }
    }
    die "salida densa requiere un unico metodo con extension continua\n" if defined($ENV{SIRU_SALIDA_PASO})
        && ($config->{glm} || $config->{pglm});
    require Siru::IntegradorGLM if $config->{glm};
    my $motor = $config->{pglm} ? 'Siru::PGLM' : $config->{glm} ? 'Siru::IntegradorGLM' : 'Siru::Integrador';
    my $filas = $motor->integrar(
        sesion => $sesion,
        parametros => $config->{parametros}, estados => $config->{estados},
        ($config->{glm} ? (glm => $config->{glm}, descriptor => $config->{descriptor_glm}) : ()),
        ($config->{pglm} ? (pglm => $config->{pglm}, descriptor => $config->{descriptor_pglm}) : ()),
        desde => $config->{desde}, hasta => $config->{hasta}, paso => $config->{paso},
        nombre_paso => $config->{nombre_paso}, nombre_tiempo => $config->{nombre_tiempo},
        nombre_pasos => $config->{nombre_pasos},
        max_pasos => $config->{max_pasos}, adaptacion => $config->{adaptacion},
        estadisticas => \%ESTADISTICAS_INTEGRACION,
        salida => $config->{salida},
        %opcion_salidas,
    );
    $sesion_salidas->cerrar() if $sesion_salidas;
    $sesion->cerrar();
    $FILAS = $filas;
    print "Escritas $filas filas en $config->{salida}\n";
    1;
} or do {
    my $error = $@ || 'error desconocido';
    $sesion_salidas->cerrar() if $sesion_salidas;
    $sesion->cerrar() if $sesion;
    die $error;
};
graficar();
