// 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) <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:        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 <iostream>
#include <stdlib.h>
#include "Sortie.h"
#include <string>
// #include <bool.h>

/** @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
