#!/usr/bin/perl
use strict;
use POSIX qw(strftime);

################################################################################################
#  script pour passer du format .pos ou .msh genere par herezh pour gmsh au format .geo        #
#  version 1: version initiale  octobre 2015                                                   #
################################################################################################

my $nom;
my $version = "1."; 
if (@ARGV[0] eq '-h')
 # si on n'a pas d'argument, on donne le mode d'emploi
{ 
  print  ("\n");
  print  ("\n" . '#############################################################################');
  print  ("\n" . '#									    #');
  print  ("\n" . '#				msh2geo.pl				    #');
  print  ("\n" . '#    transformation d\'un format .pos ou .msh genere par herezh pour gmsh    #');
  print  ("\n" . '#    en un fichier .geo				    #');
  print  ("\n" . '#############################################################################');
  print  ("\n" . '#  licence GPL, 		       gerard.rio@univ-ubs.fr		    #');
  print  ("\n" . '#				     http://www-lg2m.univ-ubs.fr/~rio	    #');
  print  ("\n" . '#  version '."$version".'       							    #');
  print  ("\n" . '#############################################################################');
  print  ("\n\n\n");
  print ("\n usage: msh2geo.pl  ");
  print ("\n   ----> entree interactive des noms de fichier \n");
  print ("\n usage: msh2geo.pl <nom fichier.msh ou .pos> <nom fichier.por> \n");
  print ("\n   ----> indication de la source et de la cible ");
  print ("\n         NB: les noms de fichier peuvent avoir ou non leur extension \n");
  print ("\n usage: msh2geo.pl -v ");
  print ("\n   ----> affiche la version du programme  \n");
  print ("\n usage: msh2geo.pl -h ");
  print ("\n   ----> information sur l'utilisation  \n");
  print  ("\n\n");
  die ("arret normal");
 }
elsif (@ARGV[0] eq '-v')
{ print  ("\n  msh2geo.pl: version "."$version"."\n\n");
  die ("arret normal");
 };

#------------------- écriture de l'entete à l'écran  -----------------
print  ("\n");
print  ("\n" . '#############################################################################');
print  ("\n" . '#									    #');
print  ("\n" . '#				msh2geo.pl				    #');
print  ("\n" . '#    transformation d\'un format .pos ou .msh genere par herezh pour gmsh    #');
print  ("\n" . '#    en un fichier utilisable par RDM6				    #');
print  ("\n" . '#############################################################################');
print  ("\n" . '#  licence GPL, 		       gerard.rio@univ-ubs.fr		    #');
print  ("\n" . '#				     http://www-lg2m.univ-ubs.fr/~rio	    #');
print  ("\n" . '#  version '."$version".'       							    #');
print  ("\n" . '#############################################################################');
print  ("\n\n\n");
 

#------------------- fin écriture de l'entete à l'écran  -----------------

#------------------- on s'occupe tout d'abord des fichiers --------------------

# tout d'abord on récupère le nom du fichier à traiter
my $nombase;
if (@ARGV[0])
 # si on a un argument, c'est le nom du fichier
 { $nombase = @ARGV[0];}
else
 # sinon on demande interactivement le nom du fichier
 { print ("\n nom du fichier ? ");
   $nombase = <STDIN>; chomp($nombase); # on supprime le retour à la ligne
  }; 

# on supprime l'extension .msh si elle existe
$nombase =~ s/\.msh//; 
# idem pour l'extension .pos si elle existe
$nombase =~ s/\.pos//; 

# on ouvre le fichier msh en lecture tout d'abord, il doit donc exister
my $fichier_msh = $nombase . '.msh'; # premier essai avec le .msh
unless (open (fic_msh,$fichier_msh))
 { # cas d'un pb d'ouverture, on essaie avec un .pos
   my $fichier_msh = $nombase . '.pos';
   open (fic_msh,$fichier_msh) || 
      die (" \n erreur en ouverture du fichier " . $fichier_msh . " et .msh \n");
 };

# on ouvre le fichier .geo en écriture, on écrase donc le fichier existant 
my $fichier_geo;
if (@ARGV[1])
 # si on a un argument 2, c'est le nom du fichier de sortie
 { $fichier_geo = @ARGV[1];}
