Herezh_dev/Elements/Mecanique/ElemPoint/Met_ElemPoint.h

// FICHIER : Met_ElemPoint.h
// CLASSE : Met_ElemPoint

// 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:        24/02/2005                                          *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:  Métrique pour le cas particulier des éléments comportants  *
 *            un seul noeud, la dimension est 1 ou 2 ou 3.              *
 *     Ici, par défaut la métrique est l'identitée de l'espace, sauf si *
 *     on impose une métrique différente, qui peut alors être de        *
 *     dimension quelconque.                                            *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/



#ifndef MET_ELEM_POINT_H
#define MET_ELEM_POINT_H

#include "Met_abstraite.h"
#include "UmatAbaqus.h" 

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



class Met_ElemPoint : public Met_abstraite
{


	public :


		// CONSTRUCTEUR :
		
		// Constructeur par defaut
		Met_ElemPoint ();	
	 // constructeur permettant de dimensionner uniquement certaine variables
	 // dim = dimension de l'espace, tab = liste
	 // des variables a initialiser
	 Met_ElemPoint (int dim_base,int nbvec,const  DdlElement& tabddl,
	                const  Tableau<Enum_variable_metrique> & tab,int nomb_noeud);
  // constructeur spécifique pour un point avec une métrique imposée
  // ici on ne donne pas le nombre de noeud ce qui permet de faire la différence
  // avec le constructeur précédent
  Met_ElemPoint (int dim_base,int nbvec,const  DdlElement& tabddl,
	             const  Tableau<Enum_variable_metrique>& tab);
		// constructeur de copie
		Met_ElemPoint (const  Met_ElemPoint&);
		// DESTRUCTEUR :
		
		~Met_ElemPoint ();
  // Surcharge de l'operateur = : realise l'affectation
  // fonction virtuelle
  inline Met_abstraite& operator= (const Met_abstraite& met)
         { return (Met_abstraite::operator=(met));};
 
// --------------- spécifiques aux opérations Umat -----------------
  // calcul des grandeurs spécifiques aux opérations Umat
  const Umat_cont& Calcul_grandeurs_Umat(bool premier_calcul);
  // mise à jour de grandeur via les infos d'umat
  // il s'agit des grandeurs suivantes: giB à 0 t et tdt,
  // les routines types Calcul_giB_t (etc..) ne calculent donc plus rien, ici
  void Mise_a_jour(const UmatAbaqus& umat);
// --------------- fin spécifique aux opérations Umat -----------------
        
		
	protected :
	 // indique si l'on a affaire à une métrique imposée ou non
	 bool metrique_imposee;
	// METHODES protegees:
    //==calcul des points, identique a Met_abstraite
		   
	    	    	         
        // --- calcul de la base  naturel et dual ----  
        // dans tous les cas on ne fait rien, mais cela permet de surcharger le calcul de Met_abstraite
        // si metrique_imposee est vrai, dans ce cas les gi sont imposés
        // si metrique_imposee est faux, dans ce cas les gi sont unitaires et orthonormées

		// calcul de la base naturel a t0
		void Calcul_giB_0(const  Tableau<Noeud *>& ,const   Mat_pleine& , int ,const Vecteur& ) {};
		// calcul de la base naturel a t
		void Calcul_giB_t(const  Tableau<Noeud *>& ,const   Mat_pleine& , int ,const Vecteur& ) {};
		// calcul de la base naturel a t+dt
		void Calcul_giB_tdt(const  Tableau<Noeud *>& ,const   Mat_pleine& , int ,const Vecteur& ) {};
		// Calcul des composantes covariantes de la metrique de la base naturelle a 0 :
	//	virtual void Calcul_gijBB_0() {};
		// Calcul des composantes covariantes de la metrique de la base naturelle a t :
	//	virtual void Calcul_gijBB_t()  {};
		// Calcul des composantes covariantes de la metrique de la base naturelle a tdt :
	//	virtual void Calcul_gijBB_tdt() {};
	    // Calcul des composantes contravariantes de la metrique de la base naturelle a 0 :
	//	virtual void Calcul_gijHH_0() {};
		// Calcul des composantes contravariantes de la metrique de la base naturelle a t :
	//	virtual void Calcul_gijHH_t() {};
		// Calcul des composantes contravariantes de la metrique de la base naturelle a tdt :
	//	virtual void Calcul_gijHH_tdt() {};
		
};
/// @}  // end of group


#endif