// 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: 04/05/2006 * * $ * * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * * $ * * PROJET: Herezh++ * * $ * ************************************************************************ * BUT: Interface pour les lois de frottement dans * * le cas de contact. * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * * VERIFICATION: * * * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * ! ! ! ! * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * MODIFICATIONS: * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * $ * ************************************************************************/ // FICHIER : CompFrotAbstraite.h // CLASSE : CompFrotAbstraite #ifndef COMP_FROT_ABSTRAITE_H #define COMP_FROT_ABSTRAITE_H #include "Enum_comp.h" #include "Tableau_T.h" #include "Tenseur.h" #include "LoiAbstraiteGeneral.h" #include "TypeQuelconque.h" #include "EnergieMeca.h" class CompFrotAbstraite : public LoiAbstraiteGeneral { public : // CONSTRUCTEURS : // Constructeur par defaut CompFrotAbstraite () ; // Constructeur utile si l'identificateur du nom de la loi // de comportement et la dimension sont connus CompFrotAbstraite (Enum_comp id_compor,Enum_categorie_loi_comp categorie_comp,int dimension); // Constructeur utile si l'identificateur du nom de la loi // de comportement et la dimension sont connus CompFrotAbstraite (char* nom,Enum_categorie_loi_comp categorie_comp,int dimension); // Constructeur de copie CompFrotAbstraite (const CompFrotAbstraite & a ); // DESTRUCTEUR VIRTUEL : virtual ~CompFrotAbstraite (); // 2) METHODES VIRTUELLES public: // initialise les donnees particulieres a l'elements // de matiere traite ( c-a-dire au pt calcule) // Il y a creation d'une instance de SaveResul particuliere // a la loi concernee // la SaveResul classe est remplie par les instances heritantes // le pointeur de SaveResul est sauvegarde au niveau de l'element de contact // c-a-d que les info particulieres au point considere sont stocke // au niveau de l'element et non de la loi. class SaveResul { public : // définition d'une nouvelle instance identique // appelle du constructeur via new virtual SaveResul * Nevez_SaveResul() const =0; // affectation virtual SaveResul & operator = ( const SaveResul & a) = 0; //============= 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) = 0; // 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) = 0; // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) virtual void TdtversT() {}; virtual void TversTdt() {}; //changement de base de toutes les grandeurs internes tensorielles stockées // beta(i,j) represente les coordonnees de la nouvelle base naturelle gpB dans l'ancienne gB // gpB(i) = beta(i,j) * gB(j), i indice de ligne, j indice de colonne // gpH(i) = gamma(i,j) * gH(j) virtual void ChBase_des_grandeurs(const Mat_pleine& beta,const Mat_pleine& gamma) = 0; }; virtual SaveResul * New_et_Initialise() { return NULL;}; // affichage des donnees particulieres a l'elements // de matiere traite ( c-a-dire au pt calcule) virtual void AfficheDataSpecif(ofstream& ,SaveResul * ) const {}; // schema de calcul explicite à tdt // calcul des efforts de frottement à un instant t+deltat // les indices t se rapporte au pas précédent, sans indice au temps actuel // vit_T : vitesse, force_normale: force normale (à la cible) agissant sur le noeud projectile // force_tangente: force tangente (à la cible) agissant sur le noeud projectile // normale: la normale de contact normée // energie_frottement: l'énergie échangée: élas=la totalité, viqueux et plas= uniquement pendant dt // delta_t : le pas de temps // F_frot: force de frottement calculé, // retour glisse: indique si oui ou non le noeud glisse virtual bool Cal_explicit_contact_tdt(const Coordonnee& vit_T, const Coordonnee& normale ,const Coordonnee& force_normale,const Coordonnee& force_tangente ,EnergieMeca& energie_frottement,const double delta_t ,Coordonnee& F_frot,CompFrotAbstraite::SaveResul * = NULL) {return Calcul_Frottement(vit_T,normale,force_normale,force_tangente ,energie_frottement,delta_t,F_frot);}; // schema implicit // calcul des efforts de frottement à un instant t+deltat // et ses variations par rapport aux ddl de vitesse // vit_T : vitesse, force_normale: force normale (à la cible) agissant sur le noeud projectile // force_tangente: force tangente (à la cible) agissant sur le noeud projectile // normale: la normale de contact normée // energie_frottement: l'énergie échangée: élas=la totalité, viqueux et plas= uniquement pendant dt // delta_t : le pas de temps // F_frot: force de frottement calculé // d_F_frot_vit: variation de la force de frottement par rapport aux coordonnées de vitesse // retour glisse: indique si oui ou non le noeud glisse virtual bool Cal_implicit(const Coordonnee& vit_T, const Coordonnee& normale ,const Coordonnee& force_normale,const Coordonnee& force_tangente ,EnergieMeca& energie_frottement,const double delta_t ,Coordonnee& F_frot,Tableau & d_F_frot_vit ,CompFrotAbstraite::SaveResul * = NULL) {return Calcul_DFrottement_tdt(vit_T,normale,force_normale,force_tangente ,energie_frottement,delta_t,F_frot,d_F_frot_vit);}; // activation des données des noeuds et/ou elements nécessaires au fonctionnement de la loi // exemple: mise en service de ddl particulier // pour l'instant rien virtual void Activation_donnees() {}; // modification de l'indicateur de comportement tangent void Modif_comp_tangent_simplifie(bool modif) { comp_tangent_simplifie = modif;}; // test pour connaître l'état du comportement : simplifié ou non bool Test_loi_simplife() { return comp_tangent_simplifie;}; // récupération des grandeurs particulière (hors ddl ) // correspondant à liTQ // la liste d'entiers correspond à un décalage éventuel // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière virtual void Grandeur_particuliere(bool absolue,List_io& ,CompFrotAbstraite::SaveResul *,list& ) {}; // récupération de la liste de tous les grandeurs particulières // ces grandeurs sont ajoutées à la liste passées en paramètres // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière virtual void ListeGrandeurs_particulieres(bool absolue,List_io& ) {}; // création d'une loi à l'identique et ramène un pointeur sur la loi créée virtual CompFrotAbstraite* Nouvelle_loi_identique() const = 0; protected : // affichage et definition interactive des commandes particulières à la classe CompFrotAbstraite void Info_commande_don_LoisDeComp(UtilLecture& ) const {}; //----- lecture écriture de restart spécifique aux données de la classe ----- // 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) void Lecture_don_base_info(ifstream& ,const int ,LesReferences& ,LesCourbes1D& ,LesFonctions_nD& ) {}; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void Ecriture_don_base_info(ofstream& ,const int ) const {}; // activation des données des noeuds et/ou elements nécessaires au fonctionnement de la loi // exemple: mise en service de de certain ddl aux noeuds // méthode appelée par Activation_donnees principal, ou des classes dérivées // ce qui permet de surcharger ces dernières: actuellement rien !! void Activ_donnees(); // VARIABLES PROTEGEES : // pointeur de travail utilise par les classes derivantes SaveResul * saveResul; // indic pour définir si oui ou non on utilise un comportement tangent simplifié bool comp_tangent_simplifie; // --------- variables gérées en I/O par les classes dérivées ------- protected : // 3) METHODES VIRTUELLES PURES protegees: // calcul des efforts de frottement à un instant t+deltat // les indices t se rapporte au pas précédent, sans indice au temps actuel // vit_T : vitesse, force_normale: force normale (à la cible) agissant sur le noeud projectile // force_tangente: force tangente (à la cible) agissant sur le noeud projectile // normale: la normale de contact normée // energie_frottement: l'énergie échangée: élas=la totalité, viqueux et plas= uniquement le pas de temps // delta_t : le pas de temps // F_frot: force de frottement calculé, // retour glisse: indique si oui ou non le noeud glisse virtual bool Calcul_Frottement(const Coordonnee& vit_T, const Coordonnee& normale ,const Coordonnee& force_normale,const Coordonnee& force_tangente ,EnergieMeca& energie_frottement,const double delta_t ,Coordonnee& F_frot) = 0; // calcul des efforts de frottement à un instant t+deltat // et ses variations par rapport aux ddl de vitesse // vit_T : vitesse, force_normale: force normale (à la cible) agissant sur le noeud projectile // force_tangente: force tangente (à la cible) agissant sur le noeud projectile // energie_frottement: l'énergie échangée: élas=la totalité, viqueux et plas= uniquement le pas de temps // delta_t : le pas de temps // F_frot: force de frottement calculé, // d_F_frot_vit: variation de la force de frottement par rapport aux coordonnées de vitesse // retour glisse: indique si oui ou non le noeud glisse virtual bool Calcul_DFrottement_tdt (const Coordonnee& vit_T, const Coordonnee& normale ,const Coordonnee& force_normale,const Coordonnee& force_tangente ,EnergieMeca& energie_frottement,const double delta_t ,Coordonnee& F_frot,Tableau & d_F_frot_vit) = 0; }; #endif