Herezh_dev/TypeBase/PtTabRel.h

// 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:   Listes de petits tableaux de réels
*     la definition exacte des listes globales est faite dans le
*     fichier PtTabRel_Prin.h qui n'est inclus qu'une seule fois
*     dans le fichier du programme principal
*                                                                $     *
*     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
************************************************************************/


#ifndef PTTABREL_H
#define PTTABREL_H

//#include <boost/pool/poolfwd.hpp>
//#include </opt/local/include/boost/pool/poolfwd.hpp>
#include <list>

/** @defgroup Les_listes_de_petits_tableaux_de_reels
*
*     BUT:   Listes de petits tableaux de réels
*     la definition exacte des listes globales est faite dans le
*     fichier PtTabRel_Prin.h qui n'est inclus qu'une seule fois
*     dans le fichier du programme principal
*
*
* \author    Gérard Rio
* \version   1.0
* \date       23/01/97
* \brief       Listes de petits tableaux de réels
*
*/

/** @defgroup Les_pointeurs_dans_listes_de_petits_tableaux
*
*     BUT:   def de pointeur qui donne la position d'un élément dans une liste
*
* \author    Gérard Rio
* \version   1.0
* \date       23/01/97
* \brief       def de pointeur qui donne la position d'un élément dans une liste
*
*/

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///

//------------------------------------------------------------------
//!      ReelsPointe  classe virtuelle de laquelle dérive  les  classe  contenant un pointeur de réel
//------------------------------------------------------------------
/// \author    Gérard Rio
/// \version   1.0
/// \date       23/01/97

// ===== tout d'abord une classe virtuelle de laquelle dérive  les  classe  contenant
// un pointeur de réel 
class ReelsPointe 
{   public :
  };

/// @}  // end of group

//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de 1 réel
class Reels1 
{   public :
   // Données :
   double donnees ;
  };
/// @}  // end of group

