Herezh_dev/contact/ElContact.h
2023-05-03 17:23:49 +02:00

546 lines
28 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: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Element de contact. *
* - l'élément utilise une frontiere Front qui contient ses *
* donnees geometriques : l'élément de contact crée une copie *
* d'un élément de frontière qui existe par ailleurs, en fait *
* l'originale existe dans LesContacts. *
* L'aspect spécifique est: *
* . le Front de l'élément de contact est une copie *
* . le tableau de ses mitoyens pointe sur les originaux *
* du coup on peut supprimer et créer de nouvelles copies *
* de Front sans invalider le tableau de pointeur de Front *
* qui définit les mitoyens ! (un peu tordu ) *
* - il gère les aspects spécifiques du contact: efforts, *
* résidu, raideur etc. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef ELCONTACT_H
#define ELCONTACT_H
#include "Front.h"
#include "Noeud.h"
#include "Condilineaire.h"
#include "LesFonctions_nD.h"
/** @defgroup Groupe_sur_les_contacts
*
* BUT: groupe relatif aux contacts
*
*
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
* \brief groupe relatif aux contacts
*
*/
/// @addtogroup Groupe_sur_les_contacts
/// @{
///
class ElContact
{
public :
// une classe structure de transfert pour simplifier le passage de paramètres
class Fct_nD_contact
{ public:
Fct_nD_contact();
Fct_nD_contact(const Fct_nD_contact& a);
~Fct_nD_contact();
Fct_nD_contact& operator= (const Fct_nD_contact& a);
// utilisation de fct nD
Fonction_nD * fct_nD_penalisationPenetration; // fct nD dans le cas d'une valeur pilotée
Fonction_nD * fct_nD_penetration_contact_maxi; // fct nD dans le cas d'une valeur pilotée
Fonction_nD * fct_nD_penetration_borne_regularisation; // fct nD dans le cas d'une valeur pilotée
Fonction_nD * fct_nD_force_contact_noeud_maxi; // fct nD dans le cas d'une valeur pilotée
Fonction_nD * fct_nD_penalisationTangentielle;
Fonction_nD * fct_nD_tangentielle_contact_maxi; // fct nD dans le cas d'une valeur pilotée
Fonction_nD * fct_nD_tangentielle_borne_regularisation; // fct nD dans le cas d'une valeur pilotée
Fonction_nD * fct_nD_force_tangentielle_noeud_maxi; // fct nD dans le cas d'une valeur pilotée
Fonction_nD * fct_niveau_commentaire; // fct nD dans le cas d'une valeur pilotée
// initialisation des conteneurs statique des fonction nD
void Init_conteneur_statique();
// stockage transitoire pour les quelconques vraiment quelconque
static Tableau <const TypeQuelconque * > tqi_const_fct_nD_penalisationPenetration;
static Tableau < TypeQuelconque * > tqi_fct_nD_penalisationPenetration;
static Tableau <int> t_num_ordre_fct_nD_penalisationPenetration;
static Tableau <const TypeQuelconque * > tqi_const_fct_nD_penetration_contact_maxi;
static Tableau < TypeQuelconque * > tqi_fct_nD_penetration_contact_maxi;
static Tableau <int> t_num_ordre_fct_nD_penetration_contact_maxi;
static Tableau <const TypeQuelconque * > tqi_const_fct_nD_penetration_borne_regularisation;
static Tableau < TypeQuelconque * > tqi_fct_nD_penetration_borne_regularisation;
static Tableau <int> t_num_ordre_fct_nD_penetration_borne_regularisation;
static Tableau <const TypeQuelconque * > tqi_const_fct_nD_force_contact_noeud_maxi;
static Tableau < TypeQuelconque * > tqi_fct_nD_force_contact_noeud_maxi;
static Tableau <int> t_num_ordre_fct_nD_force_contact_noeud_maxi;
static Tableau <const TypeQuelconque * > tqi_const_fct_nD_penalisationTangentielle;
static Tableau < TypeQuelconque * > tqi_fct_nD_penalisationTangentielle;
static Tableau <int> t_num_ordre_fct_nD_penalisationTangentielle;
static Tableau <const TypeQuelconque * > tqi_const_fct_nD_tangentielle_contact_maxi;
static Tableau < TypeQuelconque * > tqi_fct_nD_tangentielle_contact_maxi;
static Tableau <int> t_num_ordre_fct_nD_tangentielle_contact_maxi;
static Tableau <const TypeQuelconque * > tqi_const_fct_nD_tangentielle_borne_regularisation;
static Tableau < TypeQuelconque * > tqi_fct_nD_tangentielle_borne_regularisation;
static Tableau <int> t_num_ordre_fct_nD_tangentielle_borne_regularisation;
static Tableau <const TypeQuelconque * > tqi_const_fct_nD_force_tangentielle_noeud_maxi;
static Tableau < TypeQuelconque * > tqi_fct_nD_force_tangentielle_noeud_maxi;
static Tableau <int> t_num_ordre_fct_nD_force_tangentielle_noeud_maxi;
static Tableau <const TypeQuelconque * > tqi_const_fct_nD_niveau_commentaire;
static Tableau < TypeQuelconque * > tqi_fct_nD_niveau_commentaire;
static Tableau <int> t_num_ordre_fct_nD_niveau_commentaire;
protected :
// définition des conteneurs de transfert des TypeQuelconque
// pour une fonction nD particulière
void Definition_conteneurs_static_TypeQuelconque
(Fonction_nD * pt_fonct,Tableau < TypeQuelconque * >& tqi
,Tableau < const TypeQuelconque * >& tqii,Tableau <int>& t_num_ordre );
};
// CONSTRUCTEURS :
// par defaut
ElContact();
// la version avec fonction de pilotage nD
ElContact(Fct_nD_contact & fct_contact);
// fonction d'un pointeur d'element frontiere et d'un pointeur de noeud
// du fait éventuel qu'il peut-être collant ou pas
ElContact ( const Front * elfront, const Noeud * noeud, Fct_nD_contact & fct_contact_, int collant = 0);
// de copie
ElContact ( const ElContact & a);
// DESTRUCTEUR :
~ElContact ();
// METHODES PUBLIQUES :
// test d'egalite sur les éléments originaux :
// l'élément de frontière front, le noeud esclave, même zone de contact
inline bool MemeOrigine( const ElContact& a) const
{ if ( (this->elfront->MemeOrigine(*a.Elfront()))
&& (this->noeud->Num_noeud() == a.Const_Esclave()->Num_noeud())
&& (this->noeud->Num_Mail() == a.Const_Esclave()->Num_Mail())
&& (num_zone_contact == a.Const_Num_zone_contact())
)
return true;
else
return false;
};
// init d'une fonction nD pour le pilotage du type de contact 4
static void Init_fct_pilotage_contact4(Fonction_nD * fct_pilo_contact4)
{fct_pilotage_contact4 = fct_pilo_contact4;};
//retourne le niveau d'affichage
int Permet_affichage() const
{ return( (fct_nD_contact.fct_niveau_commentaire == NULL) ?
(niveau_commentaire == 0) ? ParaGlob::NiveauImpression() : niveau_commentaire
: Valeur_fct_nD(fct_nD_contact.fct_niveau_commentaire
,ElContact::Fct_nD_contact::tqi_fct_nD_niveau_commentaire
,ElContact::Fct_nD_contact::tqi_const_fct_nD_niveau_commentaire
,ElContact::Fct_nD_contact::t_num_ordre_fct_nD_niveau_commentaire
)
);
};
// méthode statique de modification éventuelle du type de contact utilisé localement
// par exemple pour le type 4 en fonction des itérations
static int Recup_et_mise_a_jour_type_contact() ;
// affichage à l'écran des informations liées au contact
// cas = 0 : affichage en fonction du niveau de commentaire voulu
// cas = 1 : affichage minimal nécessaire pour repérer l'élément
// cas = 2 : affichage en fonction du niveau de commentaire pour les éléments de contact
void Affiche(int cas=0) const ;
// calcul d'un contact eventuel entre le noeud esclave et la frontiere
// ramene true s'il y a contact
// si init = false, on recherche le contact a partir du precedent point sauvegarde
// sinon on commence a l'aide d'element de reference,
// et on calcule et sauvegarde les coordonnées
// initiale locales theta^i du point de contact
// si le contact existe et si l'algo le demande (cf. ParaAlgoControle) :
// le noeud pourrait-être ramené sur la surface mais:
// on ne fait pas de projection, sinon on ne peut pas tester plusieurs contacts pour
// choisir le meilleur, puisque les choses changent entre avant et après le test de contact
// donc ici la position du noeud esclave n'est pas modifiée
bool Contact( bool init = true);
// juste après l'utilisation de la méthode Contact(), ramène le point en contact
const Coordonnee& Point_intersection() const { return Mtdt; };
// un stockage utilisé par les méthodes appelantes
int& Num_zone_contact() {return num_zone_contact;};
int Const_Num_zone_contact() const {return num_zone_contact;};
// calcul de la trajectoire a prendre en compte pour le contact
// ---- a) cas ou à t il n'y avait pas de contact, ou que l'on n'a pas fait de projection sur la surface (cas du contact cinématique)
// 4 cas : 1) le noeud bouge, dans ce cas la trajectoire est determinee
// par la variation de la position du noeud
// 2) le noeud est immobile, mais la frontiere bouge, la trajectoire est determine
// par une parallele a la variation moyenne de la frontiere (variation de G)
// 4) est une variante du 2), cas où l'on a une rotation autour de G, dans ce cas on prend comme trajectoire
// le maxi des déplacements de noeud
// 3) rien ne bouge, on utilise la normale au point de reference de l'element de frontiere
// pour calculer la trajectoire .
// dans le cas 3 la variable test = 0 , sinon elle vaut 1 pour le cas 1 et 2 pour le cas 2 , 4 pour le cas 4
// ---- b) cas ou à t on était déjà en contact avec projection sur la surface
// la trajectoire est alors systématiquement la direction de la dernière normale,
// retour : test=5
Coordonnee Trajectoire(int & test);
// calcul de l'Intersection de la trajectoire du noeud definit par le vecteur V
// avec l'element frontiere
// ramene les coordonnees du noeud projete
// dans le cas où il n'y a pas d'intersection, on ramène un point de dimension nulle
Coordonnee Intersection( const Coordonnee& V,bool init);
// construction de la condition lineaire de contact
// nb_assemb : indique le numéro d'assemblage correspondant
Condilineaire ConditionLi(int nb_assemb);
// ramene le tableau de tous les noeuds, le premier est celui esclave
Tableau <Noeud*>& TabNoeud() {return tabNoeud;};
const Tableau <Noeud*>& Const_TabNoeud() const {return tabNoeud;};
// ramene le tableau pour assemblage: dépend du Cas_solide()
// est cohérent avec TableauDdlCont
Tableau <Noeud*>& TabNoeud_pour_assemblage() {return tabNoeud_pour_assemblage;};
// retourne les tableaux de ddl associés aux noeuds, gere par l'element
// qui sont actifs au moment de la demande
// Tableau de DdlElement pour l'assemblage uniquement
const DdlElement & TableauDdlCont() const {return *ddlElement_assemblage;};
// ramene le noeud esclave
inline Noeud* Esclave() { return noeud;};
inline const Noeud* Const_Esclave() const { return noeud;};
// ramene la force de contact pour consultation
const Coordonnee& Force_contact() const {return force_contact;};
// ramène les maxis concernant le noeud esclave
double F_N_MAX() const {return F_N_max;};
double F_T_MAX() const {return F_T_max;};
// ramène la pénalisation actuelle éventuelle
const double& Penalisation() const {return penalisation;};
const double& Penalisation_tangentielle() const {return penalisation_tangentielle;};
// ramène le déplacement tangentiel actuel
const Coordonnee& Dep_tangentiel() const {return dep_tangentiel;};
// ramène la normale actuelle
const Coordonnee& Normale_actuelle() const {return N;};
// idem pour les réactions sur les noeuds de la facette
const Tableau <Coordonnee>& TabForce_cont() const {return tabForce_cont;};
// actualisation de la projection du noeud esclave en fonction de la position de l'element
// maitre frontiere. Lorsque le noeud change d'element fontiere, on change l'element
// frontiere de l'element de contact en consequence
// dans le cas ou on ne trouve pas d'intersection, cas d'un noeud qui sort d'une zone de
// contact, on retourne 0, sinon retourne 1 si on n'a pas changé de frontière
// retourne 2 si on a changé de frontière
// en fonction de la méthode de contact, le noeud est ramené éventuellement sur la frontière
int Actualisation();
// ramene un pointeur sur l'element frontiere
inline Front * Elfront() const { return elfront;};
// permet de changer le deplacement maxi de tous les noeuds, qui sert
// pour éviter de considérer des contact trop éloignés
static void Change_dep_max(const double & deplac_max)
{dep_max = deplac_max * ParaGlob::param->ParaAlgoControleActifs().FacPourRayonAccostage();};
// test et met à jour le compteur de décollage du noeud
// si le noeud decolle ou non en fonction de la force de reaction
// ramene 1: s'il decolle
// 0: s'il ne décolle pas
bool Decol();
// change force: permet de changer la valeur de la force
// utile quand la force est calculée en dehors de l'élément de contact
void Change_force(const Coordonnee& force);
// idem pour les forces réparties sur la facette
void Change_TabForce_cont(const Tableau <Coordonnee>& tab) {tabForce_cont=tab;};
// gestion de l'activité
int Actif() const {return actif;}; // ramène l'activité du contact
void Met_Inactif() { actif = 0;nb_decol_tdt=0;
#ifdef MISE_AU_POINT
if (Permet_affichage() > 2)
{cout << "\n inactivation du contact: ";this->Affiche(1);};
#endif
}; // met en inactif
void Met_actif() { actif++;nb_decol_tdt=0;
#ifdef MISE_AU_POINT
if (Permet_affichage() > 2)
{cout << "\n activation du contact: ";this->Affiche(1);};
#endif
}; // met en actif une fois de plus
// ramène le nombre actuel de décolement
int Nb_decol() const {return nb_decol_tdt;};
// ramène le nombre de pénétration actuel
int Nb_pene() const {return nb_pene_tdt;};
// --- calcul des puissances virtuelles développées par les efforts de contact ----------
// et eventuellement calcul de la raideur associé
// -> explicite à tdt
virtual Vecteur* SM_charge_contact();
// -> implicite,
virtual Element::ResRaid SM_K_charge_contact();
// récupération des énergies intégrées sur l'éléments, résultants d'un précédent calcul
// explicite, ou implicite:
// 1- il s'agit ici de l'énergie développée par le frottement glissant ou pas
const EnergieMeca& EnergieFrottement() const {return energie_frottement;};
// 2- énergie de pénalisation (élastique a priori)
const double& EnergiePenalisation() const {return energie_penalisation;};
// cas d'une méthode avec pénalisation: calcul éventuel d'un pas de temps idéal,
// permettant de limiter la pénétration
// si oui retour de la valeur delta_t proposé
// sinon dans tous les autres cas retour de 0.
// le calcul se fait en fonction du pas de temps courant et de la pénétration
// donc nécessite que le contact ait déjà été étudié
double Pas_de_temps_ideal()const;
// ramène l'info sur le fait que le contact est avec un solide ou pas
// retour = 0 : contact bi déformable,
// = 1 le noeud est libre et la frontière est bloqué (solide)
// = 2 le noeud est bloqué (solide) la frontière est libre
// = 3: tout est bloqué (solide)
int Cas_solide() const {return cas_solide;};
// permet de modifier le contact entre collant ou non suivant "change"
void Change_contact_collant(bool change);
// récup de l'information concernant le contact collant ou pas
int Collant() const {return cas_collant;};
// gestion du lissage du lissage de la normale
void Change_lissage_normale(int lissage)
{normale_lisser = lissage;};
// récup de l'information
// indique si la normale doit-être lissée sur l'élément frontière, ou non
int Lissage_normale() const {return normale_lisser;};
// récup des gaps calculés
const double & Gaptdt() const {return gap_tdt;};
const double & Dep_T_tdt() const {return dep_T_tdt;}
// mise à jour du niveau de commentaire
static void Mise_a_jour_niveau_commentaire()
{niveau_commentaire = ParaGlob::param->ParaAlgoControleActifs().Niveau_commentaire_contact();};
// récupération des ddl ou des grandeurs actives de tdt vers t
void TdtversT();
// actualisation des ddl et des grandeurs actives de t vers tdt
void TversTdt();
//----- lecture écriture de restart -----
void Lec_base_info_ElContact(ifstream& ent);
void Ecri_base_info_ElContact(ofstream& sort);
protected :
// VARIABLES PROTEGEES :
int actif; // un indicateur, disant si le contact est actif ou pas
// conteneur plutôt utilisé par les classes appelantes
// =1 -> premier contact, > 1 contact qui suit un contact
// ... elfront, noeud, tabNoeud : peuvent changer d'affectation sur le pas
// pour pouvoir revenir au temps t, on définit les valeurs à t
Front* elfront, * elfront_t; // un element frontiere , qui est créé par l'élément de contact
// et qui correspond à une copie d'un élément frontière qui existe par ailleurs
// en fait, qui existe dans LesContacts
Noeud * noeud, * noeud_t; // un pointeur de noeud
// pour éviter de le construire à chaque demande on définit un tableau de tous les noeuds
Tableau <Noeud*> tabNoeud, tabNoeud_t; // tableau de tous les noeud, le premier est noeud
int num_zone_contact; // un stockage uniquement utilisé par les méthodes appelantes
// le tableau des positions successives du noeud esclave, ceci pour effectuer une moyenne glissante
Tableau <Coordonnee> tab_posi_esclave;
// le nombre courant de positions de noeuds esclaves actuellement stockées
int nb_posi_esclave_stocker_t,nb_posi_esclave_stocker_tdt;
// indice dans tab_posi_esclave, du prochain stockage
int indice_stockage_glissant_t,indice_stockage_glissant_tdt;
Coordonnee Mtdt,Mt; // sauvegarde du point d'intercection s'il est recevable
Coordonnee M_noeud_tdt_avant_projection; // dans le cas d'une projection du noeud sur la surface maître
// sauvegarde des coordonnées du noeuds esclave: utilisation avec le type de contact 4
// les fonctions d'interpolation au premier point en contact: sert pour le contact collant
Vecteur phi_theta_0 ; // *** il faut sauvegarder également la frontière correspondante
EnergieMeca energie_frottement; // énergie développée par le frottement glissant ou pas
double energie_penalisation; // énergie due à la pénalisation (élastique a priori)
// cas_solide permet de simplifier le contact dans le cas ou le maître ou l'esclave est solide
// sert pour diminuer la taille de la raideur uniquement
int cas_solide; // =0 contact bi déformable, =1 le noeud est libre et la frontière est bloqué (solide)
// = 2 le noeud est bloqué (solide) la frontière est libre
// = 3 tout est solide
int cas_collant; // prise en compte éventuelle d'un contact collant, si 0: contact normal
// = 1 : contact collant
int normale_lisser; // indique si la normale doit-être lissée sur l'élément, ou non
int nb_change_frontiere; // totalise sur un incrément le nb de fois de changement de front
// sert à éviter les flip flop en implicite
Vecteur * residu; // residu local
Mat_pleine * raideur; // raideur locale
DdlElement * ddlElement_assemblage; // le ddlElement qui correspond
Tableau <Noeud*> tabNoeud_pour_assemblage; // tableau des noeuds qui servent pour l'assemblage
Coordonnee force_contact,force_contact_t; // force de contact sur le noeud principal
double F_N_max,F_T_max,F_N_max_t,F_T_max_t; // les maxis constatés
Tableau <Coordonnee> tabForce_cont,tabForce_cont_t; // le tableau des forces sur les noeuds de la facette
Coordonnee N; // la dernière normale calculée
Coordonnee dep_tangentiel; // le dernier déplacement tangentiel calculé
int nb_decol_t,nb_decol_tdt; // nombre de fois où le noeud décolle de manière consécutive
double gap_t,gap_tdt; // les pénétrations d'un pas à l'autre
double dep_T_t, dep_T_tdt; // les valeurs absolue des déplacements tangentiels d'un pas à l'autre
double nb_pene_t,nb_pene_tdt; // le nombre de penetration positives
// cas TypeCalculPenalisationPenetration() = 4 ou -4
// -> cas d'un facteur multiplicatif évolutif, on fait une moyenne glissante de 2
// on mémorise donc les facteurs multiplicatifs successifs
double mult_pene_t,mult_pene_tdt;
// cas TypeCalculPenalisationTangentielle() = 4 ou -4
// -> cas d'un facteur multiplicatif évolutif, on fait une moyenne glissante de 2
// on mémorise donc les facteurs multiplicatifs successifs
double mult_tang_t,mult_tang_tdt;
double penalisation,penalisation_tangentielle; // on sauvegarde la pénalisation
// l'intérêt est de pouvoir la visualiser
double penalisation_t,penalisation_tangentielle_t; // les grandeurs à t
// utilisation de fct nD
Fct_nD_contact fct_nD_contact;
// pour le contact 4, pour le calcul de la pénalisation avec une moyenne glissante
Tableau <double > val_penal; // tableau de stockage intermédiaire
int pt_dans_val_penal; // indice du prochain elem du tableau a remplir
// stocke le dernier type de trajectoire du noeud par rapport à la facette
// c-a-d la valeur de la variable test dans la fonction Trajectoire(int & test)
int type_trajectoire_t,type_trajectoire_tdt;
// concernant les enum de ddl associées aux éléments de contact, on définit un tableau global
// qui est utilisé par tous les éléments
static list <DdlElement> list_Ddl_global; // liste de tous les DdlElements des éléments de contact
static list <Vecteur> list_SM; // list de seconds membres locals: sert pour tous les éléments de contact
static list <Mat_pleine> list_raideur; // list de raideurs locales: " " " "
// stockage du maximum de distance tolérée entre noeud à tdt et le projeté, sert pour éliminer les contacts aberrants
static double dep_max;
static int niveau_commentaire;
// stockage d'une fonction nD pour le pilotage du type de contact 4
static Fonction_nD * fct_pilotage_contact4;
// METHODES PROTEGEES :
// calcul la normal en fonction de differente conditions
Coordonnee Calcul_Normale (int dim, Plan & pl, Droite & dr,int indic);
void Libere();
// construction du tableau de tous les noeuds, le premier est celui esclave
// et mise à jour de ddlElement et de list_Ddl_global éventuellement
// et mise à jour des grandeurs liées à elfront: concerne le dimensionnement
// si on change d'elfront -> peut changer le nombre de noeud maître d'où
// il faut redimensionner: tabForce_cont,tabForce_cont_t;
void Construction_TabNoeud();
// récupération d'informations des classes internes pour le calcul du résidu
// N: le vecteur normal
// M_impact: le point d'impact sur la surface (ou ligne)
// phii : les fonctions d'interpolation au point d'impact
// si avec_var est vrai: il y a retour du tableau de variation de la normale
Tableau <Coordonnee >* RecupInfo(Coordonnee& N,Coordonnee& M_impact,Vecteur& phii,bool avec_var );
// mise à jour de cas_solide et donc de ddlElement en fonction de l'activité des ddl
// mise à jour du tableau de noeud pour l'assemblage tabNoeud_pour_assemblage
void Mise_a_jour_ddlelement_cas_solide_assemblage();
// récup d'une place pour le résidu local et mise à jour de list_SM éventuellement
void RecupPlaceResidu(int nbddl);
// récup d'une place pour la raideur locale et mise à jour de list_raideur éventuellement
void RecupPlaceRaideur(int nbddl);
// calcul du facteur de pénalisation en pénétration, en fonction de la géométrie
// du module de compressibilité et des différents possibles
// éventuellement, calcul de la dérivée: d_beta_gapdu, du facteur par rapport au gap
// la sensibilité dépend du type de calcul du facteur de pénalisation
double CalFactPenal(const double& gap,double & d_beta_gap,int contact_type);
// calcul du facteur de pénalisation tangentielle, en fonction de la géométrie
// du module de compressibilité et des différents cas possibles
// éventuellement, calcul de la dérivée: d_beta_gapdu, du facteur par rapport au gap
// la sensibilité dépend du type de calcul du facteur de pénalisation
double CalFactPenalTangentiel(const double& gap,double & d_beta_gap);
// limitation éventuelle au niveau de la pénétration maxi
//void Limitation_penetration_maxi(
// calcul éventuel de la moyenne glissante des positions successive du noeud esclave
void ChangeEnMoyGlissante(Coordonnee& Noe_atdt);
// calcul de la moyenne glissante de la pénalisation
void Moyenne_glissante_penalisation(double& penalisation, double& essai_penalisation);
// calcul d'une fonction nD relative à des données de contact
double Valeur_fct_nD(Fonction_nD * fct_nD,Tableau < TypeQuelconque * >& tqi
,Tableau < const TypeQuelconque * >& tqii,Tableau <int>& t_num_ordre ) const;
};
/// @} // end of group
#endif