rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Maillage/LesCondLim.h

582 lines
33 KiB
C
Raw Normal View History

ajout des fichiers du répertoire Maillage - concerne les conditions limites, les maillages, les ddl en tout genre
2021-09-18 09:47:14 +02:00
// 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.
//
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
ajout des fichiers du répertoire Maillage - concerne les conditions limites, les maillages, les ddl en tout genre
2021-09-18 09:47:14 +02:00
// 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: Gestion des differentes conditions limites *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef LESCONDLIM_H
#define LESCONDLIM_H
#include "LectBloc_T.h"
#include "Tableau_T.h"
#include "DdlLim.h"
#include "UtilLecture.h"
#include "LesReferences.h"
#include "MotCle.h"
#include "LesMaillages.h"
#include "CondLim.h"
#include "Condilineaire.h"
#include "Nb_assemb.h"
#include "LesCourbes1D.h"
#include "LesFonctions_nD.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"
#include "Basiques.h"
#include "I_O_Condilineaire.h"
#include "Temps_CPU_HZpp.h"
/** @defgroup Les_classes_relatives_aux_conditions_limites
*
* BUT:Gestion des differentes conditions limites
*
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
* \brief Gestion des differentes conditions limites
*
*/
/// @addtogroup Les_classes_relatives_aux_conditions_limites
/// @{
///
class LesCondLim
{
public :
// CONSTRUCTEURS :
LesCondLim (); // par defaut
// DESTRUCTEUR :
~LesCondLim ();
// METHODES PUBLIQUES :
// lecture des conditions limites : ddl bloque
void Lecture1(UtilLecture & entreePrinc,LesReferences& lesRef);
// lecture des conditions limites linéaires
void Lecture2(UtilLecture & entreePrinc,LesReferences& lesRef);
// lecture des conditions limites : initialisation
void Lecture3(UtilLecture & entreePrinc,LesReferences& lesRef);
// affichage des informations concernant les conditions limites
void Affiche() const ; // affichage de tous les infos
void Affiche1() const ; // affichage des ddl bloques
void Affiche2() const ; // affichage des conditions limites linéaires
void Affiche3() const ; // affichage des ddl d'initialisation
// introduction des données et variables pour leurs emplois futures, avec init par défaut
void IntroductionDonnees (LesMaillages * lesMail,LesReferences* lesRef
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD);
// initialisation des ddl avec le tableau de ddl d'init
// verif de l'existence de tous les ddl (initialisation et imposes)
// ajout si necessaire, dans ce dernier cas l'initialisation est a zero
// choix = false : indique qu'il faut initialiser que les ddl a t
// choix = true : indique qu'il faut initialiser les ddl a t et t+dt
// vérification de l'existence des courbes de charge adoc si nécessaire
// cas : indique le cas d'association de ddl en cours, ces ddl sont gérés globalement, c-a-d lorsque
// le statut d'un ddl est modifié (de bloqué à non bloqué par exemple) tous les ddl associés ont
// leur statut modifié de manière équivalente
// =0 pas d'association
// =1 association X V GAMMA
void Initial(LesMaillages * lesMail,LesReferences* lesRef,LesCourbes1D* lesCourbes1D
,LesFonctions_nD* lesFonctionsnD,bool choix,int cas);
// // mise à jour de l'initialisation, par exemple après un restart
// // même paramètres que Initial, par contre ici il n'y a aucune création
// void Re_initial(LesMaillages * lesMail,LesReferences* lesRef,LesCourbes1D* lesCourbes1D,bool choix,int cas);
// initialisation du nombre de cas d'assemblage
// si inf au nombre actuel, aucune action
void InitNombreCasAssemblage(int nb_cas)
{ if (nb_cas > condlim.Taille())
condlim.Change_taille(nb_cas);
};
// incrementation des coordonnees a t+dt et des ddl en fonctions des ddl imposes
// et du chargement
// coef: est un facteur multiplicatif des ddl sans courbes de charge,
// est suposé intégrer déjà le multiplicateur général
// en fait du chargement impose
// mult_gene : multiplicateur général de tous les chargements
// deltat : incrément de temps actuel
// temps : le temps courant où sont calculées les conditions
// ch_statut : indique s'il y a changement ou non de statut des conditions limites (pour les ddl aux noeuds)
// c-a-d un ddl qui passe de bloqué à non bloqué ou inversement: il s'agit uniquement des ddl aux noeuds
// c-a-d ceux qui ont une influence sur la mise en place des cl sur la raideur et le résidu
// cas : indique le cas d'association de ddl en cours, ces ddl sont gérés globalement, c-a-d lorsque
// le statut d'un ddl est modifié (de bloqué à non bloqué par exemple) tous les ddl associés ont
// leur statut modifié de manière équivalente
// =0 pas d'association
// =1 association X V GAMMA
// lorsque en_ddl est égal à NU_DDL, cela signifie que l'on met les conditions limites sur tous les
// ddl de noeud actifs
// lorsque en_ddl est différent de NU_DDL, il donne le type des seules ddl pour lesquels on met les
// conditions de blocage: par exemple X1 -> blocage sur X1,X2,X3 selon la dimension
void MiseAJour_tdt
(const double& mult_gene,LesMaillages * lesMail,const double& deltat,const LesReferences* lesRef
,const double& temps,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,const double& coef,bool& ch_statut
,int cas , Enum_ddl en_ddl = NU_DDL);
// mise en place de la répercussion sur les noeuds des conditions linéaires imposées externes (par les données d'entrées),
// ne prend pas en charge par exemple les CL dues aux contacts(gérés par CL)
// pour les paramètres: voir MiseAJour_tdt
void MiseAJour_condilineaire_tdt
(const double& mult_gene,LesMaillages * lesMail,const double& deltat,LesReferences* lesRef
,const double& temps,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,const double& coef,bool& ch_statut
,int cas ,Enum_ddl en_ddl = NU_DDL);
// validation des conditions de blocages et des conditions linéaire, pour l'incrément.
// concernant l'activité des ddlLim, elle est enregistrée en fonction du temps
// idem pour les conditions linéaires
void Validation_blocage (LesReferences* lesRef,const double& temps);
// test s'il y a changement de statut pour le temps indiqué par rapport à la situation actuelle ou pas
// n'effectue aucune autre opération
// si en_ddl est différent de NU_DDL on test le changement de statut uniquement pour le ddl en_ddl
bool Changement_statut(const LesMaillages * lesMail,const LesReferences* lesRef
,LesFonctions_nD* lesFonctionsnD
,const double& temps,const Enum_ddl en_ddl = NU_DDL) ;
// récupération des tableaux d'indices généraux des ddl bloqués
// cas : donne le type d'association de ddl que l'on veut
// =0 -> pas d'association
// =1 -> association de Xi avec Vi avec Gammai
// t_assemb: donne pour chaque type d'association, le numéro d'assemblage correspondant au different ddl
// de l'association
// cas=1 -> numéro d'assemblage de X1 puis V1 puis GAMMA1
// : en sortie une liste de Gene_asso, correspondant à tous les ddl bloqués et les
// les ddl associés
// définition d'un conteneur pour la routine Tableau_indice
class Gene_asso
{ public :
Gene_asso () : ty_prin(NU_DDL),pointe() {};
Gene_asso (Enum_ddl ty_prin,const Tableau <int>& pointes) :
ty_prin(ty_prin),pointe(pointes) {};
Gene_asso (const Gene_asso& a) : ty_prin(a.ty_prin),pointe(a.pointe) {};
Gene_asso& operator= (const Gene_asso& a)
{ty_prin=a.ty_prin;pointe=a.pointe;return (*this);};
bool operator== (const Gene_asso& a) const
{if((ty_prin==a.ty_prin)&&(pointe==a.pointe)) return true;else return false;};
bool operator!= (const Gene_asso& a) const
{if ( (*this)==a ) return true; else return false;};
Enum_ddl ty_prin; // le ddl principal bloqué
Tableau <int> pointe; // la position générale des ddl, principal et secondaire
// pour le cas 1 : pointe(k) -> la position du ddl Xi , puis Vi puis Gammai
};
list <Gene_asso> Tableau_indice(const LesMaillages * lesMail,const Tableau <Nb_assemb> & t_assemb
,const LesReferences* lesRef,const double& temps,int cas );
// mise en place des conditions limites sur les matrices et second membres
// (autres que les conditions linéaires)
// nb_casAssemb : le cas d'assemblage
// cas : indique un type d'association de ddl
// = 0 -> pas d'association, seules les ddl fournis par l'utilisateur sont considéré
// = 1 -> association de Xi Vi Gammai, qui sont pris en compte dès lors que l'un
// a été fixé par l'utilisateur
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
void ImposeConLimtdt(LesMaillages * lesMail,LesReferences* lesRef,
Mat_abstraite & matglob,Vecteur& vecglob
,const Nb_assemb& nb_casAssemb,int cas,Vecteur* vec2);
// mise en place des conditions limites sur le second membres
// nb_casAssemb : le cas d'assemblage
// cas : indique un type d'association de ddl
// = 0 -> pas d'association, seules les ddl fournis par l'utilisateur sont considéré
// = 1 -> association de Xi Vi Gammai, qui sont pris en compte dès lors que l'un
// a été fixé par l'utilisateur
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
void ImposeConLimtdt(LesMaillages * lesMail,LesReferences* lesRef,
Vecteur& vecglob,const Nb_assemb& nb_casAssemb,int cas,Vecteur* vec2);
// mise en place des conditions limites sur deux matrices
// utilisé par exemple pour le flambement
// la première matrice est initialisée avec des 1 sur la diagonale
// la seconde avec des 0 sur la diagonale
// nb_casAssemb : le cas d'assemblage
// cas : indique un type d'association de ddl
// = 0 -> pas d'association, seules les ddl fournis par l'utilisateur sont considéré
// = 1 -> association de Xi Vi Gammai, qui sont pris en compte dès lors que l'un
// a été fixé par l'utilisateur
void ImpConLimtdt2Mat(LesMaillages * lesMail,LesReferences* lesRef,
Mat_abstraite & matglob,Mat_abstraite & matgeom
,const Nb_assemb& nb_casAssemb,int cas);
// retourne la valeur absolu du maxi des efforts exterieurs
// et le numero ili du ddl correspondant dans l'assemblage global
double MaxEffort(int & ili,const Nb_assemb& nb_casAssemb)
{ return condlim(nb_casAssemb.n).MaxEffort(ili);};
// calcul des reactions et stockage des valeurs
// ceci dans le cas ou il n'y a pas de conditions lineaires appliquee
// on se sert des valeurs sauvegardees lors de la mise en place des CL bloquees
// nb_casAssemb : le cas d'assemblage
// cas : indique un type d'association de ddl
// = 0 -> pas d'association, seules les ddl fournis par l'utilisateur sont considéré
// = 1 -> association de Xi Vi Gammai, qui sont pris en compte dès lors que l'un
// a été fixé par l'utilisateur
void CalculReaction(LesMaillages * lesMail,LesReferences* lesRef
,const Nb_assemb& nb_casAssemb,int cas);
// récupération des reactions initiales, avant les rotations dues aux conditions linéaires
// il s'agit des réactions dues aux ddl bloqués et dues aux conditions linéaires
// et calcul des torseurs de réaction
void ReacAvantCHrepere(Vecteur& residu,LesMaillages * lesMail,
LesReferences* lesRef,const Nb_assemb& nb_casAssemb,int cas);
// récupération des reactions= residu et stockage des valeurs
// NB: après changement de repère, il n'y a plus que des ddl bloqués
// cas : indique un type d'association de ddl
// = 0 -> pas d'association, seules les ddl fournis par l'utilisateur sont considéré
// = 1 -> association de Xi Vi Gammai, qui sont pris en compte dès lors que l'un
// a été fixé par l'utilisateur
void ReacApresCHrepere(Vecteur& residu,LesMaillages * lesMail,
LesReferences* lesRef,const Nb_assemb& nb_casAssemb,int cas);
// affichage sur la sortie sort des reactions
void Affiche_reaction(ofstream& sort,const LesMaillages * lesMail) const ;
// ------------------ conditions linéaires externes ----------------------------------------------
// mise en place de condition externe lineaires
// expression de la raideur et du second membre dans un nouveau repere
// ramène si oui ou non, il y a eu un changement effectué
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
bool CoLinCHrepere_ext(Mat_abstraite & matglob,Vecteur& vecglob
,const Tableau <Condilineaire>& tabCondLine
,const Nb_assemb& nb_casAssemb,Vecteur* vec2);
// blocage des seconds membres pour les conditions lineaires
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
inline void CoLinBlocage(Mat_abstraite & matglob,Vecteur& vecglob
,const Nb_assemb& nb_casAssemb,Vecteur* vec2)
{ condlim(nb_casAssemb.n).CondlineaireImpose ( matglob, vecglob,vec2);};
// retour des ddl dans le repere general, ceci dans le cas d'utilisation
// de conditions lineaires
inline void RepInitiaux( Vecteur& sol,const Nb_assemb& nb_casAssemb)
{ condlim(nb_casAssemb.n).RepInitiaux(sol); };
// mise en place de condition externe lineaires en une opération
// retour de la raideur et du second membre sans changement de repere
// ramène si oui ou non, il y a eu un changement effectué
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
bool CoLinUneOpe_ext(Mat_abstraite & matglob,Vecteur& vecglob
,const Tableau <Condilineaire>& tabCondLine
,const Nb_assemb& nb_casAssemb,Vecteur* vec2);
// -------- conditions linéaires internes: imposées par les conditions limites en entrée -----------
// mise en place des conditions linéaires imposées par les données d'entrée
// expression de la raideur et du second membre dans un nouveau repere
// ramène si oui ou non, il y a eu un changement effectué
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
bool CoLinCHrepere_int(Mat_abstraite & matglob,Vecteur& vecglob,const Nb_assemb& nb_casAssemb,Vecteur* vec2);
// effacement du marquage de ddl bloque du au conditions lineaire imposées par les conditions d'entrée
void EffMarque();
// def de la largeur de bande en fonction des conditions linéaire limite en entrée
// casAssemb : donne le cas d'assemblage en cours
// les condi linéaires ne donnent pas des largeurs de bande sup et inf égales !!!
// demi = la demi largeur de bande ,
// total = le maxi = la largeur sup + la largeur inf +1
// cumule = la somme des maxis, ce qui donnera la largeur finale, due à des multiples multiplications: une par conditions linéaires
// dans le cas où on tiens compte des conditions linéaires par rotation (c-a-d sans multiplicateur ou pénalisation)
// en retour, ramène un booleen qui :
// = true : si la largeur de bande en noeud est supérieure à 1
// = false : si non, ce qui signifie dans ce cas qu'il n'y a pas d'augmentation de la largeur
// en noeud
bool Largeur_Bande(int& demi,int& total,const Nb_assemb& casAssemb,LesMaillages * lesMail,LesReferences* lesRef
,int& cumule);
// création d'un tableau de condition linéaire, correspondant à toutes les conditions linéaires d'entrées
// qu'elles soient actives 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,
Tableau <Tableau <Condilineaire> > ConnectionCLL(const LesMaillages * lesMail,const LesReferences* lesRef) const;
// idem ConnectionCLL avec une liste, mais spécifiquement les conditions de type "stricte_egalite" entre ddl de noeud
// correspondant à toutes les conditions linéaires d'entrées actives uniquement
// (a priori cette méthode est conçu pour donner des infos pour condenser les pointeurs d'assemblages:
// LesMaillages::MiseAJourPointeurAssemblage() )
// chacune des condition ne contient "d'exploitable" que le tableau de noeuds associés à la CLL, et le type enumere de ddl
list <Condilineaire> ConnectionCLL_stricte_egalite
(const LesMaillages * lesMail,const LesReferences* lesRef) const;
// récupération du tableau de conditions linéaires en cours
//résultant de l'application des conditions lues (indépendamment du contact par exemple)
// mis à jour après la méthode: MiseAJour_condilineaire_tdt
const Tableau < Tableau <Condilineaire > >& Tab_CLinApplique() const {return tab_CLinApplique;};
// indique si oui ou non il y a des conditions limites linéaires en entrée
bool ExisteCondiLimite() const {return tab_iocondiline.Taille();};
// ----------------------- fin conditions linéaires -------------------------------------------
//initialisation, mise a zero des sauvegarde
void InitSauve(const Nb_assemb& nb_casAssemb);
// lecture de donnée en fonction d'un indicateur : int type
// pour l'instant ne fait rien
void LectureDonneesExternes(UtilLecture& ,LesReferences& ,const int ,const string&) {};
// affichage et definition interactive des commandes pour les conditions limites CL
void Info_commande_LesCondLim1(UtilLecture & entreePrinc);
// affichage et definition interactive des commandes pour les conditions limites CLL
void Info_commande_LesCondLim2(UtilLecture & entreePrinc);
// affichage et definition interactive des commandes pour les initialisations
void Info_commande_LesCondLim3(UtilLecture & entreePrinc);
//----- lecture écriture de restart -----
// 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_base_info(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas);
//------- temps cpu -----
// retourne temps cumulé pour imposer les CL imposées
const Temps_CPU_HZpp& Temps_cpu_CL() const {return tempsCL;};
// retourne le temps cumulé pour imposer les CLL
const Temps_CPU_HZpp& Temps_cpu_CLL() const {return tempsCLL;};
// --- conteneur pour les réactions -----
class ReactStoc
{ public :
// surcharge de l'operator de lecture typée
friend istream & operator >> (istream &, ReactStoc &);
// surcharge de l'operator d'ecriture typée
friend ostream & operator << (ostream &, const ReactStoc &);
//Surcharge d'operateur logique
bool operator == ( const ReactStoc& a) const
{ return ((numMail==a.numMail)&&(numNoeud==a.numNoeud)
&&(ddl==a.ddl)&&(casAss==a.casAss));
};
bool operator != ( const ReactStoc& a) const { return !(*this == a);};
// !*!*!*! classement uniquement sur le numéro de noeud !*!*!*!
// --->> non: changement 3/1/2018
bool operator < ( const ReactStoc& a) const
{if (numMail < a.numMail) return true;
else if (numMail == a.numMail) return (numNoeud < a.numNoeud);
else // cas où numMail > a.numMail
return false;
//return (numNoeud < a.numNoeud);
};
bool operator > ( const ReactStoc& a) const { return !(*this < a);};;
public : int numMail; // numero de maillage
int numNoeud ; // numero de noeud
Ddl ddl; // le ddl bloque
int casAss; // cas d'assemblage
};
class TorseurReac
{// surcharge de l'operator de lecture typée
friend istream & operator >> (istream &, TorseurReac &);
// surcharge de l'operator d'ecriture typée
friend ostream & operator << (ostream &, const TorseurReac &);
public :
// constructeurs
TorseurReac():existe_torseur_reac(false),resultante(),moment(),bloque_ou_CLL(true) {};
TorseurReac(const TorseurReac& a):
existe_torseur_reac(a.existe_torseur_reac),resultante(a.resultante)
,moment(a.moment),bloque_ou_CLL(a.bloque_ou_CLL) {};
// méthodes
void Activation(int dima) {existe_torseur_reac=true;resultante.Change_dim(dima);
moment.Change_dim(dima);};
void Zero_init_torseur() {resultante.Zero();moment.Zero();};
// données
bool existe_torseur_reac; // indique si le Torseur doit-être calculé ou non
Coordonnee resultante; // la résultante du torseur
Coordonnee moment; // le moment du torseur par rapport à l'origine
bool bloque_ou_CLL; // true provient d'un ddl bloqué, false provient d'une CLL
};
// retourne les réactions aux conditions limites à un noeud noe d'un maillage mail
// s'il n'y a pas de conditions limites : retour d'une liste vide
// const list<const LesCondLim::ReactStoc*>& Reaction_noeud_mail(int mail,int noeud) const ;
// retourne la liste des types de ddl actuellement imposés
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io < Ddl_enum_etendu> > Les_type_de_ddl_en_reaction() const;
// retourne la liste des torseurs de réaction actuellement actif pour les maillages
// appelons tab_lili la liste:
// - tab_lili(i) concerne le maillage nb i
// - les éléments de tab_lili(i) sont les noms des références qui conduisent à un torseur de réaction
// actif, et un indice de gestion utilisé par LesCondLim pour retrouver
// rapidemment les informations
Tableau < List_io <String_et_entier > > TabListTorseurReaction(const LesMaillages & lesmail) const;
// retourne le torseur de réaction correspondant à l'indice i
const TorseurReac & Torseur_de_reaction(int i) const {return tab_torseurReac(i);};
private :
// VARIABLES PROTEGEES :
Tableau <DdlLim> tabBloq; // tableau des ddl bloques
Tableau <TorseurReac> tab_torseurReac; // tableau des torseurs de réaction
// relatif aux ddl bloqués et aux conditions linéaires
// de 1 à ttRG.Taille() on a les torseurs relatifs à tabBloq
// puis de ttRG.Taille() à la fin c-a-d ttRG.Taille()+ttRGCLL.Taille(),
// on a les torseurs relatifs à tab_iocondiline
// un tableau, qui permet de passer de tabBloq à tab_torseurReac
Tableau <int> ttRG; // tabBloq(i) contribue au torseur tab_torseurReac(ttRG(i))
// ttorBloq(i) contient tous les numéros de tabBloq qui contribue au torseur i
Tableau < List_io <int> > ttorBloq;
Tableau <DdlLim> tabInit; // tableau des ddl d'initialisation
Tableau <ReactStoc> reaction; // les reactions pour les ddl bloqués
Tableau <ReactStoc> reaction_CLin; // les reactions pour les conditions linéaires
Tableau <ReactStoc> reactionApresCHrepere; // les reactions après CHrepere
// tableau des conditions linéaires a imposer par les données d'entrée
Tableau <I_O_Condilineaire > tab_iocondiline;
Tableau < Tableau <Condilineaire > > tab_CLinApplique; // tableau des conditions linéaires
//résultant de l'application de tab_iocondiline
// un tableau à deux dim, qui permet de passer de tab_CLinApplique à tab_torseurReac
Tableau < Tableau <int> > ttRGCLL; // tab_CLinApplique(i)(j) contribue au torseur tab_torseurReac(ttRGCLL(i)(j))
// ttorCLL(i) contient tous les numéros de tab_iocondiline qui contribue au torseur i, avec
// le premier élément de l'instantce DeuxEntiers = le numéros dans tab_iocondiline, le second élement = le rang de
// la référence dans la condition linéaire
Tableau < List_io <DeuxEntiers> > ttorCLL;
//deux liste de noms de ref qui servent pour accèder aux grandeurs globales correspondantes
// aux composantes des torseurs de réaction
// voir: DimensionneTorseurs() :
// ttRG_noms_ref + _Re_ + i -> ième composante de Re a tdt
// et à la place de Re -> Mo pour le moment
Tableau <string> ttRG_noms_ref; // nom générique associé aux torseurs de ddl bloqué
Tableau <string> ttRGCLL_noms_ref; // idem pour les CLL
// une map pour faire l'association entre numéro de maillage et numéro de noeud d'une part
// et le tableau de réaction pour un accès quasi-directe
// map < string, list<const ReactStoc*> , std::less <string> > map_reaction;
int nb_maillage; // sauvegarde du nombre de maillage
Tableau < CondLim > condlim; // les fonctions et données qui permettent d'imposer les cl
// aux matrices, aux second membres, de remonter aux efforts apres
// resolution etc ..., le tableau est indicé par le numéro de cas d'assemblage
//------- temps cpu -----
Temps_CPU_HZpp tempsCL; // temps cumulé pour imposer les CL imposées
Temps_CPU_HZpp tempsCLL; // temps cumulé pour imposer les CLL
// ----fonctions internes pour simplifier
// cas de l'initialisation: prise en compte de l'appartenance à un groupe
// fixe : donne le type d'initialisation que l'on veut
// une_variable: indique si le ddl est une variable (=true) ou une donnée (=false)
void Init_appart_groupe(bool une_variable,Enum_ddl a,bool fixe,Noeud& noe, int cas,bool choix);
//cas courant: mise en place du blocage sur un ddl ou un groupe si besoin est
void Mise_cl(int nd,DdlLim& ddl,Enum_ddl a,Noeud& noe, int cas);
// cas courant : on retire le blocage sur un ddl ou un groupe si besoin est
void Retire_cl(int nd,DdlLim& ddlbloqu,Enum_ddl enu,Noeud& noe, int cas);
// vérification qu'il n'y a pas de surcharge de blocage
// choix indique si l'on vérifie à t ou à tdt
void Verif_surcharge_blocage(const LesMaillages * lesMail,const LesReferences* lesRef,const double& temps,int cas) ;
// fourni la liste des ddl associé de même dim, pour un du groupe et en fonction du cas d'association
// ramène une référence sur tab_travail qui est mis à jour
Tableau <Ddl>& Ddl_associe( Ddl& ddl,Noeud& noe,Tableau <Ddl>& tab_travail,int cas);
// cas particulier des mouvements solides, dans le second passage pour la méthode MiseAJour_tdt
void MiseAjour_tdt_second_passage_mvtSolide(const double& mult_gene,LesMaillages * lesMail
,const double& deltat,int cas
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD,const double& coef
,DdlLim& tabBloq_i,const ReferenceNE & ref,const double& temps,Enum_ddl en_ddl);
// mise à jour et calcul éventuel du torseur de réaction: uniquement pour les ddl X1, X2, X3
// --> pour au final obtenir le torseur des efforts globaux résultant de l'application d'un DdlLim
void CalculTorseurReaction(TorseurReac& tr, const Noeud& noe, ReactStoc& reac);
// récupération de valeurs à un noeud pour les grandeur enu
// ici il s'agit de grandeur scalaires
Tableau <double> Valeur_multi_interpoler_ou_calculer
(const Noeud& noe, Enum_dure temps,const List_io<Ddl_enum_etendu>& enu);
// récupération de valeurs à un noeud pour les grandeur enu
// ici il s'agit de grandeurs tensorielles
void Valeurs_Tensorielles_interpoler_ou_calculer
(const Noeud& noe, Enum_dure temps,List_io<TypeQuelconque>& enu);
// dimensionnement du tableau des torseurs ainsi que des tableaux ttRG et ttorBloq
// en fonction de tabBloq (utilisé plusieurs fois), puis de ttRGCLL en fonction de tab_iocondiline
void DimensionneTorseurs();
// DdlLim à un noeud: mise à jour des temps min et temps max, lorsque ceci dépendent de fonction nD
void Mise_a_jour_t_minmax_ddlLim(Noeud& noe,DdlLim& ddlLim,LesFonctions_nD* lesFonctionsnD);
// DdlLim général: mise à jour des temps min et temps max, lorsque ceci dépendent de fonction nD
// ici les fct nD doivent dépendre uniquement de grandeur générale
void Mise_a_jour_t_minmax_ddlLim(DdlLim& ddlLim,LesFonctions_nD* lesFonctionsnD);
};
/// @} // end of group
#endif
Reference in a new issue Copy permalink