else
  # sinon on construit le nom du fichier
 {$fichier_geo = $nombase . '.geo';
  # on regarde s'il existe déjà 
  foreach (<*.geo>) 
  { if ($_ eq $fichier_geo)
    { print ("\n le fichier " . $fichier_geo . " existe deja ! ");
      print ("\n voulez-vous l\' ecraser ? (0 ou N ) ");
      my $rep = <STDIN>; chomp($rep); $rep=lc($rep); # lc passage en minuscule
      if ($rep eq 'n')
      {print ("\n nom du fichier de sortie ? ");
      $fichier_geo = <STDIN>; chomp($fichier_geo);
      };
    };
  }; # fin du foreach
 };
# on supprime l'extension .geo si elle existe
$fichier_geo =~ s/\.geo//;
# et on la rajoute
$fichier_geo .= '.geo'; 

# maintenant on tente l'ouverture de fichier 
open (fic_geo,">$fichier_geo") || die (" \n erreur en ouverture du fichier " . $fichier_geo . " \n");
 
#------------------------ fin des ouvertures de fichiers ---------------------


#------------------ lecture de l'entete jusqu'aux noeuds -------------
print ("\n lecture de l'entete ");
# on lit dans les lignes jusqu'au mot clé $Nodes
my $position_sur_node = 0; # pour signaler que l'on est à la position des noeuds
# ++++++++++++++++++++++ lecture des coordonnées des noeuds ++++++++++++++++++++++++++
print ("\n lecture des coordonnees des noeuds ");
# on lit dans les lignes jusqu'au mot clé $Nodes
my $ligne;my @champ;
if ($position_sur_node != 1)
{ while (<fic_msh>)
  { $ligne = $_; chomp($ligne); # sauvegarde de la ligne
    $ligne =~ s/^[ \t]+//mg;  # suppression des blancs et tabulation en début de ligne
    @champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces 
    # on lit dans le fichier jusqu'au mot clé $Nodes
    if ( $champ[0] eq '$Nodes' ) 
     {$position_sur_node = 1; 
       last;}; # on a trouvé le premier enreg,   
  };
  if ($position_sur_node != 1)
  { die ( "\n on n'a pas trouve le mot cle \$Nodes ?? , on ne peut pas continuer \n");
   };
};  

# --- on lit le nombre de noeud
$ligne = <fic_msh>; chomp($ligne);
$ligne =~ s/^[ \t]+//mg;  # suppression des blancs et tabulation en début de ligne
@champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces 
print ("     nombre total de noeuds lus : " . $champ[0] );
my $nb_noeud = $champ[0] ;

# --- on lit chaque ligne de coordonnée que l'on recopie dans un tableau jusqu'au mot clé $EndNodes
my @les_noeuds = () ; # déclaration du tableau des coordonnées des  noeuds
while (<fic_msh>)
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
  $ligne =~ s/^[ \t]+//mg;  # suppression des blancs et tabulation en début de ligne
  @champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces 
  # on lit dans le fichier jusqu'au mot clé $EndNodes
  if ( $champ[0] eq '$EndNodes' ) 
     {last;}; # on a trouvé le premier enreg,
  # ce n'est pas le mot clé, donc on enregistre la ligne   
  push @les_noeuds, $ligne; # sauvegarde des coordonnées et du numéro initial du noeud
};


# ++++++++++++++++++++++ fin de lecture  des coordonnees noeuds ++++++++++++++++++++++++++++++++++++

#-------- def de tableaux de conversion entre les numérotations gmsh et celles d'herezh++ ----------

# définition des types d'éléments

my @type_element = ( 'rien pour le  numero 0',    # '0' 
   'segment lineaire a 2 noeuds' ,   	          # '1' 
   'triangle lineaire a 3 noeuds' ,	          # '2' 
   'quadrangle bilineaire a 4 noeuds' ,           # '3' 
   'tetrahedre lineaire a 4 noeuds' ,	          # '4' 
   'hexahedre trilineaire a 8 noeuds' ,           # '5' 
   'pentaedre bilineaire a 6 noeuds' ,	          # '6' 
   'pyramide a 5 noeuds' ,		          # '7' 
   'segment quadratique a 3 noeuds' ,	          # '8' 
   'triangle quadratique a 6 noeuds' ,	          # '9' 
  'quadrangle quadratique complet a 9 noeuds' ,   #'10'  
  'tetraedre quadratique a 10 noeuds' , 	  #'11'  
  'hexaedre quadratique complet a 27 noeuds' ,	  #'12'  
  'pentaedre quadratique complet a 18 noeuds' ,   #'13'  
  'pyramide quadratique a 14 noeuds' ,		  #'14'  
  '  point a 1 noeud ' ,			  #'15'  
  'quadrangle quadratique incomplet a 8 noeuds' , #'16'  
  'hexaedre quadratique incomplet a 20 noeuds' ,  #'17'  
  'pentaedre quadratique incomplet a 15 noeuds' , #'18'  
  'pyramide quadratique incomplete a 13 noeuds'   #'19'  
                  );

