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