// FICHIER : ReferencePtiAF.h
// CLASSE : ReferencePtiAF

// 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:        22/04/2020                                          *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:  Def, stockage et manipulation des références pour les      *
 *           pti de faces et d'arêtes   .                               *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/


#ifndef REFERENCEPTIAF_H
#define REFERENCEPTIAF_H

#include "Reference.h"


/// @addtogroup Les_classes_Reference
///  @{
///

///  Def, stockage et manipulation des références pour les  pti de faces et d'arêtes 
///
/// \author    Gérard Rio
/// \version   1.0
/// \date       22/04/2020

class ReferencePtiAF : public Reference
{
	public :

		// CONSTRUCTEURS :
		
		// Constructeur par defaut
		ReferencePtiAF ( 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		
		ReferencePtiAF (int nbmaille , int indic);

		// Constructeur fonction  de trois  tableaux de numeros, le premier pour les numéros
		// d'éléments le deuxième pour les numéros de faces, ou d'aretes,
		// le troisième pour le nb du pt d'integ,
  // puis le  nb de maillage, et enfin le type de ref
		ReferencePtiAF (const Tableau<int>& tabelem,const Tableau<int>& tabAF,const Tableau<int>& tabPti
		             ,int nbmaille , int indic, string nom = "rien_actuellement");
		// idem mais avec des listes d'entiers plutôt que des tableaux
		ReferencePtiAF (const list <int>& list_elem,const list <int>& list_numAF
               ,const list <int>& list_num_pti
		             ,int nbmaille , int indic, string nom = "rien_actuellement");
		
		// Constructeur fonction d'un nom de  reference
		// du nb de maillage, du type de ref		
		ReferencePtiAF(string nom,int nbmaille , int indic);
				
		// Constructeur de copie
		ReferencePtiAF(const ReferencePtiAF& ref);
		
		
		// DESTRUCTEUR :
		
		~ReferencePtiAF();
		
		
		// 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
		  {ReferencePtiAF* ref_ret=new ReferencePtiAF(*this); return ref_ret;} ;

		Reference& operator= (const Reference& ref);
		
		// Retourne le tableau des numeros d'élément
		const Tableau<int>& 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<int>& Tab_FA() const
		  {	return tab_FA;	};

  // Retourne le tableau des numeros des points d'integ
  const Tableau<int>& Tab_Pti() const
    { return tab_pti; };

		// 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 ieme element du tableau de points d'integ
  // de la reference (acces lecture uniquement)
  int NumeroPti(int i) const
      { return tab_pti(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, nbPti
		//       le num de points d'integ
		void Change_num_PtiAF_dans_ref(int i,int nbe, int nbAF, int nbPti);
			
  // change les 3 tableaux de la ref
		void Change_tab_num(const Tableau<int>& tabele,const Tableau<int>& tabAF
                      ,const Tableau<int>& tabPti);

		// indique si le numéro d'élément, le numéro de faces ou d'arêtes, et le num 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,
		//       nbPti le num  de points d'integ
		bool Contient_PtiAF(int nbe, int nbAF, int nbPti) 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<int> tab_Elem; // tableau des numeros des éléments de la reference	
		Tableau<int> tab_FA; // tableau des numeros des faces ou arêtes de la reference
  Tableau<int> tab_pti; // tableau des points d'intégrations
		
};
/// @}  // end of group

#ifndef MISE_AU_POINT
  #include "ReferencePtiAF.cc"
  #define  REFERENCEPTIAF_H_deja_inclus
#endif

#endif
		
				
