188 lines
7.9 KiB
C++
188 lines
7.9 KiB
C++
|
|
// 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";
|
|
};
|