
// 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:        27/07/2022                                          *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:   Méthodes génériques de transformations                    *
 *     de tenseurs. Utilisées en particulier par ElemMeca et les
 *     lois de comportement
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef TRANS_VAL_MULTI_TENSORIEL_H
#define  TRANS_VAL_MULTI_TENSORIEL_H

#include "Tenseur.h"
#include "NevezTenseur.h"
#include "Enum_calcul_masse.h"
#include "Basiques.h"
#include "Enum_dure.h"
#include "LesPtIntegMecaInterne.h"
#include "Enum_StabHourglass.h"
#include "Temps_CPU_HZpp.h"

/**
*
*     BUT:   Méthodes génériques de transformations
*     de tenseurs. Utilisées en particulier par ElemMeca et les
*     lois de comportement
*
* \author    Gérard Rio
* \version   1.0
* \date      27/07/2022
* \brief     Méthodes génériques de transformations de tenseurs
*
*/


class   Trans_val_multi_tensoriel :
{
  public :
    // VARIABLES PUBLIQUES :
    
/*    // CONSTRUCTEURS par défaut:
       Trans_val_multi_tensoriel();
       // Constructeur de copie
       Trans_val_multi_tensoriel(const Trans_val_multi_tensoriel& a);
    
    // DESTRUCTEUR :
       ~Trans_val_multi_tensoriel();
    
    // METHODES PUBLIQUES :
    
        
    // récupération des  valeurs au numéro d'ordre  = iteg pour
    // les grandeur enu
    // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
    // NB Importante: il faut faire attention à ce que ces métriques soient identiques à celles qui ont servit
    // pour le calcul des tenseurs: en particulier si c'est utilisé pour calculer les grandeurs pour le chargement
    // il faut s'assurer que ce sont les "mêmes pti" qui servent pour la charge et pour la raideur !!
    Tableau <double> Valeur_multi(bool absolue,Enum_dure enu_t,const List_io<Ddl_enum_etendu>& enu
                                  ,int iteg,int cas
                                  ) ;
                         
    // récupération des  valeurs Tensorielles (et non scalaire comme avec Valeur_multi)
    // au numéro d'ordre  = iteg pour les grandeur enu
    // enu contient les grandeurs de retour
    // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
    // NB Importante: il faut faire attention à ce que ces métriques soient identiques à celles qui ont servit
    // pour le calcul des tenseurs: en particulier si c'est utilisé pour calculer les grandeurs pour le chargement
    // il faut s'assurer que ce sont les "mêmes pti" qui servent pour la charge et pour la raideur !!
    void Valeurs_Tensorielles(bool absolue, Enum_dure enu_t,List_io<TypeQuelconque>& enu
                              ,int iteg,int cas
                              ) ;
                              
                              
                              
                              
                              
    // récupération de  valeurs interpolées pour les grandeur enu
    // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
    // une seule des 3 métriques doit-être renseigné, les autres doivent être un pointeur nul
    void Valeurs_Tensorielles_interpoler_ou_calculer
                     (bool absolue, Enum_dure temps,List_io<TypeQuelconque>& enu
                      ,Deformation & defor
                      ,const Met_abstraite::Impli* ex_impli
                      ,const Met_abstraite::Expli_t_tdt* ex_expli_tdt
                      ,const Met_abstraite::Expli* ex_expli
                     );


         // récupération de  valeurs interpolées pour les grandeur enu ou directement calculées
         // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
         // exclure_dd_etend: donne une liste de Ddl_enum_etendu à exclure de la recherche
         //          parce que par exemple, ils sont calculés par ailleurs
         // on peut également ne pas définir de métrique et matrice de passage (c-a-d gijHH == NULL)
         // ==> tous les autres pointeurs d'éléments de métrique et matrices de passages sont alors réputés NULL
         //     donc inutilisable
         //     , dans ce cas on ne peut pas calculer certaines grandeurs
         //  -> il y a vérification
         Tableau <double> Valeur_multi_interpoler_ou_calculer
                          (bool absolue, Enum_dure temps,const List_io<Ddl_enum_etendu>& enu
                           // éléments de métrique et matrices de passage
                           ,TenseurHH* gijHH,TenseurBB* gijBB,BaseB* giB
                           ,BaseH* giH_0,BaseH* giH
                           ,BaseB* giB_0
                           ,BaseB* giB_t // n'est définit "que" pour certains cas
                           ,Mat_pleine* Aa0,Mat_pleine* Aafin
                           ,Mat_pleine* gamma0,Mat_pleine* gammafin
                           ,Mat_pleine* beta0,Mat_pleine* betafin
                           // exclusion du calcul
                           ,const List_io<Ddl_enum_etendu>* exclure_dd_etend
                          );
         
         // récupération de  valeurs interpolées pour les grandeur enu
         // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
         // exclure_Q: donne une liste de grandeur quelconque à exclure de la recherche
         //          parce que par exemple, ils sont calculés par ailleurs
         // on peut également ne pas définir de métrique et matrice de passage (c-a-d gijHH == NULL)
         // ==> tous les autres pointeurs d'éléments de métrique et matrices de passages sont alors réputés NULL
         //     donc inutilisable
         //     , dans ce cas on ne peut pas calculer certaines grandeurs
         //  -> il y a vérification
         void Valeurs_Tensorielles_interpoler_ou_calculer
                          (bool absolue, Enum_dure temps,List_io<TypeQuelconque>& enu
                           // éléments de métrique et matrices de passage
                           ,TenseurHH* gijHH,TenseurBB* gijBB,BaseB* giB
                           ,BaseH* giH_0,BaseH* giH
                           ,BaseB* giB_0
                           ,BaseB* giB_t // n'est définit "que" pour certains cas
                           ,Mat_pleine* Aa0,Mat_pleine* Aafin
                           ,Mat_pleine* gamma0,Mat_pleine* gammafin
                           ,Mat_pleine* beta0,Mat_pleine* betafin
                           // exclusion du calcul
                           ,const List_io<EnumTypeQuelconque>* exclure_Q
                          );
        
        // récupération de  valeurs interpolées pour les grandeur ici considéré quelconque enu
        // ces grandeurs ne sont pas définies dans la liste des Ddl_enum_etendu : ex mises à t
        // ou le numéro de l'élément etc.
        // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
        // exclure_Q: donne une liste de grandeur quelconque à exclure de la recherche
        //          parce que par exemple, ils sont calculés par ailleurs
        // on peut également ne pas définir de métrique et matrice de passage (c-a-d gijHH == NULL)
        // ==> tous les autres pointeurs d'éléments de métrique et matrices de passages sont alors réputés NULL
        //     donc inutilisable
        //     , dans ce cas on ne peut pas calculer certaines grandeurs
        //  -> il y a vérification
        // retour: la list li_quelc
        void Valeurs_quelconque_interpoler_ou_calculer
                         (bool absolue, Enum_dure temps
                          ,const Tableau <EnumTypeQuelconque>& tqi
                          ,List_io<TypeQuelconque>& li_quelc
                          // éléments de métrique et matrices de passage
                          ,TenseurHH* gijHH,TenseurBB* gijBB,BaseB* giB
                          ,BaseH* giH_0,BaseH* giH
                          ,BaseB* giB_0
                          ,BaseB* giB_t // n'est définit "que" pour certains cas
                          ,Mat_pleine* Aa0,Mat_pleine* Aafin
                          ,Mat_pleine* gamma0,Mat_pleine* gammafin
                          ,Mat_pleine* beta0,Mat_pleine* betafin
                          // exclusion du calcul
                          ,const List_io<EnumTypeQuelconque>* exclure_Q
                         );
*/
 };


 
#endif  