my @type_herezh_element = ( 'rien pour le  numero 0', #  '0' 
   ' POUT BIE1 ' ,   	       # '1'
   ' TRIANGLE LINEAIRE ' ,     # '2'
   ' QUADRANGLE LINEAIRE ' ,   # '3'
   ' TETRAEDRE LINEAIRE ' ,    # '4'
   ' HEXAEDRE LINEAIRE ' ,     # '5'
   ' PENTAEDRE LINEAIRE ' ,    # '6'
   ' PYRAMIDE LINEAIRE ' ,     # '7'
   ' POUT QUADRATIQUE ' ,      # '8'
   ' TRIANGLE QUADRACOMPL ' ,  # '9'
  ' QUADRANGLE QUADRACOMPL ' , #'10' 
  ' TETRAEDRE QUADRACOMPL '  , #'11'  
  ' HEXAEDRE QUADRACOMPL '  ,  #'12'  
  ' PENTAEDRE QUADRACOMPL ' ,  #'13'  
  ' PYRAMIDE QUADRACOMPL ' ,   #'14'  
  ' POINT LINEAIRE ' ,	       #'15'  
  ' QUADRANGLE QUADRATIQUE ' , #'16'  
  ' HEXAEDRE QUADRATIQUE ' ,   #'17'  
  ' PENTAEDRE QUADRATIQUE ' ,  #'18'  
  ' PYRAMIDE QUADRATIQUE '     #'19'  
                  );

# les types et nombre de points d'intégration pour chaque éléments:
# le premier chiffre indique le nombre de pti par défaut, si 0 : il n'y a pas plusieurs choix: un seul cas par défaut
# puis les différents cas						
my @type_herezh_integration = ( [0], #'rien pour le  numero 0', #  '0' 
   [0], # ' POUT BIE1 ' ,   	       # '1'
   [0], # ' TRIANGLE LINEAIRE ' ,     # '2'
   [0], # ' QUADRANGLE LINEAIRE ' ,   # '3'
   [0], # ' TETRAEDRE LINEAIRE ' ,    # '4'
   [8,1,27,64], # ' HEXAEDRE LINEAIRE ' ,     # '5'
   [2,1,6], # ' PENTAEDRE LINEAIRE ' ,    # '6'
   [0], # ' PYRAMIDE LINEAIRE ' ,     # '7'
   [0], # ' POUT QUADRATIQUE ' ,      # '8'
   [0], # ' TRIANGLE QUADRACOMPL ' ,  # '9'
  [0], # ' QUADRANGLE QUADRACOMPL ' , #'10' 
  [0], # ' TETRAEDRE QUADRACOMPL '  , #'11'  
  [8,1,27,64], # ' HEXAEDRE QUADRACOMPL '  ,  #'12'  
  [6,9,12,18], #' PENTAEDRE QUADRACOMPL ' ,  #'13'  
  [0], # ' PYRAMIDE QUADRACOMPL ' ,   #'14'  
  [0], # ' POINT LINEAIRE ' ,	       #'15'  
  [0], # ' QUADRANGLE QUADRATIQUE ' , #'16'  
  [8,1,27,64], # ' HEXAEDRE QUADRATIQUE ' ,   #'17'  
  [6,9,12,18], # ' PENTAEDRE QUADRATIQUE ' ,  #'18'  
  [0], # ' PYRAMIDE QUADRATIQUE '     #'19'  
                  );

my @nbn_par_elem; 
  $nbn_par_elem[0]=0; $nbn_par_elem[1]=2; $nbn_par_elem[2]=3; $nbn_par_elem[3]=4;	  
  $nbn_par_elem[4]=4; $nbn_par_elem[5]=8; $nbn_par_elem[6]=6; $nbn_par_elem[7]=5;	  
  $nbn_par_elem[8]=3; $nbn_par_elem[9]=6; $nbn_par_elem[10]=9; $nbn_par_elem[11]=10;	  
  $nbn_par_elem[12]=27; $nbn_par_elem[13]=18; $nbn_par_elem[14]=14; $nbn_par_elem[15]=1;	  
  $nbn_par_elem[16]=8; $nbn_par_elem[17]=20; $nbn_par_elem[18]=15; $nbn_par_elem[19]=13;
  
