pre-pos_processing_gmsh-herezh

#!/usr/bin/env perl

use strict;

use warnings;

use English;

use File::Basename;

use File::Spec::Functions qw(rel2abs);

use Cwd;

my $NOM_PROG = basename $PROGRAM_NAME;

#pattern d un reel pour les regex

my $format_reel = '[+-]?[\.]?\d+[\.]?\d*(?:[eE][+-]?\d*)?';

my $VERSION = '1.00';

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

#  script pour visualiser un ou plusieurs maillages dans Gmsh                                       #

#  version 1.00 : version initiale                                                                  #

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

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

# VARIABLES QUE L UTILISATEUR PEUT ETRE AMENE A RENSEIGNER  #

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

#

# les variables $exeHZ et $exeGMSH servent a imposer le choix des executables Herezh et Gmsh

#   (rq : les alias shell ne fonctionneront pas)

#

#commande HZ++ definie par l utilisateur (modifiable egalement avec l option -exeHZ)

my $exeHZ; # = 'mon_executable_a_moi';

#commande gmsh definie par l utilisateur (modifiable egalement avec l option -exeGMSH)

my $exeGMSH; # = 'mon_executable_a_moi';

#commande Herezh par defaut selon la plateforme

#  rq : ces variables seront utilisees uniquement si la variable $exeHZ n a pas ete definie

my $EXE_HZ_Linux64bits = 'HZppfast64';#linux 64 bits

my $EXE_HZ_MacOSX = 'HZppfast_Vn-1';#MacOSX

my $EXE_HZ_autres = 'HZppfast';#tous les autres systemes

#commande gmsh par defaut (quelque soit la plateforme)

#  rq : cette variable sera utilisee uniquement si la variable $exeGMSH n a pas ete definie

my $exeGMSH_defaut = 'gmsh';

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

# FIN VARIABLES UTILISATEUR                                 #

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

sub affichage_aide {

  use Text::Wrap;

  #config du package Text::Wrap

  $Text::Wrap::columns = 81;#le nombre de caracteres maximum par ligne sera egal a ($Text::Wrap::columns - 1) dans le cas ou utilise wrap

  #indentation de longueur $NOM_PROG

  my $indent_NOM_PROG = ""; $indent_NOM_PROG .= " " for(1 .. length($NOM_PROG));

  print "----------------------------------------\n";

  print " script $NOM_PROG (version $VERSION)\n";

  print "----------------------------------------\n";

  print "\n";

  print "But : visualiser la position des points d integration d un\n";

  print "      element avec Gmsh\n";

  print "\n";

  print "Usage : $NOM_PROG [-h|help] [-exeHZ path_HZ] [-exeGMSH path_GMSH] fher no_elt\n";

  print "\n";

  print "Dependance :\n";

  print "    > script hz_splitMail.pl\n";

  print "\n";

  print "Fonctionnement :\n";

  print wrap("      ", "    ", "$NOM_PROG lance des calculs herezh pour lire la ",

                               "position des points d integration dans le .maple et ",

                               "cree une visu Gmsh de l element et ses points ",

                               "d integration\n");

  print "\n";

  print "Arguments :\n";

  print "     o fher   : fichier .her\n";

  print "     o no_elt : numero de l element\n";

  print "\n";

  print "Options :\n";

  print "    -v : affichage du numero de version\n";

  print "\n";

  print wrap("    ", "                     ", "-exeHZ path_HZ : choisir l executable Herezh++. Le calcul Herezh se ",

                                                               "fera avec l executable path_HZ\n",

                                                               "par defaut : linux 64 bits   => path_HZ=HZppfast64\n", 

                                                               "             MacOSX (darwin) => path_HZ=HZppfast_Vn-1\n",

                                                               "             autres          => path_HZ=HZppfast\n",

                                                               "(a noter que les alias shell ne fonctionneront pas)\n");

  print "\n";

  print wrap("    ", "                         ", "-exeGMSH path_GMSH : choisir l executable Gmsh. La visualisation Gmsh se ",

                                                                       "fera avec l executable path_GMSH\n",

                                                                       "par defaut : path_GMSH=gmsh\n",

                                                                       "(a noter que les alias shell ne fonctionneront pas)\n");

  print "\n";

  print "Remarque :\n";

  print "    Liste des elements supportes par ce script :\n";

  foreach my $type_elt (conversion_eltType_her2gmsh('-liste_elts',0)) {

    print "      > $type_elt\n";

  }

  print "\n";

  print "Auteur :\n";

  print "   TROUFFLARD Julien\n";

  print "       julien.troufflard\@univ-ubs.fr\n";

  print "       julien.troufflard\@free.fr\n";

  print "----------------------------------------\n";

  exit;

}

#------------------------------------

#premier balayage des arguments

# => si option du style -h ou -help => affichage aide

#------------------------------------

my $isOpt_help = 0;

foreach my $arg (@ARGV) {

  if(($arg =~ /^-h$/i) or ($arg =~ /^-help$/i)) {

    $isOpt_help = 1;

  }

}

#si option -h|-help ou pas d arguments => affichage aide

