#!/usr/bin/perl

#{[(%
#hace paraplot desde $ref o desde $caj o desde .ds
#traduce de un archivo $archivo a ..  para gnuplot y lllama a gnuplot

use warnings;
use strict;
use Text::Abbrev;
use Data::Dumper;
use File::Basename;
use Cwd;
use Storable;


# OFRECER clean, cuardar todo lo que crea y bonerlo en un a boorar
# ofrecer celan dep borrar TODAS LAS GRAFICAS
# y clean 1 para borrar todo lo con el nombre que se ponga 


#lss1  todos escriben ahi
#lss2 es sceptre
#ls3  noclas es lss1 y clas en ls3
#ls4 mensajes del fortran compilando
#ls5 de la ejecucion  del fortran
#lsg son mesnajes del gnuplot 
#lsp seran mensajes del paraplot.pl 
  
#para paraplort.pl
use Simusol::AyudasPP;    
use Simusol::ParaPlot;  #ex plotgraf
use Simusol::ArchSimul;

# para plotgnu.pl
use Simusol::AuxiliaresPP;    #crear_tmp   OJO CAMBIO RETURN DE ELEGIR ARCHIVOS
use Simusol::Globales;
use Simusol::PlotGNU;
use Getopt::Long;
use Pod::Usage; 

     $Simusol::AyudasPP::progr{'simplot'}='p';
     #comienza el log con simplot.ls3, luego en cada origen hace origen.ls3 
     Simusol::AyudasPP::abrir_ls3({},'simplot','simplot');   
     #http://search.cpan.org/dist/Log-Log4perl/lib/Log/Log4perl.pm
#exit;

    my ($commlineinfo,$archivos)=Simusol::AyudasPP::desmenuzar_comando(1);


#print Dumper $archivos;
#exit;
    #warn " O: $archivos->{outdir}, PP:  $commlineinfo->{progpath} PN:  $commlineinfo->{progname}, CA $commlineinfo->{cantarg};\n" ;
    #print "archivos ", Dumper $archivos;
    #print "commlineinfo ", Dumper $commlineinfo;
    #foreach (keys %{$archivos->{arg}}){
	#print "ARCHIVO $archivos->{arg}->{$_}->{dirs}->[4] <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n";	
        #}
    

    if (not $commlineinfo->{opciones}->{nokill} or not defined $commlineinfo->{opciones}->{nokill} and $commlineinfo->{opciones}->{kill}){
	#print "Matando gnuplot\n";
        system "killall gnuplot_x11 2>/dev/null";
}

    if ($commlineinfo->{opciones}->{kill}){
	# return();
	my $NF='SI';
	if (not defined $commlineinfo->{opciones}->{nofiles} ){
	    $NF ='';
	    }
	warn "SALGO KILL nofiles: $NF cantarg $commlineinfo->{cantarg}\n ";
	########## arreglar buscaq files, esto sirvce pero arregalr
	exit 0; #es normal
        }



    if (not scalar keys %{$archivos->{arg}}){
       if ($commlineinfo->{cantarg}==0){
          print "usar simplot ARCH (sin extension, busca @{$archivos->{extensiones}})  @ARGV \n";         
          }
       print "No encontro archivos\n";    
       exit 0;  # es normal
       }


    #print Dumper $archivos;
    
    Simusol::PlotGNU::inicio();
    Simusol::AuxiliaresPP::inicio($commlineinfo); # antes de buscafile por elegir   
    Simusol::AyudasPP::inicio($commlineinfo,0,', paraplot',$archivos);
    Simusol::Globales::inicio($commlineinfo);
    Simusol::ParaPlot::inicio($commlineinfo);

print "A procesar: \n";

 Simusol::AyudasPP::archiva("#NUEVO PROCESA",'P',$archivos,'');       

 foreach (@{$archivos->{argumentos}}){
    my $ll=$archivos->{arg}->{$_}->{dirs};
    printf ("%30s: %30s  %20s   %-10s   \n", $_,$ll->[1],$ll->[0],$ll->[3]);
  }

#print Dumper $archivos->{arg};
print "---------------------------------------------------------------\n";


    foreach my $elemento (@{$archivos->{argumentos}}){
       #para que este en stdout y stderr
       warn "ARCHIVO $archivos->{arg}->{$elemento}->{dirs}->[4] <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n";
      # print "ARCHIVO $archivos->{arg}->{$elemento}->{dirs}->[4] <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n";

      
       # llama a abrir LS3  ....LSS1,  intenta imprimr antes cuando no tiene nombre de archivo procesado, usa simplot.ls3 y simplot.log
       Simusol::AyudasPP::abrir_ls3($archivos,$elemento,$commlineinfo->{progname});   
       # solo hay un log, en este programa termina en extension .ls3
       # cada origen genera uno, y cuando arranca o finaliza el procesamiento del origen es simplot.ls3

       #print Dumper $archivos;
       #exit;
       
       
       procesaarchivo($elemento,$archivos,$commlineinfo);
       close  $Simusol::AyudasPP::SALIDAlog;
       }
########################################################################

