// 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) . // // Herezh++ is distributed under GPL 3 license ou ultérieure. // // Copyright (C) 1997-2021 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 . // // For more information, please consult: . /************************************************************************ * DATE: 23/01/97 * * $ * * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * * $ * * PROJET: Herezh++ * * $ * ************************************************************************ * BUT: Met_abstraite constitue une boite a outil qui permet * * d'otenir les diverses grandeurs liées a la metrique. * * Se rappeler qu'avant la recuperation d'une grandeur il faut la * * calculer* En phase de mise au point c'a-d avec l'existence de la * * variable MISE_AU_POINT il y a verification des tailles etc, en phase* * normale il n'y a plus de verif ! * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * * VERIFICATION: * * * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * ! ! ! ! * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * MODIFICATIONS: * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * $ * ************************************************************************/ #ifndef MET_ABSTRAITE_H #define MET_ABSTRAITE_H #include #include "ParaGlob.h" #include "DdlElement.h" #include "Mat_pleine.h" #include "Tableau_3D.h" #include "Tenseur.h" #include "NevezTenseur.h" #include "Base.h" #include "Noeud.h" #include "Tableau2_T.h" #include "Enum_variable_metrique.h" #include "Enum_dure.h" /** @defgroup groupe_des_metrique * * BUT: Met_abstraite constitue une boite a outil qui permet * d'otenir les diverses grandeurs liées a la metrique. * Se rappeler qu'avant la recuperation d'une grandeur il faut la * calculer* En phase de mise au point c'a-d avec l'existence de la * variable MISE_AU_POINT il y a verification des tailles etc, en phase * normale il n'y a plus de verif ! * La metrique est concue pour etre commune a toute une classe d'element * d'ou une gestion de la memoire particuliere, vu la taille des different tableaux * en fonctionnement normal les methodes ne testent pas les differentes tailles et si * les tableaux sont correctement alloue ce qui impose de bien gerer l'allocation * a l'aide du constructeur et des routines public de gestion, ceci a chaque changement * de pb par exemple pasage d'explicit a implicit * * * \author Gérard Rio * \version 1.0 * \date 23/01/97 * \brief groupe relatif aux calculs de métriques * */ /// @addtogroup groupe_des_metrique /// @{ /// // la metrique est concue pour etre commune a toute une classe d'element // d'ou une gestion de la memoire particuliere, vu la taille des different tableaux // en fonctionnement normal les methodes ne testent pas les differentes tailles et si // les tableaux sont correctement alloue ce qui impose de bien gerer l'allocation // a l'aide du constructeur et des routines public de gestion, ceci a chaque changement // de pb par exemple pasage d'explicit a implicit class Met_abstraite { public : // Constructeur par defaut Met_abstraite (); // constructeur permettant de dimensionner uniquement certaines variables // dim = dimension de l'espace, nbvec = nb de vecteur des bases, tab = liste // des variables a initialiser Met_abstraite (int dim_base,int nbvec_base,const DdlElement& tabddl, const Tableau& tab,int nomb_noeud ,int nbddl_sup_xi = 0); // Constructeur de copie : Met_abstraite (const Met_abstraite& ); // DESTRUCTEUR VIRTUEL : virtual ~Met_abstraite (); // METHODES PUBLIQUES : // Surcharge de l'operateur = : realise l'affectation virtual Met_abstraite& operator= (const Met_abstraite& met); // affichage minimale des éléments de métrique de base virtual void Affiche() const; // ------------------------ calculs ---------------------------------------- //================================================================================================== // définition des différentes classes conteneurs, utilisés pour ramener les résultats après calcul | #include "Met_abstraite_struc_donnees.h" //================================================================================================== // calcul de Expli: cas entre 0 et t, toutes les grandeurs sont a 0 ou 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 virtual const Expli& Cal_explicit_t(const Tableau& tab_noeud,bool gradV_instantane, const Mat_pleine& tabDphi, int nombre_noeud,const Vecteur& phi,bool premier_calcul); // calcul de Expli_t_tdt cas explicite entre t=0 et tdt, toutes les grandeurs sont a 0 ou 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 virtual const Expli_t_tdt& Cal_explicit_tdt(const Tableau& tab_noeud,bool gradV_instantane, const Mat_pleine& tabDphi, int nombre_noeud,const Vecteur& phi,bool premier_calcul); // récup du conteneur Expli_t_dt virtual const Expli_t_tdt& Conteneur_Expli_tdt() const {return ex_expli_t_tdt;}; // calcul de impli. Par défaut tous les termes de variation sont calculés (le D...) // mais dans certain cas ils ne sont pas nécessaire. le paramétre avec_D est alors // a mettre à false et le calcul de toutes les variations est omis // 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 // avec_var_Xi : par défaut true, si false indique que l'on ne calcule pas les variations / au ddl Xi virtual const Impli& Cal_implicit(const Tableau& tab_noeud,bool gradV_instantane, const Mat_pleine& tabDphi, int nombre_noeud,const Vecteur& phi,bool premier_calcul,bool avec_var_Xi = true); // calcul de gijHH_0 et de giH_0 juste après le calcul implicite ou explicite (sinon il y a erreur) virtual const gijHH_0_et_giH_0& Cal_gijHH_0_et_giH_0_apres_im_expli(); // récupération de grandeurs sauvegardées par ailleurs à 0 et t(et non les pointeurs) void Recup_grandeur_0_t(BaseB & ggiB_0,BaseH & ggiH_0,BaseB & ggiB_t,BaseH& ggiH_t ,TenseurBB& ggijBB_0,TenseurHH& ggijHH_0,TenseurBB& ggijBB_t,TenseurHH& ggijHH_t ,TenseurBB & ggradVmoyBB_t,double& gjacobien_t,double& gjacobien_0) {ex_impli.Recup_grandeur_0_t(ggiB_0,ggiH_0,ggiB_t,ggiH_t,ggijBB_0,ggijHH_0,ggijBB_t ,ggijHH_t,ggradVmoyBB_t,gjacobien_t,gjacobien_0); }; // met à jour en même temps tous les autres conteneurs pour les grandeurs équivalentes // récupération de grandeurs sauvegardées par ailleurs à 0 (et non les pointeurs) void Recup_grandeur_0(BaseB & ggiB_0,BaseH & ggiH_0,TenseurBB& ggijBB_0,TenseurHH& ggijHH_0 ,double& gjacobien_0) {ex_expli.Recup_grandeur_0(ggiB_0,ggiH_0,ggijBB_0,ggijHH_0,gjacobien_0); }; // met à jour en même temps tous les autres conteneurs pour les grandeurs équivalentes // construction d'une métrique umat // - construction d'une métrique qui dépend du paramétrage matériel = X_(0)^a // - en fonction d'une métrique normale fonction de l'interpolation sur // les éléments de référence c'est-à-dire theta^i virtual const Umat_cont& Construction_Umat(const Met_abstraite::Impli& umat_cont); // idem à partir d'une umat_cont virtual const Umat_cont& Construction_Umat(const Met_abstraite::Umat_cont& umat_cont); // récup du conteneur umat virtual const Umat_cont& Conteneur_Umat() const {return umat_cont;}; // ---------------- cas de la dynamique ---------------------------- // calcul pour la matrice masse virtual const Dynamiq& Cal_pourMatMass(const Tableau& tab_noeud, const Mat_pleine& tabDphi ,int nombre_noeud,const Vecteur& phi); // ------------------------ flambage linéaire ------------------------------ // calcul des termes de la classe flambe_lin virtual const flambe_lin& Cal_flambe_lin(const Tableau& tab_noeud,bool gradV_instantane, const Mat_pleine& tabDphi, int nombre_noeud,const Vecteur& phi,bool premier_calcul) { return (flambe_lin&) Cal_implicit(tab_noeud,gradV_instantane,tabDphi,nombre_noeud ,phi,premier_calcul);}; // ---------------- calcul de données interpolées aux même points d'integ que la mécanique -------- // et utilisées par la mécanique (ex: température, taux de cristalinité, vitesse, etc..) virtual double DonneeInterpoleeScalaire (const Tableau& tab_noeud,const Vecteur& phi,int nombre_noeud ,Enum_ddl enu,Enum_dure temps) const; // --------- calcul de la variation d'une donnée interpolée par rapport aux ddl de la donnée ------ // aux même points d'integ que la mécanique -------- // et utilisées par la mécanique (ex: température, taux de cristalinité, vitesse, etc..) // en sortie : d_A virtual Tableau & DerDonneeInterpoleeScalaire (Tableau & d_A, const Tableau& tab_noeud,const Vecteur& phi ,int nombre_noeud,Enum_ddl enu) const; // ---------------- calcul du gradient d'une donnée interpolée aux même points d'integ que la mécanique -------- // et utilisées par la mécanique (ex: température, taux de cristalinité, vitesse, etc..) // en sortie : gradB virtual CoordonneeB& GradDonneeInterpoleeScalaire (CoordonneeB& gradB,const Tableau& tab_noeud,const Mat_pleine& dphi ,int nombre_noeud,Enum_ddl enu,Enum_dure temps) const; // --------- calcul de la variation du gradient d'une donnée interpolée par rapport aux ddl de la donnée ------ // aux même points d'integ que la mécanique -------- // et utilisées par la mécanique (ex: température, taux de cristalinité, vitesse, etc..) // en sortie : d_gradB virtual Tableau & DerGradDonneeInterpoleeScalaire (Tableau & d_gradB,const Tableau& tab_noeud ,const Vecteur& phi,const Mat_pleine& dphi,int nombre_noeud,Enum_ddl enu) const; // --------- calcul de la variation seconde du gradient d'une donnée interpolée par rapport aux ddl de la donnée ------ // aux même points d'integ que la mécanique -------- // et utilisées par la mécanique (ex: température, taux de cristalinité, vitesse, etc..) // en sortie : d2_gradB // si d2_gradB est NULL cela signifie qu'il ne faut pas considérer cette grandeur virtual Tableau2 * Der2GradDonneeInterpoleeScalaire (Tableau2 * d2_gradB,const Tableau& tab_noeud ,const Vecteur& phi,const Mat_pleine& dphi,int nombre_noeud,Enum_ddl enu) const; // Vecteur& DonneeInterpoleeVecteur // (const Tableau& tab_noeud,const Vecteur& phi,int nombre_noeud // ,Enum_ddl enu,Vecteur& v, Enum_dure temps); // ------- variation seconde de la métrique -------- // calcul et récupération de la variation seconde de la métrique à t+dt // total = true : indique que le calcul est complet, à partir des données de base // c-a-d calcul de la variation de vecteur de base puis calcul de la variation seconde // = false: le calcul est simplifié, on considère que la variation des vecteurs de base vient // juste d'être calculé, dans un calcul implicit, on ne calcul alors que la variation seconde const Tableau2 & CalVar2GijBBtdt(bool total,const Mat_pleine& dphi,int nombre_noeud,const Vecteur& phi); // ========== remontee aux informations ========================= // cas sortie d'infoImp // calcul des termes de la classe InfoImp virtual const InfoImp& Cal_InfoImp(const Tableau& tab_noeud, const Mat_pleine& tabDphi, const Vecteur& phi, int nombre_noeud); // récup du conteneur qui a déjà été calculé virtual const InfoImp& Recup_InfoImp() {return ex_InfoImp;}; // cas sortie d'infoExp à 0 et t // calcul des termes de la classe InfoExp virtual const InfoExp_t& Cal_InfoExp_t(const Tableau& tab_noeud, const Mat_pleine& tabDphi, const Vecteur& phi, int nombre_noeud); // récup du conteneur qui a déjà été calculé virtual const InfoExp_t& Recup_InfoExp_t() {return ex_InfoExp_t;}; // cas sortie d'infoExp à 0 et tdt // calcul des termes de la classe InfoExp virtual const InfoExp_tdt& Cal_InfoExp_tdt(const Tableau& tab_noeud, const Mat_pleine& tabDphi, const Vecteur& phi, int nombre_noeud); // récup du conteneur qui a déjà été calculé virtual const InfoExp_tdt& Recup_InfoExp_tdt() {return ex_InfoExp_tdt;}; // cas sortie d'info à 0 t et tdt: point, giB, giH, calcul des termes de la classe Info0_t_tdt virtual const Info0_t_tdt& Cal_Info0_t_tdt(const Tableau& tab_noeud, const Mat_pleine& tabDphi ,const Vecteur& phi, int nombre_noeud); // récup du conteneur qui a déjà été calculé virtual const Info0_t_tdt& Recup_Info0_t_tdt() {return ex_Info0_t_tdt;}; // récup du conteneur avec métrique qui a déjà été calculé virtual const Info_et_metrique_0_t_tdt& Recup_Info_et_metrique_0_t_tdt() {return umat_cont;}; // cas du calcul de la déformation d'Almansi uniquement class Pour_def_Almansi{public: TenseurBB * gijBB;TenseurBB * gijBB_0; Pour_def_Almansi(): gijBB(NULL), gijBB_0(NULL) {}; Pour_def_Almansi(const Pour_def_Almansi& a ) : gijBB(a.gijBB), gijBB_0(a.gijBB_0) {}; }; virtual const Pour_def_Almansi Cal_pour_def_Almansi_au_temps (Enum_dure temps,const Tableau& tab_noeud,const Mat_pleine& dphi ,int nombre_noeud,const Vecteur& phi); // cas du calcul de la déformation logarithmique uniquement class Pour_def_log{public: TenseurBB * gijBB;TenseurHH * gijHH;TenseurBB * gijBB_0;TenseurHH * gijHH_0; Pour_def_log():gijBB(NULL),gijHH(NULL),gijBB_0(NULL),gijHH_0(NULL) {}; Pour_def_log(const Pour_def_log& a) : gijBB(a.gijBB),gijHH(a.gijHH),gijBB_0(a.gijBB_0),gijHH_0(a.gijHH_0) {}; }; virtual const Pour_def_log Cal_pour_def_log_au_temps (Enum_dure temps,const Tableau& tab_noeud,const Mat_pleine& dphi ,int nombre_noeud,const Vecteur& phi); // ========== utilise par le contact et autres ========================= // calcul d'un point M en fonction de phi et des coordonnees a 0 virtual const Coordonnee & PointM_0 // ( stockage a t=0) (const Tableau& tab_noeud,const Vecteur& phi); // calcul d'un point M en fonction de phi et des coordonnees a t virtual const Coordonnee & PointM_t // ( stockage a t=t) (const Tableau& tab_noeud,const Vecteur& phi); // calcul de la variation d'un point M par rapport aux ddl , // en fonction de phi et des coordonnees a t virtual const Tableau & D_PointM_t // ( stockage a t) (const Tableau& tab_noeud,const Vecteur& phi); // calcul d'un point M en fonction de phi et des coordonnees a tdt virtual const Coordonnee & PointM_tdt // ( stockage a tdt) (const Tableau& tab_noeud,const Vecteur& phi); // calcul de la variation d'un point M par rapport aux ddl , // en fonction de phi et des coordonnees a tdt virtual const Tableau & D_PointM_tdt // ( stockage a tdt) (const Tableau& tab_noeud,const Vecteur& phi); // calcul de la vitesse du point M en fonction de phi et des coordonnees a 0 // dans le cas où les ddl de vitesse existent, ils sont directement interpolés // dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t virtual const Coordonnee & VitesseM_0 // ( stockage a t=0) (const Tableau& tab_noeud,const Vecteur& phi); // idem mais au noeud passé en paramètre virtual const Coordonnee & VitesseM_0 (const Noeud* noeud); // calcul de la vitesse du point M en fonction de phi et des coordonnees a t // dans le cas où les ddl de vitesse existent, ils sont directement interpolés // dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t virtual const Coordonnee & VitesseM_t // ( stockage a t=t) (const Tableau& tab_noeud,const Vecteur& phi); // idem mais au noeud passé en paramètre virtual const Coordonnee & VitesseM_t (const Noeud* noeud); // calcul de la variation de la vitesse du point M par rapport aux ddl , // en fonction de phi et des coordonnees a t // dans le cas où les ddl de vitesse existent, ils sont directement interpolés // dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t // ddl_vitesse : indique si oui ou non il s'agit de variation par rapport // aux ddl de vitesse ou au ddl de position virtual const Tableau & D_VitesseM_t // ( stockage a t) (const Tableau& tab_noeud,const Vecteur& phi,bool ddl_vitesse); // idem mais au noeud passé en paramètre virtual const Tableau & D_VitesseM_t (const Noeud* noeud,bool ddl_vitesse); // calcul de la vitesse du point M en fonction de phi et des coordonnees a tdt // dans le cas où les ddl de vitesse existent, ils sont directement interpolés // dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t // ddl_vitesse : indique si oui ou non il s'agit de variation par rapport // aux ddl de vitesse ou au ddl de position virtual const Coordonnee & VitesseM_tdt // ( stockage a tdt) (const Tableau& tab_noeud,const Vecteur& phi); // idem mais au noeud passé en paramètre virtual const Coordonnee & VitesseM_tdt (const Noeud* noeud); // calcul de la variation de la vitesse du point M par rapport aux ddl , // en fonction de phi et des coordonnees a tdt // dans le cas où les ddl de vitesse existent, ils sont directement interpolés // dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t // ddl_vitesse : indique si oui ou non il s'agit de variation par rapport // aux ddl de vitesse ou au ddl de position virtual const Tableau & D_VitesseM_tdt // ( stockage a tdt) (const Tableau& tab_noeud,const Vecteur& phi,bool ddl_vitesse); // idem mais au noeud passé en paramètre virtual const Tableau & D_VitesseM_tdt (const Noeud* noeud,bool ddl_vitesse); // calcul de la base naturel , au point correspondant au dphi en fonction des coord a t=0 virtual const BaseB& BaseNat_0 // ( stockage a t=0) (const Tableau& tab_noeud,const Mat_pleine& tabDphi,const Vecteur& phi); // calcul de la base naturel , au point correspondant au dphi en fonction des coord a t virtual const BaseB& BaseNat_t // ( stockage a t) (const Tableau& tab_noeud,const Mat_pleine& tabDphi,const Vecteur& phi); // calcul de la base naturel , au point correspondant au dphi en fonction des coord a tdt virtual const BaseB& BaseNat_tdt // ( stockage a tdt) (const Tableau& tab_noeud,const Mat_pleine& tabDphi,const Vecteur& phi); // calcul de la variation de la base naturel, au point correspondant au dphi en fonction des coord a tdt // nécessite que la base naturelle ait été calculée auparavant virtual const Tableau & d_BaseNat_tdt // ( stockage a tdt) (const Tableau& tab_noeud,const Mat_pleine& tabDphi,const Vecteur& phi); // calcul de la base naturelle et duale ( stockage a t=0) en fonction des coord a 0 virtual void BaseND_0(const Tableau& tab_noeud,const Mat_pleine& tabDphi, const Vecteur& phi,BaseB& bB,BaseH& bH); // calcul de la base naturelle et duale ( stockage a t) en fonction des coord a t virtual void BaseND_t(const Tableau& tab_noeud,const Mat_pleine& tabDphi, const Vecteur& phi,BaseB& bB,BaseH& bH); // calcul de la base naturelle et duale ( stockage a tdt) en fonction des coord a tdt virtual void BaseND_tdt(const Tableau& tab_noeud,const Mat_pleine& tabDphi, const Vecteur& phi,BaseB& bB,BaseH& bH); // ====== informations diverses (mais cohérentes, c-a-d, peuvent être appelées directement sans init) ==== double JacobienInitial(const Tableau& tab_noeud,const Mat_pleine& tabDphi ,int nombre_noeud,const Vecteur& phi); // ------------------------ gestion de la memoire -------------------------- // Ajout d'initialisation de differentes variables : liste dans tab virtual void PlusInitVariables(Tableau& tab) ; // initialisation de la dimension , du nb de vecteur et du tableau de ddl // cette fonction n'agi qu'une fois , lors des autres appels elle ne fait rien virtual void Dim_NbVec(int dim_base,int nbvec_base,DdlElement & tabddl,int nb_noeud_interpol); // ramène les informations de taille utilisées par la classe const int & Dim_vec_base() const {return dim_base;}; // dimension des vecteurs de base const int & Nbvec_des_bases() const {return nbvec_base;}; // nb de vecteur des bases const int & Nombre_de_noeud() const {return nomb_noeud;}; // nombre de noeud de l'interpolation const DdlElement& Tab_ddl_element() const {return tab_ddl;}; // tableau de ddl de l'element //============================ Methodes protegees ================================ protected: //==calcul des points, par defaut la dimension des points est celle du probleme //== transmise par ParaGlob // calcul du point a t0 virtual void Calcul_M0 ( const Tableau& tab_noeud,const Vecteur& phi, int nombre_noeud); // calcul du point a t virtual void Calcul_Mt (const Tableau& tab_noeud, const Vecteur& phi, int nombre_noeud); // calcul des variations du point a t virtual void Calcul_d_Mt (const Tableau& tab_noeud, const Vecteur& phi, int nombre_noeud); // calcul du point a tdt virtual void Calcul_Mtdt (const Tableau& tab_noeud,const Vecteur& phi, int nombre_noeud); // calcul des variations du point a tdt virtual void Calcul_d_Mtdt (const Tableau& tab_noeud, const Vecteur& phi, int nombre_noeud); // calcul de la vitesse du point a t0 en fonction des ddl existants de vitesse virtual void Calcul_V0 ( const Tableau& tab_noeud,const Vecteur& phi, int nombre_noeud); // idem mais au noeud passé en paramètre virtual void Calcul_V0 (const Noeud* noeud); // calcul de la vitesse du point a t en fonction des ddl existants de vitesse virtual void Calcul_Vt (const Tableau& tab_noeud, const Vecteur& phi, int nombre_noeud); // idem mais au noeud passé en paramètre virtual void Calcul_Vt (const Noeud* noeud); // calcul des variations de la vitesse du point a t en fonction des ddl existants de vitesse virtual void Calcul_d_Vt (const Tableau& tab_noeud, const Vecteur& phi, int nombre_noeud); // idem mais au noeud passé en paramètre virtual void Calcul_d_Vt (const Noeud* noeud); // calcul de la vitesse du point a tdt en fonction des ddl existants de vitesse virtual void Calcul_Vtdt (const Tableau& tab_noeud,const Vecteur& phi, int nombre_noeud); // idem mais au noeud passé en paramètre virtual void Calcul_Vtdt (const Noeud* noeud); // calcul des variations de la vitesse du point a tdt en fonction des ddl existants de vitesse virtual void Calcul_d_Vtdt (const Tableau& tab_noeud, const Vecteur& phi, int nombre_noeud); // idem mais au noeud passé en paramètre virtual void Calcul_d_Vtdt (const Noeud* noeud); // calcul de la vitesse moyenne du point a t0 en fonction des ddl de position virtual void Calcul_V_moy0 ( const Tableau& tab_noeud,const Vecteur& phi, int nombre_noeud); // idem mais au noeud passé en paramètre virtual void Calcul_V_moy0 (const Noeud* noeud); // calcul de la vitesse moyenne du point a t en fonction des ddl de position virtual void Calcul_V_moyt (const Tableau& tab_noeud, const Vecteur& phi, int nombre_noeud); // idem mais au noeud passé en paramètre virtual void Calcul_V_moyt (const Noeud* noeud); // calcul des variations de la vitesse moyenne du point a t en fonction des ddl de position virtual void Calcul_d_V_moyt (const Tableau& tab_noeud, const Vecteur& phi, int nombre_noeud); // idem mais au noeud passé en paramètre virtual void Calcul_d_V_moyt (const Noeud* noeud); // calcul de la vitesse moyenne du point a tdt en fonction des ddl de position virtual void Calcul_V_moytdt (const Tableau& tab_noeud,const Vecteur& phi, int nombre_noeud); // idem mais au noeud passé en paramètre virtual void Calcul_V_moytdt (const Noeud* noeud); // calcul des variations de la vitesse moyenne du point a tdt en fonction des ddl de position virtual void Calcul_d_V_moytdt (const Tableau& tab_noeud, const Vecteur& phi, int nombre_noeud); // idem mais au noeud passé en paramètre virtual void Calcul_d_V_moytdt (const Noeud* noeud); //== par defaut le nombre de vecteur de base est celui de la dimension du //== probleme transmis par paraglob // calcul de la base naturel a t0 virtual void Calcul_giB_0 (const Tableau& tab_noeud, const Mat_pleine& tabDphi, int nombre_noeud,const Vecteur& phi); // calcul de la base naturel a t virtual void Calcul_giB_t (const Tableau& tab_noeud, const Mat_pleine& tabDphi,int nombre_noeud,const Vecteur& phi); // calcul de la base naturel a t+dt virtual void Calcul_giB_tdt (const Tableau& tab_noeud, const Mat_pleine& tabDphi,int nombre_noeud,const Vecteur& phi); //== par defaut la metrique est de type (nbvecteurdela base)au carre //== ce qui permet d'avoir une metrique 2*2 en 3D //== !! neccessite d'avoir calcule la base naturelle corespondante auparavant // 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 () ; //== 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 virtual void Calcul_gradVBB_t (const Tableau& tab_noeud, const Mat_pleine& tabDphi,int nombre_noeud); // calcul gradient de vitesse à t+dt virtual void Calcul_gradVBB_tdt (const Tableau& 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 !! virtual void Calcul_gradVBB_moyen_t (const Tableau& tab_noeud, const Mat_pleine& tabDphi,int nombre_noeud); // calcul du gradient de vitesse moyen entre t et t+dt virtual void Calcul_gradVBB_moyen_tdt (const Tableau& tab_noeud, const Mat_pleine& tabDphi,int nombre_noeud); //== par defaut le nombre de vecteur de la base duale est identique //== a celui de la base naturelle ainsi on peu etre es 3d est avoir uniquement //== un seul vecteur de base (cas d'une biellette par exemple //== mais il faut surcaharger le cacul de la base // !!! important : il est necessaire de calculer les composantes covariantes // puis contravariantes de la metrique avant de calculer les bases duales // calcul de la base duale a t0 virtual void Calcul_giH_0(); // calcul de la base duale a t virtual void Calcul_giH_t(); // calcul de la base duale a t+dt virtual void Calcul_giH_tdt(); //== 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 //== par defaut le nombre de ddl est egal a la dimension du pb //== * le nombre de vecteur de la base virtual void D_giB_t( const Mat_pleine& tabDphi, int nbnoeu,const Vecteur & phi); // avant calcul de : giB_t virtual void D_giB_tdt( const Mat_pleine& tabDphi, int nbnoeu,const Vecteur & phi); // avant calcul de : giB_tdt virtual void D_giH_t(); // avant calcul de : d_giB_t et giH_t virtual void D_giH_tdt(); // avant calcul de : d_giB_tdt et giH_tdt //== calcul de la variation du gradient // par rapport aux composantes V^ar (et non les X^ar ) virtual void DgradVBB_t( const Mat_pleine& dphi); // avant calcul de : giB_t // par rapport aux composantes V^ar (et non les X^ar ) virtual void DgradVBB_tdt(const Mat_pleine& dphi); // avant calcul de : giB_tdt // par rapport aux composantes X^ar (et non les V^ar ) virtual void DgradVmoyBB_t(const Mat_pleine& dphi,const Tableau& tab_noeud); // calcul variation du gradient moyen à t // par rapport aux composantes X^ar (et non les V^ar ) virtual void DgradVmoyBB_tdt(const Mat_pleine& dphi); // calcul variation du gradient moyen à tdt //== calcul de la variation des metriques virtual void D_gijBB_t(); // avant calcul de : d_giB_t et giB_t, Prepa_calcul_DgradVmoy_t() virtual void D_gijBB_tdt(); // avant calcul de : d_giB_tdt et giB_tdt, Prepa_calcul_DgradVmoy_tdt() virtual void D_gijHH_t(); // avant calcul de : d_giH_t et giH_t virtual void D_gijHH_tdt();// avant calcul de : d_giH_tdt et giH_tdt //== calcul de la variation seconde des metriques // ici on ne considère que la variation première des vecteurs de base, c-a-d que // l'on considère que leurs variations secondes sont nulles // ce qui est vrai dans le cas d'une cinématique simple virtual void D2_gijBB_tdt(); // avant calcul de : d_giB_tdt et giB_tdt //== calcul de la variation des jacobiens virtual void Djacobien_t(); // avant calcul de : d_giB_t et giB_t virtual void Djacobien_tdt(); // avant calcul de : d_giB_tdt et giB_tdt // donnee protegees DdlElement tab_ddl; // tableau de ddl de l'element int nbddl_sup_xi; // nombre de ddl supplémentaire à ajouter aux ddl normaux en x,v et gamma // par défaut = 0, mais les classes dérivées ex: les coques // peuvent changer ce nombre, ce qui permet de réserver de la place pour des ddls // spécifiques, exemple l'épaisseur, dans le cas des coques int dim_base ; // dimension des vecteurs de base int nbvec_base; // nb de vecteur des bases int nomb_noeud; // nombre de noeud de l'interpolation Tableau tab; // tableau Coordonnee * M0; // point a t=0 Coordonnee * Mt ; // point a l'instant t Coordonnee * Mtdt; // point a l'instant t+dt Tableau * d_Mt ; // derivées au point a l'instant t, par rapport aux ddl Tableau * d_Mtdt; // derivées au point a l'instant t+dt, par rapport aux ddl Coordonnee * V0; // vitesse du point a t=0 Coordonnee * Vt ; // vitesse du point a l'instant t Coordonnee * Vtdt; // vitesse du point a l'instant t+dt Tableau * d_Vt ; // derivées de la vitesse du point a l'instant t, par rapport aux ddl Tableau * d_Vtdt; // derivées de la vitesse du point a l'instant t+dt, par rapport aux ddl Tableau V_moy_t,V_moy_tdt; // variable interne: vitesse moyenne à t et tdt en chaque noeud r, // calculé dans le calcul du gradient utilisé, dans le calcul de la variation du gradient moyen BaseB * dmatV_moy_t,* dmatV_moy_tdt; // variable interne: dérivée par rapport au repère // matériel (d/dteta_i) au point interpolé BaseB * giB_0 ; // base naturelle a t=0 BaseB * giB_t ; // base naturelle a t BaseB * giB_tdt ; // base naturelle a t+dt BaseH * giH_0; // vecteur de la base duale a 0 BaseH * giH_t; // vecteur de la base duale a t BaseH * giH_tdt; // vecteur de la base duale a t+dt TenseurBB * gijBB_0; // composantes de la metrique de la base naturelle a t TenseurBB * gijBB_t; // composantes de la metrique de la base naturelle a t TenseurBB * gijBB_tdt; // composantes de la metrique de la base naturelle a tdt TenseurHH * gijHH_0; // composantes de la metrique de la base duale a t=0 TenseurHH * gijHH_t; // composantes de la metrique de la base duale a t TenseurHH * gijHH_tdt; // composantes de la metrique de la base duale a t+dt double jacobien_0; // jacobien a l'instant t=0 double jacobien_t; // jacobien a l'instant t double jacobien_tdt; // jacobien a l'instant t+dt Tableau * d_giB_t; // derivees de la base naturelle a t par rapport // aux degres de liberte de position Tableau * d_giB_tdt; // derivees de la base naturelle a t+dt par rapport // aux degres de liberte de position Tableau * d_giH_t; // derivees de la base duale a t par rapport // aux degres de liberte de position Tableau * d_giH_tdt; // derivees de la base duale a t+dt par rapport // aux degres de liberte de position Tableau d_gijBB_t;// derivees de la metrique de la base naturelle // a t par rapport aux degres de liberte de position Tableau d_gijBB_tdt;// derivees de la metrique de la base naturelle // a t+dt par rapport aux degres de liberte de position Tableau2 d2_gijBB_tdt;// derivees seconde de la metrique de la base naturelle // a t+dt par rapport aux degres de liberte de position Tableau d_gijHH_t; // derivees de la metrique de la base duale a t Tableau d_gijHH_tdt; // derivees de la metrique de la base duale a t+dt Vecteur d_jacobien_t ; // derivees du jacobien à t par rapport aux degres de liberte de position Vecteur d_jacobien_tdt ; // derivees du jacobien à tdt par rapport aux degres de liberte de position // *** convention : grad(i,j) = vi|j *** TenseurBB * gradVmoyBB_t; // composantes du gradient de vitesse moyen à t TenseurBB * gradVmoyBB_tdt; // composantes du gradient de vitesse moyen à tdt TenseurBB * gradVBB_t; // composantes du gradient de vitesse instantatnée à t TenseurBB * gradVBB_tdt; // composantes du gradient de vitesse instantatnée à tdt Tableau d_gradVmoyBB_t; // dérivée du gradient de vitesse moyen à t par rapport aux ddl de vitesse Tableau d_gradVmoyBB_tdt; // dérivée du gradient de vitesse moyen à tdt par rapport aux ddl de vitesse Tableau d_gradVBB_t; // dérivée du gradient de vitesse instantatnée à t par rapport aux ddl de vitesse Tableau d_gradVBB_tdt; // dérivée du gradient de vitesse instantatnée à tdt par rapport aux ddl de vitesse // maintenant définition des différents conteneurs de retour des méthodes globales Impli ex_impli; // cas d'un calcul implicite Expli ex_expli; // calcul explicite 0 t Expli_t_tdt ex_expli_t_tdt; // calcul explicite 0 t tdt gijHH_0_et_giH_0 ex_gijHH_0_et_giH_0; // comme le nom l'indique ! Dynamiq ex_Dynamiq; // calcul pour la dynamique (partie spécifique à quelques grandeurs) flambe_lin ex_flambe_lin; // grandeurs pour le flambement linéaire Umat_cont umat_cont; // calcul relatif aux Umat InfoImp ex_InfoImp; // sortie d'info en implicite InfoExp_t ex_InfoExp_t; // sortie d'info en explicite à t InfoExp_tdt ex_InfoExp_tdt; // sortie d'info en explicite à tdt Info0_t_tdt ex_Info0_t_tdt; // sortie d'info à 0 t et tdt // fonctions privees // Calcul des composantes de la metrique d'une base naturelle: void Calcul_gijBB (BaseB & giB,TenseurBB & gijBB) ; void Calcul_giH(BaseB* giB, TenseurHH* gijHH, BaseH * giH); //== Existe, recherche si un element de l'enumeration existe // retourne vrai si x appartiend au tableau false sinon bool Existe(Tableau& tab,const Enum_variable_metrique& x); int posi_tab; // pour le programme exite //== Existe_num, recherche si un element de l'enumeration existe // retourne le numéro si x appartiend au tableau, 0 sinon int Existe_num(Tableau& tab,const Enum_variable_metrique& x); // allocation de la memoire void Allocation (); // deallocation de la memoire void Deallocation(); // de toutes les grandeurs // uniquement des grandeurs de tib void Deallocation(Tableau& tib); // copie en fonction de l'instance passée // concerne que les grandeurs pointées void Copie_met(const Met_abstraite& a); // initialisation des conteneurs de retour des méthodes void Init_conteneur_de_retour_methode(); // changement de nbddl_sup_xi par les classes dérivées void Change_nbddl_sup_xi(int nbddl_sup_xi_new) {nbddl_sup_xi=nbddl_sup_xi_new;}; }; /// @} // end of group #endif