Herezh_dev/References/Reference.h
2023-05-03 17:23:49 +02:00

224 lines
8.9 KiB
C++

// FICHIER : Reference.h
// CLASSE : Reference
// 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: 06/02/00 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: classe général virtuel des références. Les classes dérivées*
* permettent de définir précisemment les différentes références : *
* de noeuds, d'élément, d'aretes, de faces etc.. *
* Une instance de la classe s'identifie a partir d'un nom *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
/** @defgroup Les_classes_Reference
*
* BUT: Definir les différentes références
* de noeuds, d'élément, d'aretes, de faces, de pti etc..
*
*
* \author Gérard Rio
* \version 1.0
* \date 06/02/00
* \brief Definir les différentes références de noeuds, d'élément, d'aretes, de faces, de pti etc..
*
*/
#ifndef REFERENCE_H
#define REFERENCE_H
#include <iostream>
#include <string>
//#include "Debug.h"
#include "Tableau_T.h"
#include "UtilLecture.h"
#include <list>
#include "MotCle.h"
/// @addtogroup Les_classes_Reference
/// @{
///
/// class Reference: classe général virtuel des références. Les classes dérivées
/// permettent de définir précisemment les différentes références :
/// de noeuds, d'élément, d'aretes, de faces etc..
/// Une instance de la classe s'identifie a partir d'un nom
///
/// \author Gérard Rio
/// \version 1.0
/// \date 06/02/00
class Reference
{
public :
// CONSTRUCTEURS :
// Constructeur par defaut
Reference ( string nom = "rien_actuellement");
// indic = 1 : il s'agit de reference de noeud
// indic = 2 : il s'agit de reference d'element
// =3 -> surface relatives à des éléments,
// =4 -> arrete relatives à des éléments,
// =5 -> des noeuds relatifs à des éléments
// =6 -> de points d'intégrations relatifs à des éléments
// =7 -> de points d'intégrations relatifs à des surfaces d'éléments
// =8 -> de points d'intégrations relatifs à des arrete d'éléments
// Constructeur fonction du nb de maillage et du type de ref
Reference (int nbmaille , int indic);
// Constructeur fonction d'un nom de reference
// du nb de maillage, du type de ref
Reference (string nom,int nbmaille , int indic);
// Constructeur de copie
Reference (const Reference& ref);
// DESTRUCTEUR :
virtual ~Reference ();
// METHODES :
// création d'une référence du même type contenant les mêmes info
// que la référence donnée en argument: utilisation du constructeur de copie
virtual Reference* Nevez_Ref_copie() const = 0;
// Surcharge de l'operateur = : realise l'egalite entre deux references
virtual Reference& operator= (const Reference& ref);
// Retourne le nom associe a la reference
string Nom () const;
// Retourne le type de reference
// = 1 : il s'agit de reference de noeud
// = 2 : il s'agit de reference d'element
// =3 -> surface relatives à des éléments,
// =4 -> arrete relatives à des éléments,
// =5 -> des noeuds relatifs à des éléments
// =6 -> de points d'intégrations relatifs à des éléments
// =7 -> de points d'intégrations relatifs à des surfaces d'éléments
// =8 -> de points d'intégrations relatifs à des arrete d'éléments
int Indic () const;
// Retourne le numero du maillage auquelle la reference se rattache
int Nbmaille() const;
// change le numéro du maillage associé
void Change_Nbmaille(int nv_nm) {nbmaille= nv_nm;};
// Remplace l'ancien nom de la reference par nouveau_nom
void Change_nom (string nouveau_nom);
// supprime les doublons internes éventuels dans la référence
virtual void Supprime_doublons_internes() = 0;
// Affiche les donnees liees a la reference
virtual void Affiche () const;
// Affiche les donnees des références dans le flux passé en paramètre
virtual void Affiche_dans_lis(ofstream& sort) const =0 ;
// lecture d'une liste de reference
virtual bool LectureReference(UtilLecture & entreePrinc) =0 ;
// affichage et definition interactive des commandes
// nbMaxi: nombre maxi de noeud ou d'éléments pour les exemples
// cas : =1 premier passage, il s'agit de références de noeuds uniquement
// cas : =2 second passage, il s'agit de l'ensemble des possibilités de références
virtual void Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas) =0;
//----- lecture écriture dans base info -----
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
virtual void Lecture_base_info(ifstream& ent,const int cas) =0;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
virtual void Ecriture_base_info(ofstream& sort,const int cas) =0;
protected :
string nom_ref; // nom de la reference
int nbmaille; // numero du maillage auquelle la reference se rapporte
int indic; // indic = 1 : il s'agit de reference de noeud
// indic = 2 : il s'agit de reference d'element
// =3 -> surface relatives à des éléments,
// =4 -> arrete relatives à des éléments,
// =5 -> des noeuds relatifs à des éléments
// =6 -> de points d'intégrations relatifs à des éléments
// =7 -> de points d'intégrations relatifs à des surfaces d'éléments
// =8 -> de points d'intégrations relatifs à des arrete d'éléments
static MotCle motCle; // liste des mots clés
// methodes appellées par les classes dérivées
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lect_int_base_info(ifstream& ent);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecrit_int_base_info(ofstream& sort);
};
/// @} // end of group
#ifndef MISE_AU_POINT
#include "Reference.cc"
#define REFERENCE_H_deja_inclus
#endif
#endif