
// 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:   Def et application de differentes conditions limites.     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef CONDLIM_H 
#define CONDLIM_H

#include "Mat_abstraite.h"
#include "Vecteur.h"
#include <list>
#include "MathUtil.h"
#include "Mat_pleine.h"
   

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


class CondLim 
{ // pour pouvoir faire des tableaux de condlim on introduit les surcharges de lecture
  // écriture, mais en fait elles ne doivent pas être utilisé d'où une sortie d'erreur
    // surcharge de l'operator de lecture typée
    friend istream & operator >> (istream & ent, CondLim &)
     { cout << "\n erreur, la surcharge de lecture n'est pas implanté "
            << " \n operator >> (istream & ent, CondLim &) " ;
       Sortie(1);  return ent;      
      };      
    // surcharge de l'operator d'ecriture typée
    friend ostream & operator << (ostream & sort, const CondLim &)
     { cout << "\n erreur, la surcharge d'écriture n'est pas implanté "
            << " \n operator << (ostream & sort, const CondLim &)";
       Sortie(1);  return sort;      
      };      

  public :
    // CONSTRUCTEURS :
      CondLim(); 
    // DESTRUCTEUR :
      ~CondLim();
    // METHODES PUBLIQUES :
    //=============================================================================
    // IMPORTANT !! = lorsque l'on a des conditions limites a imposer a un second =
    // membre et a une matrice , il faut d'abord impose a la matrice  puis        =
    // apres au second membre                                                     =
    //=============================================================================
     // valeur imposee au second membre
     // vecglob : le second membre, i : la position globale du ddl impose
     // val : la valeur a imposer
	  // vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
	  //        mais sans sauvegarde (correspond par exemple à une partie de vecglob)
     void Val_imposee_Sm(Vecteur& vecglob,int i,double val,Vecteur* vec2);
     // valeur imposee a la matrice et au second membre si la valeur est
     // differente de zero
     // matglob : la matrice, i : la position globale du ddl impose
     // val : la valeur a imposer     
	  // vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
	  //        mais sans sauvegarde (correspond par exemple à une partie de vecglob)
     void Val_imposee_Mat(Mat_abstraite & matglob,Vecteur& vecglob,
                         int i,double val,Vecteur* vec2);
     // cas particulier de valeur imposee a une matrice 
     // c'a-dire val sur la diagonale 
     // et des zéros sur le reste de la ligne et colonne corsespondantes
     // matglob : la matrice, i : la position globale du ddl impose
     // dans ce cas-ci il n'y a aucune information sauvegardée, des valeurs modifiées
     // cela signifie qu'après cette fonction, les appels aux routines pour la 
     // remontée aux réactions, n'ont aucun sens     
     void Val_imposSimple_Mat(Mat_abstraite & matglob,int i,double val);
     // remontee aux efforts apres resolution
     // ceci pour la ligne i dans le cas de ddl bloque
     // la matrice est utilisee pour restorer les lignes supprimee
     // par les conditions limites, elle est donc modifiee
     // par cette operation, parcontre ses valeurs initiales ne sont pas utilisees
     double RemonteDdlBloqueMat(Mat_abstraite & matglob,Vecteur& solution, int i); 
     
     // retourne la valeur absolu du maxi des efforts exterieurs
     // et le numero d'assemblage correspondant
     double MaxEffort(int & ili);
     
     // retourne la valeur initiale au second membre avant condition limite
     // en fonction du pointeur d'assemblage
     double ValReact(int & ili);
     
     //------------------------------------------------------------------
     //      cas de conditions limites lineaires entre plusieurs ddl
     //------------------------------------------------------------------
     // la condition est imposee sur la matrice et sur le second membre
     // la mise en place des condition lineaire doit ce faire en deux temps
     // premier temps : préparation  des conditions, c'est a dire expression
     // de la raideur et du second membre dans les reperes locaux ceci pour
     // TOUS LES CONDITIONS
     // second temps : seulement une fois que TOUTES LES changements de reperes
     // sont effectuee, on impose les valeurs de second memebres apres ou avant
     // les valeurs fixe.
     
     // pt : tableau des pointeurs de ddl concerne, pt(i) = la position du ddl i
     // dans la matrice globale
     // val : tableau des coefficients de la condition lineaire
     // valeur : valeur a laquelle est egale la condition lineaire
     // cond lineire  -> somme des val(i) * ddl(pt(i)) = valeur
     // la procedure modifie les reperes d'expression des ddl, mais sauvegarde
     // les infos permettant de reconstruire les reperes initiaux
     // !!! par principe, c'est la direction du premier indice qui est bloquee
     // il faut donc ecrire la condition en consequence

