802 lines
31 KiB
C++
Executable file
802 lines
31 KiB
C++
Executable file
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
/************************************************************************
|
|
* DATE: 23/01/97 *
|
|
* $ *
|
|
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
|
|
* $ *
|
|
* PROJET: Herezh++ *
|
|
* $ *
|
|
************************************************************************
|
|
* BUT: Gestion de divers bloc courant du fichier de lecture . *
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
|
|
* VERIFICATION: *
|
|
* *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* ! ! ! ! *
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
|
|
* MODIFICATIONS: *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* $ *
|
|
************************************************************************/
|
|
#ifndef BLOC_H
|
|
#define BLOC_H
|
|
|
|
#include <iostream>
|
|
#include <stdlib.h>
|
|
#include "Sortie.h"
|
|
#include "UtilLecture.h"
|
|
#include "string"
|
|
#include "string.h"
|
|
// #include "bool.h"
|
|
#include "ParaGlob.h"
|
|
#include "Tableau_T.h"
|
|
#include "Coordonnee.h"
|
|
#include "TypeQuelconque.h"
|
|
|
|
|
|
/** @defgroup Goupe_conteneurs_bloc
|
|
*
|
|
* BUT: groupe concernant la définition de bloc de stockage divers associant des opérations d'I/O
|
|
*
|
|
*
|
|
* \author Gérard Rio
|
|
* \version 1.0
|
|
* \date 23/01/97
|
|
* \brief groupe concernant la définition de bloc de stockage divers associant des opérations d'I/O
|
|
*
|
|
*/
|
|
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//================================================
|
|
// cas d'un bloc scalaire normal
|
|
//================================================
|
|
// un bloc scalaire normal correspond a une reference
|
|
// et une seule valeur
|
|
|
|
class BlocScal
|
|
{
|
|
// surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream &, BlocScal &);
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream &, const BlocScal &);
|
|
public :
|
|
// VARIABLES PUBLIQUES :
|
|
// stockage d'un element
|
|
// class conforme a la specif de T de la class LectBloc_T
|
|
|
|
// Constructeur
|
|
BlocScal () ; // par defaut
|
|
BlocScal (const string nom, const double valeur)
|
|
: nomref(nom),val(valeur) {} ;
|
|
BlocScal (const BlocScal& a) ; // de copie
|
|
// destructeur
|
|
~BlocScal () ;
|
|
|
|
//-------- les méthodes constantes --------------
|
|
// retourne le nom de reference
|
|
const string & NomRef() const;
|
|
// la méthode MemeCibleMaisDataDifferents, ne sert pas ici,
|
|
// mais elle est définit pour des raisons de compatibilité
|
|
bool MemeCibleMaisDataDifferents(BlocScal& ) const {return false;};
|
|
// affichage des informations
|
|
void Affiche() const ;
|
|
// surcharge des operateurs
|
|
bool operator == (const BlocScal& a) const;
|
|
// retourne la valeur en lecture
|
|
const double Val() const { return val;};
|
|
bool operator != (const BlocScal& a) const;
|
|
bool operator < (const BlocScal& a) const;
|
|
|
|
//------------- les méthodes qui modifient -------------
|
|
// modifie le nom de reference
|
|
void Change_Nomref(const string newnom) { nomref = newnom;};
|
|
// lecture d'un bloc
|
|
void Lecture(UtilLecture & entreePrinc);
|
|
// nom de maillage: par défaut null, surchargé ensuite si l'on veut
|
|
string * NomMaillage() {return NULL;};
|
|
BlocScal& operator = (const BlocScal& a);
|
|
// modifie la valeur
|
|
void Change_val(const double a) {val = a;};
|
|
|
|
protected :
|
|
double val; // valeur
|
|
string nomref; // nom de la ref
|
|
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//================================================
|
|
// cas d'un bloc scalaire ou non de fonction nD
|
|
//================================================
|
|
// un bloc qui correspond a une reference
|
|
// et soit une seule valeur ou soit le nom d'une fonction nD
|
|
// qui doit-être précédé par le mot clé une_fonction_nD_
|
|
|
|
class BlocScal_ou_fctnD
|
|
{
|
|
// surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream &, BlocScal_ou_fctnD &);
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream &, const BlocScal_ou_fctnD &);
|
|
public :
|
|
// VARIABLES PUBLIQUES :
|
|
// stockage d'un element
|
|
// class conforme a la specif de T de la class LectBloc_T
|
|
|
|
// Constructeur
|
|
BlocScal_ou_fctnD () ; // par defaut
|
|
BlocScal_ou_fctnD (const string nom, const double valeur)
|
|
: nomref(nom),val(new double(valeur)) {} ;
|
|
BlocScal_ou_fctnD (const BlocScal_ou_fctnD& a) ; // de copie
|
|
// destructeur
|
|
~BlocScal_ou_fctnD () ;
|
|
|
|
//-------- les méthodes constantes --------------
|
|
// retourne le nom de reference
|
|
const string & NomRef() const;
|
|
// la méthode MemeCibleMaisDataDifferents, ne sert pas ici,
|
|
// mais elle est définit pour des raisons de compatibilité
|
|
bool MemeCibleMaisDataDifferents(BlocScal_ou_fctnD& ) const {return false;};
|
|
// affichage des informations
|
|
void Affiche() const ;
|
|
// surcharge des operateurs
|
|
bool operator == (const BlocScal_ou_fctnD& a) const;
|
|
// retourne la valeur en lecture si elle existe
|
|
// sinon retourne un pointeur NULL
|
|
const double* Val() const { return val;};
|
|
// retourne le nom de la fonction nD en lecture si elle existe
|
|
// sinon retourne un pointeur NULL
|
|
const string* Fct_nD() const { return fctnD;};
|
|
bool operator != (const BlocScal_ou_fctnD& a) const;
|
|
bool operator < (const BlocScal_ou_fctnD& a) const;
|
|
|
|
//------------- les méthodes qui modifient -------------
|
|
// modifie le nom de reference
|
|
void Change_Nomref(const string newnom) { nomref = newnom;};
|
|
// lecture d'un bloc
|
|
void Lecture(UtilLecture & entreePrinc);
|
|
// nom de maillage: par défaut null, surchargé ensuite si l'on veut
|
|
string * NomMaillage() {return NULL;};
|
|
BlocScal_ou_fctnD& operator = (const BlocScal_ou_fctnD& a);
|
|
// modifie la valeur du double: possible uniquement s'il n'y a pas de fonction nD
|
|
void Change_val(const double a);
|
|
// modifie la valeur du nom de la fonction : possible uniquement s'il n'y a pas de valeur
|
|
void Change_fctnD(const string a);
|
|
|
|
protected :
|
|
double* val; // valeur si le pointeur est non nulle
|
|
string* fctnD; // nom de fonction si le pointeur est non nulle
|
|
string nomref; // nom de la ref
|
|
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//================================================
|
|
// cas d'un bloc scalaire type
|
|
//================================================
|
|
// un bloc scalaire type correspond a une reference
|
|
// un mot cle, et une seule valeur
|
|
|
|
class BlocScalType
|
|
{
|
|
// surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream &, BlocScalType &);
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream &, const BlocScalType &);
|
|
public :
|
|
// VARIABLES PUBLIQUES :
|
|
// stockage d'un element
|
|
// class conforme a la specif de T de la class LectBloc_T
|
|
|
|
// Constructeur
|
|
BlocScalType () ; // par defaut
|
|
BlocScalType (const BlocScalType& a) ; // de copie
|
|
// destructeur
|
|
~BlocScalType () ;
|
|
|
|
//-------- les méthodes constantes --------------
|
|
// retourne le nom de reference
|
|
const string & NomRef() const;
|
|
// retourne le nom du mot clef
|
|
const string & Mot_clef() const {return motClef;};
|
|
// la méthode MemeCibleMaisDataDifferents, ramène true si d et this on le même nom de ref et mot clé
|
|
// mais pas la même valeur
|
|
bool MemeCibleMaisDataDifferents(BlocScalType& d) const
|
|
{if ((nomref == d.NomRef()) && (motClef == d.Mot_clef())
|
|
&& (val != d.val))
|
|
{return true;}
|
|
else return false;
|
|
};
|
|
// affichage des informations
|
|
void Affiche() const ;
|
|
// surcharge des operateurs
|
|
bool operator == (const BlocScalType& a) const;
|
|
bool operator != (const BlocScalType& a) const;
|
|
// retourne la valeur en lecture
|
|
const double Val() const { return val;};
|
|
|
|
//------------- les méthodes qui modifient -------------
|
|
// nom de maillage: par défaut null, surchargé ensuite si l'on veut
|
|
string * NomMaillage() {return NULL;};
|
|
// modifie le nom de reference
|
|
void Change_Nomref(const string newnom) { nomref = newnom;};
|
|
// modifie le nom du mot clef
|
|
void Change_Mot_clef(const string newnom) { motClef = newnom;};
|
|
// lecture d'un bloc
|
|
void Lecture(UtilLecture & entreePrinc);
|
|
BlocScalType& operator = (const BlocScalType& a);
|
|
// modifie la valeur
|
|
void Change_val(const double a) {val = a;};
|
|
|
|
protected :
|
|
double val; // valeur
|
|
string nomref; // nom de la ref
|
|
string motClef; // nom du mot cle
|
|
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//========================================================
|
|
// cas d'un bloc general de n chaines et de m scalaires
|
|
//========================================================
|
|
//
|
|
|
|
class BlocGen
|
|
{
|
|
// surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream &, BlocGen &);
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream &, const BlocGen &);
|
|
public :
|
|
// VARIABLES PUBLIQUES :
|
|
// stockage d'un element
|
|
// class conforme a la specif de T de la class LectBloc_T
|
|
// Constructeur
|
|
// n= nombre de string, m nombre de double
|
|
BlocGen (int n=1, int m =1) ; // par defaut
|
|
BlocGen (const BlocGen& a) ; // de copie
|
|
|
|
// destructeur
|
|
~BlocGen () ;
|
|
|
|
//-------- les méthodes constantes --------------
|
|
// retourne le nom de reference
|
|
// apriori c'est le premier nom stocke
|
|
string & NomRef() const;
|
|
// retourne le i ieme nom en lecture
|
|
inline const string& Nom(int i) const { return ptnom(i);};
|
|
// retourne la ieme valeur en lecture
|
|
inline const double& Val(int i) const { return pt(i);};
|
|
// retourne la dimension en nom
|
|
inline int DimNom() const{ return ptnom.Taille();};
|
|
// retourne la dimension en valeurs
|
|
inline int DimVal() const { return pt.Taille();};
|
|
// la méthode MemeCibleMaisDataDifferents, ne sert pas ici,
|
|
// mais elle est définie pour des raisons de compatibilité
|
|
bool MemeCibleMaisDataDifferents(BlocGen& )const {return false;};
|
|
// affichage des informations
|
|
void Affiche() const ;
|
|
// surcharge des operateurs
|
|
bool operator == (const BlocGen& a) const;
|
|
bool operator != (const BlocGen& a) const;
|
|
|
|
//------------- les méthodes qui modifient -------------
|
|
// change la ieme valeur
|
|
void Change_val(const int i, double val) {pt(i)=val;};
|
|
// change le i ieme nom
|
|
void Change_nom(const int i,const string& nom) { ptnom(i) = nom;};
|
|
// lecture d'un bloc
|
|
void Lecture(UtilLecture & entreePrinc);
|
|
// nom de maillage: par défaut null, surchargé ensuite si l'on veut
|
|
string * NomMaillage() {return NULL;};
|
|
BlocGen& operator = (const BlocGen& a);
|
|
|
|
|
|
protected :
|
|
Tableau<double> pt ; // les valeurs
|
|
Tableau<string> ptnom; // les noms
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//========================================================
|
|
// cas d'un bloc de 3 noms et 1 scalaires
|
|
//========================================================
|
|
//
|
|
|
|
class BlocGen_3_1 : public BlocGen
|
|
{ // surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream & entree, BlocGen_3_1 & coo)
|
|
{ entree >> *((BlocGen*) &coo);return entree;} ;
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream & sort, const BlocGen_3_1 & coo)
|
|
{ sort << *((BlocGen*) &coo);return sort;} ;
|
|
public :
|
|
// Constructeur par defaut
|
|
BlocGen_3_1 () : BlocGen(3,1) { };
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//========================================================
|
|
// cas d'un bloc de 3 noms et 2 scalaires
|
|
//========================================================
|
|
//
|
|
|
|
class BlocGen_3_2 : public BlocGen
|
|
{ // surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream & entree, BlocGen_3_2 & coo)
|
|
{ entree >> *((BlocGen*) &coo);return entree;} ;
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream & sort, const BlocGen_3_2 & coo)
|
|
{ sort << *((BlocGen*) &coo);return sort;} ;
|
|
public :
|
|
// Constructeur par defaut
|
|
BlocGen_3_2 () : BlocGen(3,2) { };
|
|
};
|
|
/// @} // end of group
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//========================================================
|
|
// cas d'un bloc de 3 noms et 0 scalaires
|
|
//========================================================
|
|
//
|
|
|
|
class BlocGen_3_0 : public BlocGen
|
|
{ // surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream & entree, BlocGen_3_0 & coo)
|
|
{ entree >> *((BlocGen*) &coo);return entree;} ;
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream & sort, const BlocGen_3_0 & coo)
|
|
{ sort << *((BlocGen*) &coo);return sort;} ;
|
|
public :
|
|
// Constructeur par defaut
|
|
BlocGen_3_0 () : BlocGen(3,0) { };
|
|
};
|
|
/// @} // end of group
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//========================================================
|
|
// cas d'un bloc de 4 noms et 0 scalaires
|
|
//========================================================
|
|
//
|
|
|
|
class BlocGen_4_0 : public BlocGen
|
|
{ // surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream & entree, BlocGen_4_0 & coo)
|
|
{ entree >> *((BlocGen*) &coo);return entree;} ;
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream & sort, const BlocGen_4_0 & coo)
|
|
{ sort << *((BlocGen*) &coo);return sort;} ;
|
|
public :
|
|
// Constructeur par defaut
|
|
BlocGen_4_0 () : BlocGen(4,0) { };
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//========================================================
|
|
// cas d'un bloc de 5 noms et 0 scalaires
|
|
//========================================================
|
|
//
|
|
|
|
class BlocGen_5_0 : public BlocGen
|
|
{ // surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream & entree, BlocGen_5_0 & coo)
|
|
{ entree >> *((BlocGen*) &coo);return entree;} ;
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream & sort, const BlocGen_5_0 & coo)
|
|
{ sort << *((BlocGen*) &coo);return sort;} ;
|
|
public :
|
|
// Constructeur par defaut
|
|
BlocGen_5_0 () : BlocGen(5,0) { };
|
|
};
|
|
/// @} // end of group
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//========================================================
|
|
// cas d'un bloc de 6 noms et 0 scalaires
|
|
//========================================================
|
|
//
|
|
|
|
class BlocGen_6_0 : public BlocGen
|
|
{ // surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream & entree, BlocGen_6_0 & coo)
|
|
{ entree >> *((BlocGen*) &coo);return entree;} ;
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream & sort, const BlocGen_6_0 & coo)
|
|
{ sort << *((BlocGen*) &coo);return sort;} ;
|
|
public :
|
|
// Constructeur par defaut
|
|
BlocGen_6_0 () : BlocGen(6,0) { };
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//================================================
|
|
// cas d'un bloc vecteur
|
|
//================================================
|
|
// un bloc vecteur correspond a une reference et
|
|
// un vecteur, fonction de la dimension du pb
|
|
|
|
class BlocVec
|
|
{
|
|
// surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream &, BlocVec &);
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream &, const BlocVec &);
|
|
public :
|
|
// VARIABLES PUBLIQUES :
|
|
// stockage d'un element
|
|
// class conforme a la specif de T de la class LectBloc_T
|
|
|
|
// Constructeur
|
|
BlocVec () ; // par defaut
|
|
BlocVec (const BlocVec & a) ; // de copie
|
|
// destructeur
|
|
~BlocVec () ;
|
|
|
|
//-------- les méthodes constantes --------------
|
|
// retourne le nom de reference
|
|
const string & NomRef() const;
|
|
// la méthode MemeCibleMaisDataDifferents, ne sert pas ici,
|
|
// mais elle est définit pour des raisons de compatibilité
|
|
bool MemeCibleMaisDataDifferents(BlocVec& ) const {return false;};
|
|
// affichage des informations
|
|
void Affiche() const ;
|
|
// surcharge des operateurs
|
|
bool operator == (const BlocVec& a) const;
|
|
bool operator != (const BlocVec& a) const;
|
|
// retourne les coordonnées en constantes
|
|
const Coordonnee& Coord() const { return coorpt;};
|
|
// retourne une coordonnée
|
|
double Coord(int i) const { return coorpt(i);};
|
|
|
|
//------------- les méthodes qui modifient -------------
|
|
// nom de maillage: par défaut null, surchargé ensuite si l'on veut
|
|
string * NomMaillage() {return NULL;};
|
|
// lecture d'un bloc en fonction de la dimension
|
|
void Lecture(UtilLecture & entreePrinc);
|
|
BlocVec& operator = (const BlocVec& a);
|
|
// modifie les valeurs du vecteur
|
|
void Change_val(Coordonnee& a) {coorpt = a;};
|
|
|
|
|
|
protected :
|
|
Coordonnee coorpt; // les coordonnées du vecteur
|
|
string nomref; // nom de la ref
|
|
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//================================================
|
|
// cas d'un bloc vecteur type
|
|
//================================================
|
|
// un bloc vecteur type correspond a une reference et
|
|
// un mot cle et un vecteur, fonction de la dimension du pb
|
|
|
|
class BlocVecType
|
|
{
|
|
// surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream &, BlocVecType &);
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream &, const BlocVecType &);
|
|
public :
|
|
// VARIABLES PUBLIQUES :
|
|
// stockage d'un element
|
|
// class conforme a la specif de T de la class LectBloc_T
|
|
|
|
// Constructeur
|
|
BlocVecType () ; // par defaut
|
|
BlocVecType (const BlocVecType & a) ; // par defaut
|
|
// destructeur
|
|
~BlocVecType () ;
|
|
|
|
//-------- les méthodes constantes --------------
|
|
// retourne le nom de reference
|
|
const string & NomRef() const;
|
|
// retourne le nom du mot clef
|
|
const string & Mot_clef() const {return motClef;};
|
|
// la méthode MemeCibleMaisDataDifferents, ramène true
|
|
// si d et this on le même nom de ref et mot clé
|
|
// mais pas les mêmes coordonnées
|
|
bool MemeCibleMaisDataDifferents(BlocVecType& d)const
|
|
{if ((nomref == d.NomRef()) && (motClef == d.Mot_clef())
|
|
&& (coorpt != d.coorpt))
|
|
{return true;}
|
|
else return false;
|
|
};
|
|
// affichage des informations
|
|
void Affiche() const ;
|
|
// surcharge des operateurs
|
|
bool operator == (const BlocVecType& a) const;
|
|
bool operator != (const BlocVecType& a) const;
|
|
// retourne les coordonnées en constantes
|
|
const Coordonnee& Coord() const { return coorpt;};
|
|
// retourne une coordonnée
|
|
double Coord(int i) const { return coorpt(i);};
|
|
|
|
//------------- les méthodes qui modifient -------------
|
|
// nom de maillage: par défaut null, surchargé ensuite si l'on veut
|
|
string * NomMaillage() {return NULL;};
|
|
// lecture d'un bloc en fonction de la dimension
|
|
void Lecture(UtilLecture & entreePrinc);
|
|
// modifie les valeurs du vecteur
|
|
void Change_val(Coordonnee& a) {coorpt = a;};
|
|
BlocVecType& operator = (const BlocVecType& a);
|
|
|
|
|
|
protected :
|
|
Coordonnee coorpt; // les coordonnées du vecteur
|
|
string nomref; // nom de la ref
|
|
string motClef; // nom du mot cle
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//================================================
|
|
// cas d'un bloc de n vecteur et m scalaires type
|
|
//================================================
|
|
// un bloc de plusieurs vecteurs et plusieurs scalaires type correspond a une reference et
|
|
// un mot cle et des vecteurs, fonction de la dimension du pb et des scalaires
|
|
|
|
class BlocVecMultType
|
|
{
|
|
// surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream &, BlocVecMultType &);
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream &, const BlocVecMultType &);
|
|
public :
|
|
// VARIABLES PUBLIQUES :
|
|
// stockage d'un element
|
|
// class conforme a la specif de T de la class LectBloc_T
|
|
|
|
// Constructeur
|
|
// n est le nombre de vecteur à dimensionner
|
|
// m le nombre de scalaires
|
|
BlocVecMultType (int n=1,int m=1) ; // par defaut
|
|
BlocVecMultType (const BlocVecMultType & a) ; // par defaut
|
|
// destructeur
|
|
~BlocVecMultType () ;
|
|
|
|
//-------- les méthodes constantes --------------
|
|
// retourne le nom de reference
|
|
const string & NomRef() const;
|
|
// retourne le nom du mot clef
|
|
const string & Mot_clef() const {return motClef;};
|
|
// la méthode MemeCibleMaisDataDifferents, ramène true si d et this on le même nom de ref et mot clé
|
|
// mais que le tableau de coordonnées ou de scalaire n'est pas identique
|
|
bool MemeCibleMaisDataDifferents(BlocVecMultType& d) const
|
|
{if ((nomref == d.NomRef()) && (motClef == d.Mot_clef())
|
|
&& (((this->pt)!=d.pt) || (this->vect_coorpt)!= d.vect_coorpt) )
|
|
{return true;}
|
|
else return false;
|
|
};
|
|
// affichage des informations
|
|
void Affiche() const ;
|
|
// surcharge des operateurs
|
|
bool operator == (const BlocVecMultType& a) const;
|
|
bool operator != (const BlocVecMultType& a) const;
|
|
// retourne les coordonnées du vecteur i en constantes
|
|
const Coordonnee& Vect_de_coordonnee (int i) const { return vect_coorpt(i);};
|
|
// retourne la ieme valeur scalaire en lecture
|
|
inline const double& Val(int i) const { return pt(i);};
|
|
// retourne la dimension en vecteur
|
|
inline int DimVect() const { return vect_coorpt.Taille();};
|
|
// retourne la dimension en scalaire
|
|
inline int DimVal() const { return pt.Taille();};
|
|
|
|
//------------- les méthodes qui modifient -------------
|
|
// nom de maillage: par défaut null, surchargé ensuite si l'on veut
|
|
string * NomMaillage() {return NULL;};
|
|
// lecture d'un bloc en fonction de la dimension
|
|
void Lecture(UtilLecture & entreePrinc);
|
|
BlocVecMultType& operator = (const BlocVecMultType& a);
|
|
// modifie les valeurs d'un vecteur i
|
|
void Change_vect_de_coordonnee(int i, const Coordonnee& a) {vect_coorpt(i) = a;};
|
|
// change la ieme valeur scalaire
|
|
void Change_val(const int i, double val) {pt(i)=val;};
|
|
|
|
|
|
protected :
|
|
Tableau <Coordonnee> vect_coorpt; // les coordonnées du vecteur
|
|
Tableau<double> pt ; // les scalaires
|
|
string nomref; // nom de la ref
|
|
string motClef; // nom du mot cle
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup Goupe_conteneurs_bloc
|
|
/// @{
|
|
///
|
|
|
|
//=======================================================================
|
|
// cas d'un bloc general de n vecteurs, m scalaire
|
|
// avec un choix en lecture et définition des coordonnees ou de chaine
|
|
//=======================================================================
|
|
//
|
|
class BlocGeneEtVecMultType
|
|
{ // surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream & entree, BlocGeneEtVecMultType & );
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream & sort, const BlocGeneEtVecMultType & );
|
|
public :
|
|
// constructeur par défaut
|
|
// n: le nombre de vecteurs, m le nombre de scalaires , n le nombre de ptnom
|
|
BlocGeneEtVecMultType(int n=1,int m=1);
|
|
BlocGeneEtVecMultType (const BlocGeneEtVecMultType & a) ; // constructeur par defaut
|
|
~BlocGeneEtVecMultType () ; // destructeur
|
|
|
|
//-------- les méthodes constantes --------------
|
|
// retourne le nom de reference
|
|
const string & NomRef() const {return nomref;};
|
|
// retourne le nom du mot clef
|
|
const string & Mot_clef() const {return motClef;};
|
|
// la méthode MemeCibleMaisDataDifferents, ramène true si d et this on le même nom de ref et mot clé
|
|
// mais que le tableau de coordonnées ou de scalaire n'est pas identique
|
|
bool MemeCibleMaisDataDifferents(BlocGeneEtVecMultType& d) const
|
|
{if ((nomref == d.NomRef()) && (motClef == d.Mot_clef())
|
|
&& (((this->tab_val)!=d.tab_val) || ((this->vect_coorpt)!= d.vect_coorpt)
|
|
|| ((this->ptnom_vect)!=d.ptnom_vect))
|
|
)
|
|
{return true;}
|
|
else return false;
|
|
};
|
|
// affichage des informations
|
|
void Affiche() const ;
|
|
// surcharge des operateurs
|
|
bool operator == (const BlocGeneEtVecMultType& a) const;
|
|
bool operator != (const BlocGeneEtVecMultType& a) const;
|
|
// retourne les coordonnées du vecteur i en constantes
|
|
const Coordonnee& Vect_de_coordonnee(int i) const { return vect_coorpt(i);};
|
|
// retourne la ieme valeur scalaire en lecture
|
|
inline const double& Val(int i) const { return tab_val(i);};
|
|
// retourne la dimension en vecteur
|
|
inline int DimVect() const { return vect_coorpt.Taille();};
|
|
// retourne le nombre de scalaire
|
|
inline int DimVal() const { return tab_val.Taille();};
|
|
// retourne le (i,j) ieme nom associé aux vecteurs en lecture
|
|
inline const string& Nom_vect(int i,int j) const { return ptnom_vect(i)(j);};
|
|
// retourne le (i) ieme nom associé aux valeurs en lecture
|
|
inline const string& Nom_val(int i) const { return ptnom_tab_val(i);};
|
|
|
|
//------------- les méthodes qui modifient -------------
|
|
BlocGeneEtVecMultType& operator = (const BlocGeneEtVecMultType& a);
|
|
// lecture d'un bloc en fonction de la dimension
|
|
void Lecture(UtilLecture & entreePrinc);
|
|
// lecture uniquement de l'entête: nom ref et mot clef
|
|
void Lecture_entete(UtilLecture & entreePrinc)
|
|
{ *(entreePrinc.entree) >> nomref >> motClef;};
|
|
|
|
// modifie les valeurs d'un vecteur i
|
|
void Change_vect_de_coordonnee(int i, const Coordonnee& a) {vect_coorpt(i) = a;};
|
|
// nom de maillage: par défaut null, surchargé ensuite si l'on veut
|
|
string * NomMaillage() {return NULL;};
|
|
// change la ieme valeur scalaire
|
|
void Change_val(const int i, double val) {tab_val(i)=val;};
|
|
// change le (i,j) ieme nom associé aux vecteurs
|
|
void Change_nom_val(int i,const string& nom) { ptnom_tab_val(i) = nom;};
|
|
// change le tableau des coordonnées, la taille des noms associés est modifié
|
|
// en conséquence
|
|
void Change_vect_coorpt(const Tableau <Coordonnee>& vect);
|
|
// change le tableau des coordonnées, la taille des noms associés est modifié
|
|
// en conséquence, ici à partir d'une liste
|
|
void Change_vect_coorpt(const list<Coordonnee>& livect);
|
|
// change le tableau des scalaires
|
|
// la taille des noms associés est modifié en conséquence
|
|
void Change_tab_val(const Tableau <double>& t_val)
|
|
{tab_val=t_val;ptnom_tab_val.Change_taille(t_val.Taille());};
|
|
// change le tableau de scalaires en fonction d'une liste
|
|
// la taille des noms associés est modifié en conséquence
|
|
void Change_tab_val(const list<double>& li);
|
|
// change le tableau des noms associés aux vecteurs
|
|
// la taille du tableau de vecteurs associés est modifié en conséquence
|
|
void Change_ptnom_vect(const Tableau <Tableau<string> >& t_ptnom_vect);
|
|
// change le (i,j) ieme nom associé aux vecteurs
|
|
void Change_nom_vect(int i,int j,const string& nom) { ptnom_vect(i)(j) = nom;};
|
|
// change le tableau des noms associés aux scalaires
|
|
// la taille du tableau de vecteurs associés est modifié en conséquence
|
|
void Change_ptnom_val(const Tableau<string> & t_ptnom_val);
|
|
// change le tableau des noms associé aux scalaires en fonction d'une liste
|
|
// la taille du tableau de scalaires associés est modifié en conséquence
|
|
void Change_ptnom_val(const list<string>& li);
|
|
|
|
protected :
|
|
Tableau <Coordonnee> vect_coorpt; // les coordonnées du vecteur
|
|
Tableau <Tableau<string> > ptnom_vect; // les noms associés aux vecteurs
|
|
Tableau<double> tab_val ; // les scalaires
|
|
Tableau <string > ptnom_tab_val; // les noms associés aux scalaires
|
|
string nomref; // nom de la ref
|
|
string motClef; // nom du mot cle
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
#endif
|