332 lines
13 KiB
C++
Executable file
332 lines
13 KiB
C++
Executable file
// FICHIER : DdlLim.h
|
|
// CLASSES : DdlLim
|
|
|
|
// 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/>.
|
|
|
|
/************************************************************************
|
|
* DATE: 15/04/1997 *
|
|
* $ *
|
|
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
|
|
* $ *
|
|
* PROJET: Herezh++ *
|
|
* $ *
|
|
************************************************************************
|
|
* BUT: La classe DdlLim permet de declarer un ensemble de ddl coiffe *
|
|
* par une reference utilise pour les conditions limites. $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
|
|
* VERIFICATION: *
|
|
* *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* ! ! ! ! *
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
|
|
* MODIFICATIONS: *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* $ *
|
|
************************************************************************/
|
|
|
|
|
|
#ifndef DDLLIM_H
|
|
#define DDLLIM_H
|
|
|
|
|
|
#include "Ddl.h"
|
|
#include "Tableau_T.h"
|
|
#include <iostream>
|
|
#include <stdlib.h>
|
|
#include "Sortie.h"
|
|
#include "UtilLecture.h"
|
|
#include "string.h"
|
|
#include "string"
|
|
#include <list>
|
|
#include "MvtSolide.h"
|
|
#include "EnuTypeCL.h"
|
|
|
|
/// @addtogroup Les_classes_Ddl_en_tout_genre
|
|
/// @{
|
|
///
|
|
|
|
|
|
/// BUT: La classe DdlLim permet de declarer un ensemble de ddl coiffe par une reference utilise pour les conditions limites.
|
|
///
|
|
/// \author Gérard Rio
|
|
/// \version 1.0
|
|
/// \date 15/04/1997
|
|
///
|
|
///
|
|
|
|
|
|
class DdlLim
|
|
{ // surcharge de l'operator de lecture
|
|
// les informations sont typées
|
|
friend istream & operator >> (istream &, DdlLim &);
|
|
// surcharge de l'operator d'ecriture typée
|
|
friend ostream & operator << (ostream &, const DdlLim &);
|
|
|
|
public:
|
|
|
|
|
|
// CONSTRUCTEURS :
|
|
|
|
// Constructeur defaut
|
|
DdlLim ();
|
|
|
|
// Constructeur de copie
|
|
DdlLim (const DdlLim& d);
|
|
|
|
|
|
// DESTRUCTEUR :
|
|
~DdlLim ();
|
|
|
|
|
|
// METHODES :
|
|
|
|
// Retourne la reference attache au degre de liberte
|
|
const string& NomRef () const { return ref; };
|
|
// retourne un pointeur de string donnant le nom du maillage associé
|
|
// = NULL si aucun maillage
|
|
const string* NomMaillage() const {return nom_maillage;};
|
|
// retourne le type de condition limite associé
|
|
EnuTypeCL TypeDeCL() const {return typeCL;};
|
|
|
|
// retourne la taille du tableau de ddl
|
|
int Taille() const { return tab.Taille();};
|
|
|
|
// retourne le ddl nb i en lecture/écriture
|
|
Ddl& ElemLim(int i) { return tab(i).ddl;};
|
|
// idem en constant
|
|
const Ddl& ElemLim_const(int i) const { return tab(i).ddl;};
|
|
|
|
// retourne le nom de la courbe i ou "" s'il n'y en n'a pas
|
|
// dans le cas d'un mouvement solide, c'est uniquement le premier ddl
|
|
// qui contient la courbe de charge éventuelle
|
|
const string& Nom_courbe(int i) const { return tab(i).co_charge;};
|
|
|
|
// retourne le nom de la fonctionnD i ou "" s'il n'y en n'a pas
|
|
// dans le cas d'un mouvement solide, c'est uniquement le premier ddl
|
|
// qui contient la courbe de charge éventuelle
|
|
const string & NomF_charge(int i) const {return tab(i).f_charge;};
|
|
|
|
// retourne si la référence est celle d'un champ ou pas
|
|
bool Champ() const {return champ;};
|
|
|
|
// retourne si le blocage est relatif ou pas
|
|
// un blocage relatif signifie que le blocage s'effectue par rapport au pas de temps
|
|
// précédent i.e. t=t
|
|
// un blocage non relatif, donc absolue signifie que le blocage s'effectue par rapport à
|
|
// t = 0
|
|
bool BlocageRelatif() const {return blocage_relatif;};
|
|
|
|
// indique si c'est un mouvement solide ou pas
|
|
bool Mouvement_Solide() const {return (mvtsolide!=NULL);};
|
|
// récupération du mouvement solide
|
|
const MvtSolide* Const_MouvementSolide() const {return mvtsolide;};
|
|
// récupération du mouvement solide
|
|
MvtSolide* MouvementSolide() const {return mvtsolide;};
|
|
|
|
// retourne l'échelle pour le ddl nb i
|
|
// dans le cas d'un mouvement solide, c'est uniquement le premier ddl
|
|
// qui contient la courbe de charge éventuelle
|
|
double Echelle_courbe(int i) const {return tab(i).echelle;};
|
|
|
|
// indique si le temps mini et/ou le temps maxi dépend d'une fonction nD
|
|
// retour:
|
|
// 0 : pas de dépendance
|
|
// 1 : tmin uniquement
|
|
// 2 : tmax uniquement
|
|
// 3 : tmin et tmax
|
|
|
|
int Temps_depend_nD() const
|
|
{int retour = 0; if (nom_fnD_t_min != "") {if (nom_fnD_t_max != "") return 3;else return 1;}
|
|
else {if (nom_fnD_t_max != "") return 2;else return 0;};
|
|
};
|
|
|
|
// retour du nom de la fonction nD qui pilote tmin
|
|
// si == "", pas de fonction
|
|
string Nom_fctnD_tmin() const {return nom_fnD_t_min;};
|
|
// idem pour tmax
|
|
string Nom_fctnD_tmax() const {return nom_fnD_t_max;};
|
|
|
|
// mise à jour de tmin et/ou tmax
|
|
// uniquement s'ils dépendent d'une fct nD
|
|
void Mise_a_jour_tmin_tmax(double tmin, double tmax)
|
|
{ if (nom_fnD_t_min != "") t_min = tmin;
|
|
if (nom_fnD_t_max != "") t_max = tmax;
|
|
};
|
|
// mise à jour de tmin
|
|
// uniquement s'il dépend d'une fct nD
|
|
void Mise_a_jour_tmin(double tmin)
|
|
{ if (nom_fnD_t_min != "") t_min = tmin;
|
|
};
|
|
// mise à jour de tmax
|
|
// uniquement s'il dépend d'une fct nD
|
|
void Mise_a_jour_tmax(double tmax)
|
|
{ if (nom_fnD_t_max != "") t_max = tmax;
|
|
};
|
|
|
|
// retourne un booléen qui indique si oui ou non le temps passé en paramètre
|
|
// est situé entre le temps min et maxi du ddllim
|
|
bool Temps_actif(const double& temps) const
|
|
{if ((t_min < temps) && (temps <= t_max))
|
|
return true;
|
|
else return false;
|
|
};
|
|
|
|
// ramène vrai si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif
|
|
bool Pas_a_prendre_en_compte(const double& temps) const
|
|
{if ((temps <= t_min) || ((temps > t_max) && !precedent))
|
|
return true;
|
|
else return false;
|
|
};
|
|
// ramène vrai si le temps est inférieur ou égale au temps actif, ou supérieur au temps max
|
|
bool Pas_a_prendre_en_compte_dans_intervalle(const double& temps) const
|
|
{if ((temps <= t_min) || (temps > t_max))
|
|
return true;
|
|
else return false;
|
|
};
|
|
|
|
// affichage et definition interactive des commandes
|
|
// plusieurs_maillages : indique si oui ou non, il y a plusieurs maillage
|
|
void Info_commande_DdlLim(ofstream & sort,bool plusieurs_maillages);
|
|
|
|
// Validation on non de l'activité du ddlLim
|
|
void Validation(const double& temps) {precedent = Temps_actif(temps);};
|
|
// retour du statut de validation
|
|
// vrai signifie que l'état enregistré est actif
|
|
bool Etat_validation() const {return precedent;};
|
|
|
|
|
|
// lecture des degres de liberte
|
|
// sur le fichier d'entree
|
|
// util pour la lecture de ddl bloque
|
|
void Lecture(UtilLecture & entreePrinc);
|
|
|
|
// examine si le ddlmin passé en argument possède les mêmes cibles que this
|
|
// mais que les data associés sont différents
|
|
// ramène true si c'est vrai, false sinon
|
|
bool MemeCibleMaisDataDifferents(const DdlLim& d) const;
|
|
|
|
// ramène true si le DdlLim contient l'enum_ddl passé en argument, false sinon
|
|
bool Existe_ici_leDdl(Enum_ddl enu) const;
|
|
// ramène true si le DdlLim contient au moins un déplacement, false sinon
|
|
bool Existe_ici_un_deplacement() const;
|
|
|
|
// Affiche les donnees liees aux degres de liberte
|
|
void Affiche () const ;
|
|
|
|
// Realise l'egalite
|
|
DdlLim& operator= (const DdlLim& d);
|
|
|
|
//Surcharge d'operateur logique
|
|
bool operator == ( const DdlLim& a) const ;
|
|
|
|
bool operator != ( const DdlLim& a) const { return !(*this == a);};
|
|
|
|
// ----------- définition de conteneurs à usage interne -----------
|
|
// cependant elles ne peuvent pas être déclaré en protégé ??
|
|
// protected :
|
|
|
|
// le conteneur des ddl bloqués
|
|
class Ddlbloque
|
|
{ public:
|
|
// surcharge de l'operator de lecture
|
|
friend istream & operator >> (istream & entree, Ddlbloque& d);
|
|
// surcharge de l'operator d'ecriture
|
|
friend ostream & operator << (ostream & sort, const Ddlbloque& d);
|
|
// constructeur
|
|
Ddlbloque() : co_charge(""),f_charge(""),ddl(),echelle(1.) {};
|
|
Ddlbloque(const Ddlbloque& d): co_charge(d.co_charge)
|
|
,f_charge(d.f_charge),ddl(d.ddl),echelle(d.echelle) {};
|
|
Ddlbloque(Ddl ddl_): co_charge(""),f_charge(""),ddl(ddl_),echelle(1.) {};
|
|
// destructeur
|
|
~Ddlbloque() {};
|
|
// surcharge de l'opérateur d'affectation
|
|
Ddlbloque& operator= (const Ddlbloque& d);
|
|
//Surcharge d'operateur logique
|
|
bool operator == ( Ddlbloque& a);
|
|
bool operator != ( Ddlbloque& a);
|
|
public:
|
|
Ddl ddl; // ddl bloqué
|
|
string co_charge; // nom d'une courbe de charge éventuelle
|
|
string f_charge; // nom d'une fonction nD utilisant des variables globales et autres
|
|
double echelle;
|
|
};
|
|
|
|
protected :
|
|
|
|
// données
|
|
string* nom_maillage; // nom de maillage associé, éventuellement!
|
|
string ref; // reference attachee aux ddl
|
|
EnuTypeCL typeCL; // indique éventuellement un type de condition limite associé
|
|
// = RIEN_TYPE_CL par exemple pour les noeuds (donc ne sert à rien dans ce cas)
|
|
// = TANGENTE_CL par exemple pour une arête, indique une condition de tangente imposée
|
|
Tableau <Ddlbloque> tab; // tableau des ddl
|
|
double t_min,t_max; // temps mini et maxi de durée des ddl imposés
|
|
string nom_fnD_t_min; // nom éventuelle de la fonction associée
|
|
string nom_fnD_t_max; // nom éventuelle de la fonction associée
|
|
int precedent; // pour la description de l'évolution du ddlLim
|
|
bool champ; // indique si c'est une référence de champ ou pas
|
|
bool blocage_relatif; // indique si oui ou non le blocage à t+dt s'effectue
|
|
// par rapport à t ou par rapport à 0
|
|
MvtSolide* mvtsolide; // indique si diff de NULL qu'il s'agit d'un mouvement solide appliqué
|
|
// si oui, tab contient les 3 ddl de position, dont le premier contient éventuellement
|
|
// une courbe de charge si on veut un pilotage du mvt solide par courbe de charge,
|
|
// ainsi qu'une échelle éventuelle globale
|
|
|
|
|
|
// FONCTIONS PROTEGEES
|
|
// verification en fonction de la dimension du pb
|
|
// par exemple en dim 2 d'existance des UZ ou des X3 etc..
|
|
void VerifDimDdl();
|
|
// lecture dans le cas particulier d'un champ
|
|
list <Ddlbloque> Lecture_champ(UtilLecture & entreePrinc);
|
|
// lecture dans le cas particulier d'un mouvement solide
|
|
list <Ddlbloque> Lecture_mvtSolide(UtilLecture & entreePrinc);
|
|
|
|
// Remplace la reference du degre de
|
|
// liberte par nouveau
|
|
// ATTENTION : Les modifications liees au changement de la reference du degre
|
|
// de liberte sont a la charge de l'utilisateur, en particulier il n'y a pas
|
|
// de vérification par exemple du fait que c'est un champ ou pas .
|
|
void Change_ref (string nouveau);
|
|
// idem pour le changement de nom de maillage
|
|
// le nouveau nom ne doit pas être vide !! sinon erreur
|
|
void Change_nom_maillage(const string& nouveau);
|
|
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
|
|
#endif
|