// FICHIER : ReferenceAF.h
// CLASSE : ReferenceAF
// 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++ *
* $ *
************************************************************************
* BUT: Def, stockage et manipulation des références pour les *
* faces et les arêtes . *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef REFERENCEAF_H
#define REFERENCEAF_H
#include "Reference.h"
/// @addtogroup Les_classes_Reference
/// @{
///
/// Def, stockage et manipulation des références pour les faces et les arêtes
///
/// \author Gérard Rio
/// \version 1.0
/// \date 23/01/97
class ReferenceAF : public Reference
{
public :
// CONSTRUCTEURS :
// Constructeur par defaut
ReferenceAF ( 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 -> arête 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
ReferenceAF (int nbmaille , int indic);
// Constructeur fonction de deux tableaux de numeros, le premier pour les numéros
// d'éléments le second pour les numéros de faces, ou d'aretes, ou de noeud d'element,
// ou de pt d'integ, du nb de maillage, du type de ref
ReferenceAF (const Tableau& tabelem,const Tableau& tab
,int nbmaille , int indic, string nom = "rien_actuellement");
// idem mais avec des listes d'entiers plutôt que des tableaux
ReferenceAF (const list & list_elem,const list & list_num
,int nbmaille , int indic, string nom = "rien_actuellement");
// Constructeur fonction d'un nom de reference
// du nb de maillage, du type de ref
ReferenceAF (string nom,int nbmaille , int indic);
// Constructeur de copie
ReferenceAF (const ReferenceAF& ref);
// DESTRUCTEUR :
~ReferenceAF ();
// 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
Reference* Nevez_Ref_copie() const
{ReferenceAF* ref_ret=new ReferenceAF(*this); return ref_ret;} ;
Reference& operator= (const Reference& ref);
// Retourne le tableau des numeros d'élément
const Tableau& Tab_Elem() const
{ return tab_Elem; };
// Retourne le tableau des numeros de faces, ou d'arêtes, ou de noeud d'element, ou de points d'integ
const Tableau& Tab_FA() const
{ return tab_FA; };
// Retourne le ieme element du tableau d'éléments
// de la reference (acces lecture uniquement)
int NumeroElem(int i) const
{ return tab_Elem(i); };
// Retourne le ieme element du tableau de faces, ou d'arêtes, ou de noeud d'element, ou de points d'integ
// de la reference (acces lecture uniquement)
int NumeroFA(int i) const
{ return tab_FA(i); };
// Retourne le nombre de numeros de la reference
int Taille () const
{ return tab_Elem.Taille(); };
// change un numéro i de référence
// nbe: le numéro d'élément, nbAF: le numéro de de faces, ou d'arêtes, ou de noeud d'element,
// ou de points d'integ
void Change_num_AF_dans_ref(int i,int nbe, int nbAF);
// change les 2 tableaux de la ref
void Change_tab_num(const Tableau& tabele,const Tableau& tab);
// indique si le numéro d'élément et le numéro de faces, ou d'arêtes, ou de noeud d'element, ou de points
// d'integ, passé en argument, fait partie de la référence
// nbe: le numéro d'élément, nbAF: le numéro de de faces, ou d'arêtes, ou de noeud d'element,
// ou de points d'integ
bool Contient_AF(int nbe, int nbAF) const;
// supprime les doublons internes éventuels dans la référence
virtual void Supprime_doublons_internes();
// Affiche les donnees liees a la reference
void Affiche () const;
//-------- méthodes découlant de virtuelles ----------------
// Affiche les donnees des références dans le flux passé en paramètre
void Affiche_dans_lis(ofstream& sort) const ;
// lecture d'une liste de reference
bool LectureReference(UtilLecture & entreePrinc);
// affichage et definition interactive des commandes
// nbMaxi: nombre maxi d'éléments pour les exemples
// cas : =1 premier passage, il s'agit de références de noeuds uniquement,
// donc ici cela génére une erreur
// cas : =2 second passage, il s'agit de l'ensemble des possibilités de références
void Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas);
//----- 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)
void Lecture_base_info(ifstream& ent,const int cas);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas);
protected :
Tableau tab_Elem; // tableau des numeros des éléments de la reference
Tableau tab_FA; // tableau des numeros des faces ou arêtes de la reference
// ou noeud d'element, ou de points d'intégrations d'élément
};
/// @} // end of group
#ifndef MISE_AU_POINT
#include "ReferenceAF.cc"
#define REFERENCEAF_H_deja_inclus
#endif
#endif