// 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 };