
// 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:        23/01/97                                            *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:  Definition d'un container pour une condition limite        *
 *           lineaire.                                                   *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef CONDILINEAIRE_H
#define CONDILINEAIRE_H

#include "Noeud.h"
#include "Nb_assemb.h"
#include <stdlib.h>
#ifdef UTILISATION_MPI
  #include <boost/serialization/split_member.hpp>
  #include <boost/serialization/string.hpp>
  #include "mpi.h"
  #include <boost/mpi/environment.hpp>
  #include <boost/mpi/communicator.hpp>
  #include <boost/serialization/string.hpp>
  #include <boost/mpi.hpp>
  namespace mpi = boost::mpi;
#endif


/// @addtogroup Les_classes_Matrices
///  @{
///


class Condilineaire
{   // surcharge de l'operator de lecture typée
    // en fait ces fonctions ne doivent pas être utilisées, elles existent uniquement
    // pour que Tableau_T puisse exister
    friend istream & operator >> (istream & ent, Condilineaire &)
      { Sortie(1); return ent;}; // erreur 
    // surcharge de l'operator d'ecriture typée
    friend ostream & operator << (ostream & sort , const Condilineaire &)
      { Sortie(1); return sort;}; // erreur 

  public :    
    // CONSTRUCTEURS :
    // par defaut
    Condilineaire () :
      pt(),val(),beta(0.),t_noeud(),t_enu(),casAssemb()
		    ,Uk_impose(ConstMath::tresgrand),iddl(0)
       {} ;
    // cas ou l'on connait toutes les infos, sauf Uk_impose, qui est une variable de stockage gérée indépendament 
    Condilineaire (Tableau <Enum_ddl>& t_enuu, const Tableau<int> & ptt, const Vecteur& vall
                 , double betar,int posiddl, const Tableau < Noeud *>& t_n) :
      pt(ptt),val(vall),beta(betar),iddl(posiddl),t_noeud(t_n)
      ,t_enu(t_enuu),casAssemb()
		    ,Uk_impose(ConstMath::tresgrand)
       {};
    // cas ou l'on connait les infos relatives uniquements aux noeuds, aux enum ddl
    Condilineaire(Tableau <Enum_ddl>& t_enuu,  const Tableau < Noeud *>& t_n) :
      t_noeud(t_n),t_enu(t_enuu),casAssemb()
      ,pt(),val(),beta(0.)
       ,Uk_impose(ConstMath::tresgrand),iddl(0)
       {};
    // de copie
    Condilineaire (const Condilineaire& a) :
      pt(a.pt),val(a.val),beta(a.beta),iddl(a.iddl),t_noeud(a.t_noeud)
      ,t_enu(a.t_enu),casAssemb(a.casAssemb),Uk_impose(a.Uk_impose)
        { };
    // DESTRUCTEUR :
    ~Condilineaire () {};
    // METHODES PUBLIQUES :
    // surcharge de l'opérateur =
    Condilineaire& operator = (const Condilineaire& cond);
    
    inline const Tableau<int>& Pt_t() const{ return pt;};
    Tableau<int>& ChangePt() { return pt;}; // acces lecture / écriture
    inline const Vecteur& Val() const{ return val;};
    Vecteur& Valchange() {return val;}; // acces lecture / écriture
    void ChangeCoeff(const Vecteur& v) {val=v;}; 
    inline double Beta() const { return beta;};
    double& BetaChange() { return beta;}; // acces lecture / écriture
    void ChangeBeta(const double& x) { beta = x;}; 

    // dans le cas de la mise en place de la CL à partir d'un changement de repère, on peut stocker la valeur imposée avant chg de repère
    // cette valeur a imposer sur le ddl avant changement de repère, correspondra à beta après chg de repère
    // Uk_impose sert uniquement de stockage, mais n'est pas forcément cohérent avec la CL, sa manipulation est faite en dehors de la classe
    // via les deux méthodes qui suivent
    void ChangeUk_impose(double Uk_new) {Uk_impose=Uk_new;};
    // lorsque la valeur retourné par Val_Uk_impose() == ConstMath::tresgrand, cela signifie qu'elle n'est pas a considérer
    const double & Val_Uk_impose() const {return Uk_impose;};

    Noeud* Noe() {return t_noeud(1);}; // acces lecture / écriture
    void Change_tab_enum(const Tableau <Enum_ddl> & t_enuu) {t_enu = t_enuu;};
    // le tableau de noeuds associé
    const Tableau < Noeud *>& TabNoeud() const { return t_noeud;}; 
    void ChangeTabNoeud(const Tableau < Noeud *>& t_n) {t_noeud = t_n;};

    // Iddl() -> le numéro d'ordre dans sa famille, du ddl bloqué
	   // NB: ce n'est pas la position du ddl dans le noeud !!, cette dernière est: Tab_Enum()(1)
    inline  const int& Iddl() const { return iddl;};
    int& ChangeIddl() { return iddl;};  // acces lecture / écriture
	 
