294 lines
15 KiB
C++
294 lines
15 KiB
C++
|
|
// 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
|
|
|
|
|