Herezh_dev/TypeBase/TypeQuelconque.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:        29/05/2004                                          *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:  une classe générique qui permet de définir                 *
 *           des identificateurs de grandeurs quelconque.               *
 *           Ces idendificateurs sont prévue en particulier pour gérer  *
 *           les sorties de résultats.                                  *
 *           Le type s'appuit sur un type énuméré pour les gestions     *
 *           rapide de tableau ou de choix (via case).                  *
 *           Le type contiend une grandeur pointée, mais ne crée pas    *
 *           ni ne détruit la grandeur pointée ! Ainsi au niveau de     *
 *           l'affectation, il ne gère que le changement de pointeur.   *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef TYPE_QUELCONQUE_H
#define TYPE_QUELCONQUE_H

#include <iomanip>
#include "List_io.h"
#include "Tableau_T.h"
#include <algorithm>
#include <string.h>

#include "EnumTypeGrandeur.h"
#include "Enum_TypeQuelconque.h"
#include "EnuTypeQuelParticulier.h"
#include "Enum_ddl.h"
#include "Mat_pleine.h"
#include "TypeQuelconque_enum_etendu.h"

/**  @defgroup Group_TypeQuelconque
*
*     BUT:  une classe générique qui permet de définir                 
*           des identificateurs de grandeurs quelconque.               
*           Ces idendificateurs sont prévue en particulier pour gérer
*           les sorties de résultats.
*           Le type s'appuit sur un type énuméré pour les gestions
*           rapide de tableau ou de choix (via case).
*           Le type contiend une grandeur pointée, mais ne crée pas
*           ni ne détruit la grandeur pointée ! Ainsi au niveau de
*           l'affectation, il ne gère que le changement de pointeur.
*
*
* \author    Gérard Rio
* \version   1.0
* \date       29/05/2004
* \brief       classe qui permet de définir des identificateurs de grandeurs quelconque.
*
*/


/// @addtogroup Group_TypeQuelconque
///  @{

/// TypeQuelconque : def de la classe générique globale qui sert a gérer la grandeur
/// particulière qui est attachée via un pointeur

class TypeQuelconque
{
 // surcharge de l'operator de lecture
  friend istream & operator >> (istream & ent, TypeQuelconque & a);
  
 // surcharge de l'operator d'ecriture
  friend ostream & operator << (ostream & sort , const TypeQuelconque & a);

  public :
    //----------------------------------------------------------------------------
    /// définition de la classe virtuelle qui serait déclinée en une grandeur particulière
    /// il s'agit ici de la classe conteneur
    //----------------------------------------------------------------------------
    class Grandeur 
       { // surcharge de l'operator de lecture
         friend istream & operator >> (istream & ent, Grandeur & a)
           { a.Lecture_grandeur(ent);return ent;};
         // surcharge de l'operator d'ecriture
         friend ostream & operator << (ostream & sort , const Grandeur & a)
           { a.Ecriture_grandeur(sort); return sort;};
         public: virtual ~Grandeur(){};
         virtual Grandeur* New_idem_grandeur() const =0; // ramène une grandeur identique, créée          
         virtual TypeQuelconque::Grandeur & operator = ( const TypeQuelconque::Grandeur & a) = 0; // surcharge d'affectation (totale a priori)
         // ** operations simples: si l'opération ne veut rien dire pour le type quelconque -> erreur
         // ** les opérations entre deux types quelconques ne doivent concerner que des grandeurs  de même type
         // affectation uniquement des données numériques (pas les pointeurs, pas les string)
         virtual void Affectation_numerique( const TypeQuelconque::Grandeur & a) = 0;
		       // Surcharge de l'operateur +=
	        virtual void operator+= (const Grandeur& c) = 0;
		       // Surcharge de l'operateur -= 
	        virtual void operator-= (const Grandeur& c) = 0;
		       // Surcharge de l'operateur *= 
	        virtual void operator*= (double val) = 0;
		       // Surcharge de l'operateur /= : division  par un scalaire
	        virtual void operator/= (double val)  = 0;
         // récup du nom de référence si diff de NULL
         // c'est un nom qui permet de discriminer différentes grandeurs quelconque qui
         // ont la même signature (mêmes énumérés) Cependant n'existe pas toujours
         virtual const string* Nom_ref() const {return NULL;};
         // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
         // si pas possible, ramène 0
         virtual double GrandeurNumOrdre(int num) const =0;
         virtual int NbMaxiNumeroOrdre() const = 0; // récup du nb maxi de numéros d'ordres
         virtual void Grandeur_brut(ostream & sort,int nbcar) const =0; // sortie de la grandeur brut sur sort
         // ramène le type de grandeur associée de la grandeur de base, car 
         // la grandeur peut être une grandeur complexe comme un tableau ou un liste de grandeur de base
         virtual EnumTypeGrandeur Type_grandeurAssocie() const =0;
         // ramène le type de la structure: tableau, liste ext..
         virtual EnumType2Niveau  Type_structure_grandeurAssocie() const = 0;
         // ramène le type de la grandeur particulière
         virtual EnuTypeQuelParticulier Type_enumGrandeurParticuliere() const = 0;
         // change de repère de la grandeur si nécessaire 
         virtual void Change_repere(const Mat_pleine& beta,const Mat_pleine& gamma) =0;
         // lecture 
         virtual istream & Lecture_grandeur(istream & ent) =0;
         // ecriture
         virtual ostream & Ecriture_grandeur(ostream & sort) const  =0;
         // initialise la grandeur à une valeur par défaut: = 0 pour les grandeurs numériques
         virtual void InitParDefaut() = 0;
       };

