|
#!/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");
|
|
|
|
|