
// 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:        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  