    // CONSTRUCTEURS :
    // constructeur par défaut
    // ensuite il faut utiliser ChangeGrandeur pour affecter une bonne valeur
    TypeQuelconque();
    // constructeur fonction d'un type donnée et d'une grandeur
    // c'est le 1er constructeur officiel, qui sert
    // posi_ddl: indique un ddl dont les points de calcul (ex: les pt d'integ) sont les même
    // que la grandeur particulière
    TypeQuelconque(TypeQuelconque_enum_etendu enuType,Enum_ddl posi_ddl,const TypeQuelconque::Grandeur& pt_gr);
    // le même constructeur mais à partir d'un énum
    TypeQuelconque(EnumTypeQuelconque enuType,Enum_ddl posi_ddl,const TypeQuelconque::Grandeur& pt_gr);

    // constructeur fonction d'un type donnée uniquement
    // c'est le 2er constructeur officiel, qui sert
    // ici il n'y a pas de grandeur associée, util uniquement pour gérer le type mais pas la grandeur
    TypeQuelconque(TypeQuelconque_enum_etendu enuType);
    // le même constructeur mais à partir d'un énum
    TypeQuelconque(EnumTypeQuelconque enuType);

// -- ces deux constructeurs ont été imaginés, mais a priori ne sont pas utilisés ---
//    // Constructeur fonction  d'un type de donnée, et d'un énuméré permettant de construire la grandeur
//    // celle-ci , si elle dépend de la dimension, est construite suivant la dimension courante
//    // posi_ddl: indique un ddl dont les points de calcul (ex: les pt d'integ) sont les même
//    // que la grandeur particulière
//    TypeQuelconque(TypeQuelconque_enum_etendu enuType,Enum_ddl posi_ddl,EnuTypeQuelParticulier enuGrandQuelParti);
//    // le même constructeur mais à partir d'un énum
//    TypeQuelconque(EnumTypeQuelconque enuType,Enum_ddl posi_ddl,EnuTypeQuelParticulier enuGrandQuelParti);
 
    // constructeur de copie
    TypeQuelconque(const TypeQuelconque& a);             
    // DESTRUCTEUR :
    ~TypeQuelconque();
    
    // METHODES PUBLIQUES :
    
    // changement d'une grandeur quelconque
    // la grandeur initiale est transformée en la grandeur passée en paramètre 
    // utile après une contruction par défaut
    void ChangeGrandeur(const TypeQuelconque& a);
    
    // surcharge d'affectation
    // ne doit concerner que des grandeurs quelconques de même type
    // il n'y a donc pas de changement automatique de type, volontairement pour éviter des erreurs
    // et un long temps de traitement
    TypeQuelconque & operator = ( const TypeQuelconque & a);
    
    // surcharge d'égalité: ne concerne que les types, ne concerne pas la grandeur elle-même pointée !
    bool operator == ( const TypeQuelconque & a) const { return (enuType == a.enuType);};
    // surcharge de non égalité
    bool operator != ( const TypeQuelconque & a) const { return (enuType != a.enuType);};
    // surcharge de comparaison
    bool operator > (const TypeQuelconque & a)   const {return (enuType > a.enuType);};
    bool operator >= (const TypeQuelconque & a)  const {return (enuType > a.enuType);};
    bool operator < (const TypeQuelconque & a)   const {return (enuType < a.enuType);};
    bool operator <= (const TypeQuelconque & a)  const {return (enuType < a.enuType);};