# $connex[i][j] donne pour l'element i, le num de gmsh  pour le numéro j  d'herezh
  
my @connex = ( [], # le premier avec rien, pour que la numérotation commence à 1
   [1,2], #  1: ' POUT BIE1 ' ,   	      
   [1,2,3], # 2:  ' TRIANGLE LINEAIRE ' ,     
   [1,2,3,4], #  3: ' QUADRANGLE LINEAIRE ' ,   
   [1,2,3,4], #  4:  ' TETRAEDRE LINEAIRE ' ,    
   [1,2,3,4,5,6,7,8], #  5: ' HEXAEDRE LINEAIRE ' ,     
   [1,2,3,4,5,6], #  6: ' PENTAEDRE LINEAIRE ' ,    
   [1,2,3,4,5], #  7: ' PYRAMIDE LINEAIRE ' ,     
   [1,3,2], #  8: ' POUT QUADRATIQUE ' ,      
   [1,2,3,4,5,6], #  9: ' TRIANGLE QUADRACOMPL ' ,  
   [1,2,3,4,5,6,7,8,9], # 10: ' QUADRANGLE QUADRACOMPL ' , 
   [1,2,3,4,5,6,7,8,10,9], # 11: ' TETRAEDRE QUADRACOMPL '  , 
   [1,2,3,4,5,6,7,8,9,12,14,10,11,13,15,16,17,19,20,18,21,22,24,25,23,26,27], # 12: ' HEXAEDRE QUADRACOMPL '  ,  
#     [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27]   uniquement pour voir les numéros   
   [1,2,3,4,5,6,7,10,8,9, 11,12,13,15,14,16,18,17], #  13:' PENTAEDRE QUADRACOMPL ' ,  
   [1,2,3,4,5,6,7,8,9,10,11,12,13,14], #  14:' PYRAMIDE QUADRACOMPL ' ,   
   [1], #  15: ' POINT LINEAIRE ' ,	       
   [1,2,3,4,5,6,7,8], #  16: ' QUADRANGLE QUADRATIQUE ' , 
   [1,2,3,4,5,6,7,8,9,12,14,10,11,13,15,16,17,19,20,18], # 17: ' HEXAEDRE QUADRATIQUE ' ,  
#   [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20], # 17: ' HEXAEDRE QUADRATIQUE ' ,   
   [1,2,3,4,5,6,7,10,8,9, 11,12,13,15,14], #  18:' PENTAEDRE QUADRATIQUE ' ,  
   [1,2,3,4,5,6,7,8,9,10,11,12,13], # 19:  ' PYRAMIDE QUADRATIQUE '      
              );
	        	  
my @type_geom = 
 ( 'RIEN_TYPE_GEOM',  # '0' 
   'LIGNE' ,   	      # '1' 
   'SURFACE' ,	      # '2' 
   'SURFACE' ,        # '3' 
   'VOLUME' ,	      # '4' 
   'VOLUME' ,         # '5' 
   'VOLUME' ,	      # '6' 
   'VOLUME' ,	      # '7' 
   'LIGNE' ,	      # '8' 
   'SURFACE' ,	      # '9' 
   'SURFACE' ,        #'10'  
   'VOLUME' , 	      #'11'  
   'VOLUME' ,	      #'12'  
   'VOLUME' ,         #'13'  
   'VOLUME' ,         #'14'  
   'POINT_G' ,	      #'15'  
   'SURFACE' ,        #'16'  
   'VOLUME' ,         #'17'  
   'VOLUME' ,         #'18'  
   'VOLUME'           #'19'  
                  );

#-------- fin def de tableaux de conversion entre les numérotations gmsh et celles d'herezh++ ----------
		   

# ++++++++++++++++++++++ lecture  des éléments +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
print ("\n lecture des elements ");

while (<fic_msh>)
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
  $ligne =~ s/^[ \t]+//mg;  # suppression des blancs et tabulation en début de ligne
  @champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces 
  # on lit dans le fichier jusqu'au mot clé $Elements 
  if ( $champ[0] eq '$Elements' ) 
     {last;}; # on a trouvé le premier enreg,
};

# ----- on lit le nombre d'éléments
$ligne = <fic_msh>; chomp($ligne);
$ligne =~ s/^[ \t]+//mg;  # suppression des blancs et tabulation en début de ligne
@champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces 
print ("   nombre total d'elements lus : " . $champ[0] );
my $nb_element = $champ[0] ;
 

