From 91879f296df5ef4dd6771d1a469ed00e67e8415b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?G=C3=A9rard=20Rio?= Date: Sun, 26 Sep 2021 17:51:23 +0200 Subject: [PATCH] introduction du main du programme Herezh++ et de la classe principale: "Projet" --- General/Projet.cc | 883 +++++++++++++++++++++++++++++++++++++++++++++ General/Projet.h | 222 ++++++++++++ General/Projet2.cc | 689 +++++++++++++++++++++++++++++++++++ General/herezh.cc | 443 +++++++++++++++++++++++ General/herezh.h | 79 ++++ 5 files changed, 2316 insertions(+) create mode 100644 General/Projet.cc create mode 100644 General/Projet.h create mode 100644 General/Projet2.cc create mode 100644 General/herezh.cc create mode 100644 General/herezh.h diff --git a/General/Projet.cc b/General/Projet.cc new file mode 100644 index 0000000..f0e981c --- /dev/null +++ b/General/Projet.cc @@ -0,0 +1,883 @@ + +// 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) . +// +// 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 . +// +// For more information, please consult: . + + +#include "Projet.h" +//#include "AlgoriNonDyna.h" +//#include "ImpliNonDynaCont.h" +//#include "AlgoriFlambLineaire.h" +//#include "AlgoInformations.h" +//#include "AlgoUtils.h" +//#include "AlgoriDynaExpli.h" +//#include "AlgoriNewmark.h" +//#include "Algori_chung_lee.h" +//#include "AlgoriDynaExpli_zhai.h" +//#include "Algori_tchamwa.h" +//#include "AlgoUmatAbaqus.h" +//#include "AlgoRungeKutta.h" +//#include "AlgoBonelli.h" +//#include "Algori_relax_dyna.h" +//#include "AlgoriCombine.h" +#include "CharUtil.h" +#include "MotCle.h" +#include "Banniere.h" + + // Constructeur par defaut (car les arguments sont par défauts +// il y a passage éventuelle d'argument : argc=le nombre d'argument +// argv : donne un tableau correspondant de mots clés + Projet::Projet (string & retour,int argc, const char * argv[]) : + paraGlob(NULL),entreePrinc(NULL),lesMaillages(NULL),algori(NULL) + ,lesRef(NULL),lesCourbes1D(NULL),lesFonctionsnD(NULL) + ,lesLoisDeComp(NULL),diversStockage(NULL),charge(NULL) + ,lesCondLim(NULL),lescontacts(NULL),resultats(NULL) + ,varExpor(NULL),tabAlgo() + ,tempsMiseEnDonnees() + + { + tempsMiseEnDonnees.Mise_en_route_du_comptage(); // comptage cpu + // initialisation par defaut de la classe des utilitaires de lecture + // lecture du nom de fichier principal d'entree + entreePrinc = new UtilLecture (argc,argv); + // dans le cas du mode de demande de renseignement (-help) de UtilLecture -> arrêt + if (entreePrinc->Lec_ent_info() == -100) + { cout << "\n *** bizarre: on a lue :\n "; + for (int i=0;i< argc;i++) + cout << (argv[i]) << " "; + cout << "\n*** on ne sait pas quoi faire !! "; + retour = "fin"; return; + }; + entreePrinc->OuvrirFichier(); // ouverture du fichier principal + int lec_ent_info = entreePrinc->Lec_ent_info(); + // traitement suivant le type d'entrée de données + switch (lec_ent_info) + {case -12 : // --------- cas de la construction shema XML d'entrée de données .info ---- + { InitConstructionSchemaXml(retour); + break; + } + case -11 : // ------------ cas d'une écriture d'un fichier de commande ---------- + { InitConstructionFichierCommande(retour); + break; + } + case 0 : // ------------ cas d'une entrée via un fichier .info ---------- + { InitEntreeFichierInfo(retour); + break; + } + case 1 : // ------------ cas d'une entrée via un fichier .base-info ---------- + { InitEntreeFichierBaseInfo(retour); + break; + } + default : + cout << "\nErreur : valeur incorrecte de lec_ent_info =" + << entreePrinc->Lec_ent_info() << " !\n"; + cout << "Projet::Projet () " << endl; + tempsMiseEnDonnees.Arret_du_comptage(); // fin comptage cpu + Sortie(1); + }; + tempsMiseEnDonnees.Arret_du_comptage(); // fin comptage cpu + }; + // destructeur + Projet::~Projet () + { if (paraGlob != NULL) delete paraGlob; // parametres globaux + if (entreePrinc != NULL) delete entreePrinc; // acces a la lecture du fichier principal + if (lesMaillages != NULL) delete lesMaillages; // description des maillages + if (algori != NULL) delete algori; // algorithme de calcul + if (lesRef != NULL) delete lesRef; // references des maillages + if (lesCourbes1D != NULL) delete lesCourbes1D; // courbes 1D + if (lesFonctionsnD != NULL) delete lesFonctionsnD; // courbes nD + if (lesLoisDeComp != NULL) delete lesLoisDeComp; // lois de comportement + if (diversStockage != NULL) delete diversStockage; // stockage divers + if (charge != NULL) delete charge; // chargement + if (lesCondLim != NULL) delete lesCondLim; // conditions limites + if (lescontacts != NULL) delete lescontacts; // le contact eventuel + if (resultats != NULL) delete resultats; // sortie des resultats + if (varExpor != NULL) delete varExpor; // définition des variables a exporter + int nbAlgo=tabAlgo.Taille(); + for (int i=2;i<=nbAlgo;i++) + if (tabAlgo(i)!= NULL) delete tabAlgo(i); + // fermeture du fichier base info si nécessaire + if (algori != NULL) + if (algori->Active_sauvegarde()) + entreePrinc->Fermeture_base_info(); + }; + +// définition d'un fichier de commandes +void Projet::Def_fichier_commande(string& ) + { + tempsMiseEnDonnees.Mise_en_route_du_comptage(); // comptage cpu + //On va proposer un menu + string rep=" "; + while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0")) + { + try + {cin.clear(); + cout + << "\n [c] -> para tres classique [-] para assez courants " + << "\n (0 ou f) (fin) " + << "\n (1)maillage(s)..........[c] (2)courbes 1D et fonction nD .......[-]" + << "\n (3)loi de comportement..[c] (4)divers stockages 1...............[c] " + << "\n (5)zones contact (6)efforts..........................[c]" + << "\n (7)cond limites cine ..[c] (8)cond limites lineaires " + << "\n (9)divers stockages 2 (10)initialisation .................[-]" + << "\n (11)type de chargement (12)parametres de controle..........[c]" + << "\n (13)type de fin fichier.[c] (14 ou ? ) informations " + << "\n "; + // procédure de lecture avec prise en charge d'un retour chariot + rep = lect_return_defaut(false,"f"); + // si la taille de rep == 0 cela veut dire que c'est un retour chariot + if (rep.size()==0) + {rep = "0"; + cout << "--> valeur: 0 "; + }; + + if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie directe + break; + int num = ChangeEntier(rep); + if (Minuscules(rep) == "?") + num = 14; + bool choix_valide=false; + if ((num >= 0)&&(num<=14)) + { choix_valide=true; } + else { cout << "\n Erreur on attendait un entier entre 0 et 14 !!, " + << "\n redonnez une bonne valeur" + << "\n ou taper f ou 0 pour arreter le programme"; + choix_valide=false; + } + switch (num) + { case 0: //pas de sous type + { break;} // normalement cela a déjà été filtré avant + case 1: // les maillage + { lesMaillages->Info_commande_lesMaillages(); // def des maillages et des references + break;} + case 2: // les courbes et fonction + { lesCourbes1D->Info_commande_lesCourbes1D(*entreePrinc); // def des courbes 1D + lesFonctionsnD->Info_commande_lesFonctions_nD(*entreePrinc); // def des courbes nD + break;} + case 3: // les lois de comp + { lesLoisDeComp->Info_commande_lesLoisDeComp(*entreePrinc,*lesRef); // def des lois + break;} + case 4: // divers stockage 1 + { diversStockage->Info_commande_DiversStockage1(*entreePrinc); + break;} + case 5: // contact + { lescontacts->Info_commande_LesContacts(*entreePrinc); + break;} + case 6: // les efforts + { charge->Info_commande_LesCharges1(*entreePrinc); + break;} + case 7: // les conditions limites cinématiques (CL) + { lesCondLim->Info_commande_LesCondLim1(*entreePrinc); + break;} + case 8: // les conditions limites linéaires (CLL) + { lesCondLim->Info_commande_LesCondLim2(*entreePrinc); + break;} + case 9: // divers stockage 2 + { diversStockage->Info_commande_DiversStockage2(*entreePrinc); // def des lois + break;} + case 10: // les conditions limites d'initialisation + { lesCondLim->Info_commande_LesCondLim3(*entreePrinc); + break;} + case 11: // le chargement général + { charge->Info_commande_LesCharges2(*entreePrinc); + break;} + case 12: // paramètres de contrôle + { algori->Info_commande_ParaAlgoControle(*entreePrinc); + break;} + case 13: // remonte + { resultats->Info_commande_Resultats(); // def des parametres de gestion de la sortie des resultats + break;} + default: + cout << "\n le cas "<Commande_pointInfo()); // pour simplifier + sort << "\n\n\n _fin_point_info_ \n \n " << endl; + // fermeture du fichier .info + entreePrinc->fermeture_pointInfo(); + tempsMiseEnDonnees.Arret_du_comptage(); // fin comptage cpu + }; + +// définition du fichier schema XML +void Projet::Def_fichier_SchemaXML(string& ) + { // récupération du flot dans lequel on écrit le schéma + ofstream* sort=entreePrinc->ShemaXML(); + // chaque classe s'occupe de gérer ses sorties de commandes + // la sortie s'effectue en plusieurs niveaux: premier niveau les classes de base + // niveau 2: les classes complexes etc... + for (int niveau=1;niveau<=nombre_maxi_de_type_de_Enum_IO_XML; niveau++) + { // écriture de séparateurs pour une lecture plus simple et def des éléments racines + Enum_IO_XML type_traitement_XML = Enum_IO_XML(niveau); + // tout d'abord le début de chaque traitement + switch (type_traitement_XML) + {case XML_TYPE_GLOBAUX : + { (*sort) << "\n " + << "\n " + << "\n "; + // pas de définition d'élément particulier + break; + } + case XML_IO_POINT_INFO : + { (*sort) << "\n " + << "\n " + << "\n "; + // définition d'un élément maître + (*sort) << "\n" + << "\n " + << "\n " + << "\n " + << "\n ******************************************************** " + << "\n ******** definition fichier de commande .info ******** " + << "\n ******************************************************** " + << "\n " + << "\n " + << "\n "; + break; + } + case XML_IO_POINT_BI : + { (*sort) << "\n " + << "\n " + << "\n "; + // définition d'un élément maître + (*sort) << "\n" + << "\n " + << "\n " + << "\n " + << "\n ******************************************************** " + << "\n ******** definition fichier restart .BI ******** " + << "\n ******************************************************** " + << "\n " + << "\n " + << "\n "; + break; + } + case XML_IO_ELEMENT_FINI : + { (*sort) << "\n " + << "\n " + << "\n "; + // définition d'un élément maître + (*sort) << "\n" + << "\n " + << "\n " + << "\n " + << "\n ************************************************************** " + << "\n ******** interface pour un element fini particulier ******** " + << "\n ************************************************************** " + << "\n " + << "\n " + << "\n "; + break; + } + case XML_ACTION_INTERACTIVE : + { (*sort) << "\n " + << "\n " + << "\n "; + // définition d'un élément maître + (*sort) << "\n" + << "\n " + << "\n " + << "\n " + << "\n ************************************************************** " + << "\n ******** interface pour les actions interactives ******** " + << "\n ************************************************************** " + << "\n " + << "\n " + << "\n "; + break; + } + case XML_STRUCTURE_DONNEE : + { (*sort) << "\n " + << "\n " + << "\n "; + // définition d'un élément maître + (*sort) << "\n" + << "\n " + << "\n " + << "\n " + << "\n ************************************************************** " + << "\n ******** interface : structures de donnees internes ******** " + << "\n ************************************************************** " + << "\n " + << "\n " + << "\n "; + break; + } + }; + // ++++++++++++++++ maintenant sortie relatives aux différentes entitées ++++++++++++++++ + // -- def de la dimension pour une sortie schema XML, def du type global + SchemaXML_dim(entreePrinc,type_traitement_XML); + varExpor->SchemaXML_VariablesExporters(entreePrinc,type_traitement_XML); + // cas de l'ensemble des algorithmes + int nb_algo=tabAlgo.Taille(); + for (int i=1;i<=nb_algo;i++) + tabAlgo(i)->SchemaXML_Algori(*sort,type_traitement_XML); + // la suite + SchemaXML_Type_de_base(*sort,type_traitement_XML); // les types de base + lesMaillages->SchemaXML_LesMaillages(*sort,type_traitement_XML); // def des maillages et des references + lesCourbes1D->SchemaXML_lesCourbes1D(*sort,type_traitement_XML); // def des courbes 1D + lesFonctionsnD->SchemaXML_lesFonctions_nD(*sort,type_traitement_XML); // def des courbes nD + /* lesLoisDeComp->SchemaXML_lesLoisDeComp(*entreePrinc,*lesRef); // def des lois + diversStockage->SchemaXML_diversStockage1(*entreePrinc,*lesRef); // premiere lecture des stockages divers + charge->SchemaXML_charge1(*entreePrinc,*lesRef); // lecture des actions exterieurs de chargement + lesCondLim->SchemaXML_lesCondLim1(*entreePrinc,*lesRef); // lecture des ddl bloques + diversStockage->SchemaXML_diversStockage2(*entreePrinc,*lesRef); // seconde lecture du stockage divers + lesCondLim->SchemaXML_lesCondLim2(*entreePrinc,*lesRef); // lecture des ddl d'initialisation + diversStockage->SchemaXML_diversStockage3(*entreePrinc,*lesRef); // lecture des masses additionnelles + charge->SchemaXML_charge2(*entreePrinc); // lecture du type d'application du chargement + algori->SchemaXML_algori(*entreePrinc); // lecture des parametres de controle de l'algorithme + resultats->SchemaXML_resultats(lesRef); // lecture des parametres de gestion de la sortie des resultats + // s'il y a des données externes sur les maillages nécessaires pour l'algorithme + if (algori->ExisteDonneesExternes()) + SchemaXML_algoriLectureDonneesExternes();*/ + // la fin de chaque traitement + switch (type_traitement_XML) + {case XML_TYPE_GLOBAUX : + { // pas de définition d'élément particulier + break; + } + case XML_IO_POINT_INFO: case XML_IO_POINT_BI: case XML_IO_ELEMENT_FINI: + case XML_ACTION_INTERACTIVE: + case XML_STRUCTURE_DONNEE: + { // fin de la définition d'un élément maître + (*sort) << "\n " + << "\n " + << "\n"; + break; + } + }; + }; + + // fin du schema + SchemaXML_fin(entreePrinc); + }; + +//------------------------------------ protegees ---------------------- + // lecture eventuelle de la dimension sinon elle est mise a trois +int Projet::LectureDimension() + { int dim; + int lec_ent_info = entreePrinc->Lec_ent_info(); + // traitement suivant le type d'entrée de données + if (lec_ent_info == 0) + // ------------ cas d'une entrée via un fichier .info ---------- + // on regarde si lle mot cle "dimension" existe + {if (strstr(entreePrinc->tablcar,"dimension")!=NULL) + {string mot; + *(entreePrinc->entree) >> mot >> dim; + if ((dim!=1) && (dim!=2) && (dim!=3)) + { cout << "\n erreur en lecture de la dimension du probleme "; + cout << " \n la dimension doit etre 1 ou 2 ou 3 , ici la valeur lue = " + << dim << " !! " << endl; + entreePrinc->MessageBuffer("** lecture de la dimension du probleme **"); + throw (UtilLecture::ErrNouvelleDonnee(-1)); + Sortie (1); + } + entreePrinc->NouvelleDonnee(); // pour la prochaine lecture + } + else + { dim = 3; // par defaut + cout << "\n mot clé dimension non trouvé, on retiend la dimension 3 par défaut"; + } + } + return dim; + }; + + // lecture eventuelle du niveau de sortie des commentaires +int Projet::LectureNiveauCommentaire() + { int niveau = ParaGlob::NiveauImpression(); + int lec_ent_info = entreePrinc->Lec_ent_info(); + // traitement suivant le type d'entrée de données + if (lec_ent_info == 0) + // ------------ cas d'une entrée via un fichier .info ---------- + // on regarde si lle mot cle "niveau_commentaire" existe + {if (strstr(entreePrinc->tablcar,"niveau_commentaire")!=NULL) + {string mot; + *(entreePrinc->entree) >> mot >> niveau; + entreePrinc->NouvelleDonnee(); // pour la prochaine lecture + } + } + return niveau; + }; + + +// -- def de la dimension pour une sortie sur un fichier de commande +int Projet::Info_commande_dimension(UtilLecture * entreePrinc) + { int retour; + //cout << "\n "; + cout << "\n ==> Dimension espace geometrique (defaut 3) : 1 2 ou 3 ? "; + string rep; bool choix_valide=false; + + while (!choix_valide) + { rep = "_"; + int c = std::cin.peek(); // peek character (sans changer le flux !!) + if (( c == EOF )||(c=='\n')) + {rep = "3";cout << "--> valeur: 3 "; // si c'est return on met "3" + c = getchar(); // on lit quand même le caractère + } + else // sinon on peut lire + {std::getline (std::cin,rep); + // a priori les prochaines lectures vont utilisées un getline + }; + // si la taille de rep == 0 cela veut aussi dire que c'est un retour chariot + if (rep.size()==0) + {rep = "3"; + cout << "--> valeur: 3 "; + }; + + if (rep == "1") { retour = 1; choix_valide=true;} + else if (rep == "2") {retour = 2;choix_valide=true;} + else if (rep == "3") {retour = 3;choix_valide=true;} + else if (rep == "f") {retour = 3;choix_valide=true;} + else if (rep == "fin_prog") Sortie(1); + else { cout << "\n Erreur on attendait 1 2 ou 3 !!, redonnez une bonne valeur" + << "\n ou taper fin_prog pour arreter le programme"; + choix_valide=false; + } + } + // écriture de la dimension + ofstream & sort = *(entreePrinc->Commande_pointInfo()); // pour simplifier +// // affichage de la banniere sur la sortie passée en argument +// Banniere::Sortie_banniere( sort); +// // puis affichage de la version +// ParaGlob::Sortie_Version(sort); sort << "\n \n"; +// sort << "\n#######################################################################" +// << "\n# fichier de commande #" +// << "\n \n \n" +// << "# --- commentaire sur l'objet du travail ???" +// << "\n \n \n" + sort << "\n#----------------------------------------------------" + << "\n# definition de la dimension de l'espace de travail |" + << "\n#----------------------------------------------------" + << "\n dimension " << retour + << endl; + return retour; + }; + +// -- def du niveau de commentaire pour une sortie sur un fichier de commande +int Projet::Info_commande_niveauCommentaire(UtilLecture * entreePrinc) + { int retour; + //cout << "\n "; + cout << "\n ==> Niveau de commentaire souhaitez (defaut 3) : 0 a 10 ? "; + string rep; bool choix_valide=false; + while (!choix_valide) + { rep = "_"; + int c = std::cin.peek(); // peek character (sans changer le flux !!) + if (( c == EOF )||(c=='\n')) + {rep = "3";cout << "--> valeur par defaut : 3 "; // si c'est return on met "3" + c = getchar(); // on lit quand même le caractère + } + else // sinon on peut lire + {std::getline (std::cin,rep); + // a priori les prochaines lectures vont utilisées un getline + }; + // si la taille de rep == 0 cela veut dire que c'est un retour chariot + if (rep.size()==0) + {rep = "3"; + cout << "--> valeur par defaut : 3 "; + }; + try + { if (rep == "fin_prog") {Sortie(1);} + else if (rep == "f") {retour = 3;} + // sinon + else {retour = ChangeEntier(rep);}; + if ((retour >= 0)&&(retour<=10)) + choix_valide=true; + else { cout << "\n Erreur on attendait un entier entre 0 et 10 !!, " + << "\n redonnez une bonne valeur" + << "\n ou taper fin_prog pour arreter le programme"; + choix_valide=false; + } + } + catch (ErrSortieFinale) + // cas d'une direction voulue vers la sortie + // on relance l'interuption pour le niveau supérieur + { ErrSortieFinale toto; + throw (toto); + } + catch (...)//(UtilLecture::ErrNouvelleDonnee erreur) + { cout << "\n Erreur on attendait un entier entre 0 et 10 !!, " + << "\n redonnez une bonne valeur" + << "\n ou taper fin_prog pour arreter le programme"; + choix_valide=false; + } + } //-- fin du while + // écriture du niveau de commentaire + ofstream & sort = *(entreePrinc->Commande_pointInfo()); // pour simplifier + sort << "\n#---------------------------------------------------------------" + << "\n# definition facultative du niveau d'impression (entre 0 et 10)|" + << "\n#---------------------------------------------------------------" + << "\n niveau_commentaire " << retour + << endl; + return retour; + }; + +// lecture éventuelle de l'indicateur de version +void Projet::LectureVersion() + { if ( (strstr(entreePrinc->tablcar,"version ")!=NULL) + || (strstr(entreePrinc->tablcar,"numero_version ")!=NULL)) + { // lecture de la version sur l'entrée passée en argument + ParaGlob::Lecture_Version((*(entreePrinc->entree))); + entreePrinc->NouvelleDonnee(); // preparation du flot + } + }; + +// lecture éventuelle de l'indicateur de langue +void Projet::LectureLangue() + { if (strstr(entreePrinc->tablcar,"lang ")!=NULL) + { // lecture de l'indicateur de langue sur l'entrée passée en argument + ParaGlob::Lecture_Langue((*(entreePrinc->entree))); + entreePrinc->NouvelleDonnee(); // preparation du flot + } + }; + +// -- def de l'entête pour une sortie schema XML +void Projet::SchemaXML_entete(UtilLecture * entreePrinc) + { if (ParaGlob::NiveauImpression() >= 1) + cout << "\n entete et dimension "; + if (ParaGlob::NiveauImpression() >= 8) + cout << " Projet::SchemaXML_entete(...) "; + ofstream & sort = *(entreePrinc->ShemaXML()); // récup du fichier + // sortie de l'entête + sort << "" + << "\n"; + + sort << "\n" + << "\n " + << "\n schema XML genere automatiquement par Herezh++, permettant de dialoguer avec Herezh++" + << "\n ceci en utilisant une syntaxe XML pour l'ensemble des entrees sorties " + << "\n " + << "\n"; + // targetNamespace="http://schema.morphon.com/2002/markup" + // elementFormDefault="qualified" + // xmlns:tns="http://schema.morphon.com/2002/markup"> + + }; +// -- def de la fin pour une sortie schema XML +void Projet::SchemaXML_fin(UtilLecture * entreePrinc) + { // écriture de la fin de fichier + // récup du fichier + ofstream & sort = *(entreePrinc->ShemaXML()); + sort << "\n" << endl; // fermeture du schéma + // fermeture du fichier + entreePrinc->fermetureSchemaXML(); + }; + +// -- def de la dimension pour une sortie schema XML suivant le type d'io +void Projet::SchemaXML_dim(UtilLecture * entreePrinc,Enum_IO_XML enuIO_XML) + { // définition de la dimension dans le fichier .info + ofstream & sort = *(entreePrinc->ShemaXML()); // récup du fichier + // choix en fonction de l'io + switch (enuIO_XML) + {case XML_TYPE_GLOBAUX: // cas de la sortie du type global + {sort << "\n" + << "\n " + << "\n " + << "\n definition de la dimension du probleme 1 2 ou 3" + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; + } + default : // pour tous les autres cas on sort un élément pour définir la dimension + sort << "\n "; + }; + }; + +// ---- fonctions d'aides pour le constructeur de Projet ---- +// démarrage: cas de la construction du schema XML +void Projet::InitConstructionSchemaXml(string & retour) +{ retour = "def_schema_XML"; + // les parametres globaux + // -- def de l'entête pour une sortie schema XML + SchemaXML_entete(entreePrinc); + int dim = 3; // par défaut pour renseigner ParaGlob + // -- niveau de commentaire + int niveau = 5; + paraGlob = new ParaGlob (dim) ; // initialisation a la dimension + + // modif éventuelle du niveau de commentaire précédemment lue + if (ParaGlob::NiveauImpression() != niveau) paraGlob->Change_niveau_impression(niveau); + // def des valeurs des constantes en fonction de la dimension + ConstantesTenseur(dim); + // def du type de calcul: ici c'est de type DEF_SCHEMA_XML, la méthode le sait + // en intérogeant entreePrinc + paraGlob->Info_commande_TypeCalcul((UtilLecture&) *entreePrinc); + // définition de l'ensemble des algorithmes + tabAlgo.Change_taille(13); + // par défaut le premier est l'algo courant + tabAlgo = Algori::New_tous_les_Algo + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul(),(UtilLecture&) *entreePrinc); + algori = tabAlgo(1); + +{ /* + algori = new AlgoriNonDyna + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul(),(UtilLecture&) *entreePrinc); + tabAlgo(1)=algori; + tabAlgo(2) = new ImpliNonDynaCont + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul(),(UtilLecture&) *entreePrinc); + tabAlgo(3) = new AlgoriFlambLineaire + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul(),(UtilLecture&) *entreePrinc); + tabAlgo(4) = new AlgoInformations + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul(),(UtilLecture&) *entreePrinc); + tabAlgo(5) = new AlgoUtils + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul(),(UtilLecture&) *entreePrinc); + tabAlgo(6) = new AlgoriDynaExpli + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul() ,(UtilLecture&) *entreePrinc); + tabAlgo(7) = new AlgoriTchamwa + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul() ,(UtilLecture&) *entreePrinc); + tabAlgo(8) = new Algori_chung_lee + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul() ,(UtilLecture&) *entreePrinc); + tabAlgo(9) = new AlgoriDynaExpli_zhai + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul() ,(UtilLecture&) *entreePrinc); + tabAlgo(10) = new AlgoriNewmark + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul() ,(UtilLecture&) *entreePrinc); + tabAlgo(11) = new AlgoUmatAbaqus + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul() ,(UtilLecture&) *entreePrinc); + tabAlgo(12) = new AlgoriRungeKutta + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul() ,(UtilLecture&) *entreePrinc); + tabAlgo(13) = new AlgoriCombine + (paraGlob->Avec_typeDeCalcul(),paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul() ,(UtilLecture&) *entreePrinc); + */ }; + + // def des classes generales + lesRef = new LesReferences ; //def des reference + lesCourbes1D = new LesCourbes1D ; // def des courbes1D + lesFonctionsnD = new LesFonctions_nD(lesCourbes1D); // def des courbes nD + lesMaillages = new LesMaillages (entreePrinc,paraGlob,lesRef);// def des maillages + lesLoisDeComp = new LesLoisDeComp ; // def des lois de comportement + diversStockage = new DiversStockage ; // stockage divers + charge = new Charge ; // chargement + lesCondLim = new LesCondLim ; // conditions limites + resultats = new Resultats(entreePrinc) ; // sortie des resultats + lescontacts = new LesContacts; // les contacts éventuelles + cout << "\n !!sortie schema XML: en cours de d\'eveloppement"; +}; + +// démarrage: cas d'une écriture d'un fichier de commande +void Projet::InitConstructionFichierCommande(string & retour) + { retour = "def_fichier_commande"; + // les parametres globaux + // -- def exportation de constantes et variables utilisateurs + varExpor = new VariablesExporter() ; + varExpor->Info_commande_VariablesExporters(entreePrinc); + + // -- def de la dimension + int dim = Info_commande_dimension(entreePrinc); + // -- niveau de commentaire + int niveau = Info_commande_niveauCommentaire(entreePrinc); + paraGlob = new ParaGlob (dim) ; // initialisation a la dimension + // modif éventuelle du niveau de commentaire précédemment lue + if (ParaGlob::NiveauImpression() != niveau) paraGlob->Change_niveau_impression(niveau); + // def des valeurs des constantes en fonction de la dimension + ConstantesTenseur(dim); + // def du type de calcul et éventuellement des sous-types éventuel + // indiquant qu'il y a par exemple + // un calcul d'erreur, remonté au contrainte, relocation etc... + paraGlob->Info_commande_TypeCalcul((UtilLecture&) *entreePrinc); + // définition d'un algorithme pour l'affichage des données particulières + algori = Algori::New_Agori + (paraGlob->TypeCalcul_maitre(),paraGlob->Avec_typeDeCalcul() + ,paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul(),(UtilLecture&) *entreePrinc + ); + + // def des classes generales + lesRef = new LesReferences ; //def des reference + lesCourbes1D = new LesCourbes1D ; // def des courbes1D + lesFonctionsnD = new LesFonctions_nD(lesCourbes1D); // def des courbes nD + lesMaillages = new LesMaillages (entreePrinc,paraGlob,lesRef);// def des maillages + lesLoisDeComp = new LesLoisDeComp ; // def des lois de comportement + diversStockage = new DiversStockage ; // stockage divers + charge = new Charge ; // chargement + lesCondLim = new LesCondLim ; // conditions limites + resultats = new Resultats(entreePrinc) ; // sortie des resultats + lescontacts = new LesContacts; // les contacts éventuelles + }; + +// démarrage: cas d'une entrée via un fichier .info +void Projet::InitEntreeFichierInfo(string & retour) + {try + { retour = "calcul_elements_finis"; + // les parametres globaux + // lecture éventuelle de l'indicateur de version + entreePrinc->NouvelleDonnee(); // preparation du flot + LectureVersion(); // lecture éventuelle du numéro de version + LectureLangue(); // lecture éventuelle de l'indicateur de langue + // lecture éventuelle de constantes utilisateur + // et variables à exporter en grandeur globale + varExpor = new VariablesExporter(); + varExpor->LectureVariablesExporter(entreePrinc); + // puis dimension .... + int dim = LectureDimension(); // lecture eventuelle de la dimension sinon = 3 par defaut + int niveau = LectureNiveauCommentaire(); // lecture eventuelle du niveau de commentaire + paraGlob = new ParaGlob (dim) ; // initialisation a la dimension + // modif éventuelle du niveau de commentaire précédemment lue + if (ParaGlob::NiveauImpression() != niveau) paraGlob->Change_niveau_impression(niveau); + // dans le cas où il y a une différence de niveau de version message de warning... non , pas utile !! + // insertion et stockage des constantes utilisateur au niveau de ParaGlob + // idem pour les variables à exporter + varExpor->InsertConstVarUtilisateur_dans_globale(); + // def des valeurs des constantes internes en fonction de la dimension + ConstantesTenseur(dim); + // lecture du type de calcul sans modification du flux d'entree + // ainsi que lecture d'un sous type éventuel indiquant qu'il y a par exemple + // un calcul d'erreur, remonté au contrainte, relocation etc... + // lecture du type de calcul sans modification du flux d'entree + paraGlob->LecTypeCalcul((UtilLecture&) *entreePrinc) ; + // def de l'algorithme + algori = Algori::New_Agori + (paraGlob->TypeCalcul_maitre(),paraGlob->Avec_typeDeCalcul() + ,paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul(),(UtilLecture&) *entreePrinc + ); + + // dans le cas où un grand nombre d'information nécessaire pour l'algorithme + // est stocké de manière externe sur un fichier + // exemple : calcul d'erreur a partir + // d'un champ d'information stocké de manière externe sur un fichier + // l'acquisition du (ou des) lieu(x) (flot) où sont stocké ces infos est effectuée + // ce lieu fait parti des paramètres de l'algorithme + //// entreePrinc->NouvelleDonnee(); + // preparation du flot sur un nouveau mot clé s'il n'est pas déjà sur un mot clé + MotCle motCle; // ref aux mots cle + while ( !motCle.SimotCle(entreePrinc->tablcar)) + {entreePrinc->NouvelleDonnee(); }; + // def de flot externe + algori->DefFlotExterne(entreePrinc); + + // appel d'une procedure qui definit un exemplaire de chaque element + // pour que l'edition de lien est lieu effectivement + // DefElement(); + // def des classes generales + lesRef = new LesReferences ; //def des references + lesCourbes1D = new LesCourbes1D ; // def des courbes1D + lesFonctionsnD = new LesFonctions_nD(lesCourbes1D); // def des courbes nD + lesMaillages = new LesMaillages (entreePrinc,paraGlob,lesRef);// def des maillages + lesLoisDeComp = new LesLoisDeComp ; // def des lois de comportement + diversStockage = new DiversStockage ; // stockage divers + charge = new Charge ; // chargement + lesCondLim = new LesCondLim ; // conditions limites + resultats = new Resultats(entreePrinc) ; // sortie des resultats + lescontacts = new LesContacts; // les contacts éventuelles + } + catch (UtilLecture::ErrNouvelleDonnee erreur) + { if ( erreur.lecture == 1) + { cout << "\n fin de fichier atteinte "; + cout << " Il manque des informations !!!! " << endl; + entreePrinc->MessageBuffer("** lecture du type d\'algorithme **"); + Affiche(); + Sortie (1); + } + else if ( erreur.lecture == -1 ) + { cout << "\n erreur de lecture, "; + // cout << " la derniere ligne lue du fichier est : \n "; + // cout << entreePrinc->tablcar << endl; + entreePrinc->MessageBuffer("** lecture du type d\'algorithme **"); + Affiche(); + Sortie (1); + } + else + { cout << "\n erreur de lecture inconnue "; + // cout << " la derniere ligne lue du fichier est : \n "; + // cout << entreePrinc->tablcar << endl; + entreePrinc->MessageBuffer("** lecture du type d\'algorithme **"); + Affiche(); + Sortie (1); + }; + }; + }; + +// démarrage: cas d'une entrée via un fichier .base-info +void Projet::InitEntreeFichierBaseInfo(string & retour) + { retour = "calcul_elements_finis"; + // les parametres globaux + paraGlob = new ParaGlob () ; // construction par défaut + int cas = 1; + // lecture éventuelle de variables à exporter en grandeur globale + varExpor = new VariablesExporter(); + varExpor->Lecture_base_info(*(entreePrinc->Ent_BI()),cas); + // lecture de la dimension et du type de calcul + paraGlob->Lecture_base_info(*(entreePrinc->Ent_BI()),cas); + int dim = paraGlob->Dimension (); // récup de la dimension + // def des valeurs des constantes en fonction de la dimension + ConstantesTenseur(dim); + // def de l'algorithme + algori = Algori::New_Agori + (paraGlob->TypeCalcul_maitre(),paraGlob->Avec_typeDeCalcul() + ,paraGlob->LesSousTypesDeCalcul() + ,paraGlob->Avec_soustypeDeCalcul(),(UtilLecture&) *entreePrinc + ); + // def des classes generales + lesRef = new LesReferences ; //def des reference + lesCourbes1D = new LesCourbes1D ; // def des courbes1D + lesFonctionsnD = new LesFonctions_nD(lesCourbes1D); // def des courbes nD + lesMaillages = new LesMaillages (entreePrinc,paraGlob,lesRef);// def des maillages + lesLoisDeComp = new LesLoisDeComp ; // def des lois de comportement + diversStockage = new DiversStockage ; // stockage divers + charge = new Charge ; // chargement + lesCondLim = new LesCondLim ; // conditions limites + resultats = new Resultats(entreePrinc) ; // sortie des resultats + lescontacts = new LesContacts; // les contacts éventuelles + }; + + + diff --git a/General/Projet.h b/General/Projet.h new file mode 100644 index 0000000..1d99c00 --- /dev/null +++ b/General/Projet.h @@ -0,0 +1,222 @@ + +// 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) . +// +// 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 . +// +// For more information, please consult: . + +/************************************************************************ + * * + * DATE: 15/01/97 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * CLASSE: Projet * + * $ * + * BUT: definition des operations de haut niveau : * + * Lecture, Calcul, Sortie des Resultats. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * * + * $ * + * * + ************************************************************************/ + #ifndef PROJET_H + #define PROJET_H + #include +//#include "Debug.h" +#ifndef ENLINUX_STREAM + #include // pour le flot en memoire centrale +#else + #include // pour le flot en memoire centrale +#endif + #include "UtilLecture.h" + #include "LesMaillages.h" + #include "ParaGlob.h" +// pour la definition de nouveaux tenseurs +#include "NevezTenseur.h" +// "DefValConsTens.h" +// est a placer dans le fichier qui defini les valeurs des constantes +// des tenseurs +# include "DefValConsTens.h" + +#include "Algori.h" +#include "LesReferences.h" +#include "LesLoisDeComp.h" +#include "LesCourbes1D.h" +#include "LesFonctions_nD.h" +#include "DiversStockage.h" +#include "Charge.h" +#include "LesCondLim.h" +#include "Resultats.h" +#include "LesContacts.h" +#include "Enum_IO_XML.h" +#include "VariablesExporter.h" + +//------------------------------------------------------------------ +//! definition des operations de haut niveau : Lecture, Calcul, Sortie des Resultats. +//------------------------------------------------------------------ +/// \author Gérard Rio +/// \version 1.0 +/// \date 15/01/97 + + + class Projet + { + public: + // -------------- constructeurs ------------------ : + // défaut inutilisable + Projet () {cout << "\n erreur constructeur de Projet"; Sortie(1);}; + + // ++ le constructeur officiel ++ + // il y a passage éventuelle d'argument : argc=le nombre d'argument + // argv : donne un tableau correspondant de mots clés + Projet (string& retour,int argc=0, const char * argv[] = NULL); + // -------------- destructeur ------------------ : + ~Projet (); + // -------------- methodes ------------------ : + // lecture initiale des informations + void Lecture(); + // lectures secondaires éventuelles: ramène true s'il y a effectivement + // une lecture secondaire, qui donc modifie la lecture initiale + bool Lecture_secondaire(); + + // calculs + void Calcul (); + + // type de calcul + EnumTypeCalcul TypeDeCalcul() const {return algori->TypeDeCalcul();}; + + // sortie des resultats + void SortieDesResultats (); + + // visualisation (éventuelle) + void Visualisation_interactive (); + + // définition d'un fichier de commandes + void Def_fichier_commande(string& retour); + + // définition du fichier schema XML + void Def_fichier_SchemaXML(string& ); + + // fermeture des fichiers de visualisation liés au projet + void FermetureFichiersVisualisation(); + + // sortie sur fichier des temps cpu + // retourne un pointeur sur UtilLecture pour la récupération du fichier + // de temps, qui peut ainsi être utilisé par la méthode appelant + UtilLecture * Sortie_temps_cpu(); + + // def du fichier des temps cpu + // puis retourne un pointeur sur UtilLecture pour la récupération du fichier + // de temps, qui peut ainsi être utilisé par la méthode appelant + UtilLecture * Def_sortie_temps_cpu(); + + // une méthode qui a pour objectif de terminer tous les comptages, utile + // dans le cas d'un arrêt impromptu + void Arret_du_comptage_CPU(); + + private : + + // VARIABLES PROTEGEES : + ParaGlob * paraGlob; // parametres globaux + UtilLecture * entreePrinc; // acces a la lecture du fichier principal + LesMaillages * lesMaillages; // description des maillages + Algori* algori; // algorithme de calcul + LesReferences* lesRef; // references des maillages + LesCourbes1D* lesCourbes1D; // courbes 1D + LesFonctions_nD* lesFonctionsnD; // les fonctions multi-dimensionnelles + LesLoisDeComp* lesLoisDeComp; // lois de comportement + DiversStockage* diversStockage; // stockage divers + Charge* charge; // chargement + LesCondLim* lesCondLim; // conditions limites + LesContacts* lescontacts; // le contact eventuel + Resultats* resultats; // sortie des resultats + VariablesExporter* varExpor; // variables exportées globalement + + Tableau tabAlgo; // pour le schema XML + + Temps_CPU_HZpp tempsMiseEnDonnees; // TempsCpu + + // METHODES PROTEGEES : + // lecture eventuelle de la dimension sinon elle est mise a trois + int LectureDimension(); + // lecture eventuelle du niveau de sortie des commentaires + int LectureNiveauCommentaire(); + // affichage de toutes les informations lue + void Affiche() const ; + // procedure qui definit un exemplaire de chaque element + // pour que l'edition de lien est lieu effectivement + // void DefElement(); + + // lecture des données externes pour chaque entitée gérée par le projet + // type indique le type de données externes à lire + void LectureDonneesExternes(); + + + // -- def de la dimension pour une sortie sur un fichier de commande + int Info_commande_dimension(UtilLecture * entreePrinc); + // -- def du niveau de commentaire pour une sortie sur un fichier de commande + int Info_commande_niveauCommentaire(UtilLecture * entreePrinc); + + // -- def de l'entête pour une sortie schema XML + void SchemaXML_entete(UtilLecture * entreePrinc); + // -- def de la fin pour une sortie schema XML + void SchemaXML_fin(UtilLecture * entreePrinc); + // -- def de la dimension pour une sortie schema XML suivant le type d'io + void SchemaXML_dim(UtilLecture * entreePrinc,Enum_IO_XML enuIO_XML); + // sortie du schemaXML: en fonction de enu + // ceci pour tous les types de base + void SchemaXML_Type_de_base(ofstream& sort,const Enum_IO_XML enu); + + void LectureVersion(); // lecture éventuelle de l'indicateur de version + void LectureLangue(); // lecture éventuelle de l'indicateur de langue + + // ---- fonctions d'aides pour le constructeur de Projet ---- + // démarrage: cas de la construction du schema XML + void InitConstructionSchemaXml(string & retour); + // démarrage: cas d'une écriture d'un fichier de commande + void InitConstructionFichierCommande(string & retour); + // démarrage: cas d'une entrée via un fichier .info + void InitEntreeFichierInfo(string & retour); + // démarrage: cas d'une entrée via un fichier .base-info + void InitEntreeFichierBaseInfo(string & retour); + }; + + #endif diff --git a/General/Projet2.cc b/General/Projet2.cc new file mode 100644 index 0000000..51ccf83 --- /dev/null +++ b/General/Projet2.cc @@ -0,0 +1,689 @@ + +// 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) . +// +// 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 . +// +// For more information, please consult: . + + +#include "Projet.h" +#include "AlgoriNonDyna.h" +#include "ImpliNonDynaCont.h" +#include "AlgoriFlambLineaire.h" +#include "AlgoInformations.h" +#include "AlgoUtils.h" +#include "AlgoriDynaExpli.h" +#include "AlgoriNewmark.h" +#include "Algori_chung_lee.h" +#include "AlgoriDynaExpli_zhai.h" +#include "Algori_tchamwa.h" +#include "AlgoriCombine.h" +#include "CharUtil.h" +#include "MotCle.h" +#include "Banniere.h" +// les types de bases +#include "Coordonnee.h" +#include "Coordonnee1.h" +#include "Coordonnee2.h" +#include "Coordonnee3.h" +// handler d'exception +#include "Handler_exception.h" + + + + // lecture initiale des donnees + void Projet::Lecture () + {tempsMiseEnDonnees.Mise_en_route_du_comptage(); // comptage cpu + bool fr = ParaGlob::Francais(); // pour simplifier + try + { //il y a deux types d'entrée de donnée soit via un fichier info + // soir via via base info + int lec_ent_info = entreePrinc->Lec_ent_info(); + switch (lec_ent_info) + {case 0 : // ------- lecture dans le fichier info ----------------- + { + // il s'agit des données initiales. Par exemple si l'on veut effectuer un restart + // celui-ci sera effectué dans l'algorithme avant le début du calcul mais après + // la mise en cohérence des données + lesMaillages->LectureLesMaillages(); // lecture des maillages et des references + lesCourbes1D->Lecture(*entreePrinc); // lecture des courbes 1D + lesFonctionsnD->Lecture(*entreePrinc); // lecture des courbes nD + lesLoisDeComp->LecturelesLoisDeComp(*entreePrinc,*lesRef,*lesCourbes1D,*lesFonctionsnD); // lecture des lois + diversStockage->Lecture1(*entreePrinc,*lesRef); // premiere lecture des stockages divers + // lecture éventuelle des zones de contact et auto-contact si nécessaire + if(lescontacts != NULL) lescontacts->Lecture_zone_contact(*entreePrinc,*lesRef); + charge->Lecture1(*entreePrinc,*lesRef,*lesCourbes1D,*lesFonctionsnD); // lecture des actions exterieurs de chargement + lesCondLim->Lecture1(*entreePrinc,*lesRef); // lecture des ddl bloques + diversStockage->Lecture1(*entreePrinc,*lesRef); // seconde lecture du stockage divers + lesCondLim->Lecture2(*entreePrinc,*lesRef); // lecture des conditions limites linéaires + lesCondLim->Lecture3(*entreePrinc,*lesRef); // lecture des ddl d'initialisation + diversStockage->Lecture2(*entreePrinc,*lesRef); // lecture des masses additionnelles + charge->Lecture2(*entreePrinc,*lesCourbes1D,*lesFonctionsnD); // lecture du type d'application du chargement + algori->Lecture(*entreePrinc,*paraGlob,*lesMaillages); // lecture des parametres de controle de l'algorithme + resultats->Lecture(lesRef); // lecture des parametres de gestion de la sortie des resultats + // s'il y a des données externes sur les maillages nécessaires pour l'algorithme + if (algori->ExisteDonneesExternes()) + LectureDonneesExternes(); + // on garde en mémoire que l'on vient de faire une lecture primaire + paraGlob->ChangeEtatDeLaLecturePointInfo(0); + ////----- debug + // // on écrit la connection de l'élément 55 + // Element& el = lesMaillages->Element_LesMaille(1, 55); + // const Tableau& tabi = el.Tab_noeud_const(); + // cout << "\n *** connection de l'element 55: "; + // for (int i=1;i<=tabi.Taille();i++) cout << " "<Num_noeud(); + // cout << " Projet::Lecture () " << endl; + ////---fin debug + break; + } + case 1 : // ------- lecture dans base_info ----------------- + {// cas d'un démarrage à partir de base_info + // lecture initiale + algori->Lecture_base_info(lec_ent_info,lesMaillages,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp + ,diversStockage,charge,lesCondLim,lescontacts,resultats); + break; + } + default : + { if (fr){cout << "\nErreur : valeur incorrecte de lec_ent_info!\n";} + else {cout << "\nError : incorrect value of lec_ent_info!\n";}; + cout << "Projet::Lecture ()" + << " lec_ent_info= " << lec_ent_info << endl; + tempsMiseEnDonnees.Arret_du_comptage(); // fin comptage cpu + Sortie(1); + } + }; + if (fr){cout << "\n ======== fin de la lecture, Projet::Lecture( ...===========\n" << endl;} + else {cout << "\n ======== end of the reading, Projet::Lecture( ...===========\n" << endl;}; + } + catch (UtilLecture::ErrNouvelleDonnee erreur) + { if ( erreur.lecture == 1) + { if (fr){cout << "\n ========lecture terminee, Projet::Lecture(" + << " fin de fichier atteinte ======== " << endl; } + else {cout << "\n ======== the reading is ended, Projet::Lecture(" + << " the end of the file is reached ======== " << endl; }; + } + else + {cout << "\n ===============================================\n" ; + // on sort tous les informations lues par défaut + if (fr){cout << "\n **** erreur en lecture, voulez-vous sortir les informations actuellement lues ?"; + cout << " rep (o ou n) ";} + else {cout << "\n **** error in reading, do you want to print the data already read ? "; + cout << " answer yes (y) or not (n) ";}; + string toto; +// toto= lect_chaine(); + toto = lect_o_n(true); + if ((toto == "o")||(toto=="O")||(toto=="y")||(toto=="Y")) + Affiche(); + tempsMiseEnDonnees.Arret_du_comptage(); // fin comptage cpu + Sortie(0); + }; + } + catch (ErrSortieFinale) + // cas d'une direction voulue vers la sortie + // on relance l'interuption pour le niveau supérieur + { ErrSortieFinale toto; + throw (toto); + } + catch ( ... ) + { if (fr){cout << "\n ======== erreur inconnue en lecture ===== Projet::Lecture(.." << endl;} + else {cout << "\n ======== unknown error in reading ===== Projet::Lecture(.." << endl;} + // on sort tous les informations lues par défaut + if (fr){cout << "\n **** erreur en lecture, voulez-vous sortir les informations actuellement lues ?"; + cout << " rep (o ou n) ";} + else {cout << "\n **** error in reading, do you want to print the data already read ? "; + cout << " answer yes (y) or not (n) ";}; + + string toto; toto= lect_chaine(); + if ((toto == "o")||(toto=="O")||(toto=="y")||(toto=="Y")) Affiche(); + tempsMiseEnDonnees.Arret_du_comptage(); // fin comptage cpu + Sortie(0); + }; + // recopie eventuelle de la lecture + if (resultats->Copie()) + Affiche(); + tempsMiseEnDonnees.Arret_du_comptage(); // fin comptage cpu + }; + +// lectures secondaires éventuelles: ramène true s'il y a effectivement +// une lecture secondaire, qui donc modifie la lecture initiale +bool Projet::Lecture_secondaire() +{ tempsMiseEnDonnees.Mise_en_route_du_comptage(); // comptage cpu + // on regarde s'il y a une suite à lire dans le .info + MotCle motCle; // ref aux mots cle + bool fr = ParaGlob::Francais(); // pour simplifier + + if (strstr(entreePrinc->tablcar,"-fin_point_info_")!=NULL) + // il faut s'arrêter, + return false; + + // on se positionne sur un mot cle + try {while ( !motCle.SimotCle(entreePrinc->tablcar)) + entreePrinc->NouvelleDonnee(); + } + catch (UtilLecture::ErrNouvelleDonnee errnewdonnee) + {if (errnewdonnee.lecture == 1) + { cout << "\n fin de lecture de tous les fichiers atteint ";} + else if (errnewdonnee.lecture == -1) + { cout << "\n erreur de lecture en fermeture de fichier ";} + // on arrête le processus + return false; + }; + + // dans le cas où on rencontre un ordre de pause on appelle le handler d'exception + bool pause_lue=false; + while (strstr(entreePrinc->tablcar,"_pause_point_info_")!=NULL) + { if (fr){cout << "\n\n !!======== pause demandee ========!! " << endl; } + else {cout << "\n\n !!======== pause asked ========!! " << endl; }; + Handler_signal(0);pause_lue=true; + // on passe une ligne + entreePrinc->NouvelleDonnee(); + + }; + + // dans le cas où on a forcé une lecture secondaire, il faut fermer le fichier + // et le réouvrire et se positionner à la bonne place + if (paraGlob->EtatDemandeLectureSecondaireInPointInfo() > 0) + // raffraichir le dernier fichier de lecture .info en cours + // il y a fermeture puis ouverture au même endroit du fichier .info + entreePrinc->Raffraichir_pointInfo(); + // si on vient d'une pause, on passe une ligne jusqu'à un mot clé + if (pause_lue) + { while ( !motCle.SimotCle(entreePrinc->tablcar)) + entreePrinc->NouvelleDonnee(); + pause_lue = false; // mise à jours au cas où + }; + + bool lecture_secondaire = false; + if (strstr(entreePrinc->tablcar,"_suite_point_info_")!=NULL) + {if (ParaGlob::NiveauImpression() >= 4) + cout << " debut eventuel de lectures secondaires a la fin du .info " << endl; + try + { // pour l'instant les changements en lecture secondaire ne concerne qu'un nombre restreind de cas + entreePrinc->NouvelleDonnee(); // on passe le mot clé + // on lit tant qu'il n'y a pas de mot clé fin ou que l'on n'est pas arrivé à la fin du fichier + while ((strstr(entreePrinc->tablcar,"_suite_point_info_")==NULL) + && (strstr(entreePrinc->tablcar,"_pause_point_info_")==NULL) + && (strstr(entreePrinc->tablcar,"_fin_point_info_")==NULL)) + { // on indique en mémoire que l'on fait une lecture secondaire + paraGlob->ChangeEtatDeLaLecturePointInfo(paraGlob->EtatDeLaLecturePointInfo()+1); + if (strstr(entreePrinc->tablcar,"Mise_A_jour_Constantes_utilisateurs_")!=NULL) + {varExpor->MiseAjourConstantesUtilisateur(*entreePrinc); + lecture_secondaire = true; + } + else if (strstr(entreePrinc->tablcar,"charges")!=NULL) + { charge->Lecture1(*entreePrinc,*lesRef,*lesCourbes1D,*lesFonctionsnD); + lecture_secondaire=true;} // lecture des actions exterieurs de chargement + else if (strstr(entreePrinc->tablcar,"blocages")!=NULL) + { lesCondLim->Lecture1(*entreePrinc,*lesRef); + lecture_secondaire=true;} // lecture des ddl bloques + else if ( (strstr(entreePrinc->tablcar,"controle")!=NULL) || + (strstr(entreePrinc->tablcar,"para_syteme_lineaire")!=NULL) || + (strstr(entreePrinc->tablcar,"para_pilotage_equi_global")!=NULL) || + (strstr(entreePrinc->tablcar,"para_dedies_dynamique")!=NULL) || + (strstr(entreePrinc->tablcar,"para_affichage")!=NULL)|| + (strstr(entreePrinc->tablcar,"para_contact")!=NULL)|| + (strstr(entreePrinc->tablcar,"para_energie")!=NULL)|| + (strstr(entreePrinc->tablcar,"para_calculs_geometriques")!=NULL)) + { algori->Lecture(*entreePrinc,*paraGlob,*lesMaillages); + lecture_secondaire=true;}// lecture des parametres de controle de l'algorithme + else if (strstr(entreePrinc->tablcar,"resultats")!=NULL) + { resultats->Lecture(lesRef); + lecture_secondaire=true;}; // lecture des parametres de gestion de la sortie des resultats + if (!lecture_secondaire) // si on a rien lue on passe à l'enregistrement suivant + entreePrinc->NouvelleDonnee(); + }; + // information sur la lecture secondaire + if (fr){cout << "\n ======== lecture secondaire terminee ======== " << endl; } + else {cout << "\n ======== the secondary reading is ended ======== " << endl; }; + } + catch (UtilLecture::ErrNouvelleDonnee erreur) + { if ( erreur.lecture == 1) + { if (fr){cout << "\n ========lecture secondaire terminee, Projet::Lecture(" + << " fin de fichier atteinte ======== " << endl; } + else {cout << "\n ======== the secondary reading is ended, Projet::Lecture(" + << " the end of the file is reached ======== " << endl; }; + } + else + { cout << "\n ===============================================\n" ; + // on sort tous les informations lues par défaut + if (fr){cout << "\n **** erreur en lecture, voulez-vous sortir les informations actuellement lues ?"; + cout << " rep (o ou n) ";} + else {cout << "\n **** error in reading, do you want to print the data already read ? "; + cout << " answer yes (y) or not (n) ";}; + string toto; + toto= lect_chaine(); + if ((toto == "o")||(toto=="O")||(toto=="y")||(toto=="Y")) + Affiche(); + tempsMiseEnDonnees.Arret_du_comptage(); // fin comptage cpu + Sortie(0); + }; + } + catch (ErrSortieFinale) + // cas d'une direction voulue vers la sortie + // on relance l'interuption pour le niveau supérieur + { ErrSortieFinale toto; + throw (toto); + } + catch ( ... ) + { if (fr){cout << "\n ======== erreur inconnue en lecture secondaire ===== Projet::Lecture(.." << endl;} + else {cout << "\n ======== unknown error in secondary reading ===== Projet::Lecture(.." << endl;} + // on sort tous les informations lues par défaut + if (fr){cout << "\n **** erreur en lecture, voulez-vous sortir les informations actuellement lues ?"; + cout << " rep (o ou n) ";} + else {cout << "\n **** error in reading, do you want to print the data already read ? "; + cout << " answer yes (y) or not (n) ";}; + + string toto; toto= lect_chaine(); + if ((toto == "o")||(toto=="O")||(toto=="y")||(toto=="Y")) Affiche(); + tempsMiseEnDonnees.Arret_du_comptage(); // fin comptage cpu + Sortie(0); + } + // recopie eventuelle de la lecture + if (resultats->Copie()) Affiche(); + }; + + tempsMiseEnDonnees.Arret_du_comptage(); // fin comptage cpu + return lecture_secondaire; +}; + + // resolution du probleme + void Projet::Calcul() + { if (!(paraGlob->EtatDeLaLecturePointInfo())) // cas d'une première exécution + {// preparation et verification globale des instances de classe + // 1) introduire les lois de comportement dans les elements qui le necessite + // des sections pour les biellettes etc c-a-d , completer les elements + // avec les donnees qui ont ete acquises apres la lecture du maillage +////---- debug +//cout << "\n debug -- Projet::Calcul () "; +//lesRef->Affiche(2,0); +////----- fin debug + lesCondLim->IntroductionDonnees(lesMaillages,lesRef,lesCourbes1D,lesFonctionsnD); + lesMaillages->Completer(diversStockage,lesLoisDeComp,lesFonctionsnD); + // 2) verification des elements + if (!(lesMaillages->Complet())) + { cout << "\n le maillage n\'est pas complet avant le calcul, il" + << " faut completer les donnees "; + cout << " Projet::Calcul () "; + Sortie(1); + }; + // 3) vérification des courbes + if (!(lesCourbes1D->Complet())) + { cout << "\n les courbes ne sont pas completes avant le calcul, il faut completer les donnees "; + cout << " Projet::Calcul () "; + Sortie(1); + }; + // 3) vérification des fonctions nD et mise à jour des variables globales + if (!(lesFonctionsnD->Complet())) + { cout << "\n les fonctions nD ne sont pas completes avant le calcul, il faut completer les donnees "; + cout << " Projet::Calcul () "; + Sortie(1); + }; + // vérification sur les variables utilisateurs + if (!varExpor->Complet_VariablesExporter(*lesRef)) + { cout << "\n Les variables utilisateurs sont a revoir... "; + cout << " Projet::Calcul () "; + Sortie(1); + }; + + // vérification de la cohérence du critère d'arrêt de calcul + algori->Coherence_Algo_typeConvergence(); + } + else // cas d'une exécution suite point info + { // pour l'instant ne fonctionne pas avec tous les algos + switch (algori->TypeDeCalcul()) + {case NON_DYNA : case RELAX_DYNA : case DYNA_IMP : + case DYNA_EXP_CHUNG_LEE : case DYNA_EXP_TCHAMWA : + case DYNA_EXP: case DYNA_EXP_ZHAI: case DYNA_RUNGE_KUTTA: + case DYNA_EXP_BONELLI : break; // OK + case COMBINER : + {// on passe en revue tous les sous_algo + AlgoriCombine* al = (AlgoriCombine*) algori; + list list_algo = al->List_Sous_Algo(); + list ::iterator il,ilfin = list_algo.end(); + bool tout_ok = true; // init + for (il = list_algo.begin();il != ilfin; il++) + {switch (*il) + {case NON_DYNA : case RELAX_DYNA : case DYNA_IMP : + case DYNA_EXP_CHUNG_LEE : case DYNA_EXP_TCHAMWA : + case DYNA_EXP: case DYNA_EXP_ZHAI: case DYNA_RUNGE_KUTTA: + case DYNA_EXP_BONELLI : break; // OK + default : tout_ok=false; break; + } + if (!tout_ok) + break; + } + if (!tout_ok) + {cout << "\nErreur : pour l'instant le type d'algorithme COMBINER " + << " avec un sous algo de type " << Nom_TypeCalcul(*il) + << " n'est pas disponible pour faire un calcul avec l'option _suite_point_info_ !\n"; + cout << "\n faire une demande a gerard rio " << endl; + Sortie(1); + } + break; + } + default : + cout << "\nErreur : pour l'instant le type d'algorithme " << Nom_TypeCalcul(algori->TypeDeCalcul()) + << " n'est pas disponible pour faire un calcul avec l'option _suite_point_info_ !\n"; + cout << "\n faire une demande a gerard rio " << endl; + Sortie(1); + }; + }; + // execution de l'algorithme + algori->Execution + (paraGlob,lesMaillages,lesRef,lesCourbes1D,lesFonctionsnD, varExpor,lesLoisDeComp,diversStockage,charge + ,lesCondLim,lescontacts,resultats); + }; + +// sortie des resultats +void Projet::SortieDesResultats () + { // tout d'abord sortie des résultats fichiers + resultats->SortieInfo(paraGlob,lesMaillages,lesRef,lesCondLim,lescontacts); + }; + +// visualisation (éventuelle) via le format vrml ou autre +void Projet::Visualisation_interactive () +{try + { // dans le cas où il y a une lecture de fichier de commande de visualisation + // on met en place la visualisation demandée et on exécute la visualisation + if (paraGlob->SousTypeCalcul(lectureCommandesVisu)) + { algori->LectureCommandeVisu + (paraGlob,lesMaillages,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,diversStockage,charge + ,lesCondLim,lescontacts,resultats); + }; +/* // dans le cas où l'on veut une visualisation automatique + if (paraGlob->SousTypeCalcul(VisuAutoCommandes)) + { algori->VisualisationAutomatique + (paraGlob,lesMaillages,lesRef,lesCourbes1D,lesLoisDeComp,diversStockage,charge + ,lesCondLim,lescontacts,resultats); + } */ + // dans le cas ou l'utilisateur veux également une visualisation interactive + // via le format vrml ou autre on active l'algorithme adoc + if (paraGlob->SousTypeCalcul(visualisation)) + { // on remet ok le flux d'entrée au cas où + // gestion d'erreur éventuelle + if ( std::cin.fail() || std::cin.eof()) + {std::cin.clear(); // effacer les bits d'erreurs + std::cin.ignore( std::numeric_limits::max(), '\n' );// purge de cin + }; + + // choix entre les différents types de visualisation + bool choix_valide = false; + while (!choix_valide) + { + if (ParaGlob::Francais()) + {cout << "\n =========== choix du module de visualisation interactive ============" + << "\n sauvegarde des commandes de visualisation ? (rep 1)" + << "\n visualisation automatique ? (rep 2)" + << "\n visualisation au format vrml ? (rep 3)" + << "\n visualisation par fichier de points, format maple ? (rep 4)" + << "\n visualisation au format geomview ? (rep 5)" + << "\n visualisation au format Gid ? (rep 6)" + << "\n changement de fichier de commande .CVisu ? (rep 7)" + << "\n visualisation au format Gmsh ? (rep 8)" + << "\n nom grandeurs actuelles accessibles globalement ? (rep 9)" + << "\n fin (defaut) (rep 0 ou f)"; + } + else + {cout << "\n =========== choice of the type of visualisation ============" + << "\n save commands of visualization which have been read ? (rep 1)" + << "\n automatic visualisation ? (rep 2)" + << "\n visualisation with the output format: vrml ? (rep 3)" + << "\n visualisation with a text format: style maple ? (rep 4)" + << "\n visualisation with a format for Geomview ? (rep 5)" + << "\n visualisation with a format for Gid ? (rep 6)" + << "\n change of command file : .CVisu ? (rep 7)" + << "\n visualisation with a format for Gmsh ? (rep 8)" + << "\n Name of current entities readable anywhere ? (rep 9)" + << "\n finish (default) (rep 0 ou f)"; + }; + string rep; + if (ParaGlob::Francais()) {cout << "\n reponse ? ";} else {cout << "\n answer ? ";}; +////------- debug +//cout << "\n *** debug Projet::Visualisation_interactive ()--"; +//raise(SIGINT); +// +// +////----- fin debug + rep = lect_return_defaut(false,"f"); + if (rep == "1") + {// cas d'une sauvegarde des commandes de visualisation + algori->EcritureCommandeVisu();} + else if (rep == "2") + {// cas d'une visualisation automatique demandée + algori->LectureCommandeVisu + (paraGlob,lesMaillages,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,diversStockage,charge + ,lesCondLim,lescontacts,resultats);} + else if (rep == "3") + {// cas format vrml + algori->Visu_vrml + (paraGlob,lesMaillages,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,diversStockage,charge + ,lesCondLim,lescontacts,resultats);} + else if (rep == "4") + {// cas format maple + algori->Visu_maple + (paraGlob,lesMaillages,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,diversStockage,charge + ,lesCondLim,lescontacts,resultats);} + else if (rep == "5") + {// cas format geomview + algori->Visu_geomview + (paraGlob,lesMaillages,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,diversStockage,charge + ,lesCondLim,lescontacts,resultats);} + else if (rep == "6") + {// cas format Gid + algori->Visu_Gid + (paraGlob,lesMaillages,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,diversStockage,charge + ,lesCondLim,lescontacts,resultats);} + else if (rep == "7") + {// changement de fichier de commande .CVisu + entreePrinc->Fermeture_CommandeVisu(); // fermeture du fichier actuel s'il y en a un + string nouveauNomCvisu=""; // pour faire l'entrée interactive dans Changement_NomCVisu + entreePrinc->Changement_NomCVisu(nouveauNomCvisu); + } + else if (rep == "8") + {// cas format Gmsh + algori->Visu_Gmsh + (paraGlob,lesMaillages,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,diversStockage,charge + ,lesCondLim,lescontacts,resultats);} + else if (rep == "9") + { // on affiche directement + ParaGlob::param->Affiche_GrandeurGlobal(cout); + } + else if ((rep == "0") || (rep == "o") || (rep == "O") || (rep == "f")) + choix_valide = true; + else + {if (ParaGlob::Francais()) {cout << "\n la réponse : " << rep << " n'est pas utilisable, recommencez !";} + else {cout << "\n the answer : " << rep << " cannot be use , do it again !";}; + }; + }; + }; + // dans le cas où l'on veut une sauvegarde de la visualisation dans un fichier de commande + // on effectue la sauvegarde (suite aux infos lue dans le .info) + if (paraGlob->SousTypeCalcul(sauveCommandesVisu)) + algori->EcritureCommandeVisu(); + } + catch ( ... ) + { cout << "\n ======== erreur de lecture detectee ====== " << endl; + ErrSortieFinale titi; + throw (titi); + }; +}; + + +// lecture des données externes pour chaque entitée gérée par le projet +// type indique le type de données externes à lire +void Projet::LectureDonneesExternes() + { + tempsMiseEnDonnees.Mise_en_route_du_comptage(); // comptage cpu + // on boucle sur tous les types différents de flots externes définies + for (int nbf=1;nbf<= algori->NbTypeFlotExt();nbf++) + {// on parcours tous les éléments d'un même type + const list & lalist = algori->Noms_fichier(nbf).infos; + list ::const_iterator ii; + for (ii=lalist.begin() ; ii != lalist.end(); ii++) + {// récup du nom de fichier + const string& nfichier = (*ii).nomFichier; + // ouverture du nouveau flot + entreePrinc->NouveauFichier(((char*)(nfichier).c_str())); + // lecture des données externes + const string& nmaillage = (*ii).nomMaillage; // récup nom du maillage + const int type = algori->TypeDonneesExternes(nbf); + // chaque entité est appelé + lesMaillages->LectureDonneesExternes(type,nmaillage); + lesLoisDeComp->LectureDonneesExternes(*entreePrinc,*lesRef,type,nmaillage); + diversStockage->LectureDonneesExternes(*entreePrinc,*lesRef,type,nmaillage); + charge->LectureDonneesExternes(*entreePrinc,*lesRef,type,nmaillage); + lesCondLim->LectureDonneesExternes(*entreePrinc,*lesRef,type,nmaillage); + // fermeture du flot, retour au flot antérieur + int indic; entreePrinc->FermetureFichier( indic); + } + } + tempsMiseEnDonnees.Arret_du_comptage(); // fin comptage cpu + }; + +// affichage de toutes les informations lue +void Projet::Affiche() const + { // entreePrinc->OuvrirCopie(); // ouverture de la sauvegarde + // memorisation du flux de sortie + //iostream_withassign out; + // ostream& out = cout; + // out = cout; + // réaffectation de la sortie courante +// ofstream* cout = entreePrinc->copie; + // cout = entreePrinc->copie; + if (algori != NULL) algori->Affiche1(); // type de calcul + if (lesMaillages != NULL) lesMaillages->Affiche(); // maillages + if (lesRef != NULL) lesRef->Affiche(); // affichage des references` + if (lesCourbes1D != NULL) lesCourbes1D->Affiche(); // affichage des courbes 1D + if (lesLoisDeComp != NULL) lesLoisDeComp->Affiche(); // affichage des lois + if (diversStockage != NULL) diversStockage->Affiche1(); // 1er affichage des divers stockage + // affichage du contact si nécessaire + if (lescontacts != NULL) lescontacts->Affiche(); + if (charge != NULL) charge->Affiche1(); // chargement + if (lesCondLim != NULL) lesCondLim->Affiche1(); // conditions limite bloquee + if (lesCondLim != NULL) lesCondLim->Affiche2(); // conditions d'initialisation + if (diversStockage != NULL) diversStockage->Affiche2(); // second affichage des divers stockage + if (charge != NULL) charge->Affiche2(); // type de charge + if (algori != NULL) algori->Affiche2(); // parametres de controle + if (resultats != NULL) resultats->Affiche(); // gestion de la sortie des resultats + + // entreePrinc->FermerCopie(); // fermeture de la sauvegarde + // cout = *out; // retour de la sortie sur l'ecran + Sortie(1); + }; + +// sortie du schemaXML: en fonction de enu +// ceci pour tous les types de base +void Projet::SchemaXML_Type_de_base(ofstream& sort,const Enum_IO_XML enu) + { // définition d'une liste de réels + if (enu == XML_TYPE_GLOBAUX) // cas de la sortie du type global + {sort << "\n " + << "\n " + << "\n " + << "\n "; + }; + // cas des différentes coordonnées + Coordonnee::SchemaXML_Coordonnee(sort,enu); + CoordonneeH::SchemaXML_Coordonnee(sort,enu); + CoordonneeB::SchemaXML_Coordonnee(sort,enu); + Coordonnee1::SchemaXML_Coordonnee(sort,enu); + Coordonnee1H::SchemaXML_Coordonnee(sort,enu); + Coordonnee1B::SchemaXML_Coordonnee(sort,enu); + Coordonnee2::SchemaXML_Coordonnee(sort,enu); + Coordonnee2H::SchemaXML_Coordonnee(sort,enu); + Coordonnee2B::SchemaXML_Coordonnee(sort,enu); + Coordonnee3::SchemaXML_Coordonnee(sort,enu); + Coordonnee3H::SchemaXML_Coordonnee(sort,enu); + Coordonnee3B::SchemaXML_Coordonnee(sort,enu); + }; + + + +// fermeture des fichiers de visualisation liés au projet +void Projet::FermetureFichiersVisualisation() + {if (entreePrinc != NULL) + { // on ferme les sorties vrml (fichier) et appel éventuel du visualisateur + entreePrinc->Fermeture_fichier_principal_vrml(); + entreePrinc->Fermeture_fichier_legende_vrml(); + // on ferme la sortie maple (fichier) et appel éventuel du visualisateur + entreePrinc->Fermeture_fichier_principal_maple(); + // on ferme les sorties geomview (fichier) et appel éventuel du visualisateur + entreePrinc->Fermeture_fichier_principal_geomview(); + entreePrinc->Fermeture_fichier_legende_geomview(); + // on ferme les sorties Gid (fichier) et appel éventuel du visualisateur + entreePrinc->Fermeture_fichier_initial_Gid(); + entreePrinc->Fermeture_fichier_resultat_Gid(); + // on ferme les sorties Gmsh (fichier) et appel éventuel du visualisateur + entreePrinc->Fermeture_fichier_initial_Gmsh(); + entreePrinc->Fermeture_TousLesFichiersResultats_Gmsh(); + // on ferme les sorties vrml (fichier) et appel éventuel du visualisateur + entreePrinc->Fermeture_fichier_principal_vrml(); + entreePrinc->Fermeture_fichier_legende_vrml(); + }; + }; + +// sortie sur fichier des temps cpu +// retourne un pointeur sur UtilLecture pour la récupération du fichier +// de temps, qui peut ainsi être utilisé par la méthode appelant +UtilLecture * Projet::Sortie_temps_cpu() + { // on commence par appeler l'algorithme + // sortie sur fichier des temps cpu + algori->Sortie_temps_cpu(*lesCondLim,*charge,*lescontacts); + // puis la partie spécifique aux lois de comportement + lesLoisDeComp->Sortie_temps_cpu(*entreePrinc); + // écriture des temps cpu de la mise en donnéees: + // récupération du fichier des temps cpu + ofstream & sort_cpu = entreePrinc->Sort_temps_cpu(); + sort_cpu << "\n \n --------------- temps_mise_en_donnees_en_milliseconde: ---------"; + sort_cpu << fixed; + sort_cpu.precision(2); + sort_cpu << "\n tps_de la mise en donnees " + << tempsMiseEnDonnees.Temps_CPU_User_milli(); + // puis retour + return entreePrinc; + }; + +// def du fichier des temps cpu +// puis retourne un pointeur sur UtilLecture pour la récupération du fichier +// de temps, qui peut ainsi être utilisé par la méthode appelant +UtilLecture * Projet::Def_sortie_temps_cpu() + { + // on ouvre le fichier des temps cpu + entreePrinc->Ouverture_fichier_temps_cpu(); // ouverture au cas où + // puis retour + return entreePrinc; + }; + +// une méthode qui a pour objectif de terminer tous les comptages, utile +// dans le cas d'un arrêt impromptu +void Projet::Arret_du_comptage_CPU() + { // tout d'abord l'algorithme + algori->Arret_du_comptage_CPU(); + // puis la mise en données + tempsMiseEnDonnees.Arret_du_comptage(); + }; + + + + diff --git a/General/herezh.cc b/General/herezh.cc new file mode 100644 index 0000000..10e3e0c --- /dev/null +++ b/General/herezh.cc @@ -0,0 +1,443 @@ +/*! \file herezh.cc + \brief programme principal herezh++. +*/ + +// 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) . +// +// 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 . +// +// For more information, please consult: . + +/************************************************************************ + * * + * DATE: 15/01/97 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: programme de calcul de structure par elements finis * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * * + * $ * + * * + ************************************************************************/ +//#include +# include +using namespace std; //introduces namespace std + +#include "herezh.h" +//#include "Debug.h" +//#include "DebugNew.h" // peut-etre à virer ensuite ? + +#include +//# include "EnteteParaGlob.h" +#include "ConstantePrinc.h" +# include "ParaGlob.h" + +// ------- specifiques tenseur ------------------------------- +// 1- second ordre +# include "Tenseur3.h" +# include "Tenseur2.h" +# include "Tenseur1.h" +// 2- quatrieme ordre +# include "TenseurQ-3.h" +# include "TenseurQ-2.h" +# include "TenseurQ-1.h" +#include "Tenseur1_TroisSym.h" +#include "Tenseur2_TroisSym.h" +#include "Tenseur3_TroisSym.h" +// def des variables statiques permettant entre autre d'effacer les tenseurs intermediaires +# include "EnteteTenseur.h" +// fonction permettant la definition de nouveaux tenseurs +#include "NevezTenseur.h" +// def des constantes tenseur +# include "TypeConsTensPrinc.h" +// lorsque l'on veut faire reference a des constantes tenseurs dans un autre +// fichier que le prog principal il faut inclure : +// # include "TypeConsTens.h" +// uniquement, ceci a la place de : +// "TypeConsTensPrinc.h" +// "DefValConsTens.h" +// est a placer dans le fichier qui defini les valeurs des constantes +// --------- fin specifique tenseur --------------- + +//-------- listes globales de petits tableaux ------------ +//#include "PtTabRel_Princ.h" + +#include "Projet.h" +#include "Biellette.h" +#include "BielletteQ.h" +#include "Biel_axi.h" +#include "Biel_axiQ.h" +#include "TriaMembL1.h" +#include "TriaMembQ3.h" +#include "TriaMembQ3_cm1pti.h" +#include "TriaQ3_cmpti1003.h" +#include "TriaCub.h" +#include "TriaCub_cm4pti.h" +#include "Quad.h" +#include "Quad_cm1pti.h" +#include "QuadQ.h" +#include "QuadQCom.h" +#include "QuadQCom_cm4pti.h" +#include "Hexa.h" +#include "Hexa_cm1pti.h" +#include "Hexa_cm27pti.h" +#include "Hexa_cm64pti.h" +#include "HexaQ.h" +#include "HexaQ_cm1pti.h" +#include "HexaQ_cm27pti.h" +#include "HexaQ_cm64pti.h" +#include "HexaQComp.h" +#include "HexaQComp_cm1pti.h" +#include "HexaQComp_cm27pti.h" +#include "HexaQComp_cm64pti.h" +#include "Tetra.h" +#include "TetraQ.h" +#include "TetraQ_cm1pti.h" +#include "TetraQ_cm15pti.h" +#include "PentaL.h" +#include "PentaL_cm1pti.h" +#include "PentaL_cm6pti.h" +#include "PentaQ.h" +#include "PentaQ_cm3pti.h" +#include "PentaQ_cm9pti.h" +#include "PentaQ_cm12pti.h" +#include "PentaQ_cm18pti.h" +#include "PentaQComp.h" +#include "PentaQComp_cm9pti.h" +#include "PentaQComp_cm12pti.h" +#include "PentaQComp_cm18pti.h" +#include "TriaSfe1.h" +#include "TriaSfe1_cm5pti.h" +#include "TriaSfe2.h" +#include "TriaSfe3.h" +#include "TriaSfe3_3D.h" +#include "TriaSfe3_cm3pti.h" +#include "TriaSfe3_cm4pti.h" +#include "TriaSfe3_cm5pti.h" +#include "TriaSfe3_cm6pti.h" +#include "TriaSfe3_cm7pti.h" +#include "TriaSfe3_cm12pti.h" +#include "TriaSfe3_cm13pti.h" +#include "TriaSfe3C.h" +#include "TriaQSfe3.h" +#include "TriaQSfe1.h" +#include "PoutSimple1.h" +#include "QuadCCom.h" +#include "QuadCCom_cm9pti.h" +#include "TriaAxiL1.h" +#include "TriaAxiQ3.h" +#include "TriaAxiQ3_cm1pti.h" +#include "TriaAxiQ3_cmpti1003.h" +#include "QuadAxiL1.h" +#include "QuadAxiL1_cm1pti.h" +#include "QuadAxiQ.h" +#include "QuadAxiQComp.h" +#include "QuadAxiQComp_cm4pti.h" +#include "QuadAxiCCom.h" +#include "QuadAxiCCom_cm9pti.h" +#include "ElemPoint.h" +#include "ElemPoint_CP.h" +#include "BielletteThermi.h" + +//#ifdef ENLINUX_STREAM +// #include "Profiler.h" +//#endif +//#define USE_PROFILE + +#ifdef UTILISATION_DE_LA_LIBRAIRIE_BOOST + #include + #include +#endif +#include "Temps_CPU_HZpp.h" +#include "Temps_CPU_HZpp_3.h" + + + + +#ifdef SYSTEM_MAC_OS_X +int main (int argc, const char * argv[]) { +#else + #ifdef ENLINUX_STREAM //ENLINUX + int main (int argc, const char * argv[]) { + #else + #ifdef SYSTEM_MAC_OS_X_unix + int main (int argc, const char * argv[]) { + #else + int main () + { int argc=0; const char ** argv = NULL ; + #endif + #endif +#endif + +// gestion du temps cpu global +Temps_CPU_HZpp_3 temps_CPU_Herezh_total; +temps_CPU_Herezh_total.Mise_en_route_du_comptage(); // comptage cpu +UtilLecture* pt_UtilLecture = NULL; // un pointeur qui doit-être renseigné par le projet + +// écriture de l'entête du programme +Presentation(); + +// definition d'un projet +string retour ; +try + { // par la définition du projet, est définit également l'algo + // on définit le projet en dehors du try qui suit, pour le projet demeure valide même s'il y a + // une exception, ce qui permet quand même d'utiliser des fonction du projet, + // par exemple l'acces aux fichier qui sont définit dans UtilLecture + Projet projet(retour,argc,argv); + if (retour != "fin") + try + { + + // les differents elements + // (sont ici définit pour qu'ils soient pris en compte à l'édition de lien !!) + Biellette b1; // biellette + BielletteQ b11; // biellette quadratique + Biel_axi baxi; // biellette axisymétrique linéaire + Biel_axiQ baxiQ; // biellette axisymétrique quadratique + TriaMembL1 t1; // triangle membranne, lineaire 1 pt d'integ + TriaMembQ3 t2; // triangle membranne, quadratique 3 pt d'integ + TriaMembQ3_cm1pti triaMembQ3_cm1pti; // triangle membranne, quadratique 1 pt d'integ + TriaQ3_cmpti1003 t_cmpti1003; // triangle membranne, quadratique avec 3 pt d'integ interne + TriaCub triacub; // triangle cubique + TriaCub_cm4pti triacub_cm4pti; // triangle cubique avec 4 pti + Quad q1; // quadrangle membranne, lineaire 4 pt d'integ + Quad_cm1pti quad_cm1pti; // quadrangle membranne, lineaire 1 pt d'integ + QuadQ q2; // quadrangle membranne, quadratique incomplet 4 pt d'integ + QuadQCom q3; // quadrangle membranne, quadratique complet 9 pt d'integ + QuadQCom_cm4pti quadQCom_cm4pti; // quadrangle membranne, quadratique complet 4 pt d'integ + QuadCCom q4; // quadrangle membranne, cubique complet 16 pt d'integ + QuadCCom_cm9pti q4_9pti; // quadrangle membranne, cubique complet 9 pt d'integ + Hexa h1; // un hexaedre trilineaire, 8 pt d'integ + Hexa_cm1pti h1_cm1pti; // un hexaedre trilineaire, 1 pt d'integ + Hexa_cm27pti h1_cm27pti; // un hexaedre trilineaire, 27 pt d'integ + Hexa_cm64pti h1_cm64pti; // un hexaedre trilineaire, 64 pt d'integ + HexaQ h2; // un hexaedre trilquadratique incomplet, 8 pt d'integ + HexaQ_cm1pti h2_cm1pti; // un hexaedre trilquadratique incomplet, 1 pt d'integ + HexaQ_cm27pti h2_cm27pti; // un hexaedre trilquadratique incomplet, 27 pt d'integ + HexaQ_cm64pti h2_cm64pti; // un hexaedre trilquadratique incomplet, 64 pt d'integ + HexaQComp h2comp; // un hexaedre trilquadratique complet, 8 pt d'integ + HexaQComp_cm1pti h2comp_1pti; // un hexaedre trilquadratique complet, 1 pt d'integ + HexaQComp_cm27pti h2comp_27pti; // un hexaedre trilquadratique complet, 27 pt d'integ + HexaQComp_cm64pti h2comp_64pti; // un hexaedre trilquadratique complet, 64 pt d'integ + Tetra te1; // un tetraedre trilineaire, 1 pt d'integ + TetraQ te2; // un tetraedre triquadratique, 4 pt d'integ + TetraQ_15pti te3; // un tetraedre triquadratique, 15 pt d'integ + TetraQ_cm1pti te2_cm1pti; // un tetraedre triquadratique, 1 pt d'integ + PentaL pe1; // un pentaedre trilinéaire, 2 pts d'intégration + PentaL_cm1pti pe1_cm1pti; // un pentaedre trilinéaire, 1 pts d'intégration + PentaL_cm6pti pe1_cm6pti; // un pentaedre trilinéaire, 6 pts d'intégration + PentaQ pe2; // un pentaedre triquadratique incomplet, 6 pts d'intégration + PentaQ_cm3pti pe2_cm3pti; // un pentaedre triquadratique incomplet, 3 pts d'intégration + PentaQ_cm9pti pe2_cm9pti; // un pentaedre triquadratique incomplet, 9 pts d'intégration + PentaQ_cm12pti pe2_cm12pti; // un pentaedre triquadratique incomplet, 12 pts d'intégration + PentaQ_cm18pti pe2_cm18pti; // un pentaedre triquadratique incomplet, 18 pts d'intégration + PentaQComp pe2Comp; // un pentaedre triquadratique complet, 6 pts d'intégration + PentaQComp_cm9pti pe2Comp_cm9pti; // un pentaedre triquadratique complet, 9 pts d'intégration + PentaQComp_cm12pti pe2Comp_cm12pti; // un pentaedre triquadratique complet, 12 pts d'intégration + PentaQComp_cm18pti pe2Comp_cm18pti; // un pentaedre triquadratique complet, 18 pts d'intégration + TriaSfe1 t3; // un triangle SFE1 + TriaSfe1_cm5pti tfe1_cm5pti; // idem avec 5 pti + TriaSfe2 t3_2; // un triangle SFE2 + TriaSfe3 t3_3; // un triangle SFE3 + TriaSfe3_3D t3_3_3D; // un triangle SFE3_3D + TriaSfe3_cm4pti t3_3_cm4pti; // un triangle SFE3 avec 4pt d'integ + TriaSfe3_cm6pti t3_3_cm6pti; // un triangle SFE3 avec 6pt d'integ + TriaSfe3_cm12pti t3_3_cm12pti; // un triangle SFE3 avec 12pt d'integ + TriaSfe3_cm3pti t3_3_cm3pti; // un triangle SFE3 avec 3pt d'integ type Gauss Lobatto + TriaSfe3_cm5pti t3_3_cm5pti; // un triangle SFE3 avec 5pt d'integ type Gauss Lobatto + TriaSfe3_cm7pti t3_3_cm7pti; // un triangle SFE3 avec 7pt d'integ type Gauss Lobatto + TriaSfe3_cm13pti t3_3_cm13pti; // un triangle SFE3 avec 13pt d'integ type Gauss Lobatto + TriaSfe3C t3_3C; // un triangle SFE3C + TriaQSfe3 tqSfe3; // un triangle QSFE3 + TriaQSfe1 tqSfe1; // un triangle QSFE1 + PoutSimple1 p1; // poutre simple, interpolation quadratique en 2 D + TriaAxiL1 triAxil1; // triangle axisymétrique linéaire + TriaAxiQ3 triAxiq3; // triangle axisymétrique quadratique 3 pti + TriaAxiQ3_cm1pti triaAxiQ3_cm1pti; // triangle axisymétrique quadratique 1 pti + TriaAxiQ3_cmpti1003 triaAxiQ3_cmpti1003; // triangle axi quadra 3 pti hors arêtes + QuadAxiL1 quadAxil1; // quadrangle axisymétrique linéaire + QuadAxiL1_cm1pti quadAxiL1_cm1pti; // idem avec 1 pti + QuadAxiQ quadAxiq; // quadrangle axisymétrique quadratique incomplet + QuadAxiQComp quadAxiqcomp; // quad quadratique axisymétrique complet + QuadAxiQComp_cm4pti quadAxiQComp_cm4pti; // idem mais avec 4 pti + QuadAxiCCom quadAxicCom; // quad cubique axi complet + QuadAxiCCom_cm9pti quadAxiCCom_cm9pti; // idem avec 9 pti + ElemPoint elemPoint; // élément pour umat abaqus + ElemPoint_CP elemPoint_CP; // idem mais pour les contraintes planes + //.... cas de la thermique + BielletteThermi bielletteThermi; // une biellette thermique + + // le projet étant définit, on peut définir le fichier de stockage des temps cpu + pt_UtilLecture = projet.Def_sortie_temps_cpu(); + + + //il y a deux types d'entrée de donnée soit via un fichier info + // -------------------------------------------------------- + // choix en fonction de la construction du projet + // -------------------------------------------------------- + if (retour == "def_fichier_commande") + // ------------------------------------------------- + // cas de la définition d'un fichier de commandes + // ------------------------------------------------- + {projet.Def_fichier_commande(retour);} + else if (retour == "def_schema_XML") + // ---------------------------------------------------------------------- + // cas de la définition d'un fichier de de shema XML d'entrée de données + // ---------------------------------------------------------------------- + {projet.Def_fichier_SchemaXML(retour);} + else if (retour != "fin") + // -------------------------------------------------------- + // cas d'un calcul + // definition des quatres grandes etapes du calcul + // -------------------------------------------------------- + { + projet.Lecture(); // 1- lecture initiale + + // #ifdef USE_PROFILE + // // préparation du profiler + // if (!ProfilerInit(collectDetailed, bestTimeBase,8000, 100)) + // { + // #endif + + do + { projet.Calcul(); // 2- calcul + + // #ifdef USE_PROFILE + // int erro; + // // sortie des infos pour le profiler + // erro= ProfilerDump("\pHerezh.prof"); + // ProfilerTerm(); + // } + // #endif + + projet.SortieDesResultats(); // 3- sortie automatique résultats + projet.Visualisation_interactive(); // 4- sortie interactive résultats + // ou automatique via un fichier de commande + } while (projet.Lecture_secondaire()); + }; + // fermeture des fichiers de visualisation liés au projet + projet.FermetureFichiersVisualisation(); + + // on sauvegarde les différents temps cpu, et on récupère l'adresse d'UtilLecture + pt_UtilLecture = projet.Sortie_temps_cpu(); + // gestion du temps cpu global + temps_CPU_Herezh_total.Arret_du_comptage(); // fin comptage cpu + temps_CPU_Herezh_total.Affiche_hh_mn_s_ml(cout); + if (pt_UtilLecture != NULL) // sortie sur fichier si le fichier a été créé + { // récupération du fichier des temps cpu + ofstream & sort_cpu = pt_UtilLecture->Sort_temps_cpu(); + sort_cpu << "\n ------- temps globaux jour/heure:minute:seconde:centieme ------\n"; + temps_CPU_Herezh_total.Affiche_hh_mn_s_ml(pt_UtilLecture->Sort_temps_cpu()); + }; + } // fin de la surveillance + catch (ErrSortie erreur) + { cout << "\n ======== erreur (Sortie) detectee ====== " << endl; + // on sauvegarde les différents temps cpu, et on récupère l'adresse d'UtilLecture + projet.Arret_du_comptage_CPU(); // on termine les comptages non fermés + pt_UtilLecture = projet.Sortie_temps_cpu(); + // gestion du temps cpu global + temps_CPU_Herezh_total.Arret_du_comptage(); // fin comptage cpu + temps_CPU_Herezh_total.Affiche_hh_mn_s_ml(cout); + if (pt_UtilLecture != NULL) // sortie sur fichier si le fichier a été créé + { // récupération du fichier des temps cpu + ofstream & sort_cpu = pt_UtilLecture->Sort_temps_cpu(); + sort_cpu << "\n ------- temps globaux jour/heure:minute:seconde:centieme ------\n"; + temps_CPU_Herezh_total.Affiche_hh_mn_s_ml(pt_UtilLecture->Sort_temps_cpu()); + }; + } + catch (ErrSortieFinale erreur) + { cout << "\n ======== erreur (Sortie) detectee ====== " << endl; + // on sauvegarde les différents temps cpu, et on récupère l'adresse d'UtilLecture + projet.Arret_du_comptage_CPU(); // on termine les comptages non fermés + pt_UtilLecture = projet.Sortie_temps_cpu(); + // gestion du temps cpu global + temps_CPU_Herezh_total.Arret_du_comptage(); // fin comptage cpu + temps_CPU_Herezh_total.Affiche_hh_mn_s_ml(cout); + if (pt_UtilLecture != NULL) // sortie sur fichier si le fichier a été créé + { // récupération du fichier des temps cpu + ofstream & sort_cpu = pt_UtilLecture->Sort_temps_cpu(); + sort_cpu << "\n ------- temps globaux jour/heure:minute:seconde:centieme ------\n"; + temps_CPU_Herezh_total.Affiche_hh_mn_s_ml(pt_UtilLecture->Sort_temps_cpu()); + }; + } + catch ( ... ) + { cout << "\n ======== erreur detectee ====== " << endl; + projet.Arret_du_comptage_CPU(); // on termine les comptages non fermés + // on sauvegarde les différents temps cpu, et on récupère l'adresse d'UtilLecture + pt_UtilLecture = projet.Sortie_temps_cpu(); + // gestion du temps cpu global + temps_CPU_Herezh_total.Arret_du_comptage(); // fin comptage cpu + temps_CPU_Herezh_total.Affiche_hh_mn_s_ml(cout); + if (pt_UtilLecture != NULL) // sortie sur fichier si le fichier a été créé + { // récupération du fichier des temps cpu + ofstream & sort_cpu = pt_UtilLecture->Sort_temps_cpu(); + sort_cpu << "\n ------- temps globaux jour/heure:minute:seconde:centieme ------\n"; + temps_CPU_Herezh_total.Affiche_hh_mn_s_ml(pt_UtilLecture->Sort_temps_cpu()); + }; + }; + + } +catch (ErrSortieFinale erreur) + { cout << "\n *** ======== erreur fatale detectee ======*** " << endl; + // gestion du temps cpu global + temps_CPU_Herezh_total.Arret_du_comptage(); // fin comptage cpu + temps_CPU_Herezh_total.Affiche_hh_mn_s_ml(cout); + if (pt_UtilLecture != NULL) // sortie sur fichier si le fichier a été créé + { // récupération du fichier des temps cpu + ofstream & sort_cpu = pt_UtilLecture->Sort_temps_cpu(); + sort_cpu << "\n ------- temps globaux jour/heure:minute:seconde:centieme ------\n"; + temps_CPU_Herezh_total.Affiche_hh_mn_s_ml(pt_UtilLecture->Sort_temps_cpu()); + }; + } +catch ( ... ) + { cout << "\n *** ======== erreur fatale detectee ======*** " << endl; + }; + + +cout << "\n =============================================================\n"; +cout << " | fin HEREZH++ |\n"; +cout << " ============================================================="; +cout << endl; + +}; diff --git a/General/herezh.h b/General/herezh.h new file mode 100644 index 0000000..365a5f4 --- /dev/null +++ b/General/herezh.h @@ -0,0 +1,79 @@ +/*! \file herezh.h + \brief Entête du programme herezh++. +*/ + +// 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) . +// +// 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 . +// +// For more information, please consult: . + +/************************************************************************ + * * + * DATE: 18/10/2001 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Entête du programme herezh++ * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * * + * $ * + * * + ************************************************************************/ +# include + +//#include "Debug.h" +#include "Banniere.h" + +#include +# include "EnteteParaGlob.h" + +#include "ConstantePrinc.h" + +void Presentation(); + +void Presentation() +{ // affichage de l'entête du programme + // sortie de la banniere + Banniere::Sortie_banniere(); + // puis affichage de la version + ParaGlob::Sortie_Version(); +};