if($isOpt_help or ($#ARGV == -1)) {

  affichage_aide();

}

#------------------------------------

#recuperation des arguments et options

#------------------------------------

my $fher;#fichier .her

my $no_elt;#numero de l element

my $opt;

my @args;

while($#ARGV != -1) {

  $opt = shift(@ARGV);

  #affichage numero version

  if($opt eq '-v') {

    print "\n $NOM_PROG : version $VERSION\n\n";

    exit;

  }

  #option -exeHZ

  elsif($opt eq '-exeHZ') {

    ($#ARGV >= 0) or die "\nErreur (prog:$NOM_PROG,opt:-exeHZ) : pas assez d arguments donnes pour cette option...\n\n";

    $exeHZ = shift(@ARGV);

  }

  #option -exeGMSH

  elsif($opt eq '-exeGMSH') {

    ($#ARGV >= 0) or die "\nErreur (prog:$NOM_PROG,opt:-exeGMSH) : pas assez d arguments donnes pour cette option...\n\n";

    $exeGMSH = shift(@ARGV);

  }

  #arguments obligatoires

  else {

    push(@args,$opt);

  }

}#while($#ARGV != -1)

($#args >= 1) or die "\nErreur (prog:$NOM_PROG) : arguments manquants...\n\n";

$fher = shift(@args);

$no_elt = shift(@args);

#---------------------

#verif de l executable Herezh

#---------------------

#si la variable $exeHZ n a pas ete renseigne au prealable => on selectionne l executable par defaut en fonction de la plateforme

if(not defined($exeHZ)) {

  #- - - - - -

  #type de plateforme

  #- - - - - -

  my $type_OS;

  #-avec uname

  if(verif_commande('uname')) {

    $type_OS = qx(uname -a);

    chomp($type_OS);

  }

  #-sinon : warning (OS inconnue)

  else {warn "**Attention : impossible de saisir le type de systeme d exploitation avec uname -a ...\n";}

  #selection de l executable Herezh

  #-linux 64 bits

  if($type_OS =~ /linux/i and $type_OS =~ /x86_64/i) {$exeHZ = $EXE_HZ_Linux64bits;}

  #-MacOSX (darwin)

  elsif($type_OS =~ /darwin/i) {$exeHZ = $EXE_HZ_MacOSX;}

  #-tous les autres (y compris linux 32 bits)

  else{$exeHZ = $EXE_HZ_autres;}

}

#verif de l executable Herezh

verif_commande($exeHZ) or die "\n**Erreur (prog:$NOM_PROG) : executable Herezh ($exeHZ) introuvable (pour eviter cette erreur : vous pouvez soit utiliser l option -exeHZ, soit renseigner directement la commande Herezh dans la variable \$exeHZ au debut du script)...\n\n";

#---------------------

#verif de l executable Gmsh

#---------------------

#si la variable $exeGMSH n a pas ete renseigne au prealable => on selectionne l executable par defaut

$exeGMSH = $exeGMSH_defaut if(not defined($exeGMSH));

#verif de l executable Gmsh

verif_commande($exeGMSH) or die "\n**Erreur (prog:$NOM_PROG) : executable Gmsh ($exeGMSH) introuvable (pour eviter cette erreur : vous pouvez soit utiliser l option -exeGMSH, soit renseigner directement la commande Gmsh dans la variable \$exeGMSH au debut du script)...\n\n";

#existence du fichier .info

(-e $fher) or die "\nErreur (prog:$NOM_PROG) : fichier $fher introuvable...\n\n";

#extension du fichier .her

($fher =~ /\.her$/) or die "\nErreur (prog:$NOM_PROG) : fichier $fher n a pas l extension .her ...\n\n";

#verif de l exe HZ++

defined(( verif_commande($exeHZ) )[0]) or die "\nErreur (prog:$NOM_PROG) : l executable HZ++ ($exeHZ) est introuvable dans les \$PATH ...\n\n";

#verif de hz_splitMail.pl

defined(( verif_commande("hz_splitMail.pl") )[0]) or die "\nErreur (prog:$NOM_PROG) : l executable hz_splitMail.pl est introuvable dans les \$PATH ...\n\n";

#verif du numero d element

($_, $_, $_, $_[0]) = lecture_mail_her($fher);

$_[1] = 'element'; $_[1] .= 's' if($_[0] > 1);#petite bidouille pour afficher "element" sans "s" si il y a un seul element dans le maillage

($no_elt <= $_[0]) or die "\nErreur (prog:$NOM_PROG) : element $no_elt n existe pas dans le maillage $fher (qui contient $_[0] $_[1]) ...\n\n";

#racine fichier visu Gmsh

my $racine_fvisu = "visu_Gmsh";

#repertoire temporaire

my $rep_tmp = "/tmp/$NOM_PROG\_$PID";

mkdir $rep_tmp or die "\nErreur (prog:$NOM_PROG) : impossible de creer le repertoire $rep_tmp (message d erreur : $!)\n\n";

#recopie du maillage vers le repertoire temporaire

system("cp $fher $rep_tmp/.");

#-- et son eventuel .lis

($_ = $fher) =~ s/.her$/.lis/;

system("cp $_ $rep_tmp/.") if(-e $_);

#deplacement vers le repertoire temporaire

my $rep_original = cwd;#repertoire d origine ...

$rep_original = rel2abs($rep_original);#... en chemin absolu

chdir $rep_tmp;

#

# pour l instant, on travaille sur un maillage reduit au seul element $no_elt

#  on retabliera le maillage original par la suite

#

my $no_elt_original = $no_elt;

my $fher_original = basename $fher;

$no_elt = 1;

$fher = "$racine_fvisu.her";

#constitution des listes des elements 1D, 2D et 3D

my @PREFIXE_1D = qw(POUT);

my @PREFIXE_2D = qw(TRIA QUAD);

my @SUFFIXE_AXI = qw(_AXI);

#-maillage de l element $no_elt uniquement (on utilise $racine_fvisu pour nommer ce maillage)

system("hz_splitMail.pl $fher_original $no_elt_original > redir.txt");

#-recuperation du .her qui nous interesse en sortie de hz_splitMail.pl 

my @fic_generes_par_split;

open(FIC, "<redir.txt");

while(<FIC>) {

  if(/\b(\S+.her)\b/) {

    push(@fic_generes_par_split, $1);

  }

}

close(FIC);

system("mv $fic_generes_par_split[0] $fher");

my ($nom_maillage, $nb_noeuds, $ref_noeuds, $nb_elts, $ref_elements, @ref_listes) = lecture_mail_her($fher);

my (@ELEM_1D, @ELEM_2D, @ELEM_3D);

ELEM:for(my $i=1; $i<=$nb_elts; $i++) {

  #verif si element AXI (donc loi 3D)

  foreach my $suffixe (@SUFFIXE_AXI) {

    @_ = split(/\s+/, $ref_elements->{$i}{'TYPE'});

    if($_[0] =~ /$suffixe\s*$/) {

      push(@ELEM_3D, $i);

      next ELEM;

    }

  }

  #verif si element 1D

  foreach my $prefixe (@PREFIXE_1D) {

    if($ref_elements->{$i}{'TYPE'} =~ /^\s*$prefixe/) {

      push(@ELEM_1D, $i);

      next ELEM;

    }

  }

  #verif si element 2D

  foreach my $prefixe (@PREFIXE_2D) {

    if($ref_elements->{$i}{'TYPE'} =~ /^\s*$prefixe/) {

      push(@ELEM_2D, $i);

      next ELEM;

    }

  }

  #sinon, c est un element 3D

  push(@ELEM_3D, $i);

}

#saisie des coordonnees des points d integration de l element (on incremente $no_pti jusqu a ce que le calcul soit echec)

my $no_pti = 0;

my @COORD_PTI;

print "\n... calcul HZ++ pour connaitre les coord des points d integration ...\n";

print "     (rq : c est normal que le dernier calcul genere une erreur de segmentation)\n";

while() {

  $no_pti++;

  #preparation du calcul

  my $racine_fher = $fher; $racine_fher =~ s/\.her$//;

  my $racine_tmp = $racine_fher.int(rand(9999999)); while(-e "$racine_tmp.info") {$racine_tmp = $racine_fher.int(rand(9999999));}

  my $finfo = $racine_tmp.'.info';

  my $fCVisu = $racine_tmp.'.CVisu';

  my $fmaple = $racine_tmp.'_princ.maple';

  print_finfo($finfo);

  print_fCVisu($fCVisu);

  #lancement du calcul

  system("$exeHZ -f $finfo > /dev/null");

  #lecture du .maple

  my ($col_X, $col_Y, $col_Z);

  open(FIC, "<$fmaple");

  while(<FIC>) {

    next if(not (/element_/ and /pt_integ_/));

    $col_X = $1 if(/\[\s*(\d+)\s*\]\s*X /);

    $col_Y = $1 if(/\[\s*(\d+)\s*\]\s*Y /);

    $col_Z = $1 if(/\[\s*(\d+)\s*\]\s*Z /);

    last;

  }

  my ($X,$Y,$Z);

  while(<FIC>) {

    next if(not /^\s*$format_reel/);

    s/^\s+//;

    @_ = split(/\s+/, $_);

    $X = $_[$col_X-1] if(defined $col_X);

    $Y = $_[$col_Y-1] if(defined $col_Y);

    $Z = $_[$col_Z-1] if(defined $col_Z);

    last;

  }

  close(FIC);

  #destruction des fichiers de calcul

  system("rm -f $finfo $fCVisu $fmaple");

  if(defined $Z) {

    #print "\ncoord (X Y Z) elt $no_elt pti $no_pti : $X $Y $Z\n\n";

    @{$COORD_PTI[$no_pti]} = ($X, $Y, $Z);

  }

  elsif(defined $Y) {

    #print "\ncoord (X Y) elt $no_elt pti $no_pti : $X $Y\n\n";

    @{$COORD_PTI[$no_pti]} = ($X, $Y, 0);

  }

  elsif(defined $X) {

    #print "\ncoord (X) elt $no_elt pti $no_pti : $X\n\n";

    @{$COORD_PTI[$no_pti]} = ($X, 0, 0);

  }

  #fin de la boucle while() infinie

  else {$no_pti--; last;}

}

#on retablit le maillage original

system("rm -f $racine_fvisu.her $racine_fvisu.lis");

$no_elt = $no_elt_original;

$fher = $fher_original;

($nom_maillage, $nb_noeuds, $ref_noeuds, $nb_elts, $ref_elements, @ref_listes) = lecture_mail_her($fher);

#conversion des types d elements de herezh vers gmsh

conversion_eltType_her2gmsh($nb_elts,$ref_elements);

#creation d un fichier de visu Gmsh de l element $no_elt

# rq : en gardant la numerotation du maillage original

#-- on va ecrire seulement les $no_noeud_max premiers noeuds (c est a dire le no de noeud max parmi ceux de l element $no_elt)

my $no_noeud_max = 0;

foreach my $noeud_old (@{$ref_elements->{$no_elt}{'CONNEX'}}) {

  next if($noeud_old < $no_noeud_max);

  $no_noeud_max = $noeud_old;

}

open(Fmsh, ">$racine_fvisu.msh");

print Fmsh <<"_FIN_";

\$MeshFormat

2 0 8

\$EndMeshFormat

\$Nodes

$no_noeud_max

_FIN_

for(my $i=1; $i<=$no_noeud_max; $i++) {

  print Fmsh "$i  @{$ref_noeuds->[$i]}\n";

}

print Fmsh <<"_FIN_";

\$EndNodes

\$Elements

1

_FIN_

print Fmsh "1  $ref_elements->{$no_elt}{'TYPE'}   @{$ref_elements->{$no_elt}{'CONNEX'}}\n";

print Fmsh <<'_FIN_';

$EndElements

_FIN_

close(Fmsh);

#creation d un .geo pour y ecrire les points d integration sous forme de Point()

open(Fgeo, ">$racine_fvisu.geo");

for(my $i=1; $i<=$no_pti; $i++) {

  print Fgeo "Point($i) = {$COORD_PTI[$i][0], $COORD_PTI[$i][1], $COORD_PTI[$i][2], 1.e+22};\n";

}

print Fgeo '

Geometry.Light = 0;     //desactivation de la lumiere (geometrie)

Mesh.Light = 0;         //desactivation de la lumiere (maillage)

View.Light = 0;         //desactivation de la lumiere (vue)

Mesh.ColorCarousel = 0; //type de couleur (0=by element type, 1=by elementary entity, 2=by physical entity, 3=by partition)

Geometry.Points = 1;    //affichage des points (=0 desactiver, =1 activer)

Geometry.Color.Points = {255,0,0};

Geometry.PointNumbers = 1;//affichage des numeros de points (=0 desactiver, =1 activer)

Mesh.Points = 1;        //affichage des noeuds (=0 desactiver, =1 activer)

Mesh.Lines = 1;         //affichage des lignes (elements 1D) (=0 desactiver, =1 activer)

Mesh.SurfaceEdges = 1;  //affichage des aretes des elements 2D (=0 desactiver, =1 activer)

Mesh.SurfaceFaces = 0;  //affichage des faces des elements 2D (=0 desactiver, =1 activer)

Mesh.VolumeEdges = 1;   //affichage des aretes des elements 3D (=0 desactiver, =1 activer)

Mesh.VolumeFaces = 0;   //affichage des faces des elements 3D (=0 desactiver, =1 activer)

Mesh.PointSize = 3.;   //taille des noeuds

Mesh.PointNumbers = 1;//affichage des numeros de noeuds (=0 desactiver, =1 activer)

Mesh.Color.Points = {0,0,0};          //on met toutes les couleurs des elements en noir pour que les noeuds et les aretes des elements soient en noir

Mesh.Color.Lines = {0,0,0};

Mesh.Color.Triangles = {0,0,0};

Mesh.Color.Quadrangles = {0,0,0};

Mesh.Color.Tetrahedra = {0,0,0};

Mesh.Color.Hexahedra = {0,0,0};

Mesh.Color.Prisms = {0,0,0};

Mesh.Color.Pyramids = {0,0,0};

';

$_ = rel2abs("$racine_fvisu.msh");

print Fgeo "Merge \"$_\";\n";

close(Fgeo);

#lancement gmsh

system("$exeGMSH $racine_fvisu.geo");

#effacement repertoire temporaire

chdir $rep_original;

system("rm -rf $rep_tmp");

sub conversion_eltType_her2gmsh {

  my $premier_arg = shift;

  my $ref_elts = shift;

  my %table_conversion_elt;

  #elements 1D lineaire

  $table_conversion_elt{'POUT BIE1'}{'TYPE'} = "1 3 0 0 0";

  @{$table_conversion_elt{'POUT BIE1'}{'CONNEX'}} = (0, 1);

  #elements 2D lineaire

  $table_conversion_elt{'TRIANGLE LINEAIRE'}{'TYPE'} = "2 3 0 0 0";

  @{$table_conversion_elt{'TRIANGLE LINEAIRE'}{'CONNEX'}} = (0, 1, 2);

  $table_conversion_elt{'QUADRANGLE LINEAIRE'}{'TYPE'} = "3 3 0 0 0";

  @{$table_conversion_elt{'QUADRANGLE LINEAIRE'}{'CONNEX'}} = (0, 1, 2, 3);

  #elements 2D axisymetriques lineaire

  $table_conversion_elt{'TRIA_AXI LINEAIRE'}{'TYPE'} = "2 3 0 0 0";

  @{$table_conversion_elt{'TRIA_AXI LINEAIRE'}{'CONNEX'}} = (0, 1, 2);

  $table_conversion_elt{'QUAD_AXI LINEAIRE'}{'TYPE'} = "3 3 0 0 0";

  @{$table_conversion_elt{'QUAD_AXI LINEAIRE'}{'CONNEX'}} = (0, 1, 2, 3);

  #elements 2D quadratique

  $table_conversion_elt{'TRIANGLE QUADRACOMPL'}{'TYPE'} = "9 3 0 0 0";

  @{$table_conversion_elt{'TRIANGLE QUADRACOMPL'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5);

  $table_conversion_elt{'QUADRANGLE QUADRACOMPL'}{'TYPE'} = "10 3 0 0 0";#quadrangle quadratique complet 9 noeuds

  @{$table_conversion_elt{'QUADRANGLE QUADRACOMPL'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5, 6, 7, 8);

  $table_conversion_elt{'QUADRANGLE QUADRATIQUE'}{'TYPE'} = "16 3 0 0 0";#quadrangle quadratique incomplet 8 noeuds

  @{$table_conversion_elt{'QUADRANGLE QUADRACOMPL'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5, 6, 7);

  #elements 2D axisymetriques quadratique

  $table_conversion_elt{'TRIA_AXI QUADRACOMPL'}{'TYPE'} = "9 3 0 0 0";

  @{$table_conversion_elt{'TRIA_AXI QUADRACOMPL'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5);

  $table_conversion_elt{'QUAD_AXI QUADRACOMPL'}{'TYPE'} = "10 3 0 0 0";

  @{$table_conversion_elt{'QUAD_AXI QUADRACOMPL'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5, 6, 7, 8);

  $table_conversion_elt{'QUAD_AXI QUADRATIQUE'}{'TYPE'} = "16 3 0 0 0";

  @{$table_conversion_elt{'QUAD_AXI QUADRATIQUE'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5, 6, 7);

  #elements 3D lineaire

  $table_conversion_elt{'TETRAEDRE LINEAIRE'}{'TYPE'} = "4 3 0 0 0";

  @{$table_conversion_elt{'TETRAEDRE LINEAIRE'}{'CONNEX'}} = (0, 1, 2, 3);

  $table_conversion_elt{'HEXAEDRE LINEAIRE'}{'TYPE'} = "5 3 0 0 0";

  @{$table_conversion_elt{'HEXAEDRE LINEAIRE'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5, 6, 7);

  $table_conversion_elt{'PENTAEDRE LINEAIRE'}{'TYPE'} = "6 3 0 0 0";

  @{$table_conversion_elt{'PENTAEDRE LINEAIRE'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5);

  #elements 3D quadratiques

  $table_conversion_elt{'PENTAEDRE QUADRATIQUE'}{'TYPE'} = "18 3 0 0 0";#pentaedre quadratique incomplet 15 noeuds

  @{$table_conversion_elt{'PENTAEDRE QUADRATIQUE'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5, 6, 8, 9, , 7, 10, 11, 12, 14, 13);

  $table_conversion_elt{'PENTAEDRE QUADRACOMPL'}{'TYPE'} = "13 3 0 0 0";#pentaedre quadratique complet 18 noeuds

  @{$table_conversion_elt{'PENTAEDRE QUADRACOMPL'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5, 6, 8, 9, 7, 10, 11, 12, 14, 13);

  $table_conversion_elt{'HEXAEDRE QUADRATIQUE'}{'TYPE'} = "17 3 0 0 0";

  @{$table_conversion_elt{'HEXAEDRE QUADRATIQUE'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 12, 9, 13, 10, 14, 15, 16, 19, 17, 18);

  $table_conversion_elt{'HEXAEDRE QUADRACOMPL'}{'TYPE'} = "12 3 0 0 0";

  @{$table_conversion_elt{'HEXAEDRE QUADRACOMPL'}{'CONNEX'}} = (0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 12, 9, 13, 10, 14, 15, 16, 19, 17, 18, 20, 21, 24, 22, 23, 25, 26);

  #option -liste_elts (on renvoie la liste des elements supportes par conversion_eltType_her2gmsh()

  my @LISTE_ELTS_SUPPORTES = keys %table_conversion_elt;

  if($premier_arg eq '-liste_elts') {

    return @LISTE_ELTS_SUPPORTES;

  }

  #sinon $premier_arg est un numero d element

  my $nb_elts = $premier_arg;

  my $type;

  my @connex_msh;

  my $ind;

  for(my $i=1; $i<=$nb_elts; $i++) {

    $type = $ref_elts->{$i}{'TYPE'};

    $type =~ s/_cm\d+pti//;#suppression d un eventuel changement du nombre de points d integration de l element

    $type =~ s/^\s+//; $type =~ s/\s+$//;

    $type =~ s/\s+/ /g;

    defined($table_conversion_elt{$type}{'TYPE'}) or die "\nErreur (prog:$NOM_PROG) : type d element \"$type\" non supporte...\n\n";

    $ref_elts->{$i}{'TYPE'} = $table_conversion_elt{$type}{'TYPE'};

    @connex_msh = ();

    for(my $j=0; $j<=$#{$table_conversion_elt{$type}{'CONNEX'}}; $j++) {

      $ind = $table_conversion_elt{$type}{'CONNEX'}[$j];

      push(@connex_msh, $ref_elts->{$i}{'CONNEX'}[$ind]);

    }

    for(my $j=0; $j<=$#{$table_conversion_elt{$type}{'CONNEX'}}; $j++) {

      $ref_elts->{$i}{'CONNEX'}[$j] = $connex_msh[$j];

    }

  }

}#sub conversion_her2gmsh

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

#subroutine qui recherche l existence d une commande et renvoie le premier path trouve (renvoie 0 si commande introuvable)

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

# en entree :

#    - nom de la commande

#

# en sortie :

#    - chemin absolu de la commande (0 si commande introuvable)

#

sub verif_commande {

  my $cmd = shift;#nom de la commande

  #cas d un chemin absolu ou relatif (si la commande commence par . ou /. Par exemple : ./HZpp ../HZppfast ou /Users/dupont/bin/HZppfast)

  if($cmd =~ /^\./ or $cmd =~ /^\//) {

    #on passe la commande en chemin absolu

    $cmd = rel2abs($cmd);

    return $cmd;

  }

  #sinon on regarde dans la variable environnement $PATH

  foreach my $path (split(/\s*:\s*/, $ENV{PATH})) {

    if(-x "$path/$cmd") {

      #on s assure que c est un chemin absolu

      $cmd = rel2abs("$path/$cmd");

      return $cmd;

    }

  }

  #on regarde a nouveau si la commande est en chemin absolu ou relatif

  #  (cas d une commande qui ne commence pas par . ou / et qui n est pas dans les PATH. Par exemple : rep/HZpp)

  if(-x $cmd) {

    #on passe la commande en chemin absolu

    $cmd = rel2abs($cmd);

    return $cmd;

  }

  #cas ou la commande est introuvable

  return 0;

}#sub verif_commande

#rq : on cree un calcul de dynamique explicite (plus rapide pour faire un increment)

sub print_finfo {

my $fic = shift;

open(FIC, ">$fic");

print FIC '

dimension   3

niveau_commentaire   3

TYPE_DE_CALCUL

dynamique_explicite   avec plus lectureCommandesVisu

';

print FIC "< $fher\n";

print FIC "ELEM_1D @ELEM_1D\n" if($#ELEM_1D > -1);

print FIC "ELEM_2D @ELEM_2D\n" if($#ELEM_2D > -1);

print FIC "ELEM_3D @ELEM_3D\n" if($#ELEM_3D > -1);

print FIC '

les_courbes_1D ----------------------------------------------

courbe_traction COURBEPOLYLINEAIRE_1_D

  Debut_des_coordonnees_des_points

    Coordonnee dim= 2 0. 0.

    Coordonnee dim= 2 1.  -0.30

  Fin_des_coordonnees_des_points

choix_materiaux ----------

';

print FIC "ELEM_1D MAT_1D\n" unless($#ELEM_1D == -1);

print FIC "ELEM_2D MAT_2D\n" unless($#ELEM_2D == -1);

print FIC "ELEM_3D MAT_3D\n" unless($#ELEM_3D == -1);

print FIC '

materiaux ----------------------------------------------

MAT_1D     LOI_RIEN1D

MAT_2D     LOI_RIEN2D_C

MAT_3D     LOI_RIEN3D

masse_volumique ----------------------------

E_tout  1

';

print FIC "\nsections\n\nELEM_1D 1\n\n" unless($#ELEM_1D == -1);

print FIC "\nepaisseurs\n\nELEM_2D 1\n" unless($#ELEM_2D == -1);

print FIC '

charges ------------------------------------

blocages ---------------------------------

controle ---------------------------------------

DELTAtMAXI   1

TEMPSFIN     1

DELTAt       1

ITERATIONS   15

PRECISION    1e-3

SAUVEGARDE   1

MAXINCRE     1

para_pilotage_equi_global ---------------------------------

para_syteme_lineaire ------------

para_affichage ------------

resultats  pas_de_sortie_finale_

COPIE 0

_fin_point_info_

';

close(FIC);

}

sub print_fCVisu {

my $fic = shift;

open(FIC, ">$fic");

print FIC '

     debut_fichier_commande_visu   # >>>>>> le mot cle: <debut_fichier_commande_visu> 

                                   # permet au programme de se positionner au debut du fichier, il est indispensable 

 #  =================================================================================

 #  ||       *****         demande dune visualisation maple:      *****           || 

 #  =================================================================================

 #  un mot cle de debut (debut_visualisation_maple)

 #  un mot cle de fin ( fin_visualisation_maple)

 #  la seule presence de ces deux mots cle suffit a activer la visualisation maple

 debut_visualisation_maple 

 #  ----------------------------- definition de la liste des increments a balayer: ---------------- 

 debut_list_increment #  un mot cle de debut de liste 

 actif 1   # <0 ou 1> indique si lordre est actif ou non 

 # une liste dentier separee par des blancs, ou le mot cle (tous_les_increments) 

 #   un mot cle de fin de liste ( fin_list_increment)

 dernier_increment    fin_list_increment 

 #  ----------------------------- choix des maillages a visualiser: ---------------- 

 #  la liste est facultative, par defaut la visualisation concerne le premier maillage

 debut_choix_maillage #  un mot cle de debut,

 actif 0   # <0 ou 1> indique si lordre est actif ou non 

 #  une liste dentiers , puis <fin_choix_maillage>, sur une meme ligne

 1  fin_choix_maillage 

 #  ----------------------------- definition des grandeurs a visualiser (maple): ---------------- 

 debut_grandeurs_maple  #  un mot cle de debut (debut_grandeurs_maple),

 actif 1   # <0 ou 1> indique si lordre est actif ou non 

 # les grandeurs globales (energie, puissance ....) un mot cle de debut, le nom des grandeurs puis un mot de fin

 debut_grandeurs_globales     fin_grandeurs_globales  

 #  ensuite pour chaque maillage:,

 #    le numero du maillage <un entier>,  

 #    les infos pour la visualisation eventuelle des torseurs de reaction,

 #    les infos pour la visualisation eventuelle aux noeud,

 #         - tout dabord les ddl principaux (position, deplacements, temperature etc.)

 #         - puis les ddl etendus et particulieres qui peuvent representer des grandeurs diverses 

 #    les infos pour la visualisation eventuelle aux elements,

 #         - tout dabord les grandeurs generiques (deformations, contraintes etc.)

 #         - puis les grandeurs particulieres, par exemple specifique a une loi de comp ou une mesure de def 

 #  enfin un mot cle de fin ( fin_grandeurs_maple)

 1 # le numero de maillage

 # les torseurs de reaction:  un mot cle de debut:  debut_list_torseur_reaction

 # une liste de nom  <chaine de caracteres >, puis <fin_list_torseur_reaction>

 debut_list_torseur_reaction   fin_list_torseur_reaction  

 debut_liste_ddl_et_noeud     # ** debut des ddl principaux aux noeuds 

 #  debut de la liste de noeuds,  puis une liste de numero de noeud <entier>, puis <fin_list_noeud>

 deb_list_noeud   fin_list_noeud  

 #  debut de la liste des ref de noeuds,  puis une liste de nom  <chaine de caracteres >, puis <fin_list_ref_noeud>

 deb_list_ref_noeud  fin_list_ref_noeud  

 #   debut de la liste des ddl a considerer aux noeuds, (une liste de ddl), puis <fin_list_ddl_noeud>

 deb_list_ddl_noeud          fin_list_ddl_noeud   

 type_sortie_ddl_retenue= 0

 #   debut de la liste des ddl etendus a considerer aux noeuds, (une liste de ddl), puis <fin_list_ddl_etendu_noeud>

 deb_list_ddl_etendu_noeud         fin_list_ddl_etendu_noeud    # fin des ddl etendu aux noeuds

 #   debut de la liste des grandeurs particulieres a considerer aux noeuds, (une liste de string), puis <fin_list_GrandParticuliere_noeud>

 deb_list_GrandParticuliere_noeud         fin_list_GrandParticuliere_noeud    # fin des grandeurs particulieres aux noeuds

 fin_liste_ddl_et_noeud      # fin des grandeurs aux noeuds

 debut_liste_ddl_ptinteg  # ** debut des grandeurs aux elements 

 #  debut de la liste des elements et points dintegration, une liste de   (un element, un numero de pt dinteg), puis <fin_list_NbElement_NbPtInteg>

';

print FIC " deb_list_NbElement_NbPtInteg $no_elt $no_pti  fin_list_NbElement_NbPtInteg  \n";

print FIC '

 #  debut de la liste des ref delements,  puis une liste de: nom  <chaine de caracteres > + numero dinteg, puis <fin_list_ref_element>

 deb_list_ref_element  fin_list_ref_element  

 #  debut de la liste des ref de ptinteg delements,  puis une liste de: nom  <chaine de caracteres >  puis <fin_list_ref_ptinteg_element>

 deb_list_ref_ptinteg_element    fin_list_ref_ptinteg_element  

 # debut de la liste des ddl a considerer pour les elements, (une liste de ddl),    puis <fin_list_ddl_element>

 deb_list_ddl_element  contrainte_mises       fin_list_ddl_element          # fin de la liste de ddl a considerer pour les elements

 #   debut de la liste des grandeurs particulieres a considerer pour les elements, (une liste de string), puis <fin_list_GrandParticuliere_element>

 deb_list_GrandParticuliere_element         fin_list_GrandParticuliere_element    # fin des grandeurs particulieres aux elements

 #   tableau de grandeurs evoluees  aux elements a visualiser, un par maillage

 deb_list_GrandEvoluee_element  fin_list_GrandEvoluee_element 

 fin_liste_ddl_ptinteg   # fin des grandeurs aux elements 

# informations particuliere dans le cas ou il y a une animation

# type_xi indique si oui ou non les grandeurs a tracer sont aux noeuds (sinon cest au elements)

# x1 et x2 indiquent les noms des ddls des grandeurs en x et y. accroi_x1 et accroi_x2 indiquent 

# si oui ou non x1 et x2 represente laccroissement entre 0 et t de la grandeur ou bien la grandeur elle meme.

 debut_info_particulier  grandeur_au_noeud? 1  x1=  NU_DDL x2=  NU_DDL accroi_x1= 0 accroi_x2= 1  fin_info_particulier 

# un parametre de pilotage du style de sortie

 parametre_style_de_sortie 1

# un parametre indiquant si les tenseurs sont en absolue (rep 1) ou suivant un repere ad hoc

# (tangent pour les coques, suivant la fibre moyenne pour les element 1D ) 

 tenseur_en_absolue_  0

 fin_grandeurs_maple  # fin des grandeurs a visualiser au format maple 

 #  ----------------------------- definition des parametres danimation: ---------------- 

 debut_animation #  un mot cle de debut de liste (debut_animation)

 actif 0   # <0 ou 1> indique si lordre est actif ou non 

 #  des parametres avec des valeurs: (sur une meme ligne) 

 cycleInterval 8 # cycleInterval  <un reel> (indique le temps en seconde du cycle de lanimation)

 fin_animation  #   un mot cle de fin  

 fin_visualisation_maple 

 #  =================================================================================

 #  ||                          fin de la  visualisation maple                     || 

 #  =================================================================================

     fin_fichier_commande_visu   # <<<<<<  le mot cle <fin_fichier_commande_visu> permet

                                 #  larret de la lecture des commandes, apres ce mot cle, aucune commande nest lu, de plus 

                                 #  sans le mot cle de fin de fichier, le fichier nest pas valide  

';

close(FIC);

}

#----------------

#sub qui lit un maillage herezh++ pour recuperer les noeuds, les elements et les listes de references

#et les renvoier sous forme de reference (lecture du .her et d un .lis si il existe)

#

# exemple d appel :

#  my ($nom_maillage, $nb_noeuds, $ref_tab_noeuds, $nb_elts, $ref_tab_elements, @ref_listes) = lecture_mail_her("fic_her");

#

#  avec - $nom_maillage     : nom du maillage (si il y en a un. sinon $nom_maillage sera egal a undef

#       - $nb_noeuds        : nombre de noeuds (entier)

#       - $ref_tab_noeuds   : reference vers un tableau de noeuds => $ref_tab_noeuds->[no noeud][0] : coordonnee x

#                                                                    $ref_tab_noeuds->[no noeud][1] : coordonnee y

#                                                                    $ref_tab_noeuds->[no noeud][2] : coordonnee z)

#       - $nb_elts          : nombre d elements (entier)

#       - $ref_tab_elements : reference vers une table de hashage => $ref_tab_elements->{no elt}{'TYPE'}      : type d element

#                                                                    @{$ref_tab_elements->{no elt}{'CONNEX'}} : (liste des noeuds)

#       - @ref_listes       : liste de references vers les tables de hashage contenant les listes de references de noeuds, aretes, faces et elements

#                             => $ref_listes[0] : reference vers la table de hashage des listes de noeuds  => @{$ref_listes[0]->{'nom liste'}} : (liste des noeuds)

#                                $ref_listes[1] : reference vers la table de hashage des listes d aretes   => @{$ref_listes[1]->{'nom liste'}} : (liste des aretes)

#                                $ref_listes[2] : reference vers la table de hashage des listes de faces   => @{$ref_listes[2]->{'nom liste'}} : (liste des faces)

#                                $ref_listes[3] : reference vers la table de hashage des listes d elements => @{$ref_listes[3]->{'nom liste'}} : (liste des elements)

#                                $ref_listes[4] : reference vers la table de hashage des listes de points d integration => @{$ref_listes[4]->{'nom liste'}} : (liste des points d integration)

#                                

sub lecture_mail_her {

  my $fher = shift;

  my $nom_maillage;

  #------------------------

  # lecture du maillage .her

  #------------------------

  #-lecture de noeuds

  my @tab_noeuds; my $nb_noeuds;

  my $no_noeud = 0;

  open(Fher, "<$fher");

  while(<Fher>) {

    if(/^\s*nom_maillage\s+(\S+)/) {$nom_maillage = $1; next;}

    next if(not /(\d+)\s+NOEUDS/);

    $nb_noeuds = $1;

    last;

  }

  while(<Fher>) {

    last if($no_noeud == $nb_noeuds);

    next if(not /^\s*(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s*$/);

    $no_noeud = $1;

    @{$tab_noeuds[$no_noeud]} = ($2,$3,$4);

  }

  #-lecture des elements

  my %tab_elements; my $nb_elts;

  my $no_elt = 0;

  while(<Fher>) {

    next if(not /(\d+)\s+ELEMENTS/);

    $nb_elts = $1;

    last;

  }

  while(<Fher>) {

    last if($no_elt == $nb_elts);

    next if(not /^\s*\d+\s+\w+\s+\w+/);

    s/^\s+//;s/\s+$//;

    $_ =~ /^(\d+)\s+/;

    $no_elt = $1; s/^(\d+)\s+//;

    $_ =~ /\s+(\d+(?:\s+\d+)*)$/;

    @{$tab_elements{$no_elt}{'CONNEX'}} = split(/\s+/, $1); s/\s+(\d+(?:\s+\d+)*)$//;

    $tab_elements{$no_elt}{'TYPE'} = $_; $tab_elements{$no_elt}{'TYPE'} =~ s/\s+/ /g;

  }

  close(Fher);

  #------------------------

  # lecture des references (dans le .her et dans un eventuel .lis)

  #------------------------

  my $flis = $fher; $flis =~ s/.her$/.lis/;

  my $nom_liste;

  my $is_liste_en_cours;

  my %listes_NOEUDS;

  my %listes_ARETES;

  my %listes_FACES;

  my %listes_ELEMENTS;

  my %listes_PTI;

  #-dans le .her

  open(Fher, "<$fher");

  $is_liste_en_cours = 0;

  while(<Fher>) {

    chomp;

    if(/^\s*(N\S+)/) {

      $nom_liste = $1;

      $is_liste_en_cours = 1;

      s/^\s*N\S+\s+//; s/\s+$//;

      push(@{$listes_NOEUDS{$nom_liste}},split(/\s+/,$_));

    }

    elsif(/^\s*noeuds/i or /^\s*elements/i or /^\s*[AFEG]/) {

      $is_liste_en_cours = 0;

    }

    elsif($is_liste_en_cours and /^\s*\d+(\s+\d+)*\s*$/i) {

      s/^\s+//; s/\s+$//;

      push(@{$listes_NOEUDS{$nom_liste}},split(/\s+/,$_));

    }

  }

  close(Fher);

  open(Fher, "<$fher");

  $is_liste_en_cours = 0;