    // récup du type de grandeur associé
    // il s'agit ici du type de base, car la grandeur peut être un type complexe comme un tableau
    // de type de base ou une liste
    EnumTypeGrandeur EnuTypeGrandeur() const {return enuType.TypeDeGrandeurTG();};
    // récup du typeQuelconque
    const TypeQuelconque_enum_etendu& EnuTypeQuelconque() const {return enuType;};
    // écriture d'une chaine de caractère composés de l'Enumtypequlconque et du string additionnel
 
    // récup du type de calcul de la grandeur:
    // = 1 indique si la grandeur est naturellement exprimé dans le repère globale
    // = 0 indique que la grandeur est dans le repère naturelle (ou une combinaison)
    int TypeExpressionGrandeur() const {return EnumTypeQuelconqueGlobale(enuType.EnumTQ());};
    // sortie de la grandeur uniquement sur sort (sans info particulière c-a-d de typage)
    void Grandeur_brut(ostream & sort,int nbcar) const {Gestion_erreur();pt_grandeur->Grandeur_brut(sort,nbcar);};
    // ramène le ddl associé, qui correspond à un ddl éventuellement du même type, mais surtout
    // qui est calculé au même point géométrique !
    // si ce ddl n'exite pas => pas d'existance de la grandeur quelconque
    Enum_ddl Enum() const {return enu_ddl_posi;};
    // change de repère de la grandeur si nécessaire 
    void Change_repere(const Mat_pleine& beta0,const Mat_pleine& betat,const Mat_pleine& betatdt
                       ,const Mat_pleine& gamma0,const Mat_pleine& gammat,const Mat_pleine& gammatdt);
    // indique si c'est un type numérique ou non
    bool Type_numerique() const
          {return Type_grandeur_numerique(Type_de_grandeur_associee(enuType.EnumTQ()));};
    // retourne le nombre maxi de numéros d'ordre (c'est à dire de numéros de classement
    // des différents éléments de la grandeur, s'il y en a plusieurs
    // pour un tableau, un vecteur une liste, c'est directement le numéro d'ordre
    // pour des tenseurs, ou tableaux multidimentionnels c'est de dernier indice qui varie
    // d'abord puis on remonte 
    int NbMaxiNumeroOrdre() const {Gestion_erreur();return pt_grandeur->NbMaxiNumeroOrdre();};
    // récupération de la valeur numérique d'une grandeur correspondant à un numéro d'ordre
    // si pas possible, ramène 0
    double GrandeurNumOrdre(int num) const {Gestion_erreur();return pt_grandeur->GrandeurNumOrdre(num);};
    // récupération de la grandeur en lecture/écriture pour un cast !!! attention il faut savoir ce que l'on fait 
    Grandeur* Grandeur_pointee() {return pt_grandeur;};
    const Grandeur* Const_Grandeur_pointee() const {return pt_grandeur;};
    // écriture de l'entête de la grandeur : TypeQuelconque_enum_etendu EnumType2Niveau EnumTypeGrandeur et nombre de grandeur
    // numérique équivalente si c'est une grandeur numérique
    void Ecriture_entete_grandeur(ostream & sort);
    // --- lecture en 2 temps
    // lecture des infos internes sauf de la grandeur
    // retour de l'EnuTypeQuelParticulier de la grandeur
    EnuTypeQuelParticulier  Lecture_un (istream & ent);
 
    // idem mais avec création du TypeQuelconque_enum_etendu interne
    // s'il n'existe pas,: il s'agit uniquement du nom de def, mais les infos
    // associées:  EnumTypeQuelconque et EnumTypeGrandeur sont lues et vérifiés
    // le string, lui peut ne pas exister: intéressant lorsqu'il s'agit de grandeurs
    // qui sont crées pendant le calcul et/ou en restart
    EnuTypeQuelParticulier  Lecture_un_avec_creation_TypeQuelconque_enum_etendu(istream & ent);
 
    // gestion de l'activité du type quelconque
    void Active() {actif=true;};
    void Inactive() {actif = false;};
    bool Activite() const {return actif;};
    
  protected :  
    // VARIABLES PROTEGEES :
    TypeQuelconque_enum_etendu enuType;
    Enum_ddl enu_ddl_posi; // un enum d'un ddl qui est calculé au même point que le type quelconque
    Grandeur * pt_grandeur; // le pointeur sur la grandeur correspondantes
    bool actif; // un boolen qui permet une gestion du type: par exemple prise en compte ou non
        
    // METHODES PROTEGEES :
    // gestion de l'erreur dans le cas où il n'y a pas de grandeur associée
#ifdef MISE_AU_POINT	 	 
    void Gestion_erreur() const ;
#endif    
#ifndef MISE_AU_POINT	 	 
    void Gestion_erreur() const {};
#endif    

 };
 
 /// @}  // end of group

  
#endif