|
1
|
#!/usr/bin/perl
|
|
2
|
use strict;
|
|
3
|
|
|
4
|
#########################################################################################
|
|
5
|
# script pour passer du format de maillage genere par abaqus au format lu par herezh++ #
|
|
6
|
# !!!!tous les cas ne sont pas int?gr? !!!!! #
|
|
7
|
#########################################################################################
|
|
8
|
|
|
9
|
my $nom;
|
|
10
|
if (@ARGV[0] eq '-h')
|
|
11
|
# si on n'a pas d'argument, on donne le mode d'emploi
|
|
12
|
{
|
|
13
|
print ("\n");
|
|
14
|
print ("\n" . '#############################################################################');
|
|
15
|
print ("\n" . '# #');
|
|
16
|
print ("\n" . '# ino2her.pl #');
|
|
17
|
print ("\n" . '# transformation d\'un maillage genere par le programme abaqus #');
|
|
18
|
print ("\n" . '# en un maillage utilisable par Herezh++ #');
|
|
19
|
print ("\n" . '#############################################################################');
|
|
20
|
print ("\n" . '# licence GPL, gerard.rio@univ-ubs.fr #');
|
|
21
|
print ("\n" . '# http://www-lg2m.univ-ubs.fr/~rio #');
|
|
22
|
print ("\n" . '# version 1 #');
|
|
23
|
print ("\n" . '#############################################################################');
|
|
24
|
print ("\n\n\n");
|
|
25
|
print ("\n usage: inp2her.pl ");
|
|
26
|
print ("\n ----> entree interactive des noms de fichier \n");
|
|
27
|
print ("\n usage: inp2her.pl <nom fichier.inp> <nom fichier.her> \n");
|
|
28
|
print ("\n ----> indication de la source et de la cible ");
|
|
29
|
print ("\n NB: les noms de fichier peuvent avoir ou non leur extension \n");
|
|
30
|
print ("\n usage: inp2her.pl -v ");
|
|
31
|
print ("\n ----> affiche la version du programme \n");
|
|
32
|
print ("\n usage: inp2her.pl -h ");
|
|
33
|
print ("\n ----> information sur l'utilisation \n");
|
|
34
|
print ("\n\n");
|
|
35
|
die ("arret normal");
|
|
36
|
}
|
|
37
|
elsif (@ARGV[0] eq '-v')
|
|
38
|
{ print ("\n inp2her.pl: version 1");
|
|
39
|
die ("arret normal");
|
|
40
|
};
|
|
41
|
|
|
42
|
#------------------- on s'occupe tout d'abord des fichiers --------------------
|
|
43
|
|
|
44
|
# tout d'abord on r?cup?re le nom du fichier ? traiter
|
|
45
|
my $nombase;
|
|
46
|
if (@ARGV[0])
|
|
47
|
# si on a un argument, c'est le nom du fichier
|
|
48
|
{ $nombase = @ARGV[0];}
|
|
49
|
else
|
|
50
|
# sinon on demande interactivement le nom du fichier
|
|
51
|
{ print ("\n nom du fichier ? ");
|
|
52
|
$nombase = <STDIN>; chomp($nombase); # on supprime le retour ? la ligne
|
|
53
|
};
|
|
54
|
|
|
55
|
# on supprime l'extension .inp si elle existe
|
|
56
|
$nombase =~ s/\.msh//;
|
|
57
|
|
|
58
|
# on ouvre le fichier msh en lecture tout d'abord, il doit donc exister
|
|
59
|
my $fichier_inp = $nombase . '.inp';
|
|
60
|
open (fic_inp,$fichier_inp) || die (" \n erreur en ouverture du fichier " . $fichier_inp . " \n");
|
|
61
|
|
|
62
|
# on ouvre le fichier .her en ?criture, on ?crase donc le fichier existant
|
|
63
|
my $fichier_her;
|
|
64
|
if (@ARGV[1])
|
|
65
|
# si on a un argument 2, c'est le nom du fichier de sortie
|
|
66
|
{ $fichier_her = @ARGV[1];}
|
|
67
|
else
|
|
68
|
# sinon on construit le nom du fichier
|
|
69
|
{$fichier_her = $nombase . '.her';
|
|
70
|
# on regarde s'il existe d?j?
|
|
71
|
foreach (<*.her>)
|
|
72
|
{ if ($_ eq $fichier_her)
|
|
73
|
{ print ("\n le fichier " . $fichier_her . " existe deja ! ");
|
|
74
|
print ("\n voulez-vous l\' ecraser ? (0 ou N ) ");
|
|
75
|
my $rep = <STDIN>; chomp($rep); $rep=lc($rep); # lc passage en minuscule
|
|
76
|
if ($rep eq 'n')
|
|
77
|
{print ("\n nom du fichier de sortie ? ");
|
|
78
|
$fichier_her = <STDIN>; chomp($fichier_her);
|
|
79
|
};
|
|
80
|
};
|
|
81
|
}; # fin du foreach
|
|
82
|
};
|
|
83
|
# on supprime l'extension .her si elle existe
|
|
84
|
$fichier_her =~ s/\.her//;
|
|
85
|
# et on la rajoute
|
|
86
|
$fichier_her .= '.her';
|
|
87
|
|
|
88
|
# maintenant on tente l'ouverture de fichier
|
|
89
|
open (fic_her,">$fichier_her") || die (" \n erreur en ouverture du fichier " . $fichier_her . " \n");
|
|
90
|
|
|
91
|
#------------------------ fin des ouvertures de fichiers ---------------------
|
|
92
|
|
|
93
|
# et ? l'?cran
|
|
94
|
print ("\n");
|
|
95
|
print ("\n" . '#############################################################################');
|
|
96
|
print ("\n" . '# #');
|
|
97
|
print ("\n" . '# inp2her.pl #');
|
|
98
|
print ("\n" . '# transformation d\'un maillage genere par le programme abaqus #');
|
|
99
|
print ("\n" . '# en un maillage utilisable par Herezh++ #');
|
|
100
|
print ("\n" . '#############################################################################');
|
|
101
|
print ("\n" . '# licence GPL, gerard.rio@univ-ubs.fr #');
|
|
102
|
print ("\n" . '# http://www-lg2m.univ-ubs.fr/~rio #');
|
|
103
|
print ("\n" . '# version 1 #');
|
|
104
|
print ("\n" . '#############################################################################');
|
|
105
|
print ("\n\n\n");
|
|
106
|
|
|
107
|
|
|
108
|
#------------------- fin ?criture de l'entete ? l'?cran -----------------
|
|
109
|
|
|
110
|
#------------------ lecture des tag qui vont servir pour fabriquer les r?f?rences -------------
|
|
111
|
print ("\n lecture des tags (preparation a la creation des references) ");
|
|
112
|
# on lit dans les lignes jusqu'au mot cl? $PhysicalNames
|
|
113
|
my $ligne;my @champ;
|
|
114
|
while (<fic_inp>)
|
|
115
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
116
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
117
|
# on lit dans le fichier jusqu'au mot cl? $PhysicalNames
|
|
118
|
if ( $champ[0] eq '$PhysicalNames' )
|
|
119
|
{last;}; # on a trouv? le premier enreg,
|
|
120
|
};
|
|
121
|
|
|
122
|
|
|
123
|
# --- on lit les tag
|
|
124
|
$ligne = <fic_inp>; chomp($ligne);
|
|
125
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
126
|
print (" nombre total de references lus : " . $champ[0] );
|
|
127
|
my $nb_reference = $champ[0] ;
|
|
128
|
|
|
129
|
# --- on lit chaque ligne de reference que l'on recopie dans un tableau jusqu'au mot cl? $EndPhysicalNames
|
|
130
|
my %les_references = () ; # d?claration de la table des reference
|
|
131
|
while (<fic_inp>)
|
|
132
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
133
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
134
|
# on lit dans le fichier jusqu'au mot cl? $EndPhysicalNames
|
|
135
|
if ( $champ[0] eq '$EndPhysicalNames' )
|
|
136
|
{last;}; # on a trouv? le mot cle de fin de reference,
|
|
137
|
# ce n'est pas le mot cl?, donc on enregistre la reference
|
|
138
|
$champ[1] =~ s/\"+//g; # on retire les guillemets ?ventuelles
|
|
139
|
$les_references{"$champ[0]"}= "$champ[1]";
|
|
140
|
};
|
|
141
|
print "\n les references ";
|
|
142
|
while ( (my $cle, my $valeur) = each %les_references)
|
|
143
|
{ print "\n ".$cle . ' => ' .$valeur;};
|
|
144
|
|
|
145
|
#------------------ fin de la lecture des tag qui vont servir pour fabriquer les r?f?rences -------------
|
|
146
|
|
|
147
|
|
|
148
|
|
|
149
|
# ++++++++++++++++++++++ lecture des coordonn?es des noeuds ++++++++++++++++++++++++++
|
|
150
|
print ("\n lecture des coordonnees des noeuds ");
|
|
151
|
# on lit dans les lignes jusqu'au mot cl? *NODE
|
|
152
|
my $ligne;my @champ;
|
|
153
|
while (<fic_inp>)
|
|
154
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la 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? $Nodes
|
|
157
|
if ( $champ[0] eq '$Nodes' )
|
|
158
|
{last;}; # on a trouv? le premier enreg,
|
|
159
|
};
|
|
160
|
|
|
161
|
# --- on lit le nombre de noeud
|
|
162
|
$ligne = <fic_inp>; chomp($ligne);
|
|
163
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
164
|
print (" nombre total de noeuds lus : " . $champ[0] );
|
|
165
|
my $nb_noeud = $champ[0] ;
|
|
166
|
|
|
167
|
#--- on pr?pare la def du nombre de noeud
|
|
168
|
my $nb_noeud = 0;
|
|
169
|
|
|
170
|
# --- on lit chaque ligne de coordonn?e que l'on recopie dans un tableau jusqu'au mot cl? $EndNodes
|
|
171
|
my @les_noeuds = () ; # d?claration du tableau des coordonn?es des noeuds
|
|
172
|
while (<fic_inp>)
|
|
173
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
174
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
175
|
# on lit dans le fichier jusqu'au mot cl? *NSET
|
|
176
|
if ( $champ[0] eq '*NSET' )
|
|
177
|
{last;}; # on a trouv? le premier enreg,
|
|
178
|
# ce n'est pas le mot cl?, donc on enregistre la ligne
|
|
179
|
push @les_noeuds, $ligne; # sauvegarde des coordonn?es et du num?ro initial du noeud
|
|
180
|
};
|
|
181
|
|
|
182
|
# ++++++++++++++++++++++ fin de lecture des coordonnees noeuds ++++++++++++++++++++++++++++++++++++
|
|
183
|
|
|
184
|
#-------- def de tableaux de conversion entre les num?rotations gmsh et celles d'herezh++ ----------
|
|
185
|
|
|
186
|
# d?finition des types d'?l?ments
|
|
187
|
|
|
188
|
my @type_element = ( 'rien pour le numero 0', # '0'
|
|
189
|
'segment lineaire a 2 noeuds' , # '1'
|
|
190
|
'triangle lineaire a 3 noeuds' , # '2'
|
|
191
|
'quadrangle bilineaire a 4 noeuds' , # '3'
|
|
192
|
'tetrahedre lineaire a 4 noeuds' , # '4'
|
|
193
|
'hexahedre trilineaire a 8 noeuds' , # '5'
|
|
194
|
'pentaedre bilineaire a 6 noeuds' , # '6'
|
|
195
|
'pyramide a 5 noeuds' , # '7'
|
|
196
|
'segment quadratique a 3 noeuds' , # '8'
|
|
197
|
'triangle quadratique a 6 noeuds' , # '9'
|
|
198
|
'quadrangle quadratique complet a 9 noeuds' , #'10'
|
|
199
|
'tetraedre quadratique a 10 noeuds' , #'11'
|
|
200
|
'hexaedre quadratique complet a 27 noeuds' , #'12'
|
|
201
|
'pentaedre quadratique complet a 18 noeuds' , #'13'
|
|
202
|
'pyramide quadratique a 14 noeuds' , #'14'
|
|
203
|
' point a 1 noeud ' , #'15'
|
|
204
|
'quadrangle quadratique incomplet a 8 noeuds' , #'16'
|
|
205
|
'hexaedre quadratique incomplet a 20 noeuds' , #'17'
|
|
206
|
'pentaedre quadratique incomplet a 15 noeuds' , #'18'
|
|
207
|
'pyramide quadratique incomplete a 13 noeuds' #'19'
|
|
208
|
);
|
|
209
|
|
|
210
|
my @type_herezh_element = ( 'rien pour le numero 0', # '0'
|
|
211
|
' POUT BIE1 ' , # '1'
|
|
212
|
' TRIANGLE LINEAIRE ' , # '2'
|
|
213
|
' QUADRANGLE LINEAIRE ' , # '3'
|
|
214
|
' TETRAEDRE LINEAIRE ' , # '4'
|
|
215
|
' HEXAEDRE LINEAIRE ' , # '5'
|
|
216
|
' PENTAEDRE LINEAIRE ' , # '6'
|
|
217
|
' PYRAMIDE LINEAIRE ' , # '7'
|
|
218
|
' POUT QUADRATIQUE ' , # '8'
|
|
219
|
' TRIANGLE QUADRACOMPL ' , # '9'
|
|
220
|
' QUADRANGLE QUADRACOMPL ' , #'10'
|
|
221
|
' TETRAEDRE QUADRATIQUE ' , #'11'
|
|
222
|
' HEXAEDRE QUADRACOMPL ' , #'12'
|
|
223
|
' PENTAEDRE QUADRACOMPL ' , #'13'
|
|
224
|
' PYRAMIDE QUADRACOMPL ' , #'14'
|
|
225
|
' POINT LINEAIRE ' , #'15'
|
|
226
|
' QUADRANGLE QUADRATIQUE ' , #'16'
|
|
227
|
' HEXAEDRE QUADRATIQUE ' , #'17'
|
|
228
|
' PENTAEDRE QUADRATIQUE ' , #'18'
|
|
229
|
' PYRAMIDE QUADRATIQUE ' #'19'
|
|
230
|
);
|
|
231
|
my @nbn_par_elem;
|
|
232
|
$nbn_par_elem[0]=0; $nbn_par_elem[1]=2; $nbn_par_elem[2]=3; $nbn_par_elem[3]=4;
|
|
233
|
$nbn_par_elem[4]=4; $nbn_par_elem[5]=8; $nbn_par_elem[6]=6; $nbn_par_elem[7]=5;
|
|
234
|
$nbn_par_elem[8]=3; $nbn_par_elem[9]=6; $nbn_par_elem[10]=9; $nbn_par_elem[11]=10;
|
|
235
|
$nbn_par_elem[12]=27; $nbn_par_elem[13]=18; $nbn_par_elem[14]=14; $nbn_par_elem[15]=1;
|
|
236
|
$nbn_par_elem[16]=8; $nbn_par_elem[17]=20; $nbn_par_elem[18]=15; $nbn_par_elem[19]=13;
|
|
237
|
|
|
238
|
# $connex[i][j] donne pour l'element i, le num de gmsh pour le num?ro j d'herezh
|
|
239
|
|
|
240
|
my @connex = ( [], # le premier avec rien, pour que la num?rotation commence ? 1
|
|
241
|
[1,2], # 1: ' POUT BIE1 ' ,
|
|
242
|
[1,2,3], # 2: ' TRIANGLE LINEAIRE ' ,
|
|
243
|
[1,2,3,4], # 3: ' QUADRANGLE LINEAIRE ' ,
|
|
244
|
[1,2,3,4], # 4: ' TETRAEDRE LINEAIRE ' ,
|
|
245
|
[1,2,2,3,4,5,6,7,8], # 5: ' HEXAEDRE LINEAIRE ' ,
|
|
246
|
[1,2,3,4,5,6], # 6: ' PENTAEDRE LINEAIRE ' ,
|
|
247
|
[1,2,3,4,5], # 7: ' PYRAMIDE LINEAIRE ' ,
|
|
248
|
[1,3,2], # 8: ' POUT QUADRATIQUE ' ,
|
|
249
|
[1,2,3,4,5,6], # 9: ' TRIANGLE QUADRACOMPL ' ,
|
|
250
|
[1,2,3,4,5,6,7,8,9], # 10: ' QUADRANGLE QUADRACOMPL ' ,
|
|
251
|
[1,2,3,4,5,6,7,8,9,10], # 11: ' TETRAEDRE QUADRATIQUE ' ,
|
|
252
|
[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], # 12: ' HEXAEDRE QUADRACOMPL ' ,
|
|
253
|
# [1,2,3,4,5,6,7,8, 9,10,11,12,13,14,15,16,17,18,] uniquement pour voir les num?ros
|
|
254
|
[1,2,3,4,5,6,7,10,8,9, 11,12,13,15,14,16,18,17], # 13:' PENTAEDRE QUADRACOMPL ' ,
|
|
255
|
[1,2,3,4,5,6,7,8,9,10,11,12,13,14], # 14:' PYRAMIDE QUADRACOMPL ' ,
|
|
256
|
[1], # 15: ' POINT LINEAIRE ' ,
|
|
257
|
[1,2,3,4,5,6,7,8], # 16: ' QUADRANGLE QUADRATIQUE ' ,
|
|
258
|
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20], # 17: ' HEXAEDRE QUADRATIQUE ' ,
|
|
259
|
[1,2,3,4,5,6,7,10,8,9, 11,12,13,15,14], # 18:' PENTAEDRE QUADRATIQUE ' ,
|
|
260
|
[1,2,3,4,5,6,7,8,9,10,11,12,13], # 19: ' PYRAMIDE QUADRATIQUE '
|
|
261
|
);
|
|
262
|
|
|
263
|
#-------- fin def de tableaux de conversion entre les num?rotations gmsh et celles d'herezh++ ----------
|
|
264
|
|
|
265
|
|
|
266
|
# ++++++++++++++++++++++ lecture des ?l?ments +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
267
|
print ("\n lecture des elements ");
|
|
268
|
|
|
269
|
while (<fic_inp>)
|
|
270
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
271
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
272
|
# on lit dans le fichier jusqu'au mot cl? $Elements
|
|
273
|
if ( $champ[0] eq '$Elements' )
|
|
274
|
{last;}; # on a trouv? le premier enreg,
|
|
275
|
};
|
|
276
|
|
|
277
|
# ----- on lit le nombre d'?l?ments
|
|
278
|
$ligne = <fic_inp>; chomp($ligne);
|
|
279
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
280
|
print (" nombre total d'elements lus : " . $champ[0] );
|
|
281
|
my $nb_element = $champ[0] ;
|
|
282
|
|
|
283
|
|
|
284
|
# --- on lit chaque ligne que l'on recopie dans des tableaux jusqu'au mot cl? $EndElements
|
|
285
|
|
|
286
|
my @liste_element = (); # ce sera un tableau multidimentionel
|
|
287
|
# chaque ?l?ment de @liste_element est une liste d'?l?ments d'un m^eme type
|
|
288
|
# $liste_element[i] = la liste des ?l?ments de type i
|
|
289
|
# $liste_element[i][j] un ?l?ment = une liste d'entiers donc un tableau
|
|
290
|
# $liste_element [i][j][k] = un scalaire (entier) ouf !!
|
|
291
|
|
|
292
|
my @number_type = (); # les nombres d'?l?ment de chaque type
|
|
293
|
|
|
294
|
while (<fic_inp>)
|
|
295
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
296
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
297
|
# on lit dans le fichier jusqu'au mot cl? $EndElements
|
|
298
|
if ( $champ[0] eq '$EndElements' )
|
|
299
|
{last;}; # on a trouv? le premier enreg,
|
|
300
|
# traitement et enregistrement
|
|
301
|
push @{$liste_element[$champ[1]]}, [@champ ]; # tableau multidimentionnel, syntaxe particuli?re
|
|
302
|
#if ( $champ[1] == 15)
|
|
303
|
# {print "\n trouve " . @champ; print " ligne = " . $ligne;
|
|
304
|
# print ",,, " .$champ[0]." ".$champ[1]." ".$champ[2]." ".$champ[3]." ".$champ[4]." ".$champ[5]." ";};
|
|
305
|
$number_type[$champ[1]]++;
|
|
306
|
};
|
|
307
|
|
|
308
|
|
|
309
|
# test d?bug
|
|
310
|
print "\n essai= " . $liste_element[15][1][3] ;
|
|
311
|
#print "\n une tranche
|
|
312
|
|
|
313
|
# on recherche le nombre d'?l?ment diff?rent
|
|
314
|
my $nb_type_elem = 0;
|
|
315
|
my $taille_list_elem = $#liste_element;
|
|
316
|
#print "\n number_type = " . @number_type;
|
|
317
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
318
|
{ if ($number_type[$j] != 0)
|
|
319
|
{ print "\n nombre d'elements du type ".$type_element[$j] ." = " . $number_type[$j] ;
|
|
320
|
$nb_type_elem++;
|
|
321
|
};
|
|
322
|
};
|
|
323
|
|
|
324
|
print "\n nombre initial d'elements differents " . $nb_type_elem ;
|
|
325
|
|
|
326
|
# maintenant on demande si l'on veut tous les ?l?ments ou certain uniquement
|
|
327
|
|
|
328
|
my @number_type_initial = @number_type; # sauvegarde pour le traitement des r?f?rences
|
|
329
|
print "\n\n === choix d'elements: voulez-vous ? ";
|
|
330
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
331
|
{ if ($number_type[$j] != 0)
|
|
332
|
{ print "\n conserver les element du type ".$type_element[$j] ." (rep o ou n) " ;
|
|
333
|
my $rep = <STDIN>; chomp($rep); $rep=lc($rep); # lc passage en minuscule
|
|
334
|
if ($rep eq 'o')
|
|
335
|
{print (' ===> ok, on conserve les elements '.$type_element[$j] . "\n");}
|
|
336
|
else
|
|
337
|
{print (' *** on supprime les elements '.$type_element[$j] .'*** '. "\n");
|
|
338
|
$number_type[$j] = 0;
|
|
339
|
}
|
|
340
|
};
|
|
341
|
};
|
|
342
|
|
|
343
|
# ++++++++++++++++++++++ fin lecture des ?l?ments ++++++++++++++++++++++++++
|
|
344
|
|
|
345
|
# ++++++++++++++++++++++ cr?ation des r?f?rences ++++++++++++++++++++++++++++++
|
|
346
|
|
|
347
|
# les r?f?rences de noeuds se trouvent par l'interm?diaire des ?l?ments "points"
|
|
348
|
# on passe donc en revue ces ?l?ments
|
|
349
|
my %ref_noeud; # def de conteneur des r?f?rences de noeuds
|
|
350
|
my %ref_element; # def du conteneur des r?f?rences d'?l?ments
|
|
351
|
#print "\n taille de la liste d'elem = " . $taille_list_elem;
|
|
352
|
my $numero = 1;
|
|
353
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
354
|
{ #print "\n taille des elem = " . $number_type[$j] ;
|
|
355
|
if ($number_type[$j] != 0)
|
|
356
|
{ my $nb_el = $number_type_initial[$j];
|
|
357
|
#print "\n nb_el= ".$nb_el;
|
|
358
|
for (my $el = 0;$el < $nb_el;$el++)
|
|
359
|
{
|
|
360
|
# ------- cas des r?f?rences de noeuds -----
|
|
361
|
|
|
362
|
if ($liste_element[$j][$el][1] == 15) # 15 c'est le type point
|
|
363
|
{ # on balaie les tag pour ajouter
|
|
364
|
my $nbtag = $liste_element[$j][$el][2]; # r?cup du nombre de tag
|
|
365
|
for (my $ic = 0; $ic < $nbtag; $ic++)
|
|
366
|
{ my $indic_ref = $liste_element[$j][$el][3+$ic]; # l'indicateur de la r?f?rence
|
|
367
|
#print "\n indicateur de la reference : ".$indic_ref;
|
|
368
|
my $nbnoe = $liste_element[$j][$el][3+ $nbtag]; # le num?ro du noeud
|
|
369
|
# $les_references{"$indic_ref"} = le nom de la r?f?rence, si ce n'est pas directement le nombre
|
|
370
|
my $nom = $les_references{"$indic_ref"};
|
|
371
|
#print "\n l equivalent d'indicateur de ref ".$nom;
|
|
372
|
if ($nom ne undef)
|
|
373
|
{ # cas ou le nom de la r?f?rence existe
|
|
374
|
if ( $ref_noeud{'N_' . $nom} == undef)
|
|
375
|
# si la r?f?rence n'est pas d?finie on la d?finie
|
|
376
|
{ my @tab = ($nbnoe);
|
|
377
|
#print "\n la cle = " . 'N_' . $nom;
|
|
378
|
$ref_noeud{'N_' . $nom} = [@tab]; # on sauvegarde le tableau
|
|
379
|
}
|
|
380
|
else
|
|
381
|
{ #print "\n la cle = " . 'N_' . $nom;
|
|
382
|
push @{$ref_noeud{'N_' . $nom}}, $nbnoe;
|
|
383
|
};
|
|
384
|
}
|
|
385
|
else
|
|
386
|
{ # cas ou le nom de la r?f?rence n'existe pas, on utilise directement le nombre
|
|
387
|
if ( $ref_noeud{'N_' ."$indic_ref"} == undef)
|
|
388
|
# si la r?f?rence n'est pas d?finie on la d?finie
|
|
389
|
{ my @tab = ($nbnoe);
|
|
390
|
$ref_noeud{'N_' ."$indic_ref"} = [@tab]; # on sauvegarde le tableau
|
|
391
|
}
|
|
392
|
else
|
|
393
|
{ push @{$ref_noeud{'N_' ."$indic_ref"}}, $nbnoe;
|
|
394
|
};
|
|
395
|
};
|
|
396
|
}
|
|
397
|
}
|
|
398
|
|
|
399
|
else # diff de 15 donc ?l?ments normal
|
|
400
|
# ------- cas des r?f?rences d'?l?ments -----
|
|
401
|
{ # on balaie les tag pour ajouter
|
|
402
|
my $nbtag = $liste_element[$j][$el][2]; # r?cup du nombre de tag
|
|
403
|
my %tag_deja_traite;
|
|
404
|
for (my $ic = 0; $ic < $nbtag; $ic++)
|
|
405
|
{ my $indic_ref = $liste_element[$j][$el][3+$ic]; # l'indicateur de la r?f?rence
|
|
406
|
# dans le cas o? il y a un nom de r?f?rence, l'indicateur de r?f?rence est doubl?
|
|
407
|
# ce qui n'est pas normal, on supprime ce doublement
|
|
408
|
if ($tag_deja_traite{"$indic_ref"} ne undef)
|
|
409
|
{next;}
|
|
410
|
$tag_deja_traite{"$indic_ref"} = '1'; # ne maniere ? pas avoir de undef
|
|
411
|
|
|
412
|
#print "\n indicateur de la reference : ".$indic_ref;
|
|
413
|
# $les_references{"$indic_ref"} = le nom de la r?f?rence, si ce n'est pas directement le nombre
|
|
414
|
my $nom = $les_references{"$indic_ref"};
|
|
415
|
#print "\n l equivalent d'indicateur de ref ".$nom;
|
|
416
|
if ($nom ne undef)
|
|
417
|
{ # cas ou le nom de la r?f?rence existe
|
|
418
|
if ( $ref_element{'E_' . $nom} == undef)
|
|
419
|
# si la r?f?rence n'est pas d?finie on la d?finie
|
|
420
|
{ my @tab = ($numero);
|
|
421
|
#print "\n la cle = " . 'E_' . $nom;
|
|
422
|
$ref_element{'E_' . $nom} = [@tab]; # on sauvegarde le tableau
|
|
423
|
}
|
|
424
|
else
|
|
425
|
{ #print "\n la cle = " . 'E_' . $nom;
|
|
426
|
push @{$ref_element{'E_' . $nom}}, $numero;
|
|
427
|
};
|
|
428
|
}
|
|
429
|
else
|
|
430
|
{ # cas ou le nom de la r?f?rence n'existe pas, on utilise directement le nombre
|
|
431
|
if ( $ref_element{'E_' ."$indic_ref"} == undef)
|
|
432
|
# si la r?f?rence n'est pas d?finie on la d?finie
|
|
433
|
{ my @tab = ($numero);
|
|
434
|
$ref_element{'E_' ."$indic_ref"} = [@tab]; # on sauvegarde le tableau
|
|
435
|
}
|
|
436
|
else
|
|
437
|
{ push @{$ref_element{'E_' ."$indic_ref"}}, $numero;
|
|
438
|
};
|
|
439
|
};
|
|
440
|
}
|
|
441
|
};
|
|
442
|
# on suit le cas de l'?criture finale des ?l?ments donc on n'incr?mente le num?ro
|
|
443
|
# d'?l?ment que s'il sera ?crit
|
|
444
|
if ($number_type[$j] != 0)
|
|
445
|
{ $numero++;};
|
|
446
|
};
|
|
447
|
};
|
|
448
|
};
|
|
449
|
|
|
450
|
# ++++++++++++++++++++++ fin cr?ation des r?f?rences ++++++++++++++++++++++++++
|
|
451
|
|
|
452
|
|
|
453
|
print ("\n ");
|
|
454
|
|
|
455
|
close (fic_inp);
|
|
456
|
|
|
457
|
|
|
458
|
#====================== ?criture du fichier .her ============================
|
|
459
|
|
|
460
|
#------------------- ?criture de l'entete du fichier .her ---------------------
|
|
461
|
|
|
462
|
print fic_her ("\n");
|
|
463
|
print fic_her ("\n" . '#############################################################################');
|
|
464
|
print fic_her ("\n" . '# #');
|
|
465
|
print fic_her ("\n" . '# msh2her.pl #');
|
|
466
|
print fic_her ("\n" . '# transformation d\'un maillage genere par le programme gmsh #');
|
|
467
|
print fic_her ("\n" . '# en un maillage utilisable par Herezh++ #');
|
|
468
|
print fic_her ("\n" . '#############################################################################');
|
|
469
|
print fic_her ("\n" . '# licence GPL, gerard.rio@univ-ubs.fr #');
|
|
470
|
print fic_her ("\n" . '# http://www-lg2m.univ-ubs.fr/~rio #');
|
|
471
|
print fic_her ("\n" . '# version 1 #');
|
|
472
|
print fic_her ("\n" . '#############################################################################');
|
|
473
|
print fic_her ("\n\n\n");
|
|
474
|
my $nom_maillage = $fichier_her;
|
|
475
|
$nom_maillage =~ s/\.her//;
|
|
476
|
print fic_her ("\n nom_maillage ".$nom_maillage ."\n\n");
|
|
477
|
#------------------- ?criture des noeuds ---------------------
|
|
478
|
|
|
479
|
# ------ entete des noeuds --------
|
|
480
|
|
|
481
|
print fic_her ("\n" . ' noeuds ------------');
|
|
482
|
print fic_her ("\n $nb_noeud NOEUDS "); # ici ?criture du nombre de noeuds
|
|
483
|
print fic_her ("\n\n\n");
|
|
484
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
485
|
print fic_her ("\n" . ' #|NO DU| X | Y | Z |');
|
|
486
|
print fic_her ("\n" . ' #|NOEUD| | | |');
|
|
487
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
488
|
print fic_her ("\n");
|
|
489
|
|
|
490
|
# ------ la liste des coordonn?es des noeuds --------
|
|
491
|
for (my $k=0; $k < $nb_noeud; $k++)
|
|
492
|
{ my $enreg = @les_noeuds[$k];
|
|
493
|
@champ = split (/\s+/,$enreg); # le /s+/ permet de s?parer sur des espaces
|
|
494
|
print fic_her ("\n ". ($k+1) ." ". $champ[1] ." ". $champ[2] ." ". $champ[3] );
|
|
495
|
}
|
|
496
|
print fic_her ("\n\n\n");
|
|
497
|
|
|
498
|
# ------ liste de r?f?rences de noeuds -----------
|
|
499
|
print fic_her ("\n\n\n");
|
|
500
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
501
|
print fic_her ("\n" . ' # references de noeuds |');
|
|
502
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
503
|
print fic_her ("\n");
|
|
504
|
|
|
505
|
foreach my $refno(keys %ref_noeud)
|
|
506
|
{ print fic_her ( "\n ".$refno . " "); # le nom de la r?f?rence
|
|
507
|
my $compteur = 1;
|
|
508
|
foreach my $nbnoeu ( @{$ref_noeud{$refno}})
|
|
509
|
{ print fic_her ( $nbnoeu . " ");
|
|
510
|
$compteur++;
|
|
511
|
if ($compteur > 24)
|
|
512
|
{ print fic_her ("\n ");
|
|
513
|
$compteur = 1;
|
|
514
|
};
|
|
515
|
};
|
|
516
|
print fic_her ("\n ");
|
|
517
|
};
|
|
518
|
|
|
519
|
#------------------- fin ?criture des noeuds ---------------------
|
|
520
|
|
|
521
|
#-------------------- ?criture des ?l?ments --------------------
|
|
522
|
|
|
523
|
print fic_her ("\n\n\n");
|
|
524
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
525
|
print fic_her ("\n" . ' # les elements |');
|
|
526
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
527
|
|
|
528
|
# ------ entete des ?l?ments --------
|
|
529
|
|
|
530
|
# on compte les ?l?ments ? sortir
|
|
531
|
my $nb_elementASortir = 0;
|
|
532
|
for (my $j=0;$j<$taille_list_elem;$j++)
|
|
533
|
{ if ($number_type[$j] != 0)
|
|
534
|
{ $nb_elementASortir += $number_type[$j];};
|
|
535
|
};
|
|
536
|
|
|
537
|
|
|
538
|
print fic_her ("\n" . ' elements ------------');
|
|
539
|
print fic_her ("\n $nb_elementASortir ELEMENTS "); # ici ?criture du nombre de noeuds
|
|
540
|
print fic_her ("\n\n\n");
|
|
541
|
print fic_her ("\n" . ' #----------------------------------------------------------------------');
|
|
542
|
print fic_her ("\n" . ' #| NO | | |');
|
|
543
|
print fic_her ("\n" . ' #|ELTS | type element | Noeuds |');
|
|
544
|
print fic_her ("\n" . ' #----------------------------------------------------------------------');
|
|
545
|
print fic_her ("\n");
|
|
546
|
|
|
547
|
# ------ ?criture des ?l?ments ------
|
|
548
|
|
|
549
|
my $numero = 1;
|
|
550
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
551
|
{ if ($number_type[$j] != 0)
|
|
552
|
{ my $nb_el = $number_type[$j];
|
|
553
|
for (my $el = 0;$el < $nb_el;$el++)
|
|
554
|
{ my $nbtag = $liste_element[$j][$el][2];
|
|
555
|
# ?criture du num?ro de l'?l?ment puis du descriptif
|
|
556
|
print fic_her ("\n ". $numero ." ". $type_herezh_element[$j] ." ");
|
|
557
|
my $tyyp = $liste_element[$j][$el][1]; # le type de l'?l?ment
|
|
558
|
#print " tyyp= ".$tyyp."\n";
|
|
559
|
for (my $ia =0;$ia < $nbn_par_elem[$j]; $ia++)
|
|
560
|
{ # $ia = num?ro d'ordre du noeud au format gmsh
|
|
561
|
# $connex[$tyyp][$ia] = num?ro d'ordre du noeud au format herezh++
|
|
562
|
#print " ia= " . $ia ." connex= " . $connex[$tyyp][$ia]." ";
|
|
563
|
my $bb = $liste_element[$j][$el][2+ $nbtag + $connex[$tyyp][$ia] ]; # le numero herezh
|
|
564
|
print fic_her ( $bb . " ");
|
|
565
|
};
|
|
566
|
$numero++;
|
|
567
|
}
|
|
568
|
};
|
|
569
|
};
|
|
570
|
|
|
571
|
# ------- ?criture des r?f?rences d'?l?ments ---------
|
|
572
|
print fic_her ("\n\n\n");
|
|
573
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
574
|
print fic_her ("\n" . ' # references elements |');
|
|
575
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
576
|
print fic_her ("\n");
|
|
577
|
|
|
578
|
foreach my $refel(keys %ref_element)
|
|
579
|
{ print fic_her ( "\n ".$refel . " "); # le nom de la r?f?rence
|
|
580
|
my $compteur = 1;
|
|
581
|
foreach my $nbnelem ( @{$ref_element{$refel}})
|
|
582
|
{ print fic_her ( $nbnelem . " ");
|
|
583
|
$compteur++;
|
|
584
|
if ($compteur > 24)
|
|
585
|
{ print fic_her ("\n ");
|
|
586
|
$compteur = 1;
|
|
587
|
};
|
|
588
|
};
|
|
589
|
print fic_her ("\n ");
|
|
590
|
};
|
|
591
|
|
|
592
|
|
|
593
|
#------------------- fin ?criture des ?l?ments ---------------------
|
|
594
|
|
|
595
|
|
|
596
|
|
|
597
|
print fic_her ("\n\n\n");
|
|
598
|
close (fic_her); # fermeture du fichier de maillage .her
|
|
599
|
|
|
600
|
print ("\n" . '#############################################################################');
|
|
601
|
print ("\n" . '# msh2her.pl #');
|
|
602
|
print ("\n" . '# fin creation du fichier de maillage .her #');
|
|
603
|
print ("\n" . '#############################################################################'."\n\n");
|