1460 lines
64 KiB
C++
Executable file
1460 lines
64 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 "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 ";
|
|
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;
|
|
};
|
|
|
|
|
|
|
|
|