Herezh_dev/Resultats/Resultats.cc
2023-05-03 17:23:49 +02:00

1459 lines
64 KiB
C++

// 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-2022 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 "Resultats.h"
#include "LectBlocMot.h"
#include "CharUtil.h"
#include "MathUtil.h"
#include <iomanip>
#include "ElemMeca.h"
#include "ElFrontiere.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"
#include "TypeConsTens.h"
// CONSTRUCTEURS :
// entreePrinc gere les entrees sorties
Resultats::Resultats(UtilLecture* ent) :
lesValVecPropres(),tabRegion(),pas_de_sortie(false)
{ entreePrinc = ent;
// parametres par defaut
copie = 1; // recopie de la lecture
};
// DESTRUCTEUR :
Resultats::~Resultats()
{ };
// METHODES PUBLIQUES :
// lecture des parametres de gestions de la sortie des resultats
void Resultats::Lecture(LesReferences* lesRef)
{try
{
if (ParaGlob::NiveauImpression() >= 4)
cout << " debut de la lecture de la sortie automatique de resultats " << endl;
MotCle motCle; // ref aux mots cle
{ // on se positionne sur un mot cle
while ( !motCle.SimotCle(entreePrinc->tablcar))
entreePrinc->NouvelleDonnee();
if (strstr(entreePrinc->tablcar,"resultats")!=NULL)
{ // on regarde si l'utilisateur éventuellement ne veut aucune sortie
if (strstr(entreePrinc->tablcar,"pas_de_sortie_finale_")!=NULL)
{pas_de_sortie = true;
entreePrinc->NouvelleDonnee();
if (strstr(entreePrinc->tablcar,"COPIE")!=NULL)
{string nom;*(entreePrinc->entree) >> nom;
if (nom == "COPIE")
{ *(entreePrinc->entree) >> copie;
entreePrinc->NouvelleDonnee();
}
}
else
{copie=0;};
}
else
{// on lit jusqu'au prochain mot cle
string nom;
entreePrinc->NouvelleDonnee();
// definition d'un tableau de sous mot cle permettant
// l'arret a chaque sous mot cle dans les procedures specifiques
// de lecture
Tableau<string> tsousMot(5);
tsousMot(1) = "COPIE";tsousMot(2) = "POINTS_INTEGRATION";
tsousMot(3) = "REACTIONS";tsousMot(4) = "DEGRE_DE_LIBERTE";
tsousMot(5) = "DEFORMEE";
// lecture
while ( !motCle.SimotCle(entreePrinc->tablcar))
{ *(entreePrinc->entree) >> nom;
if (nom == "COPIE")
{ *(entreePrinc->entree) >> copie;
entreePrinc->NouvelleDonnee();
}
else if (nom == "POINTS_INTEGRATION")
// cas des sorties au points d'integrations
{ReadPtInteg(lesRef,tsousMot);}
else if (nom == "REACTIONS")
{ReadReac(lesRef);}
else if (nom == "DEGRE_DE_LIBERTE")
{ReadNoeuds(lesRef);}
else if (nom == "DEFORMEE")
{ ReadDeformee(lesRef);
entreePrinc->NouvelleDonnee();
}
else
{ cout << "\n ** erreur en lecture des parametre de gestion des resultats"
<< " , nom lu : "<< nom;
entreePrinc->MessageBuffer
("** lecture des parametres de gestion des resultats **");
Affiche();
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
};
}; // fin du while
}; // fin du if sur pas de sortie finale
}
else
{ cout << "\n lecture des parametres de gestion des resultats : pas d'informations particulières";
cout << "\n **** d'où : utilisation de TOUS les parametres par defaut !! ";
cout << endl;
};
};// fin d'un bloc
if (ParaGlob::NiveauImpression() >= 4)
cout << " fin de la lecture de la sortie automatique de resultats " << endl;
}
catch (UtilLecture::ErrNouvelleDonnee erreur)
{ if ( erreur.lecture == 1)
{ // fin de fichier atteind, ce n'est peut-être pas une erreur,
cout << "\n --- fin de fichier atteind sans mot cle ??? --- "
<< " \n (return pour continuer !) "<< flush;
// -------- utilitaire pour lire une chaine de caractères:
// si retour chariot, retourne la valeur par défaut passée en paramètre
// sinon retourne le string lue au clavier
// gestion d'erreur si lecture non correcte
// si avec_ecriture = true: on écrit "--> valeur par defaut : n " val_defaut
lect_return_defaut(false,"");
return;
}
else
{cout << "\n ===============================================\n" ;
// on signale l'erreur
cout << "\n **** bizarre, erreur inconnue en lecture des parametres de sortie de 'resultats' ( fin du .info ) ";
throw (erreur);
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch ( ... )
{ // on signale l'erreur
cout << "\n **** bizarre, erreur inconnue en lecture des parametres de sortie de resultats ";
throw (UtilLecture::ErrNouvelleDonnee(-1));
};
};
// affichage des parametres de gestions de la sortie des resultats
void Resultats::Affiche() const
{ cout << "\n parametres de gestion des resultats \n";
cout << "recopie de la lecture ? = " << copie << '\n';
};
// def interactive des parametres de gestion de la sortie des resultats
void Resultats::Info_commande_Resultats()
{ofstream & sort = *(entreePrinc->Commande_pointInfo()); // pour simplifier
string rep = " ";
while (Minuscules(rep) != "f")
{ cout << "\n\n sortie standard ? (rep o) ";
cout << "\n infos fichiers speciaux (rep ?) ";
cout << "\n sorte fichiers speciaux (rep s) ";
cout << "\n fin (rep f) ";
rep = lect_return_defaut(false,"f");
if ((rep == "o") || (rep == "O") || (rep == "0"))
{ sort << "\n# ------------------------------------------------------------------------------------ "
<< "\n resultats pas_de_sortie_finale_ "
<< "\n COPIE 0 "
<< "\n#";
}
else if (rep == "?")
{ cout << "\n Il s'agit uniquement des sorties automatiques effectuees a la fin de l'execution "
<< "\n donc des infos sur l'etat final en fin de calcul "
<< "\n fichiers: "
<< "\n .res (grandeurs aux pti) ; _cab.isoe (tableau des contraintes)"
<< "\n .ddl (les ddl aux noeuds) ; .reac (les reactions due aux blocages divers)"
<< "\n .cont (les reactions de contact) ; _dpl.points (tableau des deplacements des noeuds)"
<< "\n L'eventail de choix est restreint, si l'on veut plus de choix il faut utiliser la sortie interactive "
<< "\n et construire un fichier .CVisu "
<< "\n ce qui est automatique: .ddl, .reac, _cab.isoe, .cont, _dpl.points "
<< "\n ce qui peut etre modifie sont les grandeurs pour le .res "
<< "\n on indique les ref d elements ou l'on veut les sorties, puis la liste des grandeurs ";
}
else if (rep == "s")
{ cout << "\n -- constitution de la liste des references ---";
// -- construction de la liste de ref
string rop = " ";
list <Deux_String> list_ref;
while (Minuscules(rop) != "f" )
{ cout << "\n non d'une ref existante -> (rep : nf) "
<< "\n effacer la liste a sortir -> (rep : ef) "
<< "\n la ref tout et un seul maillage(par defaut) -> (rep : to) "
<< "\n fin -> (rep : f) ";
rop = lect_return_defaut(false,"f");
if (rop == "nf")
{ string nom_ref;
cout << "\n nom de la reference ? ";nom_ref=lect_chaine();
string nom_mail; // par defaut
cout << "\n nom du maillage (ou _ si un seul maillage) ? "; nom_mail=lect_chaine();
list_ref.push_back(Deux_String(nom_mail,nom_ref));
}
else if (rop == "ef")
{ // on efface la liste des références d'éléments et la liste de pt d'integ associée
list_ref.clear();
}
else if (rop == "to")
{ list_ref.push_back(Deux_String("_","E_tout"));
};
// visualisation de la liste actuelle
if (list_ref.size() != 0)
{ list <Deux_String>::iterator ili,ilifin = list_ref.end();
cout << "\n liste actuelle de ref : ";
for (ili=list_ref.begin();ili != ilifin;ili++)
cout << "\n maillage: "<< (*ili).nom1 << " ref: "<< (*ili).nom2 <<" ";
cout << "\n ";
};
};
// -- construction de la liste des grandeurs à sortir
list <string> list_grandeurs;
rop = " ";
while (Minuscules(rop) != "f" )
{ Tableau<string> tsousMotref(9);
tsousMotref(1) = "Green-Lagrange";tsousMotref(2) = "Almansi";
tsousMotref(3) = "Cauchy_global";tsousMotref(4) = "Def_mixte_local";
tsousMotref(5) = "Sigma_mixte_local";tsousMotref(6) = "Sigma_principale";
tsousMotref(7) = "Def_principale";tsousMotref(8) = "Resultat_loi";
tsousMotref(9) = "logarithmique";
int pair=0;
for (int i=1;i<= 9; i++)
{if (pair == 0) {cout << "\n"<<tsousMotref(i);pair++;}
else {cout << " " << tsousMotref(i);pair = 0;};
};
cout << "\n";
cout << "\n non d'une grandeur -> (rep : gr) "
<< "\n effacer la liste a sortir -> (rep : ef) "
<< "\n toutes les grandeurs (par defaut) -> (rep : to) "
<< "\n fin -> (rep : f) ";
rop = lect_return_defaut(false,"f");
if (rop == "gr")
{ string nom_ref;
cout << "\n nom de la grandeurs ? ";nom_ref=lect_chaine();
// vérif que la grandeur existe
bool existe=false;
for (int i=1;i<=9;i++)
if (tsousMotref(i)==nom_ref)
{existe = true;break;}
if (existe)
{ list_grandeurs.push_back(nom_ref);}
else
{ cout << "\n erreur la grandeur (** "<< nom_ref << " **) donnee ne correspond pas a une grandeur acceptable ";};
}
else if (rop == "ef")
{ // on efface la liste des grandeurs
list_grandeurs.clear();
}
else if (rop == "to")
{ for (int i=1;i<= 9; i++)
list_grandeurs.push_back(tsousMotref(i));
};
// visualisation de la liste actuelle
if (list_grandeurs.size() != 0)
{ list <string>::iterator ili,ilifin = list_grandeurs.end();
cout << "\n liste actuelle de grandeurs : ";
for (ili=list_grandeurs.begin();ili != ilifin;ili++)
cout << (*ili) << " ";
cout << "\n ";
};
};
// -- on sort les infos
sort << "\n# ---------------- resultats sur des fichiers particuliers -----------";
sort << "\n resultats #----------- "
<< "\n COPIE 0 "
<< "\n ";
list <string>::iterator im,imfin= list_grandeurs.end();
list <Deux_String>::const_iterator il,ilfin=list_ref.end();
for (il=list_ref.begin();il != ilfin;il++)
{sort << "\nPOINTS_INTEGRATION ";
if ((*il).nom1 != "_")
{ sort << "nom_mail= "<<(*il).nom1 << " ";};
sort << (*il).nom2 << "\n";
for (im = list_grandeurs.begin();im != imfin;im++)
sort << (*im) << " ";
};
sort << "\n ";
};
};
sort << flush;
/*
sort << "\n# Il s'agit uniquement des sorties automatiques effectuees a la fin de l'execution" //
<< "\n# Le choix est limite, si l'on veut plus de choix il faut utiliser la sortie interactive " //
<< "\n# et construire un fichier .CVisu " //
<< "\n# ------------------------------------------------------------------------------------ "; //
sort << "\n resultats #-----------mot cle " //
<< "\n# (( si le mot cle resultats est absent : utilisation de tous les parametres par defauts )) "
<< "\n#------------------------------------puis par exemple----------------------------------- "
<< "\nCOPIE 0 # =0 par defaut, si = 1: il y a recopie a l'ecran de tout ce qui a ete lue jusqu'ici "
<< "\nPOINTS_INTEGRATION E_tout "
<< "\nGreen-Lagrange Almansi Cauchy_global Def_mixte_local Sigma_mixte_local"
<< "\n#................................................................................"
<< "\n# explication: POINTS_INTEGRATION signifie que l'on veut une sortie aux points d'integration "
<< "\n# E_tout est la reference pour laquelle on veut les infos "
<< "\n# puis on definit certaines grandeurs que l'on veut sortir aux points d'integrations "
<< "\n# qui sont a choisir entre: "
<< "\n# Green-Lagrange Almansi Cauchy_global Def_mixte_local Sigma_mixte_local Sigma_principale"
<< "\n# Def_principale Resultat_loi logarithmique "
<< "\n#................................................................................."
<< "\n# ********* dans le cas particulier ou l'on veut aucun resultat on indique au debut "
<< "\n# resultats pas_de_sortie_finale_ "
<< "\n#";*/
};
// sortie des resultats suivant les infos stockee durant la lecture du fichier d'entree
void Resultats::SortieInfo
(ParaGlob * paraGlob,LesMaillages* lesMail,LesReferences* lesRef,
LesCondLim * lesCondLim,LesContacts* lescontacts)
{ // sortie des frontières dans le cas ou le calcul a été demandé
if ((paraGlob->TypeCalcul_principal(INFORMATIONS)) &&
(paraGlob->SousTypeCalcul(frontieres)))
SortieFrontieres(lesMail);
else if (!pas_de_sortie)
{ // sortie des grandeurs duales aux points d'integration
// sous une forme texte lisible
PointsDintegration(lesMail,lesRef);
// sortie des contraintes aux éléments en texte peu lisible mais condensé
SortieElemenContrainte(lesMail,paraGlob);
// sortie des ddls et grandeurs aux noeuds
SortieNoeuds(lesMail,lesRef);
// sortie des reactions
SortieReactions(lesMail,lesRef,lesCondLim);
// sortie d'information concernant le contact
if (lescontacts != NULL)
// appel d'une routine specifique
SortieContacts(lescontacts);
// cas d'un calcul de flambement
if (paraGlob->TypeCalcul_principal(FLAMB_LINEAIRE))
SortieFlamb();
// sortie des deformees pour livan
SortieDeformee(lesMail,lesRef,paraGlob);
// dans le cas ou l'on a une remontée aux contraintes, sortie d'isovaleurs
// de contraintes.
// récup de la liste des sous types
list <EnumSousTypeCalcul> const & lis_sous = paraGlob->LesSousTypesDeCalcul();
list <EnumSousTypeCalcul>::const_iterator ik,ikfin; // iterators
ikfin = lis_sous.end();
for (ik= lis_sous.begin();ik!=ikfin;ik++)
if ( (Remonte_in(*ik)) && paraGlob->SousTypeCalcul(*ik))
SortieNoeudContaintes(lesMail,lesRef,paraGlob);
// dans le cas ou l'on a une remontée aux erreurs, sortie d'isovaleurs
// d'erreurs.
for (ik= lis_sous.begin();ik!=ikfin;ik++)
if (Erreur_in(*ik) && paraGlob->SousTypeCalcul(*ik))
{SortieNoeudErreur(lesMail,lesRef,paraGlob);
// idem mais aux éléments
SortieElemErreur(lesMail,lesRef,paraGlob);
}
// sortie des frontières dans le cas ou le calcul a été demandé
if ((paraGlob->TypeCalcul_principal(INFORMATIONS) ) &&
(paraGlob->SousTypeCalcul(frontieres)))
SortieFrontieres(lesMail);
};
// sortie de la deformee du maillage pour l'article
// tirer les commentaires !!!!!!!!
// DeformeeArticle(lesMail);
};
//----- lecture écriture base info -----
// lecture base info
void Resultats::Lect_result_base_info(ifstream& ent,const int cas)
{ if (cas == 1)
{ string toto;
// lecture de l'entête et vérification
ent >> toto ;
if (toto != "****Resultats")
Sortie(1);
ent >> pas_de_sortie ; // lecture de l'indication éventuelle de aucune sortie
// entrée des tableau des regions
// tout d'abord le nombre d'élément
int tabRegion_taille;
ent >> toto >> tabRegion_taille ;
// on boucle sur le nombre
BlocGen interne;
for (int i=1;i<= tabRegion_taille;i++)
{ ent >> interne; // lecture
// intégration dans la liste
tabRegion.push_back(interne);
}
// parametres de gestion
ent >> toto >> copie ;
}
};
// écriture base info
void Resultats::Ecri_result_base_info(ofstream& sort,const int cas)
{ if (cas == 1)
{ sort << "\n ****Resultats "<< pas_de_sortie <<" \n";
// sortie des tableau des regions
// tout d'abord le nombre d'élément et un identificateur
sort << "liste_region:_nb= " << tabRegion.size() << "\n";
// on balaie la liste
list <BlocDdlLim< BlocGen> >::const_iterator i;
for (i=tabRegion.begin() ; i != tabRegion.end(); i++)
sort << (*i) ;
sort << "\n";
// parametres de gestion
sort << "copie: " << copie << " ";
}
};
// =============================== fonctions privates ==============
// lecture concernant les sorties aux points d'integration
void Resultats::ReadPtInteg(LesReferences* lesRef,Tableau<string>& TsousMot)
{ // definition de la liste de mot specifique acceptable
Tableau<string> tsousMotref(9);
tsousMotref(1) = "Green-Lagrange";tsousMotref(2) = "Almansi";
tsousMotref(3) = "Cauchy_global";tsousMotref(4) = "Def_mixte_local";
tsousMotref(5) = "Sigma_mixte_local";tsousMotref(6) = "Sigma_principale";
tsousMotref(7) = "Def_principale";tsousMotref(8) = "Resultat_loi";
tsousMotref(9) = "logarithmique";
string message =
" *** lecture des conditions de sortie des variables duales au points d\'integration";
// lecture
// on commence par passer le mot cle
string nom;
LectBlocmot lectBlocmot;
BlocDdlLim< BlocGen> blocMot = lectBlocmot.Lecture
(*entreePrinc,*lesRef,message,tsousMotref,TsousMot);
// stockage
tabRegion.push_back(blocMot);
};
// Lectures concernant les sorties aux noeuds
void Resultats::ReadNoeuds(LesReferences* )
{
};
// lectures concernant les reactions
void Resultats::ReadReac(LesReferences* )
{
};
// lectures concernant les deformees
void Resultats::ReadDeformee(LesReferences* )
{
};
// sortie des grandeurs duales aux points d'integration
void Resultats::PointsDintegration(LesMaillages* lesMail,LesReferences* lesRef)
{ // ouverture du fichier de resultats
char nomm[132];
char*fileName = nomm;
strcpy(fileName,entreePrinc->RacineNom());
ofstream sort(strcat(fileName,".res"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier " << fileName
<< ", Resultats::PointsDintegration(etc..." << endl;
Sortie(1);
};
// cas ou la liste est vide, on sort toutes les informations
if (tabRegion.size() == 0)
{ for (int numMail=1;numMail<= lesMail->NbMaillage();numMail++)
for (int numElem=1; numElem<= lesMail->Nombre_element(numMail);numElem++)
{ // recup de l'element
Element & elem = lesMail->Element_LesMaille(numMail,numElem);
sort << "\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" ;
sort << "\n element " << numElem << " du maillage " << numMail;
sort << "\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" ;
Tableau <string> tab; // tableau vide
elem.AfficheVarDual(sort,tab);
}
}
// sinon on balaie la liste de reference d'element a sortir
list <BlocDdlLim< BlocGen> >::iterator ibloc; // def d'un iterator adoc
for (ibloc=tabRegion.begin(); ibloc != tabRegion.end(); ibloc++)
{ // recup de la reference correspondant au mot cle
const ReferenceNE & ref
= ((ReferenceNE &)lesRef->Trouve((*ibloc).NomRef(),(*ibloc).NomMaillage()));
if (ref.Indic() != 2)
// cas autre que des elements
{ cout << "\n sortie de resultats aux points d\'integration "
<< "autre que sur des elements pas d\'action implentee a ce sujet !!";
cout << "\nResultats::PointsDintegration(etc... " << endl;
Sortie(1);
}
else
{
// cas des elements
Tableau <string> tab;
if ((*ibloc).DimNom() > 1)
// cas ou des noms de variable duale sont specifies
{ tab.Change_taille((*ibloc).DimNom() -1);
for (int nbnom=2; nbnom<= (*ibloc).DimNom(); nbnom++)
tab (nbnom-1) = (*ibloc).Nom(nbnom);
}
for (int nn =1; nn<= ref.Taille();nn++)
{ // recup de l'element
Element & elem = lesMail->Element_LesMaille(ref.Nbmaille(),ref.Numero(nn));
sort << "\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" ;
sort << "\n element " << ref.Numero(nn) << " du maillage " << ref.Nbmaille();
sort << "\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" ;
elem.AfficheVarDual(sort,tab);
}
}
}
// on vide le buffer de sortie
sort << endl;
};
// sortie des ddls et grandeurs aux noeuds
void Resultats::SortieNoeuds(LesMaillages* lesMail,LesReferences* )
{ // ouverture du fichier de resultats
char nomm[132];
char*fileName = nomm;
strcpy(fileName,entreePrinc->RacineNom());
ofstream sort(strcat(fileName,".ddl"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier " << fileName
<< ", Resultats::SortieNoeuds(etc..." << endl;
Sortie(1);
};
// on balaie tous les noeuds de tous les maillages
int nbmaximaillage = lesMail->NbMaillage();
for (int numMail=1;numMail<= nbmaximaillage;numMail++)
{ int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
{ // recup du noeud
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
noe.Affiche(sort);
}
}
// on vide le buffer de sortie
sort << endl;
};
// sortie des reactions
void Resultats::SortieReactions
(LesMaillages* lesMail,LesReferences* ,LesCondLim * lesCondLim)
{ // ouverture du fichier de resultats
char nomm[132];
char*fileName = nomm;
strcpy(fileName,entreePrinc->RacineNom());
ofstream sort(strcat(fileName,".reac"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier " << fileName
<< ", Resultats::SortieNoeuds(etc..." << endl;
Sortie(1);
};
// affichage
lesCondLim->Affiche_reaction(sort,lesMail);
// on vide le buffer de sortie
sort << endl;
};
// sortie du contact
void Resultats::SortieContacts(LesContacts* lescontacts)
{ // ouverture du fichier de resultats
char nomm[132];
char*fileName = nomm;
strcpy(fileName,entreePrinc->RacineNom());
ofstream sort(strcat(fileName,".cont"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier " << fileName
<< ", Resultats::SortieNoeuds(etc..." << endl;
Sortie(1);
};
// affichage
sort << "#=====================================================\n";
sort << "# Reactions de contact \n";
sort << "#=====================================================\n";
lescontacts->Affiche(sort);
// on vide le buffer de sortie
sort << endl;
};
// sortie pour le flambement
void Resultats::SortieFlamb()
{ // ouverture du fichier de resultats
char nomm[132];
char*fileName = nomm;
strcpy(fileName,entreePrinc->RacineNom());
ofstream sort(strcat(fileName,".flamb"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier " << fileName
<< ", Resultats::SortieFlamb()" << endl;
Sortie(1);
};
// affichage
sort << "#=====================================================\n";
sort << "# cas d'un calcul de flambement \n";
sort << "#=====================================================\n";
lesValVecPropres.Affiche(sort);
// on vide le buffer de sortie
sort << endl;
};
// sortie des deformees
void Resultats::SortieDeformee(LesMaillages* lesMail,LesReferences*,ParaGlob * paraGlob )
{ // on veut sortir une deforme pour chaque maillage
int nbmaximaillage = lesMail->NbMaillage();
for (int numMail=1;numMail<= nbmaximaillage;numMail++)
{ // ouverture du fichier pour ecrire la deformee
char nomm[132];
char*fileName = nomm;
// transformation du nb de maillage en char*
string toto = ChangeEntierSTring(numMail );
char* cnbmaille = (char *) toto.c_str();
strcpy(fileName,entreePrinc->RacineNom());
ofstream sort(strcat(strcat(fileName,cnbmaille),"_dpl.points"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier " << fileName
<< ", Resultats::SortieDeformee(etc..." << endl;
Sortie(1);
}
// on balaie tous les noeuds du maillage
int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
sort << nbmaxinoeud << "\n ";
Coordonnee coor_zero(paraGlob->Dimension ()); // coordonnées nulles
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
{ // recup du noeud
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
if (noe.ExisteCoord1())
{ // ecriture de la difference de coordonnee entre 0 et t
sort << setw (16); (noe.Coord1() - noe.Coord0() ).Affiche(sort,16);
}
else
{ // cas où le noeud n'a pas bougé
// ecriture de la difference de coordonnee entre 0 et t
sort << setw (16); coor_zero.Affiche(sort,16);
}
// si l'on n'est pas en dimension 3 on complete avec des zeros
if (paraGlob->Dimension () == 2)
{ sort << setw (16) << 0 <<" ";
}
else if (paraGlob->Dimension () == 1)
{ sort << setw (16) << 0 <<" " << setw (16) << 0 <<" ";
}
sort << setw (16) << 0 << "\n ";
}
// on vide le buffer de sortie
sort << endl;
};
};
// dans le cas ou l'on a une remontée aux contraintes, sortie d'isovaleurs
// de contraintes.
void Resultats::SortieNoeudContaintes
(LesMaillages* lesMail,LesReferences* ,ParaGlob * paraGlob)
{ // on sort les contraintes aux noeuds dans le cas où a priori elles ont
// ete calculées
// récup de la liste des sous types
list <EnumSousTypeCalcul> const & lis_sous = paraGlob->LesSousTypesDeCalcul();
list <EnumSousTypeCalcul>::const_iterator ik,ikfin; // iterators
ikfin = lis_sous.end();
for (ik= lis_sous.begin();ik!=ikfin;ik++)
if ( (Remonte_in(*ik)) && paraGlob->SousTypeCalcul(*ik))
{
// on veut sortir des isovaleurs pour chaque maillage
int nbmaximaillage = lesMail->NbMaillage();
for (int numMail=1;numMail<= nbmaximaillage;numMail++)
{ // ouverture du fichier pour ecrire contraintes aux noeuds
char nomm[132];
char*fileName = nomm;
// transformation du nb de maillage en char*
string toto = ChangeEntierSTring(numMail );
char* cnbmaille = (char *) toto.c_str();
strcpy(fileName,entreePrinc->RacineNom());
ofstream sort(strcat(strcat(fileName,cnbmaille),"_cab.ison"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier " << fileName
<< ", Resultats::SortieNoeudContaintes(etc..." << endl;
Sortie(1);
}
int dim = paraGlob->Dimension ();
// on balaie tous les noeuds du maillage
int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
// écriture de l'entête
sort << nbmaxinoeud << " 0 \n";
int nbcomposante; // nombre de composante du tenseur des contraintes
sort << " ";
switch (dim)
{ case 1 : sort << " Sig11 SigI Mises "
<< " Tresca" ; nbcomposante= 1; break;
case 2 : sort << " Sig11 Sig22 Sig12 "
<< " SigI SigII Mises "
<< " Tresca" ; nbcomposante= 3; break;
case 3 : sort << " Sig11 Sig22 Sig33 "
<< " Sig12 Sig13 Sig23 "
<< " SigI SigII SigIII "
<< " Mises Tresca"; nbcomposante= 6; break;
};
sort << '\n';
// def d'un vecteur contenant les coordonnées du tenseur
Vecteur Sig; // dimension par défaut
Coordonnee valPropreSig;
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
{ // recup du noeud
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
bool retour = noe.Contrainte(Sig); // recup des contraintes
// écriture
sort << setw (5) << "-1";
if (retour)
{ // sortie des contraintes
for (int i=1;i<= nbcomposante;i++)
sort << setw (16) << Sig(i) << " " ;
// ---- sortie des contraintes principales ---
// 1) reconstitution du tenseur
TenseurHB* sigHB;
switch (dim)
{ case 1 : sigHB = new Tenseur1HB(Sig(1)); break;
case 2 : sigHB = new Tenseur2HB(Sig(1),Sig(2),Sig(3),Sig(3)); break;
case 3 : sigHB = new Tenseur3HB(Sig(1),Sig(4),Sig(5),
Sig(4),Sig(2),Sig(6),
Sig(5),Sig(6),Sig(3)); break;
};
// 2) calcul des valeurs propres
int cas;
valPropreSig = sigHB->ValPropre(cas);
if (cas == -1)
{ cout << "\n warning *** erreur dans le calcul des valeurs propres de la contrainte";
if (ParaGlob::NiveauImpression() >= 7)
{sigHB->Ecriture(cout); cout << "\nResultats::SortieNoeudContaintes(...";};
cout << endl;
};
// 3) sortie des contraintes principales
int nval = valPropreSig.Dimension();
for (int i=1;i<= nval;i++)
sort << setw (16) << valPropreSig(i) << " " ;
// 4) def de la contrainte de Mises et de Tresca
Coordonnee& vv = valPropreSig; // pour condenser l'écriture
double Mises = 0.; double Tresca = 0.;
if (dim ==1) { Mises = Dabs(vv(1)); Tresca = Mises/2.;}
else if (dim ==2) { Mises = Dabs(vv(1)-vv(2));Tresca = Mises/2.;}
else {Mises = sqrt( ((vv(1)-vv(2))*(vv(1)-vv(2)) + (vv(1)-vv(3))*(vv(1)-vv(3))
+ (vv(3)-vv(2))*(vv(3)-vv(2))) * 0.5);;
Tresca = 0.5* MaX( MaX(Dabs(vv(1)-vv(2)),Dabs(vv(1)-vv(3))), Dabs(vv(2)-vv(3)));
}
// 5) Sortie de Mises et Tresca
sort << setw (16) << Mises << " " << setw (16) << Tresca << " " ;
sort << '\n';
}
}
// on vide le buffer de sortie
sort << endl;
};
};
};
// dans le cas ou l'on a une remontée aux erreurs, sortie d'isovaleurs
// d'erreur aux noeuds.
void Resultats::SortieNoeudErreur
(LesMaillages* lesMail,LesReferences* ,ParaGlob * paraGlob)
{ // on sort les erreurs aux noeuds dans le cas où a priori elles ont
// ete calculées
// récup de la liste des sous types
list <EnumSousTypeCalcul> const & lis_sous = paraGlob->LesSousTypesDeCalcul();
list <EnumSousTypeCalcul>::const_iterator ik,ikfin; // iterators
ikfin = lis_sous.end();
for (ik= lis_sous.begin();ik!=ikfin;ik++)
if (Erreur_in(*ik) && paraGlob->SousTypeCalcul(*ik))
{
// on veut sortir des isovaleurs pour chaque maillage
int nbmaximaillage = lesMail->NbMaillage();
for (int numMail=1;numMail<= nbmaximaillage;numMail++)
{ // ouverture du fichier pour ecrire contraintes aux noeuds
char nomm[132];
char*fileName = nomm;
// transformation du nb de maillage en char*
string toto = ChangeEntierSTring(numMail );
char* cnbmaille = (char *) toto.c_str();
strcpy(fileName,entreePrinc->RacineNom());
ofstream sort(strcat(strcat(fileName,cnbmaille),"_err.ison"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier " << fileName
<< ", Resultats::SortieNoeudErreur(etc..." << endl;
Sortie(1);
}
//int dim = paraGlob->Dimension ();
// on balaie tous les noeuds du maillage
int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
// écriture de l'entête
sort << nbmaxinoeud << " 0 \n";
sort << " ERREUR \n";
// tout d'abord on fait un premier passage pour déterminer le
// minimum de l'erreur
double miniErreur =0.;
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
{ // recup du noeud
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
miniErreur = MiN(noe.Valeur_t(ERREUR),miniErreur);
}
// sortie des erreurs traités avec les log pour augmenter
// la plage de concentration
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
{ // recup du noeud
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
// écriture conditionnelle
if (noe.Existe_ici(ERREUR))
{ sort << setw (5) << "-1";
double erreur = noe.Valeur_t(ERREUR); // l'erreur
// finalement on sort une grandeur régulée par le log
// avec un décalage sur 1 pour le mini, d'où un log nul
sort << setw (16) << (log(erreur-miniErreur+1.)) << " " ;
// sort << setw (16) << erreur << " " ;
sort << '\n';
}
}
// on vide le buffer de sortie
sort << endl;
};
};
};
// dans le cas ou l'on a une remontée aux erreurs, sortie des valeurs d'erreur
// aux éléments.
void Resultats::SortieElemErreur
(LesMaillages* lesMail,LesReferences* ,ParaGlob * paraGlob)
{ // on sort les erreurs aux éléments dans le cas où a priori elles ont
// ete calculées
// récup de la liste des sous types
list <EnumSousTypeCalcul> const & lis_sous = paraGlob->LesSousTypesDeCalcul();
list <EnumSousTypeCalcul>::const_iterator ik,ikfin; // iterators
ikfin = lis_sous.end();
for (ik= lis_sous.begin();ik!=ikfin;ik++)
if (Erreur_in(*ik) && paraGlob->SousTypeCalcul(*ik))
{
// on veut sortir les valeurs pour chaque maillage
int nbmaximaillage = lesMail->NbMaillage();
for (int numMail=1;numMail<= nbmaximaillage;numMail++)
{ // ouverture du fichier pour ecrire aux éléments
char nomm[132];
char*fileName = nomm;
// transformation du nb de maillage en char*
string toto = ChangeEntierSTring(numMail );
char* cnbmaille = (char *) toto.c_str();
strcpy(fileName,entreePrinc->RacineNom());
ofstream sort(strcat(strcat(fileName,cnbmaille),"_err.isoe"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier " << fileName
<< ", Resultats::SortieElemErreur(etc..." << endl;
Sortie(1);
}
//int dim = paraGlob->Dimension ();
// on balaie tous les éléments du maillage
int nbmaxiElement = lesMail->Nombre_element(numMail);
// écriture de l'entête
sort << nbmaxiElement << " 0 \n";
sort << " ERREUR \n";
for (int numElem=1; numElem<= nbmaxiElement;numElem++)
{ // recup de l'élément
Element & noel = lesMail->Element_LesMaille(numMail,numElem);
// écriture conditionnelle au cas mécanique et au cas ou l'erreur a été
// calculée
if (noel.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
if (((ElemMeca&) noel).ErreurDejaCalculee())
{sort << setw (5) << "-1";
double erreur = noel.Erreur(); // l'erreur
// l'erreur doit être forcément supérieur à 0
// dans le cas où elle est négative, on la met à 0
if(erreur < 0.)
erreur = 0.;
sort << setw (16) << erreur << " " ;
sort << '\n';
}
}
// on vide le buffer de sortie
sort << endl;
};
};
};
// sortie des contraintes aux éléments en texte peu lisible mais condensé
void Resultats::SortieElemenContrainte
(LesMaillages* lesMail,ParaGlob * paraGlob)
{ // on veut sortir les valeurs pour chaque maillage
int nbmaximaillage = lesMail->NbMaillage();
for (int numMail=1;numMail<= nbmaximaillage;numMail++)
{ // ouverture du fichier pour ecrire aux éléments
char nomm[132];
char*fileName = nomm;
// transformation du nb de maillage en char*
string toto = ChangeEntierSTring(numMail );
char* cnbmaille = (char *) toto.c_str();
strcpy(fileName,entreePrinc->RacineNom());
ofstream sort(strcat(strcat(fileName,cnbmaille),"_cab.isoe"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier " << fileName
<< ", Resultats::SortieElemenContrainte(etc..." << endl;
Sortie(1);
}
int dim = paraGlob->Dimension ();
// on balaie tous les éléments du maillage
int nbmaxiElement = lesMail->Nombre_element(numMail);
// écriture de l'entête
sort << " 0 " << nbmaxiElement << " \n";
int nbcomposante; // nombre de composante du tenseur des contraintes
sort << " ";
switch (dim)
{ case 1 : sort << " Sig11 "; nbcomposante= 1; break;
case 2 : sort << " Sig11 Sig22 Sig12"; nbcomposante= 3; break;
case 3 : sort << " Sig11 Sig22 Sig33 "
<< " Sig12 Sig23 Sig13"; nbcomposante= 6; break;
};
sort << '\n';
// def d'un tableau de vecteur contenant les coordonnées du tenseur
Tableau <Vecteur> tabSig; // dimension par défaut
// il est redimensionné dans l'élément si nécessaire
// on regarde sur le premier élément qui doit être de type mécanique
// du maillage si le calcul de contrainte
// est possible si oui on continu et on considère que c'est possible pour
// tous les autres sinon arrêt pour ce maillage
Element & elem = lesMail->Element_LesMaille(numMail,1);
bool possible;
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
possible = ((ElemMeca&) elem).ContrainteAbsoluePossible();
else
possible = false;
if (possible)
for (int numElem=1; numElem<= nbmaxiElement;numElem++)
{ // recup de l'élément
Element & elem = lesMail->Element_LesMaille(numMail,numElem);
// on regarde si c'est un élément de mécanique
// si oui on récupère le tableau des tenseurs en absolu
bool retour = false;
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
retour =((ElemMeca&) elem).ContraintesAbsolues(tabSig);
else
retour = false;
// écriture
if (retour)
{
sort << setw (5) << "-1 " ;
int taille = tabSig.Taille();
for (int ni = 1; ni<= taille; ni++)
for (int i=1;i<= nbcomposante;i++)
sort << setw (16) << tabSig(ni)(i) << " " ;
sort << '\n';
}
}
// on vide le buffer de sortie
sort << endl;
};
};
// sortie des frontières
void Resultats::SortieFrontieres (LesMaillages* lesMail)
{ //récupération de la liste de frontière
Tableau <LaLIST <Front>*>& tablist = lesMail->ListFrontiere();
// on veut sortir les valeurs pour chaque maillage
int nbmaximaillage = lesMail->NbMaillage();
for (int numMail=1;numMail<= nbmaximaillage;numMail++)
{ // ouverture du fichier d'écriture
char nomm[132];
char*fileName = nomm;
// transformation du nb de maillage en char*
string toto = ChangeEntierSTring(numMail );
char* cnbmaille = (char *) toto.c_str();
strcpy(fileName,entreePrinc->RacineNom());
// le .faces
ofstream sort(strcat(strcat(fileName,cnbmaille),"_front.faces"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier .faces" << fileName
<< ", Resultats::SortieFrontieres (LesMaillages* lesMail)" << endl;
Sortie(1);
};
//récupération de la liste de frontière
LaLIST <Front>& listfront = *(tablist(numMail)); // pour simplifier
int nbmaxiElement = (int) listfront.size();
// écriture de l'entête
sort << " elements \n \n" << nbmaxiElement << " ELEMENTS \n \n";
sort << "#-----------------------------------------------------------------------\n";
sort << "# NO Type Noeuds |\n";
sort << "#-----------------------------------------------------------------------\n \n";
LaLIST <Front>::iterator ip;int ne;
for (ne=1,ip = listfront.begin();ip != listfront.end(); ip++,ne++)
{ // écriture de l'élément courant
sort << ne << " " ; // le numéro
const ElemGeomC0 & geom = (*ip).Eleme()->ElementGeometrique();
sort << Nom_geom(geom.TypeGeometrie()) << " " ; // la géométrie
sort << Nom_interpol(geom.TypeInterpolation()) << " " ; // l'interpolation
// les noeuds
Tableau <Noeud *> tabnoeud = (*ip).Eleme()->TabNoeud();
int taille = tabnoeud.Taille();
for (int ine = 1; ine<=taille; ine++)
sort << tabnoeud(ine)->Num_noeud() << " ";
sort << "\n";
}
// on vide le buffer de sortie
sort << endl;
// on ne continue que s'il y a des éléments frontières
if (listfront.size() != 0)
{// dans le cas d'un maillage 2D donc d'une frontière 1D on essaie de sortir
// la frontière ordonnée
// le .faces
ip = listfront.begin() ; // on prend le premier pour tester
if ((*ip).Eleme()->ElementGeometrique().Dimension() == 1)
{ char nomm2[132];
char*file2Name = nomm2;
strcpy(file2Name,entreePrinc->RacineNom());
ofstream sirt(strcat(strcat(file2Name,cnbmaille),"_frOrdre.faces"));
if(!(sirt.is_open()))
{ cout << "\n erreur en ouverture du fichier .faces" << fileName
<< ", Resultats::SortieFrontieres (LesMaillages* lesMail)" << endl;
Sortie(1);
}
// écriture de l'entête
sirt << " elements \n \n" << nbmaxiElement << " ELEMENTS \n \n";
sirt << "#-----------------------------------------------------------------------\n";
sirt << "# NO Type Noeuds |\n";
sirt << "#-----------------------------------------------------------------------\n \n";
int ne = 1;
Front * precedent = NULL;
Front * debut = &(*ip);
Front* elfront = &(*ip);
while(ne <= nbmaxiElement)
{ // écriture de l'élément courant
sirt << ne << " " ; // le numéro
const ElemGeomC0 & geom = elfront->Eleme()->ElementGeometrique();
sirt << Nom_geom(geom.TypeGeometrie()) << " " ; // la géométrie
sirt << Nom_interpol(geom.TypeInterpolation()) << " " ; // l'interpolation
// les noeuds
Tableau <Noeud *> tabnoeud = elfront->Eleme()->TabNoeud();
int taille = tabnoeud.Taille();
for (int ine = 1; ine<=taille; ine++)
sirt << tabnoeud(ine)->Num_noeud() << " ";
sirt << "\n";
ne++;
// récupération de l'élément frontière suivant
const Tableau <Front*>* tabmitoyen=elfront->TabMitoyen();
if (tabmitoyen != NULL)
{for (int i=1;i<=tabmitoyen->Taille();i++)
if ((*tabmitoyen)(i) != precedent)
{ elfront = &(*(*tabmitoyen)(i));
break;
}
};
// si l'on a rejoint le début on s'arrête
if ( elfront == debut) break;
};
ne--;
if (ne != nbmaxiElement)
// cas où l'on n'a pas parcouru toute la liste
cout << " \n Resultats::SortieFrontieres (LesMaillages* lesMail)"
<< "\n pour la sortie ordonnée, "
<< " toutes les frontières n'ont pas été copiées !!"
<< "\n sans doute parce que les frontières sont "
<< " constituées de plusieurs boucles \n";
// on vide le buffer de sortie
sirt << endl;
}
};
};
};
// sortie de la deformee du maillage pour l'article
void Resultats::DeformeeArticle(LesMaillages* lesmail)
{// ouverture du fichier de resultats
char nomm[132];
char*fileName = nomm;
strcpy(fileName,entreePrinc->RacineNom());
ofstream sort(strcat(fileName,".def"));
if(!(sort.is_open()))
{ cout << "\n erreur en ouverture du fichier " << fileName
<< ", Resultats::SortieNoeuds(etc..." << endl;
Sortie(1);
};
// on divise les faces des cubes en n*n petites facettes
int n = 4 ; // 4 par defaut
// question sur le cas
int cas;
cout << " cas 1cube seule (3), avec biellette (1) , 2 cube (2) ou autre pour arreter?\n"
<< " (un nombre negatif pour avoir les ligne du cube initial) "
<< " un cube et une biellette lies (4), deux cubes lies (5)";
cas=(int)lect_double();
cout << "\n valeur de n ? ";
n = (int) lect_double();
if ((cas!=1) && (cas!=2) && (cas!=3)&&(cas!=-1) && (cas!=-2)
&& (cas!=-3) && (Dabs(cas) != 4) && (Dabs(cas) != 5) ) return;
// si cas = 1 -> 1 cube sinon 2 cubes
int nbface; //nb face
int nbnoe; // nb de noeud
int nbface0 = 0; //nb face a t= 0
int nbnoe0 = 0; // nb de noeud a t = 0
Tableau <Coordonnee> tabCgen; // tableau general des noeuds
Tableau < Tableau <int> > tabFgen; // tableau general des faces
if (cas < 0)
{ nbface0 = 12;
nbnoe0 = 8;
}
Tableau <Coordonnee> tabc; // tableau inter
Tableau < Tableau <int> > tabF;// " "
int inNoe =1; // indice de noeud
int inFace =1; // indice de face
int decalNoe = 0; // decalage sur les noeuds
if (Dabs(cas) == 3)
{ nbface = 6*n*n + nbface0;
nbnoe = 8 + (n-1)*12 + (n-1)*(n-1)*6 + nbnoe0 ;
tabCgen.Change_taille(nbnoe);
tabFgen.Change_taille(nbface);
// premier maillage -> le cube
Tableau<Noeud *>& t1 = lesmail->Element_LesMaille(1,1).Tab_noeud();
ZoomElem(t1,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=tabF.Taille();i++,inFace++)
tabFgen(inFace) = tabF(i);
decalNoe += tabc.Taille();
// second maillage le cube initial
if (cas < 0)
{ InitialC(t1,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=tabF.Taille();i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
}
}
else if (Dabs(cas) == 1)
{ nbface = 6*n*n + 1 + nbface0;
nbnoe = 8 + (n-1)*12 + (n-1)*(n-1)*6 + 2 + nbnoe0;
tabCgen.Change_taille(nbnoe);
tabFgen.Change_taille(nbface);
// 1er maillage -> la biellete
Tableau<Noeud *>& t1 = lesmail->Element_LesMaille(1,1).Tab_noeud();
tabFgen(1).Change_taille(4);
tabFgen(1)(1) = 1;tabFgen(1)(2) = 2;
tabFgen(1)(3) = 1;tabFgen(1)(4) = 1;
tabCgen(1) = t1(1)->Coord2();tabCgen(2) = t1(2)->Coord2();
inNoe = 3; inFace = 2; decalNoe += 2;
// second maillage -> le cube deforme
Tableau<Noeud *>& t2 = lesmail->Element_LesMaille(2,1).Tab_noeud();
ZoomElem(t2,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=tabF.Taille();i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
decalNoe += tabc.Taille();
// troisieme maillage le cube initial
if (cas < 0)
{ InitialC(t2,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=nbface0;i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
}
}
else if (Dabs(cas) == 4)
{ nbface = 6*n*n + 1 + nbface0;
nbnoe = 8 + (n-1)*12 + (n-1)*(n-1)*6 + 2 + nbnoe0;
tabCgen.Change_taille(nbnoe);
tabFgen.Change_taille(nbface);
// 1er maillage -> la biellete -> second element
Tableau<Noeud *>& t1 = lesmail->Element_LesMaille(1,2).Tab_noeud();
tabFgen(1).Change_taille(4);
tabFgen(1)(1) = 1;tabFgen(1)(2) = 2;
tabFgen(1)(3) = 1;tabFgen(1)(4) = 1;
tabCgen(1) = t1(1)->Coord2();tabCgen(2) = t1(2)->Coord2();
inNoe = 3; inFace = 2; decalNoe += 2;
// second maillage -> le cube deforme -> le premier element
Tableau<Noeud *>& t2 = lesmail->Element_LesMaille(1,1).Tab_noeud();
ZoomElem(t2,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=tabF.Taille();i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
decalNoe += tabc.Taille();
// troisieme maillage le cube initial
if (cas < 0)
{ InitialC(t2,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=nbface0;i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
}
}
else if (Dabs(cas) == 2)
{ nbface = 12*n*n + 2*nbface0;
nbnoe = 2*(8 + (n-1)*12 + (n-1)*(n-1)*6) + 2*nbnoe0;
tabCgen.Change_taille(nbnoe);
tabFgen.Change_taille(nbface);
// 1er maillage -> le premier cube deforme
Tableau<Noeud *>& t1 = lesmail->Element_LesMaille(1,1).Tab_noeud();
ZoomElem(t1,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=tabF.Taille();i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
decalNoe += tabc.Taille();
// 2ieme maillage le 1er cube initial
if (cas < 0)
{ InitialC(t1,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=nbface0;i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
decalNoe += tabc.Taille();
}
// 3ieme maillage -> le second cube deforme
Tableau<Noeud *>& t2 = lesmail->Element_LesMaille(2,1).Tab_noeud();
ZoomElem(t2,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=tabF.Taille();i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
decalNoe += tabc.Taille();
// 4ieme maillage le 2er cube initial
if (cas < 0)
{ InitialC(t2,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=nbface0;i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
decalNoe += tabc.Taille();
}
}
else if (Dabs(cas) == 5)
{ nbface = 12*n*n + 2*nbface0;
nbnoe = 2*(8 + (n-1)*12 + (n-1)*(n-1)*6) + 2*nbnoe0;
tabCgen.Change_taille(nbnoe);
tabFgen.Change_taille(nbface);
// 1er maillage -> le premier cube deforme
Tableau<Noeud *>& t1 = lesmail->Element_LesMaille(1,1).Tab_noeud();
ZoomElem(t1,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=tabF.Taille();i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
decalNoe += tabc.Taille();
// 2ieme maillage le 1er cube initial
if (cas < 0)
{ InitialC(t1,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=nbface0;i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
decalNoe += tabc.Taille();
}
// 3ieme maillage -> le second cube deforme
Tableau<Noeud *>& t2 = lesmail->Element_LesMaille(1,2).Tab_noeud();
ZoomElem(t2,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=tabF.Taille();i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
decalNoe += tabc.Taille();
// 4ieme maillage le 2er cube initial
if (cas < 0)
{ InitialC(t2,n,tabc,tabF);
for (int i=1;i<=tabc.Taille();i++,inNoe++)
tabCgen(inNoe) = tabc(i);
for (int i=1;i<=nbface0;i++,inFace++)
{ tabFgen(inFace).Change_taille(4);
for (int j=1;j<=4;j++)
tabFgen(inFace)(j) = tabF(i)(j)+decalNoe;
}
decalNoe += tabc.Taille();
}
}
// on ecrit l'entete
sort << " dataset type = fe Ngp = " << nbnoe << ", nE = " << nbface
<< ", ns = 4" << '\n';
// ecriture des noeuds
for (int in=1;in<=nbnoe;in++)
sort << tabCgen(in)(1) << " " << tabCgen(in)(2) << " " << tabCgen(in)(3) << '\n';
// ecriture des connections des elements
for (int iff=1;iff<=nbface;iff++)
sort << tabFgen(iff)(1) << " "<< tabFgen(iff)(2) << " "
<< tabFgen(iff)(3) << " "<< tabFgen(iff)(4) << '\n';
// vide le buffer
sort << endl;
};
//++++++++++++++++++++++++++++
// pour un cube, creation de noeuds intermediaires et de faces pour la visualisation
void Resultats::ZoomElem
(Tableau <Noeud*>& tabN, int n, Tableau <Coordonnee>& tabc,
Tableau < Tableau <int> >& tabF)
{ //dimensionnement des tableaux de sortie
int nbface = 6*n*n;
int nbnoe = 8 + (n-1)*12 + (n-1)*(n-1)*6;
tabc.Change_taille(nbnoe);
tabF.Change_taille(nbface);
for (int i=1;i<=nbface;i++)
tabF(i).Change_taille(4);
// indice de noeud utilise pour reperer les nouveaus noeud cree
int inoe =1;
// def des sommets principaux
for (int i=1;i<=8;i++,inoe++) tabc(inoe) = tabN(i)->Coord2();
// constitution des grandes faces
Tableau < Tableau <int> > tab4N(6);
for (int i=1;i<=6;i++)
tab4N(i).Change_taille(4);
tab4N(1)(1) = 4;tab4N(1)(2) = 1;tab4N(1)(3) = 5;tab4N(1)(4) = 8;
tab4N(2)(1) = 3;tab4N(2)(2) = 7;tab4N(2)(3) = 6;tab4N(2)(4) = 2;
tab4N(3)(1) = 8;tab4N(3)(2) = 5;tab4N(3)(3) = 6;tab4N(3)(4) = 7;
tab4N(4)(1) = 1;tab4N(4)(2) = 2;tab4N(4)(3) = 6;tab4N(4)(4) = 5;
tab4N(5)(1) = 4;tab4N(5)(2) = 3;tab4N(5)(3) = 2;tab4N(5)(4) = 1;
tab4N(6)(1) = 4;tab4N(6)(2) = 8;tab4N(6)(3) = 7;tab4N(6)(4) = 3;
// def des arretes et def des coordonnees des noeuds intermediaires sur les arretes
Tableau < Tableau <int> > tabAr(12);
for (int i=1;i<=12;i++)
tabAr(i).Change_taille(n-1); // on ne met pas les noeuds extremes
int iAr = 1; // numero d'arrete
Tableau < Tableau <int> > tabEx(2); // tableau intermediaires des extremites des arretes
for (int i=1;i<=2;i++)
tabEx(i).Change_taille(2);
for (int nf=1;nf<=6;nf++)
// pour chaque grande face on defini deux aretes, les deux premieres
// ce qui permet de definir toutes les aretes
{ tabEx(1)(1) = tab4N(nf)(1);tabEx(1)(2) = tab4N(nf)(2);
tabEx(2)(1) = tab4N(nf)(2);tabEx(2)(2) = tab4N(nf)(3);
for (int ia=1;ia<=2;ia++,iAr++) // pour chaque arrete
{ Coordonnee dxxy = (tabc(tabEx(ia)(2)) - tabc(tabEx(ia)(1)))/n; // delta coord
for (int j=1;j<=n-1;j++,inoe++)
{ tabc(inoe) = tabc(tabEx(ia)(1)) + dxxy * j;
tabAr(iAr)(j) = inoe;
}
}
}
// on attache a chaque grande face 4 numero d'arretes ordonnees la verticale a gauche
// puis a droite, ce qui servira a calculer les noeuds inter, puis l'horizontale du bas
// et enfin horizontale du haut
Tableau < Tableau <int> > tArF(6);
for (int i=1;i<=6;i++)
tArF(i).Change_taille(4);
tArF(1)(1) = 1;tArF(1)(2) = 5;tArF(1)(3) = 2;tArF(1)(4) = 11;
tArF(2)(1) = 3;tArF(2)(2) = 8;tArF(2)(3) = 4;tArF(2)(4) = 10;
tArF(3)(1) = 5;tArF(3)(2) = 4;tArF(3)(3) = 6;tArF(3)(4) = 12;
tArF(4)(1) = 7;tArF(4)(2) = 6;tArF(4)(3) = 8;tArF(4)(4) = 2;
tArF(5)(1) = 9;tArF(5)(2) = 7;tArF(5)(3) = 10;tArF(5)(4) = 1;
tArF(6)(1) = 11;tArF(6)(2) = 3;tArF(6)(3) = 12;tArF(6)(4) = 9;
// calcul des noeuds et faces
int ifac =1; // indice de face
for (int nf=1;nf<=6;nf++) // boucle sur les 6 faces
// pour chaque grande face
{ // creation des lignes horizontales complete (avec les extremites)
Tableau < Tableau <int> > tintAr(n+1);
for (int i=1;i<=n+1;i++)
tintAr(i).Change_taille(n+1);
// cas des extremitees, la premiere ligne et la derniere
tintAr(1)(1) = tab4N(nf)(2) ;tintAr(1)(n+1) = tab4N(nf)(3) ; // les sommets
tintAr(n+1)(1) = tab4N(nf)(1) ;tintAr(n+1)(n+1) = tab4N(nf)(4) ; // "
for (int i=1;i<= n-1;i++)
{ tintAr(1)(i+1) = tabAr(tArF(nf)(3))(i); // arete du bas
tintAr(n+1)(i+1) = tabAr(tArF(nf)(4))(i); // arete du haut
tintAr(i+1)(1) = tabAr(tArF(nf)(1))(n-i) ; // verticale gauche
tintAr(i+1)(n+1) = tabAr(tArF(nf)(2))(n-i) ; // verticale droite
}
// cas des lignes intermediaires
for (int iL=1;iL<=n-1;iL++)
{// le delta longueur
Coordonnee dxxy = (tabc(tintAr(iL+1)(n+1)) - tabc(tintAr(iL+1)(1)))/n;
for (int j=1;j<=n-1;j++,inoe++)
{ tabc(inoe) = tabc(tintAr(iL+1)(1)) + dxxy * j; // le noeud sup
tintAr(iL+1)(j+1) = inoe;
}
}
// creation des petites faces
for (int iL=1;iL<=n;iL++)
for (int iC=1;iC<=n;iC++,ifac++)
{ tabF(ifac)(1) = tintAr(iL)(iC); tabF(ifac)(2) = tintAr(iL+1)(iC);
tabF(ifac)(3) = tintAr(iL+1)(iC+1); tabF(ifac)(4) = tintAr(iL)(iC+1);
}
}
};
// dessin d'un cube initial
void Resultats::InitialC
(Tableau <Noeud*>& tabN, int , Tableau <Coordonnee>& tabc,
Tableau < Tableau <int> >& tabF)
{ //dimensionnement des tableaux de sortie
int nbface = 12; // chaque face represente une arete
int nbnoe = 8; // les sommets
tabc.Change_taille(nbnoe);
tabF.Change_taille(nbface);
for (int i=1;i<=nbface;i++)
tabF(i).Change_taille(4);
// indice de noeud utilise pour reperer les nouveaus noeud cree
int inoe =1;
// def des sommets principaux
for (int i=1;i<=8;i++,inoe++) tabc(inoe) = tabN(i)->Coord0();
// constitution des faces
tabF(1)(1) = 1;tabF(1)(2) = 4;tabF(1)(3) = 1;tabF(1)(4) = 1;
tabF(2)(1) = 1;tabF(2)(2) = 5;tabF(2)(3) = 1;tabF(2)(4) = 1;
tabF(3)(1) = 3;tabF(3)(2) = 7;tabF(3)(3) = 3;tabF(3)(4) = 3;
tabF(4)(1) = 7;tabF(4)(2) = 6;tabF(4)(3) = 7;tabF(4)(4) = 7;
tabF(5)(1) = 5;tabF(5)(2) = 8;tabF(5)(3) = 5;tabF(5)(4) = 5;
tabF(6)(1) = 5;tabF(6)(2) = 6;tabF(6)(3) = 5;tabF(6)(4) = 5;
tabF(7)(1) = 1;tabF(7)(2) = 2;tabF(7)(3) = 1;tabF(7)(4) = 1;
tabF(8)(1) = 2;tabF(8)(2) = 6;tabF(8)(3) = 2;tabF(8)(4) = 2;
tabF(9)(1) = 3;tabF(9)(2) = 4;tabF(9)(3) = 3;tabF(9)(4) = 3;
tabF(10)(1) = 2;tabF(10)(2) = 3;tabF(10)(3) = 2;tabF(10)(4) = 2;
tabF(11)(1) = 4;tabF(11)(2) = 8;tabF(11)(3) = 4;tabF(11)(4) = 4;
tabF(12)(1) = 8;tabF(12)(2) = 7;tabF(12)(3) = 8;tabF(12)(4) = 8;
};