|
1
|
#!/usr/bin/perl
|
|
2
|
use strict;
|
|
3
|
use POSIX qw(strftime);
|
|
4
|
|
|
5
|
################################################################################################
|
|
6
|
# script pour passer du format .pos ou .msh genere par herezh pour gmsh au format .geo #
|
|
7
|
# version 1: version initiale octobre 2015 #
|
|
8
|
################################################################################################
|
|
9
|
|
|
10
|
my $nom;
|
|
11
|
my $version = "1.";
|
|
12
|
if (@ARGV[0] eq '-h')
|
|
13
|
# si on n'a pas d'argument, on donne le mode d'emploi
|
|
14
|
{
|
|
15
|
print ("\n");
|
|
16
|
print ("\n" . '#############################################################################');
|
|
17
|
print ("\n" . '# #');
|
|
18
|
print ("\n" . '# msh2geo.pl #');
|
|
19
|
print ("\n" . '# transformation d\'un format .pos ou .msh genere par herezh pour gmsh #');
|
|
20
|
print ("\n" . '# en un fichier .geo #');
|
|
21
|
print ("\n" . '#############################################################################');
|
|
22
|
print ("\n" . '# licence GPL, gerard.rio@univ-ubs.fr #');
|
|
23
|
print ("\n" . '# http://www-lg2m.univ-ubs.fr/~rio #');
|
|
24
|
print ("\n" . '# version '."$version".' #');
|
|
25
|
print ("\n" . '#############################################################################');
|
|
26
|
print ("\n\n\n");
|
|
27
|
print ("\n usage: msh2geo.pl ");
|
|
28
|
print ("\n ----> entree interactive des noms de fichier \n");
|
|
29
|
print ("\n usage: msh2geo.pl <nom fichier.msh ou .pos> <nom fichier.por> \n");
|
|
30
|
print ("\n ----> indication de la source et de la cible ");
|
|
31
|
print ("\n NB: les noms de fichier peuvent avoir ou non leur extension \n");
|
|
32
|
print ("\n usage: msh2geo.pl -v ");
|
|
33
|
print ("\n ----> affiche la version du programme \n");
|
|
34
|
print ("\n usage: msh2geo.pl -h ");
|
|
35
|
print ("\n ----> information sur l'utilisation \n");
|
|
36
|
print ("\n\n");
|
|
37
|
die ("arret normal");
|
|
38
|
}
|
|
39
|
elsif (@ARGV[0] eq '-v')
|
|
40
|
{ print ("\n msh2geo.pl: version "."$version"."\n\n");
|
|
41
|
die ("arret normal");
|
|
42
|
};
|
|
43
|
|
|
44
|
#------------------- écriture de l'entete à l'écran -----------------
|
|
45
|
print ("\n");
|
|
46
|
print ("\n" . '#############################################################################');
|
|
47
|
print ("\n" . '# #');
|
|
48
|
print ("\n" . '# msh2geo.pl #');
|
|
49
|
print ("\n" . '# transformation d\'un format .pos ou .msh genere par herezh pour gmsh #');
|
|
50
|
print ("\n" . '# en un fichier utilisable par RDM6 #');
|
|
51
|
print ("\n" . '#############################################################################');
|
|
52
|
print ("\n" . '# licence GPL, gerard.rio@univ-ubs.fr #');
|
|
53
|
print ("\n" . '# http://www-lg2m.univ-ubs.fr/~rio #');
|
|
54
|
print ("\n" . '# version '."$version".' #');
|
|
55
|
print ("\n" . '#############################################################################');
|
|
56
|
print ("\n\n\n");
|
|
57
|
|
|
58
|
|
|
59
|
#------------------- fin écriture de l'entete à l'écran -----------------
|
|
60
|
|
|
61
|
#------------------- on s'occupe tout d'abord des fichiers --------------------
|
|
62
|
|
|
63
|
# tout d'abord on récupère le nom du fichier à traiter
|
|
64
|
my $nombase;
|
|
65
|
if (@ARGV[0])
|
|
66
|
# si on a un argument, c'est le nom du fichier
|
|
67
|
{ $nombase = @ARGV[0];}
|
|
68
|
else
|
|
69
|
# sinon on demande interactivement le nom du fichier
|
|
70
|
{ print ("\n nom du fichier ? ");
|
|
71
|
$nombase = <STDIN>; chomp($nombase); # on supprime le retour à la ligne
|
|
72
|
};
|
|
73
|
|
|
74
|
# on supprime l'extension .msh si elle existe
|
|
75
|
$nombase =~ s/\.msh//;
|
|
76
|
# idem pour l'extension .pos si elle existe
|
|
77
|
$nombase =~ s/\.pos//;
|
|
78
|
|
|
79
|
# on ouvre le fichier msh en lecture tout d'abord, il doit donc exister
|
|
80
|
my $fichier_msh = $nombase . '.msh'; # premier essai avec le .msh
|
|
81
|
unless (open (fic_msh,$fichier_msh))
|
|
82
|
{ # cas d'un pb d'ouverture, on essaie avec un .pos
|
|
83
|
my $fichier_msh = $nombase . '.pos';
|
|
84
|
open (fic_msh,$fichier_msh) ||
|
|
85
|
die (" \n erreur en ouverture du fichier " . $fichier_msh . " et .msh \n");
|
|
86
|
};
|
|
87
|
|
|
88
|
# on ouvre le fichier .geo en écriture, on écrase donc le fichier existant
|
|
89
|
my $fichier_geo;
|
|
90
|
if (@ARGV[1])
|
|
91
|
# si on a un argument 2, c'est le nom du fichier de sortie
|
|
92
|
{ $fichier_geo = @ARGV[1];}
|
|
93
|
else
|
|
94
|
# sinon on construit le nom du fichier
|
|
95
|
{$fichier_geo = $nombase . '.geo';
|
|
96
|
# on regarde s'il existe déjà
|
|
97
|
foreach (<*.geo>)
|
|
98
|
{ if ($_ eq $fichier_geo)
|
|
99
|
{ print ("\n le fichier " . $fichier_geo . " existe deja ! ");
|
|
100
|
print ("\n voulez-vous l\' ecraser ? (0 ou N ) ");
|
|
101
|
my $rep = <STDIN>; chomp($rep); $rep=lc($rep); # lc passage en minuscule
|
|
102
|
if ($rep eq 'n')
|
|
103
|
{print ("\n nom du fichier de sortie ? ");
|
|
104
|
$fichier_geo = <STDIN>; chomp($fichier_geo);
|
|
105
|
};
|
|
106
|
};
|
|
107
|
}; # fin du foreach
|
|
108
|
};
|
|
109
|
# on supprime l'extension .geo si elle existe
|
|
110
|
$fichier_geo =~ s/\.geo//;
|
|
111
|
# et on la rajoute
|
|
112
|
$fichier_geo .= '.geo';
|
|
113
|
|
|
114
|
# maintenant on tente l'ouverture de fichier
|
|
115
|
open (fic_geo,">$fichier_geo") || die (" \n erreur en ouverture du fichier " . $fichier_geo . " \n");
|
|
116
|
|
|
117
|
#------------------------ fin des ouvertures de fichiers ---------------------
|
|
118
|
|
|
119
|
|
|
120
|
#------------------ lecture de l'entete jusqu'aux noeuds -------------
|
|
121
|
print ("\n lecture de l'entete ");
|
|
122
|
# on lit dans les lignes jusqu'au mot clé $Nodes
|
|
123
|
my $position_sur_node = 0; # pour signaler que l'on est à la position des noeuds
|
|
124
|
# ++++++++++++++++++++++ lecture des coordonnées des noeuds ++++++++++++++++++++++++++
|
|
125
|
print ("\n lecture des coordonnees des noeuds ");
|
|
126
|
# on lit dans les lignes jusqu'au mot clé $Nodes
|
|
127
|
my $ligne;my @champ;
|
|
128
|
if ($position_sur_node != 1)
|
|
129
|
{ while (<fic_msh>)
|
|
130
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
131
|
$ligne =~ s/^[ \t]+//mg; # suppression des blancs et tabulation en début de ligne
|
|
132
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces
|
|
133
|
# on lit dans le fichier jusqu'au mot clé $Nodes
|
|
134
|
if ( $champ[0] eq '$Nodes' )
|
|
135
|
{$position_sur_node = 1;
|
|
136
|
last;}; # on a trouvé le premier enreg,
|
|
137
|
};
|
|
138
|
if ($position_sur_node != 1)
|
|
139
|
{ die ( "\n on n'a pas trouve le mot cle \$Nodes ?? , on ne peut pas continuer \n");
|
|
140
|
};
|
|
141
|
};
|
|
142
|
|
|
143
|
# --- on lit le nombre de noeud
|
|
144
|
$ligne = <fic_msh>; chomp($ligne);
|
|
145
|
$ligne =~ s/^[ \t]+//mg; # suppression des blancs et tabulation en début de ligne
|
|
146
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces
|
|
147
|
print (" nombre total de noeuds lus : " . $champ[0] );
|
|
148
|
my $nb_noeud = $champ[0] ;
|
|
149
|
|
|
150
|
# --- on lit chaque ligne de coordonnée que l'on recopie dans un tableau jusqu'au mot clé $EndNodes
|
|
151
|
my @les_noeuds = () ; # déclaration du tableau des coordonnées des noeuds
|
|
152
|
while (<fic_msh>)
|
|
153
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
154
|
$ligne =~ s/^[ \t]+//mg; # suppression des blancs et tabulation en début de ligne
|
|
155
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces
|
|
156
|
# on lit dans le fichier jusqu'au mot clé $EndNodes
|
|
157
|
if ( $champ[0] eq '$EndNodes' )
|
|
158
|
{last;}; # on a trouvé le premier enreg,
|
|
159
|
# ce n'est pas le mot clé, donc on enregistre la ligne
|
|
160
|
push @les_noeuds, $ligne; # sauvegarde des coordonnées et du numéro initial du noeud
|
|
161
|
};
|
|
162
|
|
|
163
|
|
|
164
|
# ++++++++++++++++++++++ fin de lecture des coordonnees noeuds ++++++++++++++++++++++++++++++++++++
|
|
165
|
|
|
166
|
#-------- def de tableaux de conversion entre les numérotations gmsh et celles d'herezh++ ----------
|
|
167
|
|
|
168
|
# définition des types d'éléments
|
|
169
|
|
|
170
|
my @type_element = ( 'rien pour le numero 0', # '0'
|
|
171
|
'segment lineaire a 2 noeuds' , # '1'
|
|
172
|
'triangle lineaire a 3 noeuds' , # '2'
|
|
173
|
'quadrangle bilineaire a 4 noeuds' , # '3'
|
|
174
|
'tetrahedre lineaire a 4 noeuds' , # '4'
|
|
175
|
'hexahedre trilineaire a 8 noeuds' , # '5'
|
|
176
|
'pentaedre bilineaire a 6 noeuds' , # '6'
|
|
177
|
'pyramide a 5 noeuds' , # '7'
|
|
178
|
'segment quadratique a 3 noeuds' , # '8'
|
|
179
|
'triangle quadratique a 6 noeuds' , # '9'
|
|
180
|
'quadrangle quadratique complet a 9 noeuds' , #'10'
|
|
181
|
'tetraedre quadratique a 10 noeuds' , #'11'
|
|
182
|
'hexaedre quadratique complet a 27 noeuds' , #'12'
|
|
183
|
'pentaedre quadratique complet a 18 noeuds' , #'13'
|
|
184
|
'pyramide quadratique a 14 noeuds' , #'14'
|
|
185
|
' point a 1 noeud ' , #'15'
|
|
186
|
'quadrangle quadratique incomplet a 8 noeuds' , #'16'
|
|
187
|
'hexaedre quadratique incomplet a 20 noeuds' , #'17'
|
|
188
|
'pentaedre quadratique incomplet a 15 noeuds' , #'18'
|
|
189
|
'pyramide quadratique incomplete a 13 noeuds' #'19'
|
|
190
|
);
|
|
191
|
|
|
192
|
my @type_herezh_element = ( 'rien pour le numero 0', # '0'
|
|
193
|
' POUT BIE1 ' , # '1'
|
|
194
|
' TRIANGLE LINEAIRE ' , # '2'
|
|
195
|
' QUADRANGLE LINEAIRE ' , # '3'
|
|
196
|
' TETRAEDRE LINEAIRE ' , # '4'
|
|
197
|
' HEXAEDRE LINEAIRE ' , # '5'
|
|
198
|
' PENTAEDRE LINEAIRE ' , # '6'
|
|
199
|
' PYRAMIDE LINEAIRE ' , # '7'
|
|
200
|
' POUT QUADRATIQUE ' , # '8'
|
|
201
|
' TRIANGLE QUADRACOMPL ' , # '9'
|
|
202
|
' QUADRANGLE QUADRACOMPL ' , #'10'
|
|
203
|
' TETRAEDRE QUADRACOMPL ' , #'11'
|
|
204
|
' HEXAEDRE QUADRACOMPL ' , #'12'
|
|
205
|
' PENTAEDRE QUADRACOMPL ' , #'13'
|
|
206
|
' PYRAMIDE QUADRACOMPL ' , #'14'
|
|
207
|
' POINT LINEAIRE ' , #'15'
|
|
208
|
' QUADRANGLE QUADRATIQUE ' , #'16'
|
|
209
|
' HEXAEDRE QUADRATIQUE ' , #'17'
|
|
210
|
' PENTAEDRE QUADRATIQUE ' , #'18'
|
|
211
|
' PYRAMIDE QUADRATIQUE ' #'19'
|
|
212
|
);
|
|
213
|
|
|
214
|
# les types et nombre de points d'intégration pour chaque éléments:
|
|
215
|
# 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
|
|
216
|
# puis les différents cas
|
|
217
|
my @type_herezh_integration = ( [0], #'rien pour le numero 0', # '0'
|
|
218
|
[0], # ' POUT BIE1 ' , # '1'
|
|
219
|
[0], # ' TRIANGLE LINEAIRE ' , # '2'
|
|
220
|
[0], # ' QUADRANGLE LINEAIRE ' , # '3'
|
|
221
|
[0], # ' TETRAEDRE LINEAIRE ' , # '4'
|
|
222
|
[8,1,27,64], # ' HEXAEDRE LINEAIRE ' , # '5'
|
|
223
|
[2,1,6], # ' PENTAEDRE LINEAIRE ' , # '6'
|
|
224
|
[0], # ' PYRAMIDE LINEAIRE ' , # '7'
|
|
225
|
[0], # ' POUT QUADRATIQUE ' , # '8'
|
|
226
|
[0], # ' TRIANGLE QUADRACOMPL ' , # '9'
|
|
227
|
[0], # ' QUADRANGLE QUADRACOMPL ' , #'10'
|
|
228
|
[0], # ' TETRAEDRE QUADRACOMPL ' , #'11'
|
|
229
|
[8,1,27,64], # ' HEXAEDRE QUADRACOMPL ' , #'12'
|
|
230
|
[6,9,12,18], #' PENTAEDRE QUADRACOMPL ' , #'13'
|
|
231
|
[0], # ' PYRAMIDE QUADRACOMPL ' , #'14'
|
|
232
|
[0], # ' POINT LINEAIRE ' , #'15'
|
|
233
|
[0], # ' QUADRANGLE QUADRATIQUE ' , #'16'
|
|
234
|
[8,1,27,64], # ' HEXAEDRE QUADRATIQUE ' , #'17'
|
|
235
|
[6,9,12,18], # ' PENTAEDRE QUADRATIQUE ' , #'18'
|
|
236
|
[0], # ' PYRAMIDE QUADRATIQUE ' #'19'
|
|
237
|
);
|
|
238
|
|
|
239
|
my @nbn_par_elem;
|
|
240
|
$nbn_par_elem[0]=0; $nbn_par_elem[1]=2; $nbn_par_elem[2]=3; $nbn_par_elem[3]=4;
|
|
241
|
$nbn_par_elem[4]=4; $nbn_par_elem[5]=8; $nbn_par_elem[6]=6; $nbn_par_elem[7]=5;
|
|
242
|
$nbn_par_elem[8]=3; $nbn_par_elem[9]=6; $nbn_par_elem[10]=9; $nbn_par_elem[11]=10;
|
|
243
|
$nbn_par_elem[12]=27; $nbn_par_elem[13]=18; $nbn_par_elem[14]=14; $nbn_par_elem[15]=1;
|
|
244
|
$nbn_par_elem[16]=8; $nbn_par_elem[17]=20; $nbn_par_elem[18]=15; $nbn_par_elem[19]=13;
|
|
245
|
|
|
246
|
# $connex[i][j] donne pour l'element i, le num de gmsh pour le numéro j d'herezh
|
|
247
|
|
|
248
|
my @connex = ( [], # le premier avec rien, pour que la numérotation commence à 1
|
|
249
|
[1,2], # 1: ' POUT BIE1 ' ,
|
|
250
|
[1,2,3], # 2: ' TRIANGLE LINEAIRE ' ,
|
|
251
|
[1,2,3,4], # 3: ' QUADRANGLE LINEAIRE ' ,
|
|
252
|
[1,2,3,4], # 4: ' TETRAEDRE LINEAIRE ' ,
|
|
253
|
[1,2,3,4,5,6,7,8], # 5: ' HEXAEDRE LINEAIRE ' ,
|
|
254
|
[1,2,3,4,5,6], # 6: ' PENTAEDRE LINEAIRE ' ,
|
|
255
|
[1,2,3,4,5], # 7: ' PYRAMIDE LINEAIRE ' ,
|
|
256
|
[1,3,2], # 8: ' POUT QUADRATIQUE ' ,
|
|
257
|
[1,2,3,4,5,6], # 9: ' TRIANGLE QUADRACOMPL ' ,
|
|
258
|
[1,2,3,4,5,6,7,8,9], # 10: ' QUADRANGLE QUADRACOMPL ' ,
|
|
259
|
[1,2,3,4,5,6,7,8,10,9], # 11: ' TETRAEDRE QUADRACOMPL ' ,
|
|
260
|
[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 ' ,
|
|
261
|
# [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
|
|
262
|
[1,2,3,4,5,6,7,10,8,9, 11,12,13,15,14,16,18,17], # 13:' PENTAEDRE QUADRACOMPL ' ,
|
|
263
|
[1,2,3,4,5,6,7,8,9,10,11,12,13,14], # 14:' PYRAMIDE QUADRACOMPL ' ,
|
|
264
|
[1], # 15: ' POINT LINEAIRE ' ,
|
|
265
|
[1,2,3,4,5,6,7,8], # 16: ' QUADRANGLE QUADRATIQUE ' ,
|
|
266
|
[1,2,3,4,5,6,7,8,9,12,14,10,11,13,15,16,17,19,20,18], # 17: ' HEXAEDRE QUADRATIQUE ' ,
|
|
267
|
# [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20], # 17: ' HEXAEDRE QUADRATIQUE ' ,
|
|
268
|
[1,2,3,4,5,6,7,10,8,9, 11,12,13,15,14], # 18:' PENTAEDRE QUADRATIQUE ' ,
|
|
269
|
[1,2,3,4,5,6,7,8,9,10,11,12,13], # 19: ' PYRAMIDE QUADRATIQUE '
|
|
270
|
);
|
|
271
|
|
|
272
|
my @type_geom =
|
|
273
|
( 'RIEN_TYPE_GEOM', # '0'
|
|
274
|
'LIGNE' , # '1'
|
|
275
|
'SURFACE' , # '2'
|
|
276
|
'SURFACE' , # '3'
|
|
277
|
'VOLUME' , # '4'
|
|
278
|
'VOLUME' , # '5'
|
|
279
|
'VOLUME' , # '6'
|
|
280
|
'VOLUME' , # '7'
|
|
281
|
'LIGNE' , # '8'
|
|
282
|
'SURFACE' , # '9'
|
|
283
|
'SURFACE' , #'10'
|
|
284
|
'VOLUME' , #'11'
|
|
285
|
'VOLUME' , #'12'
|
|
286
|
'VOLUME' , #'13'
|
|
287
|
'VOLUME' , #'14'
|
|
288
|
'POINT_G' , #'15'
|
|
289
|
'SURFACE' , #'16'
|
|
290
|
'VOLUME' , #'17'
|
|
291
|
'VOLUME' , #'18'
|
|
292
|
'VOLUME' #'19'
|
|
293
|
);
|
|
294
|
|
|
295
|
#-------- fin def de tableaux de conversion entre les numérotations gmsh et celles d'herezh++ ----------
|
|
296
|
|
|
297
|
|
|
298
|
# ++++++++++++++++++++++ lecture des éléments +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
299
|
print ("\n lecture des elements ");
|
|
300
|
|
|
301
|
while (<fic_msh>)
|
|
302
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
303
|
$ligne =~ s/^[ \t]+//mg; # suppression des blancs et tabulation en début de ligne
|
|
304
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces
|
|
305
|
# on lit dans le fichier jusqu'au mot clé $Elements
|
|
306
|
if ( $champ[0] eq '$Elements' )
|
|
307
|
{last;}; # on a trouvé le premier enreg,
|
|
308
|
};
|
|
309
|
|
|
310
|
# ----- on lit le nombre d'éléments
|
|
311
|
$ligne = <fic_msh>; chomp($ligne);
|
|
312
|
$ligne =~ s/^[ \t]+//mg; # suppression des blancs et tabulation en début de ligne
|
|
313
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces
|
|
314
|
print (" nombre total d'elements lus : " . $champ[0] );
|
|
315
|
my $nb_element = $champ[0] ;
|
|
316
|
|
|
317
|
|
|
318
|
# --- on lit chaque ligne que l'on recopie dans des tableaux jusqu'au mot clé $EndElements
|
|
319
|
|
|
320
|
my @liste_element = (); # ce sera un tableau multidimentionel
|
|
321
|
# chaque élément de @liste_element est une liste d'éléments d'un m^eme type
|
|
322
|
# $liste_element[i] = la liste des éléments de type i
|
|
323
|
# $liste_element[i][j] un élément = une liste d'entiers donc un tableau
|
|
324
|
# $liste_element [i][j][k] = un scalaire (entier) ouf !!
|
|
325
|
|
|
326
|
my @number_type = (); # les nombres d'élément de chaque type
|
|
327
|
|
|
328
|
while (<fic_msh>)
|
|
329
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
330
|
$ligne =~ s/^[ \t]+//mg; # suppression des blancs et tabulation en début de ligne
|
|
331
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de séparer sur des espaces
|
|
332
|
# on lit dans le fichier jusqu'au mot clé $EndElements
|
|
333
|
if ( $champ[0] eq '$EndElements' )
|
|
334
|
{last;}; # on a trouvé le premier enreg,
|
|
335
|
# traitement et enregistrement
|
|
336
|
push @{$liste_element[$champ[1]]}, [@champ ]; # tableau multidimentionnel, syntaxe particulière
|
|
337
|
#if ( $champ[1] == 15)
|
|
338
|
# {print "\n trouve " . @champ; print " ligne = " . $ligne;
|
|
339
|
# print ",,, " .$champ[0]." ".$champ[1]." ".$champ[2]." ".$champ[3]." ".$champ[4]." ".$champ[5]." ";};
|
|
340
|
$number_type[$champ[1]]++;
|
|
341
|
};
|
|
342
|
|
|
343
|
|
|
344
|
# test débug
|
|
345
|
#print "\n essai= " . $liste_element[15][1][3] ;
|
|
346
|
#print "\n une tranche
|
|
347
|
|
|
348
|
# on recherche le nombre d'élément différent
|
|
349
|
my $nb_type_elem = 0;
|
|
350
|
my $taille_list_elem = $#liste_element;
|
|
351
|
#print "\n number_type = " . @number_type;
|
|
352
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
353
|
{ if ($number_type[$j] != 0)
|
|
354
|
{ print "\n nombre d'elements du type ".$type_element[$j] ." = " . $number_type[$j] ;
|
|
355
|
$nb_type_elem++;
|
|
356
|
};
|
|
357
|
};
|
|
358
|
|
|
359
|
print "\n nombre initial d'elements differents " . $nb_type_elem ;
|
|
360
|
# en fait on ne conserve que les éléments lignes à 2 noeuds
|
|
361
|
# on signale les éléments supprimés
|
|
362
|
|
|
363
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
364
|
{ if ($number_type[$j] != 0)
|
|
365
|
{ if (($type_element[$j] ne 'segment lineaire a 2 noeuds')
|
|
366
|
&& ($type_element[$j] ne 'triangle lineaire a 3 noeuds')
|
|
367
|
&& ($type_element[$j] ne 'quadrangle bilineaire a 4 noeuds')
|
|
368
|
# && ($type_element[$j] ne 'triangle quadratique a 6 noeuds')
|
|
369
|
# && ($type_element[$j] ne 'quadrangle quadratique complet a 9 noeuds')
|
|
370
|
# && ($type_element[$j] ne 'quadrangle quadratique incomplet a 8 noeuds')
|
|
371
|
)
|
|
372
|
{print (' *** on supprime les elements '.$type_element[$j] .'*** '. "\n");
|
|
373
|
$number_type[$j] = 0;
|
|
374
|
}
|
|
375
|
};
|
|
376
|
};
|
|
377
|
|
|
378
|
# ++++++++++++++++++++++ fin lecture des éléments ++++++++++++++++++++++++++
|
|
379
|
|
|
380
|
|
|
381
|
|
|
382
|
close (fic_msh);
|
|
383
|
|
|
384
|
|
|
385
|
#====================== écriture du fichier .geo ============================
|
|
386
|
|
|
387
|
#------------------- écriture de l'entete du fichier .geo ---------------------
|
|
388
|
|
|
389
|
print fic_geo ("\n".'//************************************************************************');
|
|
390
|
print fic_geo ("\n".'// fichier genere automatiquement par msh2geo.pl');
|
|
391
|
print fic_geo ("\n".'//************************************************************************');
|
|
392
|
# cas particulier de la date
|
|
393
|
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();
|
|
394
|
print fic_geo ("\n".'// date: ');
|
|
395
|
printf fic_geo ("%02d/%02d/%02d", $mday, $mon, (1900+$year));
|
|
396
|
print fic_geo (' heure: ');
|
|
397
|
printf fic_geo (" %02d:%02d:%02d", $hour, $min, $sec);
|
|
398
|
|
|
399
|
# variables globales
|
|
400
|
print fic_geo ("\n\n".'dens = 1.e6 ; // densite des noeuds aux points ');
|
|
401
|
|
|
402
|
|
|
403
|
#------------------- écriture des points ---------------------
|
|
404
|
|
|
405
|
print fic_geo ("\n".'// les points ');
|
|
406
|
|
|
407
|
# ------ la liste des coordonnées des noeuds --------
|
|
408
|
for (my $k=0; $k < $nb_noeud; $k++)
|
|
409
|
{ my $enreg = @les_noeuds[$k];
|
|
410
|
@champ = split (/\s+/,$enreg); # le /s+/ permet de séparer sur des espaces
|
|
411
|
print fic_geo ("\nPoint(". $champ[0] .') = {'. $champ[1] .','. $champ[2] .','. $champ[3].',dens};' );
|
|
412
|
}
|
|
413
|
|
|
414
|
|
|
415
|
#-------------------- écriture des lignes = poutres --------------------
|
|
416
|
# ici uniquement un type d'éléments à sortir
|
|
417
|
# mais si on voulait par la suite des éléments triangles ou autre on
|
|
418
|
# laisse la procédure générale de msh2her.pl
|
|
419
|
my $nb_elementASortir = 0;
|
|
420
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
421
|
{ if ($number_type[$j] != 0)
|
|
422
|
{ $nb_elementASortir += $number_type[$j];};
|
|
423
|
};
|
|
424
|
print fic_geo ("\n\n".'// les lignes ( '."$nb_elementASortir".' )');
|
|
425
|
|
|
426
|
# ------ écriture des éléments lignes ------
|
|
427
|
|
|
428
|
my $numero = 1;
|
|
429
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
430
|
{ if ($number_type[$j] != 0)
|
|
431
|
{ my $nb_el = $number_type[$j];
|
|
432
|
for (my $el = 0;$el < $nb_el;$el++)
|
|
433
|
{ my $nbtag = $liste_element[$j][$el][2];
|
|
434
|
# si c'est une poutre on définit directement une ligne
|
|
435
|
my $tyyp = $liste_element[$j][$el][1]; # le type de l'élément
|
|
436
|
if ($type_element[$j] eq 'segment lineaire a 2 noeuds')
|
|
437
|
{
|
|
438
|
# écriture du numéro de l'élément puis du descriptif
|
|
439
|
printf fic_geo ("\n".'Line('. $numero.') = {' );
|
|
440
|
#print " tyyp= ".$tyyp."\n";
|
|
441
|
for (my $ia =0;$ia < $nbn_par_elem[$j]; $ia++)
|
|
442
|
{ # $ia = numéro d'ordre du noeud au format gmsh
|
|
443
|
# $connex[$tyyp][$ia] = numéro d'ordre du noeud au format herezh++
|
|
444
|
#print " ia= " . $ia ." connex= " . $connex[$tyyp][$ia]." ";
|
|
445
|
my $bb = $liste_element[$j][$el][2+ $nbtag + $connex[$tyyp][$ia] ]; # le numero herezh
|
|
446
|
if ($ia+1 != $nbn_par_elem[$j])
|
|
447
|
{print fic_geo ( $bb . ', ' );}
|
|
448
|
else
|
|
449
|
{print fic_geo ( $bb . '}; ' );};
|
|
450
|
};
|
|
451
|
$numero++;
|
|
452
|
}
|
|
453
|
# sinon il s'agit d'un élément de membrane
|
|
454
|
else
|
|
455
|
{ # on va créer un contour puis une surface
|
|
456
|
my $nb_ligne = $nbn_par_elem[$j]; # le nombre de ligne à créer
|
|
457
|
my $premier_num_ligne = $numero; # pour se rappeler
|
|
458
|
for (my $ia =0;$ia < $nbn_par_elem[$j]; $ia++)
|
|
459
|
{ # $ia = numéro d'ordre du noeud au format gmsh
|
|
460
|
# $connex[$tyyp][$ia] = numéro d'ordre du noeud au format herezh++
|
|
461
|
#print " ia= " . $ia ." connex= " . $connex[$tyyp][$ia]." ";
|
|
462
|
printf fic_geo ("\n".'Line('. $numero.') = {' );
|
|
463
|
my $bb = $liste_element[$j][$el][2+ $nbtag + $connex[$tyyp][$ia] ]; # le numero herezh
|
|
464
|
if ($ia+1 != $nbn_par_elem[$j])
|
|
465
|
{ my $dd = $liste_element[$j][$el][2+ $nbtag + $connex[$tyyp][$ia+1] ]; # le numero herezh
|
|
466
|
print fic_geo ( $bb . ', '.$dd.'}; ' );
|
|
467
|
}
|
|
468
|
else
|
|
469
|
{my $dd = $liste_element[$j][$el][2+ $nbtag + $connex[$tyyp][0] ]; # le numero herezh
|
|
470
|
print fic_geo ( $bb . ', '.$dd.'}; ' );
|
|
471
|
};
|
|
472
|
$numero++;
|
|
473
|
};
|
|
474
|
# on crée la loop de contour
|
|
475
|
#Line Loop(D1) = {1,9,2,10,3,4,5,11,6,12,7,8} ;
|
|
476
|
my $num_loop = $numero;
|
|
477
|
printf fic_geo ("\n".'Line Loop('. $num_loop.') = {' );
|
|
478
|
for (my $ia =0;$ia < $nbn_par_elem[$j]; $ia++)
|
|
479
|
{my $somme = $premier_num_ligne+$ia;
|
|
480
|
if ($ia+1 != $nbn_par_elem[$j])
|
|
481
|
{ print fic_geo ( $somme . ', ' );}
|
|
482
|
else
|
|
483
|
{ print fic_geo ( $somme . '}; ' );};
|
|
484
|
};
|
|
485
|
$numero++;
|
|
486
|
# on crée la surface
|
|
487
|
#Plane Surface(D2) = {D1,tt[1],tt[2],tt[30]} ;
|
|
488
|
printf fic_geo ("\n".'Plane Surface('. $numero.') = {'.$num_loop.'};' );
|
|
489
|
$numero++;
|
|
490
|
|
|
491
|
};
|
|
492
|
};
|
|
493
|
};
|
|
494
|
};
|
|
495
|
|
|
496
|
print fic_geo ("\n");
|
|
497
|
|
|
498
|
|
|
499
|
# écriture de la fin du fichier
|
|
500
|
|
|
501
|
#print fic_geo ("\n".'$fin du fichier'."\n");
|
|
502
|
close (fic_geo); # fermeture du fichier de maillage .geo
|
|
503
|
|
|
504
|
print ("\n" . '#############################################################################');
|
|
505
|
print ("\n" . '# msh2geo.pl #');
|
|
506
|
print ("\n" . '# fin creation du fichier .geo pour gmsh #');
|
|
507
|
print ("\n" . '#############################################################################'."\n\n");
|
|
508
|
|
|
509
|
|