sub procesaparasimul{
    my ($GRAFICOS,$archivos,$elemento);
    my @simules;
    my $CORTOSIN;
    my $val;
    my $cartelvar;
    
              #$AGRAFICOS=$seccion->{GRAFICOS};  if variable
              # VER TIEMPO, STOPTIME

 	      foreach (@$GRAFICOS){
	          my $ARCHIVO;
		  my $ARCHIVOREAL;
		  #print "ZZZ $_\n";
		  if($_=~/^archivo\s+([a-zA-Z0-9_]+)\s*=\s*(.+)/){		  
		      $ARCHIVO=$1;
      		      $ARCHIVOREAL=$2;
		      print "ARCHIVO $ARCHIVO - $ARCHIVOREAL\n";
		      push (@simules,[$ARCHIVO,$ARCHIVOREAL]);
		  }
              }


	

	#### MAL NO NECESARIAMENTE SIMUL SE LLAME ASI, PUEDE HABER VARIOS ADEMAS!!!!
	 foreach (@simules){
	     my ($ok3,$val,$primerdato,$cartelvar,$unidades,$magnitudes)= Simusol::ArchSimul::campossimul($CORTOSIN.".simul");
             if ($ok3 == -1){
               warn "No coincide encabezado con datos"; 
 	       return -1;
             }elsif( $ok3 != 1){
	       warn "Otro error";
	       return;
               }	
	     # val es sceptervar cartelvar es variabledefantasia
	     print "CARTELVAR (fantasia)  @$cartelvar  | VAL (sceptre) @$val | @$unidades | @$magnitudes\n";
	
 	     #print "VAL ", Dumper $val;

	     $archivos->{arg}->{$elemento}->{simul}->{$CORTOSIN.".simul"}->{variables}=$val;
	     Simusol::ParaPlot::leeUNIDADESdeSIMUL($unidades,$magnitudes,$val,$cartelvar,$Simusol::ParaPlot::tablaunisimul);
	 }
}
####################################################################################################
sub  leererun{
	  my  ($PROPIOSIN)=@_;
	  my $reruns=[];
          if (-e "$PROPIOSIN.res"){
              if (not system "grep RERUN $PROPIOSIN.res >/dev/null 2>/dev/null") {
                 my $rerun = `grep RERUN $PROPIOSIN.res`;
                 chomp $rerun; 
                 $rerun =~ s/^.+RERUN\s.\///;  
                 $reruns = [1..$rerun];
                 };        
          }else{
 	     #warn "No hay $PROPIOSIN.res";
  	     # no pasa nada con que no exista
             };

	  return $reruns;
	}
################################################################################################## de gnuplot.pl
sub cambioseccion{
    my ($linea,$secciones)=@_;
    # identifica las lineas que indican cambio de seccion    
     ##################################################3 cuidado no avisa de circuitos abiertos o cosas mal, quizas las calcule bien
     # verficar : ramas sueltas, circutos separados
    # verifcar que esten intial condition y no defined parameters ver bien, arreglar para que no afecte

   
    
    my $secc=1;
 
    my $final=23;
    my $ultimo=20;
#    my $final=24;
#    my $ultimo=21;
   
    foreach (@$secciones){
       #print "CAMBIOSECC >$linea< - >$_<\n";	
       if($linea eq $_){
	      #print "$linea -nueva sección: $secc";
  	      last;
              }
       $secc++;	   
       }
       if ($secc>$final){
               $secc=0; # ninguna es
       }elsif ($secc>$ultimo){
               $secc=-2;
	       #print "seccion no definida o no encontrada\n";
	       #            print "Error de seccion no definida aún: \n>  $linea\n";
              }		    
return  ($secc);    
}
###############################################################
sub leesimul{
	    my ($archivos,$elemento,$tablaunisimul,$quearchivo)=@_;
	    my $CORTOSIN;
	    if ($quearchivo){
                $CORTOSIN = $archivos->{arg}->{$elemento}->{dirs}->[2];
	       $CORTOSIN.=".simul";
	    }else{
	       $CORTOSIN= $archivos->{arg}->{$elemento}->{dirs}->[4];
	    }
	#### MAL NO NECESARIAMENTE SIMUL SE LLAME ASI, PUEDE HABER VARIOS ADEMAS!!!!
	my ($ok3,$val,$primerdato,$cartelvar,$unidades,$magnitudes)= Simusol::ArchSimul::campossimul($CORTOSIN);
        if ($ok3 == -1){
           warn "No coincide encabezado con datos"; 
	   return (-1);
       }elsif( $ok3 < 0){  # ver bien que numero poner, ver ciclo en programa
	       warn "Otro error";
	       return (-1);
               }	
	# val es sceptervar cartelvar es variabledefantasia
	#print "CARTELVAR (fantasia)  @$cartelvar  | VAL (sceptre) @$val | @$unidades | @$magnitudes\n";

	    Simusol::ParaPlot::leeUNIDADESdeSIMUL($unidades,$magnitudes,$val,$cartelvar,$tablaunisimul);

	    $archivos->{arg}->{$elemento}->{simul}->{$CORTOSIN.".simul"}->{variables}=$val;
	    $archivos->{arg}->{$elemento}->{undato}=$primerdato; # un dato simplemente
            my  $cantvars=     scalar @{$val};
	    #     print "CANTVARS $cantvars \n";
	    return (1,$val,$cartelvar,$cantvars);
}
###############################################################################

