|
#!/usr/bin/perl
|
|
use strict;
|
|
|
|
#########################################################################################
|
|
# script pour passer du format de maillage genere par abaqus au format lu par herezh++ #
|
|
# !!!!tous les cas ne sont pas int?gr? !!!!! #
|
|
#########################################################################################
|
|
|
|
my $nom;
|
|
if (@ARGV[0] eq '-h')
|
|
# si on n'a pas d'argument, on donne le mode d'emploi
|
|
{
|
|
print ("\n");
|
|
print ("\n" . '#############################################################################');
|
|
print ("\n" . '# #');
|
|
print ("\n" . '# ino2her.pl #');
|
|
print ("\n" . '# transformation d\'un maillage genere par le programme abaqus #');
|
|
print ("\n" . '# en un maillage utilisable par Herezh++ #');
|
|
print ("\n" . '#############################################################################');
|
|
print ("\n" . '# licence GPL, gerard.rio@univ-ubs.fr #');
|
|
print ("\n" . '# http://www-lg2m.univ-ubs.fr/~rio #');
|
|
print ("\n" . '# version 1 #');
|
|
print ("\n" . '#############################################################################');
|
|
print ("\n\n\n");
|
|
print ("\n usage: inp2her.pl ");
|
|
print ("\n ----> entree interactive des noms de fichier \n");
|
|
print ("\n usage: inp2her.pl <nom fichier.inp> <nom fichier.her> \n");
|
|
print ("\n ----> indication de la source et de la cible ");
|
|
print ("\n NB: les noms de fichier peuvent avoir ou non leur extension \n");
|
|
print ("\n usage: inp2her.pl -v ");
|
|
print ("\n ----> affiche la version du programme \n");
|
|
print ("\n usage: inp2her.pl -h ");
|
|
print ("\n ----> information sur l'utilisation \n");
|
|
print ("\n\n");
|
|
die ("arret normal");
|
|
}
|
|
elsif (@ARGV[0] eq '-v')
|
|
{ print ("\n inp2her.pl: version 1");
|
|
die ("arret normal");
|
|
};
|
|
|
|
#------------------- on s'occupe tout d'abord des fichiers --------------------
|
|
|
|
# tout d'abord on r?cup?re le nom du fichier ? traiter
|
|
my $nombase;
|
|
if (@ARGV[0])
|
|
# si on a un argument, c'est le nom du fichier
|
|
{ $nombase = @ARGV[0];}
|
|
else
|
|
# sinon on demande interactivement le nom du fichier
|
|
{ print ("\n nom du fichier ? ");
|
|
$nombase = <STDIN>; chomp($nombase); # on supprime le retour ? la ligne
|
|
};
|
|
|
|
# on supprime l'extension .inp si elle existe
|
|
$nombase =~ s/\.msh//;
|
|
|
|
# on ouvre le fichier msh en lecture tout d'abord, il doit donc exister
|
|
my $fichier_inp = $nombase . '.inp';
|
|
open (fic_inp,$fichier_inp) || die (" \n erreur en ouverture du fichier " . $fichier_inp . " \n");
|
|
|
|
# on ouvre le fichier .her en ?criture, on ?crase donc le fichier existant
|
|
my $fichier_her;
|
|
if (@ARGV[1])
|
|
# si on a un argument 2, c'est le nom du fichier de sortie
|
|
{ $fichier_her = @ARGV[1];}
|
|
else
|
|
# sinon on construit le nom du fichier
|
|
{$fichier_her = $nombase . '.her';
|
|
# on regarde s'il existe d?j?
|
|
foreach (<*.her>)
|
|
{ if ($_ eq $fichier_her)
|
|
{ print ("\n le fichier " . $fichier_her . " existe deja ! ");
|
|
print ("\n voulez-vous l\' ecraser ? (0 ou N ) ");
|
|
my $rep = <STDIN>; chomp($rep); $rep=lc($rep); # lc passage en minuscule
|
|
if ($rep eq 'n')
|
|
{print ("\n nom du fichier de sortie ? ");
|
|
$fichier_her = <STDIN>; chomp($fichier_her);
|
|
};
|
|
};
|
|
}; # fin du foreach
|
|
};
|
|
# on supprime l'extension .her si elle existe
|
|
$fichier_her =~ s/\.her//;
|
|
# et on la rajoute
|
|
$fichier_her .= '.her';
|
|
|
|
# maintenant on tente l'ouverture de fichier
|
|
open (fic_her,">$fichier_her") || die (" \n erreur en ouverture du fichier " . $fichier_her . " \n");
|
|
|
|
#------------------------ fin des ouvertures de fichiers ---------------------
|
|
|
|
# et ? l'?cran
|
|
print ("\n");
|
|
print ("\n" . '#############################################################################');
|
|
print ("\n" . '# #');
|
|
print ("\n" . '# inp2her.pl #');
|
|
print ("\n" . '# transformation d\'un maillage genere par le programme abaqus #');
|
|
print ("\n" . '# en un maillage utilisable par Herezh++ #');
|
|
print ("\n" . '#############################################################################');
|
|
print ("\n" . '# licence GPL, gerard.rio@univ-ubs.fr #');
|
|
print ("\n" . '# http://www-lg2m.univ-ubs.fr/~rio #');
|
|
print ("\n" . '# version 1 #');
|
|
print ("\n" . '#############################################################################');
|
|
print ("\n\n\n");
|
|
|
|
|
|
#------------------- fin ?criture de l'entete ? l'?cran -----------------
|
|
|
|
#------------------ lecture des tag qui vont servir pour fabriquer les r?f?rences -------------
|
|
print ("\n lecture des tags (preparation a la creation des references) ");
|
|
# on lit dans les lignes jusqu'au mot cl? $PhysicalNames
|
|
my $ligne;my @champ;
|
|
while (<fic_inp>)
|
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
# on lit dans le fichier jusqu'au mot cl? $PhysicalNames
|
|
if ( $champ[0] eq '$PhysicalNames' )
|
|
{last;}; # on a trouv? le premier enreg,
|
|
};
|
|
|
|
|
|
# --- on lit les tag
|
|
$ligne = <fic_inp>; chomp($ligne);
|
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
print (" nombre total de references lus : " . $champ[0] );
|
|
my $nb_reference = $champ[0] ;
|
|
|
|
# --- on lit chaque ligne de reference que l'on recopie dans un tableau jusqu'au mot cl? $EndPhysicalNames
|
|
my %les_references = () ; # d?claration de la table des reference
|
|
while (<fic_inp>)
|
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
# on lit dans le fichier jusqu'au mot cl? $EndPhysicalNames
|
|
if ( $champ[0] eq '$EndPhysicalNames' )
|
|
{last;}; # on a trouv? le mot cle de fin de reference,
|
|
# ce n'est pas le mot cl?, donc on enregistre la reference
|
|
$champ[1] =~ s/\"+//g; # on retire les guillemets ?ventuelles
|
|
$les_references{"$champ[0]"}= "$champ[1]";
|
|
};
|
|
print "\n les references ";
|
|
while ( (my $cle, my $valeur) = each %les_references)
|
|
{ print "\n ".$cle . ' => ' .$valeur;};
|
|
|
|
#------------------ fin de la lecture des tag qui vont servir pour fabriquer les r?f?rences -------------
|
|
|
|
|
|
|
|
# ++++++++++++++++++++++ lecture des coordonn?es des noeuds ++++++++++++++++++++++++++
|
|
print ("\n lecture des coordonnees des noeuds ");
|
|
# on lit dans les lignes jusqu'au mot cl? *NODE
|
|
my $ligne;my @champ;
|
|
while (<fic_inp>)
|
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
# on lit dans le fichier jusqu'au mot cl? $Nodes
|
|
if ( $champ[0] eq '$Nodes' )
|
|
{last;}; # on a trouv? le premier enreg,
|
|
};
|
|
|
|
# --- on lit le nombre de noeud
|
|
$ligne = <fic_inp>; chomp($ligne);
|
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
print (" nombre total de noeuds lus : " . $champ[0] );
|
|
my $nb_noeud = $champ[0] ;
|
|
|
|
#--- on pr?pare la def du nombre de noeud
|
|
my $nb_noeud = 0;
|
|
|
|
# --- on lit chaque ligne de coordonn?e que l'on recopie dans un tableau jusqu'au mot cl? $EndNodes
|
|
my @les_noeuds = () ; # d?claration du tableau des coordonn?es des noeuds
|
|
while (<fic_inp>)
|
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
# on lit dans le fichier jusqu'au mot cl? *NSET
|
|
if ( $champ[0] eq '*NSET' )
|
|
{last;}; # on a trouv? le premier enreg,
|
|
# ce n'est pas le mot cl?, donc on enregistre la ligne
|
|
push @les_noeuds, $ligne; # sauvegarde des coordonn?es et du num?ro initial du noeud
|
|
};
|
|
|
|
# ++++++++++++++++++++++ fin de lecture des coordonnees noeuds ++++++++++++++++++++++++++++++++++++
|
|
|
|
#-------- def de tableaux de conversion entre les num?rotations gmsh et celles d'herezh++ ----------
|
|
|
|
# d?finition des types d'?l?ments
|
|
|
|
my @type_element = ( 'rien pour le numero 0', # '0'
|
|
'segment lineaire a 2 noeuds' , # '1'
|
|
'triangle lineaire a 3 noeuds' , # '2'
|
|
'quadrangle bilineaire a 4 noeuds' , # '3'
|
|
'tetrahedre lineaire a 4 noeuds' , # '4'
|
|
'hexahedre trilineaire a 8 noeuds' , # '5'
|
|
'pentaedre bilineaire a 6 noeuds' , # '6'
|
|
'pyramide a 5 noeuds' , # '7'
|
|
'segment quadratique a 3 noeuds' , # '8'
|
|
'triangle quadratique a 6 noeuds' , # '9'
|
|
'quadrangle quadratique complet a 9 noeuds' , #'10'
|
|
'tetraedre quadratique a 10 noeuds' , #'11'
|
|
'hexaedre quadratique complet a 27 noeuds' , #'12'
|
|
'pentaedre quadratique complet a 18 noeuds' , #'13'
|
|
'pyramide quadratique a 14 noeuds' , #'14'
|
|
' point a 1 noeud ' , #'15'
|
|
'quadrangle quadratique incomplet a 8 noeuds' , #'16'
|
|
'hexaedre quadratique incomplet a 20 noeuds' , #'17'
|
|
'pentaedre quadratique incomplet a 15 noeuds' , #'18'
|
|
'pyramide quadratique incomplete a 13 noeuds' #'19'
|
|
);
|
|
|
|
my @type_herezh_element = ( 'rien pour le numero 0', # '0'
|
|
' POUT BIE1 ' , # '1'
|
|
' TRIANGLE LINEAIRE ' , # '2'
|
|
' QUADRANGLE LINEAIRE ' , # '3'
|
|
' TETRAEDRE LINEAIRE ' , # '4'
|
|
' HEXAEDRE LINEAIRE ' , # '5'
|
|
' PENTAEDRE LINEAIRE ' , # '6'
|
|
' PYRAMIDE LINEAIRE ' , # '7'
|
|
' POUT QUADRATIQUE ' , # '8'
|
|
' TRIANGLE QUADRACOMPL ' , # '9'
|
|
' QUADRANGLE QUADRACOMPL ' , #'10'
|
|
' TETRAEDRE QUADRATIQUE ' , #'11'
|
|
' HEXAEDRE QUADRACOMPL ' , #'12'
|
|
' PENTAEDRE QUADRACOMPL ' , #'13'
|
|
' PYRAMIDE QUADRACOMPL ' , #'14'
|
|
' POINT LINEAIRE ' , #'15'
|
|
' QUADRANGLE QUADRATIQUE ' , #'16'
|
|
' HEXAEDRE QUADRATIQUE ' , #'17'
|
|
' PENTAEDRE QUADRATIQUE ' , #'18'
|
|
' PYRAMIDE QUADRATIQUE ' #'19'
|
|
);
|
|
my @nbn_par_elem;
|
|
$nbn_par_elem[0]=0; $nbn_par_elem[1]=2; $nbn_par_elem[2]=3; $nbn_par_elem[3]=4;
|
|
$nbn_par_elem[4]=4; $nbn_par_elem[5]=8; $nbn_par_elem[6]=6; $nbn_par_elem[7]=5;
|
|
$nbn_par_elem[8]=3; $nbn_par_elem[9]=6; $nbn_par_elem[10]=9; $nbn_par_elem[11]=10;
|
|
$nbn_par_elem[12]=27; $nbn_par_elem[13]=18; $nbn_par_elem[14]=14; $nbn_par_elem[15]=1;
|
|
$nbn_par_elem[16]=8; $nbn_par_elem[17]=20; $nbn_par_elem[18]=15; $nbn_par_elem[19]=13;
|
|
|
|
# $connex[i][j] donne pour l'element i, le num de gmsh pour le num?ro j d'herezh
|
|
|
|
my @connex = ( [], # le premier avec rien, pour que la num?rotation commence ? 1
|
|
[1,2], # 1: ' POUT BIE1 ' ,
|
|
[1,2,3], # 2: ' TRIANGLE LINEAIRE ' ,
|
|
[1,2,3,4], # 3: ' QUADRANGLE LINEAIRE ' ,
|
|
[1,2,3,4], # 4: ' TETRAEDRE LINEAIRE ' ,
|
|
[1,2,2,3,4,5,6,7,8], # 5: ' HEXAEDRE LINEAIRE ' ,
|
|
[1,2,3,4,5,6], # 6: ' PENTAEDRE LINEAIRE ' ,
|
|
[1,2,3,4,5], # 7: ' PYRAMIDE LINEAIRE ' ,
|
|
[1,3,2], # 8: ' POUT QUADRATIQUE ' ,
|
|
[1,2,3,4,5,6], # 9: ' TRIANGLE QUADRACOMPL ' ,
|
|
[1,2,3,4,5,6,7,8,9], # 10: ' QUADRANGLE QUADRACOMPL ' ,
|
|
[1,2,3,4,5,6,7,8,9,10], # 11: ' TETRAEDRE QUADRATIQUE ' ,
|
|
[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 ' ,
|
|
# [1,2,3,4,5,6,7,8, 9,10,11,12,13,14,15,16,17,18,] uniquement pour voir les num?ros
|
|
[1,2,3,4,5,6,7,10,8,9, 11,12,13,15,14,16,18,17], # 13:' PENTAEDRE QUADRACOMPL ' ,
|
|
[1,2,3,4,5,6,7,8,9,10,11,12,13,14], # 14:' PYRAMIDE QUADRACOMPL ' ,
|
|
[1], # 15: ' POINT LINEAIRE ' ,
|
|
[1,2,3,4,5,6,7,8], # 16: ' QUADRANGLE QUADRATIQUE ' ,
|
|
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20], # 17: ' HEXAEDRE QUADRATIQUE ' ,
|
|
[1,2,3,4,5,6,7,10,8,9, 11,12,13,15,14], # 18:' PENTAEDRE QUADRATIQUE ' ,
|
|
[1,2,3,4,5,6,7,8,9,10,11,12,13], # 19: ' PYRAMIDE QUADRATIQUE '
|
|
);
|
|
|
|
#-------- fin def de tableaux de conversion entre les num?rotations gmsh et celles d'herezh++ ----------
|
|
|
|
|
|
# ++++++++++++++++++++++ lecture des ?l?ments +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
print ("\n lecture des elements ");
|
|
|
|
while (<fic_inp>)
|
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
# on lit dans le fichier jusqu'au mot cl? $Elements
|
|
if ( $champ[0] eq '$Elements' )
|
|
{last;}; # on a trouv? le premier enreg,
|
|
};
|
|
|
|
# ----- on lit le nombre d'?l?ments
|
|
$ligne = <fic_inp>; chomp($ligne);
|
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
print (" nombre total d'elements lus : " . $champ[0] );
|
|
my $nb_element = $champ[0] ;
|
|
|
|
|
|
# --- on lit chaque ligne que l'on recopie dans des tableaux jusqu'au mot cl? $EndElements
|
|
|
|
my @liste_element = (); # ce sera un tableau multidimentionel
|
|
# chaque ?l?ment de @liste_element est une liste d'?l?ments d'un m^eme type
|
|
# $liste_element[i] = la liste des ?l?ments de type i
|
|
# $liste_element[i][j] un ?l?ment = une liste d'entiers donc un tableau
|
|
# $liste_element [i][j][k] = un scalaire (entier) ouf !!
|
|
|
|
my @number_type = (); # les nombres d'?l?ment de chaque type
|
|
|
|
while (<fic_inp>)
|
|
{ $ligne = $_; chomp($ligne); # sauvegarde de la ligne
|
|
@champ = split (/\s+/,$ligne); # le /s+/ permet de s?parer sur des espaces
|
|
# on lit dans le fichier jusqu'au mot cl? $EndElements
|
|
if ( $champ[0] eq '$EndElements' )
|
|
{last;}; # on a trouv? le premier enreg,
|
|
# traitement et enregistrement
|
|
push @{$liste_element[$champ[1]]}, [@champ ]; # tableau multidimentionnel, syntaxe particuli?re
|
|
#if ( $champ[1] == 15)
|
|
# {print "\n trouve " . @champ; print " ligne = " . $ligne;
|
|
# print ",,, " .$champ[0]." ".$champ[1]." ".$champ[2]." ".$champ[3]." ".$champ[4]." ".$champ[5]." ";};
|
|
$number_type[$champ[1]]++;
|
|
};
|
|
|
|
|
|
# test d?bug
|
|
print "\n essai= " . $liste_element[15][1][3] ;
|
|
#print "\n une tranche
|
|
|
|
# on recherche le nombre d'?l?ment diff?rent
|
|
my $nb_type_elem = 0;
|
|
my $taille_list_elem = $#liste_element;
|
|
#print "\n number_type = " . @number_type;
|
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
{ if ($number_type[$j] != 0)
|
|
{ print "\n nombre d'elements du type ".$type_element[$j] ." = " . $number_type[$j] ;
|
|
$nb_type_elem++;
|
|
};
|
|
};
|
|
|
|
print "\n nombre initial d'elements differents " . $nb_type_elem ;
|
|
|
|
# maintenant on demande si l'on veut tous les ?l?ments ou certain uniquement
|
|
|
|
my @number_type_initial = @number_type; # sauvegarde pour le traitement des r?f?rences
|
|
print "\n\n === choix d'elements: voulez-vous ? ";
|
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
{ if ($number_type[$j] != 0)
|
|
{ print "\n conserver les element du type ".$type_element[$j] ." (rep o ou n) " ;
|
|
my $rep = <STDIN>; chomp($rep); $rep=lc($rep); # lc passage en minuscule
|
|
if ($rep eq 'o')
|
|
{print (' ===> ok, on conserve les elements '.$type_element[$j] . "\n");}
|
|
else
|
|
{print (' *** on supprime les elements '.$type_element[$j] .'*** '. "\n");
|
|
$number_type[$j] = 0;
|
|
}
|
|
};
|
|
};
|
|
|
|
# ++++++++++++++++++++++ fin lecture des ?l?ments ++++++++++++++++++++++++++
|
|
|
|
# ++++++++++++++++++++++ cr?ation des r?f?rences ++++++++++++++++++++++++++++++
|
|
|
|
# les r?f?rences de noeuds se trouvent par l'interm?diaire des ?l?ments "points"
|
|
# on passe donc en revue ces ?l?ments
|
|
my %ref_noeud; # def de conteneur des r?f?rences de noeuds
|
|
my %ref_element; # def du conteneur des r?f?rences d'?l?ments
|
|
#print "\n taille de la liste d'elem = " . $taille_list_elem;
|
|
my $numero = 1;
|
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
{ #print "\n taille des elem = " . $number_type[$j] ;
|
|
if ($number_type[$j] != 0)
|
|
{ my $nb_el = $number_type_initial[$j];
|
|
#print "\n nb_el= ".$nb_el;
|
|
for (my $el = 0;$el < $nb_el;$el++)
|
|
{
|
|
# ------- cas des r?f?rences de noeuds -----
|
|
|
|
if ($liste_element[$j][$el][1] == 15) # 15 c'est le type point
|
|
{ # on balaie les tag pour ajouter
|
|
my $nbtag = $liste_element[$j][$el][2]; # r?cup du nombre de tag
|
|
for (my $ic = 0; $ic < $nbtag; $ic++)
|
|
{ my $indic_ref = $liste_element[$j][$el][3+$ic]; # l'indicateur de la r?f?rence
|
|
#print "\n indicateur de la reference : ".$indic_ref;
|
|
my $nbnoe = $liste_element[$j][$el][3+ $nbtag]; # le num?ro du noeud
|
|
# $les_references{"$indic_ref"} = le nom de la r?f?rence, si ce n'est pas directement le nombre
|
|
my $nom = $les_references{"$indic_ref"};
|
|
#print "\n l equivalent d'indicateur de ref ".$nom;
|
|
if ($nom ne undef)
|
|
{ # cas ou le nom de la r?f?rence existe
|
|
if ( $ref_noeud{'N_' . $nom} == undef)
|
|
# si la r?f?rence n'est pas d?finie on la d?finie
|
|
{ my @tab = ($nbnoe);
|
|
#print "\n la cle = " . 'N_' . $nom;
|
|
$ref_noeud{'N_' . $nom} = [@tab]; # on sauvegarde le tableau
|
|
}
|
|
else
|
|
{ #print "\n la cle = " . 'N_' . $nom;
|
|
push @{$ref_noeud{'N_' . $nom}}, $nbnoe;
|
|
};
|
|
}
|
|
else
|
|
{ # cas ou le nom de la r?f?rence n'existe pas, on utilise directement le nombre
|
|
if ( $ref_noeud{'N_' ."$indic_ref"} == undef)
|
|
# si la r?f?rence n'est pas d?finie on la d?finie
|
|
{ my @tab = ($nbnoe);
|
|
$ref_noeud{'N_' ."$indic_ref"} = [@tab]; # on sauvegarde le tableau
|
|
}
|
|
else
|
|
{ push @{$ref_noeud{'N_' ."$indic_ref"}}, $nbnoe;
|
|
};
|
|
};
|
|
}
|
|
}
|
|
|
|
else # diff de 15 donc ?l?ments normal
|
|
# ------- cas des r?f?rences d'?l?ments -----
|
|
{ # on balaie les tag pour ajouter
|
|
my $nbtag = $liste_element[$j][$el][2]; # r?cup du nombre de tag
|
|
my %tag_deja_traite;
|
|
for (my $ic = 0; $ic < $nbtag; $ic++)
|
|
{ my $indic_ref = $liste_element[$j][$el][3+$ic]; # l'indicateur de la r?f?rence
|
|
# dans le cas o? il y a un nom de r?f?rence, l'indicateur de r?f?rence est doubl?
|
|
# ce qui n'est pas normal, on supprime ce doublement
|
|
if ($tag_deja_traite{"$indic_ref"} ne undef)
|
|
{next;}
|
|
$tag_deja_traite{"$indic_ref"} = '1'; # ne maniere ? pas avoir de undef
|
|
|
|
#print "\n indicateur de la reference : ".$indic_ref;
|
|
# $les_references{"$indic_ref"} = le nom de la r?f?rence, si ce n'est pas directement le nombre
|
|
my $nom = $les_references{"$indic_ref"};
|
|
#print "\n l equivalent d'indicateur de ref ".$nom;
|
|
if ($nom ne undef)
|
|
{ # cas ou le nom de la r?f?rence existe
|
|
if ( $ref_element{'E_' . $nom} == undef)
|
|
# si la r?f?rence n'est pas d?finie on la d?finie
|
|
{ my @tab = ($numero);
|
|
#print "\n la cle = " . 'E_' . $nom;
|
|
$ref_element{'E_' . $nom} = [@tab]; # on sauvegarde le tableau
|
|
}
|
|
else
|
|
{ #print "\n la cle = " . 'E_' . $nom;
|
|
push @{$ref_element{'E_' . $nom}}, $numero;
|
|
};
|
|
}
|
|
else
|
|
{ # cas ou le nom de la r?f?rence n'existe pas, on utilise directement le nombre
|
|
if ( $ref_element{'E_' ."$indic_ref"} == undef)
|
|
# si la r?f?rence n'est pas d?finie on la d?finie
|
|
{ my @tab = ($numero);
|
|
$ref_element{'E_' ."$indic_ref"} = [@tab]; # on sauvegarde le tableau
|
|
}
|
|
else
|
|
{ push @{$ref_element{'E_' ."$indic_ref"}}, $numero;
|
|
};
|
|
};
|
|
}
|
|
};
|
|
# on suit le cas de l'?criture finale des ?l?ments donc on n'incr?mente le num?ro
|
|
# d'?l?ment que s'il sera ?crit
|
|
if ($number_type[$j] != 0)
|
|
{ $numero++;};
|
|
};
|
|
};
|
|
};
|
|
|
|
# ++++++++++++++++++++++ fin cr?ation des r?f?rences ++++++++++++++++++++++++++
|
|
|
|
|
|
print ("\n ");
|
|
|
|
close (fic_inp);
|
|
|
|
|
|
#====================== ?criture du fichier .her ============================
|
|
|
|
#------------------- ?criture de l'entete du fichier .her ---------------------
|
|
|
|
print fic_her ("\n");
|
|
print fic_her ("\n" . '#############################################################################');
|
|
print fic_her ("\n" . '# #');
|
|
print fic_her ("\n" . '# msh2her.pl #');
|
|
print fic_her ("\n" . '# transformation d\'un maillage genere par le programme gmsh #');
|
|
print fic_her ("\n" . '# en un maillage utilisable par Herezh++ #');
|
|
print fic_her ("\n" . '#############################################################################');
|
|
print fic_her ("\n" . '# licence GPL, gerard.rio@univ-ubs.fr #');
|
|
print fic_her ("\n" . '# http://www-lg2m.univ-ubs.fr/~rio #');
|
|
print fic_her ("\n" . '# version 1 #');
|
|
print fic_her ("\n" . '#############################################################################');
|
|
print fic_her ("\n\n\n");
|
|
my $nom_maillage = $fichier_her;
|
|
$nom_maillage =~ s/\.her//;
|
|
print fic_her ("\n nom_maillage ".$nom_maillage ."\n\n");
|
|
#------------------- ?criture des noeuds ---------------------
|
|
|
|
# ------ entete des noeuds --------
|
|
|
|
print fic_her ("\n" . ' noeuds ------------');
|
|
print fic_her ("\n $nb_noeud NOEUDS "); # ici ?criture du nombre de noeuds
|
|
print fic_her ("\n\n\n");
|
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
print fic_her ("\n" . ' #|NO DU| X | Y | Z |');
|
|
print fic_her ("\n" . ' #|NOEUD| | | |');
|
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
print fic_her ("\n");
|
|
|
|
# ------ la liste des coordonn?es des noeuds --------
|
|
for (my $k=0; $k < $nb_noeud; $k++)
|
|
{ my $enreg = @les_noeuds[$k];
|
|
@champ = split (/\s+/,$enreg); # le /s+/ permet de s?parer sur des espaces
|
|
print fic_her ("\n ". ($k+1) ." ". $champ[1] ." ". $champ[2] ." ". $champ[3] );
|
|
}
|
|
print fic_her ("\n\n\n");
|
|
|
|
# ------ liste de r?f?rences de noeuds -----------
|
|
print fic_her ("\n\n\n");
|
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
print fic_her ("\n" . ' # references de noeuds |');
|
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
print fic_her ("\n");
|
|
|
|
foreach my $refno(keys %ref_noeud)
|
|
{ print fic_her ( "\n ".$refno . " "); # le nom de la r?f?rence
|
|
my $compteur = 1;
|
|
foreach my $nbnoeu ( @{$ref_noeud{$refno}})
|
|
{ print fic_her ( $nbnoeu . " ");
|
|
$compteur++;
|
|
if ($compteur > 24)
|
|
{ print fic_her ("\n ");
|
|
$compteur = 1;
|
|
};
|
|
};
|
|
print fic_her ("\n ");
|
|
};
|
|
|
|
#------------------- fin ?criture des noeuds ---------------------
|
|
|
|
#-------------------- ?criture des ?l?ments --------------------
|
|
|
|
print fic_her ("\n\n\n");
|
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
print fic_her ("\n" . ' # les elements |');
|
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
|
|
# ------ entete des ?l?ments --------
|
|
|
|
# on compte les ?l?ments ? sortir
|
|
my $nb_elementASortir = 0;
|
|
for (my $j=0;$j<$taille_list_elem;$j++)
|
|
{ if ($number_type[$j] != 0)
|
|
{ $nb_elementASortir += $number_type[$j];};
|
|
};
|
|
|
|
|
|
print fic_her ("\n" . ' elements ------------');
|
|
print fic_her ("\n $nb_elementASortir ELEMENTS "); # ici ?criture du nombre de noeuds
|
|
print fic_her ("\n\n\n");
|
|
print fic_her ("\n" . ' #----------------------------------------------------------------------');
|
|
print fic_her ("\n" . ' #| NO | | |');
|
|
print fic_her ("\n" . ' #|ELTS | type element | Noeuds |');
|
|
print fic_her ("\n" . ' #----------------------------------------------------------------------');
|
|
print fic_her ("\n");
|
|
|
|
# ------ ?criture des ?l?ments ------
|
|
|
|
my $numero = 1;
|
|
for (my $j=1;$j<=$taille_list_elem;$j++)
|
|
{ if ($number_type[$j] != 0)
|
|
{ my $nb_el = $number_type[$j];
|
|
for (my $el = 0;$el < $nb_el;$el++)
|
|
{ my $nbtag = $liste_element[$j][$el][2];
|
|
# ?criture du num?ro de l'?l?ment puis du descriptif
|
|
print fic_her ("\n ". $numero ." ". $type_herezh_element[$j] ." ");
|
|
my $tyyp = $liste_element[$j][$el][1]; # le type de l'?l?ment
|
|
#print " tyyp= ".$tyyp."\n";
|
|
for (my $ia =0;$ia < $nbn_par_elem[$j]; $ia++)
|
|
{ # $ia = num?ro d'ordre du noeud au format gmsh
|
|
# $connex[$tyyp][$ia] = num?ro d'ordre du noeud au format herezh++
|
|
#print " ia= " . $ia ." connex= " . $connex[$tyyp][$ia]." ";
|
|
my $bb = $liste_element[$j][$el][2+ $nbtag + $connex[$tyyp][$ia] ]; # le numero herezh
|
|
print fic_her ( $bb . " ");
|
|
};
|
|
$numero++;
|
|
}
|
|
};
|
|
};
|
|
|
|
# ------- ?criture des r?f?rences d'?l?ments ---------
|
|
print fic_her ("\n\n\n");
|
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
print fic_her ("\n" . ' # references elements |');
|
|
print fic_her ("\n" . ' #---------------------------------------------------------------');
|
|
print fic_her ("\n");
|
|
|
|
foreach my $refel(keys %ref_element)
|
|
{ print fic_her ( "\n ".$refel . " "); # le nom de la r?f?rence
|
|
my $compteur = 1;
|
|
foreach my $nbnelem ( @{$ref_element{$refel}})
|
|
{ print fic_her ( $nbnelem . " ");
|
|
$compteur++;
|
|
if ($compteur > 24)
|
|
{ print fic_her ("\n ");
|
|
$compteur = 1;
|
|
};
|
|
};
|
|
print fic_her ("\n ");
|
|
};
|
|
|
|
|
|
#------------------- fin ?criture des ?l?ments ---------------------
|
|
|
|
|
|
|
|
print fic_her ("\n\n\n");
|
|
close (fic_her); # fermeture du fichier de maillage .her
|
|
|
|
print ("\n" . '#############################################################################');
|
|
print ("\n" . '# msh2her.pl #');
|
|
print ("\n" . '# fin creation du fichier de maillage .her #');
|
|
print ("\n" . '#############################################################################'."\n\n");
|