// 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-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 . // // For more information, please consult: . /************************************************************************ * DATE: 23/01/97 * * $ * * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * * $ * * PROJET: Herezh++ * * $ * ************************************************************************ * BUT: Calcul des differentes grandeurs liee a la deformation * * des elements sfe1 * * La classe fonctionne comme une boite a outil. On y choisit ce * * dont on a besoin. Bien faire attention a l'ordre d'appel des * * differentes methodes lorsque il faut suivre une chronologie. * * Cette classe calcul mais ne stock pas. * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * * VERIFICATION: * * * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * ! ! ! ! * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * MODIFICATIONS: * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * $ * ************************************************************************/ #ifndef DEFORMATIONSFE1_H #define DEFORMATIONSFE1_H #include "Tableau_T.h" #include "Met_abstraite.h" #include "Deformation.h" #include "Met_Sfe1.h" #include "EnuTypeCL.h" #include "Epai.h" /// @addtogroup groupe_des_deformations /// @{ /// /// BUT: Calcul des differentes grandeurs liee a la deformation /// des elements sfe1 /// La classe fonctionne comme une boite a outil. On y choisit ce /// dont on a besoin. Bien faire attention a l'ordre d'appel des /// differentes methodes lorsque il faut suivre une chronologie. /// Cette classe calcul mais ne stock pas. /// /// /// \author Gérard Rio /// \version 1.0 /// \date 23/01/97 class DeformationSfe1 : public Deformation { public : // CONSTRUCTEURS : DeformationSfe1 () ; // par defaut ne doit pas etre utilise -> message // d'erreur en phase de mise au point // constructeur normal dans le cas d'un ou de plusieurs pt d'integration // tabDphi et tabPhi sont relatifs aux fonctions d'interpolation // la terminaison H est relative aux grandeurs d'épaisseur, S pour la surface DeformationSfe1 (Met_abstraite & ,Tableau& tabnoeud ,Tableau const & tabDphiH,Tableau const & tabPhiH ,Tableau const & tabDphiS,Tableau const & tabPhiS); // constructeur de copie DeformationSfe1 (const DeformationSfe1 &); // DESTRUCTEUR : virtual ~DeformationSfe1 (); // METHODES PUBLIQUES : //------------------------------------------------------------------------------------ // // définition d'une classe conteneur spécifique à chaque point ou la déformation // // est calculée class SaveDefResulSfe1 : public Deformation::SaveDefResul { friend class Deformation ;friend class DeformationSfe1; public : // Constructeurs SaveDefResulSfe1(); // constructeur par défaut-> à ne pas utiliser -> message d'erreur SaveDefResulSfe1(const Met_abstraite& meta); // le constructeur recevable SaveDefResulSfe1(const SaveDefResulSfe1& a); // constructeur de copie ~SaveDefResulSfe1(); // destructeur // surcharge de l'optérateur d'affectation virtual SaveDefResul& operator= (const SaveDefResul& a); // surcharge d'affectation // affichage des infos virtual void Affiche(); // idem sur un ofstream virtual void Affiche(ofstream& sort); //============= lecture écriture dans base info ========== // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) virtual void Lecture_base_info (ifstream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) virtual void Ecriture_base_info(ofstream& sort,const int cas); // mise à jour des informations transitoires en définitif, ou l'inverse virtual void TdtversT() {meti_a_t = meti_a_tdt;}; virtual void TversTdt() {meti_a_tdt = meti_a_t;}; // mise à jour des grandeurs meti_00 virtual void MiseAJourGrandeurs_a_0(const Met_abstraite * metrique); // mise à jour des grandeurs meti_tdt virtual void MiseAJourGrandeurs_a_tdt(const Met_abstraite * metrique,const TenseurBB& Deps_BB); // il n'y a pas de mise à jour des grandeurs à t, car celles-ci sont mise à jour à l'aide // de la méthode TdtversT !! // lecture des infos des métriques const Deformation::Stmet& Meti_a_00() const {return meti_a_00;} const Deformation::Stmet& Meti_a_t() const {return meti_a_t;} const Deformation::Stmet& Meti_a_tdt() const {return meti_a_tdt;} protected : // VARIABLES PROTEGEES : // ici il s'agit des données de la facette, et dans SaveDefResul on met les infos // correspondant aux métriques dans l'épaisseur // en fait ne sert à rien d'une manière pratique !! si pour les calculs de variation d'épaisseur !!! Deformation::Stmet meti_a_00,meti_a_t,meti_a_tdt; // les infos à 0 à t et à tdt }; // création d'une instance de SaveDefResulSfe1 et initialisation. virtual SaveDefResul * New_et_Initialise() {return (new SaveDefResulSfe1(*metrique));}; // affichage des donnees particulieres a l'elements // de matiere traite ( c-a-dire au pt calcule) virtual void AfficheDataSpecif(ofstream& sort,SaveDefResul * a) const {a->Affiche(sort);}; // met à jour les données spécifiques du point considéré void Mise_a_jour_data_specif(Deformation::SaveDefResul* don) {saveDefResul=don;}; // // fin de définition relatif à la classe conteneur spécifique à chaque point // // ou la déformation est calculée //------------------------------------------------------------------------------------ // ========== changement de grandeurs stockees ========================= // définition du déformation du même type, permet d'utiliser des types dérivée surchargé virtual Deformation * Nevez_deformation(Tableau & tabN) const { DeformationSfe1* def = new DeformationSfe1(*this);def->PointeurTableauNoeud(tabN);return def;} ; // Surcharge de l'operateur = : realise l'affectation // fonction virtuelle inline Deformation& operator= (const Deformation& def) { return (Deformation::operator=(def));}; // on renseigne les conditions limites éventuelles void RenseigneCondLim(const Tableau & arTypeCL,const Tableau & vpla ) {tabTypeCL = &arTypeCL; vplan = &vpla;}; // ==== affichage ==== // affichage des informations virtual void Affiche() const; // ========== calcul des raideurs ========================= // calcul explicit à t : tous les parametres sont des resultats virtual const Met_abstraite::Expli& Cal_explicit_t ( const Tableau & def_equi_t,TenseurBB & epsBB_t,Tableau & d_epsBB ,Tableau & def_equi,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,bool premier_calcul); // calcul explicit à tdt : tous les parametres sont des resultats virtual const Met_abstraite::Expli_t_tdt& Cal_explicit_tdt (const Tableau & def_equi_t, TenseurBB & epsBB_tdt,Tableau & d_epsBB ,Tableau & def_equi,TenseurBB& DepsBB,TenseurBB& delta_epsBB_tdt,bool premier_calcul); // cas implicite const Met_abstraite::Impli& Cal_implicit (const Tableau & def_equi_t,TenseurBB & epsBB_tdt,Tableau & d_epsBB ,Tableau & def_equi,TenseurBB& DepsBB,TenseurBB& delta_epsBB,bool premier_calcul); // ---------------- calcul des variables primaires autre que pour la mécanique -------- // ------------ donc par de retour relatif aux déformations // calcul explicit à t : tous les parametres sont des resultats virtual const Met_abstraite::Expli& Cal_explicit_t(bool premier_calcul); // calcul explicit à tdt : tous les parametres sont des resultats virtual const Met_abstraite::Expli_t_tdt& Cal_explicit_tdt(bool premier_calcul); // cas implicite const Met_abstraite::Impli& Cal_implicit(bool premier_calcul); // --------------- test sur la courbure ------------------------------ // test si la courbure est anormalement trop grande // inf_normale : indique en entrée le det mini pour la courbure en locale // retour 1: si tout est ok, // 0: une courbure trop grande a été détecté int Test_courbure_anormale(Enum_dure temps,double inf_normale) {return (((Met_Sfe1*) metrique)->Test_courbure_anormale) (temps,inf_normale, *tabnoeud,(*tabDphi)(numInteg_surf),nbNoeud,(*tabPhi)(numInteg_surf)); }; // ========== remontee aux informations ========================= // calcul : // M0 : point d'integration numInteg a t = 0 // Mt ou Mtdt : point d'integration final // Aa0 et Aafin : matrice de passage initiale et finale dans un repere ortho tel que // la nouvelle base Aa est calculee par projection de "Ipa" sur Gi // gijHH et gijBB : metrique finale // Aa(i,a) = Aa^i_{.a}, avec g^i = Aa^i_{.a} * Ip^a // tout ce passe comme si Ip^a est la nouvelle base vers laquelle on veut évoluer // cas sortie d'un calcul implicit virtual const Met_abstraite::InfoImp RemontImp(bool absolue,Mat_pleine& Aa0,Mat_pleine& Aafin); // idem sans le calcul des matrices de passage virtual const Met_abstraite::InfoImp RemontImp(); // cas sortie d'un calcul explicit à t virtual const Met_abstraite::InfoExp_t RemontExp_t(bool absolue,Mat_pleine& Aa0,Mat_pleine& Aafin); // idem sans le calcul des matrices de passage virtual const Met_abstraite::InfoExp_t RemontExp_t(); // cas sortie d'un calcul explicit à tdt virtual const Met_abstraite::InfoExp_tdt RemontExp_tdt(bool absolue,Mat_pleine& Aa0,Mat_pleine& Aafin); // idem sans le calcul des matrices de passage virtual const Met_abstraite::InfoExp_tdt RemontExp_tdt(); // cas sortie d'un calcul à 0, t et tdt virtual const Met_abstraite::Info0_t_tdt Remont0_t_tdt(bool absolue,Mat_pleine& Aa0,Mat_pleine& Aat,Mat_pleine& Aatdt); // idem sans le calcul des matrices de passage virtual const Met_abstraite::Info0_t_tdt Remont0_t_tdt(); // récupération des infos relatives à la courbure pour 0, t et tdt virtual const Met_Sfe1::Courbure_t_tdt& RecupCourbure0_t_tdt()const {return ((Met_Sfe1*) metrique)->RecupCourbure();}; // change le numero d'integration courant virtual void ChangeNumInteg(int ni); // change les numeros d'integration de surface et d'epaisseur courant // nisurf : nouveau point de surface // niepaiss : nouveau point d'epaisseur void ChangeNumIntegSfe1(int nisurf, int niepaiss); // gestion du parcours de tous les points d'integration void PremierPtInteg(); bool DernierPtInteg(); void NevezPtInteg(); // méthode pour revenir au pti précédant virtual void Retour_pti_precedant(); int Nb_pt_int_surf()const {return (tabPhi->Taille());}; int Nb_pt_int_epai()const {return (tabPhiH->Taille());}; // change l'épaisseur stockée, et préparation du stockage si nécessaire void Change_epaisseur(const Epai& epaisse) {*epais=epaisse;}; // calcul de la position dans le repère absolu du point d'intégration virtual const Coordonnee& Position_0() // à t=0 {return ((Met_Sfe1*) metrique)->PointSfe1M_0(*tabnoeud,(*tabPhi)(numInteg_surf) ,(*tabDphi)(numInteg_surf),epais,(*tabPhiH)(numInteg_ep));}; virtual const Coordonnee& Position_t() // à t {return ((Met_Sfe1*) metrique)->PointSfe1M_t(*tabnoeud,(*tabPhi)(numInteg_surf) ,(*tabDphi)(numInteg_surf),epais,(*tabPhiH)(numInteg_ep));}; virtual const Coordonnee& Position_tdt() // à t+dt {return ((Met_Sfe1*) metrique)->PointSfe1M_tdt(*tabnoeud,(*tabPhi)(numInteg_surf) ,(*tabDphi)(numInteg_surf),epais,(*tabPhiH)(numInteg_ep));}; /* // calcul de la variation dans le repère absolu du point d'intégration virtual const Tableau & Der_Pos_t() // à t {return metrique->D_PointM_t(*tabnoeud,(*tabPhi)(numInteg));}; virtual const Tableau & Der_Posi_tdt() // à t+dt {return metrique->D_PointM_tdt(*tabnoeud,(*tabPhi)(numInteg));}; */ // détermination des bases de passages (seules les données en entrées et sortie // sont utilisées ) virtual void BasePassage(bool absolue,const BaseB & giB0,const BaseB & giB,const BaseH & giH0, const BaseH & giH, Mat_pleine& Aa0,Mat_pleine& Aafin); // cas où l'on veut les matrices de passages à 0 t et tdt virtual void BasePassage(bool absolue,const BaseB & giB0,const BaseB & giB_t,const BaseB & giB_tdt ,const BaseH & giH0,const BaseH & giH_t,const BaseH & giH_tdt ,Mat_pleine& Aa0,Mat_pleine& Aa_t,Mat_pleine& Aa_tdt); protected : // VARIABLES PROTEGEES : Tableau const * tabDphiH; // derivees des fonctions d'interpolation suivant H Tableau const * tabPhiH; // les fonctions d'interpolation suivant H // les tableaux tabDphi et tabPhi définis dans la classe mère Deformation, sont utilisés // pour le stockage de l'interpolation suivant l'axe ou le plan. Epai * epais; // != NULL s'il y a des épaisseurs courantes stocké à l'élément et donc // relayées ici, sinon = NULL // information concernant des conditions limites éventuelles, qui ont des répercutions sur // le calcul de la métrique Tableau const * tabTypeCL; // tabTypeCL(i) : si différent de RIEN_TYPE_CL, indique le type de condition // limite de l'arête i Tableau const * vplan; // util pour des conditions de symétrie ou d'encastrement // si tabTypeCL(i) = TANGENTE_CL , alors vplan(i) contient // un vecteur du plan normal à la tangente, // l'arête donne un second vecteur // +++++ des variables qui vont varier au cours du calcul: variables transitoires int numInteg_ep; // numero du point d'integration en cours dans l'epaisseur int numInteg_surf; // numero du point d'integration en cours sur la surface // numInteg de la class mère, est égal à numinteg_surf // méthode pour la gestion d'un changement momentané de pti int sauve_numInteg_ep; /// sauvegarde pour un retour au pti précédant avec la méthode Retour_pti_precedant(); int sauve_numInteg_surf; // +++++ fin des variables qui vont varier au cours du calcul: variables transitoires // METHODES PROTEGEES : // --- méthodes de vérifications ---- // méthode de vérification par différences finies du calcul des différentes dérivées void VerifCal_def(bool gradV_instantane,const Met_abstraite::Impli & ex,TenseurBB& epsBB_tdt ,Tableau & d_epsBB_tdt); void VerifCal_implicit(bool gradV_instantane,const Met_abstraite::Impli & ex); // indicateur utilisé par Verif_par différences finis static int indic_VerifCal_implicitSfe1; }; /// @} // end of group #endif