// FICHIER : Noeud.cp
// CLASSE : Noeud
// 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 "Noeud.h"
#include "Util.h"
#include <iomanip>
#include "TypeQuelconqueParticulier.h"
// variable globale à la classe
short int Noeud::posi_type_quel = 1;
short int Noeud::posi_ddletendu = 1;
list <Tableau <int > > Noeud::list_tab_enum;
List_io <Tableau <int > > Noeud::list_tab_posi_actif;
List_io <Tableau <int > > Noeud::list_tab_typeQuelconque; // au début il n'y a rien dans la liste
List_io <Tableau <int > > Noeud::list_tab_ddletendu; // au début il n'y a rien dans la liste
// ------ méthode concernant laclass Posi_ddl_noeud ----------------
// surcharge de l'operateur de lecture
istream & operator >> ( istream & ent, Posi_ddl_noeud & a)
{ // lecture du type et vérification
string nomtype; ent >> nomtype;
if (nomtype != "Posi_ddl_noeud")
{ Sortie(1);
return ent;
}
// lecture des data
ent >> a.nb_maillage >> a.nb_noeud >> a.enu ;
return ent;
};
// surcharge de l'operateur d'ecriture
ostream & operator << ( ostream & sort,const Posi_ddl_noeud & a)
{ // écriture du type
sort << " Posi_ddl_noeud " ;
// les data
sort << a.nb_maillage << " "<< a.nb_noeud << " "<< a.enu << " ";
return sort;
};
// Affiche les donnees liees au noeud
void Posi_ddl_noeud::Affiche (ostream& sort) const
{ // les data
sort << " Posi_ddl_noeud " ;
sort << nb_maillage << " "<< nb_noeud << " "<< enu << " ";
};
// ------ fin des méthodes concernant la sous_class Posi_ddl_noeud ----------------
//=========================================================================
// Fait appel au constructeur par defaut de Coordonnee et de Tableau<Ddl>
// Constructeur se servant eventuellement d'un numero d'identification
Noeud::Noeud (int num_id,int num_M):
tab_0(),tab_ddl(),tab_tdt(),coord1()
,tab_var_actives(),tab_actif(),pos_enum(list_tab_enum.end())
,posiAssemb(),baseB(NULL),baseB_t(NULL),baseB_0(NULL)
,t_enum_s(),tab_type_quel(),update_type_quel(),nbTypeQ_update(0)
,tab_nb_Elem(),pos_Quelconque(list_tab_typeQuelconque.end())
,pos_ddletendu(list_tab_ddletendu.end())
,nbddletendu_update(0),tab_ddletendu(0),update_ddletendu(0)
,tab_enu_liaison(NULL),tab_ddl_lier(NULL)
{ num_noeud=num_id;
coord0 = NULL;
coord2 = NULL;
num_Mail = num_M;
posi_type_quel = 1;
MiseAjourEnum(); // mise en place de l'adressage directe
MiseAjourDdl_etendu(); // cas des ddl étendue
MiseAjourTypeQuelconque(); // cas des grandeurs quelconques
};
// Constructeur utile quand seuls le numero d'identification et la
// dimension de l'espace sont connus
Noeud::Noeud (int num_id,int dimension,int num_M):
tab_0(),tab_ddl(),tab_tdt(),coord1(),tab_var_actives(),tab_actif()
,pos_enum(list_tab_enum.end())
,posiAssemb(),baseB(NULL),baseB_t(NULL),baseB_0(NULL)
,t_enum_s(),tab_type_quel()
,update_type_quel(),nbTypeQ_update(0),tab_nb_Elem()
,pos_Quelconque(list_tab_typeQuelconque.end())
,pos_ddletendu(list_tab_ddletendu.end())
,nbddletendu_update(0),tab_ddletendu(0),update_ddletendu(0)
,tab_enu_liaison(NULL),tab_ddl_lier(NULL)
{ num_noeud=num_id;
coord0 = new Coordonnee(dimension);
coord2 = NULL;
num_Mail = num_M;
posi_type_quel = 1;
MiseAjourEnum(); // mise en place de l'adressage directe
MiseAjourDdl_etendu(); // cas des ddl étendue
MiseAjourTypeQuelconque(); // cas des grandeurs quelconques
};
// Constructeur pour un noeud dont le numero et les coordonnees initiales
// sont connus
Noeud::Noeud (int num_id,const Coordonnee& c0,int num_M):
tab_0(),tab_ddl(),tab_tdt(),coord1(),tab_var_actives(),tab_actif()
,pos_enum(list_tab_enum.end())
,posiAssemb(),baseB(NULL),baseB_t(NULL),baseB_0(NULL)
,t_enum_s(),tab_type_quel()
,update_type_quel(),nbTypeQ_update(0),tab_nb_Elem()
,pos_Quelconque(list_tab_typeQuelconque.end())
,pos_ddletendu(list_tab_ddletendu.end())
,nbddletendu_update(0),tab_ddletendu(0),update_ddletendu(0)
,tab_enu_liaison(NULL),tab_ddl_lier(NULL)
{ num_noeud=num_id;
coord0 = new Coordonnee(c0);
coord2 = NULL;
num_Mail = num_M;
posi_type_quel = 1;
MiseAjourEnum(); // mise en place de l'adressage directe
MiseAjourDdl_etendu(); // cas des ddl étendue
MiseAjourTypeQuelconque(); // cas des grandeurs quelconques
};
// Constructeur fonction d'un numero d'identification, des coordonnees
// initiales et du tableau des degres de liberte
// les ddl t=0 sont initialises avec les valeurs du tableaux
// sauf coord0 qui est initialise avec c0
// par defaut les tableaux de ddl a 0 et t sont initialises mais pas
// a t+dt
Noeud::Noeud (int num_id,const Coordonnee& c0,const Tableau<Ddl>& tab,int num_M):
tab_ddl(tab),tab_0(tab_ddl.Taille()),tab_tdt(),coord1()
,tab_var_actives(),tab_actif()
,pos_enum(list_tab_enum.end())
,baseB(NULL),baseB_t(NULL),baseB_0(NULL)
,posiAssemb(),t_enum_s(),tab_type_quel()
,update_type_quel(),nbTypeQ_update(0),tab_nb_Elem()
,pos_Quelconque(list_tab_typeQuelconque.end())
,pos_ddletendu(list_tab_ddletendu.end())
,nbddletendu_update(0),tab_ddletendu(0),update_ddletendu(0)
,tab_enu_liaison(NULL),tab_ddl_lier(NULL)
{ num_noeud=num_id;
coord0 = NULL;
coord2 = NULL;
num_Mail = num_M;
// init de tab_0
for (int i=1;i<=tab_0.Taille();i++)
tab_0(i) = tab_ddl(i).Valeur();
// cas ou l'on est en coordonnees entrainees
if ( Existe(X1) != 0)
{ Liaison_t(Existe(X1));
*coord0 = c0;
}
// cas ou les ddl sont separes des coordonnees
else
{ coord0 = new Coordonnee(c0);
};
posi_type_quel = 1;
// mise a jour des ddl actifs et de l'adressage via l'énumération des ddl
MiseAjourActif();
MiseAjourEnum(); // mise en place de l'adressage directe
MiseAjourDdl_etendu(); // cas des ddl étendue
MiseAjourTypeQuelconque(); // cas des grandeurs quelconques
};
// Constructeur fonction d'un numero d'identification, des coordonnees
// initiales, a un instant t, et du tableau des degres de liberte
// les ddl t=0 sont initialises avec les valeurs du tableaux
// par defaut les tableaux de ddl a 0 et t sont initialises mais pas
// a t+dt
// les ddl corespondant a Xi sont ajoute s'ils n'existaient pas
// et il y a automatiquement liaison entre ddl et coordonnées
Noeud::Noeud (int num_id,const Coordonnee& c0,const Coordonnee& c1,const Tableau<Ddl>& tab,int num_M):
tab_ddl(tab),tab_0(tab_ddl.Taille()),tab_tdt(),coord1(c1.Dimension())
,tab_var_actives(),tab_actif()
,pos_enum(list_tab_enum.end())
,posiAssemb(),baseB(NULL),baseB_t(NULL),baseB_0(NULL)
,t_enum_s(),tab_type_quel()
,update_type_quel(),nbTypeQ_update(0),tab_nb_Elem()
,pos_Quelconque(list_tab_typeQuelconque.end())
,pos_ddletendu(list_tab_ddletendu.end())
,nbddletendu_update(0),tab_ddletendu(0),update_ddletendu(0)
,tab_enu_liaison(NULL),tab_ddl_lier(NULL)
{ num_noeud=num_id;
coord0 = NULL;
coord2 = NULL;
num_Mail = num_M;
// init de tab_0
#ifdef MISE_AU_POINT // vérification de la dimension de tab_ddl
if (tab.Taille() < c1.Dimension())
{ cout << "\nErreur : dans le constructeur de noeud : ";
cout << " Noeud (int num_id,Coordonnee& c0,Coordonnee& c1,"
<< "const Tableau<Ddl>& tab,int num_M)\n";
Sortie(1);
};
#endif
for (int i=1;i<=tab_0.Taille();i++)
tab_0(i) = tab_ddl(i).Valeur();
// cas ou l'on est en coordonnees entrainees
int posi_X1=0; // init
if ( Existe(X1) == 0)
{ // le ddl X1 n'existe pas on le rajoute
int an = tab_ddl.Taille();
tab_ddl.Change_taille(an+Dimension());
tab_0.Change_taille(an+Dimension());
for (int jj=1;jj<=Dimension();jj++)
tab_ddl(an+jj).Change_nom(Enum_ddl(jj));
posi_X1 = an+1; // c'est la position du ddl X1
}
else // sinon il existe on récupère sa position
posi_X1 = Existe(X1) ;
// on effectue la liaison ddl/ deplacement
Liaison_t(posi_X1); // (Existe(X1));
*coord0 = c0;
for (int j=1;j<= Dimension();j++)
*(coord1(j)) = c1(j);
posi_type_quel = 1;
// mise a jour des ddl actifs et de l'adressage via l'énumération des ddl
MiseAjourActif();
MiseAjourEnum(); // mise en place de l'adressage directe
MiseAjourDdl_etendu(); // cas des ddl étendue
MiseAjourTypeQuelconque(); // cas des grandeurs quelconques
};
// Constructeur pour un noeud dont le numero, les coordonnees initiales, aux
// instant t et t+dt ainsi que le tableau des degres de liberte sont connus
// comme les coordonnées à t+dt sont données cela signifie qu'ils sont des
// degrés de liberté
// les ddl corespondant a Xi sont ajoute s'ils n'existaient pas
// et il y a automatiquement liaison entre ddl et coordonnées
Noeud::Noeud (int num_id,const Coordonnee& c0,const Coordonnee& c1,const Coordonnee& c2,
const Tableau<Ddl>& tab,int num_M):
tab_ddl(tab),tab_0(tab.Taille()),tab_tdt(tab.Taille()),coord1(c1.Dimension())
,tab_var_actives(),tab_actif()
,pos_enum(list_tab_enum.end())
,posiAssemb(),baseB(NULL),baseB_t(NULL),baseB_0(NULL)
,t_enum_s(),tab_type_quel()
,update_type_quel(),nbTypeQ_update(0),tab_nb_Elem()
,pos_Quelconque(list_tab_typeQuelconque.end())
,pos_ddletendu(list_tab_ddletendu.end())
,nbddletendu_update(0),tab_ddletendu(0),update_ddletendu(0)
,tab_enu_liaison(NULL),tab_ddl_lier(NULL)
{ num_noeud=num_id;
coord0 = NULL;
coord2 = NULL;
num_Mail = num_M;
// init de tab_0
#ifdef MISE_AU_POINT // vérification de la dimension de tab_ddl
if (tab.Taille() < c1.Dimension())
{ cout << "\nErreur : dans le constructeur de noeud : ";
cout << " Noeud (int num_id,Coordonnee& c0,Coordonnee& c1,Coordonnee& c2,"
<< "const Tableau<Ddl>& tab,int num_M)\n";
Sortie(1);
};
#endif
int tab0Taille = tab_0.Taille();
for (int i=1;i<=tab0Taille;i++)
tab_0(i) = tab_ddl(i).Valeur();
// on est en coordonnees entrainees, on vérifie que les ddl XI
// sont présent sinon on rajoute
int posi_X1=0; // init
if ( Existe(X1) == 0)
{ // le ddl X1 n'existe pas on rajoute les XI
int an = tab_ddl.Taille();
tab_ddl.Change_taille(an+Dimension());
tab_0.Change_taille(an+Dimension());
tab_tdt.Change_taille(an+Dimension());
for (int jj=1;jj<=Dimension();jj++)
tab_ddl(an+jj).Change_nom(Enum_ddl(jj));
posi_X1 = an+1; // c'est la position du ddl X1
}
else // sinon il existe on récupère sa position
posi_X1 = Existe(X1) ;
// on effectue la liaison ddl/ deplacement, donc la mémoire
// des coordonnées est positionnée dans le tableau de ddl
Liaison_tdt(posi_X1); // (Existe(X1));
// Liaison_tdt(Existe(X1));
*coord0 = c0; // recopie des valeurs
*coord2 = c2; // """"
for (int j=1;j<= Dimension();j++)
*(coord1(j)) = c1(j);
posi_type_quel = 1;
// mise a jour des ddl actifs et de l'adressage via l'énumération des ddl
MiseAjourActif();
MiseAjourEnum(); // mise en place de l'adressage directe
MiseAjourDdl_etendu(); // cas des ddl étendue
MiseAjourTypeQuelconque(); // cas des grandeurs quelconques
};
// Constructeur de copie
Noeud::Noeud (const Noeud& nd):
tab_0(nd.tab_0),tab_ddl(nd.tab_ddl),tab_tdt(nd.tab_tdt),coord1()
,tab_var_actives(nd.tab_var_actives),tab_actif(nd.tab_actif)
,pos_enum(nd.pos_enum)
,posiAssemb(nd.posiAssemb),baseB(NULL),baseB_t(NULL) // on définit ensuite la base
,baseB_0(NULL)
,t_enum_s(nd.t_enum_s)
,tab_type_quel(nd.tab_type_quel),update_type_quel(nd.update_type_quel)
,nbTypeQ_update(0),tab_nb_Elem(nd.tab_nb_Elem)
,pos_Quelconque(list_tab_typeQuelconque.end()) // idem ddl étendues
,pos_ddletendu(list_tab_ddletendu.end()) // c'est dans la méthode MiseAjourDdl_etendu, que le pointeur sera mis à jour
,nbddletendu_update(nd.nbddletendu_update)
,tab_ddletendu(nd.tab_ddletendu),update_ddletendu(nd.update_ddletendu)
// pour les liaisons cinématiques: pas de recopie, il s'agit d'un stockage uniquement:
// l'utilisation et la manipulation est à la charge des classes appelantes
,tab_enu_liaison(NULL),tab_ddl_lier(NULL)
{ num_noeud=nd.num_noeud;
coord2 = NULL; // initialisation
num_Mail = nd.num_Mail;
if ( Existe(X1) != 0)
{ coord0 = NULL;
// traitement des liaisons et avec du cas de coord1
if ( tab_tdt.Taille() != 0)
// cas avec les coordonnees a t+dt
//on effectue la liaison ddl/ deplacement
Liaison_tdt(Existe(X1));
else // sinon uniquement à t
Liaison_t(Existe(X1));
}
else
{if (nd.coord0 != NULL)
{coord0 = new Coordonnee(*(nd.coord0));
}
else
{coord0 = NULL;
};
};
// cas d'une base locale éventuelle
if (nd.baseB != NULL)
{baseB = new BaseB(*nd.baseB);};
if (nd.baseB_t != NULL)
{baseB_t = new BaseB(*nd.baseB_t);};
if (nd.baseB_0 != NULL)
{baseB_0 = new BaseB(*nd.baseB_0);};
posi_type_quel = nd.posi_type_quel;
// mise a jour des ddl actifs et de l'adressage via l'énumération des ddl
MiseAjourActif();
// pour les grandeurs quelconques, a priori on les met "non a jour"
// la mise à jour nécessite l'appel explicite à l'ordre de mise à jour
if (update_type_quel.Taille() != 0)
{ int t_typTaille = update_type_quel.Taille();
for (int titq=1;titq<= t_typTaille;titq++) update_type_quel(titq)=0;
};
MiseAjourDdl_etendu(); // cas des ddl étendue
MiseAjourTypeQuelconque(); // cas des grandeurs quelconques
};
Noeud::~Noeud()
// Destructeur de Noeud utilisant les destructeurs
// de Coordonnee et de Tableau<Ddl>
{ delete coord0; // le choix de la destruction ou pas de la zone
//mémoire est fait dans coord0
if (coord2 != NULL) delete coord2;
// on n'efface pas le tableau coord2 car s'il existe (c-a-d différent de null) il représente aussi
// des degrés de liberté, donc il se situe au même endroit que les éléments de tab_tdt
// qui lui sera de toute façon détruit par le destructeur automatique
// pour les enum étendus, on utilise la méthode MiseAjourDdl_etendu(), pour que tout soit cohérent
// on commence par supprimer les tableaux ad hoc et ensuite on met à jour
tab_ddletendu.Libere();update_ddletendu.Libere();nbddletendu_update=0;
MiseAjourDdl_etendu();
// idem pour les grandeurs quelconques
tab_type_quel.Libere(); update_type_quel.Libere(); nbTypeQ_update=0;
MiseAjourTypeQuelconque(); // cas des grandeurs quelconques
// dans le cas ou il existe des liaisons cinématiques on supprime les conteneurs
Suppression_tous_liaisons_noeuds();
// cas où il existe une base locale
if (baseB_0 != NULL) delete baseB_0;
if (baseB_t != NULL) delete baseB_t;
if (baseB != NULL) delete baseB;
};
// surcharge de l'operator de lecture, avec typage
istream & operator >> (istream & ent, Noeud & noe)
{ // lecture du type et vérification
string nomType,nom;
ent >> nomType;
if (nomType != "Noeud")
{ Sortie(1);
return ent;
};
// puis le numéro de noeud et le numéro de maillage
ent >> noe.num_noeud >> noe.num_Mail ;
// les liaisons éventuelles
bool test;
ent >> nom >> test; // tab_enu_liaison
if (test)
{ int nb;int toto;
ent >> nb;
if (noe.tab_enu_liaison != NULL)
{noe.tab_enu_liaison->Change_taille(nb);}
else
{noe.tab_enu_liaison = new Tableau <Enum_liaison_noeud>(nb);};
for (int i=1;i<= nb;i++)
{ ent >> nom >> toto >> nom;
(*noe.tab_enu_liaison)(i) = Id_nom_liaison_noeud(nom);
};
}
else
{if (noe.tab_enu_liaison != NULL)
{ delete noe.tab_enu_liaison; noe.tab_enu_liaison = NULL;}
};
ent >> nom >> test; // tab_ddl_lier
if (test)
{ int nb;int toto;
ent >> nb;
if (noe.tab_ddl_lier != NULL)
{noe.tab_ddl_lier->Change_taille(nb);}
else
{noe.tab_ddl_lier = new Tableau <Tableau <Posi_ddl_noeud> >(nb);};
for (int i=1;i<= nb;i++)
ent >> nom >> toto >> (*noe.tab_ddl_lier)(i);
}
else
{if (noe.tab_ddl_lier != NULL)
{ delete noe.tab_ddl_lier; noe.tab_ddl_lier = NULL;}
};
// le tableau des degrés de liberté
ent >> nom >> noe.tab_ddl;
// coordonnee initiale on les récupère par défaut
// ensuite on fera la mise à jour
ent >> nom >> *(noe.coord0);
ent >> nom >> noe.tab_0; // valeurs a l'instant 0 des ddl
ent >> nom >> noe.tab_tdt; // valeurs a l'instant t+dt des ddl
// les coordonnees a un instant t et tdt sont reconstruit avec
// la mise à jour si nécessaire
noe.MiseAjour();
// vérif si les coordonnees a un instant t+dt existent
// si oui liaison
ent >> nom;
if (nom == "coord2Existe")
noe.Liaison_tdt(noe.Existe(X1));
// ent >> nom >> noe.tab_var_actives; // les numéros des ddl actifs
// mise a jour des ddl actifs et de l'adressage via l'énumération des ddl
noe.MiseAjourActif();
noe.MiseAjourEnum(); // mise en place de l'adressage directe
// %% cas des types quelconques éventuelles %%
noe.Lecture_grandeurs_quelconque(ent);
// idem pour les ddl_etendu
noe.Lecture_Ddl_etendu(ent);
// cas d'une base locale éventuelle
{int existe_base;
ent >> existe_base;
if (existe_base == 1)
{if (noe.baseB_0 == NULL) {noe.baseB_0=new BaseB();};
ent >> nom >> (*noe.baseB_0);
};
ent >> existe_base;
if (existe_base == 1)
{if (noe.baseB_t == NULL) {noe.baseB_t=new BaseB();};
ent >> nom >> (*noe.baseB_t);
};
ent >> existe_base;
if (existe_base == 1)
{if (noe.baseB == NULL) {noe.baseB=new BaseB();};
ent >> nom >> (*noe.baseB);
};
};
return ent;
};
// surcharge de l'operator d'ecriture avec typage
ostream & operator << (ostream & sort , const Noeud & noe)
{ // le type, le numéro de noeud et le numéro de maillage
sort << "Noeud " << noe.num_noeud << " " << noe.num_Mail ;
// les liaisons éventuelles
if (noe.tab_enu_liaison != NULL)
{ sort << "\n tab_enu_liaison " << 1 << " "; // on signale la présence du tableau
int nb = (noe.tab_enu_liaison)->Taille();
sort << nb << " ";
for (int i=1;i<= nb;i++)
sort << " ass: "<< i << Nom_liaison_noeud((*noe.tab_enu_liaison)(i)) << " ";
}
else
sort << "\n tab_enu_liaison " << 0 << " "; // on signale l'absence du tableau ;
if (noe.tab_ddl_lier != NULL)
{ sort << "\n tab_ddl_lier " << 1 << " "; // on signale la présence du tableau
int nb = (noe.tab_ddl_lier)->Taille();
sort << nb << " ";
for (int i=1;i<= nb;i++)
sort << "\n ass: "<< i << " "<< (*noe.tab_ddl_lier)(i);
}
else
sort << "\n tab_ddl_lier " << 0 << " "; // on signale l'absence du tableau ;
// le tableau des degrés de liberté
sort << "\n ddl_primaires "<< noe.tab_ddl;
// coordonnee initiale on les sauvegarde par défaut
// ensuite on fera la mise à jour
sort << "\n coordo_0 "<< *(noe.coord0);
sort << "\n ddl_a_0 " << noe.tab_0; // valeurs a l'instant 0 des ddl
sort << "\n ddl_a_tdt " << noe.tab_tdt; // valeurs a l'instant t+dt des ddl
// les coordonnees a un instant t ne sont pas sauvegardées elles seront
// reconstruites si besoin avec la mise à jour
// coordonnee a un instant t+dt on signale son existence
if (noe.coord2 != NULL)
sort << "\ncoord2Existe \n";
else
sort << "\npascoord2 \n";
// sort << "ddl_actif " << noe.tab_var_actives; // les numéros des ddl actifs
// %% cas des types quelconques éventuelles %%
noe.Ecriture_grandeurs_quelconque(sort);
// idem pour les ddl_etendu
noe.Ecriture_Ddl_etendu(sort);
// cas d'une base locale éventuelle
if (noe.baseB_0 != NULL)
{sort << "\n 1 base_locale_0: " << (*noe.baseB_0);}
else {sort << "\n 0 base_locale_0: "; };
if (noe.baseB_t != NULL)
{sort << "\n 1 base_locale_t: " << (*noe.baseB_t);}
else {sort << "\n 0 base_locale_t: "; };
if (noe.baseB != NULL)
{sort << "\n 1 base_locale: " << (*noe.baseB);}
else {sort << "\n 0 base_locale: "; };
return sort;
};
// lecture du noeud en mémoire
void Noeud::Lecture(UtilLecture *entreePrinc)
{ int numero;
Coordonnee co(Dimension()); // def d'un tableau de coordonnées
*(entreePrinc->entree) >> numero ;
// lecture brut des coordonnées sans la dimension
co.Lecture(*entreePrinc);
Change_coord0(co); // transmission a noeud
if (numero != num_noeud)
{ cout << " ***ATTENTION dans la lecture du noeud ";
cout << " le numero d identification du noeud attribue par "
<< " le constructeur (" << num_noeud << ") est different de celui lu !!! "
<< " (" << numero << ") "
<< " Noeud::Lecture((UtilLecture *entreePrinc) " << endl ;
};
};
// affichage et definition interactive des commandes
// coor: des coordonnees fixée pour un affichage different pour chaque noeud
void Noeud::Info_commande_Noeud(UtilLecture * entreePrinc,Coordonnee& co,int numero)
{ ofstream & sort = *(entreePrinc->Commande_pointInfo()); // pour simplifier
int dima = ParaGlob::Dimension();
sort << "\n" << setw (6) << numero <<" ";
double sero = 0.;
#ifndef ENLINUX_STREAM
sort.setf(ios_base::scientific);
#else
sort.setf(ios::scientific);
#endif
// sort.setf(ios_base::scientific);
for (int j=1;j<=3;j++)
if (j<=dima)
sort << setw (18) << setprecision(ParaGlob::NbdigdoCA()) <<co(j) << " ";
else
sort << setw (18) << setprecision(ParaGlob::NbdigdoCA()) << sero << " ";
Change_coord0(co); // transmission a noeud
};
// Affiche les donnees liees au noeud
// le niveau différent de 0 permet d'accèder à plus d'info
void Noeud::Affiche (int niveau) const
{ cout << "\n --noeud -- \nNumero : " << num_noeud << ", du maillage: "<< num_Mail << '\n';
// les liaisons éventuelles
if (niveau > 0)
{// les liaisons éventuelles
if (tab_enu_liaison != NULL)
{ cout << "\n tab_enu_liaison " << 1 << " "; // on signale la présence du tableau
int nb = (tab_enu_liaison)->Taille();
cout << nb << " ";
for (int i=1;i<= nb;i++)
cout << " ass: "<< i << Nom_liaison_noeud((*tab_enu_liaison)(i)) << " ";
}
else
cout << "\n tab_enu_liaison " << 0 << " "; // on signale l'absence du tableau ;
if (tab_ddl_lier != NULL)
{ cout << "\n tab_ddl_lier " << 1 << " "; // on signale la présence du tableau
int nb = (tab_ddl_lier)->Taille();
cout << nb << " ";
for (int i=1;i<= nb;i++)
cout << "\n ass: "<< i << " "<< (*tab_ddl_lier)(i);
}
else
cout << "\n tab_ddl_lier " << 0 << " "; // on signale l'absence du tableau ;
};
cout << "Coordonnee(s) initiale(s) du noeud : \n";
coord0->Affiche();
if (coord1.Taille() != 0)
{ cout << "Coordonnee(s) a l'instant t : \n";
Coord1().Affiche();
}
if (coord2 != NULL)
{ cout << "Coordonnee(s) a l'instant t+dt : \n";
coord2->Affiche();
}
cout << "Degre(s) de liberte lie(s) au noeud : \n";
cout << "Taille du tableau : " << tab_ddl.Taille() << " , a 0, a t ( et t+dt ?)\n";
for (int i=1;i<=tab_ddl.Taille();i++)
{ if (tab_0.Taille() != 0) cout << tab_0(i) << " ";
tab_ddl(i).Affiche();
if (tab_tdt.Taille() != 0) cout << tab_tdt(i) << " ";
};
// les numéros de ddl actif
if (niveau > 3)
{cout << "\n les num des ddl actifs: " << tab_var_actives;
};
// affichage éventuelle des grandeurs enum étendue stockées au noeud
int tail_tab_ddletendu = tab_ddletendu.Taille();
if (tail_tab_ddletendu != 0)
{cout << "\nddl_etendu: ";
for (int itq=1;itq<=tail_tab_ddletendu;itq++)
{Ddl_etendu& ddlenum = tab_ddletendu(itq);
if (ddlenum.DdlEnumEtendu().Nom_vide())
{ cout << Nom_ddl(ddlenum.DdlEnumEtendu().Enum()) ;}
else
{ cout << ddlenum.DdlEnumEtendu().Nom() ;};
cout << " " << ddlenum.ConstValeur()<< " ";
};
};
// affichage éventuelle des grandeurs quelconques stockées au noeud
int tail_tab_type_quel = tab_type_quel.Taille();
if (tail_tab_type_quel != 0)
{cout << "\nddl_quelconque: ";
for (int itq=1;itq<=tail_tab_type_quel;itq++)
{cout << tab_type_quel(itq).EnuTypeQuelconque().NomPlein() << " "
<< *(tab_type_quel(itq).Grandeur_pointee()) << " \n";
};
};
// cas d'une base locale éventuelle
if (baseB_0 != NULL)
{cout << "\n base_locale_0: " << (*baseB_0);}
if (baseB_t != NULL)
{cout << "\n base_locale_t: " << (*baseB_t);}
if (baseB != NULL)
{cout << "\n base_locale: " << (*baseB);}
// dans le cas ou la variable niveau est plus grande que 0 on affiche plus d'information
if (niveau > 0)
{ cout << "\n le tableau d'adressage directe " << (* pos_enum) << endl;
};
cout << "-- fin noeud --\n";
};
// Affiche les donnees liees au noeud
void Noeud::Affiche (ostream& sort) const
{ // l'entete
sort << " Numero : [ " << num_noeud
<< " ]****/////, du maillage: < "<< num_Mail
<< " > ";
// les liaisons éventuelles
if (tab_enu_liaison != NULL)
{ int nb = (tab_enu_liaison)->Taille();
sort << nb << " liaison(s) (ass,type): ";
for (int i=1;i<= nb;i++)
sort << i << " " << Nom_liaison_noeud((*tab_enu_liaison)(i)) << " ";
};
if (tab_ddl_lier != NULL)
{ cout << "\n tab_ddl_lier " << 1 << " "; // on signale la présence du tableau
int nb = (tab_ddl_lier)->Taille();
sort << nb << " , ddl_lie(s) (ass,maill,noe,enu): ";
for (int i=1;i<= nb;i++)
sort << i << " "<< (*tab_ddl_lier)(i);
};
sort << " =======================\n";
// les coordonnees
sort << "Coord t=0 : "; coord0->Affiche(sort,16); sort << ", " ;
if (coord1.Taille() != 0)
{ sort << "\nCoord a t : "; Coord1().Affiche(sort,16); sort << ", " ;};
if (coord2 != NULL)
{sort << "\nCoord a t+dt: " ; coord2->Affiche(sort,16); sort << ", " ;};
// les ddl et variations
sort << '\n' << tab_ddl.Taille() << " Ddl a ";
if (tab_0.Taille() != 0) sort << " <<0>> ";
sort << " <<t>> ( et variation) ";
if (tab_tdt.Taille() != 0) sort << " <<tdt>> (et variation) : \n";
for (int i=1;i<=tab_ddl.Taille();i++)
{ sort << tab_ddl(i).Nom() << " = "; // le nom
if (tab_0.Taille() != 0) sort << setw (16) << tab_0(i) << ", "; // val a t=0
sort << setw (16) << tab_ddl(i).Valeur() << " "; // val a t
if (tab_0.Taille() != 0)
sort << "( " << setw (16) << (tab_ddl(i).Valeur() - tab_0(i)) << "), "; // delta 0 t
if (tab_tdt.Taille() != 0) sort << setw (16) << tab_tdt(i) << " "; // val a tdt
if ((tab_0.Taille() != 0)&&(tab_tdt.Taille() != 0))
sort << "(" << setw (16) << (tab_tdt(i) - tab_0(i)) << " );"; // deltat 0 tdt
// decalage pour la ligne suivante
sort << "\n";
};
// affichage éventuelle des grandeurs quelconques stockées au noeud
int tail_tab_type_quel = tab_type_quel.Taille();
for (int itq=1;itq<=tail_tab_type_quel;itq++)
{sort << (tab_type_quel(itq).EnuTypeQuelconque()).NomPlein() << " "
<< *(tab_type_quel(itq).Grandeur_pointee()) << " \n";
};
// cas d'une base locale éventuelle
if (baseB_0 != NULL)
{sort << "\n base_locale_0: " << (*baseB_0);}
if (baseB_t != NULL)
{sort << "\n base_locale_t: " << (*baseB_t);}
if (baseB != NULL)
{sort << "\n base_locale: " << (*baseB);}
sort << "\n";
};
// insert des coordonnees coord1 si elles n'existent pas encore
// permet de définir des coordonnées à t, dans ce cas des ddl XI sont inclus
// et sont mis inactif par défaut
void Noeud::Insert_coord1(const Coordonnee& nouveau_coord1)
{ // si les coordonnées n'existe pas encore il faut les créer
if ( Existe(X1) == 0)
{ // le ddl X1 n'existe pas on le rajoute
int an = tab_ddl.Taille();
tab_ddl.Change_taille(an+Dimension());
tab_0.Change_taille(an+Dimension());
int dim = Dimension();
for (int jj=1;jj<=dim;jj++)
tab_ddl(an+jj).Change_nom(Enum_ddl(jj));
// on effectue la liaison ddl/ deplacement
Liaison_t(Existe(X1));
// on met les XI hors service
for (int i = 1; i<=dim; i++)
tab_ddl(an+i).Met_hors_service();
// mise a jour des ddl actifs et de l'adressage via l'énumération des ddl
MiseAjourActif();
MiseAjourEnum(); // mise en place de l'adressage directe
};
// copie des ddl
for (int i=1;i<=coord1.Taille();i++)
*(coord1(i)) = nouveau_coord1(i);
};
// idem mais sans paramètre indique que l'on initialise aux coordonnées à t=0
// s'ils n'existent pas, sinon on ne fait rien
void Noeud::Insert_coord1()
{ // si les coordonnées n'existe pas encore il faut les créer
if ( Existe(X1) == 0)
{ // le ddl X1 n'existe pas on le rajoute
int an = tab_ddl.Taille();
tab_ddl.Change_taille(an+Dimension());
tab_0.Change_taille(an+Dimension());
int dim = Dimension();
for (int jj=1;jj<=dim;jj++)
tab_ddl(an+jj).Change_nom(Enum_ddl(jj));
// on effectue la liaison ddl/ deplacement
// donc le ddl X1 se situe maintenant à la place an+1 dans le tableau
// des ddl
Liaison_t(an+1); //(Existe(X1));
// on met les XI hors service
for (int i = 1; i<=dim; i++)
tab_ddl(an+i).Met_hors_service();
// mise a jour des ddl actifs et de l'adressage via l'énumération des ddl
MiseAjourActif();
MiseAjourEnum(); // mise en place de l'adressage directe
// copie des ddl
for (int i=1;i<=coord1.Taille();i++)
*(coord1(i)) = (*coord0)(i);
};
};
// Modifie les valeurs des coordonnees coord1
void Noeud::Change_coord1(const Coordonnee& nouveau_coord1)
{ // si les coordonnées n'existe pas encore il faudrait les créer avant de les utiliser
#ifdef MISE_AU_POINT // vérif
if ((nouveau_coord1.Dimension() != Dimension()) ||
(coord1.Taille() == 0) || ((coord1(1)) == NULL))
{ cout << "\nErreur : dans l'affectation de coordonnées à t, elles ne sont pas définies !\n";
cout << " Noeud::Change_coord1(Coordonnee& nouveau_coord1)\n";
Sortie(1);
}
#endif
for (int i=1;i<=coord1.Taille();i++)
*(coord1(i)) = nouveau_coord1(i);
};
// Retourne les coordonnees coord1 du noeud
// uniquement pour la lecture
//Coordonnee Noeud::Coord1 ()
// { int nbcoo = coord1.Taille();
// Coordonnee coo(nbcoo);
// for (int i=1;i<=nbcoo;i++)
// coo(i) = *(coord1(i));
// return coo;
// };
// Retourne le nombre de degres de liberte du noeud
// qui sont actuellement actifs
//int Noeud::Nombre_var_ddl_actives ()
// { int total = 0;
// int imax = tab_ddl.Taille();
// for (int i=1;i<=imax;i++)
// if (tab_ddl(i).Service()) total ++;
// return total;
// };
// retourne la liste de tous les types de ddl actuellement utilisé
// par le noeud (actif ou non)
List_io <Enum_ddl> Noeud::Les_type_de_ddl(bool)
{ int tail = tab_ddl.Taille();
List_io <Enum_ddl> tab_enum;
for (int i= 1;i<= tail;i++)
tab_enum.push_back(tab_ddl(i).Id_nom());
return tab_enum;
};
// retourne la liste de tous les Ddl_enum_etendu disponible
List_io <Ddl_enum_etendu> Noeud::Les_type_de_ddl_etendu(bool)
{ int tail = tab_ddletendu.Taille();
List_io <Ddl_enum_etendu> tab_enum_etendu;
for (int i= 1;i<= tail;i++)
tab_enum_etendu.push_back(tab_ddletendu(i).Const_DdlEnumEtendu());
return tab_enum_etendu;
};
// retourne la liste de tous les TypeQuelconque disponibles
List_io <TypeQuelconque> Noeud::Les_TypeQuelconque(bool )
{ int tail = tab_type_quel.Taille();
List_io <TypeQuelconque> tab_TypeQuelconque;
for (int i= 1;i<= tail;i++)
tab_TypeQuelconque.push_back(tab_type_quel(i));
return tab_TypeQuelconque;
};
// récupération d'une liste d'info
// le tableau de retour à la taille de li_enu_scal et contient
// les valeurs correspondantes aux Ddl_enum_etendu stockées au noeud
// en fait ici on cumule les ddl pur "et" les ddl_étendue,
// li_quelc : est modifié par les valeurs contenues au noeud
Tableau <double> Noeud::Valeur_multi_et_Tensorielle
(const List_io <Ddl_enum_etendu>& li_enu_scal,List_io <TypeQuelconque >& li_quelc) const
{int nb_ddl_enum_etendu = li_enu_scal.size(); // la taille du tableau de retour
Tableau <double> tab_ret(nb_ddl_enum_etendu); // le tableau de retour
// on balaie les ddl_enum_etendu pour les alimenter
{List_io <Ddl_enum_etendu>::const_iterator il,il_fin = li_enu_scal.end();
int i_tab=1; // init
for (il= li_enu_scal.begin(); il != il_fin; il++,i_tab++)
{ // on regarde s'il s'agit d'un ddl pur
const Ddl_enum_etendu& ddl = (*il); // pour simplifier
if (ddl.Nom_vide())
// cas d'un ddl pur
{ if (Existe_ici(ddl.Enum()))
{tab_ret(i_tab)= Valeur_tdt(ddl.Enum());}
else
{cout << "\n *** erreur d'acces, le ddl "<< Nom_ddl(ddl.Enum())
<< " n'est pas disponible au temps tdt "
<< "\n Noeud::Valeur_multi_et_Tensorielle(...";
Noeud::Affiche(0);
Sortie(1);
};
}
else // cas d'un ddl étendu
{ if (Existe_ici_ddlEtendu(ddl))
{tab_ret(i_tab)= DdlEtendue(ddl).ConstValeur();}
else
{cout << "\n *** erreur d'acces, le ddl etendue "<< ddl.Nom_plein()
<< " n'est pas disponible au temps tdt "
<< "\n Noeud::Valeur_multi_et_Tensorielle(...";
Noeud::Affiche(0);
Sortie(1);
};
};
};
};
//on balaie les types quelconques
{List_io <TypeQuelconque>::iterator il,il_fin = li_quelc.end();
int i_tab=1; // init
for (il= li_quelc.begin(); il != il_fin; il++,i_tab++)
{ TypeQuelconque& etq = (*il); // pour simplifier
// on regarde s'il existe
TypeQuelconque_enum_etendu en = etq.EnuTypeQuelconque(); // pour simplifier
if (Existe_ici(en))
{ etq = Grandeur_quelconque(en);}
else
{// on test s'il s'agit d'un type correspondant à une grandeur
// stockée naturellement au noeud
bool trouver = false; // init
if(en.Nom_vide()) // on ne prend en compte que les types initiaux
{switch (en.EnumTQ())
{ case NUM_NOEUD:
{ Grandeur_scalaire_entier& gr= *((Grandeur_scalaire_entier*) (etq.Grandeur_pointee()));
*(gr.ConteneurEntier()) = this->Num_noeud();
trouver = true;
break;
}
case NUM_MAIL_NOEUD:
{ Grandeur_scalaire_entier& gr= *((Grandeur_scalaire_entier*) (etq.Grandeur_pointee()));
*(gr.ConteneurEntier()) = this->Num_Mail();
trouver = true;
break;
}
case POSITION_GEOMETRIQUE:
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) (etq.Grandeur_pointee()));
(*gr.ConteneurCoordonnee())= this->Coord2();
trouver = true;
break;
}
case POSITION_GEOMETRIQUE_t:
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) (etq.Grandeur_pointee()));
(*gr.ConteneurCoordonnee())= this->Coord1();
trouver = true;
break;
}
case POSITION_GEOMETRIQUE_t0:
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) (etq.Grandeur_pointee()));
(*gr.ConteneurCoordonnee())= this->Coord0();
trouver = true;
break;
}
case DEPLACEMENT:
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) (etq.Grandeur_pointee()));
(*gr.ConteneurCoordonnee())= this->Coord2() - this->Coord0();
trouver = true;
break;
}
case VITESSE:
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) (etq.Grandeur_pointee()));
if (this->Existe_ici(V1))
{int dima = this->Coord0().Dimension(); // on récupère la dim en cours
Coordonnee& V = (*gr.ConteneurCoordonnee()); // pour simplifier
switch (dima)
{ case 3: V(3) = this->Valeur_tdt(V3);
case 2: V(2) = this->Valeur_tdt(V2);
case 1: V(1) = this->Valeur_tdt(V1);
};
};
trouver = true;
break;
}
case ACCELERATION:
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) (etq.Grandeur_pointee()));
if (this->Existe_ici(GAMMA1))
{int dima = this->Coord0().Dimension(); // on récupère la dim en cours
Coordonnee& gamma = (*gr.ConteneurCoordonnee()); // pour simplifier
switch (dima)
{ case 3: gamma(3) = this->Valeur_tdt(GAMMA3);
case 2: gamma(2) = this->Valeur_tdt(GAMMA2);
case 1: gamma(1) = this->Valeur_tdt(GAMMA1);
};
};
trouver = true;
break;
}
//*** fin
default:
trouver = false;
break;
};
};
if (!trouver)
{cout << "\n *** erreur d'acces, le ddl "<< en.NomPlein()
<< " n'est pas disponible "
<< "\n Noeud::Valeur_multi_et_Tensorielle(...";
Noeud::Affiche(0);
Sortie(1);
};
};
};
};
// retour
return tab_ret;
};
// ramene le nombre de variables ddl actives pour un type de ddl donné,
// c'est-à-dire 1 ou la dimension, suivant que le type dépend
// ou pas de la dimension
int Noeud::Nombre_var_ddl_actives (Enum_ddl en) const
{ int retour = 0;
if ((Existe(en) != 0) && (En_service(en)) && (UneVariable(en)))
{ switch (TypeGrandeur(en))
{ case SCALAIRE :
retour=1;
break;
case VECTEUR : case COORDONNEE : // là il y a un mélange pas sain !
// dans le cas où le calcul est axisymétrique
// on ne prend pas en compte le 3 ième ddl
if (ParaGlob::AxiSymetrie())
{retour = 2; }// on est forcément en 3D
else
{retour=ParaGlob::Dimension();};
break;
case TENSEUR :
retour = ParaGlob::NbCompTens();
break;
case RIEN_TYPEGRANDEUR :
retour = 0;
break;
default :
cout << "\nErreur : valeur incorrecte du type Enum_ddl !\n";
cout << "Nombre_var_ddl_actives (Enum_ddl en) \n";
Sortie(1);
};
};
return retour;
};
// surcharge de l'affectation entre deux noeuds
Noeud& Noeud::operator= (const Noeud& nd)
{ // recopie des tableaux
tab_0 = nd.tab_0;
tab_ddl = nd.tab_ddl;
tab_tdt = nd.tab_tdt;
num_Mail = nd.num_Mail;
// // liaison éventuelle
// enu_liaison = nd.enu_liaison;
// noeud_lier = nd.noeud_lier;
// puis les variables
num_noeud=nd.num_noeud;
posiAssemb = nd.posiAssemb;
// cas d'une base locale éventuelle
if (nd.baseB != NULL)
{if (baseB != NULL)
{ (*baseB) = (*(nd.baseB));}
else
{baseB = new BaseB(*nd.baseB);};
}
else // cas où nulle
{ if (baseB != NULL) delete baseB;}
if (nd.baseB_t != NULL)
{if (baseB_t != NULL)
{ (*baseB_t) = (*(nd.baseB_t));}
else
{baseB_t = new BaseB(*nd.baseB_t);};
}
else // cas où nulle
{ if (baseB_t != NULL) delete baseB_t;}
if (nd.baseB_0 != NULL)
{if (baseB_0 != NULL)
{ (*baseB_0) = (*(nd.baseB_0));}
else
{baseB_0 = new BaseB(*nd.baseB_0);};
}
else // cas où nulle
{ if (baseB_0 != NULL) delete baseB_0;}
coord2 = NULL; // initialisation
if ( Existe(X1) != 0)
{ // on met à null coord0 pour éviter de prendre ses valeurs
coord0 = NULL;
if ( tab_tdt.Taille() != 0)
// cas avec les coordonnees a t+dt
//on effectue la liaison ddl/ deplacement
Liaison_tdt(Existe(X1));
else
Liaison_t(Existe(X1));
}
else // cas où il n'y a pas de liaison
{coord0 = new Coordonnee(*(nd.coord0));
// la taille de coord1 est initialisé à 0 par défaut
};
tab_var_actives = nd.tab_var_actives;tab_actif = nd.tab_actif;
pos_enum = nd.pos_enum; // mise en place de l'adressage directe
t_enum_s = nd.t_enum_s; // mise en place
// dans le cas où il y a des ddl_etendu
// on recopie les différents tableaux et on met à jour
tab_ddletendu=nd.tab_ddletendu;
update_ddletendu=nd.update_ddletendu;
nbddletendu_update=nd.nbddletendu_update;
// on ne recopie pas le pointeur pos_ddletendu, car se sera dans la méthode MiseAjourDdl_etendu
// qu'il sera mis à jour
MiseAjourDdl_etendu();
// dans le cas où il y a des grandeurs quelconques (mêmes remarques que dans le cas des enum étendus)
tab_type_quel = nd.tab_type_quel;
update_type_quel = nd.update_type_quel;
nbTypeQ_update = nd.nbTypeQ_update;
MiseAjourTypeQuelconque();
return (*this);
};
// initialisation d'un ou de plusieurs nouveaux cas d'assemblage
void Noeud::InitNouveauCasAssemb(int nb_cas)
{ // récup de la taille actuelle
int taille_actuelle = posiAssemb.Taille();
// nouvelle taille
int nouvelle_taille = taille_actuelle + nb_cas;
// changement de taille, normalement les anciennes valeurs sont gardée
// en début de tableau
posiAssemb.Change_taille(nouvelle_taille);
t_enum_s.Change_taille(nouvelle_taille);
// on initialise les nouveaux éléments -> pour l'instant pointe sur rien
// car c'est la fin de la liste
for (int i= taille_actuelle+1;i<= nouvelle_taille;i++)
t_enum_s(i)=list_tab_posi_actif.end();
};
// enregistrement de l'ordre des variables ddl actives, ceci pour un cas d'assemblage
// donné, cette fonction permet ensuite d'utiliser la fonction
// Position_ddl qui donne la position d'un ddl pour un cas d'assemblage
// donné
void Noeud::Enreg_ordre_variable_ddl_actives(int nb_assemb)
{ // l'objectif est de déterminer ou de construire s'il n'existe pas, un tableau
// indexé par les types énumérés des ddl actifs
// le programme est construit sur le même modèle que MiseAjourEnum()
// mais ici on ne s'intéresse qu'au ddl actif
List_io <Tableau <int > >::iterator& pos_enum_s = t_enum_s(nb_assemb); // pour simplifier
// tout d'abord on regarde si le dernier tableau construit dans la liste
// list_tab_posi_actif, convient, car ce sera le cas pour le cas courant
// le dernier tableau est positionné en début de liste.
List_io <Tableau <int > >::iterator ideb;
ideb = list_tab_posi_actif.begin();
List_io <Tableau <int > >::iterator iancien = pos_enum_s;
int taille = tab_var_actives.Taille();
// le dernier élément stocké contiend le nombre d'élément non nul, on récupère sa position
int ttail = (*ideb).Taille();
bool okk = true;
// le test n'est effectué que si la liste n'est pas vide
if (list_tab_posi_actif.size() != 0)
{ // d'abort la taille, on compte le nombre d'élément non nul dans
int ttaile = (*ideb)(ttail);
if (taille != ttaile)
okk = false;
else
// maintenant le contenu
for (int i = 1; i<= taille;i++)
if( (*ideb)(tab_ddl(tab_var_actives(i)).Id_nom()) != i)
{ okk = false; break;}
}
else
okk = false;
// si le tableau convient on met à jour le pointeur et c'est fini
// sinon on passe en revu toute la liste
if (okk)
pos_enum_s = ideb;
else // ---- cas où on passe en revue la liste -----
// ici la procédure est plus longue, mais normalement elle ne sera
// utilisé que peut souvent
{
// on reconstruit un tableau d'adressage indirect des ddl
// la taille du tableau d'adressage est celui du nombre maxi
// de type de ddl différent (donc certain ne serviron pas)
// les données du tableau sont initialisées à 0, ainsi si l'on
// cherche à utiliser un ddl indice 0, l'erreur sera détecté au
// niveau de Tableau_T
// l'avant dernier élément du tableau sert à stocker le nombre de noeud
// qui utilise le tableau
// le dernier élément indique le nombre d'élément non nul
Tableau <int> tab_indi_enum(NbEnum_ddl()+2,0);
for (int i=1;i<=taille;i++)
tab_indi_enum(tab_ddl(tab_var_actives(i)).Id_nom())=i;
// on enregistre la taille
tab_indi_enum(NbEnum_ddl()+2) = taille;
// maintenant on va regarder si ce tableau existe dans la liste
List_io <Tableau <int > >::iterator ifin = list_tab_posi_actif.end();
List_io <Tableau <int > >::iterator iter;
bool trouver = false;
for (iter = ideb;ideb!= ifin;ideb++)
if ((*iter) == tab_indi_enum)
{ trouver = true; break;}
// si pas trouver on ajoute sinon on utilise la position déjà existante
if (!trouver)
// cas où on n'a pas trouvé de tableau
{ list_tab_posi_actif.push_front(tab_indi_enum); // allocation
// on attribue le nouveau pointage
pos_enum_s = list_tab_posi_actif.begin(); // sauvegarde de la position
}
else // cas où on a trouvé un tableau dans la liste
pos_enum_s = iter;
};
// on regarde si pos_enum_s était déjà attribué
if (iancien != list_tab_posi_actif.end())
// cas où ce n'est pas la première initialisation
{if ((*iancien)(NbEnum_ddl()+1) == 1)
// cas où c'est le dernier noeud qui pointe sur ce tableau
// on supprime le tableau
list_tab_posi_actif.erase(iancien);
else
// sinon on décrémente le compteur
((*iancien)(NbEnum_ddl()+1))--;
// maintenant on s'occupe du nouveau pointage
((*pos_enum_s)(NbEnum_ddl()+1))++;
}
else
// c'est la première initialisation
// on incrémente le compteur du tableau
((*pos_enum_s)(NbEnum_ddl()+1))++;
};
// test si le noeud est complet
// = 1 tout est ok, =0 element incomplet
int Noeud::TestComplet() const
{ bool ret=true;
if ((num_noeud == -3) || (num_Mail == -3))
{ if (num_noeud == -3) cout << "\n le numero du noeud n'est pas defini";
if (num_Mail == -3) cout << "\n le numero de maillage n'est pas defini";
if (ParaGlob::NiveauImpression() >= 6) this->Affiche();
ret = false;
}
if (tab_ddl.Taille() == 0)
{ cout << "\n ***** warning : il n'y a pas de ddl rattache au noeud " << num_noeud
<< ", du maillage " << num_Mail;
// ret = false;
// maintenant normalement ce n'est plus un pb
}
else
{ int nbdd = tab_ddl.Taille();
for (int i=1;i<= nbdd ;i++)
if (tab_ddl(i).TestComplet() == 0)
{ cout << "\n probleme avec le ddl " << i << "du noeud " << num_noeud
<< ", du maillage " << num_Mail;
ret = false;
};
// if (posiAssemb.Taille() == 0) return 0;
};
return ret;
};
// ajout de ddl
// 1) s'il n'y a pas de ddl il y a initialisation
// 2) si les ddl existent deja, on égalise au ddl passé en paramètre
// 3) lorsque le ddl appartient à une famille, tous les ddl de la famille sont
// ajoutées, les ddl supplémentaires ont une valeurs par défaut nulle
void Noeud::PlusDdl(Ddl& a)
{ // on regarde si le tableau des ddl existant est vide
int taille = tab_ddl.Taille();
if (taille == 0)
{ tab_ddl.Change_taille(1);
tab_ddl(1) = a;
// on peut maintenant mettre en place l'adressage directe
// ce qui permettra d'utiliser Existe(..) dans MiseAjour
MiseAjourEnum(); // mise en place de l'adressage directe
// mise a jour des tableaux et des liaisons ddl/deplacement
MiseAjour();
}
else
{ // on regarde si le Ddl existe
for (int i=1;i<= taille; i++)
// on test uniquement sur l'identificateur du ddl, ces caractéristiques
// pouvant être différents suite à un précédent calcul
if ((tab_ddl(i)).Id_nom() == a.Id_nom())
{ tab_ddl(i) = a;
MiseAjourActif();
return;
};
// dans le cas où la dimension est supérieur à 1 et que le ddl appartient
// à une famille dépendant de la dimension, on ajoute tous les ddl de la famille
Enum_ddl enu = a.Id_nom();
if ((ParaGlob::Dimension()>1)&&FoncDim(enu))
{// on récupère tous les ddl de la famille
Tableau<Enum_ddl> t_enu =TableauTypeDdl(enu);
// fabrication d'un tableau de ddl associé
int ttaille = t_enu.Taille();
Tableau <Ddl > t_ddl(ttaille,a);// tous les nouveaux ddl on le même statut que a
for (int il=1;il<=ttaille;il++)
{t_ddl(il).Change_nom(t_enu(il));
if (t_ddl(il).Id_nom() != enu)
t_ddl(il).Valeur() = 0.; // mise à 0 pour les valeurs des ddl supplémentaires
}
// appel de la méthode gérant un tableau de ddl
PlusTabDdl(t_ddl);
return;
};
// dans le cas ou la dimension est supérieur à 1 et que les ddl est un XI
// erreur
// if ( (PremierDdlFamille(a.Id_nom())==X1) && (ParaGlob::Dimension() != 1))
// { cout <<"\n Erreur, la dimension etant superieur a 1 il n'est pas "
// << " possible d'ajouter qu'un seul ddl de position \n";
// cout << "void Noeud::PlusDdl(Ddl& a)" << endl;
// Sortie (1);
// }
// on regarde s'il y a une incompatibilite Xi Ui
if ((Existe_ici(X1) && (PremierDdlFamille(a.Id_nom())==UX)) ||
(Existe_ici(UX) && (PremierDdlFamille(a.Id_nom())==X1)) ||
(Existe_ici(UY) && (PremierDdlFamille(a.Id_nom())==X1)) ||
(Existe_ici(UZ) && (PremierDdlFamille(a.Id_nom())==X1)) )
{ cout <<"\n Erreur, on ne peut pas avoir de coordonnees entrainees"
<< " avec des ddl Ui \n";
cout << "void Noeud::PlusDdl(Ddl& a)" << endl;
Sortie (1);
};
// sauvegarde éventuelle des coordonnées
if (coord0 != NULL) // il existe déjà des coordonnées 0
// si les coordonnees existent deja on les sauvegarde dans une
//instance réelle et non éventuellement pointé
// sera ensuite modifié avec MiseAjour() éventuellement
{ Coordonnee truc(*coord0);
delete coord0;
coord0 = new Coordonnee(truc);
};
int coord1Taille = coord1.Taille();
Vecteur* toto = NULL;
if (coord1Taille != 0)
// signifie qu'il y a une liaison entre les ddl à t et coord1
if (coord1(1) != NULL)
// tableau existant et affecte, on cré un tableau
//intermédiaire, qui est supprimé à la fin de la routine
toto = new Vecteur(coord1Taille);
// réécriture dans toto, place qui sera utilisée dans mise à jour
// puis après MiseAjour() suppression de toto
for (int ii=1;ii<=coord1Taille;ii++)
{ (*toto)(ii) = *(coord1(ii));
coord1(ii) = &(*toto)(ii);
};
if (coord2 != NULL) // il existe déjà des coordonnées finales
// si les coordonnees existent deja on les sauvegarde dans
// une instance réelle et non éventuellement pointé
{ Coordonnee truc(*coord2);
delete coord2;
coord2 = new Coordonnee(truc);
};
// maintenant on peut changer le tableau de ddl
// on augmente la taille du tableau
tab_ddl.Change_taille(taille+1);
tab_ddl(taille+1) = a;
// on peut maintenant mettre en place l'adressage directe
// ce qui permettra d'utiliser Existe(..) dans MiseAjour
MiseAjourEnum(); // mise en place de l'adressage directe
// mise a jour des tableaux et des liaisons ddl/deplacement
MiseAjour();
if (toto != NULL) delete toto;
};
// mise a jour des ddl actifs et de l'adressage via l'énumération des ddl
MiseAjourActif();
// MiseAjourEnum(); // mise en place de l'adressage directe
};
// ajout d'un tableau de ddl
// 1) s'il n'y a pas de ddl il y a initialisation
// 2) si les ddl existent deja, on égalise avec les ddl passés en par
// 3) lorsque un nouveau ddl appartient à une famille, et que tous les ddl de la famille
// ne sont pas présents dans les ddl passés en paramètre, tous les ddl manquant de la famille sont
// ajoutées, avec une valeurs par défaut nulle
void Noeud::PlusTabDdl(Tableau<Ddl>& ta)
{ // on commence par ordonner le tableau ta
OrdonnerTableauDdl(ta);
// maintenant tous les ddl de ta sont dans le bonne ordre et à suivre
// on regarde si le tableau est vide
int taille = tab_ddl.Taille();
if (taille == 0)
{ tab_ddl = ta;
// on peut maintenant mettre en place l'adressage directe
// ce qui permettra d'utiliser Existe(..) dans MiseAjour
MiseAjourEnum(); // mise en place de l'adressage directe
// mise a jour des tableaux et des liaisons ddl/deplacement
MiseAjour();
}
else
{// on regarde combien de Ddl existe deja
// et on crée une liste des ddl à ajouter
// les ddl qui existent déjà sont éventuellement updaté
list<Ddl> liDdl;
bool change_donn_var=false;
ListeDdlAajouter(liDdl,ta,change_donn_var);
// on augmente la taille du tableau en consequence
// mais auparavant dans le cas où les coordonnées sont connues
// que sous la forme de valeurs pointées il faut les sauvegarder
if (liDdl.size() == 0)
{ // dans le cas où on a aucun ddl a ajouter
// on regarde cependant si il y a eu un changement de type
if (change_donn_var) MiseAjourActif();
return;
}
else
{ // sauvegarde éventuelle des coordonnées
if (coord0 != NULL) // il existe déjà des coordonnées 0
// si les coordonnees existent deja on les sauvegarde
// dans une instance réelle et non éventuellement pointé
{ Coordonnee truc(*coord0);
delete coord0;
coord0 = new Coordonnee(truc);
};
int coord1Taille = coord1.Taille();
Vecteur* toto = NULL;
if (coord1Taille != 0)
if (coord1(1) != NULL)
{// tableau existant et affecte, on crée un tableau intermédiaire,
// qui est supprimé à la fin de la routine
toto = new Vecteur(coord1Taille);
// réécriture dans toto, place qui sera utilisée dans mise à jour
// puis après MiseAjour() suppression de toto
for (int ii=1;ii<=coord1Taille;ii++)
{ (*toto)(ii) = *(coord1(ii));
coord1(ii) = &(*toto)(ii);
};
};
if (coord2 != NULL) // il existe déjà des coordonnées finales
// si les coordonnees existent deja on les sauvegarde dans
// une instance réelle et non éventuellement pointé
{ Coordonnee truc(*coord2);
delete coord2;
coord2 = new Coordonnee(truc);
};
// maintenant on peut changer le tableau de ddl
int nbddl_a_ajouter=liDdl.size();
tab_ddl.Change_taille(taille+nbddl_a_ajouter);
// on rempli le tableau
list <Ddl >::iterator il=liDdl.begin();
for (int j1=1;j1<= nbddl_a_ajouter;j1++,il++)
{ tab_ddl(taille+j1)=(*il);};
// on peut maintenant mettre en place l'adressage directe
// ce qui permettra d'utiliser Existe(..) dans MiseAjour par exemple
MiseAjourEnum(); // mise en place de l'adressage directe
// on regarde s'il y a une incompatibilite Xi Ui
int tab_ddlTaille = tab_ddl.Taille();
if (Existe_ici(X1))
for (int i=1;i<= tab_ddlTaille;i++)
if (Meme_famille(tab_ddl(i).Id_nom(),UX))
{ cout <<"\n Erreur, on ne peut pas avoir de coordonnees entrainees"
<< " avec des ddl Ui \n";
cout << "void Noeud::PlusTabDdl(Tableau<Ddl>& ta)" << endl;
Sortie (1);
};
// mise a jour des tableaux et des liaisons ddl/deplacement
MiseAjour();
if (toto != NULL) delete toto;
};
};
// mise a jour des ddl actifs et de l'adressage via l'énumération des ddl
MiseAjourActif();
// MiseAjourEnum(); // mise en place de l'adressage directe
};
// ajout du tableau de ddl d'un autre noeud
void Noeud::PlusTabDdl(const Noeud & noe)
{ // on récupère le tableau de ddl géné par noe
Tableau<Ddl> ta = noe.tab_ddl;
if (ta.Taille() != 0)
Noeud::PlusTabDdl(ta);
};
// modification du statut d'un ddl
// si en est inconnu, aucune action
void Noeud::Met_hors_service(Enum_ddl en)
{ tab_ddl(Existe(en)).Met_hors_service();
MiseAjourActif();
};
void Noeud::Met_en_service(Enum_ddl en)
{ tab_ddl(Existe(en)).Met_en_service();
MiseAjourActif();
};
// modification du statut d'un tableau de ddl
// si un des elements du tableau est inconnu, aucune action
void Noeud::Met_hors_service(const Tableau<Enum_ddl>& taben)
{ int tabenTaille = taben.Taille();
for (int i = 1; i<=tabenTaille; i++)
tab_ddl(Existe(taben(i))).Met_hors_service();
MiseAjourActif();
};
void Noeud::Met_en_service(const Tableau<Enum_ddl>& taben)
{ int tabenTaille = taben.Taille();
for (int i = 1; i<=tabenTaille; i++)
tab_ddl(Existe(taben(i))).Met_en_service();
MiseAjourActif();
};
// modification du statut de tous les ddl actuellements présent
// y compris les données
// si un des elements du tableau est inconnu, aucune action
void Noeud::Met_hors_service()
{ int tab_ddlTaille = tab_ddl.Taille();
for (int i = 1; i<=tab_ddlTaille; i++)
tab_ddl(i).Met_hors_service();
MiseAjourActif();
};
void Noeud::Met_en_service()
// y compris les données
{ int tab_ddlTaille = tab_ddl.Taille();
for (int i = 1; i<=tab_ddlTaille; i++)
tab_ddl(i).Met_en_service();
MiseAjourActif();
};
// modification du statut de tous les ddl actuellements présent
// sauf les données qui ne sont pas modifiées
// si un des elements du tableau est inconnu, aucune action
void Noeud::Met_hors_service_ddl()
{ int tab_ddlTaille = tab_ddl.Taille();
for (int i = 1; i<=tab_ddlTaille; i++)
tab_ddl(i).Met_hors_service_ddl();
MiseAjourActif();
};
void Noeud::Met_en_service_ddl()
// y compris les données
{ int tab_ddlTaille = tab_ddl.Taille();
for (int i = 1; i<=tab_ddlTaille; i++)
tab_ddl(i).Met_en_service_ddl();
MiseAjourActif();
};
// changement du statut de variable à donnée pour un tableau d'enum de ddl
void Noeud::ChangeVariable_a_Donnee(const Tableau<Enum_ddl>& taben)
{ int tabenTaille = taben.Taille();
for (int i = 1; i<=tabenTaille; i++)
{int exist = Existe(taben(i));
if (exist)
tab_ddl(exist).ChangeVariable_a_Donnee();
};
MiseAjourActif();
};
// changement du statut de donnée à variable pour un tableau d'enum de ddl
void Noeud::ChangeDonnee_a_Variable(const Tableau<Enum_ddl>& taben)
{ int tabenTaille = taben.Taille();
for (int i = 1; i<=tabenTaille; i++)
{int exist = Existe(taben(i));
if (exist)
tab_ddl(exist).ChangeVariable_a_Donnee();
};
MiseAjourActif();
};
// changement de toutes les conditions données (service, variable, fixage ..)
// selon le tableau de ddl passé en paramètre
// par contre la valeur n'est pas utilisé donc la valeur actuelle reste inchangé
void Noeud::ChangeToutesLesConditions(const Tableau<Ddl>& ta)
{ int taTaille = ta.Taille();
for (int i = 1; i<=taTaille; i++)
{int exist = Existe(ta(i).Id_nom());
if (exist)
tab_ddl(exist).CopieToutesLesConditions(ta(i).Retour_Fixe());
};
MiseAjourActif();
};
// changement de statu des ddl d'une combinaison, (cf. Enum_ddl)
// les ddl de la combinaison, prennent le même statut que celui
// actuellement stocké, correspondant à enuta
// cas est la combinaison,
void Noeud::ChangeStatut(int cas,Enum_ddl enuta)
{ // on récupère tous les membres de la combinaison
Tableau <Enum_ddl> tenu= Combinaison(cas);
int tenuTaille = tenu.Taille();
Enum_boolddl enubold=tab_ddl(Existe(enuta)).Retour_Fixe();
for (int i = 1; i<=tenuTaille; i++)
{int exist = Existe(tenu(i));
if (exist)
tab_ddl(exist).CopieToutesLesConditions(enubold);
};
MiseAjourActif();
};
// changement de statu des ddl d'une combinaison, (cf. Enum_ddl)
// les ddl de la combinaison, prennent le même statut que celui de enubold
// cas est la combinaison,
void Noeud::ChangeStatut(int cas,Enum_boolddl enubold)
{ // on récupère tous les membres de la combinaison
Tableau <Enum_ddl> tenu= Combinaison(cas);
int tenuTaille = tenu.Taille();
for (int i = 1; i<=tenuTaille; i++)
{int exist = Existe(tenu(i));
if (exist)
tab_ddl(exist).CopieToutesLesConditions(enubold);
};
MiseAjourActif();
};
/*// retourne le numero du ddl recherche identifie par en,
// s'il existe sinon 0
int Noeud::Existe(const Enum_ddl en)
{ int tab_ddl_Taille = tab_ddl.Taille();
// on commence par tester a partir de la derniere position sauvegardee
for (short int i=(short)(posiddl);i<= tab_ddl_Taille;i++)
if (en == tab_ddl(i).Id_nom())
{ posiddl=i; return i; }
// on continue la recherche a partir du debut
for (short int i=1;i< posiddl;i++)
if (en == tab_ddl(i).Id_nom())
{ posiddl=i; return i; }
// sinon retour 0
return 0;
}; */
// indique que l'on va utiliser les ddl en 0, t et tdt
// les grandeurs en tdt sont cree s'ils n'existent pas
// et initialisees par defaut
void Noeud::Travail_tdt()
{ if (tab_tdt.Taille() == 0)
tab_tdt.Change_taille(tab_ddl.Taille());
// les grandeurs à tdt peuvent changer des coordonnées vers
// autre chose, pour cela on commence par les supprimer, ensuite
// dans la procédure MiseAjour() elles sont recréées si besoin est
// a partir du tableau de tab_tdt
if (coord2 != NULL) delete coord2;
coord2 = NULL;
MiseAjour();
};
// indique que l'on va utiliser les ddl en 0, t
// si les grandeurs en tdt existaient, elles sont supprimées
void Noeud::Travail_t()
{ if (tab_tdt.Taille() != 0)
{ tab_tdt.Libere();
if (coord2 != NULL) delete coord2;
coord2 = NULL;
}
MiseAjour();
};
// mise a zero de tous les variables ddl actives
// sauf dans le cas de coordonnees entrainees. dans ce dernier
// cas les coordonnees correspondants a Xi pour t et t+dt
// sont mis a la valeur de celles de t=0
// a moins que le paramètre booléen est mis à false,
// dans ce cas les coordonnées à t sont inchangées
void Noeud::ZeroVariablesDdl(bool cas)
{ int nbactif = tab_var_actives.Taille();
for (int j=1; j<= nbactif; j++)
{int i = tab_var_actives(j);
if (((tab_ddl(i)).Nom())[0] != 'X')
{ tab_ddl(i).Valeur() = 0.;
tab_0(i) = 0.;
}
else // cas de coordonnees entrainees
if (cas)
tab_ddl(i).Valeur() = tab_0(i);
};
if (tab_tdt.Taille() != 0)
// cas de l'utilisation du tableau a tdt
for (int j1=1; j1<= nbactif; j1++)
{int ii = tab_var_actives(j1);
if (((tab_ddl(ii)).Nom())[0] != 'X')
tab_tdt(ii) = 0.;
else
tab_tdt(ii) = tab_0(ii);
};
};
// actualisation des ddl actifs (variable et donnee) de t+dt vers t
void Noeud::TdtversT()
{ int nbactif = tab_actif.Taille();
for (int j=1; j<= nbactif; j++)
{int i = tab_actif(j);
tab_ddl(i).Valeur() = tab_tdt(i);
};
// cas d'une base locale
if (baseB != NULL)
{(*baseB_t) = (*baseB);}
};
// actualisation des ddl actifs (variables et donnees) de t vers t+dt
void Noeud::TversTdt()
{ int nbactif = tab_actif.Taille();
for (int j=1; j<= nbactif; j++)
{int i = tab_actif(j);
tab_tdt(i)= tab_ddl(i).Valeur();
};
// cas d'une base locale
if (baseB != NULL)
{(*baseB) = (*baseB_t);}
};
// retourne dans le vecteur d'entrée les réels représentant les contraintes
// si les degrés de liberté contrainte existent
// sinon retourne false, en ne modifiant pas l'entrée
bool Noeud::Contrainte(Vecteur& Sig)
{ int position = Existe(SIG11);
int l_sigma; // dimension des contraintes
// test pour l'existence des ddl de sigma
if ( position != 0)
{ l_sigma = 1 ; // c'est au moins un tenseur d'ordre 1
if (Existe(SIG22) != 0)
{ l_sigma = 3 ; // c'est au moins un tenseur d'ordre 2
// donc trois coordonnées
if (Existe(SIG33) != 0)
l_sigma = 6 ; // c'est un tenseur d'ordre 3
// donc 6 coordonnées
};
if (Sig.Taille() != l_sigma) Sig.Change_taille(l_sigma);
int fin = position + l_sigma-1; int j = 1;
for (int i=position;i<= fin; i++,j++)
Sig(j) = tab_ddl(i).Valeur();
return true;
}
else
return false; // pas de contrainte
};
// retourne dans le tenseur d'entrée les réels représentant les contraintes
// si les degrés de liberté contrainte existent
// sinon retourne l'entrée sans modification
// le tenseur est choisit mixte pour représenter tous les cas
// !!! important : le tenseur Sig doit avoir la bonne dimension
// en entrée, car il n'est pas redimensionné dans la méthode
TenseurHB& Noeud::Contrainte(TenseurHB& Sig)
{ int position = Existe(SIG11);
if (position == 0) return Sig; // cas où il n'y a pas de contrainte
// ----- sinon on remplit les composantes du tenseur ------
int l_sigma = Sig.Dimension(); // dimension des contraintes
#ifdef MISE_AU_POINT // vérif des dimensions pour le debug
// comme position n'est pas nulle la dimension dans les ddl est au moins 1
int dimm = 1;
if (Existe(SIG22) != 0)
{ dimm = 2 ; // c'est au moins un tenseur d'ordre 2
if (Existe(SIG33) != 0)
dimm = 3 ; // c'est un tenseur d'ordre 3
};
if (l_sigma != dimm)
{ cout << "\nErreur : dimensions du tenseur d'entrée incorrecte Sig = " << dimm << " !\n";
cout << " Noeud::Contrainte(TenseurHB& Sig)\n";
Sortie(1);
};
#endif
switch (l_sigma)
{ case 1 : // cas à une dimension
Sig.Coor(1,1) = tab_ddl(position).Valeur();
break;
case 2 : // cas à 2 dimension
Sig.Coor(1,1) = tab_ddl(position).Valeur();
Sig.Coor(2,2) = tab_ddl(position+1).Valeur();
Sig.Coor(1,2) = tab_ddl(position+2).Valeur();
Sig.Coor(2,1) = tab_ddl(position+2).Valeur();
break;
case 3 : // cas à 3 dimension
Sig.Coor(1,1) = tab_ddl(position).Valeur();
Sig.Coor(2,2) = tab_ddl(position+1).Valeur();
Sig.Coor(3,3) = tab_ddl(position+2).Valeur();
Sig.Coor(1,2) = tab_ddl(position+3).Valeur();Sig.Coor(2,1) = Sig(1,2);
Sig.Coor(2,3) = tab_ddl(position+4).Valeur();Sig.Coor(3,2) = Sig(2,3);
Sig.Coor(1,3) = tab_ddl(position+5).Valeur();Sig.Coor(3,1) = Sig(1,3);
break;
default :
{ cout <<"\n Erreur, la dimension du tenseur Sig n'est pas correcte ";
cout << "Noeud::Contrainte(TenseurHB& Sig)" << endl;
Sortie (1);
}
};
return Sig;
};
// lecture sur le flot d'entée de déplacement
// et mise à jour des positions à t et t+dt correspondantes
void Noeud::LectureDeplacements(UtilLecture *entreePrinc)
{ // récup de la dimension
// définition du déplacement
Coordonnee dep = *coord0;
// lecture brut des coordonnées du déplacement sans la dimension
dep.Lecture(*entreePrinc);
// on ajoute aux coordonnées initiales pour avoir celles à t
dep += (*coord0);
// on insert les coordonnées à t qui sont créées si elles n'existent pas
// elles ont le statut inactif par défaut
Insert_coord1(dep);
};
//----- lecture écriture dans base info -----
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// ( ici on ne redimentionne pas,
// cela signifie que le nombre de ddl augmente mais ne diminue pas !!)
void Noeud::Lecture_base_info(istream& ent,int cas)
{ // traitement en fonction du cas
switch (cas)
{ case 1 : // ------- on récupère tout -------------------------
{ ent >> (*this) ;
break;
}
case 2 : // ----------- récup uniquement de se qui varie --------------------
{ // ici se sont les degrés de liberté
string toto;int nb;
ent >> toto >> nb;
#ifdef MISE_AU_POINT // vérification du numéro
if (nb != num_noeud )
{ cout << "\nErreur : numero de noeud lu : " << nb
<< " au lieu de " << num_noeud << " \n";;
cout << " Noeud::Lecture_base_info";
Sortie(1);
};
#endif
/* // ici on ne redimentionne pas,
/// // cela signifie que le nombre de ddl augmente mais ne diminue pas !
/// Tableau<Ddl > * pt_tableau = tab_ddl.New_en_lecture_si_taille_superieur_a_lire(ent);
/// // on regarde si le tableau a été redimensionné
/// if (pt_tableau != NULL)
/// // cas d'une redimension on ajoute les ddl
/// PlusTabDdl(*pt_tableau); */
// le code précédent pose des pb lorsque les ddl à lire sont différents de ceux existants
// donc systématiquement, on en crée des nouveaux et on met à jour
Tableau<Ddl > tableau;
tableau.Entree(ent);
// on ajoute les ddl
PlusTabDdl(tableau);
// on recopie les valeurs à t
int taille_tabddl=tab_ddl.Taille();
// en fait ce n'est pas la peine, ça a été fait dans PlusTabDdl !!
// cas de valeur à tdt
if (tab_tdt.Taille() != 0)
{for (int i=1;i<=taille_tabddl;i++)
tab_tdt(i) = tab_ddl(i).Valeur();
};
// cas d'une base locale éventuelle
{int existe_base;
ent >> existe_base >> toto;
if (existe_base == 1)
{if (baseB == NULL) {baseB=new BaseB();};
ent >> toto >> (*baseB);
// dans le cas où la grandeur à t n'existe pas
// on l'a crée et on lui donne la valeur de tdt
// sinon on fait une affectation, pour redémarrer avec quelque chose de correcte à t
if (baseB_t == NULL)
{baseB_t=new BaseB(*baseB);}
else // sinon on affecte
{(*baseB_t) = (*baseB);};
// cas à 0
if (baseB_0 == NULL)
{baseB_0=new BaseB(*baseB);};
// sinon on ne fait rien car la base est sensée avoir été correctement
// définit au départ
};
};
break;
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "Noeud::Ecriture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
}
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Noeud::Ecriture_base_info(ostream& sort,int cas)
{ // traitement en fonction du cas
switch (cas)
{ case 1 : // ------- on sauvegarde tout -------------------------
{ sort << (*this) << "\n";
break;
}
case 2 : // ----------- sauvegarde uniquement de se qui varie --------------------
{ // ici se sont les degrés de liberté
sort << "Noeud " << num_noeud << " ";
sort << tab_ddl ;
if (baseB != NULL)
{sort << " 1 baseLoc: " << (*baseB);}
else {sort << " 0 baseLoc: "; };
sort << "\n";
break;
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "Noeud::Ecriture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
};
// pour l'instant on ne sauvegarde pas les ddl_étendu et les type_quelconque car on considère
// que ce sont des résultats et non pas des données indispensables.
// idem pour enu_liaison et noeud_lier, qui sont liées aux conditions limites
// A priori, c'est infos sont reconstruites
// à chaque démarrage
};