	  // vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
	  //        mais sans sauvegarde (correspond par exemple à une partie de vecglob)
     
          // premier temps: changement de repère

     void CondlineaireCHRepere(Mat_abstraite & matglob,Vecteur& vecglob,
              const Tableau<int> & pt,const Vecteur& val, double valeur,Vecteur* vec2);
     
         // second temps : imposition des blocages correspondant
         //                aux conditions lineaires
         
     void CondlineaireImpose (Mat_abstraite & matglob,Vecteur& vecglob,Vecteur* vec2);  
     
     
     //expression du vecteur resultat dans les reperes initiaux
     // sol : la solution, est modifie et retournee dans les reperes initiaux
     void RepInitiaux( Vecteur& sol);
 
     // application d'une condition linéaire seule, avec en retour, la situation de la condition linéaire
     // imposée, ramené dans le repère initial
     void CondiLineaireImposeComplet(Mat_abstraite & matglob,Vecteur& vecglob,
                       const Tableau<int> & pt,const Vecteur& val, double valeur,Vecteur* vec2);
     
          
     // remise a zero des sauvegardes de second membre et de matrice
     void EffaceSauvegarde();

     // remise a zero des sauvegardes de condition lineaire
     void EffaceCoLin();
     

               
  private :  
    // VARIABLES PROTEGEES :
     // concernant une valeur imposee pour le second membre, on defini une
     // class qui permet d'enregistrer les ddl impose
      class ImpSM
       { public :
         ImpSM () {}; // par defaut
         ImpSM (int i, double val) : iligne(i), valeur(val) {};
         ImpSM (const ImpSM & a) : iligne(a.iligne), valeur(a.valeur) {};
         ~ImpSM () {};
         ImpSM& operator=( const ImpSM& a)  ; // assigment
                  
         int iligne; // ligne ou le ddl est impose
         double valeur; // sauvegarde de la valeur existant avant le ddl impose         
       };
       
     // on definit une liste STL comme container  
     list <ImpSM> VImpSM;     
    
    //concernant une valeur imposee pour la raideur, on defini une
    // class qui permette d'enregistrer les modifications effectuees
    // sur la raideur
     class ImpRaid
       { public :
         ImpRaid (); // par defaut
         ImpRaid (int i,const Vecteur& vL,const Vecteur& vC,double val);
         ImpRaid (const ImpRaid & a) ; // constructeur de copie
         ~ImpRaid() {};  // destructeur
         ImpRaid& operator=( const ImpRaid& a)  ; // assigment         
         
         int ilicol; // ligne et colonne ou le ddl est impose
         Vecteur  ligne; // ligne du ddl impose
         Vecteur  colonne; // colonne  du ddl impose 
         double valeur; // valeur du ddl impose        
       };
     // on definit une liste STL comme container  
     list <ImpRaid> VImpRaid;
          
    //concernant les conditions lineaires, on defini une
    // class qui permette d'enregistrer le changement de repere
     class lineaires
       { public :
         lineaires (); // par defaut
         lineaires (int i,const Vecteur& vL,const Tableau<int> & ptt,double vale);
         lineaires (const lineaires & a) ; // constructeur de copie
         ~lineaires() {};  // destructeur
         lineaires& operator=( const lineaires& a) ; // assigment         
         
         int indice; // numero dans le tableau pt qui permet d'obtenir les 
                      //ligne et colonne du ddl modifie en condition lineaire
         Vecteur  val; // vecteur des coefficients de la condition lineaire
         Tableau<int>  pt; // pt : tableau des pointeurs de ddl concerne, pt(i) = la position du ddl i
                            // dans la matrice globale 
         double valeur; // valeur de la condition lineaire       
       };
     // on definit une liste STL comme container  
     list <lineaires> Vlineaires;
 
     // méthode pour faire une rotation de la matrice et du second membre suivant un vecteur
     // vec2 : est un second vecteur éventuel (si != NULL)
     void Rotation(Mat_abstraite & matglob,Vecteur& vecglob,
                   const Tableau<int> & pt,const Vecteur& val,Vecteur* vec2);
     
     // déclaration d'une variable de travail, utilisée par CondlineaireCHRepere
     static  Mat_pleine matinter; // mise en commun pour éviter des constructions inutiles

     
    // METHODES PROTEGEES :

 };
 /// @}  // end of group

#endif  
