611 lines
28 KiB
C++
Executable file
611 lines
28 KiB
C++
Executable file
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
#include "Deformees_Gmsh.h"
|
|
#include "CharUtil.h"
|
|
#include "ConstMath.h"
|
|
#include "Visualisation_Gmsh.h"
|
|
|
|
#include <iomanip>
|
|
|
|
// CONSTRUCTEURS :
|
|
// par defaut
|
|
Deformees_Gmsh::Deformees_Gmsh () :
|
|
OrdreVisu("..........................................deformee"
|
|
,"visualisation des deformee","de")
|
|
,isovaleurs_Gmsh(NULL)
|
|
,num_mail_incr(),noms_matiere(),choix_mail(NULL)
|
|
,noms_couleurs(),nom_deplace("deplace")
|
|
,nom_vitesse("vitesse"),nom_acceleration("acceleration")
|
|
,li_bornes(),li_nom_bornes(),avec_vitesse(0),avec_acceleration(0)
|
|
//,mailInitial(NULL),isovaleurs_Gmsh(NULL)
|
|
{mailInitial=NULL;isovaleurs_Gmsh=NULL;};
|
|
|
|
// constructeur de copie
|
|
Deformees_Gmsh::Deformees_Gmsh (const Deformees_Gmsh& ord) :
|
|
OrdreVisu(ord)
|
|
,isovaleurs_Gmsh(ord.isovaleurs_Gmsh)
|
|
,num_mail_incr(ord.num_mail_incr)
|
|
,noms_matiere(),choix_mail(ord.choix_mail)
|
|
,noms_couleurs(ord.noms_couleurs)
|
|
,li_bornes(ord.li_bornes),li_nom_bornes(ord.li_nom_bornes)
|
|
,nom_deplace(ord.nom_deplace)
|
|
,nom_vitesse(ord.nom_vitesse),nom_acceleration(ord.nom_acceleration)
|
|
,avec_vitesse(ord.avec_vitesse),avec_acceleration(ord.avec_acceleration)
|
|
// ,mailInitial(ord.mailInitial),isovaleurs_Gmsh(ord.isovaleurs_Gmsh)
|
|
{mailInitial=ord.mailInitial;
|
|
isovaleurs_Gmsh=ord.isovaleurs_Gmsh;
|
|
};
|
|
|
|
// DESTRUCTEUR :
|
|
Deformees_Gmsh::~Deformees_Gmsh ()
|
|
{};
|
|
|
|
// METHODES PUBLIQUES :
|
|
// execution de l'ordre
|
|
// tab_mail : donne les numéros de maillage concerné
|
|
// incre : numéro d'incrément qui en cours
|
|
// type_incre : indique si c'est le premier le dernier ou l'incrément courant a visualiser ou pas
|
|
// animation : indique si l'on est en animation ou pas
|
|
// unseul_incre : indique si oui ou non il y a un seul increment à visualiser
|
|
void Deformees_Gmsh::ExeOrdre(ParaGlob * ,const Tableau <int>& tab_mail,LesMaillages * lesMail,bool ,LesReferences*
|
|
,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*
|
|
,LesContacts*,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre type_incre,int incre
|
|
// ,LesContacts*,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre type_incre,int incre
|
|
,bool ,const map < string, const double * , std::less <string> >&
|
|
,const List_io < TypeQuelconque >& listeVecGlob)
|
|
{// visualisation du maillage pointé si actif
|
|
if (actif)
|
|
{
|
|
// dans le cas où c'est l'incrément 0, c'est-à-dire le maillage initial, on ne sort rien dans le cas
|
|
// de l'ancien format au niveau des déplacements sinon avec le nouveau format on sort la maillage initiale
|
|
if (type_incre == PREMIER_INCRE)
|
|
{if(!isovaleurs_Gmsh->Use_hold_gmsh_format())
|
|
// dans le cas du nouveau format, on sort au début du fichier : le maillage initiale: noeuds et éléments
|
|
// ensuite à chaque incrément on ne sortira que les vecteurs déplacements aux noeuds
|
|
{ ostream &sort = entreePrinc.Sort_resultat_Gmsh(nom_deplace);
|
|
mailInitial->sortie_maillage_initial(tab_mail,lesMail,sort);
|
|
if (avec_vitesse) // cas avec la vitesse
|
|
{ ostream &sort_vit = entreePrinc.Sort_resultat_Gmsh(nom_vitesse);
|
|
mailInitial->sortie_maillage_initial(tab_mail,lesMail,sort_vit);
|
|
};
|
|
if (avec_acceleration) // cas avec l'accélération
|
|
{ ostream &sort_acc = entreePrinc.Sort_resultat_Gmsh(nom_acceleration);
|
|
mailInitial->sortie_maillage_initial(tab_mail,lesMail,sort_acc);
|
|
};
|
|
};
|
|
};
|
|
|
|
if (incre != 0)
|
|
{ ostream &sort = entreePrinc.Sort_resultat_Gmsh(nom_deplace);
|
|
if (isovaleurs_Gmsh->Use_hold_gmsh_format())
|
|
{SortieDeformee_ancien_format(tab_mail,lesMail,sort,incre);}
|
|
else
|
|
{SortieDeformee(tab_mail,lesMail,sort,incre);
|
|
if (avec_vitesse) // cas avec la vitesse
|
|
{ ostream &sort_vit = entreePrinc.Sort_resultat_Gmsh(nom_vitesse);
|
|
SortieVitesse(tab_mail,lesMail,sort_vit,incre);
|
|
};
|
|
if (avec_acceleration) // cas avec l'accélération
|
|
{ ostream &sort_acc = entreePrinc.Sort_resultat_Gmsh(nom_acceleration);
|
|
SortieAcceleration(tab_mail,lesMail,sort_acc,incre);
|
|
};
|
|
};
|
|
}; //-- fin du if sur le premier incrément
|
|
}; //-- fin du if actif
|
|
};
|
|
|
|
// choix de l'ordre, cet méthode peut entraîner la demande d'informations
|
|
// supplémentaires si nécessaire. qui sont ensuite gérer par la classe elle même
|
|
void Deformees_Gmsh::ChoixOrdre()
|
|
{ // demande de précision
|
|
bool choix_valide = false;
|
|
cout << "\n ----> preparation de la visualisation des deformees"
|
|
<< "\n parametre par defaut ? : pas de limites d'alerte sur les deplacements ,";
|
|
// on regarde s'il y a des vitesses et accélération aux noeuds
|
|
// récup ddl aux noeuds possibles à visualiser
|
|
const Tableau <List_io < Ddl_enum_etendu > >& tabnoeud_type_ddl = isovaleurs_Gmsh->Tabnoeud_type_ddl();
|
|
int tail = tabnoeud_type_ddl.Taille();
|
|
List_io < Ddl_enum_etendu >::iterator il,ilfin;
|
|
bool existe_vitesse = false; bool existe_acceleration = false;
|
|
for (int i=1;i<=tail;i++)
|
|
{ilfin = tabnoeud_type_ddl(i).end(); il = tabnoeud_type_ddl(i).begin();
|
|
for (;il != ilfin; il++ )
|
|
{if ((*il).Enum() == V1)
|
|
{existe_vitesse = true;};
|
|
if ((*il).Enum() == GAMMA1)
|
|
{existe_acceleration = true;};
|
|
if (existe_vitesse && existe_acceleration)
|
|
break;
|
|
};
|
|
};
|
|
if (existe_vitesse) cout << "\n vitesse ";
|
|
if (existe_acceleration) cout << "et acceleration ";
|
|
|
|
cout << " (rep 'o') pour accepter ces parametres sinon autre ";
|
|
string rep;
|
|
cout << "\n reponse ? "; rep = lect_return_defaut(false,"o");
|
|
if (rep != "o")
|
|
{// cas d'un choix autre que standart
|
|
while (!choix_valide)
|
|
{try
|
|
{ int nb_choix = 3; // par défaut
|
|
cout << "\n (0) fin modif"
|
|
<< "\n (1) nouvelle definition de limites d'alerte? "
|
|
<< "\n (2) effacer une limites d'alerte existante ? "
|
|
<< "\n (3) ancien format gmsh (< ou = version 2.3.1) ? ";
|
|
if (existe_vitesse)
|
|
{ cout << "\n (4) vitesse ";nb_choix = 4;};
|
|
if (existe_acceleration)
|
|
{ cout << "\n (5) acceleration ";nb_choix = 5;};
|
|
cout << "\n \n reponse ? ";
|
|
rep = lect_return_defaut(false,"0");
|
|
if (rep == "fin_prog") Sortie(1);
|
|
// sinon
|
|
int num = ChangeEntier(rep);
|
|
if (num == 0) {choix_valide=true;}
|
|
else if ((num > 0)&&(num < nb_choix))
|
|
{ choix_valide=false;
|
|
switch (num)
|
|
{ case 1: // definition des limites d'alerte
|
|
{ cout << "\n donnez une borne inferieur "
|
|
<< "\n (rep un reel ou 'no' pour utiliser le minimum total des valeurs ";
|
|
string numinf;DeuxDoubles dd; string nom_bornes;
|
|
numinf= lect_chaine();
|
|
if (numinf == "no")
|
|
{dd.un= -ConstMath::trespetit;}
|
|
else
|
|
{dd.un=ChangeReel(numinf);};
|
|
if ( numinf == "no")
|
|
{ // il faut absolument donner une borne supérieur
|
|
cout << "\n donnez une borne superieur (rep un reel) ";
|
|
numinf= lect_chaine();
|
|
dd.deux=ChangeReel(numinf);
|
|
}
|
|
else
|
|
{cout << "\n donnez une borne superieur "
|
|
<< "\n (rep un reel ou 'no' pour utiliser le maximum total des valeurs ";
|
|
numinf= lect_chaine();
|
|
if (numinf == "no")
|
|
{dd.deux= ConstMath::tresgrand;}
|
|
else
|
|
{dd.deux=ChangeReel(numinf);};
|
|
};
|
|
// définition du nom
|
|
cout << "\n donnez le nom que vous voulez donner a ces limites: ";
|
|
numinf= lect_chaine();
|
|
// maintenant on valide
|
|
li_bornes.push_back(dd); li_nom_bornes.push_back(numinf);
|
|
break;
|
|
}
|
|
case 2: // "effacer une limites d'alerte existante")
|
|
{cout << "\n liste actuelle des alertes enregistrees ";
|
|
list <DeuxDoubles>::iterator idd_n,idd_fin=li_bornes.end();
|
|
list <string>::iterator ili,ili_fin=li_nom_bornes.end();
|
|
ili=li_nom_bornes.begin();int num=1;
|
|
for (idd_n=li_bornes.begin();idd_n!=idd_fin;idd_fin++,num++)
|
|
{ cout << "\n(" << num << ") " << *ili << (*idd_n).un << " " << (*idd_n).deux <<" ";};
|
|
cout << "\n donnez le numero d'alerte a supprimer ";
|
|
string num_choix;
|
|
num_choix= lect_chaine(); int num_c=ChangeEntier(num_choix);
|
|
if ((num_c >=1)&&(num_c<=num))
|
|
{ili=li_nom_bornes.begin();int num=1;
|
|
for (idd_n=li_bornes.begin();idd_n!=idd_fin;idd_fin++,num++)
|
|
if (num==num_c)
|
|
{li_nom_bornes.erase(ili_fin);li_bornes.erase(idd_n);};
|
|
};
|
|
break;
|
|
}
|
|
case 3: // avec les vitesses
|
|
{cout << "\n ajout de la vitesse en sortie ";
|
|
avec_vitesse = 1;
|
|
break;
|
|
}
|
|
case 4: // avec les accélérations
|
|
{cout << "\n ajout de l'accélération en sortie ";
|
|
avec_acceleration = 1;
|
|
break;
|
|
}
|
|
}; // fin du switch (num)
|
|
}
|
|
else { cout << "\n Erreur on attendait un entier entre 0 et "<< nb_choix << " !!, "
|
|
<< "\n redonnez une bonne valeur"
|
|
<< "\n ou taper fin_prog pour arreter le programme";
|
|
choix_valide=false;
|
|
};
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)// erreur de lecture
|
|
{ cout << "\n Erreur on attendait un des mots cles proposés !!, "
|
|
<< "\n redonnez une bonne valeur"
|
|
<< "\n ou taper fin_prog pour arreter le programme";
|
|
choix_valide=false;
|
|
};
|
|
}; //-- fin du while
|
|
}; //-- fin du if (rep != "o") du départ c'est-à-dire du cas non standart
|
|
// appel de la méthode de la classe mère
|
|
OrdreVisu::ChoixOrdre();
|
|
};
|
|
|
|
|
|
// lecture des paramètres de l'ordre dans un flux
|
|
void Deformees_Gmsh::Lecture_parametres_OrdreVisu(UtilLecture & entreePrinc)
|
|
{ // si dans le flot il existe l'identificateur adoc on lit sinon on passe
|
|
if (strstr(entreePrinc.tablcarCVisu,"debut_deformee")!=NULL)
|
|
{// sauvegarde des paramètres actuelles
|
|
list <DeuxDoubles> li_bornes_sauve = li_bornes; // min max des alertes
|
|
list <string> li_nom_bornes_sauve = li_nom_bornes; // nom des alertes
|
|
// essaie de lecture
|
|
try
|
|
{ string nom;
|
|
(*entreePrinc.entCVisu) >> nom ;
|
|
if (nom != "debut_deformee")
|
|
{ cout << "\n Erreur en lecture des parametres de deformee a partir d'un fichier .CVisu,"
|
|
<< " le premier enregistrement doit etre le mot clef: debut_deformee "
|
|
<< " on ne tiens pas compte des parametres fournies !! ";
|
|
}
|
|
else
|
|
{ // appel de l'ordre de la classe mère
|
|
OrdreVisu::Lect_para_OrdreVisu_general(entreePrinc);
|
|
|
|
while (strstr(entreePrinc.tablcarCVisu,"fin_deformee")==NULL)
|
|
{// lecture des alertes
|
|
if (strstr(entreePrinc.tablcarCVisu,"deb_list_alerte")!=NULL)
|
|
{ // lecture de la liste des alertes
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
// on efface éventuellement les listes actuelles s'il y a quelque chose à lire
|
|
if (strstr(entreePrinc.tablcarCVisu,"fin_list_alerte")==NULL)
|
|
{li_nom_bornes.erase(li_nom_bornes.begin(),li_nom_bornes.end());
|
|
li_bornes.erase(li_bornes.begin(),li_bornes.end());
|
|
// lecture des listes demandées
|
|
int compteur=0; // pour éviter une boucle infinie
|
|
DeuxDoubles dd_n; string nom_alerte,nom2;
|
|
while (compteur < 1000000)
|
|
{ (*entreePrinc.entCVisu) >> nom >> nom2 >> nom_alerte; compteur++;
|
|
if (nom != "fin_list_alerte")
|
|
{ dd_n.un=ChangeReel(nom); dd_n.deux=ChangeReel(nom2);
|
|
// on vérifie que le nom lu est acceptable
|
|
if (find(li_nom_bornes.begin(),li_nom_bornes.end(),nom_alerte) != li_nom_bornes.end())
|
|
{li_nom_bornes.push_back(nom_alerte);li_bornes.push_back(dd_n);}
|
|
else
|
|
cout << "\n lecture d'une alerte ( "<< nom << " ) errone ! on n'en tiens pas compte";
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
}
|
|
else break;
|
|
}
|
|
};
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
}; //-- on sort du cas où il y avait une liste d'alerte
|
|
// lecture des indicateurs pour la vitesse et l'accélération
|
|
if (strstr(entreePrinc.tablcarCVisu,"avec_vitesse=")!=NULL)
|
|
{ (*entreePrinc.entCVisu) >> nom >> avec_vitesse >> nom >> avec_acceleration;
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
};
|
|
|
|
} //-- on sort des paramètres de déformée
|
|
// on passe un enregistrement pour le prochain ordrevisu
|
|
entreePrinc.NouvelleDonneeCVisu();
|
|
}; // fin du cas d'une lecture de paramètre de dérivées
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)// erreur de lecture
|
|
{ cout << "\n Erreur en lecture des parametres de deformee a partir d'un fichier .CVisu,"
|
|
<< " on ne tiens pas compte des parametres fournies !! ";
|
|
// récup des infos sauvées
|
|
li_bornes = li_bornes_sauve; // min max des alertes
|
|
li_nom_bornes = li_nom_bornes_sauve; // nom des alertes
|
|
if (ParaGlob::NiveauImpression() >= 4)
|
|
cout << "\n Deformees_Gmsh::Lecture_parametres_OrdreVisu(..";
|
|
}
|
|
}
|
|
};
|
|
|
|
// écriture des paramètres de l'ordre dans un flux
|
|
void Deformees_Gmsh::Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc)
|
|
{ // récup du flot
|
|
ostream & sort = (*(entreePrinc.Sort_CommandeVisu()));
|
|
// on commente le fonctionnement
|
|
sort << "\n # ----------------------------- definition des parametres de deformee: ---------------- "
|
|
<< "\n debut_deformee # un mot cle de debut de liste";
|
|
// appel de l'ordre de la classe mère
|
|
OrdreVisu::Ecrit_para_OrdreVisu_general(entreePrinc);
|
|
// --- on sort l'entête des paramètres pour les alertes
|
|
sort << "\n # definition des alertes: deb_list_alerte "
|
|
<< "\n # un mot clef de debut "
|
|
<< "\n # puis deux nombres: un mini et un maxi, et un nom "
|
|
<< "\n # un mot clef de fin: fin_list_alerte ";
|
|
// puis la liste des alertes
|
|
sort << "\n deb_list_alerte ";
|
|
list <DeuxDoubles>::iterator idd_n,idd_fin=li_bornes.end();
|
|
list <string>::iterator ili,ili_fin=li_nom_bornes.end();
|
|
ili=li_nom_bornes.begin();int num=1;
|
|
for (idd_n=li_bornes.begin();idd_n!=idd_fin;idd_fin++,num++)
|
|
{ sort << "\n" << (*idd_n).un << " " << (*idd_n).deux << " " << *ili << " ";};
|
|
sort << "\n fin_list_alerte ";
|
|
// indicateurs la vitesse et l'accélération si dispo
|
|
sort << "\n avec_vitesse= " << avec_vitesse << " avec_acceleration= " << avec_acceleration
|
|
<< " # 1 ou 0 pour la sortie si disponible ";
|
|
// fin
|
|
sort << "\n fin_deformee " << " # un mot cle de fin \n";
|
|
};
|
|
|
|
// sortie de la déformée dans le cas de l'ancien format
|
|
void Deformees_Gmsh::SortieDeformee_ancien_format(const Tableau <int>& tab_mail,LesMaillages * lesMail
|
|
,ostream & sort,int incre)
|
|
{ // pour boucler sur les maillages
|
|
int nbmail = tab_mail.Taille();
|
|
sort << "\n//------------------- increment "<<incre<<" ----------------------------\n";
|
|
// ----- on commence par sortir les noeuds avec un identificateur, pour optimiser la taille fichier
|
|
isovaleurs_Gmsh->SortieDefCoordonnees_old_format(sort,incre,nbmail,tab_mail,lesMail);
|
|
|
|
// on sort l'entête
|
|
int numero = 0;
|
|
isovaleurs_Gmsh->EnteteView(sort,incre,nom_deplace,numero );
|
|
// récupération de l'instanceConstructTabScalVecTensGmsh
|
|
const Isovaleurs_Gmsh::ConstructTabScalVecTensGmsh& tabScalVecTensGmsh = isovaleurs_Gmsh->TabScalVecTensGmsh();
|
|
// ramène le tableau t_Egmsh
|
|
// t_Egmsh(im)(ie): donne pour le maillage im, et pour l'élément ie, le numéro gmsh de l'élément
|
|
const Tableau < Tableau < int > >& t_Egmsh = mailInitial->TabEgmsh();
|
|
// récup de la connection herezh->gmsh
|
|
// t_GmshHer(i)(j) : donne pour le noeud j de l'élément i de gmsh, le numéro d'herezh
|
|
const Tableau < Tableau < int > >& tGmshHer = Visualisation_Gmsh::Tab_GmshHer();
|
|
|
|
for (int im=1;im<=nbmail;im++)
|
|
{ int numMail=tab_mail(im);
|
|
int nbmaxelem = lesMail->Nombre_element(numMail);
|
|
int dcaN = mailInitial->DecalNumNoeud(numMail);
|
|
for (int numElem = 1; numElem <= nbmaxelem; numElem++)
|
|
{Element& elem = lesMail->Element_LesMaille(numMail,numElem); // récup de l'élément
|
|
Tableau<Noeud *>& t_n = elem.Tab_noeud();
|
|
int num_elem_gmsh = t_Egmsh(im)(numElem); // numéro de classement du type d'élément gmsh
|
|
// maintenant on sort en fonction de d'élément
|
|
//-- 1) le type
|
|
// ***** a complèter pour les éléments quadratiques incomplet et les autres non possibles *****
|
|
sort << "\n" << tabScalVecTensGmsh.vector_pourView(num_elem_gmsh)<< "(";
|
|
//-- 2) les coordonnées des noeuds
|
|
int nbNmax = t_n.Taille();
|
|
// dans le cas des éléments sfe, il faut utiliser uniquement les noeuds centraux
|
|
switch (elem.Id_interpolation())
|
|
{ case SFE3C : case SFE3 : case SFE2: case SFE1 :
|
|
case SFE3C_3D : case SFE3_3D : case SFE2_3D: case SFE1_3D :
|
|
nbNmax = 3 ; break;
|
|
case QSFE1 : case QSFE3:
|
|
nbNmax = 6 ; break;
|
|
default: break;
|
|
};
|
|
|
|
for (int ino=1;ino<=nbNmax;ino++) // ino = numéro gmsh // tous les coordonnées sauf le dernier noeud
|
|
{ //int num_N = t_n(ino)->Num_noeud()+dcaN;
|
|
int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
|
|
int num_N = t_n(num_her)->Num_noeud()+dcaN; // num global
|
|
isovaleurs_Gmsh->SortieUseUneCoordonnee(incre,sort,(ino == nbNmax),num_N);
|
|
};
|
|
//-- 3) les grandeurs
|
|
for (int ino=1;ino<=nbNmax;ino++) // sortie des grandeurs avec un traitement particulier pour la dernière
|
|
{ int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
|
|
Noeud& noe = *t_n(num_her); // pour simplifier
|
|
// Noeud& noe = *t_n(ino); // pour simplifier
|
|
// int num_noeud = ino + dcaN;
|
|
const Coordonnee& dep = noe.Coord2() - noe.Coord0();
|
|
switch (ParaGlob::Dimension())
|
|
{ case 1: sort << dep(1) <<", 0. , 0. ";break;
|
|
case 2: sort << dep(1) <<", "<< dep(2) << ", 0. " ;break;
|
|
case 3: sort << dep(1) <<", "<< dep(2) << ", " << dep(3) ;break;
|
|
};
|
|
if (ino != nbNmax){sort << ", ";} else {sort << "};";};
|
|
};
|
|
}; //-- fin de la boucle sur les éléments
|
|
}; //-- fin de la boucle sur les maillages
|
|
// fin de la view
|
|
sort << "\n }; ";
|
|
// et on vide le buffer de sortie
|
|
sort << endl;
|
|
};
|
|
|
|
// sortie de la déformée dans le cas du nouveau format
|
|
void Deformees_Gmsh::SortieDeformee(const Tableau <int>& tab_mail,LesMaillages * lesMail
|
|
,ostream & sort,int incre)
|
|
{
|
|
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
double temps_actuel = ParaGlob::Variables_de_temps().TempsCourant();
|
|
// def de l'entete
|
|
int nb_composante=3;
|
|
int dim = ParaGlob::Dimension();
|
|
isovaleurs_Gmsh->EnteteNodeData(sort,incre,temps_actuel,nom_deplace,nb_composante);
|
|
// -- sortie des grandeurs
|
|
// on balaie les maillages
|
|
int nbmail = tab_mail.Taille();
|
|
Coordonnee A(dim); // une variable de travail
|
|
for (int im =1; im <= nbmail; im++)
|
|
{// on ne continue que si le maillage est à sortir
|
|
int numMail = tab_mail(im);
|
|
int decal_noe = mailInitial->DecalNumNoeud(numMail);
|
|
Tableau<Noeud *>& t_n = lesMail->Tab_noeud(numMail);
|
|
int nbmaxinoeud = t_n.Taille();
|
|
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
|
|
{ // recup du noeud
|
|
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
|
|
sort << "\n" << noe.Num_noeud()+decal_noe << " " ;//<< fixed ;
|
|
//-- le déplacement
|
|
if (noe.ExisteCoord2())
|
|
{ A=(noe.Coord2() - noe.Coord0());
|
|
A.Affiche(sort, ParaGlob::NbdigdoGR());
|
|
switch (dim) // on rajoute des 0 si la dimension n'est pas 3
|
|
{case 1: sort << " 0. ";
|
|
case 2: sort << " 0. ";
|
|
};
|
|
|
|
//debug cout << " noeud: " << noe.Num_noeud() <<" mailage:"<<noe.Num_Mail();
|
|
}
|
|
else // si la valeur n'existe pas on sort 0
|
|
{ sort << " 0. 0. 0. ";};
|
|
};
|
|
};
|
|
// fin de la view
|
|
sort << "\n$EndNodeData \n";
|
|
};
|
|
|
|
|
|
// idem pour le champ de vitesse dans le cas du nouveau format
|
|
void Deformees_Gmsh::SortieVitesse(const Tableau <int>& tab_mail,LesMaillages * lesMail
|
|
,ostream & sort,int incre)
|
|
{
|
|
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
double temps_actuel = ParaGlob::Variables_de_temps().TempsCourant();
|
|
// def de l'entete
|
|
int nb_composante=3;
|
|
int dim = ParaGlob::Dimension();
|
|
isovaleurs_Gmsh->EnteteNodeData(sort,incre,temps_actuel,nom_vitesse,nb_composante);
|
|
// -- sortie des grandeurs
|
|
// on balaie les maillages
|
|
int nbmail = tab_mail.Taille();
|
|
Coordonnee A(dim); // une variable de travail
|
|
for (int im =1; im <= nbmail; im++)
|
|
{// on ne continue que si le maillage est à sortir
|
|
int numMail = tab_mail(im);
|
|
int decal_noe = mailInitial->DecalNumNoeud(numMail);
|
|
Tableau<Noeud *>& t_n = lesMail->Tab_noeud(numMail);
|
|
int nbmaxinoeud = t_n.Taille();
|
|
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
|
|
{ // recup du noeud
|
|
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
|
|
sort << "\n" << noe.Num_noeud()+decal_noe << " " ;//<< fixed ;
|
|
//-- la vitesse
|
|
switch (dim)
|
|
{case 3: // on est en dim 3
|
|
{if (noe.Existe_ici(V3))
|
|
{ A(3) = noe.Ddl_noeud_tdt(V3).Valeur();
|
|
A(2) = noe.Ddl_noeud_tdt(V2).Valeur();
|
|
A(1) = noe.Ddl_noeud_tdt(V1).Valeur();
|
|
}
|
|
else {A.Zero();}
|
|
break;
|
|
}
|
|
case 2: // on est en dim 2
|
|
{if (noe.Existe_ici(V2))
|
|
{ A(3) = 0.;
|
|
A(2) = noe.Ddl_noeud_tdt(V2).Valeur();
|
|
A(1) = noe.Ddl_noeud_tdt(V1).Valeur();
|
|
}
|
|
else {A.Zero();}
|
|
break;
|
|
}
|
|
case 1: // on est en dim 1
|
|
{if (noe.Existe_ici(V2))
|
|
{ A(3) = 0.;
|
|
A(2) = 0.;
|
|
A(1) = noe.Ddl_noeud_tdt(V1).Valeur();
|
|
}
|
|
else {A.Zero();}
|
|
break;
|
|
}
|
|
default: break;
|
|
};
|
|
A.Affiche(sort, ParaGlob::NbdigdoGR());
|
|
};
|
|
};
|
|
// fin de la view
|
|
sort << "\n$EndNodeData \n";
|
|
};
|
|
|
|
|
|
// idem pour le champ d'accélération dans le cas du nouveau format
|
|
void Deformees_Gmsh::SortieAcceleration(const Tableau <int>& tab_mail,LesMaillages * lesMail
|
|
,ostream & sort,int incre)
|
|
{
|
|
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
double temps_actuel = ParaGlob::Variables_de_temps().TempsCourant();
|
|
// def de l'entete
|
|
int nb_composante=3;
|
|
int dim = ParaGlob::Dimension();
|
|
isovaleurs_Gmsh->EnteteNodeData(sort,incre,temps_actuel,nom_acceleration,nb_composante);
|
|
// -- sortie des grandeurs
|
|
// on balaie les maillages
|
|
int nbmail = tab_mail.Taille();
|
|
Coordonnee A(dim); // une variable de travail
|
|
for (int im =1; im <= nbmail; im++)
|
|
{// on ne continue que si le maillage est à sortir
|
|
int numMail = tab_mail(im);
|
|
int decal_noe = mailInitial->DecalNumNoeud(numMail);
|
|
Tableau<Noeud *>& t_n = lesMail->Tab_noeud(numMail);
|
|
int nbmaxinoeud = t_n.Taille();
|
|
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
|
|
{ // recup du noeud
|
|
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
|
|
sort << "\n" << noe.Num_noeud()+decal_noe << " " ;//<< fixed ;
|
|
//-- l'accélération
|
|
switch (dim)
|
|
{case 3: // on est en dim 3
|
|
{if (noe.Existe_ici(GAMMA3))
|
|
{ A(3) = noe.Ddl_noeud_tdt(GAMMA3).Valeur();
|
|
A(2) = noe.Ddl_noeud_tdt(GAMMA2).Valeur();
|
|
A(1) = noe.Ddl_noeud_tdt(GAMMA1).Valeur();
|
|
}
|
|
else {A.Zero();}
|
|
break;
|
|
}
|
|
case 2: // on est en dim 2
|
|
{if (noe.Existe_ici(GAMMA2))
|
|
{ A(3) = 0.;
|
|
A(2) = noe.Ddl_noeud_tdt(GAMMA2).Valeur();
|
|
A(1) = noe.Ddl_noeud_tdt(GAMMA1).Valeur();
|
|
}
|
|
else {A.Zero();}
|
|
break;
|
|
}
|
|
case 1: // on est en dim 1
|
|
{if (noe.Existe_ici(GAMMA2))
|
|
{ A(3) = 0.;
|
|
A(2) = 0.;
|
|
A(1) = noe.Ddl_noeud_tdt(GAMMA1).Valeur();
|
|
}
|
|
else {A.Zero();}
|
|
break;
|
|
}
|
|
default: break;
|
|
};
|
|
A.Affiche(sort, ParaGlob::NbdigdoGR());
|
|
};
|
|
};
|
|
// fin de la view
|
|
sort << "\n$EndNodeData \n";
|
|
};
|
|
|
|
|
|
|