// FICHIER : MetAxisymetrique3D.h
// CLASSE : MetAxisymetrique3D

// 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/12/2004                                          *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:   La classe MetAxisymetrique3D derive de Met_abstraite, et  *
 *            est pécifique aux éléments axisymétriques.                *
 *            La dimension de l'espace  3                               *
 *            dim = 3: l'axe de rotation est y, et l'élément est        *
 *            défini dans x y: en résumé: l'élément est 3D avec un élé- *
 *            ment géométrique 2D.                                      *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/


#ifndef MET_AXI_SYMETRIQUE3D_H
#define MET_AXI_SYMETRIQUE3D_H

#include "Met_abstraite.h"


/// @addtogroup groupe_des_metrique
///  @{
///


class MetAxisymetrique3D : public Met_abstraite
{


	public :


		// CONSTRUCTEUR :
		
		// Constructeur par defaut
		MetAxisymetrique3D ();	
	 // constructeur permettant de dimensionner unique ment certaine variables
	 // ici la dimension  3, 
	 // des variables a initialiser
	 MetAxisymetrique3D (const  DdlElement& tabddl,
	                     const  Tableau<Enum_variable_metrique> & tab,int nomb_noeud);
		// constructeur de copie
		MetAxisymetrique3D (const  MetAxisymetrique3D&);
		// DESTRUCTEUR :
		
		~MetAxisymetrique3D ();
  // Surcharge de l'operateur = : realise l'affectation
  // fonction virtuelle
  inline Met_abstraite& operator= (const Met_abstraite& met)
        { return (Met_abstraite::operator=(met));};
		
	protected :				
	// METHODES protegees:
    //==calcul des points, identique a Met_abstraite
		   
  //============================ Methodes protegees ================================
 protected:
    //==calcul des points, la dimension des points est 3 ici
		   	    	    	         
	//== le nombre de vecteur de base   3, le troisième est suivant k,  
	// les deux autres vecteurs de base sont calculées avec la surface de l'élément axisymétrique
	//== les fonctions de calcul de base sont donc redefini
		// calcul de la base naturel a t0
  void Calcul_giB_0
		   ( const  Tableau<Noeud *>& tab_noeud,const   Mat_pleine& dphi, int nombre_noeud,const Vecteur& phi);
		// calcul de la base naturel a t
  void Calcul_giB_t
		   ( const  Tableau<Noeud *>& tab_noeud, const  Mat_pleine& dphi, int nombre_noeud,const Vecteur& phi); 
		// calcul de la base naturel a t+dt
  void Calcul_giB_tdt
		   ( const  Tableau<Noeud *>& tab_noeud, const  Mat_pleine& dphi, int nombre_noeud,const Vecteur& phi);

    //== calcul du jacobien aux differents temps , il est necessaire d'avoir
    //== calcule le tenseur metrique correspondant
 //       virtual void Jacobien_0();
 //       virtual void Jacobien_t();
 //       virtual void Jacobien_tdt();

  //==  calcul de la variation des bases
  void D_giB_t( const  Mat_pleine& tabDphi, 
                      int nbnoeu,const  Vecteur & phi); // avant calcul de : giB_t
  void D_giB_tdt( const  Mat_pleine& tabDphi,
                      int nbnoeu,const  Vecteur & phi); // avant calcul de : giB_tdt
		
	//== par défaut le gradient de vitesse est de type (nbvecteurdela base)au carre	
	//== nécessite d'avoir calculé les vecteurs giB avant 	
		// calcul du gradient de vitesse à t
		void Calcul_gradVBB_t
		   (const  Tableau<Noeud *>& tab_noeud, const  Mat_pleine& tabDphi,int nombre_noeud); 
		// calcul gradient de vitesse à t+dt
		void Calcul_gradVBB_tdt
		   (const Tableau<Noeud *>& tab_noeud, const  Mat_pleine& tabDphi,int nombre_noeud);
	//== dans le cas où il n'y a pas de ddl de vitesse on peut utiliser les vitesses moyennes	
	//== correspondant à delta x^ar/delta t 
		// calcul du gradient de vitesse moyen à t
        // dans le cas où les ddl à tdt n'existent pas -> utilisation de la  vitesse sécante entre 0 et t !!
		void Calcul_gradVBB_moyen_t
		   (const  Tableau<Noeud *>& tab_noeud, const  Mat_pleine& tabDphi,int nombre_noeud); 
		// calcul du gradient de vitesse moyen entre t et t+dt
		void Calcul_gradVBB_moyen_tdt 
		   (const  Tableau<Noeud *>& tab_noeud, const  Mat_pleine& tabDphi,int nombre_noeud); 
					
   //== calcul de la variation du gradient	
        // par rapport aux composantes  V^ar (et non les X^ar )	
		void DgradVBB_t( const  Mat_pleine& dphi); // avant calcul de : giB_t
        // par rapport aux composantes  V^ar (et non les X^ar )	
 	void DgradVBB_tdt(const  Mat_pleine& dphi); // avant calcul de : giB_tdt
       // par rapport aux composantes  X^ar (et non les V^ar )	
 	void DgradVmoyBB_t(const  Mat_pleine& dphi,const  Tableau<Noeud *>& tab_noeud); // calcul variation du gradient moyen à t
       // par rapport aux composantes  X^ar (et non les V^ar )	
 	void DgradVmoyBB_tdt(const  Mat_pleine& dphi); // calcul variation du gradient moyen à tdt
     
  //--------------- données protégées -----------------------------
 protected:
   
		
};
/// @}  // end of group


#endif
		
		