    // changement de la taille des tableaux de pointeur et valeurs
    void Change_taille(int taille)  {pt.Change_taille(taille); val.Change_taille(taille);};

    // mise en place des pointeurs de ddl d'assemblage 
    const Condilineaire& ConditionPourPointeursAssemblage(const Nb_assemb& nb_casAssemb);
    const Nb_assemb& CasAssemb() const {return casAssemb;};
    
    // retour du tableau d'énuméré correspondant aux coefficients de la CLL
    const Tableau <Enum_ddl >&  Tab_Enum() const {return t_enu;};
 
    // ramène la différence maxi qui existe entre les numéros de noeuds de la condition linéaire
    // peut-être utilisé pour calculer une largeur de bande par exemple
    // important: cette méthode n'est valide que si les numéros de noeuds sont tous différents
    //            donc que la numérotation interne des noeuds a été changé pour cela
    // NB: en fonctionnement normal, ce n'est pas le cas ! sauf dans le cas où un seul maillage existe
    //     voir LesMaillages::Renumerotation( pour un exemple d'utilisation
    int DiffMaxiNumeroNoeud()const;
 
    // ramène la largeur de bande en ddl
    // à cause de la condition linéaire
    // casAssemb : donne le cas d'assemblage a prendre en compte
    // les condi linéaires ne donnent pas des largeurs de bande sup et inf égales !!!
    // I/O : demi = la demi largeur de bande maxi ,
    //        total = le maxi = la largeur sup + la largeur inf +1
    void Largeur_Bande(int& demi,int& total,const Nb_assemb& casAssemb);

    // affichage à l'écran des infos de la CL
	   void Affiche() const ;
	 
    //----- lecture écriture de restart -----
    // la lecture ramène en retour le numéro de maillage et le numéro de 
    // noeud sur lequel s'applique la condition limite
    // il est nécessaire ensuite d'utiliser la fonction Change_noeud pour`
    // attibuer le noeud
    void Lecture_base_info(Tableau <int>& numMaillage, istream& ent,Tableau <int>& numNoeud) ;
    void Ecriture_base_info(ostream& sort) ;
 #ifdef UTILISATION_MPI // spécifique au calcul parallèle
   // stockage dans un unique vecteur, des infos à  partir de l'indice rang inclus
   // correspond à une sérialisation des  infos
   // ramène le positionnement dans  v pour un prochain enreg, sauf si > à la taille de v
   // dans ce cas ramène 0
   int Pack_vecteur(Vecteur&  v,int rang) const;
   // taille du conteneur actuel de la condition  linéaire
   int Taille_Pack() const;
   // modification des infos à  partir de l'indice rang inclus en fonction du vecteur passé en paramètre
   // correspond à une désérialisation
   // ramène le positionnement dans  v pour un prochain enreg, sauf si > à la taille de v
   // dans ce cas ramène 0
   // on passe  un  pointeur  de fonctions qui ramène un noeud en fonction d'un numéro de maillage et d'un
   // numéro de noeud, ceci pour éviter de  passer toute l'instance de la classe Les_maillages
   template <class T> int UnPack_vecteur(T& instance,const Vecteur&  v,int rang,
                       Noeud & (T::*Ptfonc) (int num_mail,int  num_noeud) const );
 #endif

  protected :  
    // VARIABLES PROTEGEES :
    Tableau<int>  pt;  //tableau des pointeurs de ddl concerne, pt(i) = la position du ddl i
                       // dans la matrice globale
    Vecteur val;    // tableau des coefficients de la condition lineaire
    double beta;  // valeur beta a laquelle est egale la condition lineaire
    // dans le cas de la mise en place de la CL à partir d'un changement de repère, on peut stocker la valeur imposée avant chg de repère
    double Uk_impose; // valeur a imposer sur le ddl avant changement de repère, qui correspondra à beta après chg de repère
    // Uk_impose sert uniquement de stockage, mais n'est pas forcément cohérent avec la CL, sa manipulation est faite en dehors de la classe
		  // via : ChangeUk_impose et Val_Uk_impose
    Nb_assemb casAssemb; // le cas d'assemblage associé
    
    // le blocage de  condition est appliquee sur le ddl numero "iddl" du noeud "noe"
    Tableau <Enum_ddl > t_enu; // tableau des identificateur de ddl de la CLL
                     // t_enu(1) est l'identificateur du  ddl qui est bloqué pour la CLL
                     // lorsque seul t_enu(1) existe, cela signifie qu'il faut construire 
                     // les indices,  
                     
    // iddl -> le numéro d'ordre dans sa famille, du ddl bloqué
	   // NB: ce n'est pas la position du ddl dans le noeud !!, cette dernière est: Tab_Enum()(1)
    int iddl;
    // le tableau des noeuds de la CLL, le premier contient la condition
    Tableau < Noeud *> t_noeud;
    
    
    // METHODES PROTEGEES :

 };
 // pour faire de l'inline: nécessaire avec les templates
 // on n'inclut que les méthodes templates
 #include "Condilineaire_2.cc"
 #define  Condilineaire_deja_inclus
 /// @}  // end of group

#endif  
