rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Maillage/VariablesExporter.cc

3581 lines
149 KiB
C++
Raw Normal View History

ajout des fichiers du répertoire Maillage - concerne les conditions limites, les maillages, les ddl en tout genre
2021-09-18 09:47:14 +02:00
// FICHIER : VariablesExporter.cc
// CLASSE : VariablesExporter
// 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.
//
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
ajout des fichiers du répertoire Maillage - concerne les conditions limites, les maillages, les ddl en tout genre
2021-09-18 09:47:14 +02:00
// 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 "VariablesExporter.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
#include <stdio.h>
#include <vector>
#include "List_io.h"
#include "CharUtil.h"
#include "TypeQuelconqueParticulier.h"
#include "Banniere.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"
// ------------ classes conteneur ----------------
// ======== A_un_NE ============
// classe conteneur de base pour noeud et élément
ostream & operator << ( ostream & sort,const VariablesExporter::A_un_NE & a)
{ sort << a.nom_var;
if (a.nom_mail != "")
{sort << " nom_mail= "<< a.nom_mail;};
sort << " ref_ " << a.ref ;
return sort;
};
// lecture
istream & operator >> ( istream & ent, VariablesExporter::A_un_NE & a)
{ string toto;
ent >> a.nom_var >> toto;
// lecture éventuelle d'un nom de maillage
if (toto == "nom_mail=")
{ent >> a.nom_mail >> toto;}
else if (toto == "ref_")
{a.nom_mail ="";}
else
{cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur,"
<< " on attendait soit la chaine de characteres: nom_mail= ou soit ref_ "
<< " et on a lu: "<< toto << " !!"
<< endl;
Sortie(1);
} ;
// fin de la lecture
ent >> a.ref ;
// vérif il faut que les 3 premiers caractères de a.nom_var soit un V__
if (!((a.nom_var[0]== 'V')&&(a.nom_var[1]== '_')&&(a.nom_var[2]== '_')))
{ cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur,"
<< " les 3 premieres lettres "
<< " devraientt etre un 'V__' et on a lu: "<<a.nom_var << " !!"
<< endl;
Sortie(1);
};
// // on vérifie également qu'il s'agit bien d'une ref de noeud ou d'élément
// if ((a.ref[0] != 'N') && (a.ref[0] != 'E'))
// { cout << "\n *** erreur de syntaxe en lecture d'une reference de noeud ou d'element,"
// << " la premiere lettre "
// << " devraientt etre N ou E et on a lu: "<<a.ref << " !!"
// << endl;
// Sortie(1);
// };
return ent;
};
VariablesExporter::A_un_NE::A_un_NE () : // constructeur par défaut
ref(""), nom_mail(), nom_var("_"){};
// constructeur fonction de toutes les grandeurs
VariablesExporter::A_un_NE::A_un_NE
(string ref_noeEle,string nom_mail_,string nom_var_) :
ref(ref_noeEle), nom_mail(nom_mail_)
, nom_var(nom_var_) {};
// constructeur de copie
VariablesExporter::A_un_NE::A_un_NE (const A_un_NE& a) :
ref(a.ref)
,nom_mail(a.nom_mail), nom_var(a.nom_var) {};
// destructeur
VariablesExporter::A_un_NE::~A_un_NE()
{};
// opérateurs
VariablesExporter::A_un_NE& VariablesExporter::A_un_NE::operator=
(const VariablesExporter::A_un_NE& a)
{ref=a.ref;
nom_mail=a.nom_mail; nom_var=a.nom_var;
return (*this);
};
bool VariablesExporter::A_un_NE::operator== (const A_un_NE& a) const
{if ((ref==a.ref) && (nom_var==a.nom_var) )
return true;
else
return false;
};
bool VariablesExporter::A_un_NE::operator< (const A_un_NE& a) const
{if (nom_mail != a.nom_mail)
{ return (nom_mail < a.nom_mail);}
else // cas nom_mail = a.nom_mail
{ if (ref != a.ref)
{return (ref < a.ref);}
else //cas nom_mail = a.nom_mail et ref = a.ref
{if (nom_var != a.nom_var)
{return (nom_var < a.nom_var);}
else // cas où tout est égal on n'est pas inférieur
{return false;}
};
};
};
bool VariablesExporter::A_un_NE::operator<= (const A_un_NE& a) const
{if (nom_mail != a.nom_mail)
{ return (nom_mail <= a.nom_mail);}
else // nom_mail = a.nom_mail
{ if (ref != a.ref)
{return (ref <= a.ref);}
else //cas nom_mail = a.nom_mail et ref = a.ref
{if (nom_var != a.nom_var)
{return (nom_var <= a.nom_var);}
else // cas où tout est égal on n'est pas inférieur
{return true;};
};
};
};
bool VariablesExporter::A_un_NE::operator> (const A_un_NE& a) const
{if (nom_mail != a.nom_mail)
{ return (nom_mail > a.nom_mail);}
else // cas nom_mail = a.nom_mail
{ if (ref != a.ref)
{return (ref > a.ref);}
else //cas nom_mail = a.nom_mail et ref = a.ref
{if (nom_var != a.nom_var)
{return (nom_var > a.nom_var);}
else // cas où tout est égal on n'est pas supérieur
{return false;};
};
};
};
bool VariablesExporter::A_un_NE::operator>= (const A_un_NE& a) const
{if (nom_mail != a.nom_mail)
{ return (nom_mail >= a.nom_mail);}
else // cas nom_mail = a.nom_mail
{ if (ref != a.ref)
{return (ref >= a.ref);}
else //cas nom_mail = a.nom_mail et ref = a.ref
{if (nom_var != a.nom_var)
{return (nom_var >= a.nom_var);}
else // cas où tout est égal
{return true;};
};
};
};
// affichage
void VariablesExporter::A_un_NE::Affiche()
{ cout << "\n Variable utilisateur: " << nom_var
<< " au_noeud_ref: " << ref
<< " maillage: " << nom_mail;
};
// ======== Ddl_a_un_noeud ============
// classe conteneur pour un ddl à un noeud
ostream & operator << ( ostream & sort,const VariablesExporter::Ddl_a_un_noeud & a)
{ sort << "\n Ddl_noeud_ " << a.nom_var;
if (a.nom_mail != "")
{sort << " nom_mail= "<< a.nom_mail;};
sort << " ref_ " << a.ref_num_NE << " ddl_ " << a.enu
<< " temps_ " << a.temps;
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::Ddl_a_un_noeud & a)
{// lecture du type et vérification
string nomtype; ent >> nomtype;
if (nomtype != "Ddl_noeud_")
{ cout << "\n *** erreur en lecture: on attendait le mot cle Ddl_noeud_ et on a lue "
<< nomtype
<< "\n operator >> ( istream & ent, VariablesExporter::Ddl_a_un_noeud(...";
Sortie(1);
return ent;
};
// lecture
string toto;
ent >> a.nom_var >> toto;
// lecture éventuelle d'un nom de maillage
if (toto == "nom_mail=")
{ent >> a.nom_mail >> toto;}
else if (toto == "ref_")
{a.nom_mail ="";}
else
{cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur de type ddl,"
<< " on attendait soit la chaine de characteres: nom_mail= ou soit ref_ "
<< " et on a lu: "<< toto << " !!"
<< endl;
Sortie(1);
} ;
// fin de la lecture
ent >> a.ref_num_NE >> toto >> a.enu >> toto >> a.temps;
// vérif il faut que les 3 premiers caractères de a.nom_var soit un V__
if (!((a.nom_var[0]== 'V')&&(a.nom_var[1]== '_')&&(a.nom_var[2]== '_')))
{ cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur de type ddl,"
<< " les 3 premieres lettres "
<< " devraientt etre un 'V__' et on a lu: "<<a.nom_var << " !!"
<< endl;
Sortie(1);
};
// on vérifie également qu'il s'agit bien d'une ref de noeud
if (a.ref_num_NE[0] != 'N')
{ cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
<< " erreur de syntaxe en lecture d'une reference de noeud ,"
<< " la premiere lettre "
<< " devraientt etre N et on a lu: "<<a.ref_num_NE << " !!"
<< endl;
Sortie(1);
};
return ent;
};
VariablesExporter::Ddl_a_un_noeud::Ddl_a_un_noeud () : // constructeur par défaut
enu(),ref_num_NE(""), nom_mail(), nom_var("_"), temps() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::Ddl_a_un_noeud::Ddl_a_un_noeud
(Ddl_enum_etendu e,string ref_noeud,string nom_mail_,string nom_var_, Enum_dure tps) :
enu(),ref_num_NE(ref_noeud), nom_mail(nom_mail_)
, nom_var(nom_var_),temps(tps) {};
// constructeur de copie
VariablesExporter::Ddl_a_un_noeud::Ddl_a_un_noeud (const Ddl_a_un_noeud& a) :
enu(a.enu),ref_num_NE(a.ref_num_NE)
,nom_mail(a.nom_mail), nom_var(a.nom_var),temps(a.temps) {};
// destructeur
VariablesExporter::Ddl_a_un_noeud::~Ddl_a_un_noeud()
{};
// opérateurs
VariablesExporter::Ddl_a_un_noeud& VariablesExporter::Ddl_a_un_noeud::operator=
(const VariablesExporter::Ddl_a_un_noeud& a)
{enu=a.enu; ref_num_NE=a.ref_num_NE;
nom_mail=a.nom_mail; nom_var=a.nom_var;temps = a.temps;
return (*this);
};
bool VariablesExporter::Ddl_a_un_noeud::operator== (const Ddl_a_un_noeud& a) const
{if ((enu==a.enu) && (ref_num_NE==a.ref_num_NE)
&& (nom_var==a.nom_var) && (temps == a.temps))
return true;
else
return false;
};
bool VariablesExporter::Ddl_a_un_noeud::operator< (const Ddl_a_un_noeud& a) const
{if (enu != a.enu)
{ return (enu < a.enu);}
else // cas enu = a.enu
{if (nom_mail != a.nom_mail)
{ return (nom_mail < a.nom_mail);}
else // cas enu = a.enu et nom_mail = a.nom_mail
{ if (ref_num_NE != a.ref_num_NE)
{return (ref_num_NE < a.ref_num_NE);}
else //cas enu = a.enu et nom_mail = a.nom_mail et num_NE = a.num_NE
{if (nom_var != a.nom_var)
{return (nom_var < a.nom_var);}
else //cas enu = a.enu et nom_mail = a.nom_mail et num_NE = a.num_NE
// et nom_var == a.nom_var
{if (temps != a.temps)
{return (temps < a.temps);}
else // cas où tout est égal on n'est pas inférieur
{return false;}
}
};
};
};
};
bool VariablesExporter::Ddl_a_un_noeud::operator<= (const Ddl_a_un_noeud& a) const
{if (enu != a.enu)
{ return (enu <= a.enu);}
else // cas enu = a.enu
{if (nom_mail != a.nom_mail)
{ return (nom_mail <= a.nom_mail);}
else // cas enu = a.enu et nom_mail = a.nom_mail
{ if (ref_num_NE != a.ref_num_NE)
{return (ref_num_NE <= a.ref_num_NE);}
else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
{if (nom_var != a.nom_var)
{return (nom_var <= a.nom_var);}
else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
// et nom_var == a.nom_var
{if (temps != a.temps)
{return (temps <= a.temps);}
else // cas où tout est égal on n'est pas inférieur
{return true;};
};
};
};
};
};
bool VariablesExporter::Ddl_a_un_noeud::operator> (const Ddl_a_un_noeud& a) const
{if (enu != a.enu)
{ return (enu > a.enu);}
else // cas enu = a.enu
{if (nom_mail != a.nom_mail)
{ return (nom_mail > a.nom_mail);}
else // cas enu = a.enu et nom_mail = a.nom_mail
{ if (ref_num_NE != a.ref_num_NE)
{return (ref_num_NE > a.ref_num_NE);}
else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
{if (nom_var != a.nom_var)
{return (nom_var > a.nom_var);}
else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
// et nom_var == a.nom_var
{if (temps != a.temps)
{return (temps <= a.temps);}
else // cas où tout est égal on n'est pas supérieur
{return false;};
};
};
};
};
};
bool VariablesExporter::Ddl_a_un_noeud::operator>= (const Ddl_a_un_noeud& a) const
{if (enu != a.enu)
{ return (enu >= a.enu);}
else // cas enu = a.enu
{if (nom_mail != a.nom_mail)
{ return (nom_mail >= a.nom_mail);}
else // cas enu = a.enu et nom_mail = a.nom_mail
{ if (ref_num_NE != a.ref_num_NE)
{return (ref_num_NE >= a.ref_num_NE);}
else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
{if (nom_var != a.nom_var)
{return (nom_var >= a.nom_var);}
else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
// et nom_var == a.nom_var
{if (temps != a.temps)
{return (temps <= a.temps);}
else // cas où tout est égal
{return true;};
};
};
};
};
};
// affichage
void VariablesExporter::Ddl_a_un_noeud::Affiche()
{ cout << "\n Variable utilisateur: " << nom_var
<< "ddl " << enu.Nom_plein()
<< " au_noeud_ref: " << ref_num_NE
<< " maillage: " << nom_mail
<< " temps= " << temps;
};
// ======== Ddl_etendu_a_un_noeud ============
// classe conteneur pour un ddl étendu à un noeud
ostream & operator << ( ostream & sort,const VariablesExporter::Ddl_etendu_a_un_noeud & a)
{ // récup du pointeur de la classe mère
const VariablesExporter::A_un_NE* aA = a.PointeurClass_const();
// sortie
sort << "\n Ddl_etendu_a_un_noeud_ ";
sort << *aA; // la classe mère
sort << " ddl_etendu_ "<< a.Enu_const() << " ";
// retour
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::Ddl_etendu_a_un_noeud & a)
{ // récup du pointeur de la classe mère
VariablesExporter::A_un_NE* aA = a.PointeurClass();
// lecture du type et vérification
string nomtype,toto; ent >> nomtype ;
if (nomtype != "Ddl_etendu_a_un_noeud_")
{ cout << "\n *** erreur en lecture: on attendait le mot cle Ddl_etendu_a_un_noeud_ et on a lue "
<< nomtype
<< "\n operator >> ( istream & ent, VariablesExporter::Ddl_etendu_a_un_noeud(...";
Sortie(1);
return ent;
};
// lecture de la partie mère
ent >> *aA;
// on vérifie également qu'il s'agit bien d'une ref de noeud
if (aA->Ref_NE()[0] != 'N')
{ cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
<< " erreur de syntaxe en lecture d'une reference de noeud ,"
<< " la premiere lettre "
<< " devraientt etre N et on a lu: "<<aA->Ref_NE() << " !!"
<< endl;
Sortie(1);
};
// lecture du ddl étendu
ent >> toto >> a.enu ;
return ent;
};
VariablesExporter::Ddl_etendu_a_un_noeud::Ddl_etendu_a_un_noeud () : // constructeur par défaut
A_un_NE(),enu() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::Ddl_etendu_a_un_noeud::Ddl_etendu_a_un_noeud
(Ddl_enum_etendu e,string ref_noeud,string nom_mail_,string nom_var_) :
A_un_NE(ref_noeud,nom_mail_,nom_var_)
,enu(e)
{};
// constructeur de copie
VariablesExporter::Ddl_etendu_a_un_noeud::Ddl_etendu_a_un_noeud (const Ddl_etendu_a_un_noeud& a) :
A_un_NE(a)
,enu(a.enu)
{};
// destructeur
VariablesExporter::Ddl_etendu_a_un_noeud::~Ddl_etendu_a_un_noeud()
{};
// opérateurs
VariablesExporter::Ddl_etendu_a_un_noeud& VariablesExporter::Ddl_etendu_a_un_noeud::operator=
(const VariablesExporter::Ddl_etendu_a_un_noeud& a)
{enu = a.enu;
*(this->PointeurClass()) = *(a.PointeurClass_const());
return (*this);
};
bool VariablesExporter::Ddl_etendu_a_un_noeud::operator== (const Ddl_etendu_a_un_noeud& a) const
{if ((enu ==a.enu)
&& (*(this->PointeurClass_const()) == *(a.PointeurClass_const())))
return true;
else
return false;
};
bool VariablesExporter::Ddl_etendu_a_un_noeud::operator< (const Ddl_etendu_a_un_noeud& a) const
{if (enu != a.enu)
{ return (enu < a.enu);}
else // cas enu = a.enu
{return (*(this->PointeurClass_const()) < *(a.PointeurClass_const()));}
};
bool VariablesExporter::Ddl_etendu_a_un_noeud::operator<= (const Ddl_etendu_a_un_noeud& a) const
{if (enu != a.enu)
{ return (enu <= a.enu);}
else // cas enu = a.enu
{return (*(this->PointeurClass_const()) <= *(a.PointeurClass_const()));}
};
bool VariablesExporter::Ddl_etendu_a_un_noeud::operator> (const Ddl_etendu_a_un_noeud& a) const
{if (enu != a.enu)
{ return (enu > a.enu);}
else // cas enu = a.enu
{return (*(this->PointeurClass_const()) > *(a.PointeurClass_const()));}
};
bool VariablesExporter::Ddl_etendu_a_un_noeud::operator>= (const Ddl_etendu_a_un_noeud& a) const
{if (enu != a.enu)
{ return (enu >= a.enu);}
else // cas enu = a.enu
{return (*(this->PointeurClass_const()) >= *(a.PointeurClass_const()));}
};
// affichage
void VariablesExporter::Ddl_etendu_a_un_noeud::Affiche()
{ A_un_NE::Affiche();
cout << " Ddl_etendu_a_un_noeud_ " << Enu() ;
};
// ======== Quelconque_a_un_noeud ============
// classe conteneur pour une grandeur quelconque à un noeud
ostream & operator << ( ostream & sort,const VariablesExporter::Quelconque_a_un_noeud & a)
{ // récup du pointeur de la classe mère
const VariablesExporter::A_un_NE* aA = a.PointeurClass_const();
// récup de l'énuméré du type quelconque
const TypeQuelconque_enum_etendu& quelc = a.Quelc_const();
// sortie
sort << "\n Quelconque_a_un_noeud_ " ;
sort << *aA; // la classe mère
sort << " grandeur_quelconque_ " << quelc.NomPlein() << " composante: " << a.num_ordre << " ";
// retour
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::Quelconque_a_un_noeud & a)
{ // récup du pointeur de la classe mère
VariablesExporter::A_un_NE* aA = a.PointeurClass();
// lecture du type et vérification
string nomtype,toto; ent >> nomtype ;
if (nomtype != "Quelconque_a_un_noeud_")
{ cout << "\n *** erreur en lecture: on attendait le mot cle Quelconque_a_un_noeud_ et on a lue "
<< nomtype
<< "\n operator >> ( istream & ent, VariablesExporter::Quelconque_a_un_noeud(...";
Sortie(1);
return ent;
};
// lecture de la partie mère
ent >> *aA;
// on vérifie également qu'il s'agit bien d'une ref de noeud
if (aA->Ref_NE()[0] != 'N')
{ cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
<< " erreur de syntaxe en lecture d'une reference de noeud ,"
<< " la premiere lettre "
<< " devraientt etre N et on a lu: "<<aA->Ref_NE() << " !!"
<< endl;
Sortie(1);
};
// lecture de la grandeur quelconque
string nom_quelc;
ent >> toto >> nom_quelc;
a.quelc = TypeQuelconque_enum_etendu(nom_quelc);
ent >> toto >> a.num_ordre;
return ent;
};
VariablesExporter::Quelconque_a_un_noeud::Quelconque_a_un_noeud () : // constructeur par défaut
A_un_NE(),quelc() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::Quelconque_a_un_noeud::Quelconque_a_un_noeud
(TypeQuelconque_enum_etendu e,string ref_noeud,string nom_mail_,string nom_var_,int num_ord) :
A_un_NE(ref_noeud,nom_mail_,nom_var_)
,quelc(e),num_ordre(num_ord)
{};
// constructeur de copie
VariablesExporter::Quelconque_a_un_noeud::Quelconque_a_un_noeud (const Quelconque_a_un_noeud& a) :
A_un_NE(a)
,quelc(a.quelc),num_ordre(a.num_ordre)
{};
// destructeur
VariablesExporter::Quelconque_a_un_noeud::~Quelconque_a_un_noeud()
{};
// opérateurs
VariablesExporter::Quelconque_a_un_noeud& VariablesExporter::Quelconque_a_un_noeud::operator=
(const VariablesExporter::Quelconque_a_un_noeud& a)
{quelc = a.quelc;num_ordre = a.num_ordre;
*(this->PointeurClass()) = *(a.PointeurClass_const());
return (*this);
};
bool VariablesExporter::Quelconque_a_un_noeud::operator== (const Quelconque_a_un_noeud& a) const
{if ((quelc==a.quelc) && (num_ordre == a.num_ordre)
&& (*(this->PointeurClass_const()) == *(a.PointeurClass_const())))
return true;
else
return false;
};
bool VariablesExporter::Quelconque_a_un_noeud::operator< (const Quelconque_a_un_noeud& a) const
{if (quelc != a.quelc)
{ return (quelc < a.quelc);}
else // cas quelc = a.quelc
{if (num_ordre != a.num_ordre)
{return (num_ordre < a.num_ordre); }
else
{return (*(this->PointeurClass_const()) < *(a.PointeurClass_const()));}
};
};
bool VariablesExporter::Quelconque_a_un_noeud::operator<= (const Quelconque_a_un_noeud& a) const
{if (quelc != a.quelc)
{ return (quelc <= a.quelc);}
else // cas quelc = a.quelc
{if (num_ordre != a.num_ordre)
{return (num_ordre <= a.num_ordre); }
else
{return (*(this->PointeurClass_const()) <= *(a.PointeurClass_const()));}
};
};
bool VariablesExporter::Quelconque_a_un_noeud::operator> (const Quelconque_a_un_noeud& a) const
{if (quelc != a.quelc)
{ return (quelc > a.quelc);}
else // cas quelc = a.quelc
{if (num_ordre != a.num_ordre)
{return (num_ordre > a.num_ordre); }
else
{return (*(this->PointeurClass_const()) > *(a.PointeurClass_const()));}
};
};
bool VariablesExporter::Quelconque_a_un_noeud::operator>= (const Quelconque_a_un_noeud& a) const
{if (quelc != a.quelc)
{ return (quelc >= a.quelc);}
else // cas quelc = a.quelc
{if (num_ordre != a.num_ordre)
{return (num_ordre >= a.num_ordre); }
else
{return (*(this->PointeurClass_const()) >= *(a.PointeurClass_const()));}
};
};
// affichage
void VariablesExporter::Quelconque_a_un_noeud::Affiche()
{ A_un_NE::Affiche();
cout << " quelconque_a_un_noeud_ " << quelc.NomPlein()
<< " composante: " << num_ordre ;
};
// ======== A_un_E ============
// classe conteneur pour un élément
ostream & operator << ( ostream & sort,const VariablesExporter::A_un_E & a)
{ // récup du pointeur de la classe mère
const VariablesExporter::A_un_NE* aA = a.PointeurClass_const();
// sortie
sort << *aA; // la classe mère
sort << " absolu_ " << a.absolu
<< " num_pti_ " << a.num_pti
<< " ";
// retour
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::A_un_E & a)
{ // récup du pointeur de la classe mère
VariablesExporter::A_un_NE* aA = a.PointeurClass();
// lecture du type et vérification
// lecture de la partie mère
ent >> *aA ;
// on vérifie également qu'il s'agit bien d'une ref d'élément
if (aA->Ref_NE()[0] != 'E')
{ cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
<< " erreur de syntaxe en lecture d'une reference d'element ,"
<< " la premiere lettre "
<< " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
<< endl;
Sortie(1);
};
string toto;
ent >> toto;
// lecture éventuelle du paramètre absolu
if (toto == "absolu_")
{ent >> a.absolu >> toto;}
else if (toto == "num_pti_")
{a.absolu = 1;}
else
{cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur,"
<< " on attendait soit la chaine de characteres: absolu_ ou soit num_pti_ "
<< " et on a lu: "<< toto << " !!"
<< endl;
Sortie(1);
} ;
// fin de la lecture
ent >> a.num_pti ;
return ent;
};
VariablesExporter::A_un_E::A_un_E () : // constructeur par défaut
A_un_NE(),num_pti(0),absolu(1) {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::A_un_E::A_un_E
(int absolu_,string ref
,string nom_mail_,string nom_var_,int nbpti) :
A_un_NE(ref,nom_mail_,nom_var_)
,num_pti(nbpti),absolu(absolu_)
{};
// constructeur de copie
VariablesExporter::A_un_E::A_un_E (const A_un_E& a) :
A_un_NE(a)
,num_pti(a.num_pti),absolu(a.absolu)
{};
// destructeur
VariablesExporter::A_un_E::~A_un_E()
{};
// opérateurs
VariablesExporter::A_un_E& VariablesExporter::A_un_E::operator=
(const VariablesExporter::A_un_E& a)
{num_pti=a.num_pti;
absolu = a.absolu;
*(this->PointeurClass()) = *(a.PointeurClass_const());
return (*this);
};
bool VariablesExporter::A_un_E::operator== (const A_un_E& a) const
{if (((num_pti==a.num_pti)&&(absolu ==a.absolu)
&& (*(this->PointeurClass_const()) == *(a.PointeurClass_const())))
)
return true;
else
return false;
};
bool VariablesExporter::A_un_E::operator< (const A_un_E& a) const
{ if (num_pti != a.num_pti)
{return (num_pti < a.num_pti);}
else // num_pti == a.num_pti
{if (absolu != a.absolu)
{return (absolu < a.absolu);}
else
{return (*(this->PointeurClass_const()) < *(a.PointeurClass_const()));}
}
};
bool VariablesExporter::A_un_E::operator<= (const A_un_E& a) const
{ if (num_pti != a.num_pti)
{return (num_pti <= a.num_pti);}
else // num_pti == a.num_pti
{if (absolu != a.absolu)
{return (absolu <= a.absolu);}
else
{return (*(this->PointeurClass_const()) <= *(a.PointeurClass_const()));}
}
};
bool VariablesExporter::A_un_E::operator> (const A_un_E& a) const
{ if (num_pti != a.num_pti)
{return (num_pti > a.num_pti);}
else // num_pti == a.num_pti
{if (absolu != a.absolu)
{return (absolu > a.absolu);}
else
{return (*(this->PointeurClass_const()) > *(a.PointeurClass_const()));}
};
};
bool VariablesExporter::A_un_E::operator>= (const A_un_E& a) const
{ if (num_pti != a.num_pti)
{return (num_pti >= a.num_pti);}
else // temps == a.temps et num_pti == a.num_pti
{if (absolu != a.absolu)
{return (absolu >= a.absolu);}
else
{return (*(this->PointeurClass_const()) >= *(a.PointeurClass_const()));}
}
};
// affichage
void VariablesExporter::A_un_E::Affiche()
{ A_un_NE::Affiche();
cout << " absolu= " << absolu
<< " num_pti= " << num_pti << " ";
};
// ======== Ddl_a_un_element ============
// classe conteneur pour un ddl à un élément
ostream & operator << ( ostream & sort,const VariablesExporter::Ddl_a_un_element & a)
{ // récup du pointeur de la classe mère
const VariablesExporter::A_un_E* aA = a.PointeurClass_E_const();
// sortie
sort << "\n Ddl_a_un_element_ ";
sort << *aA; // la classe mère
sort << " temps_ " << a.temps
<< " ddl_ "<< a.enu << " ";
// retour
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::Ddl_a_un_element & a)
{ // récup du pointeur de la classe mère
VariablesExporter::A_un_E* aA = a.PointeurClass_E();
// lecture du type et vérification
string nomtype,toto; ent >> nomtype ;
if (nomtype != "Ddl_a_un_element_")
{ cout << "\n *** erreur en lecture: on attendait le mot cle Ddl_a_un_element_ et on a lue "
<< nomtype
<< "\n operator >> ( istream & ent, VariablesExporter::Ddl_a_un_element(...";
Sortie(1);
return ent;
};
// lecture de la partie mère
ent >> *aA;
// on vérifie également qu'il s'agit bien d'une ref d'élément
if (aA->Ref_NE()[0] != 'E')
{ cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
<< " erreur de syntaxe en lecture d'une reference d'element ,"
<< " la premiere lettre "
<< " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
<< endl;
Sortie(1);
};
// lecture du ddl étendu
ent >> toto >> a.temps >> toto >> a.enu ;
return ent;
};
VariablesExporter::Ddl_a_un_element::Ddl_a_un_element () : // constructeur par défaut
A_un_E(),enu(),temps() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::Ddl_a_un_element::Ddl_a_un_element
(int absolu_,Ddl_enum_etendu e,string ref_NE
,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti) :
A_un_E(absolu_,ref_NE,nom_mail,nom_var,nbpti)
,enu(e),temps(tps)
{};
// constructeur de copie
VariablesExporter::Ddl_a_un_element::Ddl_a_un_element (const Ddl_a_un_element& a) :
A_un_E(a)
,enu(a.enu),temps(a.temps)
{};
// destructeur
VariablesExporter::Ddl_a_un_element::~Ddl_a_un_element()
{};
// opérateurs
VariablesExporter::Ddl_a_un_element& VariablesExporter::Ddl_a_un_element::operator=
(const VariablesExporter::Ddl_a_un_element& a)
{enu = a.enu;temps=a.temps;
*(this->PointeurClass()) = *(a.PointeurClass_E_const());
return (*this);
};
bool VariablesExporter::Ddl_a_un_element::operator== (const Ddl_a_un_element& a) const
{if ((enu ==a.enu) && (temps == a.temps)
&& (*(this->PointeurClass_E_const()) == *(a.PointeurClass_E_const())))
return true;
else
return false;
};
bool VariablesExporter::Ddl_a_un_element::operator< (const Ddl_a_un_element& a) const
{if (enu != a.enu)
{ return (enu < a.enu);}
else // cas enu = a.enu
{if (temps != a.temps)
{return (temps < a.temps);}
else
{return (*(this->PointeurClass_E_const()) < *(a.PointeurClass_E_const()));}
};
};
bool VariablesExporter::Ddl_a_un_element::operator<= (const Ddl_a_un_element& a) const
{if (enu != a.enu)
{ return (enu <= a.enu);}
else // cas enu = a.enu
{if (temps != a.temps)
{return (temps <= a.temps);}
else
{return (*(this->PointeurClass_E_const()) <= *(a.PointeurClass_E_const()));}
};
};
bool VariablesExporter::Ddl_a_un_element::operator> (const Ddl_a_un_element& a) const
{if (enu != a.enu)
{ return (enu > a.enu);}
else // cas enu = a.enu
{if (temps != a.temps)
{return (temps > a.temps);}
else
{return (*(this->PointeurClass_E_const()) > *(a.PointeurClass_E_const()));}
};
};
bool VariablesExporter::Ddl_a_un_element::operator>= (const Ddl_a_un_element& a) const
{if (enu != a.enu)
{ return (enu >= a.enu);}
else // cas enu = a.enu
{if (temps != a.temps)
{return (temps >= a.temps);}
else
{return (*(this->PointeurClass_E_const()) >= *(a.PointeurClass_E_const()));}
};
};
// affichage
void VariablesExporter::Ddl_a_un_element::Affiche()
{ A_un_E::Affiche();
cout << " Ddl_a_un_element_ " << Enu() << " temps_ " << temps ;
};
// ======== TypeQuelconque_a_un_element ============
// classe conteneur pour les grandeurs particulières à un élément
ostream & operator << ( ostream & sort,const VariablesExporter::TypeQuelconque_a_un_element & a)
{ // récup du pointeur de la classe mère
const VariablesExporter::A_un_E* aA = a.PointeurClass_Quelc_const();
// récup de l'énuméré du type quelconque
const TypeQuelconque_enum_etendu& quelc = a.Quelc_const();
// sortie
sort << *aA; // la classe mère
sort << " grandeur_quelconque_ " << quelc.NomPlein() << " composante: " << a.num_ordre << " ";
// retour
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::TypeQuelconque_a_un_element & a)
{ // récup du pointeur de la classe mère
VariablesExporter::A_un_E* aA = a.PointeurClass_Quelc();
// lecture de la partie mère
ent >> *aA;
// on vérifie également qu'il s'agit bien d'une ref d'élément
if (aA->Ref_NE()[0] != 'E')
{ cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
<< " erreur de syntaxe en lecture d'une reference d'element ,"
<< " la premiere lettre "
<< " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
<< endl;
Sortie(1);
};
// lecture de la grandeur quelconque
string toto,nom_quelc;
ent >> toto >> nom_quelc;
a.quelc = TypeQuelconque_enum_etendu(nom_quelc);
ent >> toto >> a.num_ordre;
return ent;
};
VariablesExporter::TypeQuelconque_a_un_element::TypeQuelconque_a_un_element () : // constructeur par défaut
A_un_E(),quelc() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::TypeQuelconque_a_un_element::TypeQuelconque_a_un_element
(int absolu_,TypeQuelconque_enum_etendu e,string ref_NE
,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti,int num_ord) :
A_un_E(absolu_,ref_NE,nom_mail,nom_var,nbpti)
,quelc(e),num_ordre(num_ord)
{};
// constructeur de copie
VariablesExporter::TypeQuelconque_a_un_element::TypeQuelconque_a_un_element (const TypeQuelconque_a_un_element& a) :
A_un_E(a)
,quelc(a.quelc),num_ordre(a.num_ordre)
{};
// destructeur
VariablesExporter::TypeQuelconque_a_un_element::~TypeQuelconque_a_un_element()
{};
// opérateurs
VariablesExporter::TypeQuelconque_a_un_element& VariablesExporter::TypeQuelconque_a_un_element::operator=
(const VariablesExporter::TypeQuelconque_a_un_element& a)
{quelc = a.quelc;num_ordre = a.num_ordre;
*(this->PointeurClass()) = *(a.PointeurClass_E_const());
return (*this);
};
bool VariablesExporter::TypeQuelconque_a_un_element::operator== (const TypeQuelconque_a_un_element& a) const
{if ((quelc ==a.quelc)&& (num_ordre == a.num_ordre)
&& (*(this->PointeurClass_E_const()) == *(a.PointeurClass_E_const())))
return true;
else
return false;
};
bool VariablesExporter::TypeQuelconque_a_un_element::operator< (const TypeQuelconque_a_un_element& a) const
{if (quelc != a.quelc)
{ return (quelc < a.quelc);}
else // cas quelc = a.quelc
{if (num_ordre != a.num_ordre)
{return (num_ordre < a.num_ordre); }
else
{return (*(this->PointeurClass_E_const()) < *(a.PointeurClass_E_const()));}
};
};
bool VariablesExporter::TypeQuelconque_a_un_element::operator<= (const TypeQuelconque_a_un_element& a) const
{if (quelc != a.quelc)
{ return (quelc <= a.quelc);}
else // cas quelc = a.quelc
{if (num_ordre != a.num_ordre)
{return (num_ordre <= a.num_ordre); }
else
{return (*(this->PointeurClass_E_const()) <= *(a.PointeurClass_E_const()));}
};
};
bool VariablesExporter::TypeQuelconque_a_un_element::operator> (const TypeQuelconque_a_un_element& a) const
{if (quelc != a.quelc)
{ return (quelc > a.quelc);}
else // cas quelc = a.quelc
{if (num_ordre != a.num_ordre)
{return (num_ordre > a.num_ordre); }
else
{return (*(this->PointeurClass_E_const()) > *(a.PointeurClass_E_const()));}
};
};
bool VariablesExporter::TypeQuelconque_a_un_element::operator>= (const TypeQuelconque_a_un_element& a) const
{if (quelc != a.quelc)
{ return (quelc >= a.quelc);}
else // cas enu = a.enu
{if (num_ordre != a.num_ordre)
{return (num_ordre >= a.num_ordre); }
else
{return (*(this->PointeurClass_E_const()) >= *(a.PointeurClass_E_const()));}
};
};
// ======== TypeParticulier_a_un_element ============
// classe conteneur pour les grandeurs particulières à un élément
ostream & operator << ( ostream & sort,const VariablesExporter::TypeParticulier_a_un_element & a)
{ // récup du pointeur de la classe mère
const VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc_const();
// récup de l'énuméré du type quelconque
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// const TypeQuelconque_enum_etendu& quelc = a.Quelc_const();
ajout des fichiers du répertoire Maillage - concerne les conditions limites, les maillages, les ddl en tout genre
2021-09-18 09:47:14 +02:00
// sortie
sort << "\n Particulier_a_un_element_ ";
sort << *aA; // la classe mère
// retour
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::TypeParticulier_a_un_element & a)
{ // récup du pointeur de la classe mère
VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc();
// lecture du type et vérification
string nomtype,toto; ent >> nomtype ;
if (nomtype != "Particulier_a_un_element_")
{ cout << "\n *** erreur en lecture: on attendait le mot cle Particulier_a_un_element_ et on a lue "
<< nomtype
<< "\n operator >> ( istream & ent, VariablesExporter::Particulier_a_un_element_(...";
Sortie(1);
return ent;
};
// lecture de la partie mère
ent >> *aA;
// on vérifie également qu'il s'agit bien d'une ref d'élément
if (aA->Ref_NE()[0] != 'E')
{ cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
<< " erreur de syntaxe en lecture d'une reference d'element ,"
<< " la premiere lettre "
<< " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
<< endl;
Sortie(1);
};
return ent;
};
// affichage
void VariablesExporter::TypeParticulier_a_un_element::Affiche()
{ A_un_E::Affiche();
cout << " grandeur_particuliere_a_un_element_ " << quelc.NomPlein()
<< " composante: " << num_ordre ;
};
// ======== TypeEvoluee_a_un_element ============
// classe conteneur pour les grandeurs évoluées à un élément
ostream & operator << ( ostream & sort,const VariablesExporter::TypeEvoluee_a_un_element & a)
{ // récup du pointeur de la classe mère
const VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc_const();
// récup de l'énuméré du type quelconque
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// const TypeQuelconque_enum_etendu& quelc = a.Quelc_const();
ajout des fichiers du répertoire Maillage - concerne les conditions limites, les maillages, les ddl en tout genre
2021-09-18 09:47:14 +02:00
// sortie
sort << "\n Evoluee_a_un_element_ ";
sort << *aA; // la classe mère
// retour
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::TypeEvoluee_a_un_element & a)
{ // récup du pointeur de la classe mère
VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc();
// lecture du type et vérification
string nomtype,toto; ent >> nomtype ;
if (nomtype != "Evoluee_a_un_element_")
{ cout << "\n *** erreur en lecture: on attendait le mot cle Evoluee_a_un_element_ et on a lue "
<< nomtype
<< "\n operator >> ( istream & ent, VariablesExporter::TypeEvoluee_a_un_element(...";
Sortie(1);
return ent;
};
// lecture de la partie mère
ent >> *aA;
// on vérifie également qu'il s'agit bien d'une ref d'élément
if (aA->Ref_NE()[0] != 'E')
{ cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
<< " erreur de syntaxe en lecture d'une reference d'element ,"
<< " la premiere lettre "
<< " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
<< endl;
Sortie(1);
};
return ent;
};
// affichage
void VariablesExporter::TypeEvoluee_a_un_element::Affiche()
{ A_un_E::Affiche();
cout << " grandeur_Evoluee_a_un_element_ " << quelc.NomPlein()
<< " composante: " << num_ordre ;
};
// ======== TypeQuelconque_a_Face_arete ============
// classe conteneur pour un TypeQuelconque à une face ou arête
ostream & operator << ( ostream & sort,const VariablesExporter::TypeQuelconque_a_Face_arete & a)
{ // récup du pointeur de la classe mère
const VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc_const();
// sortie
sort << *aA; // la classe mère
// num FA
sort << " num_FA_ "<< a.Num_FA_const() << " ";
// retour
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::TypeQuelconque_a_Face_arete & a)
{ // récup du pointeur de la classe mère
VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc();
// lecture de la partie mère
ent >> *aA;
// num FA
string toto;
ent >> toto >> a.Num_FA() ;
return ent;
};
VariablesExporter::TypeQuelconque_a_Face_arete::TypeQuelconque_a_Face_arete () : // constructeur par défaut
TypeQuelconque_a_un_element(),num_FA() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::TypeQuelconque_a_Face_arete::TypeQuelconque_a_Face_arete
(int absolu_,TypeQuelconque_enum_etendu e,string ref_element
,string nom_mail_,int nbFA, Enum_dure tps,string nom_var_,int nbpti,int num_ord) :
TypeQuelconque_a_un_element(absolu_,e,ref_element,nom_mail,tps,nom_var,nbpti,num_ord)
,num_FA(nbFA)
{};
// constructeur de copie
VariablesExporter::TypeQuelconque_a_Face_arete::TypeQuelconque_a_Face_arete (const TypeQuelconque_a_Face_arete& a) :
TypeQuelconque_a_un_element(a)
,num_FA(a.num_FA)
{};
// destructeur
VariablesExporter::TypeQuelconque_a_Face_arete::~TypeQuelconque_a_Face_arete()
{};
// opérateurs
VariablesExporter::TypeQuelconque_a_Face_arete& VariablesExporter::TypeQuelconque_a_Face_arete::operator=
(const VariablesExporter::TypeQuelconque_a_Face_arete& a)
{num_FA = a.num_FA;
*(this->PointClass_QuelcFA()) = *(a.PointClass_QuelcFA_const());
return (*this);
};
bool VariablesExporter::TypeQuelconque_a_Face_arete::operator== (const TypeQuelconque_a_Face_arete& a) const
{if ((num_FA ==a.num_FA)
&& (*(this->PointClass_QuelcFA_const()) == *(a.PointClass_QuelcFA_const())))
return true;
else
return false;
};
bool VariablesExporter::TypeQuelconque_a_Face_arete::operator< (const TypeQuelconque_a_Face_arete& a) const
{if (num_FA != a.num_FA)
{ return (num_FA < a.num_FA);}
else // cas num_FA = a.num_FA
{return (*(this->PointClass_QuelcFA_const()) < *(a.PointClass_QuelcFA_const()));}
};
bool VariablesExporter::TypeQuelconque_a_Face_arete::operator<= (const TypeQuelconque_a_Face_arete& a) const
{if (num_FA != a.num_FA)
{ return (num_FA <= a.num_FA);}
else // cas num_FA = a.num_FA
{return (*(this->PointClass_QuelcFA_const()) <= *(a.PointClass_QuelcFA_const()));}
};
bool VariablesExporter::TypeQuelconque_a_Face_arete::operator> (const TypeQuelconque_a_Face_arete& a) const
{if (num_FA != a.num_FA)
{ return (num_FA > a.num_FA);}
else // cas num_FA = a.num_FA
{return (*(this->PointClass_QuelcFA_const()) > *(a.PointClass_QuelcFA_const()));}
};
bool VariablesExporter::TypeQuelconque_a_Face_arete::operator>= (const TypeQuelconque_a_Face_arete& a) const
{if (num_FA != a.num_FA)
{ return (num_FA >= a.num_FA);}
else // cas num_FA = a.num_FA
{return (*(this->PointClass_QuelcFA_const()) >= *(a.PointClass_QuelcFA_const()));}
};
// ======== TypeQuelc_face_a_un_element ============
// classe conteneur pour les grandeurs quelconque à une face d'élément
ostream & operator << ( ostream & sort,const VariablesExporter::TypeQuelc_face_a_un_element & a)
{ // récup du pointeur de la classe mère
const VariablesExporter::TypeQuelconque_a_Face_arete* aA = a.PointClass_QuelcFA_const();
// sortie
sort << "\n Quelconque_face_element_ ";
sort << *aA; // la classe mère
// retour
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::TypeQuelc_face_a_un_element & a)
{ // récup du pointeur de la classe mère
VariablesExporter::TypeQuelconque_a_Face_arete* aA = a.PointClass_QuelcFA();
// lecture du type et vérification
string nomtype,toto; ent >> nomtype ;
if (nomtype != "Quelconque_face_element_")
{ cout << "\n *** erreur en lecture: on attendait le mot cle Quelconque_face_element_ et on a lue "
<< nomtype
<< "\n operator >> ( istream & ent, VariablesExporter::TypeQuelc_face_a_un_element(...";
Sortie(1);
return ent;
};
// lecture de la partie mère
ent >> *aA;
// on vérifie également qu'il s'agit bien d'une ref d'élément
if (aA->Ref_NE()[0] != 'E')
{ cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
<< " erreur de syntaxe en lecture d'une reference d'element ,"
<< " la premiere lettre "
<< " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
<< endl;
Sortie(1);
};
return ent;
};
// affichage
void VariablesExporter::TypeQuelc_face_a_un_element::Affiche()
{ cout << (*this) ;
};
// ======== TypeQuelc_arete_a_un_element ============
// classe conteneur pour les grandeurs quelconque à une arete d'élément
ostream & operator << ( ostream & sort,const VariablesExporter::TypeQuelc_arete_a_un_element & a)
{ // récup du pointeur de la classe mère
const VariablesExporter::TypeQuelconque_a_Face_arete* aA = a.PointClass_QuelcFA_const();
// sortie
sort << "\n Quelconque_arete_element_ ";
sort << *aA; // la classe mère
// retour
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::TypeQuelc_arete_a_un_element & a)
{ // récup du pointeur de la classe mère
VariablesExporter::TypeQuelconque_a_Face_arete* aA = a.PointClass_QuelcFA();
// lecture du type et vérification
string nomtype,toto; ent >> nomtype ;
if (nomtype != "Quelconque_arete_element_")
{ cout << "\n *** erreur en lecture: on attendait le mot cle Quelconque_arete_element_ et on a lue "
<< nomtype
<< "\n operator >> ( istream & ent, VariablesExporter::TypeQuelc_arete_a_un_element(...";
Sortie(1);
return ent;
};
// lecture de la partie mère
ent >> *aA;
// on vérifie également qu'il s'agit bien d'une ref d'élément
if (aA->Ref_NE()[0] != 'E')
{ cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
<< " erreur de syntaxe en lecture d'une reference d'element ,"
<< " la premiere lettre "
<< " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
<< endl;
Sortie(1);
};
return ent;
};
// affichage
void VariablesExporter::TypeQuelc_arete_a_un_element::Affiche()
{ cout << (*this) ;
};
// ======== TypeQuelc_Une_composante_Grandeur_globale ============
// classe conteneur pour une composante de grandeur globale
ostream & operator << ( ostream & sort,const VariablesExporter::TypeQuelc_Une_composante_Grandeur_globale & a)
{ // sortie
sort << "\n Une_composante_Grandeur_globale_ ";
sort << a.var.nom1 << " " << a.var.nom2 << " composante: " << a.var.n << " ";
// retour
return sort;
};
istream & operator >> ( istream & ent, VariablesExporter::TypeQuelc_Une_composante_Grandeur_globale & a)
{ // lecture du type et vérification
string nomtype,toto; ent >> nomtype ;
if (nomtype != "Une_composante_Grandeur_globale_")
{ cout << "\n *** erreur en lecture: on attendait le mot cle Une_composante_Grandeur_globale_ et on a lue "
<< nomtype
<< "\n operator >> ( istream & ent, VariablesExporter::TypeQuelc_Une_composante_Grandeur_globale(...";
Sortie(1);
return ent;
};
// lecture des infos
ent >> a.var.nom1 >> a.var.nom2 >> toto >> a.var.n;
// vérif il faut que les 3 premiers caractères de a.nom_var soit un VR_
if (!((a.var.nom1[0]== 'V')&&(a.var.nom1[1]== 'R')&&(a.var.nom1[2]== '_')))
{ cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur,"
<< " les 3 premieres lettres "
<< " devraientt etre un 'VR_' et on a lu: "<<a.var.nom1 << " !!"
<< endl;
Sortie(1);
};
if (toto != "composante:")
{ cout << "\n *** erreur en lecture: on attendait le mot cle composante: et on a lue "
<< toto
<< "\n operator >> ( istream & ent, VariablesExporter::TypeQuelc_Une_composante_Grandeur_globale(...";
Sortie(1);
return ent;
};
return ent;
};
// affichage
void VariablesExporter::TypeQuelc_Une_composante_Grandeur_globale::Affiche()
{ cout << (*this) ;
};
//--------------------------- VariablesExporter --------------
// CONSTRUCTEURS :
// Constructeur par defaut
VariablesExporter::VariablesExporter ():
li_Q(),li_nom()
// ----- les variables
// -> noeuds
,list_noeud_type_ddl()
,list_noeud_type_ddlEtendu()
,list_noeud_type_quelconque()
// -> éléments
,list_element_type_ddl()
,list_element_type_particulier(),list_quelc_element_type_particulier()
,list_element_type_evoluee()
,list_quelc_element_type_evoluee()
// -> face d'éléments
,list_face_element_type_quelc()
,list_quelc_face_element_type_quelc()
// -> arête d'éléments
,list_arete_element_type_quelc()
,list_quelc_arete_element_type_quelc()
// -> une composante d'une variable globale de type multidimentionnel
,list_var_glob_sur_grandeur_globale()
,initiaConteneurQuelconque(false)
{
};
// Constructeur de copie,
VariablesExporter::VariablesExporter (const VariablesExporter& a):
li_Q(a.li_Q),li_nom(a.li_nom)
// ----- les variables
// -> noeuds
,list_noeud_type_ddl(a.list_noeud_type_ddl)
,list_noeud_type_ddlEtendu(a.list_noeud_type_ddlEtendu)
,list_noeud_type_quelconque(a.list_noeud_type_quelconque)
// -> éléments
,list_element_type_ddl(a.list_element_type_ddl)
,list_element_type_particulier(a.list_element_type_particulier)
,list_quelc_element_type_particulier(a.list_quelc_element_type_particulier)
,list_element_type_evoluee(a.list_element_type_evoluee)
,list_quelc_element_type_evoluee(a.list_quelc_element_type_evoluee)
// -> face d'éléments
,list_face_element_type_quelc(a.list_face_element_type_quelc)
,list_quelc_face_element_type_quelc(a.list_quelc_face_element_type_quelc)
// -> arête d'éléments
,list_arete_element_type_quelc(a.list_arete_element_type_quelc)
,list_quelc_arete_element_type_quelc(a.list_quelc_arete_element_type_quelc)
// -> une composante d'une variable globale de type multidimentionnel
,list_var_glob_sur_grandeur_globale(a.list_var_glob_sur_grandeur_globale)
,initiaConteneurQuelconque(a.initiaConteneurQuelconque)
{
};
VariablesExporter::~VariablesExporter()
// Destructeur
{
};
// lecture
void VariablesExporter::LectureVariablesExporter(UtilLecture * entreePrinc)
{ if (ParaGlob::NiveauImpression() >= 5) cout << " debut de lecture des constantes et variables a exporter globalement " << endl;
// 1) cas des constantes
LecConstantesUtilisateur(*entreePrinc);
LecVariablesUtilisateur(*entreePrinc);
};
// affichage et definition interactive des commandes
// cas = 1: interactif complet
// cas = 2: entrée uniquement de noms de fichier
void VariablesExporter::Info_commande_VariablesExporters(UtilLecture * entreePrinc)
{ Info_commande_ConstantesUtilisateur(entreePrinc);
Info_commande_VariablesUtilisateur(entreePrinc);
};
// insertion des constantes et variables utilisateurs vers globales
void VariablesExporter::InsertConstVarUtilisateur_dans_globale()
{InsertConstUtilisateur_dans_globale();
Insert_VarUtilisateur_dans_globale();
};
// initialisation des conteneurs quelconques
// création des conteneurs aux noeuds s'il s'agit d'une variable
// associée à un vecteur global (au sens des algorithmes globaux)
void VariablesExporter::InitialisationConteneursQuelconques(LesMaillages& lesMail
,const List_io < TypeQuelconque >& listeVecGlob,const LesReferences& lesRef)
{ if (!initiaConteneurQuelconque)
{ // on commence par récupérer les conteneurs disponibles
// on se met en absolu par défaut -> le conteneur le + grand
// ---> pourrait poser pb, si ensuite le conteneur diminue !! à surveiller !
bool absolu = true;
Tableau <List_io < TypeQuelconque > > tabelement_typeParti
(lesMail.Les_type_de_donnees_particulieres_par_element(absolu));
// idem mais sous forme de grandeurs évoluées
Tableau <List_io < TypeQuelconque > > tabelement_evoluee
(lesMail.Les_type_de_donnees_evolues_internes_par_element(absolu));
// pour les faces et arêtes
Tableau <List_io < TypeQuelconque > >tab_F_element_TypeQuelconque
(lesMail.Les_type_de_donnees_evolues_internes_par_face_element(absolu));
Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque
(lesMail.Les_type_de_donnees_evolues_internes_par_arete_element(absolu));
// on passe en revue les grandeurs pour définir les conteneurs associés
// --- cas des grandeurs particulières aux pti d'élément
{list_quelc_element_type_particulier.clear(); // init
List_io < TypeParticulier_a_un_element >::iterator
il,ilfin=list_element_type_particulier.end();
for (il = list_element_type_particulier.begin(); il != ilfin;il++)
{// on vérifie qu'elle appartient à la liste des grandeurs disponibles
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
TypeQuelconque a((*il).Quelc_const()); // création d'un type quelconque sans grandeur
List_io<TypeQuelconque>& tpg = (tabelement_typeParti(n_mail)); // pour simplifier
if (find(tpg.begin(),tpg.end(),a) != tpg.end())
{ // il existe -> enregistrement
List_io<TypeQuelconque>::iterator it = find(tpg.begin(),tpg.end(),a); // récup du réel type
list_quelc_element_type_particulier.push_back(*it);
}
else
{ cout << "\n *** erreur dans l'initialisation de la variable utilisateur "
<< (*il).Nom_var() << " la grandeur associee " << (*il).Quelc_const().NomPlein()
<< " n'existe pas !! "
<< "\n VariablesExporter::InitialisationConteneursQuelconques(..." << flush;
(*il).Affiche();
Sortie(1);
};
};
};
// --- cas des grandeurs évoluées aux pti d'élément
{list_quelc_element_type_evoluee.clear(); // init
List_io < TypeEvoluee_a_un_element >::iterator
il,ilfin=list_element_type_evoluee.end();
for (il = list_element_type_evoluee.begin(); il != ilfin;il++)
{// on vérifie qu'elle appartient à la liste des grandeurs disponibles
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
TypeQuelconque a((*il).Quelc_const()); // création d'un type quelconque sans grandeur
List_io<TypeQuelconque>& tpg = (tabelement_typeParti(n_mail)); // pour simplifier
if (find(tpg.begin(),tpg.end(),a) != tpg.end())
{ // il existe -> enregistrement
List_io<TypeQuelconque>::iterator it = find(tpg.begin(),tpg.end(),a); // récup du réel type
list_quelc_element_type_evoluee.push_back(*it);
}
else
{ cout << "\n *** erreur dans l'initialisation de la variable utilisateur "
<< (*il).Nom_var() << " la grandeur associee " << (*il).Quelc_const().NomPlein()
<< " n'existe pas !! "
<< "\n VariablesExporter::InitialisationConteneursQuelconques(..." << flush;
(*il).Affiche();
Sortie(1);
};
};
};
// --- cas des grandeurs quelconques aux pti de faces d'élément
{list_quelc_face_element_type_quelc.clear(); // init
List_io < TypeQuelc_face_a_un_element >::iterator
il,ilfin=list_face_element_type_quelc.end();
for (il = list_face_element_type_quelc.begin(); il != ilfin;il++)
{// on vérifie qu'elle appartient à la liste des grandeurs disponibles
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
TypeQuelconque a((*il).Quelc_const()); // création d'un type quelconque sans grandeur
List_io<TypeQuelconque>& tpg = (tab_F_element_TypeQuelconque(n_mail)); // pour simplifier
if (find(tpg.begin(),tpg.end(),a) != tpg.end())
{ // il existe -> enregistrement
List_io<TypeQuelconque>::iterator it = find(tpg.begin(),tpg.end(),a); // récup du réel type
list_quelc_face_element_type_quelc.push_back(*it);
}
else
{ cout << "\n *** erreur dans l'initialisation de la variable utilisateur "
<< (*il).Nom_var() << " la grandeur associee " << (*il).Quelc_const().NomPlein()
<< " n'existe pas !! "
<< "\n VariablesExporter::InitialisationConteneursQuelconques(..." << flush;
(*il).Affiche();
Sortie(1);
};
};
};
// --- cas des grandeurs quelconques aux pti d'arêtes d'élément
{list_quelc_arete_element_type_quelc.clear(); // init
List_io < TypeQuelc_arete_a_un_element >::iterator
il,ilfin=list_arete_element_type_quelc.end();
for (il = list_arete_element_type_quelc.begin(); il != ilfin;il++)
{// on vérifie qu'elle appartient à la liste des grandeurs disponibles
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
TypeQuelconque a((*il).Quelc_const()); // création d'un type quelconque sans grandeur
List_io<TypeQuelconque>& tpg = (tab_A_element_TypeQuelconque(n_mail)); // pour simplifier
if (find(tpg.begin(),tpg.end(),a) != tpg.end())
{ // il existe -> enregistrement
List_io<TypeQuelconque>::iterator it = find(tpg.begin(),tpg.end(),a); // récup du réel type
list_quelc_arete_element_type_quelc.push_back(*it);
}
else
{ cout << "\n *** erreur dans l'initialisation de la variable utilisateur "
<< (*il).Nom_var() << " la grandeur associee " << (*il).Quelc_const().NomPlein()
<< " n'existe pas !! "
<< "\n VariablesExporter::InitialisationConteneursQuelconques(..." << flush;
(*il).Affiche();
Sortie(1);
};
};
};
// --- traitement particulier pour les noeuds
{// dans le cas où il y a des vecteurs globaux qui ont été retenus,
// il faut définir aux noeuds des conteneurs adéquates
if ((listeVecGlob.size() != 0) && (list_noeud_type_quelconque.size() != 0))
{ // on boucle sur les var de noeud: a priori c'est le nombre le plus petit
List_io <Quelconque_a_un_noeud>::iterator il,ilfin=list_noeud_type_quelconque.end();
for(il= list_noeud_type_quelconque.begin();il != ilfin; il++)
{// on boucle sur les vecteurs globaux pour savoir s'il y en a un qui correspond
List_io < TypeQuelconque >::const_iterator it,itfin = listeVecGlob.end();
for (it=listeVecGlob.begin();it != itfin;it++)
{//cout << "\n (*it) "<<(*it).EnuTypeQuelconque().NomPlein()
// << " *il "<< (*il).Quelc().NomPlein() << flush;
if ((*it).EnuTypeQuelconque() == (*il).Quelc())
{ // récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
int nmail = 1;
if ((*il).Nom_mail() != "")
nmail = lesMail.NumMaillage((*il).Nom_mail());
Noeud * noo = & lesMail.Noeud_LesMaille(nmail,ne);
noo->AjoutUnTypeQuelconque(*it);
};
};
};
};
};
initiaConteneurQuelconque=true; // pour une initialisation unique
}
};
// insertion et stockage des variables au niveau de ParaGlob
void VariablesExporter::Insert_VarUtilisateur_dans_globale()
{
// --- cas des ddl aux noeuds: list_noeud_type_ddl
{List_io < Ddl_a_un_noeud >::iterator il,ilfin=list_noeud_type_ddl.end();
for (il=list_noeud_type_ddl.begin();il != ilfin;il++)
{ Ddl_a_un_noeud& dan = *il; // pour simplifier
// on regarde si la grandeur existe déjà
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
if (pointe != NULL)
{cout << "\n *** pb dans dans la def de la variable utilisateur globale "<< dan.Nom_var()
<< " elle existe deja !! , ce n'est pas normal "
<< "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
<< endl;
Sortie(1);
}
else // sinon c'est ok, on la défini
{// on crée un conteneur d'un double
double val=0;
Grandeur_scalaire_double grand_courant(val);
switch (dan.Temps())
{case TEMPS_0 :
{TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0,NU_DDL,grand_courant);
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
break;
}
case TEMPS_t :
{TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T,NU_DDL,grand_courant);
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
break;
}
case TEMPS_tdt :
{TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT,NU_DDL,grand_courant);
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
break;
}
default :
cout << "\nErreur : valeur incorrecte du temps pour une variable ddl globale !\n";
cout << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(... \n";
Sortie(1);
};
};
};
};
// --- cas des ddl étendus aux noeuds: list_noeud_type_ddlEtendu
{List_io < Ddl_etendu_a_un_noeud >::iterator il,ilfin=list_noeud_type_ddlEtendu.end();
for (il=list_noeud_type_ddlEtendu.begin();il != ilfin;il++)
{ Ddl_etendu_a_un_noeud& dan = *il; // pour simplifier
// on regarde si la grandeur existe déjà
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
if (pointe != NULL)
{cout << "\n *** pb dans dans la def de la variable utilisateur globale "<< dan.Nom_var()
<< " elle existe deja !! , ce n'est pas normal "
<< "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
<< endl;
Sortie(1);
}
else // sinon c'est ok, on la défini
{// on crée un conteneur d'un double
double val=0;
Grandeur_scalaire_double grand_courant(val);
TypeQuelconque typQ1(UN_DDL_ENUM_ETENDUE,NU_DDL,grand_courant);
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
};
};
};
// --- cas des grandeurs quelconques aux noeuds: list_noeud_type_quelconque
{List_io < Quelconque_a_un_noeud >::iterator il,ilfin=list_noeud_type_quelconque.end();
for (il=list_noeud_type_quelconque.begin();il != ilfin;il++)
{ Quelconque_a_un_noeud& dan = *il; // pour simplifier
// on regarde si la grandeur existe déjà
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
if (pointe != NULL)
{cout << "\n *** pb dans dans la def de la variable utilisateur globale "<< dan.Nom_var()
<< " elle existe deja !! , ce n'est pas normal "
<< "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
<< endl;
Sortie(1);
}
else // sinon c'est ok, on la défini
{// on insert un conteneur double associé
VariablesExporter::InsertCompGrandeurQuelc(dan.Nom_var(),dan.Quelc_const());
};
};
};
// --- cas des ddl pur à un pti d'élément : list_element_type_ddl
{List_io < Ddl_a_un_element >::iterator il,ilfin=list_element_type_ddl.end();
for (il=list_element_type_ddl.begin();il != ilfin;il++)
{ Ddl_a_un_element& dan = *il; // pour simplifier
// on regarde si la grandeur existe déjà
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
if (pointe != NULL)
{cout << "\n *** pb dans dans la def de la variable utilisateur globale "<< dan.Nom_var()
<< " elle existe deja !! , ce n'est pas normal "
<< "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
<< endl;
Sortie(1);
}
else // sinon c'est ok, on la défini
{// on crée un conteneur d'un double
double val=0;
Grandeur_scalaire_double grand_courant(val);
switch (dan.Temps())
{case TEMPS_0 :
{TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0,NU_DDL,grand_courant);
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
break;
}
case TEMPS_t :
{TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T,NU_DDL,grand_courant);
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
break;
}
case TEMPS_tdt :
{TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT,NU_DDL,grand_courant);
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
break;
}
default :
cout << "\nErreur : valeur incorrecte du temps pour une variable ddl globale !\n";
cout << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(... \n";
Sortie(1);
};
};
};
};
// --- cas des grandeurs particulières aux éléments: list_element_type_particulier
{List_io < TypeParticulier_a_un_element >::iterator il,ilfin=list_element_type_particulier.end();
for (il=list_element_type_particulier.begin();il != ilfin;il++)
{ TypeParticulier_a_un_element& dan = *il; // pour simplifier
// on regarde si la grandeur existe déjà
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
if (pointe != NULL)
{cout << "\n *** pb dans dans la def de la variable utilisateur globale "<< dan.Nom_var()
<< " elle existe deja !! , ce n'est pas normal "
<< "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
<< endl;
Sortie(1);
}
else // sinon c'est ok, on la défini
{// on insert un conteneur double associé
VariablesExporter::InsertCompGrandeurQuelc(dan.Nom_var(),dan.Quelc_const());
};
};
};
// --- cas des grandeurs évoluées aux éléments: list_element_type_evoluee
{List_io < TypeEvoluee_a_un_element >::iterator il,ilfin=list_element_type_evoluee.end();
for (il=list_element_type_evoluee.begin();il != ilfin;il++)
{ TypeEvoluee_a_un_element& dan = *il; // pour simplifier
// on regarde si la grandeur existe déjà
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
if (pointe != NULL)
{cout << "\n *** pb dans dans la def de la variable utilisateur globale "<< dan.Nom_var()
<< " elle existe deja !! , ce n'est pas normal "
<< "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
<< endl;
Sortie(1);
}
else // sinon c'est ok, on la défini
{// on insert un conteneur double associé
VariablesExporter::InsertCompGrandeurQuelc(dan.Nom_var(),dan.Quelc_const());
};
};
};
// --- cas des grandeurs quelconques aux pti de faces d'éléments: list_face_element_type_quelc
{List_io < TypeQuelc_face_a_un_element >::iterator il,ilfin=list_face_element_type_quelc.end();
for (il=list_face_element_type_quelc.begin();il != ilfin;il++)
{ TypeQuelc_face_a_un_element& dan = *il; // pour simplifier
// on regarde si la grandeur existe déjà
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
if (pointe != NULL)
{cout << "\n *** pb dans dans la def de la variable utilisateur globale "<< dan.Nom_var()
<< " elle existe deja !! , ce n'est pas normal "
<< "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
<< endl;
Sortie(1);
}
else // sinon c'est ok, on la défini
{// on insert un conteneur double associé
VariablesExporter::InsertCompGrandeurQuelc(dan.Nom_var(),dan.Quelc_const());
};
};
};
// --- cas des grandeurs quelconques aux pti d'arête d'éléments: list_arete_element_type_quelc
{List_io < TypeQuelc_arete_a_un_element >::iterator il,ilfin=list_arete_element_type_quelc.end();
for (il=list_arete_element_type_quelc.begin();il != ilfin;il++)
{ TypeQuelc_arete_a_un_element& dan = *il; // pour simplifier
// on regarde si la grandeur existe déjà
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
if (pointe != NULL)
{cout << "\n *** pb dans dans la def de la variable utilisateur globale "<< dan.Nom_var()
<< " elle existe deja !! , ce n'est pas normal "
<< "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
<< endl;
Sortie(1);
}
else // sinon c'est ok, on la défini
{// on insert un conteneur double associé
VariablesExporter::InsertCompGrandeurQuelc(dan.Nom_var(),dan.Quelc_const());
};
};
};
// --- cas d'une composante d'une variable globale de type multidimentionnel
{List_io <TypeQuelc_Une_composante_Grandeur_globale >::iterator
il,ilfin=list_var_glob_sur_grandeur_globale.end();
for (il=list_var_glob_sur_grandeur_globale.begin();il != ilfin;il++)
{ TypeQuelc_Une_composante_Grandeur_globale& dan = *il; // pour simplifier
// on regarde si la grandeur existe déjà
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
if (pointe != NULL)
{cout << "\n *** pb dans dans la def de la variable utilisateur globale "<< dan.Nom_var()
<< " elle existe deja !! , ce n'est pas normal "
<< "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
<< endl;
Sortie(1);
}
else // sinon c'est ok, on la défini
{// on insert un conteneur double nommé et indicé associé
double val=0;
Grandeur_Double_Nommer_indicer grand_courant(dan.Nom_grandeur_globale(),val,dan.Indice_const());
TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT,NU_DDL,grand_courant);
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
};
};
};
};
// Affiche l'ensemble des variables et constantes utilisateur
void VariablesExporter::Affiche () const
{ cout << "\n\t\t*** constantes et Variables exportees globalement ***\n\n";
// -- cas des Constantes utilisateurs ---
cout << "\n ===constantes_utilisateur==== ";
{ List_io < Ddl_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddl.end();
List_io < string >::const_iterator il = li_nom.begin();
for (it = list_noeud_type_ddl.begin();it != itfin; it++,il++)
cout << "\n double_ " << (*il) ;
};
// -- cas des variables utilisateurs ---
cout << "\n ===variables_utilisateur==== ";
{ List_io < Ddl_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddl.end();
for (it = list_noeud_type_ddl.begin();it != itfin; it++)
cout << (*it);
};
// -- cas des ddl étendu aux noeuds ---
{ List_io < Ddl_etendu_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddlEtendu.end();
for (it = list_noeud_type_ddlEtendu.begin();it != itfin; it++)
cout << (*it);
};
// -- cas des grandeurs quelconques aux noeuds ---
{ List_io < Quelconque_a_un_noeud >::const_iterator it, itfin = list_noeud_type_quelconque.end();
for (it = list_noeud_type_quelconque.begin();it != itfin; it++)
cout << (*it);
};
// -- cas des ddl aux pti d'éléments ---
{ List_io < Ddl_a_un_element >::const_iterator it, itfin = list_element_type_ddl.end();
for (it = list_element_type_ddl.begin();it != itfin; it++)
cout << (*it);
};
// -- cas des grandeurs particulières aux pti d'éléments ---
{ List_io < TypeParticulier_a_un_element >::const_iterator it, itfin = list_element_type_particulier.end();
for (it = list_element_type_particulier.begin();it != itfin; it++)
cout << (*it);
};
// -- cas des grandeurs évoluées aux pti d'éléments ---
{ List_io < TypeEvoluee_a_un_element >::const_iterator it, itfin = list_element_type_evoluee.end();
for (it = list_element_type_evoluee.begin();it != itfin; it++)
cout << (*it);
};
// -- cas des grandeurs quelconques aux pti de faces d'éléments ---
{ List_io < TypeQuelc_face_a_un_element >::const_iterator it, itfin = list_face_element_type_quelc.end();
for (it = list_face_element_type_quelc.begin();it != itfin; it++)
cout << (*it);
};
// -- cas des grandeurs quelconques aux pti d'arête d'éléments ---
{ List_io < TypeQuelc_arete_a_un_element >::const_iterator it, itfin = list_arete_element_type_quelc.end();
for (it = list_arete_element_type_quelc.begin();it != itfin; it++)
cout << (*it);
};
// -- cas d'une composante d'une variable globale de type multidimentionnel ---
{ List_io < TypeQuelc_Une_composante_Grandeur_globale >::const_iterator it, itfin = list_var_glob_sur_grandeur_globale.end();
for (it = list_var_glob_sur_grandeur_globale.begin();it != itfin; it++)
cout << (*it);
};
};
// Surcharge de l'operateur = : realise l'egalite entre deux instances
VariablesExporter&
VariablesExporter::operator= (VariablesExporter& a)
{ li_Q=a.li_Q; li_nom=a.li_nom;
// ----- les variables
// -> noeuds
list_noeud_type_ddl = a.list_noeud_type_ddl;
list_noeud_type_ddlEtendu=a.list_noeud_type_ddlEtendu;
list_noeud_type_quelconque = a.list_noeud_type_quelconque;
// -> éléments
list_element_type_ddl = a.list_element_type_ddl;
list_element_type_particulier = a.list_element_type_particulier;
list_quelc_element_type_particulier = a.list_quelc_element_type_particulier;
list_element_type_evoluee = a.list_element_type_evoluee;
list_quelc_element_type_evoluee = a.list_quelc_element_type_evoluee;
// -> face d'éléments
list_face_element_type_quelc = a.list_face_element_type_quelc;
list_quelc_face_element_type_quelc = a.list_quelc_face_element_type_quelc;
// -> arête d'éléments
list_arete_element_type_quelc = a.list_arete_element_type_quelc;
list_quelc_arete_element_type_quelc = a.list_quelc_arete_element_type_quelc;
// -> une composante d'une variable globale de type multidimentionnel
list_var_glob_sur_grandeur_globale = a.list_var_glob_sur_grandeur_globale;
return (*this);
};
// test si toutes les informations des maillages sont completes
// = true -> complet
// = false -> incomplet
bool VariablesExporter::Complet_VariablesExporter(const LesReferences& lesRef)
{ bool res = true; // init
// ***vérifier que toutes les variables ont des noms différents
// a priori c'est ok vu que la vérif est déjà effectuée à la lecture
// on va vérifier que toutes les références sont correctes
// --- cas des ddl aux noeuds
{List_io < Ddl_a_un_noeud >::iterator il,ilfin = list_noeud_type_ddl.end();
for (il = list_noeud_type_ddl.begin();il != ilfin;il++)
{Ddl_a_un_noeud& dan = *il; // pour simplifier
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_Num_NE(),point_mail));
// on vérifie qu'il s'agit d'une ref de noeud
if (ref.Indic() != 1)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " n'est pas associee a une reference de noeud "
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
// on vérifie qu'il n'y a qu'un seule numéro de noeud
if (ref.Taille() != 1)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " est associee a une reference qui comporte "
<< ref.Taille() << " noeud(s) alors qu'il ne faut qu'un seul noeud !"
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
};
};
// --- cas des ddl étendus aux noeuds
{List_io < Ddl_etendu_a_un_noeud >::iterator il,ilfin = list_noeud_type_ddlEtendu.end();
for (il = list_noeud_type_ddlEtendu.begin();il != ilfin;il++)
{Ddl_etendu_a_un_noeud& dan = *il; // pour simplifier
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
// on vérifie qu'il s'agit d'une ref de noeud
if (ref.Indic() != 1)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " n'est pas associee a une reference de noeud "
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
// on vérifie qu'il n'y a qu'un seule numéro de noeud
if (ref.Taille() != 1)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " est associee a une reference qui comporte "
<< ref.Taille() << " noeud(s) alors qu'il ne faut qu'un seul noeud !"
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
};
};
// --- cas des grandeurs quelconques aux noeuds
{List_io < Quelconque_a_un_noeud >::iterator il,ilfin = list_noeud_type_quelconque.end();
for (il = list_noeud_type_quelconque.begin();il != ilfin;il++)
{Quelconque_a_un_noeud& dan = *il; // pour simplifier
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
// on vérifie qu'il s'agit d'une ref de noeud
if (ref.Indic() != 1)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " n'est pas associee a une reference de noeud "
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
// on vérifie qu'il n'y a qu'un seule numéro de noeud
if (ref.Taille() != 1)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " est associee a une reference qui comporte "
<< ref.Taille() << " noeud(s) alors qu'il ne faut qu'un seul noeud !"
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
};
};
// --- cas des ddl aux pti d'élément
{List_io < Ddl_a_un_element >::iterator il,ilfin = list_element_type_ddl.end();
for (il = list_element_type_ddl.begin();il != ilfin;il++)
{Ddl_a_un_element& dan = *il; // pour simplifier
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
// on vérifie qu'il s'agit d'une ref d'élément
if (ref.Indic() != 2)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " n'est pas associee a une reference d'element' "
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
// on vérifie qu'il n'y a qu'un seule numéro d'élément
if (ref.Taille() != 1)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " est associee a une reference qui comporte "
<< ref.Taille() << " element(s) alors qu'il ne faut qu'un seul element !"
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
};
};
// --- cas des grandeurs particulières aux pti d'élément
{List_io < TypeParticulier_a_un_element >::iterator il,ilfin
= list_element_type_particulier.end();
List_io < TypeQuelconque >::iterator it = list_quelc_element_type_particulier.begin();
// on balaie la liste avec les conteneurs associés
for (il = list_element_type_particulier.begin();il != ilfin;il++,it++)
{TypeParticulier_a_un_element& dan = *il; // pour simplifier
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
// on vérifie qu'il s'agit d'une ref d'élément
if (ref.Indic() != 2)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " n'est pas associee a une reference d'element' "
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
// on vérifie qu'il n'y a qu'un seule numéro d'élément
if (ref.Taille() != 1)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " est associee a une reference qui comporte "
<< ref.Taille() << " element(s) alors qu'il ne faut qu'un seul element !"
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
};
};
// --- cas des grandeurs évoluées aux pti d'élément
{List_io < TypeEvoluee_a_un_element >::iterator il,ilfin
= list_element_type_evoluee.end();
List_io < TypeQuelconque >::iterator it = list_quelc_element_type_evoluee.begin();
// on balaie la liste avec les conteneurs associés
for (il = list_element_type_evoluee.begin();il != ilfin;il++,it++)
{TypeEvoluee_a_un_element& dan = *il; // pour simplifier
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
// on vérifie qu'il s'agit d'une ref d'élément
if (ref.Indic() != 2)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " n'est pas associee a une reference d'element' "
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
// on vérifie qu'il n'y a qu'un seule numéro d'élément
if (ref.Taille() != 1)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " est associee a une reference qui comporte "
<< ref.Taille() << " element(s) alors qu'il ne faut qu'un seul element !"
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
};
};
// --- cas des grandeurs quelconques aux pti de faces d'élément
{List_io < TypeQuelc_face_a_un_element >::iterator il,ilfin
= list_face_element_type_quelc.end();
List_io < TypeQuelconque >::iterator it = list_quelc_face_element_type_quelc.begin();
// on balaie la liste avec les conteneurs associés
for (il = list_face_element_type_quelc.begin();il != ilfin;il++,it++)
{TypeQuelc_face_a_un_element& dan = *il; // pour simplifier
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
// on vérifie qu'il s'agit d'une ref d'élément
if (ref.Indic() != 2)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " n'est pas associee a une reference d'element' "
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
// on vérifie qu'il n'y a qu'un seule numéro d'élément
if (ref.Taille() != 1)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " est associee a une reference qui comporte "
<< ref.Taille() << " element(s) alors qu'il ne faut qu'un seul element !"
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
};
};
// --- cas des grandeurs quelconques aux pti d'arêtes d'élément
{List_io < TypeQuelc_arete_a_un_element >::iterator il,ilfin
= list_arete_element_type_quelc.end();
List_io < TypeQuelconque >::iterator it = list_quelc_arete_element_type_quelc.begin();
// on balaie la liste avec les conteneurs associés
for (il = list_arete_element_type_quelc.begin();il != ilfin;il++,it++)
{TypeQuelc_arete_a_un_element& dan = *il; // pour simplifier
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
// on vérifie qu'il s'agit d'une ref d'élément
if (ref.Indic() != 2)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " n'est pas associee a une reference d'un element' "
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
// on vérifie qu'il n'y a qu'un seule numéro d'élément
if (ref.Taille() != 1)
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " est associee a une reference qui comporte "
<< ref.Taille() << " element(s) alors qu'il ne faut qu'un seul element !"
<< " revoir la mise en donnees ! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
};
};
// ----- cas une composante d'une variable globale de type multidimentionnel
// rien à faire, c'est fait à l'appel de la variable globale (cf. ParaGlob)
// retour
return res;
};
// mises à jour de constantes globales définies par l'utilisateur
// permet de changer les valeurs, lors d'une suite .info par exemple
void VariablesExporter::MiseAjourConstantesUtilisateur(UtilLecture& lec)
{ if (strstr(lec.tablcar,"Mise_A_jour_Constantes_utilisateurs_")!=NULL)
{ lec.NouvelleDonnee(); // on se positionne sur le premier enreg
// on lit tant que l'on ne rencontre pas la ligne contenant
// "fin_Mise_A_jour_Constantes_utilisateurs_"
while (strstr(lec.tablcar,"fin_Mise_A_jour_Constantes_utilisateurs_")==0)
{// lecture d'un mot clé
string nom;
*(lec.entree) >> nom;
if ((lec.entree)->rdstate() == 0)
{} // lecture normale
#ifdef ENLINUX
else if ((lec.entree)->fail())
// on a atteind la fin de la ligne et on appelle un nouvel enregistrement
{ lec.NouvelleDonnee(); // lecture d'un nouvelle enregistrement
*(lec.entree) >> nom;
}
#else
else if ((lec.entree)->eof())
// la lecture est bonne mais on a atteind la fin de la ligne
{ if(nom != "fin_Mise_A_jour_Constantes_utilisateurs_")
{lec.NouvelleDonnee(); *(lec.entree) >> nom;};
}
#endif
else // cas d'une erreur de lecture
{ cout << "\n erreur de lecture inconnue ";
lec.MessageBuffer("** erreur en lecture pour la mise a jour des constantes utilisateur **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// en fonction du type de donnée on modifie
if (nom == "double_")
{ string nom_constante; double val;
*(lec.entree) >> nom_constante >> val;
// on récupère le pointeur correspondant à la grandeur
const void* pointe = (ParaGlob::param->GrandeurGlobal(nom_constante));
if (pointe != NULL)
{TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
if ((gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie()==TYPE_SIMPLE)
&& (gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere()==PARTICULIER_SCALAIRE_DOUBLE)
)
{Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
// on met à jour la grandeur
*(gr.ConteneurDouble()) = val;
}
else // sinon pb
{ cout << "\n *** pb dans dans la mise a jour de la constante globale "<< nom_constante
<< " le conteneur lu " << nom << " n'est pas d'un type correct !! "
<< "\n Projet::MiseAjourConstantesUtilisateur(..."
<<endl;
Sortie(1);
};
}
else // sinon pb
{ cout << "\n *** erreur dans dans la mise a jour de la constante globale "<< nom_constante
<< " la variable n'existe pas !! "
<< "\n Projet::MiseAjourConstantesUtilisateur(..."
<<endl;
Sortie(1);
};
}
// else if (nom == "int_")
// { string nom_constante; int val;
// *(lec.entree) >> nom_constante >> val;
//
// // on récupère le pointeur correspondant à la grandeur
// const void* pointe = (ParaGlob::param->GrandeurGlobal(nom_constante));
// if (pointe != NULL)
// {TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
// if ((gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie()==TYPE_SIMPLE)
// && (gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere()==PARTICULIER_SCALAIRE_ENTIER)
// )
// {Grandeur_scalaire_entier& gr
// = *((Grandeur_scalaire_entier*) gr_quelc->Grandeur_pointee()); // pour simplifier
// // on met à jour la grandeur
// *(gr.ConteneurEntier()) = val;
// }
// else // sinon pb
// { cout << "\n *** pb dans dans la mise a jour de la constante globale "<< nom_constante
// << " le conteneur lu " << nom << " n'est pas d'un type correct !! "
// << "\n Projet::MiseAjourConstantesUtilisateur(..."
// <<endl;
// Sortie(1);
// };
// }
// else // sinon pb
// { cout << "\n *** erreur dans dans la mise a jour de la constante globale "<< nom_constante
// << " la variable n'existe pas !! "
// << "\n Projet::MiseAjourConstantesUtilisateur(..."
// <<endl;
// Sortie(1);
// };
//
// }
else if(nom != "fin_Mise_A_jour_Constantes_utilisateurs_")
{cout << "\n erreur de lecture pour la mise a jour de constantes "
<< " on a lu " << nom << " ??? ";
if (ParaGlob::NiveauImpression()>3)
cout << "\n Projet::MiseAjourConstantesUtilisateur(... " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
}; //-- fin du while
lec.NouvelleDonnee(); // on prépare la nouvelle lecture
};
};
// renseigne les variables définies par l'utilisateur
// via les valeurs calculées par Herezh
void VariablesExporter::RenseigneVarUtilisateur(LesMaillages& lesMail,const LesReferences& lesRef)
{
// --- cas des ddl aux noeuds
{List_io < Ddl_a_un_noeud >::iterator il,ilfin = list_noeud_type_ddl.end();
for (il = list_noeud_type_ddl.begin();il != ilfin;il++)
{Ddl_a_un_noeud& dan = *il; // pour simplifier
// récup du conteneur global
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
// récup de la valeur demandée au niveau des noeuds
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_Num_NE(),point_mail));
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
Noeud& noe = lesMail.Noeud_LesMaille(n_mail,ne);
if (!noe.Existe_ici((dan.Enu()).Enum()))
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " ne peut pas etre renseignee car le ddl "
<< dan.Enu().Nom_plein() << " n'est pas disponible !!! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
switch (dan.Temps())
{ case TEMPS_0 :
(*(gr.ConteneurDouble())) = noe.Valeur_0((dan.Enu()).Enum());break;
case TEMPS_t :
(*(gr.ConteneurDouble())) = noe.Valeur_t((dan.Enu()).Enum());break;
case TEMPS_tdt :
(*(gr.ConteneurDouble())) = noe.Valeur_tdt((dan.Enu()).Enum());break;
};
};
};
// --- cas des ddl étendus aux noeuds
{List_io < Ddl_etendu_a_un_noeud >::iterator il,ilfin = list_noeud_type_ddlEtendu.end();
for (il = list_noeud_type_ddlEtendu.begin();il != ilfin;il++)
{Ddl_etendu_a_un_noeud& dan = *il; // pour simplifier
// récup du conteneur global
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
// récup de la valeur demandée au niveau des noeuds
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
Noeud& noe = lesMail.Noeud_LesMaille(n_mail,ne);
// Noeud& noe = lesMail.Noeud_LesMaille(n_mail,dan.Num_NE());
if (!noe.Existe_ici_ddlEtendu((dan.Enu())))
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " ne peut pas etre renseignee car le ddl etendu "
<< dan.Enu().Nom_plein() << " n'est pas disponible !!! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
(*(gr.ConteneurDouble())) = noe.DdlEtendue(dan.Enu()).ConstValeur();
};
};
// --- cas des grandeurs quelconques aux noeuds
{List_io < Quelconque_a_un_noeud >::iterator il,ilfin = list_noeud_type_quelconque.end();
for (il = list_noeud_type_quelconque.begin();il != ilfin;il++)
{Quelconque_a_un_noeud& dan = *il; // pour simplifier
// récup du conteneur global
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
// récup de la valeur demandée au niveau des noeuds
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
Noeud& noe = lesMail.Noeud_LesMaille(n_mail,ne);
// Noeud& noe = lesMail.Noeud_LesMaille(n_mail,dan.Num_NE());
// le conteneur au noeud
const TypeQuelconque_enum_etendu& type_quel = dan.Quelc_const(); // la grandeur constante
if( noe.Existe_ici(type_quel))
{const TypeQuelconque& grand_quelconque_noe = noe.Grandeur_quelconque(dan.Quelc_const());
// l'affectation
(*(gr.ConteneurDouble())) = grand_quelconque_noe.Const_Grandeur_pointee()->GrandeurNumOrdre(dan.Num_ordre());
}
else
{ cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
<< " ne peut pas etre renseignee car la grandeur "
<< type_quel.NomPlein() << " n'est pas disponible !!! ";
if (ParaGlob::NiveauImpression() >= 2)
dan.Affiche();
Sortie(1);
};
};
};
// --- cas des ddl aux pti d'élément
{List_io < Ddl_a_un_element >::iterator il,ilfin = list_element_type_ddl.end();
for (il = list_element_type_ddl.begin();il != ilfin;il++)
{Ddl_a_un_element& dan = *il; // pour simplifier
// récup du conteneur global
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
// récup de la valeur demandée au niveau du pti d'élément
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
Element& ele = lesMail.Element_LesMaille(n_mail,ne);
List_io<Ddl_enum_etendu> inter; inter.push_back(dan.Enu());
Tableau <double> tab= ele.Valeur_a_diff_temps(dan.Absolue_const(),dan.Temps_const(),inter,dan.NBpti_const());
(*(gr.ConteneurDouble())) = tab(1);
};
};
// --- cas des grandeurs particulières aux pti d'élément
{List_io < TypeParticulier_a_un_element >::iterator il,ilfin
= list_element_type_particulier.end();
List_io < TypeQuelconque >::iterator it = list_quelc_element_type_particulier.begin();
// on balaie la liste avec les conteneurs associés
for (il = list_element_type_particulier.begin();il != ilfin;il++,it++)
{TypeParticulier_a_un_element& dan = *il; // pour simplifier
// récup du conteneur global
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
// récup de la valeur demandée au niveau du pti d'élément
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
Element& ele = lesMail.Element_LesMaille(n_mail,ne);
List_io<TypeQuelconque> inter; inter.push_back((*it)); // il y a une recopie
ele.Grandeur_particuliere(dan.Absolue_const(),inter,dan.NBpti_const());
// le résultat est dans inter, pas dans (*it)
// affectation
(*(gr.ConteneurDouble())) = (*inter.begin()).GrandeurNumOrdre(dan.Num_ordre());
};
};
// --- cas des grandeurs évoluées aux pti d'élément
{List_io < TypeEvoluee_a_un_element >::iterator il,ilfin
= list_element_type_evoluee.end();
List_io < TypeQuelconque >::iterator it = list_quelc_element_type_evoluee.begin();
// on balaie la liste avec les conteneurs associés
for (il = list_element_type_evoluee.begin();il != ilfin;il++,it++)
{TypeEvoluee_a_un_element& dan = *il; // pour simplifier
// récup du conteneur global
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
// récup de la valeur demandée au niveau du pti d'élément
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
Element& ele = lesMail.Element_LesMaille(n_mail,ne);
List_io<TypeQuelconque> inter; inter.push_back((*it)); // il y a une recopie
ele.Grandeur_particuliere(dan.Absolue_const(),inter,dan.NBpti_const());
// le résultat est dans inter, pas dans (*it)
// affectation
(*(gr.ConteneurDouble())) = (*inter.begin()).GrandeurNumOrdre(dan.Num_ordre());
};
};
// --- cas des grandeurs quelconques aux pti de faces d'élément
{List_io < TypeQuelc_face_a_un_element >::iterator il,ilfin
= list_face_element_type_quelc.end();
List_io < TypeQuelconque >::iterator it = list_quelc_face_element_type_quelc.begin();
// on balaie la liste avec les conteneurs associés
for (il = list_face_element_type_quelc.begin();il != ilfin;il++,it++)
{TypeQuelc_face_a_un_element& dan = *il; // pour simplifier
// récup du conteneur global
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
// récup de la valeur demandée au niveau du pti d'élément
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
Element& ele = lesMail.Element_LesMaille(n_mail,ne);
List_io<TypeQuelconque> inter; inter.push_back((*it)); // il y a une recopie
ele.Grandeur_particuliere_face(dan.Absolue_const(),inter,dan.Num_FA_const(),dan.NBpti_const());
// le résultat est dans inter, pas dans (*it)
// affectation
(*(gr.ConteneurDouble())) = (*inter.begin()).GrandeurNumOrdre(dan.Num_ordre());
};
};
// --- cas des grandeurs quelconques aux pti d'arêtes d'élément
{List_io < TypeQuelc_arete_a_un_element >::iterator il,ilfin
= list_arete_element_type_quelc.end();
List_io < TypeQuelconque >::iterator it = list_quelc_arete_element_type_quelc.begin();
// on balaie la liste avec les conteneurs associés
for (il = list_arete_element_type_quelc.begin();il != ilfin;il++,it++)
{TypeQuelc_arete_a_un_element& dan = *il; // pour simplifier
// récup du conteneur global
const void* pointe = (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
// récup de la valeur demandée au niveau du pti d'élément
int n_mail = 1; // init par défaut
if ((*il).Nom_mail() != "")
n_mail = lesMail.NumMaillage((*il).Nom_mail());
// récup de la reférence
const string * point_mail = NULL;
if ((*il).Nom_mail_const() != "")
point_mail = &((*il).Nom_mail_const());
const ReferenceNE & ref =
((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
Element& ele = lesMail.Element_LesMaille(n_mail,ne);
List_io<TypeQuelconque> inter; inter.push_back((*it)); // il y a une recopie
ele.Grandeur_particuliere_arete(dan.Absolue_const(),inter,dan.Num_FA_const(),dan.NBpti_const());
// le résultat est dans inter, pas dans (*it)
// affectation
(*(gr.ConteneurDouble())) = (*inter.begin()).GrandeurNumOrdre(dan.Num_ordre());
};
};
// ----- cas une composante d'une variable globale de type multidimentionnel
// rien à faire, c'est fait à l'appel de la variable globale (cf. ParaGlob)
};
//----- lecture écriture de base info -----
// lecture base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void VariablesExporter::Lecture_base_info(ifstream& entr,const int cas)
{switch (cas)
{ case 1 : // ------- on récupère tout -------------------------
{
break;
}
case 2 : // ----------- lecture uniquement de se qui varie --------------------
{
break;
}
default :
{ cout << "\nErreur : valeur incorrecte du type de lecture !\n";
cout << "VariablesExporter::Lecture_base_info(ofstream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
};
};
};
// écriture base info
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void VariablesExporter::Ecriture_base_info(ofstream& sort,const int cas)
{switch (cas)
{ case 1 : // ------- on sauvegarde tout -------------------------
{
// -- cas des Constantes utilisateurs ---
sort << "\n ===constantes_utilisateur==== ";
{ List_io < Ddl_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddl.end();
List_io < string >::const_iterator il = li_nom.begin();
for (it = list_noeud_type_ddl.begin();it != itfin; it++,il++)
sort << "\n double_ " << (*il) ;
};
// -- cas des variables utilisateurs ---
sort << "\n ===variables_utilisateur==== ";
{ List_io < Ddl_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddl.end();
for (it = list_noeud_type_ddl.begin();it != itfin; it++)
sort << (*it);
};
// -- cas des ddl étendu aux noeuds ---
{ List_io < Ddl_etendu_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddlEtendu.end();
for (it = list_noeud_type_ddlEtendu.begin();it != itfin; it++)
sort << (*it);
};
// -- cas des grandeurs quelconques aux noeuds ---
{ List_io < Quelconque_a_un_noeud >::const_iterator it, itfin = list_noeud_type_quelconque.end();
for (it = list_noeud_type_quelconque.begin();it != itfin; it++)
sort << (*it);
};
// -- cas des ddl aux pti d'éléments ---
{ List_io < Ddl_a_un_element >::const_iterator it, itfin = list_element_type_ddl.end();
for (it = list_element_type_ddl.begin();it != itfin; it++)
sort << (*it);
};
// -- cas des grandeurs particulières aux pti d'éléments ---
{ List_io < TypeParticulier_a_un_element >::const_iterator it, itfin = list_element_type_particulier.end();
for (it = list_element_type_particulier.begin();it != itfin; it++)
sort << (*it);
};
// -- cas des grandeurs évoluées aux pti d'éléments ---
{ List_io < TypeEvoluee_a_un_element >::const_iterator it, itfin = list_element_type_evoluee.end();
for (it = list_element_type_evoluee.begin();it != itfin; it++)
sort << (*it);
};
// -- cas des grandeurs quelconques aux pti de faces d'éléments ---
{ List_io < TypeQuelc_face_a_un_element >::const_iterator it, itfin = list_face_element_type_quelc.end();
for (it = list_face_element_type_quelc.begin();it != itfin; it++)
sort << (*it);
};
// -- cas des grandeurs quelconques aux pti d'arête d'éléments ---
{ List_io < TypeQuelc_arete_a_un_element >::const_iterator it, itfin = list_arete_element_type_quelc.end();
for (it = list_arete_element_type_quelc.begin();it != itfin; it++)
sort << (*it);
};
// -- cas d'une composante d'une variable globale de type multidimentionnel ---
{ List_io < TypeQuelc_Une_composante_Grandeur_globale >::const_iterator it, itfin = list_var_glob_sur_grandeur_globale.end();
for (it = list_var_glob_sur_grandeur_globale.begin();it != itfin; it++)
sort << (*it);
};
break;
}
case 2 : // ----------- sauvegarde uniquement de se qui varie --------------------
{
break;
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "VariablesExporter::Ecriture_base_info(ofstream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
};
};
};
// sortie du schemaXML: en fonction de enu
void VariablesExporter::SchemaXML_VariablesExporters(UtilLecture * entreePrinc,const Enum_IO_XML enu)
{
// switch (enu)
// {case XML_TYPE_GLOBAUX:
// { // cas des classes de base
// DeuxEntiers toto;
// toto.SchemaXML_DeuxEntiers(sort,enu);
// break;
// }
// case XML_IO_POINT_INFO:
// {// cas de def de LesMaillages
// sort << "\n <xs:element name=\"LesMaillages\" >"
// << "\n <xs:complexType>"
// << "\n <xs:annotation>"
// << "\n <xs:documentation> une suite de maillages </xs:documentation>"
// << "\n </xs:annotation>"
// << "\n <xs:sequence>"
// << "\n <xs:element name=\"Maillage\" type=\"Maillage\" "
// << "\n minOccurs=\"1\" maxOccurs=\"unbounded\" />"
// << "\n </xs:sequence>"
// << "\n </xs:complexType>"
// << "\n </xs:element>";
// // def de Maillage
//// SchemaXML_Maillage(sort,niveau);
// break;
// }
// };
};
// -- def de constantes utilisateur pour une sortie sur un fichier de commande
void VariablesExporter::Info_commande_ConstantesUtilisateur(UtilLecture * entreePrinc)
{ cout << "\n definition de constante(s) utilisateur (defaut 0 c-a-d non) : 1 (c-a-d oui) ? ";
string rep;bool choix_valide=false;
while (!choix_valide)
{ rep = "_";
// procédure de lecture avec prise en charge d'un retour chariot
rep = lect_return_defaut(true,"0");
if (rep.size()==0)
{rep = "0";
cout << "--> valeur: 0 ";
};
if (rep == "1") { choix_valide=true;}
else if (rep == "0") {choix_valide=true;}
else if (rep == "f") {choix_valide=true;}
else if (rep == "fin_prog") Sortie(1);
else { cout << "\n Erreur on attendait 0 ou 1 ou f !!, redonnez une bonne valeur"
<< "\n ou taper fin_prog pour arreter le programme ";
choix_valide=false;
}
};
// écriture
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"
<< endl;
// maintenant on regarde s'il faut des constantes utilisateurs
try
{if (rep == "1")
{sort << "\n#------------------------------------------------------------------"
<< "\n Constantes_utilisateurs_ ";
while (choix_valide)
{ rep = "_";string nom;double val;
cout << "\n nom de la variable ? (ou f ou 0 (defaut)) ";
nom = lect_return_defaut(false,"f");
if ((nom != "f")&&(nom != "0"))
{ cout << "\n valeur ? ";val=lect_double();
cout << "\n constante lue : "<< "C__"+nom << " "<< val << flush;
choix_valide = true;
sort << "\n double_ " << "C__"+nom << " "<< val << flush;
}
else {choix_valide = false;};
};
sort << "\n fin_Constantes_utilisateurs_ \n" << flush;
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)
{cout << "\n *** erreur en definition des constantes utilisateurs ! stop " << flush;
Sortie(1);
};
};
// -- def de variables utilisateur pour une sortie sur un fichier de commande
void VariablesExporter::Info_commande_VariablesUtilisateur(UtilLecture * entreePrinc)
{ cout << "\n definition de variable(s) utilisateur (defaut 0 c-a-d non) : 1 (c-a-d oui) ? ";
string rep;bool choix_valide=false;
while (!choix_valide)
{ rep = "_";
// procédure de lecture avec prise en charge d'un retour chariot
rep = lect_return_defaut(true,"0");
if (rep.size()==0)
{rep = "0";
cout << "--> valeur: 0 ";
};
if (rep == "1") { choix_valide=true;}
else if (rep == "0") {choix_valide=true;}
else if (rep == "f") {choix_valide=true;}
else if (rep == "fin_prog") Sortie(1);
else { cout << "\n Erreur on attendait 0 ou 1 ou f !!, redonnez une bonne valeur"
<< "\n ou taper fin_prog pour arreter le programme ";
choix_valide=false;
}
};
// écriture
ofstream & sort = *(entreePrinc->Commande_pointInfo()); // pour simplifier
// maintenant on regarde s'il faut des variables utilisateurs
try
{choix_valide=false;
if (rep == "1")
{sort << "\n#------------------------------------------------------------------"
<< "\n Variables_utilisateurs_ ";
while (!choix_valide)
{ rep = "_";string nom;
cout << "\n ddl aux noeuds -> rep : noe ?"
<< "\n ddl etendu aux noeuds -> rep : net ?"
<< "\n grandeur particuliere aux noeuds -> rep : nop ?"
<< "\n grandeurs generique aux elements -> rep : ele "
<< "\n grandeurs particulieres aux elements -> rep : elp "
<< "\n grandeurs tensorielles aux elements -> rep : elt "
<< "\n grandeurs aux faces d'elements -> rep : elF "
<< "\n grandeurs aux aretes d'elements -> rep : elA "
<< "\n une composante de grandeur globale -> rep : cgl "
<< "\n pour arreter les questions (defaut) -> rep : fin (ou f) ";
if (ParaGlob::Francais())
{cout << "\n reponse ? ";}else {cout << "\n answer ? ";}
rep = lect_return_defaut(false,"f");
cout << " rep lue: "<< rep << " ";
if (rep == "noe")
{ // cas d'un ddl à un noeud
Ddl_a_un_noeud dan;
cout << "\n nom du maillage (defaut aucun) ? ";
dan.Nom_mail() = lect_return_defaut(false,"aucun");
cout << " val lue: "<< dan.Nom_mail();
if (dan.Nom_mail() == "aucun")
{dan.Nom_mail() = "";}
cout << "\n ddl (defaut X1) ? ";
dan.Enu() = lect_return_defaut(false,"X1");
cout << " ddl lu: "<< dan.Enu();
cout << "\n reference du noeud (defaut N_1) ? ";
dan.Ref_Num_NE() = lect_return_defaut(false,"N_1");
cout << " val lue: "<< dan.Ref_Num_NE();
dan.Nom_var() = Lect_interactive_nom_var();
cout << "\n le temps ou est evalue la variable (defaut: TEMPS_0) ? ";
dan.Temps() = Id_nom_dure(lect_return_defaut(false,"TEMPS_0"));
cout << " temps lu "<< Nom_dure(dan.Temps());
// on a toutes les infos, on peut enregistrer
sort << dan << flush;
list_noeud_type_ddl.push_back(dan);
}
else if (rep == "net")
{ // cas d'un ddl étendu à un noeud
Ddl_etendu_a_un_noeud dan;
cout << "\n nom du maillage (defaut aucun) ? ";
dan.Nom_mail() = lect_return_defaut(false,"aucun");
cout << " val lue: "<< dan.Nom_mail();
if (dan.Nom_mail() == "aucun")
{dan.Nom_mail() = "";}
cout << "\n ddl etendu (defaut Masse_diago_noeud) ? ";
// string nom_ddl(lect_return_defaut(false,"Masse_diago_noeud"));
dan.Enu() = lect_return_defaut(false,"Masse_diago_noeud");
cout << " ddl etendu lu: "<< dan.Enu();
cout << "\n reference du noeud (defaut N_1) ? ";
dan.Ref_NE() = lect_return_defaut(false,"N_1");
cout << " val lue: "<< dan.Ref_NE();
dan.Nom_var() = Lect_interactive_nom_var();
// on a toutes les infos, on peut enregistrer
sort << dan << flush;
list_noeud_type_ddlEtendu.push_back(dan);
}
else if (rep == "nop")
{ Quelconque_a_un_noeud dan;
cout << "\n nom du maillage (defaut aucun) ? ";
dan.Nom_mail() = lect_return_defaut(false,"aucun");
cout << " val lue: "<< dan.Nom_mail();
if (dan.Nom_mail() == "aucun")
{dan.Nom_mail() = "";}
cout << "\n grandeur (defaut POSITION_GEOMETRIQUE) ? ";
dan.Quelc() = lect_return_defaut(false,"POSITION_GEOMETRIQUE");
cout << " lu: "<< dan.Quelc().NomPlein();
cout << "\n reference du noeud (defaut N_1) ? ";
dan.Ref_NE() = lect_return_defaut(false,"N_1");
cout << " val lue: "<< dan.Ref_NE();
dan.Nom_var() = Lect_interactive_nom_var();
cout << "\n le num d'ordre (ex: num de la composante, defaut 1) ?";
dan.Num_ordre() = ChangeEntier(lect_return_defaut(false,"1"));
cout << " val lue: "<<dan.Num_ordre();
// on a toutes les infos, on peut enregistrer
sort << dan << flush;
list_noeud_type_quelconque.push_back(dan); }
else if (rep == "ele")
{ // cas d'un ddl à un pti d'élément
Ddl_a_un_element dan;
cout << "\n nom du maillage (defaut aucun) ? ";
dan.Nom_mail() = lect_return_defaut(false,"aucun");
cout << " val lue: "<< dan.Nom_mail();
if (dan.Nom_mail() == "aucun")
{dan.Nom_mail() = "";}
cout << "\n grandeur (defaut SIG11) ? ";
dan.Enu() = lect_return_defaut(false,"SIG11");
cout << " ddl lu: "<< dan.Enu();
cout << "\n reference de l'element (defaut E_1) ? ";
dan.Ref_NE() = lect_return_defaut(false,"E_1");
cout << " val lue: "<< dan.Ref_NE();
dan.Nom_var() = Lect_interactive_nom_var();
cout << "\n le temps ou est evalue la variable (defaut: TEMPS_0) ? ";
dan.Temps() = Id_nom_dure(lect_return_defaut(false,"TEMPS_0"));
cout << " temps lu "<< Nom_dure(dan.Temps());
cout << "\n le numero du point d'integration (defaut: 1) ? ";
dan.NBpti() = ChangeEntier(lect_return_defaut(false,"1"));
cout << "\n en absolu (defaut rep 1) ou en local (rep 0) ? ";
dan.Absolue() = ChangeEntier(lect_return_defaut(false,"1"));
// on a toutes les infos, on peut enregistrer
sort << dan << flush;
list_element_type_ddl.push_back(dan);
}
else if (rep == "elp")
{ // cas d'une grandeur particulière à un pti d'élément
TypeParticulier_a_un_element dan;
cout << "\n nom du maillage (defaut aucun) ? ";
dan.Nom_mail() = lect_return_defaut(false,"aucun");
cout << " val lue: "<< dan.Nom_mail();
if (dan.Nom_mail() == "aucun")
{dan.Nom_mail() = "";}
cout << "\n grandeur (defaut POSITION_GEOMETRIQUE) ? ";
dan.Quelc() = lect_return_defaut(false,"POSITION_GEOMETRIQUE");
cout << " lu: "<< dan.Quelc().NomPlein();
cout << "\n reference de l'element (defaut E_1) ? ";
dan.Ref_NE() = lect_return_defaut(false,"E_1");
cout << " val lue: "<< dan.Ref_NE();
dan.Nom_var() = Lect_interactive_nom_var();
cout << "\n le num d'ordre (ex: num de la composante, defaut 1) ?";
dan.Num_ordre() = ChangeEntier(lect_return_defaut(false,"1"));
cout << " val lue: "<<dan.Num_ordre();
cout << "\n le numero du point d'integration (defaut: 1) ? ";
dan.NBpti() = ChangeEntier(lect_return_defaut(false,"1"));
cout << "\n en absolu (defaut rep 1) ou en local (rep 0) ? ";
dan.Absolue() = ChangeEntier(lect_return_defaut(false,"1"));
// on a toutes les infos, on peut enregistrer
sort << dan << flush;
list_element_type_particulier.push_back(dan);
}
else if (rep == "elt")
{ // cas d'une grandeur tensorielle à un pti d'élément
TypeEvoluee_a_un_element dan;
cout << "\n nom du maillage (defaut aucun) ? ";
dan.Nom_mail() = lect_return_defaut(false,"aucun");
cout << " val lue: "<< dan.Nom_mail();
if (dan.Nom_mail() == "aucun")
{dan.Nom_mail() = "";}
cout << "\n grandeur (defaut DEF_PRINCIPALES) ? ";
dan.Quelc() = lect_return_defaut(false,"DEF_PRINCIPALES");
cout << " lu: "<< dan.Quelc().NomPlein();
cout << "\n reference de l'element (defaut E_1) ? ";
dan.Ref_NE() = lect_return_defaut(false,"E_1");
cout << " val lue: "<< dan.Ref_NE();
dan.Nom_var() = Lect_interactive_nom_var();
cout << "\n le num d'ordre (ex: num de la composante, defaut 1) ?";
dan.Num_ordre() = ChangeEntier(lect_return_defaut(false,"1"));
cout << " val lue: "<<dan.Num_ordre();
cout << "\n le numero du point d'integration (defaut: 1) ? ";
dan.NBpti() = ChangeEntier(lect_return_defaut(false,"1"));
cout << "\n en absolu (defaut rep 1) ou en local (rep 0) ? ";
dan.Absolue() = ChangeEntier(lect_return_defaut(false,"1"));
// on a toutes les infos, on peut enregistrer
sort << dan << flush;
list_element_type_evoluee.push_back(dan);
}
else if (rep == "elF")
{ // cas d'une grandeur quelconque à un pti de face d'élément
TypeQuelc_face_a_un_element dan;
cout << "\n nom du maillage (defaut aucun) ? ";
dan.Nom_mail() = lect_return_defaut(false,"aucun");
cout << " val lue: "<< dan.Nom_mail();
if (dan.Nom_mail() == "aucun")
{dan.Nom_mail() = "";}
cout << "\n grandeur (defaut NN_SURF_t0) ? ";
dan.Quelc() = lect_return_defaut(false,"NN_SURF_t0");
cout << " lu: "<< dan.Quelc().NomPlein();
cout << "\n numero de la face relativement a l'element (defaut 1) ? ";
dan.Num_FA() = ChangeEntier(lect_return_defaut(false,"1"));
cout << " val lue: "<< dan.Num_FA();
cout << "\n reference de l'element (defaut E_1) ? ";
dan.Ref_NE() = lect_return_defaut(false,"E_1");
cout << " val lue: "<< dan.Ref_NE();
dan.Nom_var() = Lect_interactive_nom_var();
cout << "\n le num d'ordre (ex: num de la composante, defaut 1) ?";
dan.Num_ordre() = ChangeEntier(lect_return_defaut(false,"1"));
cout << " val lue: "<<dan.Num_ordre();
cout << "\n le numero du pti de la face (defaut: 1) ? ";
dan.NBpti() = ChangeEntier(lect_return_defaut(false,"1"));
cout << "\n en absolu (defaut rep 1) ou en local (rep 0) ? ";
dan.Absolue() = ChangeEntier(lect_return_defaut(false,"1"));
// on a toutes les infos, on peut enregistrer
sort << dan << flush;
list_face_element_type_quelc.push_back(dan);
}
else if (rep == "elA")
{ // cas d'une grandeur quelconque à un pti d'arête d'élément
TypeQuelc_arete_a_un_element dan;
cout << "\n nom du maillage (defaut aucun) ? ";
dan.Nom_mail() = lect_return_defaut(false,"aucun");
cout << " val lue: "<< dan.Nom_mail();
if (dan.Nom_mail() == "aucun")
{dan.Nom_mail() = "";}
cout << "\n grandeur (defaut POSITION_GEOMETRIQUE) ? ";
dan.Quelc() = lect_return_defaut(false,"POSITION_GEOMETRIQUE");
cout << " lu: "<< dan.Quelc().NomPlein();
cout << "\n numero de l'arete relativement a l'element (defaut 1) ? ";
dan.Num_FA() = ChangeEntier(lect_return_defaut(false,"1"));
cout << " val lue: "<< dan.Num_FA();
cout << "\n reference de l'element (defaut E_1) ? ";
dan.Ref_NE() = lect_return_defaut(false,"E_1");
cout << " val lue: "<< dan.Ref_NE();
dan.Nom_var() = Lect_interactive_nom_var();
cout << "\n le num d'ordre (ex: num de la composante, defaut 1) ?";
dan.Num_ordre() = ChangeEntier(lect_return_defaut(false,"1"));
cout << " val lue: "<<dan.Num_ordre();
cout << "\n le numero du pti de la face (defaut: 1) ? ";
dan.NBpti() = ChangeEntier(lect_return_defaut(false,"1"));
cout << "\n en absolu (defaut rep 1) ou en local (rep 0) ? ";
dan.Absolue() = ChangeEntier(lect_return_defaut(false,"1"));
// on a toutes les infos, on peut enregistrer
sort << dan << flush;
list_arete_element_type_quelc.push_back(dan);
}
else if (rep == "cgl")
{ // cas d'une composante d'une variable globale de type multidimentionnel
TypeQuelc_Une_composante_Grandeur_globale dan;
cout << "\n grandeur globale (defaut statistique_N_tout_ddl_etendu_X1) ? ";
dan.Nom_grandeur_globale() = lect_return_defaut(false,"statistique_N_tout_ddl_etendu_X1");
cout << " lu: "<< dan.Nom_grandeur_globale();
dan.Nom_var() = Lect_interactive_nom_var_relais();
cout << "\n le num de la composante ( defaut 1) ?";
dan.Indice() = ChangeEntier(lect_return_defaut(false,"1"));
cout << " val lue: "<<dan.Indice();
// on a toutes les infos, on peut enregistrer
sort << dan << flush;
list_var_glob_sur_grandeur_globale.push_back(dan);
}
else if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f"))
{choix_valide = true;}
else
{if (ParaGlob::Francais()) {cout << "\n choix non valide, recommencez !";}
else {cout << "\n the choice is not valide, starts again ! ";};
choix_valide = false;
};
};
sort << "\n fin_Variables_utilisateurs_ \n" << flush;
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)
{cout << "\n *** erreur en definition des Variables utilisateurs ! stop " << flush;
Sortie(1);
};
};
// lecture de constantes globales définies par l'utilisateur
// ramène la liste des constantes sous la forme de conteneur de type quelconque
// et la liste de leurs noms
// NB: la liste est tout d'abord vidée avant d'être éventuellement remplie
void VariablesExporter::LecConstantesUtilisateur(UtilLecture& lec)
{ // on initialise à liste
li_Q.clear();li_nom.clear();
// on regarde s'il y a des constantes à lire
if (strstr(lec.tablcar,"Constantes_utilisateurs_")!=NULL)
{ lec.NouvelleDonnee(); // on se positionne sur le premier enreg
// on lit tant que l'on ne rencontre pas la ligne contenant "fin_Constantes_utilisateurs_"
while (strstr(lec.tablcar,"fin_Constantes_utilisateurs_")==0)
{// lecture d'un mot clé
string nom;
*(lec.entree) >> nom;
if ((lec.entree)->rdstate() == 0)
{} // lecture normale
#ifdef ENLINUX
else if ((lec.entree)->fail())
// on a atteind la fin de la ligne et on appelle un nouvel enregistrement
{ lec.NouvelleDonnee(); // lecture d'un nouvelle enregistrement
*(lec.entree) >> nom;
}
#else
else if ((lec.entree)->eof())
// la lecture est bonne mais on a atteind la fin de la ligne
{ if(nom != "fin_Constantes_utilisateurs_")
{lec.NouvelleDonnee(); *(lec.entree) >> nom;};
}
#endif
else // cas d'une erreur de lecture
{ cout << "\n erreur de lecture inconnue ";
lec.MessageBuffer("** erreur en lecture des constantes utilisateur **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// en fonction du type de donnée on lit, crée et stock
if (nom == "double_")
{ string nom_constante; double val=0.;
*(lec.entree) >> nom_constante >> val;
// il faut que les 3 premiers caractères de nom_constante soit un C__
if (!((nom_constante[0]== 'C')&&(nom_constante[1]== '_')&&(nom_constante[2]== '_')))
{ cout << "\n erreur de syntaxe en lecture d'une constante de type double, les 3 premieres lettres "
<< " devraientt etre un 'C__' et on a lu: "<<nom_constante << " !!"
<< endl;
Sortie(1);
}
else // sinon c'est ok
{// on crée le conteneur
Grandeur_scalaire_double grand_courant(val);
TypeQuelconque typQ1(GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR,NU_DDL,grand_courant);
// stockage
li_Q.push_back(typQ1); li_nom.push_back(nom_constante);
};
}
// else if (nom == "int_")
// { string nom_constante; int val;
// *(lec.entree) >> nom_constante >> val;
// // il faut que le premier caractère de nom_constante soit un $
// if (nom_constante[0]!= '$')
// { cout << "\n erreur de syntaxe en lecture d'une constante de type int, la premiere lettre "
// << " devrait etre un '$' et on a lu: "<<nom_constante[0] << " !!"
// << endl;
// Sortie(1);
// }
// else // sinon c'est ok
// {// on crée le conteneur
// Grandeur_scalaire_entier grand_courant(val);
// TypeQuelconque typQ1(GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR,NU_DDL,grand_courant);
// // stockage
// li_Q.push_back(typQ1); li_nom.push_back(nom_constante);
// };
// }
else if(nom != "fin_Constantes_utilisateurs_")
{cout << "\n erreur de lecture du type de constante "
<< " on a lu " << nom << ", type qui n'est pas etre pris en compte...";
if (ParaGlob::NiveauImpression()>3)
cout << "\n Projet::LecConstantesUtilisateur(... " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
}; //-- fin du while
lec.NouvelleDonnee(); // on prépare la nouvelle lecture
};
};
// lecture éventuelle des variables globales définies par l'utilisateur
void VariablesExporter::LecVariablesUtilisateur(UtilLecture& lec)
{ // on initialise les conteneurs
// -> noeuds
list_noeud_type_ddl.clear();
list_noeud_type_ddlEtendu.clear();
list_noeud_type_quelconque.clear();
// -> éléments
list_element_type_ddl.clear();
list_element_type_particulier.clear();
list_element_type_evoluee.clear();
// -> face d'éléments
list_face_element_type_quelc.clear();
// -> arête d'éléments
list_arete_element_type_quelc.clear();
// on regarde s'il y a des variables à lire
if (strstr(lec.tablcar,"Variables_utilisateurs_")!=NULL)
{ lec.NouvelleDonnee(); // on se positionne sur le premier enreg
// on lit tant que l'on ne rencontre pas la ligne contenant "fin_Variables_utilisateurs_"
while (strstr(lec.tablcar,"fin_Variables_utilisateurs_")==0)
{// choix en fonction du type de variable
string nom;
if ((lec.entree)->rdstate() == 0)
{} // lecture normale
#ifdef ENLINUX
else if ((lec.entree)->fail())
// on a atteind la fin de la ligne et on appelle un nouvel enregistrement
{ lec.NouvelleDonnee(); // lecture d'un nouvelle enregistrement
*(lec.entree) >> nom;
}
#else
else if ((lec.entree)->eof())
// la lecture est bonne mais on a atteind la fin de la ligne
{ if(nom != "fin_Variables_utilisateurs_")
{lec.NouvelleDonnee(); };
}
#endif
else // cas d'une erreur de lecture
{ cout << "\n erreur de lecture inconnue ";
lec.MessageBuffer("** erreur en lecture des constantes utilisateur **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// en fonction du type de donnée on lit, crée et stock
if (strstr(lec.tablcar,"Ddl_noeud_") != 0)
{ Ddl_a_un_noeud dan;
*(lec.entree) >> dan;
// on vérifie que la variable lue n'existe pas déjà
VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
// stockage
list_noeud_type_ddl.push_back(dan);
}
else if (strstr(lec.tablcar,"Ddl_etendu_a_un_noeud_") != 0)
{ Ddl_etendu_a_un_noeud dan;
*(lec.entree) >> dan;
// on vérifie que la variable lue n'existe pas déjà
VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
// stockage
list_noeud_type_ddlEtendu.push_back(dan);
}
else if (strstr(lec.tablcar,"Quelconque_a_un_noeud_") != 0)
{ Quelconque_a_un_noeud dan;
*(lec.entree) >> dan;
// on vérifie que la variable lue n'existe pas déjà
VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
// stockage
list_noeud_type_quelconque.push_back(dan);
}
else if (strstr(lec.tablcar,"Ddl_a_un_element_") != 0)
{ Ddl_a_un_element dan;
*(lec.entree) >> dan;
// on vérifie que la variable lue n'existe pas déjà
VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
// stockage
list_element_type_ddl.push_back(dan);
}
else if (strstr(lec.tablcar,"Particulier_a_un_element_") != 0)
{ TypeParticulier_a_un_element dan;
*(lec.entree) >> dan;
// on vérifie que la variable lue n'existe pas déjà
VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
// stockage
list_element_type_particulier.push_back(dan);
}
else if (strstr(lec.tablcar,"Evoluee_a_un_element_") != 0)
{ TypeEvoluee_a_un_element dan;
*(lec.entree) >> dan;
// on vérifie que la variable lue n'existe pas déjà
VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
// stockage
list_element_type_evoluee.push_back(dan);
}
else if (strstr(lec.tablcar,"Quelconque_face_element_") != 0)
{ TypeQuelc_face_a_un_element dan;
*(lec.entree) >> dan;
// on vérifie que la variable lue n'existe pas déjà
VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
// stockage
list_face_element_type_quelc.push_back(dan);
}
else if (strstr(lec.tablcar,"Quelconque_arete_element_") != 0)
{ TypeQuelc_arete_a_un_element dan;
*(lec.entree) >> dan;
// on vérifie que la variable lue n'existe pas déjà
VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
// stockage
list_arete_element_type_quelc.push_back(dan);
}
else if (strstr(lec.tablcar,"Une_composante_Grandeur_globale_") != 0)
{ TypeQuelc_Une_composante_Grandeur_globale dan;
*(lec.entree) >> dan;
// on vérifie que la variable lue n'existe pas déjà
VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
// stockage
list_var_glob_sur_grandeur_globale.push_back(dan);
}
else if( strstr(lec.tablcar,"fin_Variables_utilisateurs_")
&& strstr(lec.tablcar,"Quelconque_arete_element_")
&& strstr(lec.tablcar,"Quelconque_face_element_")
&& strstr(lec.tablcar,"Evoluee_a_un_element_")
&& strstr(lec.tablcar,"Particulier_a_un_element_")
&& strstr(lec.tablcar,"Ddl_a_un_element_")
&& strstr(lec.tablcar,"Quelconque_a_un_noeud_")
&& strstr(lec.tablcar,"Ddl_etendu_a_un_noeud_")
&& strstr(lec.tablcar,"Ddl_noeud_")
&& strstr(lec.tablcar,"Une_composante_Grandeur_globale_")
)
{cout << "\n erreur de lecture du type de variable "
<< " on a lu " << nom << ", type qui n'est pas etre pris en compte...";
if (ParaGlob::NiveauImpression()>3)
cout << "\n Projet::LecVariablesUtilisateur(... " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
}; //-- fin du while
lec.NouvelleDonnee(); // on prépare la nouvelle lecture
};
};
// insertion des constantes utilisateur dans les variables globales
void VariablesExporter::InsertConstUtilisateur_dans_globale()
{ // on passe en revue tous les éléments de la liste
list<TypeQuelconque>::iterator il,ilfin = li_Q.end();
list<string>::const_iterator inom= li_nom.begin();
for (il = li_Q.begin();il != ilfin;il++,inom++)
{ // on regarde si la grandeur n'existe pas déjà: si oui on couine
const void* pointe = (ParaGlob::param->GrandeurGlobal(*inom));
if (pointe != NULL)
{TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
cout << "\n warning *** la constante globale "<< (*inom)
<< " a deja ete definie ! => " << (*(gr_quelc->Grandeur_pointee()));
cout << "\n on remplace par sa nouvelle valeur: => " << (*((*il).Grandeur_pointee()));
ParaGlob::param->Suppression_grandeur_consultable(*inom); // suppression
// puis on ajoute
ParaGlob::param->Ajout_grandeur_consultable(&(*il),*inom);
}
else // sinon on ajoute simplement
{ParaGlob::param->Ajout_grandeur_consultable(&(*il),*inom);};
};
};
// vérification que 2 nom de variables ne soient pas identique
// si avec_sortie = true -> arrêt
// si avec_sortie = false -> retour du test: true si c'est ok
// false si pb
bool VariablesExporter::VerifNomVariable(const string& nom,bool avec_sortie) const
{ // -- cas des ddl aux noeuds ---
{ List_io < Ddl_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddl.end();
for (it = list_noeud_type_ddl.begin();it != itfin; it++)
if ((*it).Nom_var_const() == nom)
{ cout << "\n *** erreur en lecture d'une variable utilisateur: Ddl_a_un_noeud "
<< " on a deja lue une variable de meme nom = "<< nom ;
if (avec_sortie)
{Sortie(1);}
else {return false;};
};
};
// -- cas des ddl étendu aux noeuds ---
{ List_io < Ddl_etendu_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddlEtendu.end();
for (it = list_noeud_type_ddlEtendu.begin();it != itfin; it++)
if ((*it).Nom_var_const() == nom)
{ cout << "\n *** erreur en lecture d'une variable utilisateur: Ddl_etendu_a_un_noeud "
<< " on a deja lue une variable de meme nom = "<< nom ;
if (avec_sortie)
{Sortie(1);}
else {return false;};
};
};
// -- cas des grandeurs quelconques aux noeuds ---
{ List_io < Quelconque_a_un_noeud >::const_iterator it, itfin = list_noeud_type_quelconque.end();
for (it = list_noeud_type_quelconque.begin();it != itfin; it++)
if ((*it).Nom_var_const() == nom)
{ cout << "\n *** erreur en lecture d'une variable utilisateur: Quelconque_a_un_noeud "
<< " on a deja lue une variable de meme nom = "<< nom ;
if (avec_sortie)
{Sortie(1);}
else {return false;};
};
};
// -- cas des ddl aux pti d'éléments ---
{ List_io < Ddl_a_un_element >::const_iterator it, itfin = list_element_type_ddl.end();
for (it = list_element_type_ddl.begin();it != itfin; it++)
if ((*it).Nom_var_const() == nom)
{ cout << "\n *** erreur en lecture d'une variable utilisateur: Ddl_a_un_element "
<< " on a deja lue une variable de meme nom = "<< nom ;
if (avec_sortie)
{Sortie(1);}
else {return false;};
};
};
// -- cas des grandeurs particulières aux pti d'éléments ---
{ List_io < TypeParticulier_a_un_element >::const_iterator it, itfin = list_element_type_particulier.end();
for (it = list_element_type_particulier.begin();it != itfin; it++)
if ((*it).Nom_var_const() == nom)
{ cout << "\n *** erreur en lecture d'une variable utilisateur: TypeParticulier_a_un_element "
<< " on a deja lue une variable de meme nom = "<< nom ;
if (avec_sortie)
{Sortie(1);}
else {return false;};
};
};
// -- cas des grandeurs évoluées aux pti d'éléments ---
{ List_io < TypeEvoluee_a_un_element >::const_iterator it, itfin = list_element_type_evoluee.end();
for (it = list_element_type_evoluee.begin();it != itfin; it++)
if ((*it).Nom_var_const() == nom)
{ cout << "\n *** erreur en lecture d'une variable utilisateur: TypeEvoluee_a_un_element "
<< " on a deja lue une variable de meme nom = "<< nom ;
if (avec_sortie)
{Sortie(1);}
else {return false;};
};
};
// -- cas des grandeurs quelconques aux pti de faces d'éléments ---
{ List_io < TypeQuelc_face_a_un_element >::const_iterator it, itfin = list_face_element_type_quelc.end();
for (it = list_face_element_type_quelc.begin();it != itfin; it++)
if ((*it).Nom_var_const() == nom)
{ cout << "\n *** erreur en lecture d'une variable utilisateur: Quelconque_face_element_ "
<< " on a deja lue une variable de meme nom = "<< nom ;
if (avec_sortie)
{Sortie(1);}
else {return false;};
};
};
// -- cas des grandeurs quelconques aux pti d'arête d'éléments ---
{ List_io < TypeQuelc_arete_a_un_element >::const_iterator it, itfin = list_arete_element_type_quelc.end();
for (it = list_arete_element_type_quelc.begin();it != itfin; it++)
if ((*it).Nom_var_const() == nom)
{ cout << "\n *** erreur en lecture d'une variable utilisateur: Quelconque_arete_element_ "
<< " on a deja lue une variable de meme nom = "<< nom ;
if (avec_sortie)
{Sortie(1);}
else {return false;};
};
};
// -- cas d'une composante d'une variable globale de type multidimentionnel---
{ List_io < TypeQuelc_Une_composante_Grandeur_globale >::const_iterator it, itfin = list_var_glob_sur_grandeur_globale.end();
for (it = list_var_glob_sur_grandeur_globale.begin();it != itfin; it++)
if ((*it).Nom_var_const() == nom)
{ cout << "\n *** erreur en lecture d'une variable utilisateur: Une_composante_Grandeur_globale_ "
<< " on a deja lue une variable de meme nom = "<< nom ;
if (avec_sortie)
{Sortie(1);}
else {return false;};
};
};
// arrivée ici, cela veut dire que tout est ok
return true;
};
// lecture interactive du nom de la variable: hors variable relais
string VariablesExporter::Lect_interactive_nom_var()
{ string no_user("");
while(no_user.length()==0)
{ cout << "\n nom_utilisateur de la grandeur ? ";
no_user = lect_return_defaut(false,"");
if (no_user.length()==0)
{cout << "\n vous devez donner un nom !! ";}
else
{// on complète éventuellement
if (!((no_user[0]== 'V')&&(no_user[1]== '_')&&(no_user[2]== '_')))
no_user = "V__" + no_user;
// on teste s'il y en a deux identiques
if (!VerifNomVariable(no_user,false))
{ cout << "\n ce nom de variable existe deja ! donner un autre ";
no_user = "";
};
};
};
cout << " nom lu: "<< no_user;
return no_user;
};
// lecture interactive du nom d'une variable relais
string VariablesExporter::Lect_interactive_nom_var_relais()
{ string no_user("");
while(no_user.length()==0)
{ cout << "\n nom_utilisateur de la grandeur ? ";
no_user = lect_return_defaut(false,"");
if (no_user.length()==0)
{cout << "\n vous devez donner un nom !! ";}
else
{// on complète éventuellement
if (!((no_user[0]== 'V')&&(no_user[1]== 'R') &&(no_user[2]== '_')))
no_user = "VR_" + no_user;
// on teste s'il y en a deux identiques
if (!VerifNomVariable(no_user,false))
{ cout << "\n ce nom de variable existe deja ! donner un autre ";
no_user = "";
};
};
};
cout << " nom lu: "<< no_user;
return no_user;
};
// insertion d'une composante d'une grandeur quelconque en globale
// sous forme d'un double
void VariablesExporter::InsertCompGrandeurQuelc
(const string& non_var,const TypeQuelconque_enum_etendu& enu)
{// on crée un conteneur d'un double
double val=0;
Grandeur_scalaire_double grand_courant(val);
// on récupère le temps
EnumTypeQuelconque eTQ = enu.EnumTQ();
Enum_dure temps = EnumTypeQuelconqueTemps(eTQ);
switch (temps)
{case TEMPS_0 :
{TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0,NU_DDL,grand_courant);
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,non_var);
break;
}
case TEMPS_t :
{TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T,NU_DDL,grand_courant);
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,non_var);
break;
}
case TEMPS_tdt :
{TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT,NU_DDL,grand_courant);
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,non_var);
break;
}
default :
cout << "\nErreur : valeur incorrecte du temps pour une variable ddl globale !\n";
cout << "\n VariablesExporter::InsertCompGrandeurQuelc(... \n";
Sortie(1);
};
};
Reference in a new issue Copy permalink