Herezh_dev/Resolin/Resolution_Condi/Condilineaire.cc

   // 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";
   };
   
#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 Condilineaire::Pack_vecteur(Vecteur&  v,int rang) const
       {
       
////debug Condilineaire::Pack_vecteur
//{      int rang_inter = rang;
//       cout << "\n debug Condilineaire::Pack_vecteur ";
//       // le tableau de pointeurs
//       int taille_pt = pt.Taille();
//       cout << "\n taille_pt "<<taille_pt << " rang= " << rang_inter;
//       rang_inter++;
//       for  (int i=1;i<=taille_pt;i++)
//        {cout << " pt(i)= "<<pt(i) << " rang= " << rang_inter;
//        rang++;};
//       // le vecteur val
//       int taille_val = val.Taille();
//       cout << "\n taille_val "<<taille_val << " rang= " << rang_inter;
//       v(rang) = taille_val;
//       for  (int i=1;i<=taille_val;i++)
//        {v(rang)= val(i);rang++;};
//       // beta
//       v(rang)=beta; rang++;
//       // Uk_impose
//       v(rang)=Uk_impose; rang++;
//       // le cas d'assemblage associé
//       rang = casAssemb.Pack_vecteur(v,rang);
//       // le tableau t_enu
//       int taille_t_enu = t_enu.Taille();
//       v(rang) = taille_t_enu;rang++;
//       for  (int i=1;i<=taille_t_enu;i++)
//        {v(rang)= t_enu(i);rang++;};
//       // iddl
//       v(rang)=iddl; rang++;
//       // le taleau t_noeud
//       // on considère que la numérotation est la même pour tous les cpu
//       // du coup on sauvegarde le numéro de maillage et le numéro de noeud
//       int taille_t_noeud = t_noeud.Taille();rang++;
//       v(rang)= taille_t_noeud;
//       for  (int i=1;i<=taille_t_noeud;i++)
//        {v(rang)= t_noeud(i)->Num_Mail();rang++;
//         v(rang)= t_noeud(i)->Num_noeud();rang++;
//        };
//       if (rang > v.Taille())  rang = 0;
//
//
//}
//fin debug Condilineaire::Pack_vecteur

         // le tableau de pointeurs
         int taille_pt = pt.Taille();
         v(rang) = taille_pt;rang++;
         for  (int i=1;i<=taille_pt;i++)
          {v(rang)= pt(i);rang++;};
         // le vecteur val
         int taille_val = val.Taille();
         v(rang) = taille_val;rang++;
         for  (int i=1;i<=taille_val;i++)
          {v(rang)= val(i);rang++;};
         // beta
         v(rang)=beta; rang++;
         // Uk_impose
         v(rang)=Uk_impose; rang++;
         // le cas d'assemblage associé
         rang = casAssemb.Pack_vecteur(v,rang);
         // le tableau t_enu
         int taille_t_enu = t_enu.Taille();
         v(rang) = taille_t_enu;rang++;
         for  (int i=1;i<=taille_t_enu;i++)
          {v(rang)= t_enu(i);rang++;};
         // iddl
         v(rang)=iddl; rang++;
         // le taleau t_noeud
         // on considère que la numérotation est la même pour tous les cpu
         // du coup on sauvegarde le numéro de maillage et le numéro de noeud
         int taille_t_noeud = t_noeud.Taille();
         v(rang)= taille_t_noeud;rang++;
         for  (int i=1;i<=taille_t_noeud;i++)
          {v(rang)= t_noeud(i)->Num_Mail();rang++;
           v(rang)= t_noeud(i)->Num_noeud();rang++;
          };
         if (rang > v.Taille())  rang = 0;
         

         
         
         return rang;
       };
       
     // taille du conteneur actuel de la condition  linéaire
     int Condilineaire::Taille_Pack() const
       {int taille_pack = 0; // init
        taille_pack += pt.Taille() + 1;
        taille_pack += val.Taille() + 1;
        taille_pack += 2; // beta et Uk
        taille_pack += casAssemb.Taille_Pack();
        taille_pack += t_enu.Taille()+1;
        taille_pack += 1; // iddl
        taille_pack += 2*t_noeud.Taille()+1;
        return taille_pack;
       };
       
#endif

/*
    
   // 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;
   
*/