Herezh_dev/herezh_pp/Lecture/Bloc.h

801 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