extern std::list < Reels1 > listdouble1;
typedef  std::list < Reels1 >::iterator listdouble1Iter  ;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
class Reel1Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel1Pointe () : ipointe()
          { listdouble1.push_front(Reels1());  // allocation d'un maillon
             ipointe =  listdouble1.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel1Pointe ()
               {  listdouble1.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble1Iter  ipointe;  // donne la position dans la liste du maillon
  };
  /// @}  // end of group

  
//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de 2 réels
class Reels2  
{   public :
   // Données : 
   double donnees [2];
  }; 
/// @}  // end of group

extern std::list <Reels2> listdouble2;
typedef  std::list < Reels2 >::iterator listdouble2Iter  ;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de 2 réels
class Reel2Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel2Pointe () : ipointe()
          { listdouble2.push_front(Reels2());  // allocation d'un maillon
             ipointe =  listdouble2.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel2Pointe ()
               {  listdouble2.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble2Iter  ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group


//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de trois réels
class Reels3 
{   public :
   // Données : 
   double donnees [3];
  }; 
/// @}  // end of group

extern std::list <Reels3> listdouble3;
typedef  std::list < Reels3 >::iterator listdouble3Iter  ;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de trois réels
class Reel3Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel3Pointe () : ipointe()
          { listdouble3.push_front(Reels3());  // allocation d'un maillon
             ipointe =  listdouble3.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel3Pointe ()
               {  listdouble3.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble3Iter  ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group

//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de quatre réels
class Reels4 
{   public :
   /*  Reels4 () { donnees [0] = 11;donnees [1] =  12; donnees [2] =  13; donnees [3] =  14;// initialisation
             };*/

   // Données : 
   double donnees [4];
  }; 
/// @}  // end of group

typedef  std::list < Reels4 >::iterator listdouble4Iter  ;
extern std::list <Reels4> listdouble4;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de quatre réels
class Reel4Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel4Pointe () : ipointe()
          { listdouble4.push_front(Reels4());  // allocation d'un maillon
             ipointe =  (listdouble4.begin()); // mémorisation du maillon
             }
         // destructeur
         ~ Reel4Pointe ()
               {  listdouble4.erase( ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble4Iter ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group

//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de 5 réels
class Reels5 
{   public :
   // Données : 
   double donnees [5];
  }; 
/// @}  // end of group

typedef  std::list < Reels5 >::iterator listdouble5Iter  ;
extern std::list <Reels5> listdouble5;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de 5 réels
class Reel5Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel5Pointe () : ipointe()
          { listdouble5.push_front(Reels5());  // allocation d'un maillon
             ipointe =  listdouble5.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel5Pointe ()
               {  listdouble5.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble5Iter  ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group

//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de 6 réels
class Reels6 
{   public :
   // Données : 
   double donnees [6];
  }; 
/// @}  // end of group

extern std::list <Reels6> listdouble6;
typedef  std::list < Reels6 >::iterator listdouble6Iter  ;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de 6 réels
class Reel6Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel6Pointe () : ipointe()
          { listdouble6.push_front(Reels6());  // allocation d'un maillon
             ipointe =  listdouble6.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel6Pointe ()
               {  listdouble6.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble6Iter  ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group

//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de sept réels
class Reels7 
{   public :
   // Données : 
   double donnees [7];
  }; 
/// @}  // end of group

typedef  std::list < Reels7 >::iterator listdouble7Iter  ;
extern std::list <Reels7> listdouble7;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de sept réels
class Reel7Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel7Pointe () : ipointe()
          { listdouble7.push_front(Reels7());  // allocation d'un maillon
             ipointe =  listdouble7.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel7Pointe ()
               {  listdouble7.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble7Iter  ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group

//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de 8 réels
class Reels8 
{   public :
   // Données : 
   double donnees [8];
  }; 
/// @}  // end of group

typedef  std::list < Reels8 >::iterator listdouble8Iter  ;
extern std::list < Reels8 > listdouble8;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de 8 réels
class Reel8Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel8Pointe () : ipointe()
          { listdouble8.push_front(Reels8());  // allocation d'un maillon
             ipointe =  listdouble8.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel8Pointe ()
               {  listdouble8.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble8Iter  ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group

//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de 9 réels
class Reels9 
{   public :
   // Données : 
   double donnees [9];
  }; 
  /// @}  // end of group

/*class Mat_3x3  // une vision explicite des identifiants d'une matrice 3x3
{   public :
   // Données : 
   double M11, M12, M13, M21, M22, M23, M31, M32, M33;
  }; 
  
// une union permettant d'avoir deux mêmes visions des tableaux à 9 réels
union Reels9_Mat_3x3 { Reels9* s9;  Mat_3x3* M; }; */

extern std::list < Reels9 > listdouble9;
typedef  std::list < Reels9 >::iterator listdouble9Iter  ;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de 9 réels
class Reel9Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel9Pointe () : ipointe()
          { listdouble9.push_front(Reels9());  // allocation d'un maillon
             ipointe =  listdouble9.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel9Pointe ()
               {  listdouble9.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble9Iter  ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group

//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de 16 réels
class Reels16 
{   public :
   // Données : 
   double donnees [16];
  }; 
/// @}  // end of group

extern std::list < Reels16 > listdouble16;
typedef  std::list < Reels16 >::iterator listdouble16Iter  ;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de 16 réels
class Reel16Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel16Pointe () : ipointe()
          { listdouble16.push_front(Reels16());  // allocation d'un maillon
             ipointe =  listdouble16.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel16Pointe ()
               {  listdouble16.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble16Iter  ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group

//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de 21 réels
class Reels21 
{   public :
   // Données : 
   double donnees [21];
  }; 
/// @}  // end of group

extern std::list < Reels21 > listdouble21;
typedef  std::list < Reels21 >::iterator listdouble21Iter  ;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de 21 réels
class Reel21Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel21Pointe () : ipointe()
          { listdouble21.push_front(Reels21());  // allocation d'un maillon
             ipointe =  listdouble21.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel21Pointe ()
               {  listdouble21.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble21Iter  ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group

//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de 36 réels
class Reels36 
{   public :
   // Données : 
   double donnees [36];
  }; 
/// @}  // end of group

extern std::list < Reels36 > listdouble36;
typedef  std::list < Reels36 >::iterator listdouble36Iter  ;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de 36 réels
class Reel36Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel36Pointe () : ipointe()
          { listdouble36.push_front(Reels36());  // allocation d'un maillon
             ipointe =  listdouble36.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel36Pointe ()
               {  listdouble36.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble36Iter  ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group

//=================================================
/// @addtogroup Les_listes_de_petits_tableaux_de_reels
///  @{
///
/// cas des tableaux de 81 réels
class Reels81 
{   public :
   // Données : 
   double donnees [81];
  }; 
/// @}  // end of group

extern std::list < Reels81 > listdouble81;
typedef  std::list < Reels81 >::iterator listdouble81Iter  ;

/// @addtogroup Les_pointeurs_dans_listes_de_petits_tableaux
///  @{
///
/// cas des tableaux de 81 réels
class Reel81Pointe : public ReelsPointe
{   public :  
       // constructeur
        Reel81Pointe () : ipointe()
          { listdouble81.push_front(Reels81());  // allocation d'un maillon
             ipointe =  listdouble81.begin(); // mémorisation du maillon
             }
         // destructeur
         ~ Reel81Pointe ()
               {  listdouble81.erase(ipointe);} ; // suppression de l'élément de la liste
          // data     
        listdouble81Iter  ipointe;  // donne la position dans la liste du maillon
  }; 
/// @}  // end of group

//=================================================


#endif