585 lines
33 KiB
C++
585 lines
33 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-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 "AlgoUtils.h"
|
||
|
|
|
||
|
|
// CONSTRUCTEURS :
|
||
|
|
AlgoUtils::AlgoUtils () : // par defaut
|
||
|
|
Algori()
|
||
|
|
{ };
|
||
|
|
|
||
|
|
// constructeur en fonction du type de calcul et du sous type
|
||
|
|
// il y a ici lecture des parametres attaches au type
|
||
|
|
AlgoUtils::AlgoUtils (const bool avec_typeDeCal
|
||
|
|
,const list <EnumSousTypeCalcul>& soustype
|
||
|
|
,const list <bool>& avec_soustypeDeCal
|
||
|
|
,UtilLecture& entreePrinc) :
|
||
|
|
Algori(UTILITAIRES,avec_typeDeCal,soustype,avec_soustypeDeCal,entreePrinc)
|
||
|
|
{ // lecture des paramètres attachés au type de calcul (ici aucun)
|
||
|
|
switch (entreePrinc.Lec_ent_info())
|
||
|
|
{ case 0 :
|
||
|
|
{// pour signaler à Algori qu'il n'y a pas eu de lecture de paramètre
|
||
|
|
deja_lue_entete_parametre=0;
|
||
|
|
// puis appel de la méthode de la classe mère
|
||
|
|
Algori::lecture_Parametres(entreePrinc); break;}
|
||
|
|
case -11 : // cas de la création d'un fichier de commande
|
||
|
|
{ Info_commande_parametres(entreePrinc); break;}
|
||
|
|
case -12 : // cas de la création d'un schéma XML, on ne fait rien à ce niveau
|
||
|
|
{ break;}
|
||
|
|
default:
|
||
|
|
Sortie(1);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
// constructeur de copie
|
||
|
|
AlgoUtils::AlgoUtils (const AlgoUtils& algo):
|
||
|
|
Algori(algo)
|
||
|
|
{ };
|
||
|
|
|
||
|
|
// destructeur
|
||
|
|
AlgoUtils::~AlgoUtils ()
|
||
|
|
{
|
||
|
|
};
|
||
|
|
|
||
|
|
// execution de l'algorithme
|
||
|
|
void AlgoUtils::Execution(ParaGlob * p,LesMaillages * lesMail
|
||
|
|
,LesReferences* lesRef,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
|
||
|
|
,VariablesExporter* varExpor,LesLoisDeComp* lesLoisDeComp, DiversStockage* divStock
|
||
|
|
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts,Resultats* resultats)
|
||
|
|
{
|
||
|
|
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
|
||
|
|
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(UTILITAIRES); // transfert info
|
||
|
|
lesMail->Insert_coord1();
|
||
|
|
lesMail->Travail_tdt(); // utile pour le travail avec des fonctions nD éventuelle
|
||
|
|
lesMail->Init_Xi_t_et_tdt_de_0(); // ""
|
||
|
|
// mise à jour au cas où
|
||
|
|
Algori::MiseAJourAlgoMere(p,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp,divStock
|
||
|
|
,charge,lesCondLim,lesContacts,resultats);
|
||
|
|
|
||
|
|
// INITIALISATION particulière concernant le contact
|
||
|
|
// ceci pour optimiser éventuellement la numérotation en prenant en compte un contact initial
|
||
|
|
// mise a zero de tous les ddl et creation des tableaux a t+dt
|
||
|
|
// les ddl de position ne sont pas mis a zero ! ils sont initialise
|
||
|
|
// a la position courante
|
||
|
|
lesMail->ZeroDdl(true);
|
||
|
|
// on vérifie que les noeuds sont bien attachés à un élément sinon on met un warning si niveau > 2
|
||
|
|
if (ParaGlob::NiveauImpression() > 2)
|
||
|
|
lesMail->AffichageNoeudNonReferencer();
|
||
|
|
// dans le cas d'un contact éventuel on initialise les frontières et la répartition esclave et maître
|
||
|
|
if (lesMail->NbEsclave() != 0)
|
||
|
|
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||
|
|
int cal_front = lesMail->CreeElemFront();
|
||
|
|
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||
|
|
if (lesContacts->Init_contact_pas_effectue())
|
||
|
|
{// initialisation des zones de contacts éventuelles
|
||
|
|
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||
|
|
}
|
||
|
|
else if (cal_front)
|
||
|
|
// si l'initialisation du contact a déjà été effectué et que les frontières viennent d'être
|
||
|
|
// recalculée -> ce n'est pas normal, car les frontières ont dues être déjà calculées pour
|
||
|
|
// initialiser le contact !!
|
||
|
|
{ cout << "\n **** >>>> ERREUR en initialisant le contact ***** ";
|
||
|
|
cout << "\n les frontieres viennent d'etre recalculees alors que l'initialisation du contact "
|
||
|
|
<< " etait deja effectif : ce n'est pas normal: les nouvelles frontieres ne seront pas "
|
||
|
|
<< " coherentes avec celles utilisees pour l'initialisation du contact : arret !!! "
|
||
|
|
<< flush;
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
// verification qu'il n'y a pas de contact avant le premier increment de charge
|
||
|
|
lesContacts->Verification();
|
||
|
|
// definition des elements de contact eventuels
|
||
|
|
// et imposition éventuel de certaines des conditions de contact (dépend du modèle de contact)
|
||
|
|
try {
|
||
|
|
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
|
||
|
|
}
|
||
|
|
// sortie anormale de l'initialisation du contact
|
||
|
|
catch (ErrSortieFinale)
|
||
|
|
// cas d'une direction voulue vers la sortie
|
||
|
|
// on relance l'interuption pour le niveau supérieur
|
||
|
|
{ ErrSortieFinale toto;
|
||
|
|
tempsCalEquilibre.Arret_du_comptage(); // temps cpu
|
||
|
|
throw (toto);
|
||
|
|
}
|
||
|
|
catch (...)// erreur inconnue
|
||
|
|
{ cout << "\n **** >>>> ERREUR inconnuee en en initialisant le contact ***** ";
|
||
|
|
if (ParaGlob::NiveauImpression() >= 4)
|
||
|
|
cout << "\n AlgoUtils::Execution(..";
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// renseigne les variables définies par l'utilisateur via les valeurs déjà calculées par Herezh
|
||
|
|
varExpor->RenseigneVarUtilisateur(*lesMail,*lesRef);
|
||
|
|
lesMail->CalStatistique(); // calcul éventuel de statistiques
|
||
|
|
// on définit le type de calcul a effectuer :
|
||
|
|
if ( soustypeDeCalcul->size()==0 )
|
||
|
|
// cas où il n'y a pas de sous type, on fait le calcul
|
||
|
|
// de toutes les cas possibles
|
||
|
|
cout << "\n rien pour l'instant (information)\n";
|
||
|
|
else
|
||
|
|
// on boucle sur tous les sous_types
|
||
|
|
{ list <EnumSousTypeCalcul>::const_iterator ili,ili_fin = soustypeDeCalcul->end();
|
||
|
|
list <bool>::const_iterator ila;
|
||
|
|
for (ili = soustypeDeCalcul->begin(),ila = avec_soustypeDeCalcul->begin();
|
||
|
|
ili!=ili_fin;ili++,ila++)
|
||
|
|
if (*ila) // cas où le sous type est valide
|
||
|
|
{if ( (*ili) == LinVersQuad )
|
||
|
|
// cas de la transformation de maillages linéaires en maillages
|
||
|
|
// quadratiques complets
|
||
|
|
{
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| Transformation des maillages lineaires en |"
|
||
|
|
<< "\n| maillages quadratiques incomplets | "
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
// on crée et on calcul les nouveaux maillages
|
||
|
|
// en y intégrant les références associées
|
||
|
|
// 1) on récupère le nombre de maillage actuellement actif
|
||
|
|
int nb_maillages_actifs_initiaux = lesMail->NbMaillage();
|
||
|
|
// 2) on crée les quadratiques incomplets
|
||
|
|
lesMail->CreeMaillagesQuadratiques_a_partir_des_lineaires(lesRef);
|
||
|
|
// 3) récup du nombre actuellement actif d'où des maillages créés
|
||
|
|
int nb_maillages_actifs_finaux = lesMail->NbMaillage();
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
for (int i=nb_maillages_actifs_initiaux+1;i<=nb_maillages_actifs_finaux;i++)
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef,i);
|
||
|
|
}
|
||
|
|
else if ( (*ili) == QuadIncVersQuadComp )
|
||
|
|
// cas de la transformation de maillages quadratiques incomplets en maillages
|
||
|
|
// quadratiques complets
|
||
|
|
{
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| Transformation des maillages quadratiques incomplets en |"
|
||
|
|
<< "\n| maillages quadratiques complets | "
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
// on crée et on calcul les nouveaux maillages
|
||
|
|
// en y intégrant les références associées
|
||
|
|
// 1) on récupère le nombre de maillage actuellement actif
|
||
|
|
int nb_maillages_actifs_initiaux = lesMail->NbMaillage();
|
||
|
|
// 2) on crée les quadratiques complets
|
||
|
|
lesMail->CreeMaillagesQuadratiquesComplets_a_partir_des_incomplets(lesRef);
|
||
|
|
// 3) récup du nombre actuellement actif d'où des maillages créés
|
||
|
|
int nb_maillages_actifs_finaux = lesMail->NbMaillage();
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
for (int i=nb_maillages_actifs_initiaux+1;i<=nb_maillages_actifs_finaux;i++)
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef,i);
|
||
|
|
}
|
||
|
|
else if ( (*ili) == relocPtMilieuQuad )
|
||
|
|
// cas de la relocalisation des points milieux sur les arrêtes des quadratiques
|
||
|
|
{
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| Relocalisation des points milieux appartenant aux arretes |"
|
||
|
|
<< "\n| des elements quadratiques | "
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
|
||
|
|
// appel de l'utilitaire dans lesMaillages
|
||
|
|
lesMail->RelocPtMilieuMailleQuadra();
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef);
|
||
|
|
}
|
||
|
|
else if ( (*ili) == sauveMaillagesEnCours )
|
||
|
|
// cas de la relocalisation des points milieux sur les arrêtes des quadratiques
|
||
|
|
{
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| ecriture des maillages en cours en .her et .lis |"
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef);
|
||
|
|
}
|
||
|
|
else if ( (*ili) == extrusion2D3D )
|
||
|
|
// cas de l'extrusion d'un maillage 2D en 3D
|
||
|
|
{
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| extrusion d'un maillage 2D en 3D |"
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
|
||
|
|
// on crée et on calcul les nouveaux maillages
|
||
|
|
// en y intégrant les références associées
|
||
|
|
// 1) on récupère le nombre de maillage actuellement actif
|
||
|
|
int nb_maillages_actifs_initiaux = lesMail->NbMaillage();
|
||
|
|
// 2) on crée les maillages extrudées
|
||
|
|
lesMail->CreeMaillageExtrusion2D3D(lesRef);
|
||
|
|
// 3) récup du nombre actuellement actif d'où des maillages créés
|
||
|
|
int nb_maillages_actifs_finaux = lesMail->NbMaillage();
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
for (int i=nb_maillages_actifs_initiaux+1;i<=nb_maillages_actifs_finaux;i++)
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef,i);
|
||
|
|
}
|
||
|
|
else if ( (*ili) == modif_orientation_element )
|
||
|
|
// cas de la modification de l'orientation d'éléments
|
||
|
|
{ // 1) on récupère le nombre de maillage actuellement actif
|
||
|
|
int nb_maillages_actifs_initiaux = lesMail->NbMaillage();
|
||
|
|
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| modification de l'orientation d'element |"
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
// 2) on demande à l'utilisation ce qu'il veut faire et on exécute
|
||
|
|
bool choix_valide = false;
|
||
|
|
int cas_orientation=0; // init
|
||
|
|
while (!choix_valide)
|
||
|
|
{
|
||
|
|
cout << "\n =========== choix du module d'orientation ==============="
|
||
|
|
<< "\n verification de l'orientation ? (rep veor)"
|
||
|
|
<< "\n orientation automatique pour un jacobien positif ? (rep oajp)"
|
||
|
|
<< "\n orientation des faces d'elem 2D via un elem de ref? (rep faor)"
|
||
|
|
<< "\n orientation des faces d'elem 2D via un rayon ? (rep fray)"
|
||
|
|
<< "\n fin (defaut) (rep f)";
|
||
|
|
string rep;
|
||
|
|
cout << "\n reponse ? "; rep = lect_return_defaut(false,"f");
|
||
|
|
if (rep == "veor")
|
||
|
|
// vérification de l'orientation
|
||
|
|
{cas_orientation=-1;
|
||
|
|
lesMail->Modif_orientation_element(cas_orientation,lesRef);
|
||
|
|
}
|
||
|
|
else if (rep == "oajp")
|
||
|
|
// cas d'une orientation automatique pour obtenir un jacobien positif
|
||
|
|
{cas_orientation=1;
|
||
|
|
lesMail->Modif_orientation_element(cas_orientation,lesRef);
|
||
|
|
}
|
||
|
|
else if (rep == "faor")
|
||
|
|
// cas d'une orientation automatique des faces d'un maillage 2D
|
||
|
|
// à partir d'une face de référence
|
||
|
|
{cas_orientation=2;
|
||
|
|
lesMail->Modif_orientation_element(cas_orientation,lesRef);
|
||
|
|
}
|
||
|
|
else if (rep == "fray")
|
||
|
|
// cas d'une orientation automatique à partir de l'orientation d'un rayon
|
||
|
|
{cas_orientation=3;
|
||
|
|
lesMail->Modif_orientation_element(cas_orientation,lesRef);
|
||
|
|
}
|
||
|
|
else if ((rep == "0") || (rep == "o") || (rep == "O") || (rep == "f"))
|
||
|
|
{choix_valide = true;cas_orientation=0;}
|
||
|
|
else
|
||
|
|
cout << "\n la réponse : " << rep << " n'est pas utilisable, recommencez !";
|
||
|
|
};
|
||
|
|
// 3) récup du nombre actuellement actif d'où des maillages créés
|
||
|
|
int nb_maillages_actifs_finaux = lesMail->NbMaillage();
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
for (int i=nb_maillages_actifs_initiaux+1;i<=nb_maillages_actifs_finaux;i++)
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef,i);
|
||
|
|
}
|
||
|
|
else if ( (*ili) == creationMaillageSFE )
|
||
|
|
// cas de la création de maillage SFE
|
||
|
|
{
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| creation de maillage SFE |"
|
||
|
|
<< "\n| | "
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
|
||
|
|
// appel de l'utilitaire dans lesMaillages
|
||
|
|
lesMail->CreationMaillageSFE();
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef);
|
||
|
|
}
|
||
|
|
else if ( (*ili) == suppression_noeud_non_references )
|
||
|
|
// cas de la suppression des noeuds non référencés
|
||
|
|
{
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| suppression des noeuds non references |"
|
||
|
|
<< "\n| | "
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
|
||
|
|
// appel de l'utilitaire dans lesMaillages
|
||
|
|
lesMail->SuppressionNoeudNonReferencer(*lesRef);
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef);
|
||
|
|
}
|
||
|
|
else if ( (*ili) == renumerotation_des_noeuds )
|
||
|
|
// cas de la renumérotation des noeuds
|
||
|
|
{ // il s'agit ici de renuméroter les noeuds de chaques maillages, indépendamment
|
||
|
|
// de conditions linéaires et de conditions de contact
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| renumerotation des noeuds |"
|
||
|
|
<< "\n| | "
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
|
||
|
|
|
||
|
|
// l'algo a besoin des éléments frontières, on les crée si elles n'existent pas
|
||
|
|
lesMail->CreeElemFront();
|
||
|
|
// appel de l'utilitaire dans lesMaillages
|
||
|
|
bool changement = lesMail->Renumerotation(*lesRef);
|
||
|
|
// on met à jour le tableau indice pour LesContacts
|
||
|
|
lesContacts->Mise_a_jour_indice(lesMail->Indice());
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
// s'il y a eu quelque chose de changé
|
||
|
|
if (changement)
|
||
|
|
{if (ParaGlob::NiveauImpression() > 2)
|
||
|
|
cout << "\n ===>> sauvegarde des maillages en .her et .lis ";
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{cout << "\n ===>> pas de changement dans un maillage -> aucune sauvegarde ";
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else if ( (*ili) == fusion_de_noeuds )
|
||
|
|
// cas de la fusion de noeuds
|
||
|
|
{
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| fusion de noeuds |"
|
||
|
|
<< "\n| | "
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
// 2) on demande à l'utilisateur le rayon maxi en dessous duquel on va fusionner
|
||
|
|
double rayon=0.; // init
|
||
|
|
cout << "\n ++ choix de la distance en dessous de laquelle on fusionne les noeuds "
|
||
|
|
<< "\n deux noeuds sont fusionable s'ils appartiennent a des elements differents "
|
||
|
|
<< "\n et s'ils appartiennent a un meme maillage. "
|
||
|
|
<< "\n distances maxi pour la fusion ? ";
|
||
|
|
rayon = lect_double();
|
||
|
|
cout << "\n distance lue: "<< rayon << endl;
|
||
|
|
// appel de l'utilitaire dans lesMaillages
|
||
|
|
lesMail->Collapse_noeuds_proches(rayon,lesRef);
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef);
|
||
|
|
}
|
||
|
|
else if ( (*ili) == fusion_elements )
|
||
|
|
// cas de la fusion d'éléments
|
||
|
|
{
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| fusion d'elements |"
|
||
|
|
<< "\n| | "
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
// appel de l'utilitaire dans lesMaillages
|
||
|
|
lesMail->Collapse_element_supperpose(lesRef);
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef);
|
||
|
|
}
|
||
|
|
else if ( (*ili) == fusion_maillages )
|
||
|
|
// cas de la fusion de maillage
|
||
|
|
{ // 1) affichage
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| fusion de maillages |"
|
||
|
|
<< "\n| | "
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
// 2) on demande à l'utilisateur ce qu'il veut faire et on exécute
|
||
|
|
bool choix_valide = false;
|
||
|
|
List_io < string > lis_a_fusionner; // la liste des maillages à fusionner
|
||
|
|
string nom_nouveau_maillage = " "; // nom du nouveau maillage
|
||
|
|
int nbmail = lesMail->NbMaillage(); // les maillages actuellement enregistré
|
||
|
|
|
||
|
|
while (!choix_valide)
|
||
|
|
{ if (lis_a_fusionner.size() != 0)
|
||
|
|
{ cout << "\n liste des maillages a fusionner : ";
|
||
|
|
List_io < string >::iterator il,ilfin=lis_a_fusionner.end();
|
||
|
|
for (il = lis_a_fusionner.begin();il != ilfin; il++)
|
||
|
|
cout << (*il) << ", ";
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
cout << "\n =========== choix des maillages a fusionner ==============="
|
||
|
|
<< "\n liste des maillages disponibles (rep list)"
|
||
|
|
<< "\n vider la liste a fusionner (rep vlis)"
|
||
|
|
<< "\n nom du maillage issu de la fusion (rep nfus)"
|
||
|
|
<< "\n fusionner tous les maillages (rep to)"
|
||
|
|
<< "\n ajout d'un nom de maillage a fusionner (rep nafu)"
|
||
|
|
<< "\n fin (appel du programme de fusion) (rep f)";
|
||
|
|
string rep;
|
||
|
|
cout << "\n reponse ? "; rep = lect_return_defaut(false,"f");
|
||
|
|
if (rep == "list")
|
||
|
|
// affichage de la liste des maillages existants
|
||
|
|
{cout << "\n -- liste des maillages enregistres -- \n";
|
||
|
|
for (int i=1;i<=nbmail;i++)
|
||
|
|
cout << lesMail->NomMaillage(i) << " ";
|
||
|
|
cout << endl;
|
||
|
|
}
|
||
|
|
else if (rep == "vlis")
|
||
|
|
// on vide la liste
|
||
|
|
{lis_a_fusionner.erase(lis_a_fusionner.begin(), lis_a_fusionner.end());
|
||
|
|
}
|
||
|
|
else if (rep == "nfus")
|
||
|
|
// nom du maillage issu de la fusion
|
||
|
|
{cout << "\n nom du nouveau maillage : ";
|
||
|
|
nom_nouveau_maillage = lect_chaine(); cout << "\n nom lue: " << nom_nouveau_maillage << "\n";
|
||
|
|
}
|
||
|
|
else if (rep == "nafu")
|
||
|
|
// ajout d'un nom de maillage a fusionner
|
||
|
|
{string new_nom;
|
||
|
|
cout << "\n nom du maillage : ";
|
||
|
|
new_nom = lect_chaine();
|
||
|
|
// on vérifie que c'est bien un nom licite
|
||
|
|
if (!(lesMail->NumMaillage(new_nom)))
|
||
|
|
{ cout << "\n erreur : ce maillage n'existe pas ! ";}
|
||
|
|
else
|
||
|
|
{ // sinon c'est ok, on enregistre
|
||
|
|
lis_a_fusionner.push_back(new_nom);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else if (rep == "to")
|
||
|
|
// ajout de tous les noms de maillage
|
||
|
|
{for (int i=1;i<=nbmail;i++)
|
||
|
|
lis_a_fusionner.push_back(lesMail->NomMaillage(i));
|
||
|
|
}
|
||
|
|
else if ((rep == "0") || (rep == "o") || (rep == "O") || (rep == "f"))
|
||
|
|
{ if (nom_nouveau_maillage == " ")
|
||
|
|
{ cout << "\n ******* le nom du nouveau maillage reste a definir !! ***** " << endl;}
|
||
|
|
else
|
||
|
|
{ choix_valide = true;};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
cout << "\n la réponse : " << rep << " n'est pas utilisable, recommencez !";
|
||
|
|
};
|
||
|
|
// appel de l'utilitaire dans lesMaillages
|
||
|
|
lesMail->Fusion_maillages(lis_a_fusionner,nom_nouveau_maillage,lesRef);
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// récup du nombre actuellement actif d'où du dernier maillage créé
|
||
|
|
int nb_maillages_actifs_final = lesMail->NbMaillage();
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
|
||
|
|
// Affichage des donnees du dernier maillage dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef,nb_maillages_actifs_final);
|
||
|
|
}
|
||
|
|
else if ( (*ili) == cree_sous_maillage )
|
||
|
|
// cas de la création d'un sous maillage à partir d'une référence d'éléments
|
||
|
|
{ // 1) affichage
|
||
|
|
cout << "\n================================================================="
|
||
|
|
<< "\n| creation d'un sous maillages |"
|
||
|
|
<< "\n| a partir d'une ref d'elements | "
|
||
|
|
<< "\n================================================================="
|
||
|
|
<< endl;
|
||
|
|
// 2) on demande à l'utilisateur le nom de la référence
|
||
|
|
bool choix_valide = false;
|
||
|
|
string nom_nouveau_maillage = " "; // nom du nouveau maillage
|
||
|
|
string nom_ref = ""; // init
|
||
|
|
int num_mail_ref = 1; // init par défaut
|
||
|
|
|
||
|
|
while (!choix_valide)
|
||
|
|
{ cout << "\n =========== choix de la reference d'elements ==============="
|
||
|
|
<< "\n liste des ref d'elements disponibles (rep list)"
|
||
|
|
<< "\n nom de la ref d'element du sous maillage (rep nref)"
|
||
|
|
<< "\n nom du maillage associe a la ref (defaut: le premier)(rep noma)"
|
||
|
|
<< "\n nom du nouveau maillage (rep nmai)"
|
||
|
|
<< "\n fin (appel de la methode de creation) (rep f)";
|
||
|
|
string rep;
|
||
|
|
cout << "\n reponse ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
string nom_mail_ref(" ");
|
||
|
|
if (rep == "list")
|
||
|
|
// affichage de la liste des ref d'elements disponibles
|
||
|
|
{lesRef->Affiche(2,1); // 2 pour éléments, 1 pour affichage uniquement des noms
|
||
|
|
cout << endl;
|
||
|
|
}
|
||
|
|
else if (rep == "nref")
|
||
|
|
// non de la ref d'element du sous maillage
|
||
|
|
{cout << "\n nom de la ref d'element du sous maillage : ";
|
||
|
|
nom_ref = lect_chaine(); cout << "\n nom lue: " << nom_ref << "\n";
|
||
|
|
}
|
||
|
|
else if (rep == "noma")
|
||
|
|
// non du maillage associé à la référence
|
||
|
|
{cout << "\n nom du maillage associe a la ref : ";
|
||
|
|
nom_mail_ref = lect_chaine(); cout << "\n nom lue: " << nom_mail_ref << "\n";
|
||
|
|
}
|
||
|
|
else if (rep == "nmai")
|
||
|
|
// nom du nouveau maillage
|
||
|
|
{cout << "\n nom du nouveau maillage : ";
|
||
|
|
nom_nouveau_maillage = lect_chaine(); cout << "\n nom lue: " << nom_nouveau_maillage << "\n";
|
||
|
|
}
|
||
|
|
else if ((rep == "0") || (rep == "o") || (rep == "O") || (rep == "f"))
|
||
|
|
{ if (nom_nouveau_maillage == " ")
|
||
|
|
{ cout << "\n ******* le nom du nouveau maillage reste a definir !! ***** " << endl;}
|
||
|
|
else if (nom_ref == "")
|
||
|
|
{ cout << "\n ******* le nom de la ref d'elements reste a definir !! ***** " << endl;}
|
||
|
|
else if (nom_mail_ref != " ")
|
||
|
|
{ //on vérifie que le maillage existe
|
||
|
|
if (lesMail->NumMaillage(nom_mail_ref))
|
||
|
|
{ // on vérifie que la ref existe
|
||
|
|
if ( lesRef->Existe(nom_ref,&nom_mail_ref))
|
||
|
|
{ num_mail_ref = lesMail->NumMaillage(nom_mail_ref);
|
||
|
|
choix_valide = true;
|
||
|
|
} // là c'est ok
|
||
|
|
else
|
||
|
|
{ cout << "\n *** la reference "<< nom_ref << "du maillage "
|
||
|
|
<< nom_mail_ref <<" n'existe pas ?? " << endl;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ cout << "\n *** le maillage " << nom_mail_ref << " n'existe pas ?? "
|
||
|
|
<< endl;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ choix_valide = true;};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
cout << "\n la réponse : " << rep << " n'est pas utilisable, recommencez !";
|
||
|
|
};
|
||
|
|
// appel de l'utilitaire dans lesMaillages
|
||
|
|
lesMail->Cree_sous_maillage(num_mail_ref,lesRef,nom_ref,nom_nouveau_maillage);
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
// récup du nombre actuellement actif d'où du dernier maillage créé
|
||
|
|
int nb_maillages_actifs_final = lesMail->NbMaillage();
|
||
|
|
// ----- sort les informations sur fichiers
|
||
|
|
|
||
|
|
// Affichage des donnees du dernier maillage dans des fichiers dont le nom est construit
|
||
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
||
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef,nb_maillages_actifs_final);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
// pour des pb de sortie de résultat qui peuvent bloquer on met à zéro les degrés
|
||
|
|
// de liberté
|
||
|
|
lesMail->ZeroDdl(true);
|
||
|
|
tempsCalEquilibre.Arret_du_comptage(); // temps cpu
|
||
|
|
|
||
|
|
};
|
||
|
|
|