# --- on lit chaque ligne que l'on recopie dans des tableaux jusqu'au mot clé $EndElements
 
my @liste_element = (); # ce sera un tableau multidimentionel
# chaque élément de @liste_element est une liste d'éléments d'un m^eme type 
#   $liste_element[i] = la liste des éléments de type i 
#  $liste_element[i][j] un élément = une liste d'entiers donc un tableau 
#  $liste_element [i][j][k] = un scalaire (entier) ouf !!

my @number_type = (); # les nombres d'élément de chaque type

while (<fic_msh>)
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
  $ligne =~ s/^[ \t]+//mg;  # suppression des blancs et tabulation en début de ligne
  @champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces 
  # on lit dans le fichier jusqu'au mot clé $EndElements 
  if ( $champ[0] eq '$EndElements' ) 
     {last;}; # on a trouvé le premier enreg,
  # traitement et enregistrement 
  push @{$liste_element[$champ[1]]}, [@champ ];  # tableau multidimentionnel, syntaxe particulière
#if ( $champ[1] == 15) 
#   {print "\n trouve " . @champ; print " ligne = " . $ligne;
#    print ",,, " .$champ[0]." ".$champ[1]." ".$champ[2]." ".$champ[3]." ".$champ[4]." ".$champ[5]." ";};
  $number_type[$champ[1]]++;
};


# test débug
#print "\n essai= " . $liste_element[15][1][3] ;
#print "\n une tranche

# on recherche le nombre d'élément différent
my $nb_type_elem = 0;
my $taille_list_elem = $#liste_element;
#print "\n number_type = " . @number_type;
for (my $j=1;$j<=$taille_list_elem;$j++)
{ if ($number_type[$j]  != 0)
    { print "\n nombre d'elements du type ".$type_element[$j] ." = " . $number_type[$j] ;
      $nb_type_elem++;
      };      
};

print "\n nombre initial d'elements differents " . $nb_type_elem ;
# en fait on ne conserve que les éléments lignes à 2 noeuds
# on signale les éléments supprimés

for (my $j=1;$j<=$taille_list_elem;$j++)
{ if ($number_type[$j]  != 0)
    { if (($type_element[$j] ne 'segment lineaire a 2 noeuds') 
          &&  ($type_element[$j] ne 'triangle lineaire a 3 noeuds') 
          &&  ($type_element[$j] ne 'quadrangle bilineaire a 4 noeuds') 
#          &&  ($type_element[$j] ne 'triangle quadratique a 6 noeuds') 
#          &&  ($type_element[$j] ne 'quadrangle quadratique complet a 9 noeuds') 
#          &&  ($type_element[$j] ne 'quadrangle quadratique incomplet a 8 noeuds') 
         ) 
        {print (' *** on supprime les elements '.$type_element[$j] .'*** '. "\n");
	      $number_type[$j] = 0;
	    }	
    };      
};

# ++++++++++++++++++++++ fin lecture des éléments ++++++++++++++++++++++++++



close (fic_msh);


#====================== écriture du fichier .geo ============================

#------------------- écriture de l'entete du fichier .geo ---------------------

print fic_geo ("\n".'//************************************************************************');
print fic_geo ("\n".'//  fichier genere automatiquement par msh2geo.pl');  
print fic_geo ("\n".'//************************************************************************');
#  cas particulier de la date
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();
print fic_geo ("\n".'// date: ');
printf fic_geo ("%02d/%02d/%02d", $mday, $mon, (1900+$year));
print fic_geo ('  heure: ');
printf fic_geo (" %02d:%02d:%02d", $hour, $min, $sec);

# variables globales
print fic_geo ("\n\n".'dens = 1.e6 ; // densite des noeuds aux points ');


#------------------- écriture des points ---------------------

print fic_geo ("\n".'// les points ');

#              ------ la liste des coordonnées des noeuds --------
for (my $k=0; $k < $nb_noeud; $k++)
{ my $enreg = @les_noeuds[$k];
  @champ = split (/\s+/,$enreg); # le /s+/ permet de séparer sur des espaces 
  print fic_geo ("\nPoint(". $champ[0] .') = {'. $champ[1] .','. $champ[2] .','. $champ[3].',dens};' );     
}


