rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

introduction du main du programme Herezh++ et de la classe principale: "Projet"

Browse source
This commit is contained in:
Gérard Rio 2021-09-26 17:51:23 +02:00
parent 39b3d7e234
commit 91879f296d
5 changed files with 2316 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

883
General/Projet.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "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 "<<rep<<" n'est pas encore traite !!, mais cela devrait ce faire sans tarder ";
};
}
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 des mots clés proposés !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour sortir ";
};
}; //-- fin du while
// mot clé de fin de fichier
ofstream & sort = *(entreePrinc->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 <!-- ******** definition des types globaux ******** -->"
<< "\n <!-- ************************************************ -->";
// pas de définition d'élément particulier
break;
}
case XML_IO_POINT_INFO :
{ (*sort) << "\n <!-- ******************************************************** -->"
<< "\n <!-- ******** definition fichier de commande .info ******** -->"
<< "\n <!-- ******************************************************** -->";
// définition d'un élément maître
(*sort) << "\n<xs:element name=\"FormatXML_point_info\" >"
<< "\n <xs:complexType >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> "
<< "\n ******************************************************** "
<< "\n ******** definition fichier de commande .info ******** "
<< "\n ******************************************************** "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>";
break;
}
case XML_IO_POINT_BI :
{ (*sort) << "\n <!-- ****************************************************** -->"
<< "\n <!-- ******** definition fichier restart .BI ******** -->"
<< "\n <!-- ****************************************************** -->";
// définition d'un élément maître
(*sort) << "\n<xs:element name=\"FormatXML_point_BI\" >"
<< "\n <xs:complexType >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> "
<< "\n ******************************************************** "
<< "\n ******** definition fichier restart .BI ******** "
<< "\n ******************************************************** "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>";
break;
}
case XML_IO_ELEMENT_FINI :
{ (*sort) << "\n <!-- ************************************************************** -->"
<< "\n <!-- ******** interface pour un element fini particulier ******** -->"
<< "\n <!-- ************************************************************** -->";
// définition d'un élément maître
(*sort) << "\n<xs:element name=\"FormatXML_element_fini\" >"
<< "\n <xs:complexType >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> "
<< "\n ************************************************************** "
<< "\n ******** interface pour un element fini particulier ******** "
<< "\n ************************************************************** "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>";
break;
}
case XML_ACTION_INTERACTIVE :
{ (*sort) << "\n <!-- ************************************************************** -->"
<< "\n <!-- ******** interface pour les actions interactives ******** -->"
<< "\n <!-- ************************************************************** -->";
// définition d'un élément maître
(*sort) << "\n<xs:element name=\"FormatXML_element_fini\" >"
<< "\n <xs:complexType >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> "
<< "\n ************************************************************** "
<< "\n ******** interface pour les actions interactives ******** "
<< "\n ************************************************************** "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>";
break;
}
case XML_STRUCTURE_DONNEE :
{ (*sort) << "\n <!-- ************************************************************** -->"
<< "\n <!-- ******** interface : structures de donnees internes ******** -->"
<< "\n <!-- ************************************************************** -->";
// définition d'un élément maître
(*sort) << "\n<xs:element name=\"FormatXML_element_fini\" >"
<< "\n <xs:complexType >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> "
<< "\n ************************************************************** "
<< "\n ******** interface : structures de donnees internes ******** "
<< "\n ************************************************************** "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>";
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 </xs:sequence>"
<< "\n </xs:complexType>"
<< "\n</xs:element>";
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 << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
<< "\n<xs:schema " //targetNamespace=\"http:\/\/web.univ-ubs.fr\/lg2m\/rio/Herezh++/schemaXML\""
<< "\n xmlns:xs=\"http://www.w3.org/2001/XMLSchema\"" // l'adresse officielle
<< "\n version=\""<<ParaGlob::NbVersion()<<"\" "
<< "\n xml:lang=\"fr\" >";
sort << "\n<xs:annotation>"
<< "\n <xs:documentation> "
<< "\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 </xs:documentation> "
<< "\n</xs:annotation>";
// 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</xs:schema>" << 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<xs:simpleType name=\"dimensionProbleme\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> "
<< "\n definition de la dimension du probleme 1 2 ou 3"
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:restriction base=\"xs:positiveInteger\" >"
<< "\n <xs:enumeration value=\"1\" />"
<< "\n <xs:enumeration value=\"2\" />"
<< "\n <xs:enumeration value=\"3\" />"
<< "\n </xs:restriction>"
<< "\n</xs:simpleType>";
break;
}
default : // pour tous les autres cas on sort un élément pour définir la dimension
sort << "\n <xs:element name=\"dimensionDuProbleme\" type=\"dimensionProbleme\" />";
};
};
// ---- 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
};

222
General/Projet.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* *
* 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 <iostream>
//#include "Debug.h"
#ifndef ENLINUX_STREAM
#include <sstream> // pour le flot en memoire centrale
#else
#include <strstream> // 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 <Algori* > 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

689
General/Projet2.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "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<Noeud *>& tabi = el.Tab_noeud_const();
// cout << "\n *** connection de l'element 55: ";
// for (int i=1;i<=tabi.Taille();i++) cout << " "<<tabi(i)->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 <EnumTypeCalcul> list_algo = al->List_Sous_Algo();
list <EnumTypeCalcul>::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<std::streamsize>::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 <Algori::DeuxString > & lalist = algori->Noms_fichier(nbf).infos;
list <Algori::DeuxString >::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 <!-- ************************ liste de reels *********************** -->"
<< "\n <xs:simpleType name=\"liste_de_reels\">"
<< "\n <xs:list itemType=\"xs:double\"/>"
<< "\n </xs:simpleType> ";
};
// 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();
};

443
General/herezh.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* *
* 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 <altivec.h>
# include <iostream>
using namespace std; //introduces namespace std
#include "herezh.h"
//#include "Debug.h"
//#include "DebugNew.h" // peut-etre à virer ensuite ?
#include <math.h>
//# 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 <boost/chrono/include.hpp>
#include <boost/system/error_code.hpp>
#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;
};

79
General/herezh.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* *
* 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 <iostream>
//#include "Debug.h"
#include "Banniere.h"
#include <math.h>
# 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();
};