1247 lines
57 KiB
C++
Executable file
1247 lines
57 KiB
C++
Executable file
|
|
// 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-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 <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
|
|
#include "LesContacts.h"
|
|
#include <vector>
|
|
#include "ReferenceNE.h"
|
|
#include "ReferenceAF.h"
|
|
#include "CharUtil.h"
|
|
|
|
#include "Enum_TypeQuelconque.h"
|
|
#include "TypeQuelconqueParticulier.h"
|
|
|
|
|
|
|
|
// récupération des ddl ou des grandeurs actives de tdt vers t
|
|
void LesContacts::TdtversT()
|
|
{ LaLIST <ElContact>::iterator il,ilfin=listContact.end();
|
|
for (il=listContact.begin();il != ilfin; il++)
|
|
(*il).TdtversT();
|
|
// on nettoie les indicateurs transitoires
|
|
listContact_nouveau_tatdt.clear();
|
|
listContact_efface_tatdt.clear();
|
|
};
|
|
|
|
// actualisation des ddl et des grandeurs actives de t vers tdt
|
|
void LesContacts::TversTdt()
|
|
{ // on essaie de mettre la situation de contact comme elle était à t
|
|
// a) on supprime les nouveaux contacts
|
|
{LaLIST <LaLIST <ElContact>::iterator>::iterator al,alfin=listContact_nouveau_tatdt.end();
|
|
for (al=listContact_nouveau_tatdt.begin();al != alfin; al++)
|
|
{ ElContact& elc = (*(*al));
|
|
Noeud* no = elc.Esclave();
|
|
int n_noee = no->Num_noeud();
|
|
int num_mail_noe_esclave = no->Num_Mail();
|
|
#ifdef MISE_AU_POINT
|
|
if (tesN_encontact(num_mail_noe_esclave).find(no)
|
|
== tesN_encontact(num_mail_noe_esclave).end() )
|
|
{ cout << "\n*** Erreur : on ne trouve pas la liste d'element en contact avec le noeud esclave "
|
|
<< n_noee << " du maillage " << num_mail_noe_esclave
|
|
<< " la suite n'est pas possible "
|
|
<< " LesContacts::TversTdt(.. \n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
LaLIST < LaLIST<ElContact>::iterator > & list_tesN
|
|
= tesN_encontact(num_mail_noe_esclave)[no];
|
|
list_tesN.remove(*al);
|
|
// tesN_encontact(num_mail_noe_esclave)(n_noee).remove(*al);
|
|
if (elc.Actif()) //a priori les nouveaux contacts étaient actif
|
|
nb_contact_actif--; // mais on ne sait jamais
|
|
listContact.erase(*al);
|
|
// cout << "\n debug toto ";
|
|
};
|
|
};
|
|
// b) on rajoute les contacts supprimés
|
|
{LaLIST <ElContact>::iterator al,alfin=listContact_efface_tatdt.end();
|
|
for (al=listContact_efface_tatdt.begin();al != alfin; al++)
|
|
{ ElContact& elc = (*al);
|
|
Noeud* no = elc.Esclave();
|
|
int n_noee = no->Num_noeud();
|
|
int num_mail_noe_esclave = no->Num_Mail();
|
|
listContact.push_front(*al);
|
|
// on met à jour le tableau tesN_encontact
|
|
#ifdef MISE_AU_POINT
|
|
if (tesN_encontact(num_mail_noe_esclave).find(no)
|
|
== tesN_encontact(num_mail_noe_esclave).end() )
|
|
{ cout << "\n*** Erreur : on ne trouve pas la liste d'element en contact avec le noeud esclave "
|
|
<< n_noee << " du maillage " << num_mail_noe_esclave
|
|
<< " la suite n'est pas possible "
|
|
<< " LesContacts::TversTdt(.. \n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
tesN_encontact(num_mail_noe_esclave)[no].push_front(listContact.begin());
|
|
if ((*al).Actif()) // si l'élément supprimé était actif on remet à jour
|
|
nb_contact_actif++;
|
|
};
|
|
};
|
|
// c) on nettoie les indicateurs transitoires
|
|
listContact_nouveau_tatdt.clear();
|
|
listContact_efface_tatdt.clear();
|
|
// d) on revient à t pour les éléments en contact
|
|
{LaLIST <ElContact>::iterator il,ilfin=listContact.end();
|
|
for (il=listContact.begin();il != ilfin; il++)
|
|
(*il).TversTdt();
|
|
};
|
|
};
|
|
|
|
|
|
// cas d'une méthode avec pénalisation: calcul éventuel d'un pas de temps idéal,
|
|
// 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 LesContacts::Pas_de_temps_ideal()const
|
|
{ double delta_optimal=ConstMath::tresgrand;
|
|
// on passe en revue tous les contacts
|
|
LaLIST <ElContact>::const_iterator il,ilfin=listContact.end();
|
|
for (il=listContact.begin();il != ilfin; il++)
|
|
{ double dtelem_optimal = (*il).Pas_de_temps_ideal();
|
|
if (dtelem_optimal != 0.)
|
|
delta_optimal = MiN(delta_optimal, dtelem_optimal);
|
|
};
|
|
// retour du temps proposé
|
|
if (delta_optimal==ConstMath::tresgrand)
|
|
// cela veut dire qu'il n'a pas été modifié, on le met à 0 pour indiquer que l'on a rien
|
|
// n'a proposer
|
|
delta_optimal = 0.;
|
|
return delta_optimal;
|
|
};
|
|
|
|
// écriture base info
|
|
// cas donne le niveau de sauvegarde
|
|
void LesContacts::Ecri_base_info_LesContacts(ofstream& sort)
|
|
{ // globalement on sauvegarde toujours tout, car les éléments de contact peuvent apparaître à tout moment
|
|
// tout d'abord on indique le type
|
|
sort << "\n LesContacts: taille " << listContact.size() << " " ;
|
|
// NB: le nombre de maillages esclave et en auto-contact, peut-être redéfinit lors d'un restart
|
|
// donc n'est pas sauvegardé
|
|
// ensuite on sauvegarde la liste des éléments de contact: en fait tout d'abord les infos
|
|
// qui permettent de construire un élément ad hoc, et ensuite les infos spécifiques internes à l'élément
|
|
for (LaLIST <ElContact>::iterator ic = listContact.begin();ic != listContact.end(); ic++)
|
|
{// les infos permettants de contruire l'élément de contact: on considère que les numéros des noeuds, maillages, éléments
|
|
// restent identiques, par contre on peut avoir d'un échange des zones de restriction de contact d'une sauvegarde à un restart
|
|
sort << "\nN_es " << (*ic).Esclave()->Num_Mail() <<" " << (*ic).Esclave()->Num_noeud(); // le noeud esclave
|
|
Front * elfront = (*ic).Elfront();
|
|
sort << " El " << elfront->NumMail() << " " << elfront->PtEI()->Num_elt_const() << " "
|
|
<< elfront->Eleme()->Type_geom_front() << " "<< elfront->Num_frontiere() ; // la frontière
|
|
// les infos spécifiques éventuelles
|
|
(*ic).Ecri_base_info_ElContact(sort);
|
|
};
|
|
sort << "\n tps_rech_contact: "<<tempsContact;
|
|
};
|
|
|
|
|
|
// Il s'agit ici de mettre à jour les conteneurs stockés aux noeuds et/ou aux éléments
|
|
// qui servent à récupérer les infos liés aux contact correspondant à liTQ
|
|
// actuellement les conteneurs passés en paramètre ne servent que pour
|
|
// les énumérés, et les informations résultantes sont stockées au niveau des noeuds
|
|
// constituant les éléments de contact
|
|
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
|
|
//--> important : les conteneurs sont supposés initialisés avec l'appel
|
|
void LesContacts::Mise_a_jour_Pour_Grandeur_particuliere(
|
|
List_io < TypeQuelconque >& li_restreinte_TQ
|
|
)
|
|
{
|
|
LaLIST<ElContact>::iterator ili_deb= listContact.begin();
|
|
LaLIST<ElContact>::iterator ilifin= listContact.end();
|
|
LaLIST<ElContact>::iterator ili;
|
|
|
|
// on passe en revue la liste de quelconque
|
|
{List_io<TypeQuelconque>::iterator itq,itqfin=li_restreinte_TQ.end();
|
|
for (itq=li_restreinte_TQ.begin();itq!=itqfin;itq++)
|
|
{const TypeQuelconque_enum_etendu& enuTypeQuelconque = (*itq).EnuTypeQuelconque();
|
|
if (enuTypeQuelconque.Nom_vide()) // veut dire que c'est un enum pur
|
|
switch (enuTypeQuelconque.EnumTQ())
|
|
{ case NOEUD_PROJECTILE_EN_CONTACT:
|
|
{// ----- cas des noeuds projectiles en contact
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
// on attribue une grandeur arbitraire de 100 aux noeuds pour un contact actif
|
|
// pour les éléments de contact inactif -> -0.1
|
|
// un noeud peut être plusieurs fois en contact -> les nombres sont cumulées
|
|
// on fait l'hypothèse qu'un ne sera jamais inactif plus de 99 fois, du coup
|
|
// en regardant le nombre modulo 100 on peut en déduire le nombre d'inactivité
|
|
// et en regardant le nombre de centaine on en déduit le nombre de contact
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) += 100.; }
|
|
else
|
|
{*(tyTQ.ConteneurDouble()) -= 0.1; }
|
|
};
|
|
break;
|
|
}
|
|
case NOEUD_FACETTE_EN_CONTACT:
|
|
{// ----- cas des noeuds facettes en contact
|
|
// on parcours la liste des éléments de contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
// on attribue une grandeur arbitraire de 100 aux noeuds pour un contact actif
|
|
// pour les éléments de contact inactif -> -0.1
|
|
// un noeud peut être plusieurs fois en contact -> les nombres sont cumulées
|
|
// on fait l'hypothèse qu'un ne sera jamais inactif plus de 99 fois, du coup
|
|
// en regardant le nombre modulo 100 on peut en déduire le nombre d'inactivité
|
|
// et en regardant le nombre de centaine on en déduit le nombre de contact
|
|
Tableau <Noeud*>& tablN = elcont.TabNoeud();
|
|
int NBNF=tablN.Taille();
|
|
// on boucle sur les noeuds de la facette (le premier noeud = noeud esclave)
|
|
if (elcont.Actif())
|
|
{for (int i=2;i<=NBNF;i++)
|
|
{TypeQuelconque& tyqN = tablN(i)->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
*(tyTQ.ConteneurDouble()) += 100.;
|
|
}
|
|
}
|
|
else
|
|
{for (int i=2;i<=NBNF;i++)
|
|
{TypeQuelconque& tyqN = tablN(i)->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
*(tyTQ.ConteneurDouble()) -= 0.1;
|
|
}
|
|
};
|
|
};
|
|
break;
|
|
}
|
|
case PENETRATION_CONTACT:
|
|
{// ----- cas des noeuds projectiles en contact
|
|
// on parcours la liste des élément en contact
|
|
// on cumule s'il y a plusieurs contacts
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_coordonnee& tyTQ= *((Grandeur_coordonnee*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{// on définit un vecteur au niveau du noeud en contact, qui part du noeud
|
|
// projectile et va au point d'impact
|
|
const Coordonnee& Mtdt = elcont.Point_intersection();
|
|
*(tyTQ.ConteneurCoordonnee()) += Mtdt - elcont.Esclave()->Coord2();
|
|
}; // sinon on ne fait rien
|
|
};
|
|
break;
|
|
}
|
|
case GLISSEMENT_CONTACT:
|
|
{// ----- cas des noeuds projectiles en contact
|
|
// on parcours la liste des élément en contact
|
|
// on cumule s'il y a plusieurs contacts
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_coordonnee& tyTQ= *((Grandeur_coordonnee*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{// on définit un vecteur au niveau du noeud en contact, qui part du noeud
|
|
// projectile et va au point d'impact
|
|
*(tyTQ.ConteneurCoordonnee()) += elcont.Dep_tangentiel();
|
|
}; // sinon on ne fait rien
|
|
};
|
|
break;
|
|
}
|
|
case NORMALE_CONTACT:
|
|
{// ----- cas des noeuds projectiles en contact
|
|
// on parcours la liste des élément en contact
|
|
// on cumule s'il y a plusieurs contacts
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_coordonnee& tyTQ= *((Grandeur_coordonnee*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{// on définit un vecteur au niveau du noeud en contact, qui part du noeud
|
|
// projectile et va au point d'impact
|
|
*(tyTQ.ConteneurCoordonnee()) += elcont.Normale_actuelle();
|
|
}; // sinon on ne fait rien
|
|
};
|
|
break;
|
|
}
|
|
case FORCE_CONTACT:
|
|
{// ----- cas des noeuds projectiles en contact
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_coordonnee& tyTQ= *((Grandeur_coordonnee*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{// on récupère la force de contact
|
|
*(tyTQ.ConteneurCoordonnee()) += elcont.Force_contact();
|
|
}; // sinon on ne fait rien
|
|
};
|
|
break;
|
|
}
|
|
case CONTACT_PENALISATION_N:
|
|
{// ----- on attribue la pénalisation au noeud projectile
|
|
// on met la pénalisation totale s'il y a plusieurs contacts
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) += elcont.Penalisation(); };
|
|
};
|
|
break;
|
|
}
|
|
case CONTACT_PENALISATION_T:
|
|
{// ----- on attribue la pénalisation au noeud projectile
|
|
// on met la pénalisation totale s'il y a plusieurs contacts
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) += elcont.Penalisation_tangentielle(); };
|
|
};
|
|
break;
|
|
}
|
|
case CONTACT_ENERG_PENAL:
|
|
{// ----- on attribue l'énergie de pénalisation au noeud projectile
|
|
// on met l'énergie totale s'il y a plusieurs contacts
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) += elcont.EnergiePenalisation(); };
|
|
};
|
|
break;
|
|
}
|
|
case CONTACT_ENERG_GLISSE_ELAS:
|
|
{// ----- on attribue l'énergie de pénalisation au noeud projectile
|
|
// on met l'énergie totale s'il y a plusieurs contacts
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) += elcont.EnergieFrottement().EnergieElastique(); };
|
|
};
|
|
break;
|
|
}
|
|
case CONTACT_ENERG_GLISSE_PLAS:
|
|
{// ----- on attribue l'énergie de pénalisation au noeud projectile
|
|
// on met l'énergie totale s'il y a plusieurs contacts
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) += elcont.EnergieFrottement().DissipationPlastique(); };
|
|
};
|
|
break;
|
|
}
|
|
case CONTACT_ENERG_GLISSE_VISQ:
|
|
{// ----- on attribue l'énergie de pénalisation au noeud projectile
|
|
// on met l'énergie totale s'il y a plusieurs contacts
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) += elcont.EnergieFrottement().DissipationVisqueuse(); };
|
|
};
|
|
break;
|
|
}
|
|
case CONTACT_NB_DECOL:
|
|
{// ----- on attribue le nombre de décolement au noeud projectile
|
|
// on met le totale s'il y a plusieurs contacts
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) += elcont.Nb_decol(); };
|
|
};
|
|
break;
|
|
}
|
|
case CONTACT_COLLANT:
|
|
{// ----- on attribue le fait d'être collant ou pas au noeud projectile
|
|
// on met le totale s'il y a plusieurs contacts
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) += elcont.Collant(); };
|
|
};
|
|
break;
|
|
}
|
|
case NUM_ZONE_CONTACT:
|
|
{// ----- on attribue le numéro de zone de contact au noeud projectile
|
|
// on met le totale s'il y a plusieurs contacts
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) += elcont.Num_zone_contact(); };
|
|
};
|
|
break;
|
|
}
|
|
case CONTACT_NB_PENET:
|
|
{// ----- on attribue le nombre de décolement au noeud projectile
|
|
// on met le totale s'il y a plusieurs contacts
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) += elcont.Nb_pene(); };
|
|
};
|
|
break;
|
|
}
|
|
case CONTACT_CAS_SOLIDE:
|
|
{// ----- on attribue le nombre au noeud projectile
|
|
// =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
|
|
|
|
// ici on ne met pas le totale s'il y a plusieurs contacts !!
|
|
// c'est le dernier élément qui contient le noeud projectile, qui donne le résultat
|
|
|
|
// on parcours la liste des élément en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact & elcont = (*ili); // pour simplifier
|
|
TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
|
|
Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
|
|
tyqN.Grandeur_pointee());
|
|
if (elcont.Actif())
|
|
{*(tyTQ.ConteneurDouble()) = elcont.Cas_solide(); };
|
|
};
|
|
break;
|
|
}
|
|
|
|
default: ;// on ne fait rien
|
|
};
|
|
|
|
};
|
|
};
|
|
|
|
|
|
};
|
|
|
|
// récupération de la liste de tous les grandeurs particulières disponibles avec le contact
|
|
// cette liste est identique quelque soit le maillage: il n'y a donc pas de tableau indicé du num de maillage
|
|
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
|
|
List_io<TypeQuelconque> LesContacts::ListeGrandeurs_particulieres(bool absolue) const
|
|
{
|
|
// def de la liste de retour
|
|
List_io <TypeQuelconque> liTQ;
|
|
|
|
// on ne ramène les infos que si le contact est actif
|
|
if (ParaGlob::param->ParaAlgoControleActifs().ContactType()!= 0)
|
|
{
|
|
// grandeurs de travail
|
|
int dim = ParaGlob::Dimension();
|
|
|
|
// ici on est en 3D et les grandeurs sont par principe en absolue, donc la variable absolue ne sert pas
|
|
Grandeur_scalaire_double grand_courant(0.);
|
|
|
|
Coordonnee inter(dim);
|
|
Grandeur_coordonnee grand_coor_courant(inter);
|
|
|
|
// def d'un type quelconque représentatif à chaque grandeur
|
|
// a priori ces grandeurs sont défini aux noeuds
|
|
//on regarde si ce type d'info existe déjà: si oui on augmente la taille du tableau, si non on crée
|
|
// $$$ cas de la visualisation des noeuds projectiles en contact
|
|
{TypeQuelconque typQ1(NOEUD_PROJECTILE_EN_CONTACT,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
// $$$ cas de la visualisation des noeuds des facettes en contact
|
|
{TypeQuelconque typQ1(NOEUD_FACETTE_EN_CONTACT,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
// $$$ cas de la visualisation du glissement des noeuds projectiles actifs
|
|
{TypeQuelconque typQ1(GLISSEMENT_CONTACT,X1,grand_coor_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
// $$$ cas de la visualisation du glissement des noeuds projectiles actifs
|
|
{TypeQuelconque typQ1(NORMALE_CONTACT,X1,grand_coor_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
// $$$ cas de la visualisation de la pénétration en contact
|
|
{TypeQuelconque typQ1(PENETRATION_CONTACT,X1,grand_coor_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
// $$$ cas de la visualisation des forces de contact
|
|
{TypeQuelconque typQ1(FORCE_CONTACT,X1,grand_coor_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
// $$$ nombre de pénétration
|
|
{TypeQuelconque typQ1(CONTACT_NB_PENET,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
// $$$ nombre de décolement
|
|
{TypeQuelconque typQ1(CONTACT_NB_DECOL,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
// $$$ cas_solide
|
|
{TypeQuelconque typQ1(CONTACT_CAS_SOLIDE,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
{TypeQuelconque typQ1(CONTACT_ENERG_PENAL,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
{TypeQuelconque typQ1(CONTACT_ENERG_GLISSE_ELAS,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
{TypeQuelconque typQ1(CONTACT_ENERG_GLISSE_PLAS,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
{TypeQuelconque typQ1(CONTACT_ENERG_GLISSE_VISQ,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
{TypeQuelconque typQ1(CONTACT_PENALISATION_N,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
{TypeQuelconque typQ1(CONTACT_PENALISATION_T,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
{TypeQuelconque typQ1(CONTACT_COLLANT,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
{TypeQuelconque typQ1(NUM_ZONE_CONTACT,X1,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
};
|
|
|
|
// retour
|
|
return liTQ;
|
|
|
|
};
|
|
|
|
|
|
// concernant les grandeurs gérées par le contact:
|
|
// ramène une liste d'enuméré correspondant aux List_io<TypeQuelconque> passé en paramètre
|
|
// idem pour une List_io < Ddl _enum_etendu >
|
|
void LesContacts::List_reduite_aux_contact(const List_io<TypeQuelconque>& liTQ
|
|
,List_io < TypeQuelconque >& li_restreinte_TQ
|
|
)
|
|
{
|
|
// initialisation des listes de retour
|
|
li_restreinte_TQ.clear();
|
|
// on passe en revue la liste
|
|
List_io<TypeQuelconque>::const_iterator itq,itqfin=liTQ.end();
|
|
for (itq=liTQ.begin();itq!=itqfin;itq++)
|
|
{const TypeQuelconque& tipParticu = (*itq); // pour simplifier
|
|
const TypeQuelconque_enum_etendu& enuTypeQuelconque = tipParticu.EnuTypeQuelconque();
|
|
if (enuTypeQuelconque.Nom_vide()) // veut dire que c'est un enum pur
|
|
switch (enuTypeQuelconque.EnumTQ())
|
|
{ case NOEUD_PROJECTILE_EN_CONTACT: case NOEUD_FACETTE_EN_CONTACT:
|
|
case PENETRATION_CONTACT: case FORCE_CONTACT:
|
|
case CONTACT_PENALISATION_N: case CONTACT_PENALISATION_T:
|
|
case CONTACT_ENERG_PENAL: case NORMALE_CONTACT:
|
|
case GLISSEMENT_CONTACT: case CONTACT_ENERG_GLISSE_ELAS:
|
|
case CONTACT_ENERG_GLISSE_VISQ: case CONTACT_ENERG_GLISSE_PLAS:
|
|
case CONTACT_NB_DECOL: case CONTACT_NB_PENET:
|
|
case CONTACT_CAS_SOLIDE: case CONTACT_COLLANT:
|
|
case NUM_ZONE_CONTACT:
|
|
{// ----- cas des noeuds projectiles en contact
|
|
li_restreinte_TQ.push_front(TypeQuelconque(tipParticu));
|
|
break;
|
|
}
|
|
default: ;// on ne fait rien
|
|
};
|
|
};
|
|
};
|
|
|
|
// initialisation des listes de grandeurs qu'ils faudra transférérer aux niveaux des noeuds des élements
|
|
// de contact, on définit si besoin, les conteneurs ad hoc au niveau des noeuds
|
|
void LesContacts::Init_Grandeur_particuliere (bool absolue,List_io<TypeQuelconque>& liTQ)
|
|
{liQ_en_sortie = liTQ; // on récupère la liste --> sans doute que cela ne sert à rien
|
|
|
|
LaLIST<ElContact>::iterator ili_deb= listContact.begin();
|
|
LaLIST<ElContact>::iterator ilifin= listContact.end();
|
|
LaLIST<ElContact>::iterator ili;
|
|
|
|
// on passe en revue la liste
|
|
List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end();
|
|
// on part du principe qu'il y a plus de noeuds en contact que de grandeur donc on fait une
|
|
// boucle externe sur les noeuds en contact: on parcours la liste des noeuds en contact
|
|
for (ili=ili_deb;ili!=ilifin;ili++)
|
|
{ElContact& elcont = (*ili); // pour simplifier
|
|
for (itq=liTQ.begin();itq!=itqfin;itq++)
|
|
{TypeQuelconque& tipParticu = (*itq); // pour simplifier
|
|
EnumTypeQuelconque enuTQ = tipParticu.EnuTypeQuelconque().EnumTQ();
|
|
|
|
switch (enuTQ)
|
|
{ case NOEUD_PROJECTILE_EN_CONTACT: case NOEUD_FACETTE_EN_CONTACT:
|
|
case GLISSEMENT_CONTACT: case PENETRATION_CONTACT:
|
|
case FORCE_CONTACT: case CONTACT_NB_PENET:
|
|
case CONTACT_PENALISATION_N: case CONTACT_PENALISATION_T:
|
|
case CONTACT_NB_DECOL: case CONTACT_CAS_SOLIDE:
|
|
case CONTACT_ENERG_PENAL: case CONTACT_COLLANT:
|
|
case NUM_ZONE_CONTACT:
|
|
case NORMALE_CONTACT: case CONTACT_ENERG_GLISSE_ELAS:
|
|
case CONTACT_ENERG_GLISSE_VISQ: case CONTACT_ENERG_GLISSE_PLAS:
|
|
|
|
{// ----- cas des noeuds projectiles en contact
|
|
elcont.Esclave()->AjoutUnTypeQuelconque(*itq); // ajout du conteneur
|
|
break;
|
|
}
|
|
default: ; // sinon rien
|
|
};
|
|
};
|
|
};
|
|
|
|
} ;
|
|
|
|
//========================== fonction protegee =============================
|
|
|
|
// mise à jour des boites d'encombrement pour les éléments qui contiennent une frontière
|
|
void LesContacts::Mise_a_jour_boite_encombrement_element_contenant_front()
|
|
{
|
|
list <Element *>::iterator il,ilfin = liste_elemens_front.end();
|
|
for (il = liste_elemens_front.begin();il!=ilfin;il++)
|
|
(*il)->Boite_encombre_element(TEMPS_tdt);
|
|
|
|
};
|
|
|
|
// suppression du gap de contact pour les noeuds "collant avec suppression de gap"
|
|
void LesContacts::Suppression_gap_pour_noeud_collant()
|
|
{
|
|
int niveau_commentaire_contact = ParaGlob::param->ParaAlgoControleActifs().Niveau_commentaire_contact();
|
|
if (niveau_commentaire_contact == 0) {niveau_commentaire_contact = ParaGlob::NiveauImpression();};
|
|
// on passe en revue les zones de contact et si nécessaire on supprime les gaps
|
|
// sinon retour
|
|
bool continuer = false; // init par défaut
|
|
// list <quatre_string_un_entier> nom_ref_zone_contact; // liste des noms de références des zones de contact
|
|
list <quatre_string_un_entier>::iterator iu,iufin = nom_ref_zone_contact.end();
|
|
for (iu = nom_ref_zone_contact.begin();iu != iufin; iu++)
|
|
if ((*iu).n == 2)
|
|
{continuer = true; break;};
|
|
if (!continuer)
|
|
return;
|
|
|
|
// sinon il faut effectivement faire une suppression de gap
|
|
if (niveau_commentaire_contact > 2)
|
|
cout << "\n >>>> Suppression_gap_pour_noeud_collant : ";
|
|
// on va iterer sur les noeuds esclaves collants dont on veut supprimer le gap
|
|
LaLIST_io <Front>::iterator iM,iMfin; // des itérator de travail
|
|
int nb_zone = MaX(1,nom_ref_zone_contact.size());
|
|
double dist_max = Dabs(ParaGlob::param->ParaAlgoControleActifs().DistanceMaxiAuPtProjete());
|
|
|
|
int tout_projeter = true; // init
|
|
int boucle_maxi = 10; // 10 boucle maxi
|
|
int boucle = 1;
|
|
do
|
|
{ if (niveau_commentaire_contact >2 )
|
|
cout << "\n boucle : "<<boucle << flush;
|
|
for (int intot = 1;intot<= nb_mail_Esclave;intot++) // boucle sur les maillages esclaves
|
|
for (int j=1;j<=nb_zone;j++) // boucle sur les zones de contact
|
|
{const Tableau <Noeud*>& tesc= tesctotal(intot)(j); // pour simplifier la notation:
|
|
const Tableau <int> tesN_col = tesN_collant(intot)(j); // pour simplifier
|
|
int tesc_taille=tesc.Taille(); // tab des noeuds esclaves à considérer
|
|
int compteur_noeuds_projecte=0; // le nombre de noeuds qui sont projetés
|
|
double le_maxi_des_distances_trouve = 0.;
|
|
for (int inesc = 1;inesc<= tesc_taille;inesc++) // boucle sur les noeuds esclaves
|
|
if (tesN_col(inesc) == 2 ) // cas noeud collant avec volonté de supprimer le gap
|
|
{ Noeud* noee = tesc(inesc); // pour simplifier
|
|
//--- debug
|
|
//if (noee->Num_noeud() == 5)
|
|
// {cout << "\n arrivée au bon element ";
|
|
// }
|
|
const Coordonnee pt_esc = noee->Coord0(); // position du noeud esclave initial
|
|
list <Coordonnee > list_P; // la liste des projetés
|
|
list <LaLIST_io <Front>::iterator> li_pt_front_P; // liste sur les faces pour le debug
|
|
for (int jlf=1;jlf<=nbmailMaitre;jlf++) // boucle sur les maillages maitres
|
|
{//Tableau < Tableau < LaLIST_io <Front> > > t_listFront;
|
|
LaLIST_io <Front>& t_l_front = t_listFront(jlf)(j);
|
|
iMfin=t_l_front.end();
|
|
for (iM = t_l_front.begin() ; iM != iMfin; iM++) // boucle sur les front maitres
|
|
{// si c'est dans le volume de la frontière augmenté de la distance ad hoc on test
|
|
// plus précisément
|
|
if ((*iM).In_boite_emcombrement_front(pt_esc,dist_max))
|
|
{// on projete le noeud sur la frontière
|
|
Coordonnee P;
|
|
////--- debug
|
|
//if ((noee->Num_noeud() == 5) && ((*iM).PtEI()->Num_elt()==367))
|
|
// {cout << "\n arrivée au bon element ";
|
|
//
|
|
// }
|
|
//{double Ndis = (P-pt_esc).Norme();
|
|
// if (Ndis > 20)
|
|
// (*iM).Eleme()->Projection_normale(pt_esc,P);
|
|
//}
|
|
//-- fin debug
|
|
|
|
// //----debug
|
|
//{if ((noee->Num_noeud() == 12)
|
|
// && ((*iM).Num_frontiere() == 1) && ((*iM).PtEI()->Num_elt() == 3130))
|
|
// { cout << "\n debug : frontiere 1 de l'element 3130";}
|
|
//}
|
|
////----fin debug
|
|
|
|
// si la projection est valide on enregistre
|
|
if ((*iM).Eleme()->Projection_normale(pt_esc,P))
|
|
{ list_P.push_back(P);
|
|
li_pt_front_P.push_back(iM);
|
|
};
|
|
//--- debug
|
|
//{double Ndis = (P-pt_esc).Norme();
|
|
// if (Ndis > 20)
|
|
// (*iM).Eleme()->Projection_normale(pt_esc,P);
|
|
//}
|
|
//-- fin debug
|
|
|
|
};
|
|
};
|
|
};
|
|
// maintenant on va garder le plus proche
|
|
bool projection_ok = false; // init
|
|
if (list_P.size() != 0)
|
|
{list <Coordonnee >::iterator il,ilfin=list_P.end();
|
|
if (niveau_commentaire_contact >5 )
|
|
{cout << "\n " << list_P.size() << " proj trouvees "
|
|
<< " Noe: "<<noee->Num_noeud()
|
|
<< " mail: " << noee->Num_Mail() << " (zone"<<j<<")";
|
|
};
|
|
Coordonnee M = pt_esc; // init
|
|
Coordonnee P(M); // la projection
|
|
double distance = dist_max;
|
|
LaLIST_io <LaLIST_io <Front>::iterator>::iterator iface = li_pt_front_P.begin();
|
|
LaLIST_io <LaLIST_io <Front>::iterator>::iterator iface_maxi ;
|
|
for (il=list_P.begin(); il!= ilfin;il++,iface++)
|
|
{ double Ndis = (M-(*il)).Norme();
|
|
if (niveau_commentaire_contact >5 )
|
|
cout << " dist: " << Ndis ;
|
|
if (Ndis < distance)
|
|
{P = (*il); distance = Ndis;
|
|
projection_ok = true; // au moins un nouveau point
|
|
iface_maxi = iface;
|
|
};
|
|
};
|
|
// si la distance == 0., il n'y a pas à changer les coordonnées
|
|
// car le point projeté == le point initial
|
|
if (distance > ConstMath::petit)
|
|
{// on change les coordonnées du noeud
|
|
noee->Change_coord0(P);
|
|
noee->Change_coord1(P);
|
|
noee->Change_coord2(P);
|
|
compteur_noeuds_projecte++;
|
|
tout_projeter=false;
|
|
if (distance > le_maxi_des_distances_trouve)
|
|
le_maxi_des_distances_trouve = distance;
|
|
if (niveau_commentaire_contact >3 )
|
|
cout << "\n suppression gap=("<<distance<<") du noeud "<<noee->Num_noeud()
|
|
<< " du maillage " << noee->Num_Mail() << " (zone "<<j<<")";
|
|
if (niveau_commentaire_contact >4 )
|
|
{cout << "\n ancienne coordonnee "<< pt_esc
|
|
<< " nouvelle " << P;
|
|
// dans le cas où iface_maxi a été attribué
|
|
if (projection_ok)
|
|
(*(*iface_maxi)).Affiche();
|
|
|
|
////--- debug
|
|
//{
|
|
//const Coordonnee pt_esc = noee->Coord0();
|
|
//Coordonnee PP;
|
|
//(*(*iface_maxi)).Eleme()->Projection_normale(pt_esc,PP);
|
|
//cout << "\n $$$ nouvelle coordonnees projetee "<< PP;
|
|
//}
|
|
////-- fin debug
|
|
|
|
};
|
|
}
|
|
else if (projection_ok)
|
|
// si on n'a pas de projection avec changement de position
|
|
// mais par contre on a quand même trouvé un projeté on enregistre
|
|
{compteur_noeuds_projecte++;};
|
|
};
|
|
if ((!projection_ok) && (boucle==1)) // au premier passage
|
|
{ if (niveau_commentaire_contact >3 )
|
|
cout << "\n pas de projection trouvee donc de suppression gap du noeud "<<noee->Num_noeud()
|
|
<< " du maillage" << noee->Num_Mail() << " (zone "<<j<<")";
|
|
} ;
|
|
}; //-- fin de la boucle sur inesc
|
|
if (niveau_commentaire_contact >2 )
|
|
{if (compteur_noeuds_projecte)
|
|
cout << "\n zone: " << j <<", " << compteur_noeuds_projecte << " suppression(s) de gap, maxi_distance= "
|
|
<< le_maxi_des_distances_trouve << "( passage"<<boucle<<")" ;
|
|
int non_gap = tesc_taille-compteur_noeuds_projecte;
|
|
if ((non_gap)&& (boucle==1)) // au premier passage
|
|
cout << "\n zone: " << j <<", *** attention pour "<<non_gap
|
|
<< " noeud(s) pas de projection trouvee !! ";
|
|
};
|
|
}; //-- fin de la boucle sur intot
|
|
boucle++;
|
|
}
|
|
while ((!tout_projeter) && (boucle < boucle_maxi));
|
|
// Sortie(1);
|
|
};
|
|
|
|
// récupération de la zone de contact d'un élément de contact existant
|
|
// c'est un peu lourdinge, mais l'avantage c'est que cela s'adapte à une situation qui
|
|
// a par exemple changé
|
|
// si en retour le numéro de zone = 0, cela signifie que le contact ne peut plus exister
|
|
int LesContacts::Recup_ref( ElContact& al)
|
|
{ int nb_zone = MaX(1,nom_ref_zone_contact.size());
|
|
const Tableau <Noeud*>& tn = al.TabNoeud();
|
|
int num_mail_esclave = tn(1)->Num_Mail();
|
|
int num_mail_maitre = tn(2)->Num_Mail();
|
|
int num_noe = tn(1)->Num_noeud();
|
|
|
|
// on parcours la liste des frontières succeptibles d'entrer en contact
|
|
// pour repérer la zone
|
|
int num_zone = 0; // init
|
|
int nb_maitre = t_listFront.Taille();
|
|
int nb_esclave = tesctotal.Taille();
|
|
for (int i=1;i<=nb_maitre;i++)
|
|
{for (int j=1;j<=nb_zone;j++)
|
|
{LaLIST_io <Front> & list_fronta = t_listFront(i)(j); // pour simplifier
|
|
LaLIST_io <Front>::iterator il,ilfin = list_fronta.end();
|
|
for (il = list_fronta.begin();il != ilfin; il++)
|
|
{if ((*il)==(*al.Elfront()))
|
|
// les deux pointeurs pointent sur la même frontière, donc
|
|
// maintenant on regarde du coté des noeuds esclaves
|
|
{ for (int ie = 1; ie<=nb_esclave;ie++)
|
|
{const Tableau <Noeud*>& tesc= tesctotal(i)(j); // pour simplifier la notation:
|
|
int tesc_taille=tesc.Taille(); // tab des noeuds esclaves à considérer
|
|
for (int inesc = 1;inesc<= tesc_taille;inesc++) // boucle sur les noeuds esclaves
|
|
{if (tesc(inesc) == al.Esclave())
|
|
// les deux pointeurs pointent sur le même noeud, c'est ok
|
|
{num_zone = j; break;};
|
|
};
|
|
if (num_zone)
|
|
break;
|
|
};
|
|
};
|
|
if (num_zone)
|
|
break;
|
|
};
|
|
if (num_zone)
|
|
break;
|
|
};
|
|
if (num_zone)
|
|
break;
|
|
};
|
|
// retour des infos
|
|
return num_zone;
|
|
};
|
|
|
|
|
|
// création d'un tableau de condition linéaire, correspondant à tous les éléments de contact en cours
|
|
// qu'ils soient actifs ou pas (a prior cette méthode est conçu pour donner des infos relativement à la largeur
|
|
// de bandes en noeuds due aux CLL)
|
|
// chacune des condition ne contient "d'exploitable" que le tableau de noeuds associés à la CLL,
|
|
const Tableau <Condilineaire>& LesContacts::ConnectionCLL()
|
|
{
|
|
// on boucle sur le tableau et pour chaque element on crée une condition lineaire
|
|
int tabTaille = listContact.size();
|
|
t_connectionCLL.Change_taille(tabTaille);
|
|
// un tableau servant à la def de la CLL
|
|
Tableau <Enum_ddl > t_enu(1); t_enu(1)=X1 ;
|
|
LaLIST <ElContact>::const_iterator il,ilfin=listContact.end();
|
|
int posi=1; // init pour le tableau
|
|
for (il=listContact.begin();il != ilfin;il++,posi++)
|
|
{ const Tableau < Noeud *>& t_n = (*il).Const_TabNoeud();
|
|
// on est dans le cas ou l'on connait les infos relatives uniquements aux noeuds, aux enum ddl
|
|
t_connectionCLL(posi) = Condilineaire(t_enu, t_n);
|
|
};
|
|
|
|
// retour
|
|
return t_connectionCLL;
|
|
};
|
|
|
|
|
|
// récupère le nombre de contact actif et met à jour ce nombre
|
|
// normalement devrait toujours être correct mais ?? il y a quelque chose d'incorrecte quelque part
|
|
int LesContacts::Recalcul_Nb_contact_actif()
|
|
{ LaLIST <ElContact>::iterator il,ilfin = listContact.end();
|
|
int ancien_nb_contact_actif = nb_contact_actif;
|
|
nb_contact_actif = 0; // init
|
|
for (il = listContact.begin();il != ilfin; il++)
|
|
if ((*il).Actif())
|
|
nb_contact_actif++;
|
|
|
|
int niveau_commentaire_contact = ParaGlob::param->ParaAlgoControleActifs().Niveau_commentaire_contact();
|
|
if (niveau_commentaire_contact == 0) {niveau_commentaire_contact = ParaGlob::NiveauImpression();};
|
|
if (nb_contact_actif != ancien_nb_contact_actif)
|
|
if (niveau_commentaire_contact > 4)
|
|
cout << "\n mise a jour anormale du nombre de contact actif : "
|
|
<< " ancien_nb_contact_actif= " << ancien_nb_contact_actif
|
|
<< " nouveau_nombre= " << nb_contact_actif << endl;
|
|
return nb_contact_actif;
|
|
};
|
|
|
|
|
|
// création du conteneur Fct_nD_contact
|
|
void LesContacts::Creation_Fct_nD_contact()
|
|
{
|
|
|
|
{// cas de la penalisation normale
|
|
string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_penalisationPenetration();
|
|
if (nom_fct != "_")
|
|
{// on va récupérer la fonction
|
|
if (sauve_lesFonctionsnD->Existe(nom_fct))
|
|
{ Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
|
|
// sauvegarde
|
|
fct_nD_contact.fct_nD_penalisationPenetration = pt_fonct;
|
|
}
|
|
else
|
|
{ cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la penalisation normale "
|
|
<< " le nom : " << nom_fct
|
|
<< " ne correspond pas a une fonction nD existante !! ";
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{fct_nD_contact.fct_nD_penalisationPenetration=NULL;};
|
|
};
|
|
|
|
{// cas fct_nD_penetration_contact_maxi
|
|
string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_penetration_contact_maxi();
|
|
if (nom_fct != "_")
|
|
{// on va récupérer la fonction
|
|
if (sauve_lesFonctionsnD->Existe(nom_fct))
|
|
{ Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
|
|
// sauvegarde
|
|
fct_nD_contact.fct_nD_penetration_contact_maxi = pt_fonct;
|
|
}
|
|
else
|
|
{ cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la "
|
|
<< " penetration maxi, le nom : " << nom_fct
|
|
<< " ne correspond pas a une fonction nD existante !! ";
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{fct_nD_contact.fct_nD_penetration_contact_maxi=NULL;};
|
|
};
|
|
|
|
{// cas Fct_nD_penetration_borne_regularisation
|
|
string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_penetration_borne_regularisation();
|
|
if (nom_fct != "_")
|
|
{// on va récupérer la fonction
|
|
if (sauve_lesFonctionsnD->Existe(nom_fct))
|
|
{ Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
|
|
// sauvegarde
|
|
fct_nD_contact.fct_nD_penetration_borne_regularisation = pt_fonct;
|
|
}
|
|
else
|
|
{ cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la "
|
|
<< " borne de regularisation, le nom : " << nom_fct
|
|
<< " ne correspond pas a une fonction nD existante !! ";
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{fct_nD_contact.fct_nD_penetration_borne_regularisation=NULL;};
|
|
};
|
|
|
|
{// cas fct_nD_force_contact_noeud_maxi
|
|
string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_force_contact_noeud_maxi();
|
|
if (nom_fct != "_")
|
|
{// on va récupérer la fonction
|
|
if (sauve_lesFonctionsnD->Existe(nom_fct))
|
|
{ Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
|
|
// sauvegarde
|
|
fct_nD_contact.fct_nD_force_contact_noeud_maxi = pt_fonct;
|
|
}
|
|
else
|
|
{ cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la "
|
|
<< " force de contact normale, le nom : " << nom_fct
|
|
<< " ne correspond pas a une fonction nD existante !! ";
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{fct_nD_contact.fct_nD_force_contact_noeud_maxi=NULL;};
|
|
};
|
|
|
|
{// cas fct_nD_penalisationTangentielle
|
|
string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_penalisationTangentielle();
|
|
if (nom_fct != "_")
|
|
{// on va récupérer la fonction
|
|
if (sauve_lesFonctionsnD->Existe(nom_fct))
|
|
{ Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
|
|
// sauvegarde
|
|
fct_nD_contact.fct_nD_penalisationTangentielle = pt_fonct;
|
|
}
|
|
else
|
|
{ cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la penalisation tangentielle "
|
|
<< " le nom : " << nom_fct
|
|
<< " ne correspond pas a une fonction nD existante !! ";
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{fct_nD_contact.fct_nD_penalisationTangentielle=NULL;};
|
|
};
|
|
|
|
{// cas fct_nD_tangentielle_contact_maxi
|
|
string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_tangentielle_contact_maxi();
|
|
if (nom_fct != "_")
|
|
{// on va récupérer la fonction
|
|
if (sauve_lesFonctionsnD->Existe(nom_fct))
|
|
{ Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
|
|
// sauvegarde
|
|
fct_nD_contact.fct_nD_tangentielle_contact_maxi = pt_fonct;
|
|
}
|
|
else
|
|
{ cout << "\n *** erreur dans la definition de la fonction nD de pilotage du "
|
|
<< " deplacement tangentiel maxi, le nom : " << nom_fct
|
|
<< " ne correspond pas a une fonction nD existante !! ";
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{fct_nD_contact.fct_nD_tangentielle_contact_maxi=NULL;};
|
|
};
|
|
|
|
{// cas fct_nD_tangentielle_borne_regularisation
|
|
string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_tangentielle_borne_regularisation();
|
|
if (nom_fct != "_")
|
|
{// on va récupérer la fonction
|
|
if (sauve_lesFonctionsnD->Existe(nom_fct))
|
|
{ Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
|
|
// sauvegarde
|
|
fct_nD_contact.fct_nD_tangentielle_borne_regularisation = pt_fonct;
|
|
}
|
|
else
|
|
{ cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la "
|
|
<< " borne de regularisation tangentielle, le nom : " << nom_fct
|
|
<< " ne correspond pas a une fonction nD existante !! ";
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{fct_nD_contact.fct_nD_tangentielle_borne_regularisation=NULL;};
|
|
};
|
|
|
|
{// cas fct_nD_force_tangentielle_noeud_maxi
|
|
string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_force_tangentielle_noeud_maxi();
|
|
if (nom_fct != "_")
|
|
{// on va récupérer la fonction
|
|
if (sauve_lesFonctionsnD->Existe(nom_fct))
|
|
{ Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
|
|
// sauvegarde
|
|
fct_nD_contact.fct_nD_force_tangentielle_noeud_maxi = pt_fonct;
|
|
}
|
|
else
|
|
{ cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la "
|
|
<< " force tangentielle maxi, le nom : " << nom_fct
|
|
<< " ne correspond pas a une fonction nD existante !! ";
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{fct_nD_contact.fct_nD_force_tangentielle_noeud_maxi=NULL;};
|
|
};
|
|
|
|
};
|
|
|
|
/*// mise à jour du stockage inter, pour prendre en
|
|
// compte une nouvelle numérotation des noeuds
|
|
void LesContacts::Prise_en_compte_nouvelle_numerotation_noeud()
|
|
{ //on va reconstruire ta_inverse
|
|
int nb_zone = MaX(1,nom_ref_zone_contact.size());
|
|
// on garde en mémoire les anciens numéros pour faire le pontage
|
|
Tableau < Tableau < Tableau <int> > > ta_inverse_old(ta_inverse);
|
|
|
|
// on recherche les maxi des numéros de noeuds esclave, pour dimensionner ta_inverse !!
|
|
Tableau < Tableau <int> > maxi_num_noe_esclave(nb_mail_Esclave); // init à 0
|
|
for (int i=1;i<=nb_mail_Esclave;i++)
|
|
{maxi_num_noe_esclave(i).Change_taille(nb_zone);
|
|
for (int j=1;j<=nb_zone;j++)
|
|
{const Tableau <Noeud*>& tesc= tesctotal(i)(j); // pour simplifier la notation:
|
|
int tesc_taille=tesc.Taille(); // tab des noeuds esclaves à considérer
|
|
int& max_num_esclave = maxi_num_noe_esclave(i)(j); // pour simplifier
|
|
for (int inesc = 1;inesc<= tesc_taille;inesc++) // boucle sur les noeuds esclaves
|
|
{ Noeud* noee = tesc(inesc); // pour simplifier
|
|
int num_noeud = noee->Num_noeud();
|
|
if (num_noeud > max_num_esclave)
|
|
max_num_esclave = num_noeud;
|
|
};
|
|
};
|
|
};
|
|
// Maintenant on peut dimensionner ta_inverse
|
|
for (int i=1;i<=nb_mail_Esclave;i++)
|
|
{ta_inverse(i).Change_taille(nb_zone);
|
|
for (int j=1;j<=nb_zone;j++)
|
|
ta_inverse(i)(j).Change_taille(maxi_num_noe_esclave(i)(j),0);
|
|
};
|
|
|
|
// ensuite on va remplir ta_inverse
|
|
for (int intot=1;intot<=nb_mail_Esclave;intot++)
|
|
{for (int j=1;j<=nb_zone;j++)
|
|
{const Tableau <Noeud*>& tesc= tesctotal(intot)(j); // pour simplifier la notation:
|
|
int tesc_taille=tesc.Taille(); // tab des noeuds esclaves à considérer
|
|
for (int inesc = 1;inesc<= tesc_taille;inesc++) // boucle sur les noeuds esclaves
|
|
{ Noeud* noee = tesc(inesc); // pour simplifier
|
|
ta_inverse(intot)(j)(noee->Num_noeud()) = inesc;
|
|
};
|
|
};
|
|
};
|
|
|
|
// on va créer un tableau de changement des numéros de noeuds
|
|
Tableau < Tableau <int> > nouveau_Noe(nb_mail_Esclave);
|
|
// on cherche la taille maxi
|
|
Tableau <int> maxi_maxi_num_noe_esclave(nb_mail_Esclave); // les maxis pour chaque maillage
|
|
for (int i=1;i<=nb_mail_Esclave;i++)
|
|
{int& max_max_esclave = maxi_maxi_num_noe_esclave(i) = 0; // init
|
|
for (int j=1;j<=nb_zone;j++)
|
|
{int& max_num_esclave = maxi_num_noe_esclave(i)(j); // pour simplifier
|
|
if (max_num_esclave > max_max_esclave)
|
|
max_max_esclave = max_num_esclave;
|
|
};
|
|
};
|
|
// on balaie les anciens noeuds
|
|
for (int i=1;i<=nb_mail_Esclave;i++)
|
|
{nouveau_Noe(i).Change_taille(maxi_maxi_num_noe_esclave(i));
|
|
Tableau <int>& nouveau_Noe_i = nouveau_Noe(i);
|
|
for (int j=1;j<=nb_zone;j++)
|
|
{ Tableau <int> & ta_inverse_old_ij = ta_inverse_old(i)(j);
|
|
Tableau <int> & ta_inverse_ij = ta_inverse(i)(j);
|
|
int nbN = ta_inverse_old_ij.Taille();
|
|
for (int k=1;k<= nbN;k++) // k c'est le numéro de l'ancien noeud
|
|
{if (ta_inverse_old_ij(k) != 0)
|
|
{for (int k2=1;k2<= nbN;k2++)
|
|
{ if (ta_inverse_old_ij(k) == ta_inverse_ij(k2))
|
|
{nouveau_Noe_i(k)=k2;break;};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// // maintenant on met à jour le tableau tesN_encontact
|
|
// // Tableau < Tableau < LaLIST < LaLIST<ElContact>::iterator > > > tesN_encontact;
|
|
// // on sauvegarde l'ancien
|
|
// Tableau < Tableau < LaLIST < LaLIST<ElContact>::iterator > > > tesN_encontact_old(tesN_encontact);
|
|
// // et on fait la passation
|
|
// for (int i=1;i<=nb_mail_Esclave;i++)
|
|
// {Tableau <int>& nouveau_Noe_i = nouveau_Noe(i);
|
|
// int nbn = tesN_encontact(i).Taille();
|
|
// for (int j=1;j<=nbn;j++)
|
|
// { tesN_encontact(i)(nouveau_Noe_i(j)) = tesN_encontact_old(i)(j);
|
|
// };
|
|
// };
|
|
|
|
// on continue avec le tableau: liste pour chaque noeud, des éléments qui contient ce noeud
|
|
// indice(i)(j) : = la liste des éléments qui contiennent le noeud j, pour le maillage i
|
|
Tableau < const Tableau <List_io < Element* > > *> indice_old(indice);
|
|
int nb_mail = indice_old.Taille();
|
|
for (int i=1;i<=nb_mail;i++)
|
|
{if (indice_old(i) != NULL)
|
|
{ int nbn = indice_old(i)->Taille();
|
|
// const Tableau <List_io < Element* > > & indice_i = indice(i);
|
|
// for (int j=1;j<=nbn;j++)
|
|
//indice
|
|
|
|
}
|
|
|
|
}
|
|
cout << "\n LesContacts::Prise_en_compte_nouvelle_numerotation_noeud() pas terminé !!"
|
|
<< " il faut changer lesMaillages pour récupérer directement la nouvelle numérotation !!";
|
|
Sortie(1);
|
|
|
|
};
|
|
*/
|
|
|
|
|
|
// récupération via les éléments de contact des forces maxis
|
|
// et affichage éventuel
|
|
// un : le maxi en effort normal, deux: le maxi en effort tangentiel
|
|
DeuxDoubles LesContacts::Forces_contact_maxi(bool affiche) const
|
|
{DeuxDoubles retour;
|
|
LaLIST <ElContact>::const_iterator il,ilfin = listContact.end();
|
|
for (il = listContact.begin();il != ilfin; il++)
|
|
{ const ElContact& icont = (*il); // pour simplifier
|
|
double fNmax = icont.F_N_MAX();
|
|
double fTmax = icont.F_T_MAX();
|
|
if (Dabs(fNmax) > Dabs(retour.un) )
|
|
retour.un = fNmax;
|
|
if (Dabs(fTmax) > Dabs(retour.deux) )
|
|
retour.deux = fTmax;
|
|
};
|
|
int niveau_commentaire_contact = ParaGlob::param->ParaAlgoControleActifs().Niveau_commentaire_contact();
|
|
if (niveau_commentaire_contact == 0) {niveau_commentaire_contact = ParaGlob::NiveauImpression();};
|
|
if ((affiche && (ParaGlob::NiveauImpression() > 2))
|
|
|| (niveau_commentaire_contact > 5) // spécifiquement pour le contact
|
|
)
|
|
cout << "\n contact: reaction ==> F_N max " << retour.un << " F_T max " << retour.deux;
|
|
return retour;
|
|
};
|
|
|
|
// récupération via les éléments de contact des gaps maxis
|
|
// un : le maxi en gap normal, deux: le maxi en gap tangentiel
|
|
DeuxDoubles LesContacts::Gap_contact_maxi(bool affiche) const
|
|
{DeuxDoubles retour;
|
|
LaLIST <ElContact>::const_iterator il,ilfin = listContact.end();
|
|
for (il = listContact.begin();il != ilfin; il++)
|
|
{ const ElContact& icont = (*il); // pour simplifier
|
|
double fNmax = icont.Gaptdt();
|
|
double fTmax = icont.Dep_T_tdt();
|
|
if (Dabs(fNmax) > Dabs(retour.un) )
|
|
retour.un = fNmax;
|
|
if (Dabs(fTmax) > Dabs(retour.deux) )
|
|
retour.deux = fTmax;
|
|
};
|
|
int niveau_commentaire_contact = ParaGlob::param->ParaAlgoControleActifs().Niveau_commentaire_contact();
|
|
if (niveau_commentaire_contact == 0) {niveau_commentaire_contact = ParaGlob::NiveauImpression();};
|
|
if ((affiche && (ParaGlob::NiveauImpression() > 2))
|
|
|| (niveau_commentaire_contact > 5) // spécifiquement pour le contact
|
|
)
|
|
cout << ", maxi gap_N : " << retour.un << " gap_T : " << retour.deux;
|
|
return retour;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|