#-------------------- écriture des lignes = poutres --------------------
# ici uniquement un type d'éléments à sortir
# mais si on voulait par la suite des éléments triangles ou autre on
# laisse la procédure générale de msh2her.pl
my $nb_elementASortir = 0;
for (my $j=1;$j<=$taille_list_elem;$j++)
{ if ($number_type[$j]  != 0)
    { $nb_elementASortir += $number_type[$j];};      
};
print fic_geo ("\n\n".'// les lignes  ( '."$nb_elementASortir".' )');

#              ------ écriture des éléments lignes ------           

my $numero = 1;
for (my $j=1;$j<=$taille_list_elem;$j++)
{ if ($number_type[$j]  != 0)
    { my $nb_el = $number_type[$j];
      for (my $el = 0;$el < $nb_el;$el++)
       { my $nbtag = $liste_element[$j][$el][2];
         # si c'est une poutre on définit directement une ligne
									my $tyyp = $liste_element[$j][$el][1]; # le type de l'élément
         if ($type_element[$j] eq 'segment lineaire a 2 noeuds')
          {
												# écriture du numéro de l'élément puis du descriptif
												printf fic_geo ("\n".'Line('. $numero.') = {' );
												#print " tyyp= ".$tyyp."\n";
												for (my $ia =0;$ia < $nbn_par_elem[$j]; $ia++)
													{ # $ia = numéro d'ordre du noeud au format gmsh
															# $connex[$tyyp][$ia]  = numéro d'ordre du noeud au format herezh++
															#print " ia= " . $ia ." connex= " . $connex[$tyyp][$ia]." ";
															my $bb = $liste_element[$j][$el][2+ $nbtag + $connex[$tyyp][$ia] ]; # le numero herezh
															if ($ia+1 != $nbn_par_elem[$j])
																	{print fic_geo ( $bb . ', ' );}
															else
																	{print fic_geo ( $bb . '}; ' );};  
													};
												$numero++;
          }
         # sinon il s'agit d'un élément de membrane
         else
          { # on va créer un contour puis une surface        
            my $nb_ligne = $nbn_par_elem[$j]; # le nombre de ligne à créer
            my $premier_num_ligne = $numero; # pour se rappeler
												for (my $ia =0;$ia < $nbn_par_elem[$j]; $ia++)
													{ # $ia = numéro d'ordre du noeud au format gmsh
															# $connex[$tyyp][$ia]  = numéro d'ordre du noeud au format herezh++
															#print " ia= " . $ia ." connex= " . $connex[$tyyp][$ia]." ";
															printf fic_geo ("\n".'Line('. $numero.') = {' );
															my $bb = $liste_element[$j][$el][2+ $nbtag + $connex[$tyyp][$ia] ]; # le numero herezh
															if ($ia+1 != $nbn_par_elem[$j])
																	{ my $dd = $liste_element[$j][$el][2+ $nbtag + $connex[$tyyp][$ia+1] ]; # le numero herezh
																	  print fic_geo ( $bb . ', '.$dd.'}; ' );
																	}
															else
																	{my $dd = $liste_element[$j][$el][2+ $nbtag + $connex[$tyyp][0] ]; # le numero herezh
																	  print fic_geo ( $bb . ', '.$dd.'}; ' );
																	};
															$numero++;		
													};
												# on crée la loop de contour					
#Line Loop(D1) = {1,9,2,10,3,4,5,11,6,12,7,8} ;
            my $num_loop = $numero;
												printf fic_geo ("\n".'Line Loop('. $num_loop.') = {' );
												for (my $ia =0;$ia < $nbn_par_elem[$j]; $ia++)
														 {my $somme = $premier_num_ligne+$ia;
														  if ($ia+1 != $nbn_par_elem[$j])
														    { print fic_geo ( $somme . ', ' );}
	               else
	                 { print fic_geo ( $somme . '}; ' );};  
               };
            $numero++;
												# on crée la surface
#Plane Surface(D2) = {D1,tt[1],tt[2],tt[30]} ;
												printf fic_geo ("\n".'Plane Surface('. $numero.') = {'.$num_loop.'};' );
												$numero++;					
           
          };
       };
   };      
};

print fic_geo ("\n");

  
# écriture de la fin du fichier

#print fic_geo ("\n".'$fin du fichier'."\n");
close (fic_geo);  # fermeture du fichier de maillage .geo

print  ("\n" . '#############################################################################');
print  ("\n" . '#				msh2geo.pl				    #');
print  ("\n" . '#		    fin creation du fichier .geo pour gmsh		    #');
print  ("\n" . '#############################################################################'."\n\n");


