// FICHIER : Ddl.h
// CLASSE : Ddl
// 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) .
//
// 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 .
//
// For more information, please consult: .
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* La classe Ddl permet de declarer des degres de liberte.
* soit c'est une variable ou soit c'est une données qui peuvent être soit active
* soit hors-service
* ensuite soit il est fixe ou soit il est bloqué
* 1) libre, fixe, ou 2) hors service libre ou hors service fixe ===> une variable
* 3) lisible libre ou fixe ou 4) hors service libre ou fixe ===> une donnée
* 1) c'est pour les ddl qui sont des variables que le calcul va déterminer,
* 2) sont les variables qui sont hors service: on ne les considères pas
* 3) sont des variables que l'on peut utiliser mais que le calcul ne
* cherche pas à déterminer: elle sont en lecture seule en quelque sorte
* 4) se sont des données qui ne sont pas dispon pour la consultation (par exemple hors temps)
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
// La classe Ddl permet de declarer des degres de liberte.
// soit c'est une variable ou soit c'est une données qui peuvent être soit active
// soit hors-service
// ensuite soit il est fixe ou soit il est bloqué
// 1) libre, fixe, ou 2) hors service libre ou hors service fixe ===> une variable
// 3) lisible libre ou fixe ou 4) hors service libre ou fixe ===> une donnée
// 1) c'est pour les ddl qui sont des variables que le calcul va déterminer,
// 2) sont les variables qui sont hors service: on ne les considères pas
// 3) sont des variables que l'on peut utiliser mais que le calcul ne
// cherche pas à déterminer: elle sont en lecture seule en quelque sorte
// 4) se sont des données qui ne sont pas dispon pour la consultation (par exemple hors temps)
#ifndef DDL_H
#define DDL_H
#include "Enum_ddl.h"
#include "Enum_boolddl.h"
#include
#include
#include "Sortie.h"
#include
// #include
/** @defgroup Les_classes_Ddl_en_tout_genre
*
* BUT:def de classes relatives aux ddl en tout genre
* Ddl, Ddl_etendu, DdlElement, DdlLim etc.
*
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
* \brief Def de classes relatives aux ddl en tout genre
*
*/
/// @addtogroup Les_classes_Ddl_en_tout_genre
/// @{
///
/// BUT: La classe Ddl permet de declarer des degres de liberte.
/// soit c'est une variable ou soit c'est une données qui peuvent être soit active
/// soit hors-service
/// ensuite soit il est fixe ou soit il est bloqué
/// 1) libre, fixe, ou 2) hors service libre ou hors service fixe ===> une variable
/// 3) lisible libre ou fixe ou 4) hors service libre ou fixe ===> une donnée
/// 1) c'est pour les ddl qui sont des variables que le calcul va déterminer,
/// 2) sont les variables qui sont hors service: on ne les considères pas
/// 3) sont des variables que l'on peut utiliser mais que le calcul ne
/// cherche pas à déterminer: elle sont en lecture seule en quelque sorte
/// 4) se sont des données qui ne sont pas dispon pour la consultation (par exemple hors temps)
///
/// \author Gérard Rio
/// \version 1.0
/// \date 23/01/97
///
///
class Ddl
{
// surcharge de l'operator de lecture
friend istream & operator >> (istream & entree, Ddl& a);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort, const Ddl& a);
public:
// CONSTRUCTEURS :
// Constructeur eventuellement par defaut
Ddl (Enum_ddl id_nom_ddl=NU_DDL,double val=0.0,Enum_boolddl val_fixe=HS_LISIBLE_LIBRE);
// Constructeur se servant d'un nom
// ( N.B. : val et val_fixe ont des valeurs par defaut, il n'est par consequent
// pas obligatoire de leur donner des valeurs a l'appel de ce constructeur )
Ddl (char* nom,double val=0.0,Enum_boolddl val_fixe=HS_LISIBLE_LIBRE);
// Constructeur de copie
Ddl (const Ddl& d);
// DESTRUCTEUR :
~Ddl ();
// METHODES :
// Retourne 1 si le degre de liberte a une valeur fixée tout au long du calcul
// Retourne 0 sinon
// ne concerne que les variables (par exemple ne concerne pas les données)
bool Fixe() const;
// test pour savoir si le ddl est une variable ou une donnée
bool UneVariable() const;
// changement du statut de variable à donnée
void ChangeVariable_a_Donnee();
// changement du statut de donnée à variable
void ChangeDonnee_a_Variable();
// Retourne la valeur de fixe en lecture uniquement
inline const Enum_boolddl Retour_Fixe() const { return fixe ; };
// Modifie la valeur de fixe, si val est vrai -> blocage , sinon libre
void Change_fixe(bool val);
// modifie toute les conditions sauf la valeur: c-a-d:
// le fixage, le fait que c'est une variable ou une donnée, le fait
// d'être en service ou non etc..
void CopieToutesLesConditions( Enum_boolddl en) {fixe = en;};
// test pour savoir si le ddl est en service ou pas
inline bool Service() const
{ return (!(Est_HS(fixe)));};
// test si le ddl est SOUSLIBRE ou SURFIXE, ramène true si oui
bool SousSurFixe() const;
// remise à normal si le ddl est en souslibre ou surfixe
// s'il est en souslibre il passe en libre et s'il est en surfixe il passe en fixe
// sinon on ne fait rien
void Retour_normal_sur_ou_sous_fixe();
// met hors_service le ddl ou la donnée, cela signifie que momentanément il ne sert plus
void Met_hors_service();
// met en service le ddl ou la donnée
void Met_en_service();
// met hors_service le ddl, cela signifie que momentanément il ne sert plus
// ne concerne pas les données
void Met_hors_service_ddl();
// met en service le ddl, ne concerne pas les données
void Met_en_service_ddl();
// Retourne la valeur associee au degre de liberte
inline double& Valeur() { return val_ddl; };
// Retourne le nom associe au degre de liberte
inline const string Nom() const { return Nom_ddl(id_nom); };
// Retourne la variable de type enumere associee au nom du degre de liberte
inline Enum_ddl Id_nom() const { return id_nom; };
// Remplace le nom du degre de liberte par nouveau_nom
// (par l'intermediaire du type enumere associe)
// ATTENTION : Les modifications liees au changement de nom du degre
// de liberte sont a la charge de l'utilisateur.
inline void Change_nom(char* nouveau_nom)
{ id_nom=Id_nom_ddl(nouveau_nom); };
// Remplace l'identificateur de nom du degre de liberte par
// nouveau_id
// ATTENTION : Les modifications liees au changement de nom du degre
// de liberte sont a la charge de l'utilisateur.
inline void Change_nom(Enum_ddl nouveau_id)
{ id_nom=nouveau_id; };
// Affiche les donnees liees au degre de liberte
void Affiche() const ;
inline Ddl& operator= (const Ddl& d)
// Realise l'egalite entre deux degres de liberte
{ id_nom=d.id_nom;
val_ddl=d.val_ddl;
fixe=d.fixe;
return (*this);
};
//Surcharge d'operateur logique
bool operator == ( const Ddl& a) const ;
bool operator != ( const Ddl& a) const;
// test si le degre de liberte est complet
// = 1 tout est ok, =0 element incomplet
int TestComplet() const;
protected :
Enum_ddl id_nom; // identificateur du nom
// bool fixe; // booleen pour savoir si la valeur associee au
// degre de liberte est fixe pendant tout le calcul
Enum_boolddl fixe; // 1) libre, fixe, ou 2) hors service libre ou hors service fixe
// ou 3) lisible libre ou fixe
// cf. l'énuméré
double val_ddl; // valeur associee
};
/// @} // end of group
// pour faire de l'inline
#ifndef MISE_AU_POINT
#include "Ddl.cc"
#define Ddl_deja_inclus
#endif
#endif