// 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: 4/06/98 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Met_PiPoCo constitue une boite a outil comme met_abstraite, *
* mais ici c'est particulièrement dédié aux poutres, plaques et *
* coques, qui nécessitent deux interpolations, une dans le plan ou *
* l'axe , et une suivant l'épaisseur.
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef MET_PIPOCO_H
#define MET_PIPOCO_H
#include "Met_abstraite.h"
#include "TabOper_T.h"
/// @addtogroup groupe_des_metrique
/// @{
///
class Met_PiPoCo : public Met_abstraite
{
public :
// CONSTRUCTEUR :
// Constructeur par defaut
Met_PiPoCo ();
// constructeur permettant de dimensionner les variables
// dim = dimension de l'espace, nbvec = nombre de vecteur de la base naturelle
// tab = liste des variables a initialiser, nomb_noeud: le nombre de noeud
Met_PiPoCo (int dim_base,int nbvec,const DdlElement& tabddl,
const Tableau<Enum_variable_metrique> & tab,int nomb_noeud);
// constructeur de copie
Met_PiPoCo (const Met_PiPoCo&);
// DESTRUCTEUR :
~Met_PiPoCo ();
// METHODES PUBLIQUES :
// Surcharge de l'operateur = : realise l'affectation
// dérivant de virtuel, a ne pas employer -> message d'erreur
Met_abstraite& operator= (const Met_abstraite& met);
// normale
virtual Met_PiPoCo& operator= (const Met_PiPoCo& met);
// ------------------------ calculs ----------------------------------------
// cas explicite à t, toutes les grandeurs sont a 0 ou t
// calcul des termes : gijBB_0, gijBB_t, gijHH_t, d_gijBB_t,jacobien_t
// gradV_instantane : true : calcul du gradient de vitesse instantannée
// premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
// false: uniquement les grandeurs à t+dt sont calculées
const Met_abstraite::Expli& Cal_explicit_t
( const Tableau<Noeud *>& tab_noeud,bool gradV_instantane,
Tableau<Mat_pleine const *>& tabdphi,int nombre_noeud,
Tableau<Vecteur const *>& tabphi,bool premier_calcul);
// calcul simplifie, a utiliser lorsque l'on se sert des grandeurs
// liers a la facette deja calculee, ainsi que la courbure
// gradV_instantane : true : calcul du gradient de vitesse instantannée
// premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
// false: uniquement les grandeurs à t+dt sont calculées
const Met_abstraite::Expli& Cal_explicit_simple_t
( const Tableau<Noeud *>& tab_noeud,bool gradV_instantane,
Tableau<Mat_pleine const *>& tabdphi,int nombre_noeud,
Tableau<Vecteur const *>& tabphi,bool premier_calcul);
// cas explicite à tdt, toutes les grandeurs sont a 0 ou tdt
// calcul des termes : gijBB_0, gijBB_tdt, gijHH_tdt, d_gijBB_tdt,jacobien_tdt
// gradV_instantane : true : calcul du gradient de vitesse instantannée
// premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
// false: uniquement les grandeurs à t+dt sont calculées
const Met_abstraite::Expli_t_tdt& Cal_explicit_tdt
( const Tableau<Noeud *>& tab_noeud,bool gradV_instantane,
Tableau<Mat_pleine const *>& tabdphi,int nombre_noeud,
Tableau<Vecteur const *>& tabphi,bool premier_calcul);
// calcul simplifie, a utiliser lorsque l'on se sert des grandeurs
// liers a la facette deja calculee, ainsi que la courbure
// gradV_instantane : true : calcul du gradient de vitesse instantannée
// premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
// false: uniquement les grandeurs à t+dt sont calculées
const Met_abstraite::Expli_t_tdt& Cal_explicit_simple_tdt
( const Tableau<Noeud *>& tab_noeud,bool gradV_instantane,
Tableau<Mat_pleine const *>& tabdphi,int nombre_noeud,
Tableau<Vecteur const *>& tabphi,bool premier_calcul);
// cas implicite
// calcul des termes de la classe impli
// gradV_instantane : true : calcul du gradient de vitesse instantannée
// premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
// false: uniquement les grandeurs à t+dt sont calculées
const Met_abstraite::Impli& Cal_implicit
( const Tableau<Noeud *>& tab_noeud,bool gradV_instantane,
Tableau<Mat_pleine const *>& tabdphi,int nombre_noeud,
Tableau<Vecteur const *>& tabphi,bool premier_calcul);
// calcul simplifie, a utiliser lorsque l'on se sert des grandeurs
// liers a la facette deja calculee, ainsi que la courbure et sa variation
// gradV_instantane : true : calcul du gradient de vitesse instantannée
// premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
// false: uniquement les grandeurs à t+dt sont calculées
const Met_abstraite::Impli& Cal_implicit_simple
( const Tableau<Noeud *>& tab_noeud,bool gradV_instantane,
Tableau<Mat_pleine const *>& tabdphi,int nombre_noeud,
Tableau<Vecteur const *>& tabphi,bool premier_calcul);
// -------------- remontee aux informations --------------------------
// cas sortie d'infoImp
// calcul des termes de la classe InfoImp
const Met_abstraite::InfoImp& Cal_InfoImp( const Tableau<Noeud *>& tab_noeud,
Tableau<Mat_pleine const *>& tabdphi,
Tableau<Vecteur const *>& tabphi, int nombre_noeud);
// cas sortie d'infoExp
// calcul des termes de la classe InfoExp_t
const Met_abstraite::InfoExp_t& Cal_InfoExp_t( const Tableau<Noeud *>& tab_noeud,
Tableau<Mat_pleine const *>& tabdphi,
Tableau<Vecteur const *>& tabphi, int nombre_noeud);
// calcul des termes de la classe InfoExp_tdt
const Met_abstraite::InfoExp_tdt& Cal_InfoExp_tdt( const Tableau<Noeud *>& tab_noeud,
Tableau<Mat_pleine const *>& tabdphi,
Tableau<Vecteur const *>& tabphi, int nombre_noeud);
// ------------------------ gestion de la memoire --------------------------
// Ajout d'initialisation de differentes variables : liste dans tab
void PlusInitVariables(Tableau<Enum_variable_metrique>& tab) ;
// ============================ protege ===========================
protected :
// METHODES protegees:
// calcul des normales a la facette
virtual void Calcul_N_0 ();
virtual void Calcul_N_t ();
virtual void Calcul_N_tdt ();
//==calcul des points, arguments identiques a ceux de Met_abstraite
// calcul du point a différent temps
void Calcul_M0 ( const Tableau<Noeud *>& , const Vecteur& phi, int );
void Calcul_Mt ( const Tableau<Noeud *>& , const Vecteur& phi, int );
void Calcul_Mtdt ( const Tableau<Noeud *>& , const Vecteur& phi, int );
//== les fonctions de calcul de base sont donc redefini
// calcul de la base naturel a t0
// pendant le traitement il y a calcul de la base aiB et aiH de la facette plane
// la fonction contiend un argument de plus que la routine dans met_abstraite
virtual void Calcul_giB_0
( const Tableau<Noeud *>& , const Mat_pleine& , int, const Vecteur& phi);
// calcul de la base naturel a t
virtual void Calcul_giB_t
( const Tableau<Noeud *>& , const Mat_pleine& , int, const Vecteur& phi);
// calcul de la base naturel a t+dt
virtual void Calcul_giB_tdt
( const Tableau<Noeud *>& , const Mat_pleine& , int, const Vecteur& phi);
//== calcul de la variation des bases
virtual void D_giB_t( const Mat_pleine& , int , const Vecteur & phi);
virtual void D_giB_tdt( const Mat_pleine& , int , const Vecteur & phi);
//-----------// calcul du tenseur de courbure dans la base naturelle
// plusieurs cas sont etudies suivant l'instant considere
// a l'instant t = 0
virtual Vecteur& courbure_0 ( const Tableau<Noeud *>& tab_noeud) = 0;
// a l'instant t
virtual Vecteur& courbure_t ( const Tableau<Noeud *>& tab_noeud) = 0;
// a l'instant t+dt
virtual Vecteur& courbure_tdt ( const Tableau<Noeud *>& tab_noeud) = 0;
//--------------// calcul du tenseur de courbure et de sa variation
// plusieurs cas sont etudies suivant l'instant considere
// a l'instant t
virtual void Dcourbure_t
( const Tableau<Noeud *>& tab_noeud,Vecteur& curb,TabOper<Vecteur>& dcurb) = 0;
// a l'instant tdt
virtual void Dcourbure_tdt
( const Tableau<Noeud *>& tab_noeud,Vecteur& curb,TabOper<Vecteur>& dcurb) = 0;
// DONNEES PROTEGEES
Tableau <Coordonnee> Ia; // base absolue
// calcul de la courbure et de sa variation eventuelle
Vecteur curb_0,curb_t,curb_tdt;
TabOper<Vecteur> dcurb_t,dcurb_tdt;
// calcul de la normale
Coordonnee N_0,N_t,N_tdt;
//il s'agit ici des infos concernant la partie médiane ( axe ou facette)
Coordonnee * P0; // point a t=0
Coordonnee * Pt ; // point a l'instant t
Coordonnee * Ptdt; // point a l'instant t+dt BaseB Ia; // la base absolu
Tableau <Coordonnee> * d_Pt ; // derivées au point a l'instant t, par rapport aux ddl
Tableau <Coordonnee> * d_Ptdt; // derivées au point a l'instant t+dt, par rapport aux ddl
BaseB * aiB_0 ; // base naturelle a t=0
BaseB * aiB_t ; // base naturelle a t
BaseB * aiB_tdt ; // base naturelle a t+dt
BaseH * aiH_0; // vecteur de la base duale a 0
BaseH * aiH_t; // vecteur de la base duale a t
BaseH * aiH_tdt; // vecteur de la base duale a t+dt
TenseurBB * aijBB_0; // composantes de la metrique de la base naturelle a t
TenseurBB * aijBB_t; // composantes de la metrique de la base naturelle a t
TenseurBB * aijBB_tdt; // composantes de la metrique de la base naturelle a tdt
TenseurHH * aijHH_0; // composantes de la metrique de la base duale a t=0
TenseurHH * aijHH_t; // composantes de la metrique de la base duale a t
TenseurHH * aijHH_tdt; // composantes de la metrique de la base duale a t+dt
double ajacobien_0; // jacobien a l'instant t=0
double ajacobien_t; // jacobien a l'instant t
double ajacobien_tdt; // jacobien a l'instant t+dt
Tableau <BaseB> * d_aiB_t; // derivees de la base naturelle par rapport
// aux degres de liberte a t
Tableau <BaseB> * d_aiB_tdt; // derivees de la base naturelle par rapport
// aux degres de liberte a t+dt
Tableau <BaseH> * d_aiH_t; // derivees de la base duale par rapport
// aux degres de liberte a t
Tableau <BaseH> * d_aiH_tdt; // derivees de la base duale par rapport
// aux degres de liberte a t+dt
Tableau <TenseurBB * > d_aijBB_t;// derivees de la metrique de la base naturelle
// a t par rapport aux degres de liberte
Tableau <TenseurBB * > d_aijBB_tdt;// derivees de la metrique de la base naturelle
// a t+dt par rapport aux degres de liberte
Tableau <TenseurHH * > d_aijHH_t; // derivees de la metrique de la base duale a t
Tableau <TenseurHH * > d_aijHH_tdt; // derivees de la metrique de la base duale a t+dt
Vecteur d_ajacobien_t ; // derivees du jacobien par rapport aux degres de liberte
// par rapport aux degres de liberte a t
Vecteur d_ajacobien_tdt ; // derivees du jacobien par rapport aux degres de liberte
// par rapport aux degres de liberte a tdt
// fonctions privees
// allocation de la memoire
void AllocPiPoCo ();
// deallocation de la memoire complète, uniquement des grandeurs spécifiques
// à Met_PiPoCo
void DeAllocPiPoCo();
// uniquement des grandeurs de tib
void DeAllocPiPoCo(Tableau<Enum_variable_metrique>& tib);
// copie en fonction de l'instance passée
// concerne que les grandeurs pointées
void Copie_metPiPoCo(const Met_PiPoCo& a);
};
/// @} // end of group
#endif