sub leetradvar{ 
          my($tradvar,$CORTOSIN)=@_;
	  if (-e $CORTOSIN.".tvar"){
              open  my $TVAR, "<", $CORTOSIN.".tvar" or die "No pude grabar $CORTOSIN.tvar $! ";
              while (my $row=<$TVAR>){
		  chomp $row;
		  my ($uno,$dos,$tres)=split(/:/,$row);
		  $tradvar->{$uno}=[$dos,$tres];
	      }
	      close $TVAR;	      
	  }
	
	  #print "TTTTTTT ", Dumper $tradvar;
	  #exit;
}
##########################################################################################
    sub  leeds{
	  my ($CORTO)=@_;
	  my $seccion;
	      my $sec=0;
	      # no eta bueno aceptar_graficos y graficos se superponen, usar solo graficos y si es aceptar en otros
	     my @renglonesds;
	      my $secciones=["CIRCUIT_DESCRIPTION", "ELEMENTS", "INITIAL_CONDITIONS", "OUTPUTS",    #circuit description se lo captura antes legacy
                #5             6                     7        8            
                "CONTROL_EQUATIONS","DEFINED_PARAMETERS", "MODELS","EQUATIONS",
                #9           10          11          12                    
                "VARIABLES", "FUNCTIONS","CONSTANTS","ELEMENT_DESCRIPTION",    
                                                     #element description se lo captura antes. igual se usa en forma directa
                #13                 14 PARAPLOT 15           16  ACEPTAR_GRAFICOS   17       18     19         20
		"FORCED_VARIABLES", "XXXX", "RESULTADOS","UNIDADES","GRAFICOS",  "DATA","DATABLOB","RUN_CONTROLS",		   
		  # NO DEFINIDAS
#		#21         22
#		"REF","STATE" , 
                # 21             22           23
		"RERUN", "CONTINUE",  "EXECUTE" # estos 3 se los captura antes llegar, no son secciones
	        ];
             my $ok=  open (my $ENTRADA,  $CORTO) ;
             if (not $ok) {                                        # REVISAR
                  warn "No existe el archivo $CORTO"; # dir:$DIRC";
             }else{
                  #Simusol::AyudasPP::parar3(12,"No existe el archivo $archpar dir:$DIRC");
                  @renglonesds = <$ENTRADA>;
                  close $ENTRADA;
	          }
	  # CAMBIAR LO DE AGREGA
	  $seccion->{GRAFICOS}=[];
	  $seccion->{RESULTADOS}=[];
	  $seccion->{UNIDADES}=[];
             foreach(@renglonesds){	
		 chomp;
		 my $nsec=cambioseccion($_,$secciones);
		 if ($nsec) {
                     $sec=$nsec;
		     }
		 #print "XX $_, NSEC $nsec - SEC $sec\n";
		 if (not $nsec and $sec>=15 and $sec<=17 and $_){
                    if ($sec==15) { #RESULTADOS, para separar en dos un renglon por coma, ver en paraplot leecaj	
                      $_=~s/^\s+//;
                      $_=~s/\s+$//;
         	      if ($_=~/\(/){                      ################# OJO ESTO ES UN DISPARATE por jol,kiol, y no jol(,),
	              	# no es obvio separar por comas las lineas, usar ;
		        #                           no permitir mas de una variable por linea	                
			push (@{$seccion->{$secciones->[$sec-1]}},$_);
	              }else{
		        my @w =split(/\s*,\s*/,$_);
			push (@{$seccion->{$secciones->[$sec-1]}},@w);	     
		        }
		  }else{
                      push (@{$seccion->{$secciones->[$sec-1]}},$_);
		  }		   
		  }		 	         
	         }
	      # print Dumper $seccion;
	      my $UNIDADES=$seccion->{UNIDADES};
	      my $GRAFICOS=join ("\n",@{$seccion->{GRAFICOS}});
	  
	      my $RESULTADOS=$seccion->{RESULTADOS};
              #print "RESULTADOS @$RESULTADOS\n";
              return ($GRAFICOS,$RESULTADOS,$UNIDADES);
	 }


##############################################################
sub procesaarchivo{    
    my($elemento,$archivos,$commlineinfo)=@_;

    # esta rutina procesa un archivo definido concreto, existente, con extension definida y ubicado en algun lugar
    # segun su extension lo procesa, si se especifico antes sin extension, aqui encuentra "el archivo mas avanzado"
    # con ese nombre. Si se quiere uno previo, borrar el avanzado que sera sobreescrito
    # avance segun datos de precedencia: 1 (simul u otro solo o con ds, caj, hashpĺot), 2 (paraplot), 3 (gra)

    # y si le pido dia, que hago (proceso con simusol1 y simusol3 ??? para tener simul y hashplot?)
    # mejor no, que eso lo haga simusol
    
    #print "COMM LINE y OPT_HASH ", Dumper $commlineinfo;
      
    my $arc=$archivos->{arg}->{$elemento}->{dirs};
    my $PROPIOSIN  =$arc->[0];  #SOLO 
    my $CORTOSIN   =$arc->[2];  #BASE+SOLO
    my $EXT        =$arc->[3];  #EXT    
    my $CORTO      =$arc->[4];  #BASE+SOLO+EXT
    my $ESTIPOSIMUL=$arc->[-1];  #TIPO esta en el 9, no lo pone prepfile si precedencia

    #print "PROCESA ARCHIVO ELE: $elemento === EXT: $EXT ==== CORTO: $CORTO === TIPO:  $ESTIPOSIMUL ==================================================\n";
    #print " simplot 209 \n";
    #print Dumper $archivos;
            
    #exit -1;      
    ####################### podria venir de simusol1.pl, si se lo llama en ese marco

    my $paraplot;
    my $GRAFICOS;
    my $AGRAFICOS;
    my $reruns;
    my $refcircuito={};
    my $cantvars=0;
    my $tradvar={};
    Simusol::AyudasPP::archiva("#NUEVO PROCESA",'S',$archivos,$elemento);
			       
    $archivos->{arg}->{$elemento}->{variables}=[];

    
    # PREPARA REFCIRCUITO Y GRAFICOS Y AGRAFICOS
    if ($ESTIPOSIMUL==10 or $EXT eq '.simul' ){  
                           # estetipo==10 NO ES NINGUNA DE LAS EXTENSIONES CONOCIDAs, solo llega aca si explicaitamente se lo llama
       # intenta trabajar solo con un archivo de datos y crear todo a partir de alli, puede ser simul o una extension
       # cualquiera
       #warn "OPCION 10  $CORTO  - $EXT $ESTIPOSIMUL es como si fuese archivo de datos\n";
       # sigo con otros archivos
       # ver simul contenidos en paraplot en subdirs

	# caso solo se tiene simul
	my $plantilladef="Termico";

	my  ($ok,$val,$cartelvar);
        ($ok,$val,$cartelvar,$cantvars)=leesimul($archivos,$elemento,$Simusol::ParaPlot::tablaunisimul,0);
	  if ($ok != 1){
           warn "Mal leesimusol"; 
	   return (-1);
	  }

       if ($cantvars){	  
         
	   # RESULTADOS SE LLENA CON VAL PARA QUIE GRAFIQUE TODO, incluso si simul tiene la info lo hace bastante bien
	  
	   my $RESULTADOS;
           @$RESULTADOS=@$val;  # se escribe asi para saber cual es resultados
	   # ojo cambiar la referencia cambia ambas;-
	    shift @$RESULTADOS;   # Con este método se grafican todas las columnas contra la primera, por ende se saca la primera columna de las que se representan
           #print Dumper $RESULTADOS;
	  # exit;
	  Simusol::ParaPlot::prepara($refcircuito,$val,{},$RESULTADOS,$cartelvar,$Simusol::ParaPlot::tablaunisimul,$Simusol::ParaPlot::tablauni,$plantilladef,"","",$archivos,$elemento);

           $refcircuito->{datos}=$refcircuito->{CORTO};
	  
          }	     

	#print "GRAFICOS  $GRAFICOS - $AGRAFICOS\n";
	#exit;
	
    }elsif($EXT eq '.caj') { #   

  	  ########## poner  $archivos->{arg}->{$elemento}
	  # caso se parta de results y se tenga simul
	  my $plantilladef="Termico";

          my  ($ok,$val,$cartelvar,$ZZZcantvars)=leesimul($archivos,$elemento,$Simusol::ParaPlot::tablaunisimul,1);   
          if ($ok != 1){
           warn "Mal leesimusol"; 
	   return (-1);
	   }
    	
	  #print "VAL ", Dumper $val;
  
          leetradvar($tradvar,$CORTOSIN);
	  
          # modifica refcircuito y crea GRAFICOS Y AGRAFICOS
	  # si hay cantvars asume que viene de un simul, por eso se pone cero, tampoco se usa $cartelvar en este caso

          my $RESULTADOS=[];
          my $UNIDADES="";
          my $STOPTIME="";
	  my $TIEMPO="";

          if  ( -e $CORTO and not $cantvars){  # debiera existir
	          ($RESULTADOS,$GRAFICOS,$AGRAFICOS,$TIEMPO,$STOPTIME,$UNIDADES)= Simusol::ParaPlot::leecaj($CORTO);	
          }else{
	         shift @$val;
                 @$RESULTADOS=@$val;
                 $TIEMPO='segundos';
                 #  exit;      
                 }

	  my $reruns=leererun($PROPIOSIN);

	  
	  # lee cuadro caj, antes por defecto y de simul
	  Simusol::ParaPlot::leeUNIDADES($UNIDADES,$Simusol::ParaPlot::tablauni);
	  
          # print Dumper $Simusol::ParaPlot::tablaunisimul,$Simusol::ParaPlot::tablauni; 
          #exit;
 
   	  #  ABRE Y LEE ARCHIVO .caj o .ds   devuelve refcircuito   y ParaPlot::settime()	
          #print "RESULTADOS ", Dumper $RESULTADOS;
	  #exit;

	  Simusol::ParaPlot::prepara($refcircuito,$val,$tradvar,$RESULTADOS,$cartelvar,$Simusol::ParaPlot::tablaunisimul,$Simusol::ParaPlot::tablauni,
                                     $plantilladef,$TIEMPO,$STOPTIME,$archivos,$elemento);

	  print "REFCIRCUITO- ", Dumper $refcircuito;
          $refcircuito->{datos}=$refcircuito->{CORTOSINDIA}.'.simul';
	  
	  #cambia refcircuito leyendo caj o el mismo refcircuito
          # recrea lo mejor que puede refcircuito
	  ########### OJO GRAFICOS Y AGRAFICOS VER!!!!!
	  
    }elsif ($EXT eq '.ds'){
   	  ########## poner  $archivos->{arg}->{$elemento}
	  # caso se parta de results y se tenga simul
          my $plantilladef="Termico";
	    
          # modifica refcircuito y crea GRAFICOS Y AGRAFICOS
	  # si hay cantvars asume que viene de un simul, por eso se pone cero, tampoco se usa $cartelvar en este caso
	  my $seccion;

          my $STOPTIME="";
	  my $TIEMPO="";

          my ($RESULTADOS,$UNIDADES);
	  #print "CORTO $CORTO\n";
	  ($GRAFICOS,$RESULTADOS,$UNIDADES)=leeds($CORTO);
	    	    
	  my $nres= scalar @$RESULTADOS;
	  #my $ngra= scalar @$GRAFICOS;
	  my $ngra= $GRAFICOS;

	  ######################################################
	  if ($nres) {  # and not $ngra   # igual falta ver si los queremos o no, otra variable de ds
		                    
	      my  ($ok,$val,$cartelvar,$ZZZcantvars)=leesimul($archivos,$elemento,$Simusol::ParaPlot::tablaunisimul,1);
	      if ($ok != 1){
                 warn "Mal leesimusol"; 
	         return (-1);
	         }

	
	         Simusol::ParaPlot::leeUNIDADES($UNIDADES,$Simusol::ParaPlot::tablauni);

	
                # print Dumper $Simusol::ParaPlot::tablaunisimul,$Simusol::ParaPlot::tablauni; 
        	#exit;
		
   	        #  ABRE Y LEE ARCHIVO .caj o .ds   devuelve refcircuito   y ParaPlot::settime()	
  	        Simusol::ParaPlot::prepara($refcircuito,$val,$tradvar,$RESULTADOS,$cartelvar,$Simusol::ParaPlot::tablaunisimul,$Simusol::ParaPlot::tablauni,$plantilladef,$TIEMPO,$STOPTIME,$archivos,$elemento);

	        $refcircuito->{datos}=$refcircuito->{CORTOSINDIA}.'.simul';
                 #cambia refcircuito leyendo ds 
                 # recrea lo mejor que puede refcircuito
	         ########### OJO GRAFICOS Y AGRAFICOS VER!!!!!
                 }
           
         
    }elsif ($EXT eq '.hashplot'){              
        # aca hay una descripcion del grafico sea con hash, results, o paraplot
        ############################ ESTO ES EL VIEJO paraplot.pl  
        #o la parte de simusol1.pl referida a la creacion de paraplots.

        $refcircuito = retrieve($arc->[4]); 
        
        $refcircuito->{datos}=$refcircuito->{CORTOSINDIA}.'.simul';
    
        my $todas='';
        my $archguardar = $refcircuito->{PROPIOSINDIA}; 
        my $archguardarcongnus = $refcircuito->{CORTOSINDIA};

        
	
        if ($todas) {
                    $archguardar = "$archguardar"."_$todas";
                    $archguardar=~ s/\s+/_/g;
                    $archguardarcongnus =~ s/([^\/]+)$/gnus\/$1/;
                    $refcircuito->{refvalores}->{GRAFICOS} = undef;
	            };
  
        }
        #print Dumper $refcircuito;
        #exit -1;

    # PUEDEN VENIR GRAFICOS AGRAFICOS Y refcircuito, los dos primeros van a paraplot directo, refcircuito pasa por prograficarASUS 
    # VER SI VIENEN GRAFICOS O AGRAFICOS Y RESOLVER
##################################################################################################################
    print Dumper $refcircuito;
        
    #### PREPARA PARAPLOT  A PARTIR de refcircuito o/y AGRAFICOS o GRAFICOS     
    if ($refcircuito->{lisoutputssceptre} or $refcircuito->{refvalores}->{GRAFICOS} )  {   
	     #Simusol::ParaPlot::muestra_refcircuito($refcircuito,''); ## MUY OPA, solo imprime
	     #my $archguardar = =$refcircuito->{PROPIOSINDIA}; + .simul
  	     my $tradvar;

	     foreach (@{$refcircuito->{lismagnitudes}}){	       
		   $_=~s/_/ /g;	       
	           }

	     ($paraplot,$tradvar)=Simusol::ParaPlot::prograficarASUS($refcircuito,$archivos,$elemento,$refcircuito->{datos});
	     #print "JJ $refcircuito->{PROPIOSINDIA}\n";
	     #foreach (keys %$tradvar){
             #    print "$_:$tradvar->{$_} \n";
	     #    }	
             }

    if($AGRAFICOS){ # si hay graficos y agregar?  nada, sale solo graficos
             $paraplot.=$AGRAFICOS;
	     }	
    if ($GRAFICOS){  # si hay graficos se anula RESULTADOS
	     $paraplot=$GRAFICOS;     
             }

    #print "PARA $paraplot\n";
    if ($paraplot){
	# cambia los nombres que contiene el paraplot de acuerdo adonde deba salvarse el paraplot
	my $fileparaplot;
	($paraplot,$fileparaplot)=Simusol::ParaPlot::relativosparaplot($archivos,$elemento,$paraplot);
	#print Dumper $paraplot;
	print "========= PARAPLOT  ======\n $paraplot \n=============================\n";
    
        # escribe .paraplot, no es necesario
	 
        if (not defined $commlineinfo->{opciones}->{ncp} or not $commlineinfo->{opciones}->{ncp}  ){   # revisar relacion entre scp y scg
	     print "Escribe paraplot: $fileparaplot;      \n";
             Simusol::ParaPlot::escribepara($paraplot,$fileparaplot,$archivos,$elemento);      
	}
#	print "YA\n";
        # ojo el paraplot que se escribe puede estar en un lugar diferente del caj o hashplot que lo origina
        # y que usa este programa para sus tareas, por lo tanto la ubicacion de los archivos en el paraplot que
        # graba puede cambiar, esto recien se notara si alguien toma el nuevo paraplot creado y genera graficos con el
        # el paraplot que sale de aqui puede ser el que entra o el que viene de GRAFICOS etc
        } #else {
	##warn "No hay paraplot:  $elemento\n"; # puede no haber si es gra, no es error    
        #}

    
    if (defined $commlineinfo->{opciones}->{scp}){

	warn "Opcion solo creo paraplot vigente";
	return (1);

    }
    
    my $renglonesparaplot=[];
    my $archivogra;
    my $Xarchivosgra;
    my $losgnu={};
    
    # en ambos casos crean png y eps
    my $paraarchivos;   # para generar los archivos gra y gnu 
    my $paraver;        # para mostrar los graficos
    
    ############################ Apartir de aca es el simusol3.pl

    # prepara RENGLONES de paraplot a partir de archivo o texto paraplot
    if ($EXT eq '.paraplot' or $paraplot){
           	
           #caso sale de simul y no hay archivo paraplot todavia creado
	   # caso simul, hay arcdat pero no paraplot
           # todo eso del simul es un disparate, aca solo puede llegar si es caj ds hasplot paraplot	    

	   #separa texto o lee archivo, en ambos casos separa en renglones
	   my $date;
           ($date,$renglonesparaplot)=Simusol::ParaPlot::pararenglones($paraplot,$archivos,$elemento);
           }

    # prepara GRA y gnus con renglonesparaplot
    ### OJO esto de los reruns, viene de prepara!!! y si esta en un paraplot?
    
    if(scalar @$renglonesparaplot){

	   # no debiera ser necesario pero por ahi aparece un archivo paraplot viejo hecho con otro simusol viejo.
	   foreach (@$renglonesparaplot){
	       if ($_=~/^magnitudes/){
		   $_=~s/_/ /g;  
	           }
	       }

	
           #print "RENGLONES========= PARAPLOT  ======\n ", join("\n",@$renglonesparaplot), "\n=============================\n";
	   my $ok;
           ($ok, $archivogra,$Xarchivosgra,$paraarchivos,$paraver,$losgnu)=Simusol::PlotGNU::gnuplot($renglonesparaplot,$elemento,$archivos,$reruns,
                                          $commlineinfo->{opciones}->{noverb},
        				  $commlineinfo->{opciones}->{graf},
					  $commlineinfo->{opciones}->{ncgf},
                                          " Preparado por $commlineinfo->{progname} \n  #   Se ejecuta con: gnuplot -persist"
	       );

	   #print "ARCHGRA $archivogra\n";
           #toma los datos de $paraplot o si es vacia de arch.paraplot, ojo el nombre arch igual hay que ponerlo
           # porque crea otros archivos con ese nombre (y otras extensiones)

	 
	   
           if ($ok != 1){
	        warn "ERROR en gnuplot";
                return -1}
	  } 

    ################################# Ejecucion de los gra/gnu, sean de archivo de la linea de comando, sea de texto $paraver
    # crea png eps dumb y muestra X11
    if ($EXT eq '.gra'){
	   $archivogra=$CORTO;
           $Xarchivosgra=$CORTOSIN;
           }
    
    if ($commlineinfo->{opciones}->{graf} >= 3) {        
        Simusol::PlotGNU::ejecutagra($archivogra,$Xarchivosgra,$paraver,$losgnu,$archivos,$elemento);
      }else {
        explic(" Se ha pedido no mostrar graficos, pero se podran ver con $archivogra  " . '-' x 15);
        }
   

    # MUESTRA ESTADISTICAS
    my $propiosin=$archivos->{arg}->{$elemento}->{dirs}->[0];    
    # if (not $hayparend) {  # y porque no ver si existe archivo .par?
    if (-e  $propiosin.".par") {  # y porque no ver si existe archivo .par?
         system "cat $propiosin.par";
         };
    
    if (-e "$propiosin.res" and  $commlineinfo->{opciones}->{graf} ne '2'  and not $commlineinfo->{opciones}->{noverb}) {
         system "cat $propiosin.res";
         foreach (@$reruns) {  
           # quizas sea mas facil ver si hay archivos de ese tipo, 
           #aunque asi mas control, si hubo y no los borraron
           system "cat ${propiosin}_$_.res";
           }; 
         };
    
    return (1);  
}

################################################################################################################
 
sub versionnum{
    my $version=0.34;
    return $version;
}


################################################################################################################


sub help{
    my ($progname)=@_;
    pod2usage({-verbose => 0
		   ,-exit => 0    # esto lo hace salir???
		   ,-verbose=>2
	   ,-message => "   $progname ",versionnum(),"
       es parte del conjunto de scripts de S I M U S O L
            mas ayuda con   
	       man $progname
	    y luego salga con   q\n"   
	   });
}
################################################################################################################

sub version{
    my ($progname)=@_;
    print "$progname versión: ",versionnum(),"\n\n";
}


#)]}
__END__

=encoding utf8

=head1 NAME

simplot - Forma parte del proyecto Simusol.

L<http://www.simusol.org/simplot>

Realiza gráficos a partir de archivos con datos tabulados, e instrucciones especiales, orientados a 
publicaciones científicas.

Simusol usa simplot para graficar los resultados de sus simulaciones.

=head1 VERSION

  Version 0.34

=head1 SYNOPSIS

B<simplot> [I<opciones>]  [I<argumentos>]


=head1 OPTIONS AND ARGUMENTS

=over 5

=item B<-h  --help>

Muestra este mensaje de ayuda 

=item B<-v  --version>

Muestra version.

=item B<-d>

Produce algunos mensajes para depuracion de errores del programa. pone el debug en 1

=item B<-nov --noverb>

Disminuye la cantidad de informacion no esencial que se da al ususrio.
Es un nivel de debug menor al normal

=item B<-sb> 

es para no tener en cuenta el basearg de un argumento


=item B<-scp> 

es para solo crear paraplot (simusol1)  ojo si esta activada ncp no sirve para nada, y termina sin hacer nada  

=item B<-ncgf> 

no crea graphic files


=item B<-ncp> 

no crea paraplot, si bien lo calcula para su grafico

=item B<-path> 

es para elegir_archivo

=item B<-impr> 

genera archivos png con los dia

=item B<-buscar> 

es junto para path, usa find

=item B<-notrad> 

es para simusol, no llama a simusol1

=item B<-nofiles>

no ejecuta ningun archivo, solo las acciones previstas por las opciones como -kill

=item B<-clean>

borra los archivos creados la ultima corrida, con archivo .clean

=item B<-cleandep>

borra, todos los archivos existentes del tipo de los producidos, salvo que sean la FUENTE, o eso intenta

=item B<-cleanalter>

borra todos los archivos existentes salvo la fuete pero con los nombres que figuran en argumentos

=item B<-comp> 

es para comparar original con backup de todos los archivos producidos en una corrida con la anterior

=item B<-pueden> 

ser muchos con numero los producidos, compara el ultimo con el anterior, los dos ultimos

=item B<-noclas> 

pone los archivos en el directorio corriente 

=item B<-toda> 

cambia las variables de salida, las pone a todas que empiecen con las letras que se indiquen, se pueden poner varios toda
 
=item B<-t --todas> I<comi>  
 
Se  ignoran  los pedidos de 
resultados y de graficos del diagrama y se sustituyen por el pedido de  
todas las variables cuyos nombres, para el sceptre, comienzan con  I<comi>
Si en I<comi> hay espacios habra que usar comillas. 
Por ejemplo,  con  B<-t VC>  se tendra, si es posible, el grafico de 
voltajes de todos los condensadores; para circuitos termicos 
corresponde a las temperaturas de todos los acumuladores, lo que tambien
 se puede pedir con  B<-t 'TEMP C'>. 


=item B<-graf> 

que tipo de graficos se necesita, con 


=over    

=item     

0 no llama a simusol3,  


=item     

1 hace graficos interactivos, 


=item     

3 el normal


=item     

4 no hace graficos pero hace los png


=item  

5 o chicos hace graficos para dos columnas, con letras mas grandes



=back

=back



(o abreviaturas distinguibles)


para las opciones no importan mayusculas o minusculas;


=over

=item  I<argumentos>

Nombres de argumentos separados por espacio. Son los archivos con
esquemas y datos para la simulacion, o bien directorios que los contienen, o bien nombres de archivos sin argumento.

Si no se especifica un argumento, toma como argumento el directorio corriente.

Cuando se especifica un archivo específico lo procesa

Cuando se especifica un directorio busca en su interior recursivamente, los archivos del tipo requerido 
y procesa todos los que encuentra

Cuando se especifica un archivo sin extension, busca todos los archivos con ese nombre y extensiones posibles, seleccionando la 
extensión que esta al final de la cadena de producción: simul -> ds|caj-> paraplot -> gra

Este trabajo es independiente de la expansión de la terminal usada. Lo que la terminal expanda en la línea de comandos mediante los comodines * y ? u otros es tomado por simplot.
       	           
Para nombres de archivos si importa el uso de  mayusculas o minusculas, si al sistema operativo le importa.

=back




=head1 DESCRIPTION

Produce gráficos en pantalla usando gnupĺot, y archivos graficos del tipo png y eps.

Esta redactado mayormente en lenguaje perl.

Debiera funcionar bien en sistemas GNU/Linux, y aunque no lo hemos probado tambien en Windows o MAC, con los instaladores apropiados.

Sólo disponemos por el momento instaladores del tipo make para GNU/LINUX o sistemas tipo UNIX, desarrollados con el módulo perl ExtUtils::MakeMaker

=over 5

=item I<arch_i>    

alguno de los archivos indicados en I<archivos>

=item I<arch_circuito>   

Archivos indicados en I<archivos> que corresponde a un circuito.

=back


=head1 LANGUGUES

=over

=item RESULTADOS

=item PARAPLOT 

=back

=head1 FILES


B<simplot>, trabaja con numerosos tipos de archivos.

Cada elemento colocado como argumento se traduce en una lista de archivos del tipo que puede procesar 
B<simplot> los que se acumulan y luego procesan uno a uno.

=over 5

=item I<archivo>B<.simul>

Archivo con los datos a graficar.

Puede ser usado en reemplazo de los archivos que siguen para definir el gráfico.
También se puede usar cualquier archivo con el formato de datos en columnas.

La información de encabezado si está codificada de ciertas  formas, las usadas por simusol y simul,
puede ser usada.

Usualmente se pone como archivo de entrada alguno de los siguientes, donde esta indicado el simul a graficar.

=item I<archivo>B<.ds>

Archivo de entrada a simul, contiene las especificaciones de graficos en lenguaje 
RESULTADOS y/o en lenguaje PARAPLOT

=item I<archivo>B<.hashplot>

Archivo producido por simusol, con toda la información que leyo del diagrama, incluida la necesaria para simplot.
Es un hash almacenado con el módulo de perl B<Storable>.

=item I<archivo>B<.caj>

Archivo producido por simusol, que contiene  información que esta en los cuadros del diagrama.
De no estar disponible archivo.hasplot puede usarse para generar gráficos con algunas limitaciones,
es posible que algunas variables que esten en el simul, tengan otro nombre en el .caj.


=item I<archivo>B<.paraplot>

Archivo producido por simplot o leido por este, escrito en lenguaje paraplot

=item I<archivo>B<.gra>

Archivo ejecutable que muestra los graficos en pantalla y genera los png y eps.

=item I<archivo>B<.tvar>

Archivo que contiene como traduce simusol las variables del usuario a las variables del sceptre
Si existe simplot lo lee, y al procesar archivos caj, lo usa. Esta información esta contenida tambien en el 
-hashplot y en general siempre se prefiere usar hasplot a caj, pero de existir solo un caj esta info puede ser util.

=back

Y los que produce, algunos de los producidos pueden tambien ser usados como entrada.

=over

=item I<archivo>B<.paraplot>

=item I<archivo>B<.gra>

=item I<archivo>B<.log>

=item I<archivo>B<.ls3>

=item I<simplot>B<.ls3>


Archivo del tipo log con todo lo que debe registrarse previo a procesar un archivo específico.

3 es porque simusol produce muchos archivos de log, en particular uno por estapa., como simplot en parte se procesaba en la etapa 3, quedo 3.


=back


Archivos de salida específicos para cada gráfico  producido:

=over


=item I<archivo_GRAFO>B<.gnu>

=item I<archivo_GRAFO>B<.png>

=item I<archivo_GRAFO>B<.eps>

=item I<archivo_GRAFO>B<.dumb>


##  no no hace ya estas ?? ls1???

=back




Para que lo procese B<sceptre> y siempre que la traducion se haya completado.

=over

=item I<archi>B<.caj>

Con copia de la informacion de los cuadros del archivo-diagrama y copia de las
claves o formulas de traduccion que se han utilizado en los calculos.

=item I<arch_ultimo>B<.paraplot>

Con indicaciones a ser procesadas por B<simusol3.pl>
para producir graficos.


produce otros archivos necesarios para el objetivo global de Simusol;  
pueden ser de utilidad tambien al usuario.


=item I<arch_ultimo>B<.lss1>

Con algunos mensajes sobre la traduccion.




=back

Ademas utiliza STDOUT y STDERR  


=head1 AUTHORS

Dolores Alia de Saravia <dolores@gmail.com>

Luis R. Saravia <luis.saravia@gmail.com>

Diego Saravia <dsa@ututo.org> 

Nilsa Sarmiento <nilsa@ututo.org> 

 

#       my ($ok3,$val,$undato,$cartelvar,$unidades,$magnitudes)= Simusol::ArchSimul::campossimul($arc->[4]);   
#       if ($ok3 == -1){
#           warn "No coincide encabezado con datos\n"; #
#	   return -1;
#       }elsif( $ok3 < 0){ # ver biuen que numero poner, ver ciclo en programa
#	       warn "Otro error";
#	       return;
 #          }	


#	Simusol::ParaPlot::leeUNIDADESdeSIMUL($unidades,$magnitudes,$val,$cartelvar,$Simusol::ParaPlot::tablaunisimul);

#	print Dumper $Simusol::ParaPlot::tablaunisimul;
#	exit;
	
#       $archivos->{arg}->{$elemento}->{variables}=$val;
#       $archivos->{arg}->{$elemento}->{undato}=$undato;
#       $cantvars=     scalar @{$val};
          
       # en todos los casos verifica que el numero de columnas se corresponda con el listado de columnas, si es simul es diferente
