|
1
|
#!/usr/bin/env perl
|
|
2
|
use strict;
|
|
3
|
use warnings;
|
|
4
|
use English;
|
|
5
|
use File::Glob qw(bsd_glob);
|
|
6
|
use File::Basename;
|
|
7
|
use IO::File;
|
|
8
|
use List::MoreUtils qw(uniq);
|
|
9
|
my $NOM_PROG = basename $PROGRAM_NAME;
|
|
10
|
#pattern d un reel pour les regex (desormais redondant avec $RE{num}{real} de Regexp::Common)
|
|
11
|
my $format_reel = '[+-]?[\.]?\d+[\.]?\d*(?:[eE][+-]?\d*)?';
|
|
12
|
|
|
13
|
|
|
14
|
my $VERSION = '1.00';
|
|
15
|
#####################################################################################################
|
|
16
|
# script pour visualiser un ou plusieurs maillages dans Gmsh #
|
|
17
|
# version 1.00 : version initiale (version testee sur : MacOSX Darwin) #
|
|
18
|
#####################################################################################################
|
|
19
|
|
|
20
|
|
|
21
|
|
|
22
|
#
|
|
23
|
# note :
|
|
24
|
# l une des difficultes du traitement est que la numerotation des noeuds dans le fichier Gmsh n est pas
|
|
25
|
# la meme que les fichiers maillage .her dans le cas ou il y a plusieurs maillages.
|
|
26
|
#
|
|
27
|
# On doit donc connaitre les maillages .her, et en particulier connaitre l ordre dans lequel ils ont ete
|
|
28
|
# declares dans la sortie Gmsh (fichier .CVisu). En general, c est le meme ordre que dans le fichier .info du calcul.
|
|
29
|
# La connaissance des fichiers maillages et de leur ordre permettra de se baser sur les listes de references
|
|
30
|
# existantes pour ces maillages et de determiner la correspondance entre numero de noeud du fichier .her et
|
|
31
|
# numero de noeud qui lui correspond dans le fichier Gmsh .pos
|
|
32
|
#
|
|
33
|
# Cette problematique est a l origine du choix de passer par un fichier de commande (voir aide du script).
|
|
34
|
# De toute facon, il est egalement plus simple de passer par un fichier de commande pour definir les sorties (qui peuvent
|
|
35
|
# etre nombreuses)
|
|
36
|
#
|
|
37
|
|
|
38
|
|
|
39
|
|
|
40
|
|
|
41
|
|
|
42
|
|
|
43
|
|
|
44
|
sub affichage_aide {
|
|
45
|
use Text::Wrap;
|
|
46
|
#config du package Text::Wrap
|
|
47
|
$Text::Wrap::columns = 101;#le nombre de caracteres maximum par ligne sera egal a ($Text::Wrap::columns - 1) dans le cas ou utilise wrap
|
|
48
|
|
|
49
|
#indentation de longueur $NOM_PROG
|
|
50
|
my $indent_NOM_PROG = ""; $indent_NOM_PROG .= " " for(1 .. length($NOM_PROG));
|
|
51
|
|
|
52
|
print "----------------------------------------\n";
|
|
53
|
print " script $NOM_PROG (version $VERSION)\n";
|
|
54
|
print "----------------------------------------\n";
|
|
55
|
print "\n";
|
|
56
|
print "But : convertir des donnees Gmsh (fichiers .pos) en fichier de type .maple\n";
|
|
57
|
print "\n";
|
|
58
|
print "Usage :\n";
|
|
59
|
print wrap(" "," $indent_NOM_PROG ", " $NOM_PROG [-h|help] [-v] [-l] [-trame nom_fic]\n",
|
|
60
|
"rep_Gmsh fic_cmd fic_maple\n");
|
|
61
|
print "\n";
|
|
62
|
print "Arguments :\n";
|
|
63
|
print " o rep_Gmsh : repertoire Gmsh\n";
|
|
64
|
print " o fic_cmd : fichier de commande de sortie (voir \"Fonctionnement\")\n";
|
|
65
|
print " o fic_maple : fichier de type .maple a creer\n";
|
|
66
|
print "\n";
|
|
67
|
print "Fonctionnement :\n";
|
|
68
|
print wrap(" ", " ",
|
|
69
|
"$NOM_PROG lit le fichier \"fic_cmd\" qui contient les mots-cles MAILLAGES et SORTIES. ",
|
|
70
|
"Il produira le fichier \"fic_maple\" ",
|
|
71
|
"qui contiendra un certain nombre de colonnes dans l ordre de ce qui est indique au mot-cle SORTIES.\n",
|
|
72
|
"\n",
|
|
73
|
"Le fichier \"fic_cmd\" aura la structure suivante :\n",
|
|
74
|
"---------------------------------------------------------\n",
|
|
75
|
"MAILLAGES #(mot-cle de declaration des maillages dans l ordre du .CVisu)\n",
|
|
76
|
"nom_fichier #(fichier .her maillage 1)\n",
|
|
77
|
"nom_fichier #(fichier .her maillage 2)\n",
|
|
78
|
"...\n",
|
|
79
|
"nom_fichier #(fichier .her maillage N)\n",
|
|
80
|
"\n",
|
|
81
|
"SORTIES #(mot-cle de declaration des grandeurs a sortir)\n",
|
|
82
|
"numero maillage\n",
|
|
83
|
"[STAT ]numero ou ref_noeuds var_1 var_2 ... var_N #(noeud ou liste suivi des grandeurs voulues)\n",
|
|
84
|
" #(eventuellement precede du mot-cle STAT)\n",
|
|
85
|
"numero maillage\n",
|
|
86
|
"[STAT ]numero ou ref_noeuds var_1 var_2 ... var_N #(noeud ou liste suivi des grandeurs voulues)\n",
|
|
87
|
" #(eventuellement precede du mot-cle STAT)\n",
|
|
88
|
"...\n",
|
|
89
|
"numero maillage\n",
|
|
90
|
"[STAT ]numero ou ref_noeuds var_1 var_2 ... var_N #(noeud ou liste suivi des grandeurs voulues)\n",
|
|
91
|
" #(eventuellement precede du mot-cle STAT)\n",
|
|
92
|
"---------------------------------------------------------\n",
|
|
93
|
"\n",
|
|
94
|
"L option -trame permet de generer un exemple de fichier de commande (voir Options).\n",
|
|
95
|
"\n",
|
|
96
|
"Le symbole \"#\" permet d ecrire des commentaires.\n",
|
|
97
|
"\n",
|
|
98
|
"Le mot-cle \"STAT\" permet d indiquer que l on souhaite une statistique (somme, moyenne, min, max) sur ",
|
|
99
|
"l ensemble des noeuds plutot que les valeurs par noeud.\n",
|
|
100
|
"\n",
|
|
101
|
"Dans le cas a plusieurs maillages, il est tres important de les declarer dans le meme ordre que\n",
|
|
102
|
"celui dans le fichier .CVisu du calcul qui a cree le repertoire Gmsh.\n"
|
|
103
|
);
|
|
104
|
print "\n";
|
|
105
|
print "Options :\n";
|
|
106
|
print " -v : affichage du numero de version\n";
|
|
107
|
print "\n";
|
|
108
|
print " -l : affichage des grandeurs disponibles dans le repertoire \"rep_Gmsh\"\n";
|
|
109
|
print " **NB : dans ce cas, on peut lancer le script de la maniere suivante :\n";
|
|
110
|
print " > $NOM_PROG -l rep_Gmsh\n";
|
|
111
|
print "\n";
|
|
112
|
print " -trame nom_fic : genere une trame de fichier de commande\n";
|
|
113
|
print " **NB : dans ce cas, on peut lancer le script de la\n";
|
|
114
|
print " maniere suivante :\n";
|
|
115
|
print " > $NOM_PROG -trame nom_fic\n";
|
|
116
|
print "\n";
|
|
117
|
print "Auteur :\n";
|
|
118
|
print " TROUFFLARD Julien\n";
|
|
119
|
print " julien.troufflard\@free.fr\n";
|
|
120
|
print "----------------------------------------\n";
|
|
121
|
}
|
|
122
|
|
|
123
|
|
|
124
|
|
|
125
|
#------------------------------------
|
|
126
|
#pas d arguments ou option -h ou -help => affichage de l aide et arret du programme
|
|
127
|
#------------------------------------
|
|
128
|
#cas sans argument
|
|
129
|
if($#ARGV == -1) {
|
|
130
|
affichage_aide();
|
|
131
|
exit;
|
|
132
|
}
|
|
133
|
# cas option -h/-help (rq : insensible a la casse)
|
|
134
|
foreach my $arg (@ARGV) {
|
|
135
|
if(($arg =~ /^-h$/i) or ($arg =~ /^-help$/i)) {
|
|
136
|
affichage_aide();
|
|
137
|
exit;
|
|
138
|
}
|
|
139
|
}
|
|
140
|
|
|
141
|
#------------------------------------
|
|
142
|
#option -v => affichage de la version et arret du programme
|
|
143
|
#------------------------------------
|
|
144
|
foreach my $arg (@ARGV) {
|
|
145
|
if($arg eq '-v') {
|
|
146
|
print "\n $NOM_PROG : version $VERSION\n\n";
|
|
147
|
exit;
|
|
148
|
}
|
|
149
|
}
|
|
150
|
|
|
151
|
#------------------------------------
|
|
152
|
#option -trame => creation du fichier de commande et arret du programme
|
|
153
|
#------------------------------------
|
|
154
|
for(my $i=0; $i<=$#ARGV; $i++) {
|
|
155
|
if($ARGV[$i] eq '-trame') {
|
|
156
|
defined($ARGV[$i+1]) or die "\n**Erreur (prog:$NOM_PROG,opt:-trame) : argument manquant (voir aide -h|-help)...\n\n";
|
|
157
|
print_fic_cmd($ARGV[$i+1]);
|
|
158
|
print "\nFichier cree : $ARGV[$i+1]\n\n";
|
|
159
|
exit;
|
|
160
|
}
|
|
161
|
}
|
|
162
|
|
|
163
|
|
|
164
|
|
|
165
|
|
|
166
|
#------------------------------------
|
|
167
|
#recuperation des arguments et options
|
|
168
|
#------------------------------------
|
|
169
|
my $rep_Gmsh;#repertoire Gmsh
|
|
170
|
my $fic_cmd;#fichier de commande
|
|
171
|
my $fic_maple_a_creer;#fichier de type .maple a creer
|
|
172
|
|
|
173
|
my $is_opt_l = 0;#indicateur de l option -l (affichage de la liste des grandeurs dispo dans le repertoire $rep_Gmsh)
|
|
174
|
|
|
175
|
#on parcourt la liste des arguments (on traite les options connues et on stocke les autres dans @args)
|
|
176
|
my $opt;
|
|
177
|
my @args;
|
|
178
|
while($#ARGV != -1) {
|
|
179
|
$opt = shift(@ARGV);
|
|
180
|
|
|
181
|
#option -l
|
|
182
|
if($opt eq '-l') {
|
|
183
|
$is_opt_l = 1;
|
|
184
|
}
|
|
185
|
|
|
186
|
#cas d une option inconnue
|
|
187
|
elsif($opt =~ /^-/) {
|
|
188
|
warn "**Attention : option $opt inconnue (on ignore cette option)...\n";
|
|
189
|
}
|
|
190
|
|
|
191
|
#autres arguments
|
|
192
|
else {
|
|
193
|
push(@args,$opt);
|
|
194
|
}
|
|
195
|
}#while($#ARGV != -1)
|
|
196
|
|
|
197
|
|
|
198
|
|
|
199
|
#recuperation des arguments obligatoires
|
|
200
|
#
|
|
201
|
#-on recupere d abord le repertoire Gmsh (pour appliquer directement une eventuelle option -l)
|
|
202
|
($#args >= 0) or die "\n**Erreur (prog:$NOM_PROG) : arguments manquants (voir aide : option -h ou -help)...\n\n";
|
|
203
|
$rep_Gmsh = shift(@args);
|
|
204
|
$rep_Gmsh =~ s/\/+$//;
|
|
205
|
|
|
206
|
#verif existence repertoire Gmsh
|
|
207
|
(-d $rep_Gmsh) or die "\n**Erreur (prog:$NOM_PROG) : repertoire Gmsh ($rep_Gmsh/) introuvable...\n\n";
|
|
208
|
|
|
209
|
#construction de la table des grandeurs et fichiers associes dans le repertoire Gmsh
|
|
210
|
my %table_grandeurs_rep_Gmsh;
|
|
211
|
#table de hashage : @{$table_grandeurs_rep_Gmsh{'liste_grandeurs'}} = (liste des noms de grandeur)
|
|
212
|
#
|
|
213
|
# $table_grandeurs_rep_Gmsh{nom grandeur}{'fichier'} = fichier .pos correspondant a la grandeur
|
|
214
|
# $table_grandeurs_rep_Gmsh{nom grandeur}{'nb_composantes'} = nombre de composantes de la grandeur
|
|
215
|
#
|
|
216
|
make_table_grandeurs_Gmsh($rep_Gmsh, \%table_grandeurs_rep_Gmsh);
|
|
217
|
|
|
218
|
|
|
219
|
#cas particulier : aucune grandeurs dispo
|
|
220
|
if($#{$table_grandeurs_rep_Gmsh{'liste_grandeurs'}} == -1) {
|
|
221
|
die "\n**Erreur (prog:$NOM_PROG) : aucune grandeur n a ete trouve dans le repertoire Gmsh ($rep_Gmsh/) (plus precisement, aucun fichier d extension .pos n existe dans ce repertoire)...\n\n";
|
|
222
|
}
|
|
223
|
|
|
224
|
|
|
225
|
|
|
226
|
#option -l => affichage des grandeurs disponibles et sortie du programme
|
|
227
|
if($is_opt_l) {
|
|
228
|
print "\n";
|
|
229
|
print "--------------------------------------------------------------\n";
|
|
230
|
print "Liste des grandeurs dans le repertoire $rep_Gmsh/ :\n";
|
|
231
|
print "--------------------------------------------------------------\n";
|
|
232
|
foreach my $grandeur (@{$table_grandeurs_rep_Gmsh{'liste_grandeurs'}}) {
|
|
233
|
my $fpos = basename $table_grandeurs_rep_Gmsh{$grandeur}{'fichier'};
|
|
234
|
print " - $grandeur ( fichier : $fpos )\n";
|
|
235
|
}
|
|
236
|
print "\n";
|
|
237
|
exit;
|
|
238
|
}
|
|
239
|
|
|
240
|
|
|
241
|
#-on recupere le fichier de commande et le fichier .maple a creer
|
|
242
|
($#args >= 1) or die "\n**Erreur (prog:$NOM_PROG) : arguments manquants (voir aide : option -h ou -help)...\n\n";
|
|
243
|
$fic_cmd = shift(@args);
|
|
244
|
$fic_maple_a_creer = shift(@args);
|
|
245
|
|
|
246
|
|
|
247
|
#verif existence fichier commande
|
|
248
|
(-e $fic_cmd) or die "\n**Erreur (prog:$NOM_PROG) : fichier de commande ($fic_cmd) introuvable...\n\n";
|
|
249
|
|
|
250
|
|
|
251
|
|
|
252
|
#saisie des infos dans le fichier de commande
|
|
253
|
#
|
|
254
|
# - table des fichiers maillage
|
|
255
|
my %FHER;
|
|
256
|
# table de hashage : $FHER{'nb_maillages'} = nombre de maillages
|
|
257
|
#
|
|
258
|
# $FHER{i}{'nb_noeuds'} = nombre de noeuds du maillage i
|
|
259
|
# $FHER{i}{'fichier'} = fichier .her du maillage i
|
|
260
|
#
|
|
261
|
$FHER{'nb_maillages'} = 0;
|
|
262
|
|
|
263
|
|
|
264
|
my $is_mot_cle_MAILLAGES_ok = 0;
|
|
265
|
my $is_mot_cle_SORTIES_ok = 0;
|
|
266
|
|
|
267
|
open(FIC, "<$fic_cmd");
|
|
268
|
my $nb_ligne_cmd = 0;
|
|
269
|
while(<FIC>) {
|
|
270
|
$nb_ligne_cmd++;
|
|
271
|
|
|
272
|
next if(/^\s*\#/);
|
|
273
|
s/\s*#.*$//;
|
|
274
|
next if(/^\s*$/);
|
|
275
|
next if(not /^\s*MAILLAGES\s*$/);
|
|
276
|
|
|
277
|
$is_mot_cle_MAILLAGES_ok = 1;
|
|
278
|
|
|
279
|
while(<FIC>) {
|
|
280
|
$nb_ligne_cmd++;
|
|
281
|
|
|
282
|
next if(/^\s*\#/);
|
|
283
|
s/\s*#.*$//;
|
|
284
|
next if(/^\s*$/);
|
|
285
|
if(/^\s*SORTIES\s*$/) {
|
|
286
|
$is_mot_cle_SORTIES_ok = 1;
|
|
287
|
last;
|
|
288
|
}
|
|
289
|
|
|
290
|
my ($fher) = split;
|
|
291
|
my $nb_noeuds = nb_noeuds_maillage($fher);
|
|
292
|
($nb_noeuds > 0) or die "\n**Erreur (prog:$NOM_PROG) : (ligne $nb_ligne_cmd fichier $fic_cmd) le fichier de maillage $fher n est pas valide (impossible d y saisir le nombre de noeuds)...\n\n";
|
|
293
|
$FHER{'nb_maillages'}++;
|
|
294
|
$FHER{$FHER{'nb_maillages'}}{'fichier'} = $fher;
|
|
295
|
$FHER{$FHER{'nb_maillages'}}{'nb_noeuds'} = $nb_noeuds;
|
|
296
|
}
|
|
297
|
last;
|
|
298
|
}
|
|
299
|
|
|
300
|
$is_mot_cle_MAILLAGES_ok or die "\n**Erreur (prog:$NOM_PROG) : le mot-cle MAILLAGES n a pas ete trouve dans le fichier $fic_cmd ...\n\n";
|
|
301
|
$is_mot_cle_SORTIES_ok or die "\n**Erreur (prog:$NOM_PROG) : le mot-cle SORTIES n a pas ete trouve dans le fichier $fic_cmd ...\n\n";
|
|
302
|
|
|
303
|
|
|
304
|
# - table des grandeurs a sortir
|
|
305
|
my %SORTIES;
|
|
306
|
# table de hashage : $SORTIES{'nb_sorties'} = nombre de commandes de sortie
|
|
307
|
#
|
|
308
|
# $SORTIES{i}{'no_maillage'} = numero maillage de la commande
|
|
309
|
# $SORTIES{i}{'ref_noeud'} = noeud ou nom de la liste de ref
|
|
310
|
# @{$SORTIES{i}{'liste_noeuds_her'} = liste des noeuds concernes dans les fichiers .her
|
|
311
|
# @{$SORTIES{i}{'liste_noeuds_Gmsh'} = liste des noeuds concernes dans les fichiers Gmsh (en tenant compte du decalage de la numerotation dans le cas a plusieurs maillages)
|
|
312
|
# @{$SORTIES{i}{'liste_grandeurs'}} = liste des grandeurs a sortir pour ce/ces noeud(s)
|
|
313
|
#
|
|
314
|
while(<FIC>) {
|
|
315
|
$nb_ligne_cmd++;
|
|
316
|
|
|
317
|
next if(/^\s*\#/);
|
|
318
|
s/\s*#.*$//;
|
|
319
|
next if(/^\s*$/);
|
|
320
|
next if(not /^\s*(\d+)\s*$/);
|
|
321
|
|
|
322
|
my $no_maillage = $1;
|
|
323
|
($no_maillage <= $FHER{'nb_maillages'}) or die "\n**Erreur (prog:$NOM_PROG) : (ligne $nb_ligne_cmd fichier $fic_cmd) le numero de maillage ($no_maillage) est plus grand que le nombre total de maillages ($FHER{'nb_maillages'}...\n\n";
|
|
324
|
|
|
325
|
while(<FIC>) {
|
|
326
|
$nb_ligne_cmd++;
|
|
327
|
|
|
328
|
next if(/^\s*\#/);
|
|
329
|
s/\s*#.*$//;
|
|
330
|
next if(/^\s*$/);
|
|
331
|
next if(not (/^\s*(STAT)?\s*\d+\s+\S/ or /^\s*(STAT)?\s*N\S+\s+\S/));
|
|
332
|
|
|
333
|
$SORTIES{'nb_sorties'}++;
|
|
334
|
|
|
335
|
#cas d une statistique sur les noeuds
|
|
336
|
if(/^\s*STAT\s+/) {
|
|
337
|
s/\s*STAT\s+//;
|
|
338
|
$SORTIES{$SORTIES{'nb_sorties'}}{'STAT'} = 1;
|
|
339
|
}
|
|
340
|
|
|
341
|
@_ = split;
|
|
342
|
my $ref_noeud = shift(@_);#pour l instant on ne sait pas si c est un noeud ou une liste de reference de noeuds
|
|
343
|
my @grandeurs = @_;
|
|
344
|
|
|
345
|
$SORTIES{$SORTIES{'nb_sorties'}}{'no_maillage'} = $no_maillage;
|
|
346
|
$SORTIES{$SORTIES{'nb_sorties'}}{'ref_noeud'} = $ref_noeud;
|
|
347
|
|
|
348
|
#verif ref noeud et remplissage des listes
|
|
349
|
#-- cas d un numero de noeud
|
|
350
|
if($ref_noeud =~ /^\d+$/) {
|
|
351
|
($ref_noeud <= $FHER{$no_maillage}{'nb_noeuds'}) or die "\n**Erreur (prog:$NOM_PROG) : (ligne $nb_ligne_cmd fichier $fic_cmd) le noeud $ref_noeud n existe pas dans le maillage $no_maillage (fichier $FHER{$no_maillage}{'fichier'})...\n\n";
|
|
352
|
@{$SORTIES{$SORTIES{'nb_sorties'}}{'liste_noeuds_her'}} = ($ref_noeud);
|
|
353
|
}
|
|
354
|
#-- cas d une liste de reference
|
|
355
|
else {
|
|
356
|
#lecture du maillage concerne
|
|
357
|
my ($nom_maillage, $nb_noeuds, $ref_tab_noeuds, $nb_elts, $ref_tab_elements, @ref_listes) = lecture_mail_her($FHER{$no_maillage}{'fichier'});
|
|
358
|
#-on ajoute automatiquement la reference N_tout (tous les noeuds) si elle n existe pas
|
|
359
|
if(not defined $ref_listes[0]->{'N_tout'}[0]) {
|
|
360
|
push(@{$ref_listes[0]->{'N_tout'}}, 1 .. $nb_noeuds);
|
|
361
|
}
|
|
362
|
|
|
363
|
#verif existence reference
|
|
364
|
(defined $ref_listes[0]->{$ref_noeud}[0]) or die "\nErreur (prog:$NOM_PROG) : (ligne $nb_ligne_cmd fichier $fic_cmd) liste de reference $ref_noeud n existe pas dans le maillage $no_maillage (fichier $FHER{$no_maillage}{'fichier'})...\n\n";
|
|
365
|
@{$SORTIES{$SORTIES{'nb_sorties'}}{'liste_noeuds_her'}} = @{$ref_listes[0]->{$ref_noeud}};
|
|
366
|
}
|
|
367
|
|
|
368
|
#conversion de la liste de noeuds en numerotation Gmsh
|
|
369
|
# (on applique un decalage egal a la somme des noeuds des maillages precedant le maillage $no_maillage)
|
|
370
|
my $decalage_no_noeud_Gmsh = 0;
|
|
371
|
for(my $i=1; $i<=$no_maillage-1; $i++) {$decalage_no_noeud_Gmsh += $FHER{$i}{'nb_noeuds'};}
|
|
372
|
foreach my $noeud_her (@{$SORTIES{$SORTIES{'nb_sorties'}}{'liste_noeuds_her'}}) {
|
|
373
|
push(@{$SORTIES{$SORTIES{'nb_sorties'}}{'liste_noeuds_Gmsh'}}, $noeud_her + $decalage_no_noeud_Gmsh);
|
|
374
|
}
|
|
375
|
|
|
376
|
#verif des grandeurs demandees
|
|
377
|
foreach my $grandeur (@grandeurs) {
|
|
378
|
(defined $table_grandeurs_rep_Gmsh{$grandeur}) or die "\nErreur (prog:$NOM_PROG) : (ligne $nb_ligne_cmd fichier $fic_cmd) grandeur $grandeur n existe pas dans le repertoire Gmsh $rep_Gmsh/ ...\n\n";
|
|
379
|
push(@{$SORTIES{$SORTIES{'nb_sorties'}}{'liste_grandeurs'}}, $grandeur);
|
|
380
|
}
|
|
381
|
|
|
382
|
last;
|
|
383
|
}#while(<FIC>)
|
|
384
|
|
|
385
|
}#while(<FIC>)
|
|
386
|
close(FIC);
|
|
387
|
|
|
388
|
|
|
389
|
($SORTIES{'nb_sorties'} > 0) or die "\nErreur (prog:$NOM_PROG) : aucune sortie n a ete trouve dans le fichier $fic_cmd ...\n\n";
|
|
390
|
|
|
391
|
|
|
392
|
|
|
393
|
#ecriture de l en-tete du fichier .maple
|
|
394
|
#
|
|
395
|
#
|
|
396
|
#
|
|
397
|
open(Fmaple, ">$fic_maple_a_creer");
|
|
398
|
|
|
399
|
print Fmaple "#fichier cree par le script : $NOM_PROG\n";
|
|
400
|
print Fmaple "#fichier de commande : $fic_cmd\n";
|
|
401
|
print Fmaple "#repertoire Gmsh : $rep_Gmsh/\n";
|
|
402
|
print Fmaple "#\n";
|
|
403
|
print Fmaple "#--------------------------------------\n";
|
|
404
|
print Fmaple "#lien entre grandeur et fichier .pos\n";
|
|
405
|
print Fmaple "#--------------------------------------\n";
|
|
406
|
foreach my $grandeur (@{$table_grandeurs_rep_Gmsh{'liste_grandeurs'}}) {
|
|
407
|
print Fmaple "# - $grandeur ==> fichier : $table_grandeurs_rep_Gmsh{$grandeur}{'fichier'}\n";
|
|
408
|
}
|
|
409
|
print Fmaple "#\n";
|
|
410
|
print Fmaple "#----------------------------\n";
|
|
411
|
print Fmaple "#description des colonnes\n";
|
|
412
|
print Fmaple "#----------------------------\n";
|
|
413
|
print Fmaple "#\n";
|
|
414
|
my $nb_colonnes = 1;
|
|
415
|
print Fmaple "#[$nb_colonnes] temps\n";
|
|
416
|
print Fmaple "#\n";
|
|
417
|
for(my $no_sortie=1; $no_sortie<=$SORTIES{'nb_sorties'}; $no_sortie++) {
|
|
418
|
|
|
419
|
my $fher = $FHER{$SORTIES{$no_sortie}{'no_maillage'}}{'fichier'};
|
|
420
|
my $ref_noeud = $SORTIES{$no_sortie}{'ref_noeud'};
|
|
421
|
my @grandeurs = @{$SORTIES{$no_sortie}{'liste_grandeurs'}};
|
|
422
|
my @liste_noeuds_her = @{$SORTIES{$no_sortie}{'liste_noeuds_her'}};
|
|
423
|
my @liste_noeuds_Gmsh = @{$SORTIES{$no_sortie}{'liste_noeuds_Gmsh'}};
|
|
424
|
my $is_STAT = 0; $is_STAT = 1 if(defined $SORTIES{$no_sortie}{'STAT'});
|
|
425
|
|
|
426
|
print Fmaple "#\n";
|
|
427
|
print Fmaple "#-- sortie $no_sortie --\n";
|
|
428
|
print Fmaple "# ----------------------------------\n";
|
|
429
|
print Fmaple "# > maillage : $fher\n";
|
|
430
|
print Fmaple "# > liste noeuds : $ref_noeud\n";
|
|
431
|
print Fmaple "# > liste grandeurs : @grandeurs\n";
|
|
432
|
print Fmaple "# > ==> STATISTIQUE : somme, moyenne, min, max\n" if($is_STAT);
|
|
433
|
print Fmaple "# ----------------------------------\n";
|
|
434
|
|
|
435
|
#cas d une STATISTIQUE
|
|
436
|
if($is_STAT) {
|
|
437
|
print Fmaple "# STATISTIQUE :";
|
|
438
|
foreach my $grandeur (@grandeurs) {
|
|
439
|
print Fmaple " ";
|
|
440
|
my $nb_comp = $table_grandeurs_rep_Gmsh{$grandeur}{'nb_composantes'};
|
|
441
|
if($nb_comp == 1) {
|
|
442
|
$nb_colonnes++;
|
|
443
|
print Fmaple " [$nb_colonnes] $grandeur(SOMME)";
|
|
444
|
$nb_colonnes++;
|
|
445
|
print Fmaple " [$nb_colonnes] $grandeur(MOYENNE)";
|
|
446
|
$nb_colonnes++;
|
|
447
|
print Fmaple " [$nb_colonnes] $grandeur(MIN)";
|
|
448
|
$nb_colonnes++;
|
|
449
|
print Fmaple " [$nb_colonnes] $grandeur(MAX)";
|
|
450
|
}
|
|
451
|
else {
|
|
452
|
for(my $i=1; $i<=$nb_comp; $i++) {
|
|
453
|
$nb_colonnes++;
|
|
454
|
print Fmaple " [$nb_colonnes] $grandeur(comp_$i, SOMME)";
|
|
455
|
$nb_colonnes++;
|
|
456
|
print Fmaple " [$nb_colonnes] $grandeur(comp_$i, MOYENNE)";
|
|
457
|
$nb_colonnes++;
|
|
458
|
print Fmaple " [$nb_colonnes] $grandeur(comp_$i, MIN)";
|
|
459
|
$nb_colonnes++;
|
|
460
|
print Fmaple " [$nb_colonnes] $grandeur(comp_$i, MAX)";
|
|
461
|
|
|
462
|
print Fmaple "\n# : " if($i != $nb_comp);
|
|
463
|
}
|
|
464
|
}
|
|
465
|
}
|
|
466
|
print Fmaple "\n";
|
|
467
|
}
|
|
468
|
|
|
469
|
#cas normal
|
|
470
|
else {
|
|
471
|
foreach my $no_noeud_her (@liste_noeuds_her) {
|
|
472
|
print Fmaple "# noeud\_$no_noeud_her :";
|
|
473
|
foreach my $grandeur (@grandeurs) {
|
|
474
|
print Fmaple " ";
|
|
475
|
my $nb_comp = $table_grandeurs_rep_Gmsh{$grandeur}{'nb_composantes'};
|
|
476
|
if($nb_comp == 1) {
|
|
477
|
$nb_colonnes++;
|
|
478
|
print Fmaple " [$nb_colonnes] $grandeur";
|
|
479
|
}
|
|
480
|
else {
|
|
481
|
for(my $i=1; $i<=$nb_comp; $i++) {
|
|
482
|
$nb_colonnes++;
|
|
483
|
print Fmaple " [$nb_colonnes] $grandeur(comp_$i)";
|
|
484
|
}
|
|
485
|
}
|
|
486
|
}
|
|
487
|
print Fmaple "\n";
|
|
488
|
}
|
|
489
|
}
|
|
490
|
|
|
491
|
}#for(my $no_sortie=1; $no_sortie<=$SORTIES{'nb_sorties'}; $no_sortie++)
|
|
492
|
|
|
493
|
print Fmaple "#\n";
|
|
494
|
print Fmaple "#\n";
|
|
495
|
print Fmaple "\n";
|
|
496
|
|
|
497
|
|
|
498
|
|
|
499
|
#---------------------------
|
|
500
|
#ecriture des donnees
|
|
501
|
#---------------------------
|
|
502
|
|
|
503
|
#-d abord : saisie du temps (on se base sur le fichier .pos de la premiere grandeur de la table des grandeurs)
|
|
504
|
my @liste_temps;
|
|
505
|
$_ = $table_grandeurs_rep_Gmsh{'liste_grandeurs'}[0];
|
|
506
|
my $fic = $table_grandeurs_rep_Gmsh{$_}{'fichier'};
|
|
507
|
open(FIC, "<$fic");
|
|
508
|
while(<FIC>) {
|
|
509
|
next if(not /^\s*\$nodedata\s*$/io);
|
|
510
|
for(1 .. 3) {<FIC>;}
|
|
511
|
$_ = <FIC>;
|
|
512
|
my ($temps) = split;
|
|
513
|
($temps =~ /^$format_reel$/) or die "\nErreur (prog:$NOM_PROG) : temps non conforme ($temps) ligne $. du fichier $fic ...\n\n";
|
|
514
|
push(@liste_temps, $temps);
|
|
515
|
}
|
|
516
|
close(FIC);
|
|
517
|
|
|
518
|
|
|
519
|
|
|
520
|
#-ensuite comme on va lire les fichiers nodedata par nodedata simultanement
|
|
521
|
# => on les ouvre tous via un hash de handle de fichiers
|
|
522
|
my %handle;
|
|
523
|
# => on cree la liste de noeuds (numerotation Gmsh) concernes pour chaque grandeur parmi toutes les sorties
|
|
524
|
my %liste_noeuds_Gmsh_grandeur;# @{$liste_noeuds_Gmsh_grandeur{nom grandeur}} = (liste de noeuds triee ordre croissant)
|
|
525
|
# => on creera un hash de valeur que l on rangera correctement dans l ordre des colonnes prevu
|
|
526
|
my %hash_valeurs;# $hash_valeurs{no noeud Gmsh}{grandeur}{no composante} = valeur
|
|
527
|
# (NB : no noeud Gmsh vient de la liste @{$SORTIES{no_sortie}{'liste_noeuds_Gmsh'})
|
|
528
|
|
|
529
|
#creation du handle de fichier pour chaque grandeur demandee
|
|
530
|
my %table_tmp_grandeurs_demandees;
|
|
531
|
my @liste_grandeurs_demandees;
|
|
532
|
my %handle_line_number;# (NB : hash permettant de connaitre la ligne courante de chaque fichier pour plus tard)
|
|
533
|
for(my $no_sortie=1; $no_sortie<=$SORTIES{'nb_sorties'}; $no_sortie++) {
|
|
534
|
foreach my $grandeur (@{$SORTIES{$no_sortie}{'liste_grandeurs'}}) {
|
|
535
|
if(not defined $table_tmp_grandeurs_demandees{$grandeur}) {
|
|
536
|
$table_tmp_grandeurs_demandees{$grandeur} = 1;
|
|
537
|
push(@liste_grandeurs_demandees, $grandeur);
|
|
538
|
$handle{$grandeur} = IO::File->new();
|
|
539
|
$handle{$grandeur}->open("<$table_grandeurs_rep_Gmsh{$grandeur}{'fichier'}");
|
|
540
|
$handle_line_number{$grandeur} = 0;
|
|
541
|
}
|
|
542
|
}
|
|
543
|
}
|
|
544
|
|
|
545
|
#liste de noeuds (numerotation Gmsh) concernes pour chaque grandeur parmi toutes les sorties
|
|
546
|
for(my $no_sortie=1; $no_sortie<=$SORTIES{'nb_sorties'}; $no_sortie++) {
|
|
547
|
my @grandeurs = @{$SORTIES{$no_sortie}{'liste_grandeurs'}};
|
|
548
|
my @liste_noeuds_Gmsh = @{$SORTIES{$no_sortie}{'liste_noeuds_Gmsh'}};
|
|
549
|
|
|
550
|
foreach my $grandeur (@grandeurs) {
|
|
551
|
push(@{$liste_noeuds_Gmsh_grandeur{$grandeur}}, @liste_noeuds_Gmsh);
|
|
552
|
}
|
|
553
|
}
|
|
554
|
#tri ordre croissant et suppression des doublons eventuels
|
|
555
|
foreach my $grandeur (@liste_grandeurs_demandees) {
|
|
556
|
@{$liste_noeuds_Gmsh_grandeur{$grandeur}} = sort {$a <=> $b} @{$liste_noeuds_Gmsh_grandeur{$grandeur}};
|
|
557
|
@{$liste_noeuds_Gmsh_grandeur{$grandeur}} = uniq @{$liste_noeuds_Gmsh_grandeur{$grandeur}};
|
|
558
|
}
|
|
559
|
|
|
560
|
|
|
561
|
#debut de la lecture
|
|
562
|
foreach my $temps (@liste_temps) {
|
|
563
|
|
|
564
|
#positionnement de tous les fichiers sur le prochain $nodedata (et verif du temps)
|
|
565
|
# plus exactement : on se positionnera juste avant le debut des valeurs noeud composantes... du nodedata
|
|
566
|
foreach my $grandeur (@liste_grandeurs_demandees) {
|
|
567
|
while($_ = $handle{$grandeur}->getline) {
|
|
568
|
$handle_line_number{$grandeur}++;
|
|
569
|
last if(/^\s*\$nodedata\s*$/io);
|
|
570
|
}
|
|
571
|
#verif temps
|
|
572
|
for(1 .. 3) {$handle{$grandeur}->getline; $handle_line_number{$grandeur}++;}
|
|
573
|
$_ = $handle{$grandeur}->getline; $handle_line_number{$grandeur}++;
|
|
574
|
my ($temps_) = split;
|
|
575
|
($temps_ = $temps) or die "\nErreur (prog:$NOM_PROG) : temps non conforme ($temps) ligne $handle_line_number{$grandeur} du fichier $table_grandeurs_rep_Gmsh{$grandeur}{'fichier'} ...\n\n";
|
|
576
|
#positionnement final juste avant le debut des valeurs du nodedata
|
|
577
|
for(1 .. 4) {$handle{$grandeur}->getline; $handle_line_number{$grandeur}++;}
|
|
578
|
}
|
|
579
|
|
|
580
|
|
|
581
|
#parcours de chaque grandeur
|
|
582
|
#pour l instant on parcours les noeuds de chaque sortie dans l ordre croissant et dans la numerotation Gmsh
|
|
583
|
#==> remplissage de $hash_valeurs{no noeud Gmsh}{grandeur}{no composante}
|
|
584
|
foreach my $grandeur (@liste_grandeurs_demandees) {
|
|
585
|
foreach my $no_noeud_Gmsh (@{$liste_noeuds_Gmsh_grandeur{$grandeur}}) {
|
|
586
|
while($_ = $handle{$grandeur}->getline) {
|
|
587
|
$handle_line_number{$grandeur}++;
|
|
588
|
@_ = split;
|
|
589
|
next if($_[0] != $no_noeud_Gmsh);
|
|
590
|
|
|
591
|
for(my $no_comp=1; $no_comp<=$#_; $no_comp++) {
|
|
592
|
$hash_valeurs{$no_noeud_Gmsh}{$grandeur}{$no_comp} = $_[$no_comp];
|
|
593
|
}
|
|
594
|
last;
|
|
595
|
}
|
|
596
|
}
|
|
597
|
}
|
|
598
|
|
|
599
|
#parcours de chaque sortie dans le meme ordre que l en-tete afin d ecrire les colonnes dans le bon ordre
|
|
600
|
#-ecriture du temps
|
|
601
|
print Fmaple "$temps";
|
|
602
|
|
|
603
|
#-ecriture des grandeurs pour chaque sortie
|
|
604
|
for(my $no_sortie=1; $no_sortie<=$SORTIES{'nb_sorties'}; $no_sortie++) {
|
|
605
|
|
|
606
|
my @grandeurs = @{$SORTIES{$no_sortie}{'liste_grandeurs'}};
|
|
607
|
my @liste_noeuds_Gmsh = @{$SORTIES{$no_sortie}{'liste_noeuds_Gmsh'}};
|
|
608
|
my $is_STAT = 0; $is_STAT = 1 if(defined $SORTIES{$no_sortie}{'STAT'});
|
|
609
|
|
|
610
|
#cas d une STATISTIQUE
|
|
611
|
if($is_STAT) {
|
|
612
|
foreach my $grandeur (@grandeurs) {
|
|
613
|
|
|
614
|
my $nb_comp = $table_grandeurs_rep_Gmsh{$grandeur}{'nb_composantes'};
|
|
615
|
|
|
616
|
if($nb_comp == 1) {
|
|
617
|
my $somme = 0.;
|
|
618
|
my $moyenne;
|
|
619
|
my ($min,$max);
|
|
620
|
my $nb_val = $#{$SORTIES{$no_sortie}{'liste_noeuds_Gmsh'}} + 1;
|
|
621
|
foreach my $no_noeud_Gmsh (@{$SORTIES{$no_sortie}{'liste_noeuds_Gmsh'}}) {
|
|
622
|
my $val = $hash_valeurs{$no_noeud_Gmsh}{$grandeur}{1};
|
|
623
|
$somme += $val;
|
|
624
|
$min = $max = $val if(not defined $min);
|
|
625
|
$min = $val if($val < $min);
|
|
626
|
$max = $val if($val > $max);
|
|
627
|
}
|
|
628
|
$moyenne = $somme/$nb_val;
|
|
629
|
print Fmaple " $somme $moyenne $min $max";
|
|
630
|
}
|
|
631
|
else {
|
|
632
|
for(my $i=1; $i<=$nb_comp; $i++) {
|
|
633
|
my $somme = 0.;
|
|
634
|
my $moyenne;
|
|
635
|
my ($min,$max);
|
|
636
|
my $nb_val = $#{$SORTIES{$no_sortie}{'liste_noeuds_Gmsh'}} + 1;
|
|
637
|
foreach my $no_noeud_Gmsh (@{$SORTIES{$no_sortie}{'liste_noeuds_Gmsh'}}) {
|
|
638
|
my $val = $hash_valeurs{$no_noeud_Gmsh}{$grandeur}{$i};
|
|
639
|
$somme += $val;
|
|
640
|
$min = $max = $val if(not defined $min);
|
|
641
|
$min = $val if($val < $min);
|
|
642
|
$max = $val if($val > $max);
|
|
643
|
}
|
|
644
|
$moyenne = $somme/$nb_val;
|
|
645
|
print Fmaple " $somme $moyenne $min $max";
|
|
646
|
}
|
|
647
|
}
|
|
648
|
}
|
|
649
|
}
|
|
650
|
|
|
651
|
#cas normal
|
|
652
|
else {
|
|
653
|
foreach my $no_noeud_Gmsh (@liste_noeuds_Gmsh) {
|
|
654
|
foreach my $grandeur (@grandeurs) {
|
|
655
|
my $nb_comp = $table_grandeurs_rep_Gmsh{$grandeur}{'nb_composantes'};
|
|
656
|
if($nb_comp == 1) {
|
|
657
|
print Fmaple " $hash_valeurs{$no_noeud_Gmsh}{$grandeur}{1}";
|
|
658
|
}
|
|
659
|
else {
|
|
660
|
for(my $i=1; $i<=$nb_comp; $i++) {
|
|
661
|
print Fmaple " $hash_valeurs{$no_noeud_Gmsh}{$grandeur}{$i}";
|
|
662
|
}
|
|
663
|
}
|
|
664
|
}
|
|
665
|
}
|
|
666
|
}
|
|
667
|
}#for(my $no_sortie=1; $no_sortie<=$SORTIES{'nb_sorties'}; $no_sortie++)
|
|
668
|
print Fmaple "\n";
|
|
669
|
|
|
670
|
|
|
671
|
}#foreach my $temps (@liste_temps)
|
|
672
|
|
|
673
|
|
|
674
|
|
|
675
|
close(Fmaple);
|
|
676
|
|
|
677
|
#fermeture des fichiers .pos
|
|
678
|
foreach my $grandeur (@liste_grandeurs_demandees) {
|
|
679
|
close($handle{$grandeur});
|
|
680
|
}
|
|
681
|
|
|
682
|
print "\nFichier cree : $fic_maple_a_creer\n\n";
|
|
683
|
|
|
684
|
|
|
685
|
|
|
686
|
|
|
687
|
|
|
688
|
#----------------
|
|
689
|
#subroutine make_table_grandeurs_Gmsh
|
|
690
|
#
|
|
691
|
# construction de la table de hashage des grandeurs d un repertoire Gmsh
|
|
692
|
#
|
|
693
|
# entree :
|
|
694
|
# - repertoire Gmsh
|
|
695
|
# - reference vers la table de hashage des grandeurs du repertoire Gmsh
|
|
696
|
#
|
|
697
|
sub make_table_grandeurs_Gmsh {
|
|
698
|
my $rep_Gmsh = shift;
|
|
699
|
my $ref_table_grandeurs = shift;
|
|
700
|
|
|
701
|
my @fpos;
|
|
702
|
foreach my $fichier (bsd_glob("$rep_Gmsh/*_Gmsh.pos")) {
|
|
703
|
(-T $fichier) or next;
|
|
704
|
is_fic_pos_valide($fichier) or next;
|
|
705
|
|
|
706
|
my $fichier_bn = basename $fichier;
|
|
707
|
push(@fpos, $fichier_bn);
|
|
708
|
}
|
|
709
|
|
|
710
|
my $racine_commune = chaine_commune(@fpos);
|
|
711
|
|
|
712
|
foreach my $fpos (@fpos) {
|
|
713
|
my $grandeur = $fpos;
|
|
714
|
$grandeur =~ s/^$racine_commune//;
|
|
715
|
$grandeur =~ s/_Gmsh.pos$//;
|
|
716
|
$grandeur =~ s/_ddl_noe$//;
|
|
717
|
$grandeur =~ s/_pti$//;
|
|
718
|
$grandeur =~ s/_evolue_noe$//;
|
|
719
|
$grandeur =~ s/_ddl_etendu_noe$//;
|
|
720
|
|
|
721
|
$ref_table_grandeurs->{$grandeur}{'fichier'} = "$rep_Gmsh/$fpos";
|
|
722
|
$ref_table_grandeurs->{$grandeur}{'nb_composantes'} = get_nb_comp_fpos("$rep_Gmsh/$fpos");
|
|
723
|
|
|
724
|
push(@{$ref_table_grandeurs->{'liste_grandeurs'}}, $grandeur);
|
|
725
|
}
|
|
726
|
|
|
727
|
}#sub make_table_grandeurs_Gmsh
|
|
728
|
#----------------
|
|
729
|
|
|
730
|
|
|
731
|
#----------------
|
|
732
|
#subroutine get_nb_comp_fpos
|
|
733
|
#
|
|
734
|
# saisie du nombre de composantes d une grandeur dans un fichier Gmsh .pos
|
|
735
|
#
|
|
736
|
# entree :
|
|
737
|
# - nom fichier .pos
|
|
738
|
#
|
|
739
|
# sortie :
|
|
740
|
# - nombre de composantes
|
|
741
|
#
|
|
742
|
sub get_nb_comp_fpos {
|
|
743
|
my $fpos = shift;
|
|
744
|
|
|
745
|
open(my $Hlocal, "<$fpos");
|
|
746
|
while(<$Hlocal>) {
|
|
747
|
next if(not /^\s*\$nodedata\s*$/io);
|
|
748
|
for(1 .. 6) {<$Hlocal>;}
|
|
749
|
$_ = <$Hlocal>;
|
|
750
|
my ($nb_comp) = split;
|
|
751
|
($nb_comp =~ /^\d+$/) or die "\nErreur (prog:$NOM_PROG) : impossible de lire le nombre de composantes dans le fichier $fpos ...\n\n";
|
|
752
|
close($Hlocal);
|
|
753
|
return $nb_comp;
|
|
754
|
}
|
|
755
|
close($Hlocal);
|
|
756
|
|
|
757
|
die "\nErreur (prog:$NOM_PROG) : impossible de lire le nombre de composantes dans le fichier $fpos ...\n\n";
|
|
758
|
}#sub get_nb_comp_fpos
|
|
759
|
#----------------
|
|
760
|
|
|
761
|
|
|
762
|
|
|
763
|
#----------------
|
|
764
|
#subroutine print_fic_cmd
|
|
765
|
#
|
|
766
|
# ecriture d un fichier exemple de commande
|
|
767
|
#
|
|
768
|
# entree :
|
|
769
|
# - nom fichier a creer
|
|
770
|
sub print_fic_cmd {
|
|
771
|
my $fic_cmd = shift;
|
|
772
|
|
|
773
|
open(my $Hlocal, ">$fic_cmd");
|
|
774
|
print $Hlocal "MAILLAGES #mot-cle de declaration des fichiers maillage\n";
|
|
775
|
print $Hlocal "nom_fichier_1.her\n";
|
|
776
|
print $Hlocal "nom_fichier_2.her\n";
|
|
777
|
print $Hlocal "\n";
|
|
778
|
print $Hlocal "SORTIES #mot-cle de declaration des sorties de grandeurs\n";
|
|
779
|
print $Hlocal "1 #maillage 1\n";
|
|
780
|
print $Hlocal "N_tout EPS11 SIG11 #sortie aux noeuds N_tout du maillage 1\n";
|
|
781
|
print $Hlocal "\n";
|
|
782
|
print $Hlocal "2 #maillage 2\n";
|
|
783
|
print $Hlocal "129 Def_principaleI Sigma_principaleI #sortie au noeud 129 du maillage 2\n";
|
|
784
|
print $Hlocal "\n";
|
|
785
|
print $Hlocal "1 #maillage 1\n";
|
|
786
|
print $Hlocal "N_S def_duale_mises contrainte_mises #sortie aux noeuds N_S du maillage 1\n";
|
|
787
|
print $Hlocal "\n";
|
|
788
|
print $Hlocal "1 #maillage 1\n";
|
|
789
|
print $Hlocal "STAT N_S def_duale_mises contrainte_mises #idem precedent mais cette fois on veut une STATISTIQUE sur la liste N_S\n";
|
|
790
|
close($Hlocal);
|
|
791
|
}#sub print_fic_cmd
|
|
792
|
#----------------
|
|
793
|
|
|
794
|
|
|
795
|
#----------------
|
|
796
|
#subroutine is_fic_pos_valide
|
|
797
|
#
|
|
798
|
# verification rapide de la valide d un fichier .pos (par une heuristique : presence du mot-cle $nodedata au moins une fois)
|
|
799
|
#
|
|
800
|
# entree :
|
|
801
|
# - nom fichier a verifier
|
|
802
|
#
|
|
803
|
# sortie :
|
|
804
|
# - indicateur (1 si fichier valide, sinon 0)
|
|
805
|
#
|
|
806
|
sub is_fic_pos_valide {
|
|
807
|
my $fic = shift;
|
|
808
|
|
|
809
|
open(my $Hlocal, "<$fic");
|
|
810
|
while(<$Hlocal>) {
|
|
811
|
next if(not /^\s*\$nodedata\s*$/io);
|
|
812
|
close($Hlocal);
|
|
813
|
return 1;
|
|
814
|
}
|
|
815
|
close($Hlocal);
|
|
816
|
|
|
817
|
return 0;
|
|
818
|
}#sub is_fic_pos_valide
|
|
819
|
|
|
820
|
|
|
821
|
#----------------
|
|
822
|
#subroutine nb_noeuds_maillage
|
|
823
|
#
|
|
824
|
# renvoie le nombre de noeuds si le fichier est un maillage .her valide (par une heuristique sur NOEUDS)
|
|
825
|
# sinon 0
|
|
826
|
#
|
|
827
|
# entree :
|
|
828
|
# - nom fichier
|
|
829
|
#
|
|
830
|
# sortie :
|
|
831
|
# - nombre de noeuds (ou 0 si le maillage n est pas valide)
|
|
832
|
sub nb_noeuds_maillage {
|
|
833
|
my $fher = shift;
|
|
834
|
|
|
835
|
my $nb_noeuds = 0;
|
|
836
|
|
|
837
|
open(my $Hlocal, "<$fher");
|
|
838
|
while(<$Hlocal>) {
|
|
839
|
next if(not /^\s*(\d+)\s+NOEUDS/o);
|
|
840
|
$nb_noeuds = $1;
|
|
841
|
last;
|
|
842
|
}
|
|
843
|
close($Hlocal);
|
|
844
|
|
|
845
|
return $nb_noeuds;
|
|
846
|
}#sub nb_noeuds_maillage
|
|
847
|
|
|
848
|
|
|
849
|
#----------------
|
|
850
|
#subroutine chaine_commune
|
|
851
|
#
|
|
852
|
# determine la chaine de caracteres commune a une liste de chaine de caractere (en commencant par le debut des chaines)
|
|
853
|
#
|
|
854
|
# entree :
|
|
855
|
# - liste de chaines de caracteres
|
|
856
|
#
|
|
857
|
# sortie :
|
|
858
|
# - chaine commune
|
|
859
|
#
|
|
860
|
sub chaine_commune {
|
|
861
|
my @liste = @_;
|
|
862
|
|
|
863
|
return '' if($#liste == -1);
|
|
864
|
|
|
865
|
my $chaine_commune = '';
|
|
866
|
MAIN:while(length($liste[0]) > 0) {
|
|
867
|
$liste[0] =~ s/^(.)//;
|
|
868
|
my $lettre_commune = $1;
|
|
869
|
for(my $i=1; $i<=$#liste; $i++) {
|
|
870
|
last MAIN if(length($liste[$i]) == 0);
|
|
871
|
$liste[$i] =~ s/^(.)//;
|
|
872
|
my $lettre = $1;
|
|
873
|
last MAIN if($lettre ne $lettre_commune);
|
|
874
|
}
|
|
875
|
$chaine_commune .= $lettre_commune;
|
|
876
|
}
|
|
877
|
|
|
878
|
return $chaine_commune;
|
|
879
|
}#sub chaine_commune
|
|
880
|
|
|
881
|
|
|
882
|
|
|
883
|
#----------------
|
|
884
|
#sub qui lit un maillage herezh++ pour recuperer les noeuds, les elements et les listes de references
|
|
885
|
#et les renvoier sous forme de reference (lecture du .her et d un .lis si il existe)
|
|
886
|
#
|
|
887
|
# exemple d appel :
|
|
888
|
# my ($nom_maillage, $nb_noeuds, $ref_tab_noeuds, $nb_elts, $ref_tab_elements, @ref_listes) = lecture_mail_her("fic_her");
|
|
889
|
#
|
|
890
|
# avec - $nom_maillage : nom du maillage (si il y en a un. sinon $nom_maillage sera egal a undef
|
|
891
|
# - $nb_noeuds : nombre de noeuds (entier)
|
|
892
|
# - $ref_tab_noeuds : reference vers un tableau de noeuds => $ref_tab_noeuds->[no noeud][0] : coordonnee x
|
|
893
|
# $ref_tab_noeuds->[no noeud][1] : coordonnee y
|
|
894
|
# $ref_tab_noeuds->[no noeud][2] : coordonnee z)
|
|
895
|
# - $nb_elts : nombre d elements (entier)
|
|
896
|
# - $ref_tab_elements : reference vers une table de hashage => $ref_tab_elements->{no elt}{'TYPE'} : type d element
|
|
897
|
# @{$ref_tab_elements->{no elt}{'CONNEX'}} : (liste des noeuds)
|
|
898
|
# - @ref_listes : liste de references vers les tables de hashage contenant les listes de references de noeuds, aretes, faces et elements
|
|
899
|
# => $ref_listes[0] : reference vers la table de hashage des listes de noeuds => @{$ref_listes[0]->{'nom liste'}} : (liste des noeuds)
|
|
900
|
# $ref_listes[1] : reference vers la table de hashage des listes d aretes => @{$ref_listes[1]->{'nom liste'}} : (liste des aretes)
|
|
901
|
# $ref_listes[2] : reference vers la table de hashage des listes de faces => @{$ref_listes[2]->{'nom liste'}} : (liste des faces)
|
|
902
|
# $ref_listes[3] : reference vers la table de hashage des listes d elements => @{$ref_listes[3]->{'nom liste'}} : (liste des elements)
|
|
903
|
# $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)
|
|
904
|
#
|
|
905
|
sub lecture_mail_her {
|
|
906
|
my $fher = shift;
|
|
907
|
|
|
908
|
my $nom_maillage;
|
|
909
|
|
|
910
|
#------------------------
|
|
911
|
# lecture du maillage .her
|
|
912
|
#------------------------
|
|
913
|
#-lecture de noeuds
|
|
914
|
my @tab_noeuds; my $nb_noeuds;
|
|
915
|
my $no_noeud = 0;
|
|
916
|
open(Fher, "<$fher");
|
|
917
|
while(<Fher>) {
|
|
918
|
if(/^\s*nom_maillage\s+(\S+)/o) {$nom_maillage = $1; next;}
|
|
919
|
next if(not /(\d+)\s+NOEUDS/o);
|
|
920
|
$nb_noeuds = $1;
|
|
921
|
last;
|
|
922
|
}
|
|
923
|
while(<Fher>) {
|
|
924
|
last if($no_noeud == $nb_noeuds);
|
|
925
|
next if(not /^\s*(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s*$/o);
|
|
926
|
$no_noeud = $1;
|
|
927
|
@{$tab_noeuds[$no_noeud]} = ($2,$3,$4);
|
|
928
|
}
|
|
929
|
|
|
930
|
#-lecture des elements
|
|
931
|
my %tab_elements; my $nb_elts;
|
|
932
|
my $no_elt = 0;
|
|
933
|
while(<Fher>) {
|
|
934
|
next if(not /(\d+)\s+ELEMENTS/o);
|
|
935
|
$nb_elts = $1;
|
|
936
|
last;
|
|
937
|
}
|
|
938
|
while(<Fher>) {
|
|
939
|
last if($no_elt == $nb_elts);
|
|
940
|
next if(not /^\s*\d+\s+\w+\s+\w+/o);
|
|
941
|
s/^\s+//;s/\s+$//;
|
|
942
|
$_ =~ /^(\d+)\s+/;
|
|
943
|
$no_elt = $1; s/^(\d+)\s+//;
|
|
944
|
$_ =~ /\s+(\d+(?:\s+\d+)*)$/;
|
|
945
|
@{$tab_elements{$no_elt}{'CONNEX'}} = split(/\s+/, $1); s/\s+(\d+(?:\s+\d+)*)$//;
|
|
946
|
$tab_elements{$no_elt}{'TYPE'} = $_; $tab_elements{$no_elt}{'TYPE'} =~ s/\s+/ /g;
|
|
947
|
}
|
|
948
|
close(Fher);
|
|
949
|
|
|
950
|
|
|
951
|
#------------------------
|
|
952
|
# lecture des references (dans le .her et dans un eventuel .lis)
|
|
953
|
#------------------------
|
|
954
|
my $flis = $fher; $flis =~ s/.her$/.lis/;
|
|
955
|
my $nom_liste;
|
|
956
|
my $is_liste_en_cours;
|
|
957
|
my %listes_NOEUDS;
|
|
958
|
my %listes_ARETES;
|
|
959
|
my %listes_FACES;
|
|
960
|
my %listes_ELEMENTS;
|
|
961
|
my %listes_PTI;
|
|
962
|
|
|
963
|
#-dans le .her
|
|
964
|
open(Fher, "<$fher");
|
|
965
|
$is_liste_en_cours = 0;
|
|
966
|
while(<Fher>) {
|
|
967
|
chomp;
|
|
968
|
if(/^\s*(N\S+)/o) {
|
|
969
|
$nom_liste = $1;
|
|
970
|
$is_liste_en_cours = 1;
|
|
971
|
s/^\s*N\S+\s+//; s/\s+$//;
|
|
972
|
push(@{$listes_NOEUDS{$nom_liste}},split(/\s+/,$_));
|
|
973
|
}
|
|
974
|
elsif(/^\s*noeuds/io or /^\s*elements/i or /^\s*[AFEG]/o) {
|
|
975
|
$is_liste_en_cours = 0;
|
|
976
|
}
|
|
977
|
elsif($is_liste_en_cours and /^\s*\d+(\s+\d+)*\s*$/io) {
|
|
978
|
s/^\s+//; s/\s+$//;
|
|
979
|
push(@{$listes_NOEUDS{$nom_liste}},split(/\s+/,$_));
|
|
980
|
}
|
|
981
|
}
|
|
982
|
close(Fher);
|
|
983
|
|
|
984
|
open(Fher, "<$fher");
|
|
985
|
$is_liste_en_cours = 0;
|
|
986
|
while(<Fher>) {
|
|
987
|
chomp;
|
|
988
|
if(/^\s*(A\S+)/o) {
|
|
989
|
$nom_liste = $1;
|
|
990
|
$is_liste_en_cours = 1;
|
|
991
|
s/^\s*A\S+\s+//; s/\s+$//;
|
|
992
|
push(@{$listes_ARETES{$nom_liste}},split(/\s+/,$_));
|
|
993
|
}
|
|
994
|
elsif(/^\s*noeuds/io or /^\s*elements/i or /^\s*[NFEG]/o) {
|
|
995
|
$is_liste_en_cours = 0;
|
|
996
|
}
|
|
997
|
elsif($is_liste_en_cours and /^\s*\d+(\s+\d+)*\s*$/io) {
|
|
998
|
s/^\s+//; s/\s+$//;
|
|
999
|
push(@{$listes_ARETES{$nom_liste}},split(/\s+/,$_));
|
|
1000
|
}
|
|
1001
|
}
|
|
1002
|
close(Fher);
|
|
1003
|
|
|
1004
|
open(Fher, "<$fher");
|
|
1005
|
$is_liste_en_cours = 0;
|
|
1006
|
while(<Fher>) {
|
|
1007
|
chomp;
|
|
1008
|
if(/^\s*(F\S+)/) {
|
|
1009
|
$nom_liste = $1;
|
|
1010
|
$is_liste_en_cours = 1;
|
|
1011
|
s/^\s*F\S+\s+//; s/\s+$//;
|
|
1012
|
push(@{$listes_FACES{$nom_liste}},split(/\s+/,$_));
|
|
1013
|
}
|
|
1014
|
elsif(/^\s*noeuds/io or /^\s*elements/i or /^\s*[NAEG]/o) {
|
|
1015
|
$is_liste_en_cours = 0;
|
|
1016
|
}
|
|
1017
|
elsif($is_liste_en_cours and /^\s*\d+(\s+\d+)*\s*$/io) {
|
|
1018
|
s/^\s+//; s/\s+$//;
|
|
1019
|
push(@{$listes_FACES{$nom_liste}},split(/\s+/,$_));
|
|
1020
|
}
|
|
1021
|
}
|
|
1022
|
close(Fher);
|
|
1023
|
|
|
1024
|
open(Fher, "<$fher");
|
|
1025
|
$is_liste_en_cours = 0;
|
|
1026
|
while(<Fher>) {
|
|
1027
|
chomp;
|
|
1028
|
if(/^\s*(E\S+)/o) {
|
|
1029
|
$nom_liste = $1;
|
|
1030
|
$is_liste_en_cours = 1;
|
|
1031
|
s/^\s*E\S+\s+//; s/\s+$//;
|
|
1032
|
push(@{$listes_ELEMENTS{$nom_liste}},split(/\s+/,$_));
|
|
1033
|
}
|
|
1034
|
elsif(/^\s*noeuds/io or /^\s*elements/io or /^\s*[NAFG]/o) {
|
|
1035
|
$is_liste_en_cours = 0;
|
|
1036
|
}
|
|
1037
|
elsif($is_liste_en_cours and /^\s*\d+(\s+\d+)*\s*$/io) {
|
|
1038
|
s/^\s+//; s/\s+$//;
|
|
1039
|
push(@{$listes_ELEMENTS{$nom_liste}},split(/\s+/,$_));
|
|
1040
|
}
|
|
1041
|
}
|
|
1042
|
close(Fher);
|
|
1043
|
|
|
1044
|
open(Fher, "<$fher");
|
|
1045
|
$is_liste_en_cours = 0;
|
|
1046
|
while(<Fher>) {
|
|
1047
|
chomp;
|
|
1048
|
if(/^\s*(G\S+)/o) {
|
|
1049
|
$nom_liste = $1;
|
|
1050
|
$is_liste_en_cours = 1;
|
|
1051
|
s/^\s*G\S+\s+//; s/\s+$//;
|
|
1052
|
push(@{$listes_PTI{$nom_liste}},split(/\s+/,$_));
|
|
1053
|
}
|
|
1054
|
elsif(/^\s*noeuds/io or /^\s*elements/io or /^\s*[NAFE]/o) {
|
|
1055
|
$is_liste_en_cours = 0;
|
|
1056
|
}
|
|
1057
|
elsif($is_liste_en_cours and /^\s*\d+(\s+\d+)*\s*$/io) {
|
|
1058
|
s/^\s+//; s/\s+$//;
|
|
1059
|
push(@{$listes_PTI{$nom_liste}},split(/\s+/,$_));
|
|
1060
|
}
|
|
1061
|
}
|
|
1062
|
close(Fher);
|
|
1063
|
|
|
1064
|
|
|
1065
|
#dans le .lis (si il existe)
|
|
1066
|
if(-e $flis) {
|
|
1067
|
|
|
1068
|
open(Flis, "<$flis");
|
|
1069
|
$is_liste_en_cours = 0;
|
|
1070
|
while(<Flis>) {
|
|
1071
|
chomp;
|
|
1072
|
if(/^\s*(N\S+)/o) {
|
|
1073
|
$nom_liste = $1;
|
|
1074
|
$is_liste_en_cours = 1;
|
|
1075
|
s/^\s*N\S+\s+//; s/\s+$//;
|
|
1076
|
push(@{$listes_NOEUDS{$nom_liste}},split(/\s+/,$_));
|
|
1077
|
}
|
|
1078
|
elsif(/^\s*noeuds/io or /^\s*elements/io or /^\s*[AFEG]/o) {
|
|
1079
|
$is_liste_en_cours = 0;
|
|
1080
|
}
|
|
1081
|
elsif($is_liste_en_cours and /^\s*\d+(\s+\d+)*\s*$/i) {
|
|
1082
|
s/^\s+//; s/\s+$//;
|
|
1083
|
push(@{$listes_NOEUDS{$nom_liste}},split(/\s+/,$_));
|
|
1084
|
}
|
|
1085
|
}
|
|
1086
|
close(Flis);
|
|
1087
|
|
|
1088
|
open(Flis, "<$flis");
|
|
1089
|
$is_liste_en_cours = 0;
|
|
1090
|
while(<Flis>) {
|
|
1091
|
chomp;
|
|
1092
|
if(/^\s*(A\S+)/o) {
|
|
1093
|
$nom_liste = $1;
|
|
1094
|
$is_liste_en_cours = 1;
|
|
1095
|
s/^\s*A\S+\s+//; s/\s+$//;
|
|
1096
|
push(@{$listes_ARETES{$nom_liste}},split(/\s+/,$_));
|
|
1097
|
}
|
|
1098
|
elsif(/^\s*noeuds/io or /^\s*elements/io or /^\s*[NFEG]/o) {
|
|
1099
|
$is_liste_en_cours = 0;
|
|
1100
|
}
|
|
1101
|
elsif($is_liste_en_cours and /^\s*\d+(\s+\d+)*\s*$/io) {
|
|
1102
|
s/^\s+//; s/\s+$//;
|
|
1103
|
push(@{$listes_ARETES{$nom_liste}},split(/\s+/,$_));
|
|
1104
|
}
|
|
1105
|
}
|
|
1106
|
close(Flis);
|
|
1107
|
|
|
1108
|
open(Flis, "<$flis");
|
|
1109
|
$is_liste_en_cours = 0;
|
|
1110
|
while(<Flis>) {
|
|
1111
|
chomp;
|
|
1112
|
if(/^\s*(F\S+)/o) {
|
|
1113
|
$nom_liste = $1;
|
|
1114
|
$is_liste_en_cours = 1;
|
|
1115
|
s/^\s*F\S+\s+//; s/\s+$//;
|
|
1116
|
push(@{$listes_FACES{$nom_liste}},split(/\s+/,$_));
|
|
1117
|
}
|
|
1118
|
elsif(/^\s*noeuds/io or /^\s*elements/io or /^\s*[NAEG]/o) {
|
|
1119
|
$is_liste_en_cours = 0;
|
|
1120
|
}
|
|
1121
|
elsif($is_liste_en_cours and /^\s*\d+(\s+\d+)*\s*$/io) {
|
|
1122
|
s/^\s+//; s/\s+$//;
|
|
1123
|
push(@{$listes_FACES{$nom_liste}},split(/\s+/,$_));
|
|
1124
|
}
|
|
1125
|
}
|
|
1126
|
close(Flis);
|
|
1127
|
|
|
1128
|
open(Flis, "<$flis");
|
|
1129
|
$is_liste_en_cours = 0;
|
|
1130
|
while(<Flis>) {
|
|
1131
|
chomp;
|
|
1132
|
if(/^\s*(E\S+)/o) {
|
|
1133
|
$nom_liste = $1;
|
|
1134
|
$is_liste_en_cours = 1;
|
|
1135
|
s/^\s*E\S+\s+//; s/\s+$//;
|
|
1136
|
push(@{$listes_ELEMENTS{$nom_liste}},split(/\s+/,$_));
|
|
1137
|
}
|
|
1138
|
elsif(/^\s*noeuds/io or /^\s*elements/io or /^\s*[NAFG]/o) {
|
|
1139
|
$is_liste_en_cours = 0;
|
|
1140
|
}
|
|
1141
|
elsif($is_liste_en_cours and /^\s*\d+(\s+\d+)*\s*$/io) {
|
|
1142
|
s/^\s+//; s/\s+$//;
|
|
1143
|
push(@{$listes_ELEMENTS{$nom_liste}},split(/\s+/,$_));
|
|
1144
|
}
|
|
1145
|
}
|
|
1146
|
close(Flis);
|
|
1147
|
|
|
1148
|
open(Flis, "<$flis");
|
|
1149
|
$is_liste_en_cours = 0;
|
|
1150
|
while(<Flis>) {
|
|
1151
|
chomp;
|
|
1152
|
if(/^\s*(G\S+)/o) {
|
|
1153
|
$nom_liste = $1;
|
|
1154
|
$is_liste_en_cours = 1;
|
|
1155
|
s/^\s*G\S+\s+//; s/\s+$//;
|
|
1156
|
push(@{$listes_PTI{$nom_liste}},split(/\s+/,$_));
|
|
1157
|
}
|
|
1158
|
elsif(/^\s*noeuds/io or /^\s*elements/io or /^\s*[NAFE]/o) {
|
|
1159
|
$is_liste_en_cours = 0;
|
|
1160
|
}
|
|
1161
|
elsif($is_liste_en_cours and /^\s*\d+(\s+\d+)*\s*$/io) {
|
|
1162
|
s/^\s+//; s/\s+$//;
|
|
1163
|
push(@{$listes_PTI{$nom_liste}},split(/\s+/,$_));
|
|
1164
|
}
|
|
1165
|
}
|
|
1166
|
close(Flis);
|
|
1167
|
|
|
1168
|
}#if(-e $flis)
|
|
1169
|
|
|
1170
|
#AFFICHAGE DES LISTES DE NOEUDS
|
|
1171
|
#foreach my $nom (keys(%listes_NOEUDS)) {
|
|
1172
|
# print "$nom : @{$listes_NOEUDS{$nom}}\n";
|
|
1173
|
#}
|
|
1174
|
#AFFICHAGE DES LISTES D ARETES
|
|
1175
|
#foreach my $nom (keys(%listes_ARETES)) {
|
|
1176
|
# print "$nom : @{$listes_ARETES{$nom}}\n";
|
|
1177
|
#}
|
|
1178
|
#AFFICHAGE DES LISTES DE FACES
|
|
1179
|
#foreach my $nom (keys(%listes_FACES)) {
|
|
1180
|
# print "$nom : @{$listes_FACES{$nom}}\n";
|
|
1181
|
#}
|
|
1182
|
#AFFICHAGE DES LISTES D ELEMENTS
|
|
1183
|
#foreach my $nom (keys(%listes_ELEMENTS)) {
|
|
1184
|
# print "$nom : @{$listes_ELEMENTS{$nom}}\n";
|
|
1185
|
#}
|
|
1186
|
#AFFICHAGE DES LISTES DE POINTS D INTEGRATION
|
|
1187
|
#foreach my $nom (keys(%listes_PTI)) {
|
|
1188
|
# print "$nom : @{$listes_PTI{$nom}}\n";
|
|
1189
|
#}
|
|
1190
|
|
|
1191
|
return($nom_maillage, $nb_noeuds, \@tab_noeuds, $nb_elts, \%tab_elements,
|
|
1192
|
\%listes_NOEUDS, \%listes_ARETES,
|
|
1193
|
\%listes_FACES, \%listes_ELEMENTS, \%listes_PTI);
|
|
1194
|
}#sub lecture_mail_her
|