259 lines
12 KiB
C++
259 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: Def et application de differentes conditions limites. *
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
|
|
* VERIFICATION: *
|
|
* *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* ! ! ! ! *
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
|
|
* MODIFICATIONS: *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* $ *
|
|
************************************************************************/
|
|
#ifndef CONDLIM_H
|
|
#define CONDLIM_H
|
|
|
|
#include "Mat_abstraite.h"
|
|
#include "Vecteur.h"
|
|
#include <list>
|
|
#include "MathUtil.h"
|
|
#include "Mat_pleine.h"
|
|
|
|
|
|
/// @addtogroup Les_classes_Matrices
|
|
/// @{
|
|
///
|
|
|
|
|
|
class CondLim
|
|
{ // pour pouvoir faire des tableaux de condlim on introduit les surcharges de lecture
|
|
// écriture, mais en fait elles ne doivent pas être utilisé d'où une sortie d'erreur
|
|
// surcharge de l'operator de lecture typée
|
|
friend istream & operator >> (istream & ent, CondLim &)
|
|
{ cout << "\n erreur, la surcharge de lecture n'est pas implanté "
|
|
<< " \n operator >> (istream & ent, CondLim &) " ;
|
|
Sortie(1); return ent;
|
|
};
|
|
// surcharge de l'operator d'ecriture typée
|
|
friend ostream & operator << (ostream & sort, const CondLim &)
|
|
{ cout << "\n erreur, la surcharge d'écriture n'est pas implanté "
|
|
<< " \n operator << (ostream & sort, const CondLim &)";
|
|
Sortie(1); return sort;
|
|
};
|
|
|
|
public :
|
|
// CONSTRUCTEURS :
|
|
CondLim();
|
|
// DESTRUCTEUR :
|
|
~CondLim();
|
|
// METHODES PUBLIQUES :
|
|
//=============================================================================
|
|
// IMPORTANT !! = lorsque l'on a des conditions limites a imposer a un second =
|
|
// membre et a une matrice , il faut d'abord impose a la matrice puis =
|
|
// apres au second membre =
|
|
//=============================================================================
|
|
// valeur imposee au second membre
|
|
// vecglob : le second membre, i : la position globale du ddl impose
|
|
// val : la valeur a imposer
|
|
// 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 Val_imposee_Sm(Vecteur& vecglob,int i,double val,Vecteur* vec2);
|
|
// valeur imposee a la matrice et au second membre si la valeur est
|
|
// differente de zero
|
|
// matglob : la matrice, i : la position globale du ddl impose
|
|
// val : la valeur a imposer
|
|
// 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 Val_imposee_Mat(Mat_abstraite & matglob,Vecteur& vecglob,
|
|
int i,double val,Vecteur* vec2);
|
|
// cas particulier de valeur imposee a une matrice
|
|
// c'a-dire val sur la diagonale
|
|
// et des zéros sur le reste de la ligne et colonne corsespondantes
|
|
// matglob : la matrice, i : la position globale du ddl impose
|
|
// dans ce cas-ci il n'y a aucune information sauvegardée, des valeurs modifiées
|
|
// cela signifie qu'après cette fonction, les appels aux routines pour la
|
|
// remontée aux réactions, n'ont aucun sens
|
|
void Val_imposSimple_Mat(Mat_abstraite & matglob,int i,double val);
|
|
// remontee aux efforts apres resolution
|
|
// ceci pour la ligne i dans le cas de ddl bloque
|
|
// la matrice est utilisee pour restorer les lignes supprimee
|
|
// par les conditions limites, elle est donc modifiee
|
|
// par cette operation, parcontre ses valeurs initiales ne sont pas utilisees
|
|
double RemonteDdlBloqueMat(Mat_abstraite & matglob,Vecteur& solution, int i);
|
|
|
|
// retourne la valeur absolu du maxi des efforts exterieurs
|
|
// et le numero d'assemblage correspondant
|
|
double MaxEffort(int & ili);
|
|
|
|
// retourne la valeur initiale au second membre avant condition limite
|
|
// en fonction du pointeur d'assemblage
|
|
double ValReact(int & ili);
|
|
|
|
//------------------------------------------------------------------
|
|
// cas de conditions limites lineaires entre plusieurs ddl
|
|
//------------------------------------------------------------------
|
|
// la condition est imposee sur la matrice et sur le second membre
|
|
// la mise en place des condition lineaire doit ce faire en deux temps
|
|
// premier temps : préparation des conditions, c'est a dire expression
|
|
// de la raideur et du second membre dans les reperes locaux ceci pour
|
|
// TOUS LES CONDITIONS
|
|
// second temps : seulement une fois que TOUTES LES changements de reperes
|
|
// sont effectuee, on impose les valeurs de second memebres apres ou avant
|
|
// les valeurs fixe.
|
|
|
|
// pt : tableau des pointeurs de ddl concerne, pt(i) = la position du ddl i
|
|
// dans la matrice globale
|
|
// val : tableau des coefficients de la condition lineaire
|
|
// valeur : valeur a laquelle est egale la condition lineaire
|
|
// cond lineire -> somme des val(i) * ddl(pt(i)) = valeur
|
|
// la procedure modifie les reperes d'expression des ddl, mais sauvegarde
|
|
// les infos permettant de reconstruire les reperes initiaux
|
|
// !!! par principe, c'est la direction du premier indice qui est bloquee
|
|
// il faut donc ecrire la condition en consequence
|
|
|
|
// 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)
|
|
|
|
// premier temps: changement de repère
|
|
|
|
void CondlineaireCHRepere(Mat_abstraite & matglob,Vecteur& vecglob,
|
|
const Tableau<int> & pt,const Vecteur& val, double valeur,Vecteur* vec2);
|
|
|
|
// second temps : imposition des blocages correspondant
|
|
// aux conditions lineaires
|
|
|
|
void CondlineaireImpose (Mat_abstraite & matglob,Vecteur& vecglob,Vecteur* vec2);
|
|
|
|
|
|
//expression du vecteur resultat dans les reperes initiaux
|
|
// sol : la solution, est modifie et retournee dans les reperes initiaux
|
|
void RepInitiaux( Vecteur& sol);
|
|
|
|
// application d'une condition linéaire seule, avec en retour, la situation de la condition linéaire
|
|
// imposée, ramené dans le repère initial
|
|
void CondiLineaireImposeComplet(Mat_abstraite & matglob,Vecteur& vecglob,
|
|
const Tableau<int> & pt,const Vecteur& val, double valeur,Vecteur* vec2);
|
|
|
|
|
|
// remise a zero des sauvegardes de second membre et de matrice
|
|
void EffaceSauvegarde();
|
|
|
|
// remise a zero des sauvegardes de condition lineaire
|
|
void EffaceCoLin();
|
|
|
|
|
|
|
|
private :
|
|
// VARIABLES PROTEGEES :
|
|
// concernant une valeur imposee pour le second membre, on defini une
|
|
// class qui permet d'enregistrer les ddl impose
|
|
class ImpSM
|
|
{ public :
|
|
ImpSM () {}; // par defaut
|
|
ImpSM (int i, double val) : iligne(i), valeur(val) {};
|
|
ImpSM (const ImpSM & a) : iligne(a.iligne), valeur(a.valeur) {};
|
|
~ImpSM () {};
|
|
ImpSM& operator=( const ImpSM& a) ; // assigment
|
|
|
|
int iligne; // ligne ou le ddl est impose
|
|
double valeur; // sauvegarde de la valeur existant avant le ddl impose
|
|
};
|
|
|
|
// on definit une liste STL comme container
|
|
list <ImpSM> VImpSM;
|
|
|
|
//concernant une valeur imposee pour la raideur, on defini une
|
|
// class qui permette d'enregistrer les modifications effectuees
|
|
// sur la raideur
|
|
class ImpRaid
|
|
{ public :
|
|
ImpRaid (); // par defaut
|
|
ImpRaid (int i,const Vecteur& vL,const Vecteur& vC,double val);
|
|
ImpRaid (const ImpRaid & a) ; // constructeur de copie
|
|
~ImpRaid() {}; // destructeur
|
|
ImpRaid& operator=( const ImpRaid& a) ; // assigment
|
|
|
|
int ilicol; // ligne et colonne ou le ddl est impose
|
|
Vecteur ligne; // ligne du ddl impose
|
|
Vecteur colonne; // colonne du ddl impose
|
|
double valeur; // valeur du ddl impose
|
|
};
|
|
// on definit une liste STL comme container
|
|
list <ImpRaid> VImpRaid;
|
|
|
|
//concernant les conditions lineaires, on defini une
|
|
// class qui permette d'enregistrer le changement de repere
|
|
class lineaires
|
|
{ public :
|
|
lineaires (); // par defaut
|
|
lineaires (int i,const Vecteur& vL,const Tableau<int> & ptt,double vale);
|
|
lineaires (const lineaires & a) ; // constructeur de copie
|
|
~lineaires() {}; // destructeur
|
|
lineaires& operator=( const lineaires& a) ; // assigment
|
|
|
|
int indice; // numero dans le tableau pt qui permet d'obtenir les
|
|
//ligne et colonne du ddl modifie en condition lineaire
|
|
Vecteur val; // vecteur des coefficients de la condition lineaire
|
|
Tableau<int> pt; // pt : tableau des pointeurs de ddl concerne, pt(i) = la position du ddl i
|
|
// dans la matrice globale
|
|
double valeur; // valeur de la condition lineaire
|
|
};
|
|
// on definit une liste STL comme container
|
|
list <lineaires> Vlineaires;
|
|
|
|
// méthode pour faire une rotation de la matrice et du second membre suivant un vecteur
|
|
// vec2 : est un second vecteur éventuel (si != NULL)
|
|
void Rotation(Mat_abstraite & matglob,Vecteur& vecglob,
|
|
const Tableau<int> & pt,const Vecteur& val,Vecteur* vec2);
|
|
|
|
// déclaration d'une variable de travail, utilisée par CondlineaireCHRepere
|
|
static Mat_pleine matinter; // mise en commun pour éviter des constructions inutiles
|
|
|
|
|
|
// METHODES PROTEGEES :
|
|
|
|
};
|
|
/// @} // end of group
|
|
|
|
#endif
|