rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Maillage/VariablesExporter.h
Gérard Rio 0460624e94 mise à jour 7.010
2023-05-03 17:23:49 +02:00

793 lines
36 KiB
C++
Executable file
Raw Blame History

// 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/>.
/************************************************************************
* DATE: 06/03/2023 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: def d'une classe relative a l'exportation en variables *
* globales de grandeurs définies dans les maillages. *
* Cela concerne les constantes utilisateur et les variables *
* calculées par Herezh. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef VARIABLES_EXPORTER_H
#define VARIABLES_EXPORTER_H
#include <iostream>
#include <map>
#ifndef ENLINUX_STREAM
#include <sstream> // pour le flot en memoire centrale
#else
#include <strstream> // pour le flot en memoire centrale
#endif
#include "UtilLecture.h"
#include "Enum_IO_XML.h"
#include "LesMaillages.h"
#include "Basiques.h"
/** @defgroup Les_classes_exportation_en_variables
*
* BUT:def de classes relatives a l'exportation en variables
* globales de grandeurs définies dans les maillages.
* Cela concerne les constantes utilisateur et les variables
* calculées par Herezh.
*
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
* \brief Définition de classes relatives a l'exportation en variables
*
*/
/// @addtogroup Les_classes_exportation_en_variables
/// @{
///
class VariablesExporter
{
public :
friend class LesMaillages;
//=================%%%%%%%% classes de conteneurs %%%%%%%%=================
// classe conteneur de base pour noeud, élément etc.
class A_un_NE
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, A_un_NE &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const A_un_NE &);
public :
A_un_NE(); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
A_un_NE(string ref
,string nom_mail_,string nom_var_);
// constructeur de copie
A_un_NE (const A_un_NE& a);
// DESTRUCTEUR :
virtual ~A_un_NE ();
// opérateurs
A_un_NE& operator= (const A_un_NE& a);
bool operator== (const A_un_NE& a) const;
bool operator!= (const A_un_NE& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const A_un_NE& a) const;
bool operator <= (const A_un_NE& a) const;
bool operator > (const A_un_NE& a) const;
bool operator >= (const A_un_NE& a) const;
void Affiche();
// retour des grandeurs
const string& Ref_const() const {return ref;}; // la ref
const string& Nom_mail_const() const {return nom_mail;}; // le nom du maillage du noeud
const string& Nom_var_const() const {return nom_var;}; // nom de la variable associée
string& Ref_NE() {return ref;}; // la ref
string* Pointeur_Ref_NE() {return &ref;}; // la ref
string& Nom_mail() {return nom_mail;}; // le nom du maillage du noeud
string* Pointeur_Nom_mail() {return &nom_mail;}; // le nom du maillage du noeud
string& Nom_var() {return nom_var;}; // nom de la variable associée
// récupération du pointeur de la classe
const A_un_NE* PointeurClass_const() const {return this;};
A_un_NE* PointeurClass() {return this;};
protected :
string ref; // la ref associée
string nom_mail; // le nom du maillage du noeud ou élément
string nom_var; // nom de la variable associée
};
// classe conteneur pour un ddl à un noeud
class Ddl_a_un_noeud
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, Ddl_a_un_noeud &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const Ddl_a_un_noeud &);
public :
Ddl_a_un_noeud (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
Ddl_a_un_noeud (Ddl_enum_etendu e,string ref_noeud
, string nom_mail_,string nom_var_, Enum_dure tps);
// constructeur de copie
Ddl_a_un_noeud (const Ddl_a_un_noeud& a);
// DESTRUCTEUR :
virtual ~Ddl_a_un_noeud ();
// opérateurs
Ddl_a_un_noeud& operator= (const Ddl_a_un_noeud& a);
bool operator== (const Ddl_a_un_noeud& a) const;
bool operator!= (const Ddl_a_un_noeud& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const Ddl_a_un_noeud& a) const;
bool operator <= (const Ddl_a_un_noeud& a) const;
bool operator > (const Ddl_a_un_noeud& a) const;
bool operator >= (const Ddl_a_un_noeud& a) const;
void Affiche();
// retour des grandeurs
const Ddl_enum_etendu& Enu_const() const {return enu;} ; // le ddl
const string& Ref_Num_NE_const() const {return ref_num_NE;}; // la ref de num du noeud
const string& Nom_mail_const() const {return nom_mail;}; // le nom du maillage du noeud
const string& Nom_var_const() const {return nom_var;}; // nom de la variable associée
const Enum_dure& Temps_const() const {return temps;}; // temps de validation du ddl
string* Pointeur_Nom_mail() {return &nom_mail;}; // le nom du maillage du noeud
Ddl_enum_etendu& Enu() {return enu;} ; // le ddl
string& Ref_Num_NE() {return ref_num_NE;}; // la ref de num du noeud
string& Nom_mail() {return nom_mail;}; // le nom du maillage du noeud
string& Nom_var() {return nom_var;}; // nom de la variable associée
Enum_dure& Temps() {return temps;}; // temps de validation du ddl
protected :
Ddl_enum_etendu enu; // le ddl
string ref_num_NE; // le num du noeud
string nom_mail; // le nom du maillage du noeud
string nom_var; // nom de la variable associée
Enum_dure temps; // temps de validation du ddl
};
// classe conteneur pour un ddl étendu à un noeud
class Ddl_etendu_a_un_noeud : public A_un_NE
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, Ddl_etendu_a_un_noeud &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const Ddl_etendu_a_un_noeud &);
public :
Ddl_etendu_a_un_noeud (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
Ddl_etendu_a_un_noeud (Ddl_enum_etendu e,string ref_noeud
, string nom_mail_,string nom_var_);
// constructeur de copie
Ddl_etendu_a_un_noeud (const Ddl_etendu_a_un_noeud& a);
// DESTRUCTEUR :
virtual ~Ddl_etendu_a_un_noeud ();
// opérateurs
Ddl_etendu_a_un_noeud& operator= (const Ddl_etendu_a_un_noeud& a);
bool operator== (const Ddl_etendu_a_un_noeud& a) const;
bool operator!= (const Ddl_etendu_a_un_noeud& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const Ddl_etendu_a_un_noeud& a) const;
bool operator <= (const Ddl_etendu_a_un_noeud& a) const;
bool operator > (const Ddl_etendu_a_un_noeud& a) const;
bool operator >= (const Ddl_etendu_a_un_noeud& a) const;
void Affiche();
// retour des grandeurs
Ddl_enum_etendu Enu_const() const {return enu;} ; // le ddl
Ddl_enum_etendu& Enu() {return enu;} ; // le ddl
protected :
Ddl_enum_etendu enu; // le ddl
};
// classe conteneur pour une grandeur quelconque à un noeud
class Quelconque_a_un_noeud : public A_un_NE
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, Quelconque_a_un_noeud &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const Quelconque_a_un_noeud &);
public :
Quelconque_a_un_noeud (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
Quelconque_a_un_noeud (TypeQuelconque_enum_etendu e,string ref_noeud
, string nom_mail_,string nom_var_,int num_ord);
// constructeur de copie
Quelconque_a_un_noeud (const Quelconque_a_un_noeud& a);
// DESTRUCTEUR :
virtual ~Quelconque_a_un_noeud ();
// opérateurs
Quelconque_a_un_noeud& operator= (const Quelconque_a_un_noeud& a);
bool operator== (const Quelconque_a_un_noeud& a) const;
bool operator!= (const Quelconque_a_un_noeud& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const Quelconque_a_un_noeud& a) const;
bool operator <= (const Quelconque_a_un_noeud& a) const;
bool operator > (const Quelconque_a_un_noeud& a) const;
bool operator >= (const Quelconque_a_un_noeud& a) const;
void Affiche();
// retour des grandeurs
const TypeQuelconque_enum_etendu& Quelc_const() const {return quelc;} ; // la grandeur constante
TypeQuelconque_enum_etendu& Quelc() {return quelc;} ; // la grandeur en i/o
const int& Num_ordre_const() const {return num_ordre;};
int& Num_ordre() {return num_ordre;};
protected :
TypeQuelconque_enum_etendu quelc; // la grandeur
int num_ordre; // le numéro de la composante
};
// classe conteneur pour un pti d'élément
class A_un_E : public A_un_NE
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, A_un_E &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const A_un_E &);
public :
A_un_E (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
A_un_E (int absolu_,string ref_
,string nom_mail_,string nom_var_,int nbpti);
// constructeur de copie
A_un_E (const A_un_E& a);
// DESTRUCTEUR :
virtual ~A_un_E ();
// opérateurs
A_un_E& operator= (const A_un_E& a);
bool operator== (const A_un_E& a) const;
bool operator!= (const A_un_E& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const A_un_E& a) const;
bool operator <= (const A_un_E& a) const;
bool operator > (const A_un_E& a) const;
bool operator >= (const A_un_E& a) const;
void Affiche();
// récupération du pointeur de la classe
const A_un_E* PointeurClass_E_const() const {return this;};
A_un_E* PointeurClass_E() {return this;};
// retour des grandeurs
const int& NBpti_const() const {return num_pti;}; // num du pti en const
int& NBpti() {return num_pti;}; // idem direct
const int& Absolue_const() const {return absolu;}; // absolu ou pas
int& Absolue() {return absolu;};
protected :
int num_pti; // numéro du point d'intégration
int absolu; // indique si la grandeur est dans un repère absolu ou local
};
// classe conteneur pour un ddl à un élément
class Ddl_a_un_element : public A_un_E
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, Ddl_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const Ddl_a_un_element &);
public :
Ddl_a_un_element (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
Ddl_a_un_element (int absolu_,Ddl_enum_etendu e,string ref_noeud
,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti);
// constructeur de copie
Ddl_a_un_element (const Ddl_a_un_element& a);
// DESTRUCTEUR :
virtual ~Ddl_a_un_element ();
// opérateurs
Ddl_a_un_element& operator= (const Ddl_a_un_element& a);
bool operator== (const Ddl_a_un_element& a) const;
bool operator!= (const Ddl_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const Ddl_a_un_element& a) const;
bool operator <= (const Ddl_a_un_element& a) const;
bool operator > (const Ddl_a_un_element& a) const;
bool operator >= (const Ddl_a_un_element& a) const;
void Affiche();
// retour des grandeurs
const Ddl_enum_etendu& Enu_const() const {return enu;} ; // le ddl en const
Ddl_enum_etendu& Enu() {return enu;} ; // le ddl direct
const Enum_dure& Temps_const() const {return temps;}; // temps de validation du ddl
Enum_dure& Temps() {return temps;}; // temps de validation du ddl
protected :
Ddl_enum_etendu enu; // le ddl
Enum_dure temps; // temps de validation du ddl
};
// classe conteneur pour un TypeQuelconque à un élément
class TypeQuelconque_a_un_element : public A_un_E
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeQuelconque_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeQuelconque_a_un_element &);
public :
TypeQuelconque_a_un_element (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
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);
// constructeur de copie
TypeQuelconque_a_un_element (const TypeQuelconque_a_un_element& a);
// DESTRUCTEUR :
virtual ~TypeQuelconque_a_un_element ();
// opérateurs
TypeQuelconque_a_un_element& operator= (const TypeQuelconque_a_un_element& a);
bool operator== (const TypeQuelconque_a_un_element& a) const;
bool operator!= (const TypeQuelconque_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeQuelconque_a_un_element& a) const;
bool operator <= (const TypeQuelconque_a_un_element& a) const;
bool operator > (const TypeQuelconque_a_un_element& a) const;
bool operator >= (const TypeQuelconque_a_un_element& a) const;
void Affiche();
// récupération du pointeur de la classe
const TypeQuelconque_a_un_element* PointeurClass_Quelc_const() const {return this;};
TypeQuelconque_a_un_element* PointeurClass_Quelc() {return this;};
// retour des grandeurs
const TypeQuelconque_enum_etendu& Quelc_const() const {return quelc;} ; // la grandeur constante
TypeQuelconque_enum_etendu& Quelc() {return quelc;} ; // la grandeur en i/o
const int& Num_ordre_const() const {return num_ordre;};
int& Num_ordre() {return num_ordre;};
protected :
TypeQuelconque_enum_etendu quelc; // la grandeur
int num_ordre; // le numéro de la composante
};
// classe conteneur pour les grandeurs particulières à un élément
class TypeParticulier_a_un_element : public TypeQuelconque_a_un_element
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeParticulier_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeParticulier_a_un_element &);
public :
TypeParticulier_a_un_element(): TypeQuelconque_a_un_element() {}; // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeParticulier_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_noeud
,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti,int num_ord):
TypeQuelconque_a_un_element(absolu_,e,ref_noeud,nom_mail_,tps,nom_var_,nbpti,num_ord) {} ;
// constructeur de copie
TypeParticulier_a_un_element(const TypeParticulier_a_un_element& a):
TypeQuelconque_a_un_element(a) {};
// DESTRUCTEUR :
virtual ~TypeParticulier_a_un_element() {};
// opérateurs
TypeParticulier_a_un_element& operator= (const TypeParticulier_a_un_element& a)
{(*PointeurClass_Quelc())= (*a.PointeurClass_Quelc_const()); return *this;};
bool operator== (const TypeParticulier_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
bool operator!= (const TypeParticulier_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeParticulier_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) < (*a.PointeurClass_Quelc_const()));};
bool operator <= (const TypeParticulier_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) <= (*a.PointeurClass_Quelc_const()));};
bool operator > (const TypeParticulier_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) > (*a.PointeurClass_Quelc_const()));};
bool operator >= (const TypeParticulier_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
void Affiche();
};
// classe conteneur pour les grandeurs évoluées à un élément
class TypeEvoluee_a_un_element : public TypeQuelconque_a_un_element
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeEvoluee_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeEvoluee_a_un_element &);
public :
TypeEvoluee_a_un_element(): TypeQuelconque_a_un_element() {}; // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeEvoluee_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_noeud
,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti,int num_ord):
TypeQuelconque_a_un_element(absolu_,e,ref_noeud,nom_mail_,tps,nom_var_,nbpti,num_ord) {} ;
// constructeur de copie
TypeEvoluee_a_un_element(const TypeEvoluee_a_un_element& a):
TypeQuelconque_a_un_element(a) {};
// DESTRUCTEUR :
virtual ~TypeEvoluee_a_un_element() {};
// opérateurs
TypeEvoluee_a_un_element& operator= (const TypeEvoluee_a_un_element& a)
{(*PointeurClass_Quelc())= (*a.PointeurClass_Quelc_const());return *this;};
bool operator== (const TypeEvoluee_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
bool operator!= (const TypeEvoluee_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeEvoluee_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) < (*a.PointeurClass_Quelc_const()));};
bool operator <= (const TypeEvoluee_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) <= (*a.PointeurClass_Quelc_const()));};
bool operator > (const TypeEvoluee_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) > (*a.PointeurClass_Quelc_const()));};
bool operator >= (const TypeEvoluee_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
void Affiche();
};
// classe conteneur pour un TypeQuelconque à une face ou arête
class TypeQuelconque_a_Face_arete : public TypeQuelconque_a_un_element
{ public :
TypeQuelconque_a_Face_arete (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
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);
// constructeur de copie
TypeQuelconque_a_Face_arete (const TypeQuelconque_a_Face_arete& a);
// DESTRUCTEUR :
virtual ~TypeQuelconque_a_Face_arete ();
// opérateurs
TypeQuelconque_a_Face_arete& operator= (const TypeQuelconque_a_Face_arete& a);
bool operator== (const TypeQuelconque_a_Face_arete& a) const;
bool operator!= (const TypeQuelconque_a_Face_arete& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeQuelconque_a_Face_arete& a) const;
bool operator <= (const TypeQuelconque_a_Face_arete& a) const;
bool operator > (const TypeQuelconque_a_Face_arete& a) const;
bool operator >= (const TypeQuelconque_a_Face_arete& a) const;
// récupération du pointeur de la classe
const TypeQuelconque_a_Face_arete* PointClass_QuelcFA_const() const {return this;};
TypeQuelconque_a_Face_arete* PointClass_QuelcFA() {return this;};
// retour des grandeurs
const int& Num_FA_const() const {return num_FA;} ; // la grandeur constante
int& Num_FA() {return num_FA;} ; // la grandeur en i/O
protected :
int num_FA; // ref de numéro de la face ou de l'arête
};
// classe conteneur pour les grandeurs quelconque à une face d'élément
class TypeQuelc_face_a_un_element : public TypeQuelconque_a_Face_arete
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeQuelc_face_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeQuelc_face_a_un_element &);
public :
TypeQuelc_face_a_un_element(): TypeQuelconque_a_Face_arete() {}; // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeQuelc_face_a_un_element (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_Face_arete(absolu_,e,ref_element,nom_mail,nbFA,tps,nom_var_,nbpti,num_ord)
{} ;
// constructeur de copie
TypeQuelc_face_a_un_element(const TypeQuelc_face_a_un_element& a):
TypeQuelconque_a_Face_arete(a) {};
// DESTRUCTEUR :
virtual ~TypeQuelc_face_a_un_element() {};
// opérateurs
TypeQuelc_face_a_un_element& operator= (const TypeQuelc_face_a_un_element& a)
{(*PointClass_QuelcFA())= (*a.PointClass_QuelcFA_const());return *this;};
bool operator== (const TypeQuelc_face_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
bool operator!= (const TypeQuelc_face_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeQuelc_face_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) < (*a.PointClass_QuelcFA_const()));};
bool operator <= (const TypeQuelc_face_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) <= (*a.PointClass_QuelcFA_const()));};
bool operator > (const TypeQuelc_face_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) > (*a.PointClass_QuelcFA_const()));};
bool operator >= (const TypeQuelc_face_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
void Affiche();
};
// classe conteneur pour les grandeurs quelconque à une arête d'élément
class TypeQuelc_arete_a_un_element : public TypeQuelconque_a_Face_arete
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeQuelc_arete_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeQuelc_arete_a_un_element &);
public :
TypeQuelc_arete_a_un_element(): TypeQuelconque_a_Face_arete() {}; // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeQuelc_arete_a_un_element (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_Face_arete(absolu_,e,ref_element,nom_mail,nbFA,tps,nom_var_,nbpti,num_ord)
{} ;
// constructeur de copie
TypeQuelc_arete_a_un_element(const TypeQuelc_arete_a_un_element& a):
TypeQuelconque_a_Face_arete(a) {};
// DESTRUCTEUR :
virtual ~TypeQuelc_arete_a_un_element() {};
// opérateurs
TypeQuelc_arete_a_un_element& operator= (const TypeQuelc_arete_a_un_element& a)
{(*PointClass_QuelcFA())= (*a.PointClass_QuelcFA_const());return *this;};
bool operator== (const TypeQuelc_arete_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
bool operator!= (const TypeQuelc_arete_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeQuelc_arete_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) < (*a.PointClass_QuelcFA_const()));};
bool operator <= (const TypeQuelc_arete_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) <= (*a.PointClass_QuelcFA_const()));};
bool operator > (const TypeQuelc_arete_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) > (*a.PointClass_QuelcFA_const()));};
bool operator >= (const TypeQuelc_arete_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
void Affiche();
};
// classe conteneur pour une composante d'une grandeur globale
class TypeQuelc_Une_composante_Grandeur_globale
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeQuelc_Une_composante_Grandeur_globale &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeQuelc_Une_composante_Grandeur_globale &);
public :
TypeQuelc_Une_composante_Grandeur_globale(): var() {}; // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeQuelc_Une_composante_Grandeur_globale (string nom_var, string nom_glob, int num_ord):
var(nom_var,nom_glob,num_ord)
{} ;
// constructeur de copie
TypeQuelc_Une_composante_Grandeur_globale(const TypeQuelc_Une_composante_Grandeur_globale& a):
var(a.var) {};
// DESTRUCTEUR :
virtual ~TypeQuelc_Une_composante_Grandeur_globale() {};
// opérateurs
TypeQuelc_Une_composante_Grandeur_globale& operator= (const TypeQuelc_Une_composante_Grandeur_globale& a)
{var = a.var;return *this;};
bool operator== (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{return (var == a.var);};
bool operator!= (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{return (var < a.var);};
bool operator <= (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{return (var <= a.var);};
bool operator > (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{return (var > a.var);};
bool operator >= (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{return (var >= a.var);};
void Affiche();
// retour des grandeurs
const string& Nom_var_const() const {return var.nom1;}; // nom de la variable associée
string& Nom_var() {return var.nom1;}; // nom de la variable associée
const string& Nom_grandeur_globale_const() const {return var.nom2;}; // nom de la grandeur globale associé
string& Nom_grandeur_globale() {return var.nom2;}; // nom de la grandeur globale associé
const int& Indice_const() const {return var.n;};
int& Indice() {return var.n;};
Deux_String_un_entier Deux_String_un_entier_const() const {return var;} ;
Deux_String_un_entier& Deux_String_un_entier_() {return var;} ;
protected :
Deux_String_un_entier var ;
// var.nom1 -> nom de la variable
// var.nom2 -> nom de la grandeur globale
// var.n -> le numéro de la composante
};
// METHODES :
//=================%%%%%%%% la classe principale %%%%%%%%=================
// CONSTRUCTEURS :
// Constructeur par defaut
VariablesExporter ();
// Constructeur de copie, cependant ici il n'y a pas de création de noeud ni d'élément
// c'est seulement une création de nouveaux conteneurs de pointeurs
// cependant le numéro de maillage et le nom de maillage n'est pas valide, il faut
// ensuite les définir
VariablesExporter (const VariablesExporter& var);
// DESTRUCTEUR :
~VariablesExporter ();
// lecture
void LectureVariablesExporter(UtilLecture * entreePrinc);
// insertion des constantes et variables utilisateurs vers globales
void InsertConstVarUtilisateur_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 InitialisationConteneursQuelconques(LesMaillages& lesMail,const List_io < TypeQuelconque >& listeVecGlob,const LesReferences& lesRef);
// ramène les liste des infos qui seront consultés pour les noeuds
const List_io < Ddl_a_un_noeud >& List_noeud_type_ddl() const {return list_noeud_type_ddl;}; // ddl pur aux noeuds
const List_io < Ddl_etendu_a_un_noeud >& List_noeud_type_ddlEtendu() const {return list_noeud_type_ddlEtendu;}; // idem pour les ddl étendu
const List_io <Quelconque_a_un_noeud>& List_noeud_type_quelconque() const {return list_noeud_type_quelconque;}; // idem en quelconque
// affichage et definition interactive des commandes
void Info_commande_VariablesExporters(UtilLecture * entreePrinc);
// Affiche
void Affiche () const ;
// Surcharge de l'operateur = : realise l'egalite de deux instances
VariablesExporter& operator= (VariablesExporter& var);
// test si toutes les informations sont completes
// = true -> complet
// = false -> incomplet
bool Complet_VariablesExporter(const LesReferences& lesRef);
// mises à jour de constantes globales définies par l'utilisateur
// permet de changer les valeurs, lors d'une suite .info par exemple
void MiseAjourConstantesUtilisateur(UtilLecture& lec);
// renseigne les variables définies par l'utilisateur
// via les valeurs calculées par Herezh
void RenseigneVarUtilisateur(LesMaillages& lesMail,const LesReferences& lesRef);
//----- lecture écriture dans base info -----
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_base_info(ifstream& ent,const int cas);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas);
// sortie du schemaXML: en fonction de enu
static void SchemaXML_VariablesExporters(UtilLecture * entreePrinc,const Enum_IO_XML enu) ;
protected :
// données:
// ---- les constantes utilisateur
list<TypeQuelconque> li_Q; // les constantes
list<string> li_nom; // le nom des constantes
// ------- les variables
// -> noeuds
List_io < Ddl_a_un_noeud > list_noeud_type_ddl; // ddl pur aux noeuds
List_io < Ddl_etendu_a_un_noeud > list_noeud_type_ddlEtendu; // idem pour les ddl étendu
List_io <Quelconque_a_un_noeud> list_noeud_type_quelconque; // idem en quelconque
// -> éléments
List_io < Ddl_a_un_element > list_element_type_ddl; // ddl pur aux pti d'élément
// idem pour les grandeurs particulières et évoluées
List_io < TypeParticulier_a_un_element > list_element_type_particulier;
List_io < TypeQuelconque > list_quelc_element_type_particulier; // les conteneurs associés
List_io < TypeEvoluee_a_un_element > list_element_type_evoluee;
List_io < TypeQuelconque > list_quelc_element_type_evoluee; // les conteneurs associés
// -> face d'éléments
List_io <TypeQuelc_face_a_un_element > list_face_element_type_quelc;
List_io < TypeQuelconque > list_quelc_face_element_type_quelc; // les conteneurs associés
// -> arête d'éléments
List_io <TypeQuelc_arete_a_un_element > list_arete_element_type_quelc;
List_io < TypeQuelconque > list_quelc_arete_element_type_quelc; // les conteneurs associés
bool initiaConteneurQuelconque; // pour gérer une seule initialisation
// -> une composante d'une variable globale de type multidimentionnel
List_io <TypeQuelc_Une_composante_Grandeur_globale > list_var_glob_sur_grandeur_globale;
// méthodes
//---- constantes utilisateurs
// lecture éventuelle de constantes globales définies par l'utilisateur
void LecConstantesUtilisateur(UtilLecture& lec);
// insertion des constantes utilisateur dans les variables globales
void InsertConstUtilisateur_dans_globale();
// def de constantes utilisateur pour une sortie sur un fichier de commande
void Info_commande_ConstantesUtilisateur(UtilLecture * lec);
// ---- variables utilisateur
// lecture éventuelle des variables globales définies par l'utilisateur
void LecVariablesUtilisateur(UtilLecture& lec);
// def de variables utilisateur pour une sortie sur un fichier de commande
void Info_commande_VariablesUtilisateur(UtilLecture * lec);
// insertion et stockage des variables au niveau de ParaGlob
void Insert_VarUtilisateur_dans_globale();
// 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 VerifNomVariable(const string& nom,bool avec_sortie) const;
// lecture interactive du nom de la variable: hors variable relais
string Lect_interactive_nom_var();
// lecture interactive du nom d'une variable relais
string Lect_interactive_nom_var_relais();
// insertion d'une composante d'une grandeur quelconque en globale
// sous forme d'un double
void InsertCompGrandeurQuelc(const string& non_var,const TypeQuelconque_enum_etendu& enu);
};
/// @} // end of group
#endif
Reference in a new issue View git blame Copy permalink