
   // 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/>.

   #include "Condilineaire.h"

    // surcharge de l'opérateur =
Condilineaire& Condilineaire::operator = (const Condilineaire& cond)
    { pt = cond.pt;
      val = cond.val;
      beta = cond.beta;
		    Uk_impose = cond.Uk_impose;
      iddl =cond.iddl;
      t_enu = cond.t_enu;
      t_noeud = cond.t_noeud;
      casAssemb = cond.casAssemb;
      return *this;
    };
    
// mise en place des pointeurs de ddl d'assemblage 
const Condilineaire& Condilineaire::ConditionPourPointeursAssemblage(const Nb_assemb& nb_casAssemb)
{ // pour les appels aux noeuds
  casAssemb = nb_casAssemb; int nb_assemb = casAssemb.n;
  // il s'agit ici de construire la condition pour les pointeurs d'assemblage
  int taille = pt.Taille();
  int nb_noeud = t_noeud.Taille();int itab=1;
  int nbddlfamille = taille / nb_noeud;
  for (int i_noe=1;i_noe <= nb_noeud;i_noe++)
    for (int i =1; i<= nbddlfamille; i++,itab++) 
      // récup du pointeur d'assemblage  
      { Enum_ddl enu = t_enu(itab); // pour simplifier
	       pt(itab) = t_noeud(i_noe)->Pointeur_assemblage(enu,nb_assemb);
	       // dans le cas où le pointeur n'existe pas, on regarde si l'on est en dynamique et que la condition linéaire est
		      // sur des positions, déplacement. Si le cas d'assemblage est de type dynamique, c'est sur les gammas qu'il faut récupérer les infos
        if (pt(itab) == -1)
          { if (Evolution_temporelle_du_calcul(ParaGlob::param->TypeCalcul_maitre()) == DYNAMIQUE)
             if (Dans_combinaison(1,enu)) //1 pour la combinaison dynamique
               { //on construit le ddl en gama équivalent aux ddl donné
                 Enum_ddl enugamma = Enum_ddl(((int)enu)-((int)PremierDdlFamille(enu)) + ((int)GAMMA1));
                 // on récupère le pointeur éventuelle
                 pt(itab) = t_noeud(i_noe)->Pointeur_assemblage(enugamma,nb_assemb);
               };
          };
       #ifdef MISE_AU_POINT
        if ( pt(itab) == -1 )
          { cout << "\nErreur : ddl X1 inexistant  pour le cas de charge " << nb_assemb
                 <<  '\n'
                 << "Condilineaire::ConditionPourPointeursAssemblage(.. 3\n";
            Sortie(1);
          };
       #endif
      };
  // retour
  return *this;	
};

 
// 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 Condilineaire::DiffMaxiNumeroNoeud()const
  { // on va parcourir les noeuds de la condition
    int nb_noeud = t_noeud.Taille();
    int num_mini = t_noeud(1)->Num_noeud(); // initialisation
    int num_maxi = num_mini; // init
    for (int i_noe=2;i_noe <= nb_noeud;i_noe++)
      { Noeud & noe = *t_noeud(i_noe); // pour simplifier
        num_mini = MiN (num_mini, noe.Num_noeud());
        num_maxi = MaX(num_maxi,noe.Num_noeud());
      };
    return (num_maxi-num_mini);
  };


// 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 Condilineaire::Largeur_Bande(int& demi,int& total,const Nb_assemb& casAssemb)
  { int nb_Assemb = casAssemb.n; // récup du numéro d'assemblage
    // on va parcourir les noeuds de la condition
    int nb_noeud = t_noeud.Taille();
    int noe=1;
    Noeud & nne = *t_noeud(noe);
    for ( int no=noe+1; no<=nb_noeud;no++)
      { Noeud & nno = *t_noeud(no);
        int di;
        if (nne.PosiAssemb(nb_Assemb) >= nno.PosiAssemb(nb_Assemb))
           di = nne.PosiAssemb(nb_Assemb) - nno.PosiAssemb(nb_Assemb)
                + nne.NB_ddl_actif_casAssemb(nb_Assemb);
        else
           di = nno.PosiAssemb(nb_Assemb) - nne.PosiAssemb(nb_Assemb)
                + nno.NB_ddl_actif_casAssemb(nb_Assemb);
        if ( di > demi)  demi = di;
        if ( 2*di > total) total = 2*di;
      };
  };



// affichaga à l'écran des infos de la CL
void Condilineaire::Affiche() const
  {  cout << "\n --- condition lineaire ---\n";
     cout << "\n tableau pt: " << pt;
     // le tableau des coefficients
     cout  << "\n val= "<< val;
     // la valeur de la condition linéaire
     cout  << "\n beta= " << beta << " Uk_impose= "<< Uk_impose << " ";
     // le repérage des noeuds supportant la condition linéaire
     int nb_noeud = t_noeud.Taille();
     cout << "\n  les noeuds: nb_noeud= " << nb_noeud << " ";
     for (int i=1; i<= nb_noeud; i++)
        cout << " num_mail= " << t_noeud(i)->Num_Mail() << " num_noeud= " << t_noeud(i)->Num_noeud() << " ";
     // le tableau des énumérés
     cout << "\n enumeres: t_enu= " << t_enu << " ";   
     // le numéro d'ordre du ddl modifié dans noeud
     cout << "\n numero d'ordre du ddl modifie dans le noeud " << iddl  << " \n";
   };
    
	 //----- lecture écriture de restart -----
void Condilineaire::Lecture_base_info
    (Tableau <int>& numMaillage, ifstream& ent,Tableau <int>& numNoeud) 
  {  // lecture du tableau
     pt.Entree(ent); 
     // le tableau des coefficients
     ent >> val;
     // la valeur de la condition linéaire
     ent >> beta >> Uk_impose;
     // le repérage des noeud supportant la condition linéaire
     string nom;int taille;
     ent >> nom >> taille;
     t_noeud.Change_taille(taille,NULL);
     numMaillage.Change_taille(taille);
     numNoeud.Change_taille(taille);
     for (int i=1;i<= taille; i++)
        ent >> numMaillage(i) >>numNoeud(i);
     // lecture des énumérés
     ent >> t_enu;   
     // lecture du numéro d'ordre du ddl modifié dans noeud
     ent >> iddl;
   };
void Condilineaire::Ecriture_base_info(ofstream& sort) 
  {  // sauvegarde du tableau
     pt.Sortir(sort); 
     // le tableau des coefficients
     sort << val;
     // la valeur de la condition linéaire
     sort << beta << " "<< Uk_impose << " ";
     // le repérage des noeuds supportant la condition linéaire
     int nb_noeud = t_noeud.Taille();
     sort << " nb_noeud= " << nb_noeud << " ";
     for (int i=1; i<= nb_noeud; i++)
        sort << t_noeud(i)->Num_Mail() << " " << t_noeud(i)->Num_noeud() << " ";
     // le tableau des énumérés
     sort << t_enu << " ";   
     // le numéro d'ordre du ddl modifié dans noeud
     sort << iddl  << " \n";
   };
