233 lines
12 KiB
C++
233 lines
12 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: Definition d'un container pour une condition limite *
|
|
* lineaire. *
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
|
|
* VERIFICATION: *
|
|
* *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* ! ! ! ! *
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
|
|
* MODIFICATIONS: *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* $ *
|
|
************************************************************************/
|
|
#ifndef CONDILINEAIRE_H
|
|
#define CONDILINEAIRE_H
|
|
|
|
#include "Noeud.h"
|
|
#include "Nb_assemb.h"
|
|
#include <stdlib.h>
|
|
#ifdef UTILISATION_MPI
|
|
#include <boost/serialization/split_member.hpp>
|
|
#include <boost/serialization/string.hpp>
|
|
#include "mpi.h"
|
|
#include <boost/mpi/environment.hpp>
|
|
#include <boost/mpi/communicator.hpp>
|
|
#include <boost/serialization/string.hpp>
|
|
#include <boost/mpi.hpp>
|
|
namespace mpi = boost::mpi;
|
|
#endif
|
|
|
|
|
|
/// @addtogroup Les_classes_Matrices
|
|
/// @{
|
|
///
|
|
|
|
|
|
class Condilineaire
|
|
{ // surcharge de l'operator de lecture typée
|
|
// en fait ces fonctions ne doivent pas être utilisées, elles existent uniquement
|
|
// pour que Tableau_T puisse exister
|
|
friend istream & operator >> (istream & ent, Condilineaire &)
|
|
{ Sortie(1); return ent;}; // erreur
|
|
// surcharge de l'operator d'ecriture typée
|
|
friend ostream & operator << (ostream & sort , const Condilineaire &)
|
|
{ Sortie(1); return sort;}; // erreur
|
|
|
|
public :
|
|
// CONSTRUCTEURS :
|
|
// par defaut
|
|
Condilineaire () :
|
|
pt(),val(),beta(0.),t_noeud(),t_enu(),casAssemb()
|
|
,Uk_impose(ConstMath::tresgrand)
|
|
{} ;
|
|
// cas ou l'on connait toutes les infos, sauf Uk_impose, qui est une variable de stockage gérée indépendament
|
|
Condilineaire (Tableau <Enum_ddl>& t_enuu, const Tableau<int> & ptt, const Vecteur& vall
|
|
, double betar,int posiddl, const Tableau < Noeud *>& t_n) :
|
|
pt(ptt),val(vall),beta(betar),iddl(posiddl),t_noeud(t_n)
|
|
,t_enu(t_enuu),casAssemb()
|
|
,Uk_impose(ConstMath::tresgrand)
|
|
{};
|
|
// cas ou l'on connait les infos relatives uniquements aux noeuds, aux enum ddl
|
|
Condilineaire(Tableau <Enum_ddl>& t_enuu, const Tableau < Noeud *>& t_n) :
|
|
t_noeud(t_n),t_enu(t_enuu),casAssemb()
|
|
{};
|
|
// de copie
|
|
Condilineaire (const Condilineaire& a) :
|
|
pt(a.pt),val(a.val),beta(a.beta),iddl(a.iddl),t_noeud(a.t_noeud)
|
|
,t_enu(a.t_enu),casAssemb(a.casAssemb),Uk_impose(a.Uk_impose)
|
|
{ };
|
|
// DESTRUCTEUR :
|
|
~Condilineaire () {};
|
|
// METHODES PUBLIQUES :
|
|
// surcharge de l'opérateur =
|
|
Condilineaire& operator = (const Condilineaire& cond);
|
|
|
|
inline const Tableau<int>& Pt_t() const{ return pt;};
|
|
Tableau<int>& ChangePt() { return pt;}; // acces lecture / écriture
|
|
inline const Vecteur& Val() const{ return val;};
|
|
Vecteur& Valchange() {return val;}; // acces lecture / écriture
|
|
void ChangeCoeff(const Vecteur& v) {val=v;};
|
|
inline double Beta() const { return beta;};
|
|
double& BetaChange() { return beta;}; // acces lecture / écriture
|
|
void ChangeBeta(const double& x) { beta = x;};
|
|
|
|
// dans le cas de la mise en place de la CL à partir d'un changement de repère, on peut stocker la valeur imposée avant chg de repère
|
|
// cette valeur a imposer sur le ddl avant changement de repère, correspondra à beta après chg de repère
|
|
// Uk_impose sert uniquement de stockage, mais n'est pas forcément cohérent avec la CL, sa manipulation est faite en dehors de la classe
|
|
// via les deux méthodes qui suivent
|
|
void ChangeUk_impose(double Uk_new) {Uk_impose=Uk_new;};
|
|
// lorsque la valeur retourné par Val_Uk_impose() == ConstMath::tresgrand, cela signifie qu'elle n'est pas a considérer
|
|
const double & Val_Uk_impose() const {return Uk_impose;};
|
|
|
|
Noeud* Noe() {return t_noeud(1);}; // acces lecture / écriture
|
|
void Change_tab_enum(const Tableau <Enum_ddl> & t_enuu) {t_enu = t_enuu;};
|
|
// le tableau de noeuds associé
|
|
const Tableau < Noeud *>& TabNoeud() const { return t_noeud;};
|
|
void ChangeTabNoeud(const Tableau < Noeud *>& t_n) {t_noeud = t_n;};
|
|
|
|
// Iddl() -> le numéro d'ordre dans sa famille, du ddl bloqué
|
|
// NB: ce n'est pas la position du ddl dans le noeud !!, cette dernière est: Tab_Enum()(1)
|
|
inline const int& Iddl() const { return iddl;};
|
|
int& ChangeIddl() { return iddl;}; // acces lecture / écriture
|
|
|
|
// changement de la taille des tableaux de pointeur et valeurs
|
|
void Change_taille(int taille) {pt.Change_taille(taille); val.Change_taille(taille);};
|
|
|
|
// mise en place des pointeurs de ddl d'assemblage
|
|
const Condilineaire& ConditionPourPointeursAssemblage(const Nb_assemb& nb_casAssemb);
|
|
const Nb_assemb& CasAssemb() const {return casAssemb;};
|
|
|
|
// retour du tableau d'énuméré correspondant aux coefficients de la CLL
|
|
const Tableau <Enum_ddl >& Tab_Enum() const {return t_enu;};
|
|
|
|
// ramène la différence maxi qui existe entre les numéros de noeuds de la condition linéaire
|
|
// peut-être utilisé pour calculer une largeur de bande par exemple
|
|
// important: cette méthode n'est valide que si les numéros de noeuds sont tous différents
|
|
// donc que la numérotation interne des noeuds a été changé pour cela
|
|
// NB: en fonctionnement normal, ce n'est pas le cas ! sauf dans le cas où un seul maillage existe
|
|
// voir LesMaillages::Renumerotation( pour un exemple d'utilisation
|
|
int DiffMaxiNumeroNoeud()const;
|
|
|
|
// ramène la largeur de bande en ddl
|
|
// à cause de la condition linéaire
|
|
// casAssemb : donne le cas d'assemblage a prendre en compte
|
|
// les condi linéaires ne donnent pas des largeurs de bande sup et inf égales !!!
|
|
// I/O : demi = la demi largeur de bande maxi ,
|
|
// total = le maxi = la largeur sup + la largeur inf +1
|
|
void Largeur_Bande(int& demi,int& total,const Nb_assemb& casAssemb);
|
|
|
|
// affichage à l'écran des infos de la CL
|
|
void Affiche() const ;
|
|
|
|
//----- lecture écriture de restart -----
|
|
// la lecture ramène en retour le numéro de maillage et le numéro de
|
|
// noeud sur lequel s'applique la condition limite
|
|
// il est nécessaire ensuite d'utiliser la fonction Change_noeud pour`
|
|
// attibuer le noeud
|
|
void Lecture_base_info(Tableau <int>& numMaillage, ifstream& ent,Tableau <int>& numNoeud) ;
|
|
void Ecriture_base_info(ofstream& sort) ;
|
|
#ifdef UTILISATION_MPI // spécifique au calcul parallèle
|
|
// stockage dans un unique vecteur, des infos à partir de l'indice rang inclus
|
|
// correspond à une sérialisation des infos
|
|
// ramène le positionnement dans v pour un prochain enreg, sauf si > à la taille de v
|
|
// dans ce cas ramène 0
|
|
int Pack_vecteur(Vecteur& v,int rang) const;
|
|
// taille du conteneur actuel de la condition linéaire
|
|
int Taille_Pack() const;
|
|
// modification des infos à partir de l'indice rang inclus en fonction du vecteur passé en paramètre
|
|
// correspond à une désérialisation
|
|
// ramène le positionnement dans v pour un prochain enreg, sauf si > à la taille de v
|
|
// dans ce cas ramène 0
|
|
// on passe un pointeur de fonctions qui ramène un noeud en fonction d'un numéro de maillage et d'un
|
|
// numéro de noeud, ceci pour éviter de passer toute l'instance de la classe Les_maillages
|
|
template <class T> int UnPack_vecteur(T& instance,const Vecteur& v,int rang,
|
|
Noeud & (T::*Ptfonc) (int num_mail,int num_noeud) const );
|
|
#endif
|
|
|
|
protected :
|
|
// VARIABLES PROTEGEES :
|
|
Tableau<int> pt; //tableau des pointeurs de ddl concerne, pt(i) = la position du ddl i
|
|
// dans la matrice globale
|
|
Vecteur val; // tableau des coefficients de la condition lineaire
|
|
double beta; // valeur beta a laquelle est egale la condition lineaire
|
|
// dans le cas de la mise en place de la CL à partir d'un changement de repère, on peut stocker la valeur imposée avant chg de repère
|
|
double Uk_impose; // valeur a imposer sur le ddl avant changement de repère, qui correspondra à beta après chg de repère
|
|
// Uk_impose sert uniquement de stockage, mais n'est pas forcément cohérent avec la CL, sa manipulation est faite en dehors de la classe
|
|
// via : ChangeUk_impose et Val_Uk_impose
|
|
Nb_assemb casAssemb; // le cas d'assemblage associé
|
|
|
|
// le blocage de condition est appliquee sur le ddl numero "iddl" du noeud "noe"
|
|
Tableau <Enum_ddl > t_enu; // tableau des identificateur de ddl de la CLL
|
|
// t_enu(1) est l'identificateur du ddl qui est bloqué pour la CLL
|
|
// lorsque seul t_enu(1) existe, cela signifie qu'il faut construire
|
|
// les indices,
|
|
|
|
// iddl -> le numéro d'ordre dans sa famille, du ddl bloqué
|
|
// NB: ce n'est pas la position du ddl dans le noeud !!, cette dernière est: Tab_Enum()(1)
|
|
int iddl;
|
|
// le tableau des noeuds de la CLL, le premier contient la condition
|
|
Tableau < Noeud *> t_noeud;
|
|
|
|
|
|
// METHODES PROTEGEES :
|
|
|
|
};
|
|
// pour faire de l'inline: nécessaire avec les templates
|
|
// on n'inclut que les méthodes templates
|
|
#include "Condilineaire_2.cc"
|
|
#define Condilineaire_deja_inclus
|
|
/// @} // end of group
|
|
|
|
#endif
|