rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

ajout des fichiers du répertoire Maillage

Browse source 
- concerne les conditions limites, les maillages, les ddl en tout genre
This commit is contained in:
Gérard Rio 2021-09-18 09:47:14 +02:00
parent 659bf52c18
commit 3a4e74e5d7
30 changed files with 38178 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

230
Maillage/BlocDdlLim.h Normal file
View file

@ -0,0 +1,230 @@
/*! \file BlocDdlLim.h
\brief def classe et fonctions template pour la lecture de ddl lim.
*/
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 28/03/2004 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Gestion de divers bloc courant du fichier de lecture . *
* Cas où ces blocs sont relatif aux conditions limites, *
* et héritent de bloc classiques. *
* par rapport au bloc, l'apport est la gestion d'un nom_de maillage*
* éventuellement en plus du nom de référence. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef BLOC_DDLLIM_T_H
#define BLOC_DDLLIM_T_H
#include "Bloc.h"
#include "ConstMath.h"
/// @addtogroup Les_classes_Ddl_en_tout_genre
/// @{
///
///
///
///================================================
/// cas d'un bloc template avec conditions limites
///================================================
template <class Bloc_particulier>
class BlocDdlLim : public Bloc_particulier
{
// surcharge de l'operator de lecture
friend istream & operator >> (istream & entree, BlocDdlLim<Bloc_particulier> & coo)
{ // lecture d'un nom de maillage éventuel
bool existe_nom_maillage; entree >> existe_nom_maillage;
if (existe_nom_maillage)
{ string nom; entree >> nom;
if (coo.nom_maillage == NULL)
coo.nom_maillage = new string(nom);
else
*(coo.nom_maillage) = nom;
};
// puis la classe mère
entree >> ((Bloc_particulier&)(coo));
return entree;
}
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort, const BlocDdlLim<Bloc_particulier> & coo)
{ // tout d'abord le maillage éventuelle
if (coo.nom_maillage == NULL)
sort << false << " ";
else
sort << true << " " << *(coo.nom_maillage) << " ";
// puis la classe mère
sort << ((const Bloc_particulier&)(coo));
return sort;
}
public :
// VARIABLES PUBLIQUES :
// stockage d'un element
// class conforme a la specif de T de la class LectBloc_T
// Constructeur
BlocDdlLim () : // par defaut
nom_maillage(NULL),Bloc_particulier()
{};
// fonction d'une instance de Bloc_particulier
BlocDdlLim (const Bloc_particulier& a) : Bloc_particulier(a),nom_maillage(NULL) {};
// fonction d'une instance et d'un string
BlocDdlLim (const string& nom_mail,const Bloc_particulier& a) :
Bloc_particulier(a),nom_maillage(new string (nom_mail)) {};
// fonction d'une instance et d'un pointeur de string
BlocDdlLim (const string* nom_mail,const Bloc_particulier& a) :
Bloc_particulier(a),nom_maillage(NULL)
{ if (nom_mail != NULL) nom_maillage = new string (*nom_mail);};
// de copie
BlocDdlLim (const BlocDdlLim& a) :
nom_maillage(NULL),Bloc_particulier(a)
{if (a.nom_maillage != NULL) nom_maillage = new string (*(a.nom_maillage));};
// destructeur
~BlocDdlLim () {if (nom_maillage != NULL) delete nom_maillage;};
// retourne un pointeur de string donnant le nom du maillage associé
// = NULL si aucun maillage
const string* NomMaillage() const {return nom_maillage;};
// change le nom de maillage
// ATTENTION : Les modifications liees au changement du nom de maillage
// sont a la charge de l'utilisateur.
// le nouveau nom ne doit pas être vide !! sinon erreur
void Change_nom_maillage(const string& nouveau);
// lecture d'un bloc
void Lecture(UtilLecture & entreePrinc);
// affichage des informations
void Affiche() const ;
// surcharge des operateurs
bool operator == ( const BlocDdlLim& a) const;
BlocDdlLim& operator = (const BlocDdlLim& a);
bool operator != ( const BlocDdlLim& a) const { return !(*this == a);};
protected :
string* nom_maillage; // nom d'un maillage
};
/// @} // end of group
/// lecture d'un bloc
template <class Bloc_particulier>
void BlocDdlLim<Bloc_particulier>::Lecture(UtilLecture & entreePrinc)
{ // on regarde tout d'abord si il y a un nom de maillage, qui doit être le premier nom
string nom;
if (strstr(entreePrinc.tablcar,"nom_mail=")!=NULL)
{ // cas où il y a un nom de maillage
*(entreePrinc.entree) >> nom >> nom; // lecture du mot_clé et du nom
if (nom_maillage == NULL) { nom_maillage = new string(nom);}
else { *nom_maillage = nom;};
}
// puis lecture de la classe mère
Bloc_particulier::Lecture(entreePrinc);
}
/// affichage des infos
template <class Bloc_particulier>
void BlocDdlLim<Bloc_particulier>::Affiche() const
{ // affichage éventuelle du nom de maillage
if (nom_maillage != NULL)
{ cout << "\n nom_mail= " << *nom_maillage;} else cout << "\n";
// puis affichage des infos de la classe mère
Bloc_particulier::Affiche();
}
/// surcharge de l'operateur ==
template <class Bloc_particulier>
bool BlocDdlLim<Bloc_particulier>::operator == ( const BlocDdlLim<Bloc_particulier>& a) const
{ if (nom_maillage == NULL)
{ if (a.nom_maillage != NULL) return false;
}
else
{ if (a.nom_maillage == NULL) return false;
// sinon les deux sont non null: on test leur égalité
if (*nom_maillage != *(a.nom_maillage)) return false;
};
// puis la classe mère
if (((Bloc_particulier&)(*this)).operator==(a))
return true;
else
{ return false; };
}
/// surcharge de l'operateur =
template <class Bloc_particulier>
BlocDdlLim<Bloc_particulier>& BlocDdlLim<Bloc_particulier>::operator
= ( const BlocDdlLim<Bloc_particulier>& a)
{ if (a.nom_maillage == NULL)
{ if (nom_maillage != NULL) {delete nom_maillage;nom_maillage=NULL;}}
else
{ if (nom_maillage == NULL) nom_maillage = new string(*(a.nom_maillage));
else *nom_maillage = *(a.nom_maillage);
};
// puis la classe mère
((Bloc_particulier&)(*this)).operator=(a);
return *this;
}
/// change le nom de maillage
/// ATTENTION : Les modifications liees au changement du nom de maillage
/// sont a la charge de l'utilisateur.
/// le nouveau nom ne doit pas être vide !! sinon erreur
template <class Bloc_particulier>
void BlocDdlLim<Bloc_particulier>::Change_nom_maillage(const string& nouveau)
{ if (nouveau.length() == 0)
{ cout << "\nErreur : reference de nom de maillage non valide car de longueur nulle ! "
<< " nom_mail= " << nouveau << "\n";
cout << "BlocDdlLim<Bloc_particulier>::Change_nom_maillage(....) \n";
Sortie(1);
}
if (nom_maillage == NULL)
{ nom_maillage = new string(nouveau);}
else
{ *nom_maillage = nouveau;};
}
#endif

514
Maillage/Ddl.cc Normal file
View file

@ -0,0 +1,514 @@
// FICHIER : Ddl.cp
// CLASSE : Ddl
// 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-2021 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 "Ddl.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
#ifndef Ddl_deja_inclus
#ifndef MISE_AU_POINT
inline
#endif
Ddl::Ddl (Enum_ddl id_nom_ddl,double val,Enum_boolddl val_fixe) :
id_nom(id_nom_ddl),val_ddl(val),fixe(val_fixe)
// Constructeur utile quand l'identificateur de nom du degre de
// liberte sont connus
// ( N.B. : Tous les parametres de ce constructeur ont des valeurs par defaut.
// Ce constructeur peut donc servir de constructeur par defaut. )
{};
#ifndef MISE_AU_POINT
inline
#endif
Ddl::Ddl (char* nom,double val,Enum_boolddl val_fixe) :
val_ddl(val),fixe(val_fixe)
// Constructeur utile quand le nom et la valeur du degre de liberte sont
// connus
// ( N.B. : val et val_fixe ont des valeurs par defaut, il n'est par consequent
// pas obligatoire de leur donner des valeurs a l'appel de ce constructeur )
{ id_nom=Id_nom_ddl(nom);
};
#ifndef MISE_AU_POINT
inline
#endif
Ddl::Ddl (const Ddl& d)
// Constructeur de copie
{ id_nom=d.id_nom;
val_ddl=d.val_ddl;
fixe=d.fixe;
};
#ifndef MISE_AU_POINT
inline
#endif
Ddl::~Ddl ()
// Destructeur
{ };
#ifndef MISE_AU_POINT
inline
#endif
// Retourne 1 si le degre de liberte a une valeur fixée tout au long du calcul
// Retourne 0 sinon
// ne concerne que les variables (par exemple ne concerne pas les données)
bool Ddl::Fixe() const
{switch (fixe)
{ case FIXE : case SURFIXE: case LISIBLE_FIXE: case LISIBLE_SURFIXE:
case HS_LISIBLE_FIXE: case HS_SURFIXE: case HS_LISIBLE_SURFIXE:
case HSFIXE: return true;break;
case LIBRE : case SOUSLIBRE: case LISIBLE_LIBRE: case LISIBLE_SOUSLIBRE:
case HS_LISIBLE_LIBRE: case HS_SOUSLIBRE: case HS_LISIBLE_SOUSLIBRE:
case HSLIBRE: return false;break;
default :
#ifdef MISE_AU_POINT
cout << "\nErreur : valeur incorrecte du type ddl !\n";
cout << "Ddl.Fixe(): val= " << fixe;
Sortie(1);
#endif
break;
}
// la ligne suivante ne sert pas mais c'est pour ne pas avoir de Warning
return false ;
};
#ifndef MISE_AU_POINT
inline
#endif
// test pour savoir si le ddl est une variable ou une donnée
bool Ddl::UneVariable() const
{ switch (fixe)
{ case LIBRE: case FIXE : case SOUSLIBRE: case SURFIXE:
case HSLIBRE: case HSFIXE: case HS_SOUSLIBRE: case HS_SURFIXE:
return true; break;
case LISIBLE_LIBRE: case LISIBLE_FIXE :
case LISIBLE_SOUSLIBRE: case LISIBLE_SURFIXE:
case HS_LISIBLE_LIBRE: case HS_LISIBLE_FIXE:
case HS_LISIBLE_SOUSLIBRE: case HS_LISIBLE_SURFIXE:
return false;break;
default :
cout << "\nErreur : degre de liberte non defini !\n";
cout << "\n UneVariable() " << fixe;
Sortie(1);
};
// la ligne suivante ne sert pas mais c'est pour ne pas avoir de Warning
return false ;
};
#ifndef MISE_AU_POINT
inline
#endif
// changement du statut de variable à donnée
void Ddl::ChangeVariable_a_Donnee()
{ switch (fixe)
{ case LIBRE: fixe = LISIBLE_LIBRE; break;
case FIXE : fixe = LISIBLE_FIXE; break;
case SOUSLIBRE: fixe = LISIBLE_SOUSLIBRE; break;
case SURFIXE: fixe = LISIBLE_SURFIXE; break;
case HSLIBRE: fixe = HS_LISIBLE_LIBRE; break;
case HSFIXE: fixe = HS_LISIBLE_FIXE; break;
case HS_SOUSLIBRE: fixe = HS_LISIBLE_SOUSLIBRE; break;
case HS_SURFIXE: fixe = HS_LISIBLE_SURFIXE; break;
// cas déjà une variable on ne fait rien
case LISIBLE_LIBRE: case LISIBLE_FIXE :
case LISIBLE_SOUSLIBRE: case LISIBLE_SURFIXE:
case HS_LISIBLE_LIBRE: case HS_LISIBLE_FIXE:
case HS_LISIBLE_SOUSLIBRE: case HS_LISIBLE_SURFIXE: break;
default :
cout << "\nErreur : degre de liberte non defini !\n";
cout << "\n Ddl::ChangeVariable_a_Donnee() " << fixe;
Sortie(1);
}
};
#ifndef MISE_AU_POINT
inline
#endif
// changement du statut de donnée à variable
void Ddl::ChangeDonnee_a_Variable()
{ switch (fixe)
{ case LISIBLE_LIBRE : fixe = LIBRE; break;
case LISIBLE_FIXE : fixe = FIXE; break;
case LISIBLE_SOUSLIBRE : fixe = SOUSLIBRE; break;
case LISIBLE_SURFIXE : fixe = SURFIXE; break;
case HS_LISIBLE_LIBRE : fixe = HSLIBRE; break;
case HS_LISIBLE_FIXE : fixe = HSFIXE; break;
case HS_LISIBLE_SOUSLIBRE: fixe = HS_SOUSLIBRE; break;
case HS_LISIBLE_SURFIXE: fixe = HS_SURFIXE; break;
// cas déjà une variable on ne fait rien
case LIBRE: case FIXE : case SOUSLIBRE: case SURFIXE:
case HSLIBRE: case HSFIXE:
case HS_SOUSLIBRE: case HS_SURFIXE: break;
default :
cout << "\nErreur : degre de liberte non defini !\n";
cout << "\n ChangeDonnee_a_Variable() " << fixe;
Sortie(1);
}
};
#ifndef MISE_AU_POINT
inline
#endif
// Modifie la valeur de fixe, si val est vrai -> blocage , sinon libre
void Ddl::Change_fixe(bool val)
{ if (val)
{switch (fixe) // cas ou on veut fixer
{ case SOUSLIBRE : fixe = LIBRE ;break;
case LIBRE : fixe = FIXE ;break;
case FIXE : fixe = SURFIXE ;break;
case HSLIBRE : fixe = HSFIXE;break;
case LISIBLE_SOUSLIBRE : fixe = LISIBLE_LIBRE;break;
case LISIBLE_LIBRE : fixe = LISIBLE_FIXE;break;
case LISIBLE_FIXE : fixe = LISIBLE_SURFIXE;break;
case HS_LISIBLE_LIBRE : fixe = HS_LISIBLE_FIXE;break;
case HS_SOUSLIBRE : fixe = HSLIBRE;break;
case HS_LISIBLE_SOUSLIBRE : fixe = HS_LISIBLE_LIBRE;break;
case HSFIXE : fixe = HS_SURFIXE;break;
case HS_LISIBLE_FIXE : fixe = HS_LISIBLE_SURFIXE;break;
// pour tous les surfixes, on ne fait rien
case SURFIXE: case LISIBLE_SURFIXE: case HS_SURFIXE: case HS_LISIBLE_SURFIXE:
break;
default :
cout << "\nErreur : degre de liberte non defini !\n";
cout << "\n Ddl::Change_fixe(.. " << fixe;
Sortie(1);
};
}
else
{ switch (fixe) // cas ou on veut rendre libre
{ case SURFIXE : fixe = FIXE ;break;
case FIXE : fixe = LIBRE ;break;
case LIBRE : fixe = SOUSLIBRE ;break;
case HSFIXE : fixe = HSLIBRE;break;
case LISIBLE_SURFIXE : fixe = LISIBLE_FIXE;break;
case LISIBLE_FIXE : fixe = LISIBLE_LIBRE;break;
case LISIBLE_LIBRE : fixe = LISIBLE_SOUSLIBRE;break;
case HS_LISIBLE_FIXE : fixe = HS_LISIBLE_LIBRE;break;
case HS_SURFIXE : fixe = HSFIXE;break;
case HS_LISIBLE_SURFIXE : fixe = HS_LISIBLE_FIXE;break;
case HSLIBRE : fixe = HS_SOUSLIBRE;break;
case HS_LISIBLE_LIBRE : fixe = HS_LISIBLE_SOUSLIBRE;break;
// pour tous les sous libre on ne fait rien
case SOUSLIBRE: case LISIBLE_SOUSLIBRE: case HS_SOUSLIBRE:
case HS_LISIBLE_SOUSLIBRE: break;
default :
cout << "\nErreur : degre de liberte non defini !\n";
cout << "\n Ddl::Change_fixe(.. " << fixe;
Sortie(1);
};
}
};
#ifndef MISE_AU_POINT
inline
#endif
// test si le ddl est SOUSLIBRE ou SURFIXE, ramène true si oui
bool Ddl::SousSurFixe() const
{ switch (fixe)
{ case SOUSLIBRE : case SURFIXE : case LISIBLE_SOUSLIBRE :
case LISIBLE_SURFIXE : case HS_SOUSLIBRE : case HS_SURFIXE :
case HS_LISIBLE_SOUSLIBRE : case HS_LISIBLE_SURFIXE :
return true; break;
// pour les autres retour false
case LIBRE : case FIXE : case HSLIBRE : case HSFIXE : case LISIBLE_LIBRE :
case LISIBLE_FIXE : case HS_LISIBLE_LIBRE : case HS_LISIBLE_FIXE:
return false; break;
default :
cout << "\nErreur : degre de liberte non defini !\n";
cout << "\n Ddl::SousSurFixe(.. " << fixe;
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// remise à normal si le ddl est en souslibre ou surfixe
// s'il est en souslibre il passe en libre et s'il est en surfixe il passe en fixe
// sinon on ne fait rien
void Ddl::Retour_normal_sur_ou_sous_fixe()
{switch (fixe) // cas ou on veut rendre libre
{ case SURFIXE : fixe = FIXE ;break;
case LISIBLE_SURFIXE : fixe = LISIBLE_FIXE ;break;
case HS_SURFIXE: fixe = HSFIXE;break;
case HS_LISIBLE_SURFIXE: fixe = HS_LISIBLE_FIXE;break;
case SOUSLIBRE : fixe = LIBRE ;break;
case LISIBLE_SOUSLIBRE : fixe = LISIBLE_LIBRE;break;
case HS_SOUSLIBRE : fixe = HSLIBRE;break;
case HS_LISIBLE_SOUSLIBRE: fixe = HS_LISIBLE_LIBRE;break;
// pour les autres on ne fait rien
case LIBRE : case FIXE : case HSLIBRE : case HSFIXE :
case LISIBLE_LIBRE : case LISIBLE_FIXE : case HS_LISIBLE_LIBRE:
case HS_LISIBLE_FIXE : break;
default :
cout << "\nErreur : degre de liberte non defini !\n";
cout << "\n Ddl::Retour_normal_sur_ou_sous_fixe(.. " << fixe;
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
void Ddl::Met_hors_service()
// met hors_service le ddl, cela signifie que momentanément il ne sert plus
{ switch (fixe) // cas ou on veut rendre libre
{ case LIBRE : fixe = HSLIBRE ;break;
case SOUSLIBRE : fixe = HS_SOUSLIBRE ;break;
case FIXE : fixe = HSFIXE ;break;
case SURFIXE : fixe = HS_SURFIXE ;break;
case LISIBLE_LIBRE : fixe = HS_LISIBLE_LIBRE ;break;
case LISIBLE_SOUSLIBRE : fixe = HS_LISIBLE_SOUSLIBRE ;break;
case LISIBLE_FIXE : fixe = HS_LISIBLE_FIXE;break;
case LISIBLE_SURFIXE : fixe = HS_LISIBLE_SURFIXE;break;
case HSLIBRE: case HSFIXE: case HS_LISIBLE_LIBRE: case HS_LISIBLE_FIXE:
case HS_SOUSLIBRE : case HS_SURFIXE : case HS_LISIBLE_SOUSLIBRE : case HS_LISIBLE_SURFIXE :
break; // cas déjà HS
default:
cout << "\n erreur cas non prevu pour le ddl "; this->Affiche();
cout << "\n Ddl::Met_hors_service() ";
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// met en service le ddl
void Ddl::Met_en_service()
{ switch (fixe) // cas ou on veut rendre libre
{ case HSLIBRE : fixe = LIBRE ;break;
case HSFIXE : fixe = FIXE ;break;
case HS_LISIBLE_LIBRE : fixe = LISIBLE_LIBRE ;break;
case HS_LISIBLE_FIXE : fixe = LISIBLE_FIXE;break;
case HS_SOUSLIBRE : fixe = SOUSLIBRE;break;
case HS_SURFIXE : fixe = SURFIXE;break;
case HS_LISIBLE_SOUSLIBRE : fixe = LISIBLE_SOUSLIBRE;break;
case HS_LISIBLE_SURFIXE :fixe = LISIBLE_SURFIXE;break;
case LIBRE: case FIXE: case SOUSLIBRE: case SURFIXE:
case LISIBLE_LIBRE: case LISIBLE_FIXE:
case LISIBLE_SOUSLIBRE: case LISIBLE_SURFIXE:
break; // cas déjà OK
default:
cout << "\n erreur cas non prevu pour le ddl "; this->Affiche();
cout << "\n Ddl::Met_hors_service() ";
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
void Ddl::Met_hors_service_ddl()
// met hors_service le ddl, cela signifie que momentanément il ne sert plus
// ne concerne pas les données
{ switch (fixe) // cas ou on veut rendre libre
{ case LIBRE : fixe = HSLIBRE ;break;
case SOUSLIBRE : fixe = HS_SOUSLIBRE ;break;
case FIXE : fixe = HSFIXE ;break;
case SURFIXE : fixe = HS_SURFIXE ;break;
// --- cas déjà HS on ne change rien
case HSLIBRE: case HSFIXE: case HS_LISIBLE_LIBRE: case HS_LISIBLE_FIXE:
case HS_SOUSLIBRE : case HS_SURFIXE : case HS_LISIBLE_SOUSLIBRE : case HS_LISIBLE_SURFIXE :
break; // cas déjà HS
// --- cas des données, on ne fait rien
case LISIBLE_LIBRE : case LISIBLE_SOUSLIBRE :
case LISIBLE_FIXE : case LISIBLE_SURFIXE :
break; // pour les données, on ne change rien
default:
cout << "\n erreur cas non prevu pour le ddl "; this->Affiche();
cout << "\n Ddl::Met_hors_service_ddl() ";
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// met en service le ddl, ne concerne pas les données
void Ddl::Met_en_service_ddl()
{ switch (fixe) // cas ou on veut rendre libre
{ case HSLIBRE : fixe = LIBRE ;break;
case HSFIXE : fixe = FIXE ;break;
case HS_SOUSLIBRE : fixe = SOUSLIBRE;break;
case HS_SURFIXE : fixe = SURFIXE;break;
// --- déjà libre, on ne change rien
case LIBRE: case FIXE: case SOUSLIBRE: case SURFIXE:
case LISIBLE_LIBRE: case LISIBLE_FIXE:
case LISIBLE_SOUSLIBRE: case LISIBLE_SURFIXE:
break; // cas déjà OK
// --- on n'intervient pas sur les données
case HS_LISIBLE_SOUSLIBRE : case HS_LISIBLE_SURFIXE :
case HS_LISIBLE_LIBRE : case HS_LISIBLE_FIXE :
break;
default:
cout << "\n erreur cas non prevu pour le ddl "; this->Affiche();
cout << "\n Ddl::Met_en_service_ddl() ";
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// surcharge de l'operateur d'ecriture
ostream & operator << (ostream & sort,const Ddl & a)
{ // écriture du type
sort << "Ddl ";
// les données
sort << a.id_nom << " " << a.fixe << " " ;
sort << setprecision(ParaGlob::NbdigdoCA()) << a.val_ddl << " ";
return sort;
};
#ifndef MISE_AU_POINT
inline
#endif
// surcharge de l'operator de lecture
istream & operator >> (istream & entree, Ddl& a)
{ // vérification du type
string type;
entree >> type;
if (type != "Ddl")
{Sortie (1);
return entree;
}
// entrée des données
entree >> a.id_nom;
entree >> a.fixe;
entree >> a.val_ddl;
return entree;
};
#ifndef MISE_AU_POINT
inline
#endif
// Affiche les donnees liees au degre de liberte
void Ddl::Affiche () const
{
cout << " " << Nom_ddl(id_nom) ;
cout << " = " << val_ddl ;
switch (fixe)
{ case LIBRE : cout << " val_libre, "; break;
case FIXE : cout << " val_fixe, "; break;
case SOUSLIBRE : cout << " val_sous_libre, "; break;
case SURFIXE : cout << " val_sur_fixe, "; break;
case LISIBLE_LIBRE : cout << " lisible_libre, "; break;
case LISIBLE_FIXE : cout << " lisible_fixe, "; break;
case LISIBLE_SOUSLIBRE : cout << " lisible_sous_libre, "; break;
case LISIBLE_SURFIXE : cout << " lisible_sur_fixe, "; break;
// pour les autres ils sont hors services
case HSLIBRE :
case HSFIXE :
case HS_LISIBLE_LIBRE :
case HS_LISIBLE_FIXE :
case HS_SOUSLIBRE :
case HS_SURFIXE :
case HS_LISIBLE_SOUSLIBRE :
case HS_LISIBLE_SURFIXE :
cout << " hors service, "; break;
/*
case LIBRE : result="LIBRE"; break;
case FIXE : result="FIXE"; break;
case HSLIBRE : result="HSLIBRE"; break;
case HSFIXE : result="HSFIXE"; break;
case SOUSLIBRE : result="SOUSLIBRE"; break;
case SURFIXE : result="SURFIXE"; break;
case LISIBLE_LIBRE : result="LISIBLE_LIBRE"; break;
case LISIBLE_FIXE : result="LISIBLE_FIXE"; break;
case LISIBLE_SOUSLIBRE : result="LISIBLE_SOUSLIBRE"; break;
case LISIBLE_SURFIXE : result="LISIBLE_SURFIXE"; break;
case HS_LISIBLE_LIBRE : result="HS_LISIBLE_LIBRE"; break;
case HS_LISIBLE_FIXE : result="HS_LISIBLE_FIXE"; break;
case HS_SOUSLIBRE : result="HS_SOUSLIBRE"; break;
case HS_SURFIXE : result="HS_SURFIXE"; break;
case HS_LISIBLE_SOUSLIBRE : result="HS_LISIBLE_SOUSLIBRE"; break;
case HS_LISIBLE_SURFIXE : result="HS_LISIBLE_SURFIXE"; break;
*/
default:
cout << "\n erreur cas non prevu pour le ddl "; this->Affiche();
cout << "\n Ddl::Affiche(.. ";
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
//Surcharge d'operateur logique
bool Ddl::operator == (const Ddl& a) const
{ if ( (id_nom==a.id_nom)
&& (val_ddl == a.val_ddl) && (fixe == a.fixe))
return true;
else return false;
};
#ifndef MISE_AU_POINT
inline
#endif
bool Ddl::operator != (const Ddl& a) const
{ return !(*this == a);};
#ifndef MISE_AU_POINT
inline
#endif
// test si le degre de liberte est complet
// = 1 tout est ok, =0 element incomplet
int Ddl::TestComplet() const
{ if (id_nom == NU_DDL)
{ cout << "\n pb !! ddl non defini ";
return false;
}
return true;
};
#endif // fin de l'inclusion totale

279
Maillage/Ddl.h Normal file
View file

@ -0,0 +1,279 @@
// FICHIER : Ddl.h
// CLASSE : Ddl
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* La classe Ddl permet de declarer des degres de liberte.
* soit c'est une variable ou soit c'est une données qui peuvent être soit active
* soit hors-service
* ensuite soit il est fixe ou soit il est bloqué
* 1) libre, fixe, ou 2) hors service libre ou hors service fixe ===> une variable
* 3) lisible libre ou fixe ou 4) hors service libre ou fixe ===> une donnée
* 1) c'est pour les ddl qui sont des variables que le calcul va déterminer,
* 2) sont les variables qui sont hors service: on ne les considères pas
* 3) sont des variables que l'on peut utiliser mais que le calcul ne
* cherche pas à déterminer: elle sont en lecture seule en quelque sorte
* 4) se sont des données qui ne sont pas dispon pour la consultation (par exemple hors temps)
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
// La classe Ddl permet de declarer des degres de liberte.
// soit c'est une variable ou soit c'est une données qui peuvent être soit active
// soit hors-service
// ensuite soit il est fixe ou soit il est bloqué
// 1) libre, fixe, ou 2) hors service libre ou hors service fixe ===> une variable
// 3) lisible libre ou fixe ou 4) hors service libre ou fixe ===> une donnée
// 1) c'est pour les ddl qui sont des variables que le calcul va déterminer,
// 2) sont les variables qui sont hors service: on ne les considères pas
// 3) sont des variables que l'on peut utiliser mais que le calcul ne
// cherche pas à déterminer: elle sont en lecture seule en quelque sorte
// 4) se sont des données qui ne sont pas dispon pour la consultation (par exemple hors temps)
#ifndef DDL_H
#define DDL_H
#include "Enum_ddl.h"
#include "Enum_boolddl.h"
#include <iostream>
#include <stdlib.h>
#include "Sortie.h"
#include <string>
// #include <bool.h>
/** @defgroup Les_classes_Ddl_en_tout_genre
*
* BUT:def de classes relatives aux ddl en tout genre
* Ddl, Ddl_etendu, DdlElement, DdlLim etc.
*
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
* \brief Def de classes relatives aux ddl en tout genre
*
*/
/// @addtogroup Les_classes_Ddl_en_tout_genre
/// @{
///
/// BUT: La classe Ddl permet de declarer des degres de liberte.
/// soit c'est une variable ou soit c'est une données qui peuvent être soit active
/// soit hors-service
/// ensuite soit il est fixe ou soit il est bloqué
/// 1) libre, fixe, ou 2) hors service libre ou hors service fixe ===> une variable
/// 3) lisible libre ou fixe ou 4) hors service libre ou fixe ===> une donnée
/// 1) c'est pour les ddl qui sont des variables que le calcul va déterminer,
/// 2) sont les variables qui sont hors service: on ne les considères pas
/// 3) sont des variables que l'on peut utiliser mais que le calcul ne
/// cherche pas à déterminer: elle sont en lecture seule en quelque sorte
/// 4) se sont des données qui ne sont pas dispon pour la consultation (par exemple hors temps)
///
/// \author Gérard Rio
/// \version 1.0
/// \date 23/01/97
///
///
class Ddl
{
// surcharge de l'operator de lecture
friend istream & operator >> (istream & entree, Ddl& a);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort, const Ddl& a);
public:
// CONSTRUCTEURS :
// Constructeur eventuellement par defaut
Ddl (Enum_ddl id_nom_ddl=NU_DDL,double val=0.0,Enum_boolddl val_fixe=HS_LISIBLE_LIBRE);
// Constructeur se servant d'un nom
// ( N.B. : val et val_fixe ont des valeurs par defaut, il n'est par consequent
// pas obligatoire de leur donner des valeurs a l'appel de ce constructeur )
Ddl (char* nom,double val=0.0,Enum_boolddl val_fixe=HS_LISIBLE_LIBRE);
// Constructeur de copie
Ddl (const Ddl& d);
// DESTRUCTEUR :
~Ddl ();
// METHODES :
// Retourne 1 si le degre de liberte a une valeur fixée tout au long du calcul
// Retourne 0 sinon
// ne concerne que les variables (par exemple ne concerne pas les données)
bool Fixe() const;
// test pour savoir si le ddl est une variable ou une donnée
bool UneVariable() const;
// changement du statut de variable à donnée
void ChangeVariable_a_Donnee();
// changement du statut de donnée à variable
void ChangeDonnee_a_Variable();
// Retourne la valeur de fixe en lecture uniquement
inline const Enum_boolddl Retour_Fixe() const { return fixe ; };
// Modifie la valeur de fixe, si val est vrai -> blocage , sinon libre
void Change_fixe(bool val);
// modifie toute les conditions sauf la valeur: c-a-d:
// le fixage, le fait que c'est une variable ou une donnée, le fait
// d'être en service ou non etc..
void CopieToutesLesConditions( Enum_boolddl en) {fixe = en;};
// test pour savoir si le ddl est en service ou pas
inline bool Service() const
{ return (!(Est_HS(fixe)));};
// test si le ddl est SOUSLIBRE ou SURFIXE, ramène true si oui
bool SousSurFixe() const;
// remise à normal si le ddl est en souslibre ou surfixe
// s'il est en souslibre il passe en libre et s'il est en surfixe il passe en fixe
// sinon on ne fait rien
void Retour_normal_sur_ou_sous_fixe();
// met hors_service le ddl ou la donnée, cela signifie que momentanément il ne sert plus
void Met_hors_service();
// met en service le ddl ou la donnée
void Met_en_service();
// met hors_service le ddl, cela signifie que momentanément il ne sert plus
// ne concerne pas les données
void Met_hors_service_ddl();
// met en service le ddl, ne concerne pas les données
void Met_en_service_ddl();
// Retourne la valeur associee au degre de liberte
inline double& Valeur() { return val_ddl; };
// Retourne le nom associe au degre de liberte
inline const string Nom() const { return Nom_ddl(id_nom); };
// Retourne la variable de type enumere associee au nom du degre de liberte
inline Enum_ddl Id_nom() const { return id_nom; };
// Remplace le nom du degre de liberte par nouveau_nom
// (par l'intermediaire du type enumere associe)
// ATTENTION : Les modifications liees au changement de nom du degre
// de liberte sont a la charge de l'utilisateur.
inline void Change_nom(char* nouveau_nom)
{ id_nom=Id_nom_ddl(nouveau_nom); };
// Remplace l'identificateur de nom du degre de liberte par
// nouveau_id
// ATTENTION : Les modifications liees au changement de nom du degre
// de liberte sont a la charge de l'utilisateur.
inline void Change_nom(Enum_ddl nouveau_id)
{ id_nom=nouveau_id; };
// Affiche les donnees liees au degre de liberte
void Affiche() const ;
inline Ddl& operator= (const Ddl& d)
// Realise l'egalite entre deux degres de liberte
{ id_nom=d.id_nom;
val_ddl=d.val_ddl;
fixe=d.fixe;
return (*this);
};
//Surcharge d'operateur logique
bool operator == ( const Ddl& a) const ;
bool operator != ( const Ddl& a) const;
// test si le degre de liberte est complet
// = 1 tout est ok, =0 element incomplet
int TestComplet() const;
protected :
Enum_ddl id_nom; // identificateur du nom
// bool fixe; // booleen pour savoir si la valeur associee au
// degre de liberte est fixe pendant tout le calcul
Enum_boolddl fixe; // 1) libre, fixe, ou 2) hors service libre ou hors service fixe
// ou 3) lisible libre ou fixe
// cf. l'énuméré
double val_ddl; // valeur associee
};
/// @} // end of group
// pour faire de l'inline
#ifndef MISE_AU_POINT
#include "Ddl.cc"
#define Ddl_deja_inclus
#endif
#endif

329
Maillage/DdlElement.cc Normal file
View file

@ -0,0 +1,329 @@
// 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-2021 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 "DdlElement.h"
// CONSTRUCTEURS :
// par defaut
DdlElement::DdlElement () :
te(),nbddl(0),tab_enum_famille() {};
// definition du tableau pour n noeuds vide
DdlElement::DdlElement (int n) :
te(n),nbddl(0),tab_enum_famille()
{ };
// definition du tableau pour n noeuds et m ddl par noeud
// utile lorsque tous les noeuds ont le meme nombre de ddl
// par contre ici aucun ddl n'est encore défini
DdlElement::DdlElement (int n, int m) :
te(n),nbddl(n*m),tab_enum_famille()
{ for (int i=1; i<= n;i++)
{ Tableau <Enum_ddl>& tb=te(i).tb;
tb.Change_taille (m);
for (int j=1;j<=m;j++)
tb(j)=NU_DDL;
};
// def du nombre des types particuliers de ddl, ici il s'agit de NU_DDL
Calcul_NbDdl_typer();
};
// definition du tableau pour n noeuds et un nombre de ddl par noeud
// stocke dans le tableau mddl qui doit avoir la dimension n
// par contre ici aucun ddl n'est encore défini
DdlElement::DdlElement (int n,const Tableau <int>& mddl) :
te(n),tab_enum_famille()
{ if (mddl.Taille() == n)
for (int i=1; i<= n;i++)
{ Tableau <Enum_ddl>& tb=te(i).tb;
int m = mddl(i);
tb.Change_taille (m);
for (int j=1;j<=m;j++)
tb(j)=NU_DDL;
}
else
{ cout << "\n erreur de dimension pour le tableau mddl, il doit avoir la ";
cout << " dimension : " << n << ", alors qu\'il a la dimension : "
<< mddl.Taille() << "\nDdlElement (int n, Tableau <int> mddl)" << endl;
Sortie (1);
}
// def du nombre total et des types particuliers de ddl
Calcul_NbDdl(); Calcul_NbDdl_typer();
};
// definition du tableau pour n noeuds et une meme liste de ddl pour chaque
// noeud identique au second argument
DdlElement::DdlElement (int n, DdlNoeudElement d) :
te(n,d),nbddl(n * d.tb.Taille()),tab_enum_famille()
{ // def du nombre total et des types particuliers de ddl
Calcul_NbDdl(); Calcul_NbDdl_typer();
};
DdlElement::DdlElement (const DdlElement& a) :
te(a.te),nbddl(a.nbddl),tab_enum_famille(a.tab_enum_famille)
{}; // de copie
// DESTRUCTEUR :
DdlElement::~DdlElement () {};
// acces en modification au ddl j du noeud i
void DdlElement::Change_Enum(int i,int j,const Enum_ddl enu)
{tab_enum_famille[PremierDdlFamille((te(i)).tb(j))]--;
(te(i)).tb(j) = enu;
tab_enum_famille[PremierDdlFamille(enu)]++;
};
// nombre de ddl du noeudElement i contenu
int DdlElement::NbDdl(int i) const
{ return (te(i)).tb.Taille();};
// change la dimension du tableau de ddl pour n noeuds et m ddl par noeud
//dans le cas ou tous les noeuds ont le meme nombre de ddl
// si la nouvelle taille est plus petite: suppression
// si la nouvelle dimension est plus grande on met les ddl suplémentaires à NU_DDL
void DdlElement::Change_taille(int n,int m)
{ int oldTaille = te.Taille();
te.Change_taille(n);
int deltataille = n-oldTaille;
if (deltataille > 0)
{ // cas où on augmente la taille
// 1) on traite différemment les anciens ddl et les nouveaux
for (int i=1;i<=oldTaille;i++)
{ Tableau <Enum_ddl>& tb=te(i).tb;
int otaille = tb.Taille();
if (m<=otaille)
{// on supprime sans pb
tb.Change_taille(m);
}
else // on augmente avec des ddl NU_DDL
{tb.Change_taille(m);
for (int j=otaille+1;j<=m;j++)
tb(j)=NU_DDL;
};
};
// 2) les nouveaux DdlNoeudElement sont mis à NU_DDL
for (int i1=oldTaille+1;i1<= n;i1++)
{ Tableau <Enum_ddl>& tb=te(i1).tb;
for (int j1=1;j1<=m;j1++)
tb(j1)=NU_DDL;
};
}
else // si on diminue
{ for (int i=1;i<=oldTaille;i++)
{ Tableau <Enum_ddl>& tb=te(i).tb;
int otaille = tb.Taille();
if (m<=otaille)
{// on supprime sans pb
tb.Change_taille(m);
}
else // on augmente avec des ddl NU_DDL
{tb.Change_taille(m);
for (int j=otaille+1;j<=m;j++)
tb(j)=NU_DDL;
};
};
};
nbddl = n*m;
Calcul_NbDdl_typer(); // mise à jour du nombre de ddl de chaque type
};
// change la dimension du tableau de ddl pour n noeuds et un nombre de ddl par noeud
// stocke dans le tableau mddl qui doit avoir la dimension n
// si la nouvelle taille est plus petite: suppression
// si la nouvelle dimension est plus grande on met les ddl suplémentaires à NU_DDL
void DdlElement::Change_taille(int n,Tableau <int> mddl)
{ int oldTaille = te.Taille();
te.Change_taille(n);
nbddl = 0;
if (mddl.Taille() == n)
{int deltataille = n-oldTaille;
if (deltataille > 0)
{ // cas où on augmente la taille
// 1) on traite différemment les anciens ddl et les nouveaux
for (int i=1;i<=oldTaille;i++)
{ Tableau <Enum_ddl>& tb=te(i).tb;
int otaille = tb.Taille();
int m = mddl(i);nbddl += m;
if (m<=otaille)
{// on supprime sans pb
tb.Change_taille(m);
}
else // on augmente avec des ddl NU_DDL
{tb.Change_taille(m);
for (int j=otaille+1;j<=m;j++)
tb(j)=NU_DDL;
};
};
// 2) les nouveaux DdlNoeudElement sont mis à NU_DDL
for (int i1=oldTaille+1;i1<= n;i1++)
{ Tableau <Enum_ddl>& tb=te(i1).tb;
int m = mddl(i1);nbddl += m;
for (int j1=1;j1<=m;j1++)
tb(j1)=NU_DDL;
};
}
else // si on diminue
{ for (int i=1;i<=oldTaille;i++)
{ Tableau <Enum_ddl>& tb=te(i).tb;
int otaille = tb.Taille();
int m = mddl(i); nbddl += m;
if (m<=otaille)
{// on supprime sans pb
tb.Change_taille(m);
}
else // on augmente avec des ddl NU_DDL
{tb.Change_taille(m);
for (int j=otaille+1;j<=m;j++)
tb(j)=NU_DDL;
};
};
};
}
else
{ cout << "\n erreur de dimension pour le tableau mddl, il doit avoir la ";
cout << " dimension : " << n << ", alors qu\'il a la dimension : "
<< mddl.Taille() << "\nChange_taille(int n,Tableau <int> mddl)" << endl;
Sortie (1);
}
Calcul_NbDdl_typer(); // mise à jour du nombre de ddl de chaque type
};
// met le tableau de ddl a zero
void DdlElement::TailleZero()
{ int maxi_elem = te.Taille();
for (int i=1; i<=maxi_elem;i++)
(te(i)).tb.Change_taille (0);
te.Change_taille(0);
nbddl = 0;
tab_enum_famille.erase(tab_enum_famille.begin(),tab_enum_famille.end());
};
// change un des ddlNoeudElements
void DdlElement::Change_un_ddlNoeudElement(int i,const DdlNoeudElement& add)
{ int nbdold = te(i).tb.Taille();
nbddl -= nbdold;
int nbdnew = add.tb.Taille();
nbddl += nbdnew;
// mise en place de add
te(i)=add;
// mise à jour des ddl par famille
Calcul_NbDdl_typer(); // mise à jour du nombre de ddl de chaque type
/*Tableau <Enum_ddl>& tb=te(i).tb;
for (int j=1;j<=nbdold;j++)
(tab_enum_famille[PremierDdlFamille(tb(j))])--;
for (int i=1;i<= nbdnew;i++)
(tab_enum_famille[PremierDdlFamille(add.tb(i))])++;*/
};
// surcharge de l'operateur d'affectation
DdlElement& DdlElement::operator = (const DdlElement & a)
{ int nb = a.NbNoeud();
this->te.Change_taille(nb);
for (int i=1;i<= nb;i++)
this->te(i) = a(i);
// mise à jour du nombre de ddl
nbddl = a.nbddl; tab_enum_famille = a.tab_enum_famille;
return *this;
};
// surcharge des operator de test
bool DdlElement::operator == (const DdlElement & a) const
{ int nb = a.NbNoeud();
for (int i=1;i<=nb;i++)
if (this->te(i) != a(i)) return false;
return true;
};
bool DdlElement::operator != (const DdlElement & a) const
{ if (*this == a) return false; else return true;
};
// surcharge de l'operator de lecture
istream & operator >> (istream & entree, DdlElement& a)
{ // vérification du type
string type;
entree >> type;
if (type != "DdlElement")
{Sortie (1);
return entree;
}
// entrée du tableau
entree >> a.te;
// puis def du nombre total de ddl
a.Calcul_NbDdl();
a.Calcul_NbDdl_typer(); // mise à jour du nombre de ddl de chaque type
return entree;
};
// surcharge de l'operator d'ecriture
ostream & operator << (ostream & sort, const DdlElement& a)
{ // tout d'abord un indicateur donnant le type
sort << "DdlElement " ;
// puis le tableau
sort << a.te;
return sort;
};
// retour du nombre de ddl d'une famille donnée
int DdlElement::NbDdl_famille(Enum_ddl enu) const
{ // pour l'instant on sort la totalité des ddl ce qui est faux mais permet de fonctionner comme avant
// return nbddl;
map < Enum_ddl, Int_initer , std::less <Enum_ddl> >::const_iterator il = tab_enum_famille.find(enu);
if (il == tab_enum_famille.end()) return 0; else return (*il).second.vali;
};
//================================= methodes proteges ==================
// calcul du nb de ddl
void DdlElement::Calcul_NbDdl()
{ nbddl = 0;
int tetaille = te.Taille();
for (int i=1; i<= tetaille;i++)
nbddl += (te(i)).tb.Taille();
};
// calcul du nb de ddl de chaque type contenu
void DdlElement::Calcul_NbDdl_typer()
{ // méthode en utilisant "tab_enum_famille"
// qui est un tableau associatif
// on commence par initialiser le tableau
tab_enum_famille.erase(tab_enum_famille.begin(),tab_enum_famille.end());
// on passe en revue tous les ddl
int tetaille = te.Taille();
for (int i=1; i<= tetaille;i++)
{ Tableau <Enum_ddl>& tb=te(i).tb;
int nbd= tb.Taille();
for (int j=1;j<=nbd;j++)
(tab_enum_famille[PremierDdlFamille(tb(j))])++;
}
/* // pour vérif
map < Enum_ddl, Int_initer , std::less <Enum_ddl> >::iterator il,ilfin=tab_enum_famille.end();
for (il=tab_enum_famille.begin();il != ilfin;il++)
cout << "\n ddl= " << (*il).first << " nombre " << (*il).second.vali << endl;
cout << "toto ?";
int toto; cin >> toto; */
};

171
Maillage/DdlElement.h Normal file
View file

@ -0,0 +1,171 @@
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Definition, gestion et stockage des ddl de l'element. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef DDLELEMENT_H
#define DDLELEMENT_H
#include "Tableau_T.h"
#include "DdlNoeudElement.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
#include <map>
/// @addtogroup Les_classes_Ddl_en_tout_genre
/// @{
///
/// BUT: Definition, gestion et stockage des ddl de l'element.
///
/// \author Gérard Rio
/// \version 1.0
/// \date 23/01/97
///
///
class DdlElement
{ // surcharge de l'operator de lecture
friend istream & operator >> (istream & entree, DdlElement& a);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort, const DdlElement& a);
public :
// CONSTRUCTEURS :
DdlElement (); // par defaut
// definition du tableau pour n noeuds vide
DdlElement (int n);
// definition du tableau pour n noeuds et m ddl par noeud
// utile lorsque tous les noeuds ont le meme nombre de ddl
// par contre ici aucun ddl n'est encore défini
DdlElement (int n, int m);
// definition du tableau pour n noeuds et un nombre de ddl par noeud
// stocke dans le tableau mddl qui doit avoir la dimension n
// par contre ici aucun ddl n'est encore défini
DdlElement (int n,const Tableau <int>& mddl);
// definition du tableau pour n noeuds et une meme liste de ddl pour chaque
// noeud identique au second argument
DdlElement (int n, DdlNoeudElement d);
// de copie
DdlElement (const DdlElement& a);
// DESTRUCTEUR :
~DdlElement ();
// retourne nombre de noeud
int NbNoeud() const { return te.Taille();};
// acces en modification au ddl j du noeud i
void Change_Enum(int i,int j,const Enum_ddl enu);
// acces en lecture seulement au ddl j du noeud i
Enum_ddl operator() (const int i,const int j) const { return (te(i)).tb(j);};
// acces en lecture seulement au tableau de ddl du noeud i
const DdlNoeudElement& operator() (int i) const { return (te(i));};
// nb de ddl total contenu
int NbDdl() const { return nbddl;};
// nb de ddl du noeudElement i contenu
int NbDdl(int i) const ;
// retour du nombre de ddl d'une famille donnée
int NbDdl_famille(Enum_ddl enu)const;
// change la dimension du tableau de ddl pour n noeuds et m ddl par noeud
//dans le cas ou tous les noeuds ont le meme nombre de ddl
// si la nouvelle taille est plus petite: suppression
// si la nouvelle dimension est plus grande on met les ddl suplémentaires à NU_DDL
void Change_taille(int n,int m);
// change la dimension du tableau de ddl pour n noeuds et un nombre de ddl par noeud
// stocke dans le tableau mddl qui doit avoir la dimension n
// si la nouvelle taille est plus petite: suppression
// si la nouvelle dimension est plus grande on met les ddl suplémentaires à NU_DDL
void Change_taille(int n,Tableau <int> mddl);
// change un des ddlNoeudElements
void Change_un_ddlNoeudElement(int i,const DdlNoeudElement& add);
// mais le tableau de ddl a zero
void TailleZero();
// surcharge de l'operateur d'affectation
DdlElement& operator = (const DdlElement & a);
// surcharge des operator de test
bool operator == (const DdlElement & a) const ;
bool operator != (const DdlElement & a) const ;
// VARIABLES et méthodes protegees :
protected :
Tableau <DdlNoeudElement> te;
int nbddl;
// on définit un tableau associatif pour contenir le nombre de ddl de chaque famille
// on redéfini une classe de int dont les éléments sont mis à 0 au début
class Int_initer {public: int vali; Int_initer(): vali(0) {};
Int_initer(const Int_initer& a): vali(a.vali) {};
Int_initer& operator =(const Int_initer& a){vali=a.vali;return *this;};
void operator ++(int){vali++;};
void operator --(int){vali--;};};
map < Enum_ddl, Int_initer , std::less <Enum_ddl> > tab_enum_famille;
// calcul du nb de ddl total contenu
void Calcul_NbDdl() ;
// calcul du nb de ddl de chaque type contenu
void Calcul_NbDdl_typer() ;
};
/// @} // end of group
#endif

1600
Maillage/DdlLim.cc Normal file
View file

File diff suppressed because it is too large Load diff

331
Maillage/DdlLim.h Normal file
View file

@ -0,0 +1,331 @@
// FICHIER : DdlLim.h
// CLASSES : DdlLim
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 15/04/1997 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: La classe DdlLim permet de declarer un ensemble de ddl coiffe *
* par une reference utilise pour les conditions limites. $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef DDLLIM_H
#define DDLLIM_H
#include "Ddl.h"
#include "Tableau_T.h"
#include <iostream>
#include <stdlib.h>
#include "Sortie.h"
#include "UtilLecture.h"
#include "string.h"
#include "string"
#include <list>
#include "MvtSolide.h"
#include "EnuTypeCL.h"
/// @addtogroup Les_classes_Ddl_en_tout_genre
/// @{
///
/// BUT: La classe DdlLim permet de declarer un ensemble de ddl coiffe par une reference utilise pour les conditions limites.
///
/// \author Gérard Rio
/// \version 1.0
/// \date 15/04/1997
///
///
class DdlLim
{ // surcharge de l'operator de lecture
// les informations sont typées
friend istream & operator >> (istream &, DdlLim &);
// surcharge de l'operator d'ecriture typée
friend ostream & operator << (ostream &, const DdlLim &);
public:
// CONSTRUCTEURS :
// Constructeur defaut
DdlLim ();
// Constructeur de copie
DdlLim (const DdlLim& d);
// DESTRUCTEUR :
~DdlLim ();
// METHODES :
// Retourne la reference attache au degre de liberte
const string& NomRef () const { return ref; };
// retourne un pointeur de string donnant le nom du maillage associé
// = NULL si aucun maillage
const string* NomMaillage() const {return nom_maillage;};
// retourne le type de condition limite associé
EnuTypeCL TypeDeCL() const {return typeCL;};
// retourne la taille du tableau de ddl
int Taille() const { return tab.Taille();};
// retourne le ddl nb i en lecture/écriture
Ddl& ElemLim(int i) { return tab(i).ddl;};
// idem en constant
const Ddl& ElemLim_const(int i) const { return tab(i).ddl;};
// retourne le nom de la courbe i ou "" s'il n'y en n'a pas
// dans le cas d'un mouvement solide, c'est uniquement le premier ddl
// qui contient la courbe de charge éventuelle
const string& Nom_courbe(int i) const { return tab(i).co_charge;};
// retourne le nom de la fonctionnD i ou "" s'il n'y en n'a pas
// dans le cas d'un mouvement solide, c'est uniquement le premier ddl
// qui contient la courbe de charge éventuelle
const string & NomF_charge(int i) const {return tab(i).f_charge;};
// retourne si la référence est celle d'un champ ou pas
bool Champ() const {return champ;};
// retourne si le blocage est relatif ou pas
// un blocage relatif signifie que le blocage s'effectue par rapport au pas de temps
// précédent i.e. t=t
// un blocage non relatif, donc absolue signifie que le blocage s'effectue par rapport à
// t = 0
bool BlocageRelatif() const {return blocage_relatif;};
// indique si c'est un mouvement solide ou pas
bool Mouvement_Solide() const {return (mvtsolide!=NULL);};
// récupération du mouvement solide
const MvtSolide* Const_MouvementSolide() const {return mvtsolide;};
// récupération du mouvement solide
MvtSolide* MouvementSolide() const {return mvtsolide;};
// retourne l'échelle pour le ddl nb i
// dans le cas d'un mouvement solide, c'est uniquement le premier ddl
// qui contient la courbe de charge éventuelle
double Echelle_courbe(int i) const {return tab(i).echelle;};
// indique si le temps mini et/ou le temps maxi dépend d'une fonction nD
// retour:
// 0 : pas de dépendance
// 1 : tmin uniquement
// 2 : tmax uniquement
// 3 : tmin et tmax
int Temps_depend_nD() const
{int retour = 0; if (nom_fnD_t_min != "") {if (nom_fnD_t_max != "") return 3;else return 1;}
else {if (nom_fnD_t_max != "") return 2;else return 0;};
};
// retour du nom de la fonction nD qui pilote tmin
// si == "", pas de fonction
string Nom_fctnD_tmin() const {return nom_fnD_t_min;};
// idem pour tmax
string Nom_fctnD_tmax() const {return nom_fnD_t_max;};
// mise à jour de tmin et/ou tmax
// uniquement s'ils dépendent d'une fct nD
void Mise_a_jour_tmin_tmax(double tmin, double tmax)
{ if (nom_fnD_t_min != "") t_min = tmin;
if (nom_fnD_t_max != "") t_max = tmax;
};
// mise à jour de tmin
// uniquement s'il dépend d'une fct nD
void Mise_a_jour_tmin(double tmin)
{ if (nom_fnD_t_min != "") t_min = tmin;
};
// mise à jour de tmax
// uniquement s'il dépend d'une fct nD
void Mise_a_jour_tmax(double tmax)
{ if (nom_fnD_t_max != "") t_max = tmax;
};
// retourne un booléen qui indique si oui ou non le temps passé en paramètre
// est situé entre le temps min et maxi du ddllim
bool Temps_actif(const double& temps) const
{if ((t_min < temps) && (temps <= t_max))
return true;
else return false;
};
// ramène vrai si le temps est inférieur au temps actif
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
// il n'était pas également actif
bool Pas_a_prendre_en_compte(const double& temps) const
{if ((temps <= t_min) || ((temps > t_max) && !precedent))
return true;
else return false;
};
// ramène vrai si le temps est inférieur ou égale au temps actif, ou supérieur au temps max
bool Pas_a_prendre_en_compte_dans_intervalle(const double& temps) const
{if ((temps <= t_min) || (temps > t_max))
return true;
else return false;
};
// affichage et definition interactive des commandes
// plusieurs_maillages : indique si oui ou non, il y a plusieurs maillage
void Info_commande_DdlLim(ofstream & sort,bool plusieurs_maillages);
// Validation on non de l'activité du ddlLim
void Validation(const double& temps) {precedent = Temps_actif(temps);};
// retour du statut de validation
// vrai signifie que l'état enregistré est actif
bool Etat_validation() const {return precedent;};
// lecture des degres de liberte
// sur le fichier d'entree
// util pour la lecture de ddl bloque
void Lecture(UtilLecture & entreePrinc);
// examine si le ddlmin passé en argument possède les mêmes cibles que this
// mais que les data associés sont différents
// ramène true si c'est vrai, false sinon
bool MemeCibleMaisDataDifferents(const DdlLim& d) const;
// ramène true si le DdlLim contient l'enum_ddl passé en argument, false sinon
bool Existe_ici_leDdl(Enum_ddl enu) const;
// ramène true si le DdlLim contient au moins un déplacement, false sinon
bool Existe_ici_un_deplacement() const;
// Affiche les donnees liees aux degres de liberte
void Affiche () const ;
// Realise l'egalite
DdlLim& operator= (const DdlLim& d);
//Surcharge d'operateur logique
bool operator == ( const DdlLim& a) const ;
bool operator != ( const DdlLim& a) const { return !(*this == a);};
// ----------- définition de conteneurs à usage interne -----------
// cependant elles ne peuvent pas être déclaré en protégé ??
// protected :
// le conteneur des ddl bloqués
class Ddlbloque
{ public:
// surcharge de l'operator de lecture
friend istream & operator >> (istream & entree, Ddlbloque& d);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort, const Ddlbloque& d);
// constructeur
Ddlbloque() : co_charge(""),f_charge(""),ddl(),echelle(1.) {};
Ddlbloque(const Ddlbloque& d): co_charge(d.co_charge)
,f_charge(d.f_charge),ddl(d.ddl),echelle(d.echelle) {};
Ddlbloque(Ddl ddl_): co_charge(""),f_charge(""),ddl(ddl_),echelle(1.) {};
// destructeur
~Ddlbloque() {};
// surcharge de l'opérateur d'affectation
Ddlbloque& operator= (const Ddlbloque& d);
//Surcharge d'operateur logique
bool operator == ( Ddlbloque& a);
bool operator != ( Ddlbloque& a);
public:
Ddl ddl; // ddl bloqué
string co_charge; // nom d'une courbe de charge éventuelle
string f_charge; // nom d'une fonction nD utilisant des variables globales et autres
double echelle;
};
protected :
// données
string* nom_maillage; // nom de maillage associé, éventuellement!
string ref; // reference attachee aux ddl
EnuTypeCL typeCL; // indique éventuellement un type de condition limite associé
// = RIEN_TYPE_CL par exemple pour les noeuds (donc ne sert à rien dans ce cas)
// = TANGENTE_CL par exemple pour une arête, indique une condition de tangente imposée
Tableau <Ddlbloque> tab; // tableau des ddl
double t_min,t_max; // temps mini et maxi de durée des ddl imposés
string nom_fnD_t_min; // nom éventuelle de la fonction associée
string nom_fnD_t_max; // nom éventuelle de la fonction associée
int precedent; // pour la description de l'évolution du ddlLim
bool champ; // indique si c'est une référence de champ ou pas
bool blocage_relatif; // indique si oui ou non le blocage à t+dt s'effectue
// par rapport à t ou par rapport à 0
MvtSolide* mvtsolide; // indique si diff de NULL qu'il s'agit d'un mouvement solide appliqué
// si oui, tab contient les 3 ddl de position, dont le premier contient éventuellement
// une courbe de charge si on veut un pilotage du mvt solide par courbe de charge,
// ainsi qu'une échelle éventuelle globale
// FONCTIONS PROTEGEES
// verification en fonction de la dimension du pb
// par exemple en dim 2 d'existance des UZ ou des X3 etc..
void VerifDimDdl();
// lecture dans le cas particulier d'un champ
list <Ddlbloque> Lecture_champ(UtilLecture & entreePrinc);
// lecture dans le cas particulier d'un mouvement solide
list <Ddlbloque> Lecture_mvtSolide(UtilLecture & entreePrinc);
// Remplace la reference du degre de
// liberte par nouveau
// ATTENTION : Les modifications liees au changement de la reference du degre
// de liberte sont a la charge de l'utilisateur, en particulier il n'y a pas
// de vérification par exemple du fait que c'est un champ ou pas .
void Change_ref (string nouveau);
// idem pour le changement de nom de maillage
// le nouveau nom ne doit pas être vide !! sinon erreur
void Change_nom_maillage(const string& nouveau);
};
/// @} // end of group
#endif

96
Maillage/DdlNoeudElement.cc Normal file
View file

@ -0,0 +1,96 @@
// 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-2021 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 "DdlNoeudElement.h"
// CONSTRUCTEURS :
DdlNoeudElement::DdlNoeudElement () : // par defaut
tb()
{ /*pt = NULL;*/};
DdlNoeudElement::DdlNoeudElement (int n) :
tb(n)
{ /* pt = new int [n];*/};
// de copie
DdlNoeudElement::DdlNoeudElement (const DdlNoeudElement& a) :
tb(a.tb)
{ // int nbddl = a.tb.Taille();
/* pt = new int[nbddl];
for (int i=0;i<= nbddl-1; i++)
pt[i] = a.pt[i];*/
};
// DESTRUCTEUR :
DdlNoeudElement::~DdlNoeudElement ()
{/*if (pt != NULL) delete [] pt;*/};
// Methodes
// surcharge de l'affectation
DdlNoeudElement& DdlNoeudElement::operator = (const DdlNoeudElement & a)
{ this->tb = a.tb;
/*if (pt != NULL) delete [] pt;*/
//int nbddl = a.tb.Taille();
/* pt = new int[nbddl];
for (int i=0;i<= nbddl-1; i++)
this->pt[i] = a.pt[i];*/
return *this;
};
// surcharge des tests
bool DdlNoeudElement::operator == (const DdlNoeudElement & a) const
{ if (this->tb != a.tb) return false;
/*for (int i=1;i<=(this->tb).Taille();i++)
if (this->pt[i-1] != a.pt[i-1]) return false;*/
return true;
};
bool DdlNoeudElement::operator != ( const DdlNoeudElement & a) const
{ if (*this == a) return false;
else return true;
};
// surcharge de l'operator de lecture
istream & operator >> (istream & entree, DdlNoeudElement& a)
{ // vérification du type
string type;
entree >> type;
if (type != "DdlNoeudElement")
{Sortie (1);
return entree;
}
// entrée du tableau d'enum de ddl
entree >> a.tb;
return entree;
};
// surcharge de l'operator d'ecriture
ostream & operator << (ostream & sort, const DdlNoeudElement& a)
{ // tout d'abord un indicateur donnant le type
sort << "DdlNoeudElement " ;
// puis le tableau d'enum_ddl
sort << a.tb;
return sort;
};

120
Maillage/DdlNoeudElement.h Normal file
View file

@ -0,0 +1,120 @@
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Def des ddl lie a un noeud d'un element ( different des ddl*
* lies aux noeuds globaux). *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef DDLNOEUDELEMENT_T
#define DDLNOEUDELEMENT_T
#include "Enum_ddl.h"
#include "Tableau_T.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
/// @addtogroup Les_classes_Ddl_en_tout_genre
/// @{
///
/// BUT: Def des ddl lie a un noeud d'un element ( different des ddl lies aux noeuds globaux)
///
/// \author Gérard Rio
/// \version 1.0
/// \date 23/01/97
///
///
class DdlNoeudElement
{
// surcharge de l'operator de lecture
friend istream & operator >> (istream & entree, DdlNoeudElement& a);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort, const DdlNoeudElement& a);
public :
// VARIABLES PUBLIQUES :
// CONSTRUCTEURS :
DdlNoeudElement (); // par defaut
// def en fonction dunombre de ddl a stocker
DdlNoeudElement (int n);
// cas où il y a un seul identificateur de ddl a stocker
DdlNoeudElement (Enum_ddl e) :
tb(1,e)
{} ;
// de copie
DdlNoeudElement (const DdlNoeudElement& a);
// DESTRUCTEUR :
~DdlNoeudElement ();
// Methodes
// surcharge de l'affectation
DdlNoeudElement& operator = (const DdlNoeudElement & a);
// surcharge des tests
bool operator == (const DdlNoeudElement & a) const ;
bool operator != (const DdlNoeudElement & a) const ;
// le tableau des identificateurs de ddl
Tableau <Enum_ddl> tb;
// pointeur du tableau de connection ddl noeud element/ ddl noeud global
// pour l'instant ne sert à rien donc en commentaire
protected :
// int * pt;
};
/// @} // end of group
#endif

111
Maillage/Ddl_etendu.cc Normal file
View file

@ -0,0 +1,111 @@
// FICHIER : Ddl_etendu.cp
// CLASSE : Ddl_etendu
// 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-2021 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 "Ddl_etendu.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
#ifndef Ddl_etendu_deja_inclus
#ifndef MISE_AU_POINT
inline
#endif
// Constructeur par défaut
Ddl_etendu::Ddl_etendu () :
ddl_enum_etendu(), val_ddl(0.0)
{};
#ifndef MISE_AU_POINT
inline
#endif
// Constructeur fonction des variables
Ddl_etendu::Ddl_etendu (const Ddl_enum_etendu& ddl,double vale) :
ddl_enum_etendu(ddl), val_ddl(vale)
{};
#ifndef MISE_AU_POINT
inline
#endif
// Constructeur de copie
Ddl_etendu::Ddl_etendu (const Ddl_etendu& d):
ddl_enum_etendu(d.ddl_enum_etendu),val_ddl(d.val_ddl)
{};
#ifndef MISE_AU_POINT
inline
#endif
Ddl_etendu::~Ddl_etendu ()
// Destructeur
{ };
#ifndef MISE_AU_POINT
inline
#endif
// surcharge de l'operateur d'ecriture
ostream & operator << (ostream & sort,const Ddl_etendu & a)
{ // écriture du type
sort << " Ddl_etendu ";
// les données
sort << a.ddl_enum_etendu << " " << setprecision(ParaGlob::NbdigdoCA()) << a.val_ddl << " ";
return sort;
};
#ifndef MISE_AU_POINT
inline
#endif
// surcharge de l'operator de lecture
istream & operator >> (istream & entree, Ddl_etendu& a)
{ // vérification du type
string type;
entree >> type;
if (type != "Ddl_etendu")
{cout << "\n **** erreur en lecture d'une grandeur type Ddl_etendu ";
Sortie (1);
return entree;
}
// entrée des données
entree >> a.ddl_enum_etendu;
entree >> a.val_ddl;
return entree;
};
#endif // fin de l'inclusion totale

196
Maillage/Ddl_etendu.h Normal file
View file

@ -0,0 +1,196 @@
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 19/01/2006 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: class de stockage d'un ddl étendue, associé au type *
* Ddl_enum_etendu. En fait il s'agit du pendant des types *
* Ddl associé au type enum_ddl *
* Noter que la grandeur stockée est un scalaire !! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef DDL_ETENDU_H
#define DDL_ETENDU_H
#include "Ddl_enum_etendu.h"
#include "Enum_boolddl.h"
#include <iostream>
#include <stdlib.h>
#include "Sortie.h"
#include <string>
/// @addtogroup Les_classes_Ddl_en_tout_genre
/// @{
///
/// BUT: class de stockage d'un ddl étendue, associé au type
/// Ddl_enum_etendu. En fait il s'agit du pendant des types
/// Ddl associé au type enum_ddl
/// Noter que la grandeur stockée est un scalaire !!
///
/// \author Gérard Rio
/// \version 1.0
/// \date 19/01/2006
///
///
class Ddl_etendu
{
// surcharge de l'operator de lecture
friend istream & operator >> (istream & entree, Ddl_etendu& a);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort, const Ddl_etendu& a);
public:
// CONSTRUCTEURS :
// Constructeur par défaut
Ddl_etendu ();
// Constructeur fonction des variables, la seconde est facultative
Ddl_etendu (const Ddl_enum_etendu& ddl,double vale=0.0) ;
// Constructeur de copie
Ddl_etendu (const Ddl_etendu& d);
// DESTRUCTEUR :
~Ddl_etendu ();
// METHODES :
// Retourne la valeur associee au degre de liberte
// en lecture écriture
inline double& Valeur() { return val_ddl; };
// idem en lecture seulement
inline const double& ConstValeur() const { return val_ddl; };
// Retourne le Ddl_enum_etendu associé
// en lecture écriture
inline Ddl_enum_etendu& DdlEnumEtendu() { return ddl_enum_etendu; };
// idem mais en constant
inline const Ddl_enum_etendu& Const_DdlEnumEtendu() const { return ddl_enum_etendu; };
// Affiche les donnees liees au degre de liberte
void Affiche() const { cout << *this; };
void Affiche(ostream& sort) const { sort << *this; };
void Affiche(ostream& sort,int nb) const { sort << setprecision(nb) << *this; };
inline Ddl_etendu& operator= (const Ddl_etendu& d)
// Realise l'egalite entre deux degres de liberte étendus
{ ddl_enum_etendu=d.ddl_enum_etendu;
val_ddl=d.val_ddl;
return (*this);
};
// Surcharge de l'operateur +=
inline void operator+= (const Ddl_etendu& c)
{if (c.ddl_enum_etendu == ddl_enum_etendu)
{val_ddl += c.val_ddl;}
else
{cout << "\n *** erreur d'affectation void operator+= (const Ddl_enum_etendu& c)";
cout << "\n this: "; this->Affiche();
cout << "\n c: "; c.Affiche();
Sortie(1);
};
};
// Surcharge de l'operateur -=
inline void operator-= (const Ddl_etendu& c)
{if (c.ddl_enum_etendu == ddl_enum_etendu)
{val_ddl -= c.val_ddl;}
else
{cout << "\n *** erreur d'affectation void operator-= (const Ddl_enum_etendu& c)";
cout << "\n this: "; this->Affiche();
cout << "\n c: "; c.Affiche();
Sortie(1);
};
};
// Surcharge de l'operateur *=
inline void operator*= (double val) {val_ddl *= val;};
// Surcharge de l'operateur /= : division par un scalaire
inline void operator/= (double val) {val_ddl /= val;};
//Surcharge d'operateur logique
// ne concerne que le type et non la valeur
bool operator == ( Ddl_etendu& a) const
{return (ddl_enum_etendu == a.ddl_enum_etendu);};
bool operator != ( Ddl_etendu& a) const
{return (ddl_enum_etendu != a.ddl_enum_etendu);};
// test du type et de la valeur
bool Identique(Ddl_etendu& a)
{ return ((*this == a)&&(val_ddl == a.val_ddl));};
protected :
Ddl_enum_etendu ddl_enum_etendu; // identificateur du nom
double val_ddl; // valeur associee
};
/// @} // end of group
// pour faire de l'inline
#ifndef MISE_AU_POINT
#include "Ddl_etendu.cc"
#define Ddl_etendu_deja_inclus
#endif
#endif

1210
Maillage/DiversStockage.cc Normal file
View file

File diff suppressed because it is too large Load diff

211
Maillage/DiversStockage.h Normal file
View file

@ -0,0 +1,211 @@
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Classe servant a stocker des informations intermediaires.*
* *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef DIVERSSTOCKAGE_H
#define DIVERSSTOCKAGE_H
#include <string.h>
#include <string>
#include <list>
#include "Tableau_T.h"
#include "UtilLecture.h"
#include "LesReferences.h"
#include "MotCle.h"
#include "LectBloc_T.h"
#include "Bloc.h"
#include "BlocDdlLim.h"
/**
*
* BUT:Classe servant a stocker des informations intermediaires.
*
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
* \brief Classe servant a stocker des informations intermediaires.
*
*/
class DiversStockage
{
public :
// VARIABLES PUBLIQUES :
// CONSTRUCTEURS :
DiversStockage ();
// DESTRUCTEUR :
~DiversStockage () {};
// METHODES PUBLIQUES :
// affichage des infos
void Affiche () const ; // affichage de tous les infos
void Affiche1 () const ; // affichage des infos de la premiere lecture
void Affiche2 () const ; // affichage des infos de la seconde lecture
// lecture des infos
// dans la premiere lecture il s'agit actuellement des epaisseurs, des sections
void Lecture1(UtilLecture & entreePrinc,LesReferences& lesRef);
// dans la seconde lecture il s'agit des masses additionnelles
void Lecture2(UtilLecture & entreePrinc,LesReferences& lesRef);
// retourne le tableau des epaisseurs
const Tableau < BlocDdlLim<BlocScal_ou_fctnD> > & TabEpaiss() const { return tabEpaiss;};
// retourne le tableau des largeurs
const Tableau < BlocDdlLim<BlocScal_ou_fctnD> > & TabLargeurs() const { return tabLargeurs;};
// retourne le tableau des section
const Tableau < BlocDdlLim<BlocScal_ou_fctnD> > & TabSect() const { return tabSection;};
// retourne le tableau des variations de section
const Tableau < BlocDdlLim<BlocScal> > & TabVarSect() const { return tabVarSection;};
// retourne le tableau des masses volumiques
const Tableau < BlocDdlLim<BlocScal_ou_fctnD> > & TabMasseVolu() const { return tabMasseVolu;};
// retourne le tableau des masses additionnelles
const Tableau < BlocDdlLim<BlocScal_ou_fctnD> > & TabMasseAddi() const { return tabMasseAddi;};
// retourne le tableau des dilatations thermique
const Tableau < BlocDdlLim<BlocScal_ou_fctnD> > & TabCoefDila() const { return tabCoefDila;};
// retourne le tableau des gestions d'hourglass
const Tableau < BlocDdlLim<BlocGen_3_1> > & TabGesHourglass() const { return tabGesHourglass;};
// retourne le tableau d'intégration de volume d'une grandeur
const Tableau < BlocDdlLim<BlocGen_3_0> >& TabIntegVol() const {return tabIntegVol;};
// retourne le tableau d'intégration de volume et en temps d'une grandeur
const Tableau < BlocDdlLim<BlocGen_3_0> >& TtabIntegVol_et_temps() const {return tabIntegVol_et_temps;};
// retourne le tableau sur la stabilisation transversale de membrane ou biel
const Tableau < BlocDdlLim<BlocGen_4_0> >& TabStabMembBiel() const {return tabStabMembraneBiel;};
// retourne le tableau sur la définition d'un repère d'anisotropie aux éléments
const Tableau < BlocDdlLim<BlocGen_6_0> >& TabRepAnisotrope() const {return tabRepAnisotrope;};
// lecture de donnée en fonction d'un indicateur : int type
// pour l'instant ne fait rien
void LectureDonneesExternes(UtilLecture& ,LesReferences& ,const int ,const string& ) {};
// retourne le tableau sur statistique d'une ref de noeuds pour une grandeur quelconque
const Tableau < BlocDdlLim<BlocGen_3_0> >& TabStatistique() const {return tabStatistique;};
// retourne le tableau sur statistique d'une ref de noeuds cumulée en temps pour une grandeur queconque
const Tableau < BlocDdlLim<BlocGen_3_0> >& TabStatistique_et_temps() const {return tabStatistique_et_temps;};
// affichage et definition interactive des commandes
void Info_commande_DiversStockage1(UtilLecture & entreePrinc);
void Info_commande_DiversStockage2(UtilLecture & entreePrinc);
//----- 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)
void Lecture_base_info(ifstream& ent,const int cas);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas);
private :
// VARIABLES PROTEGEES :
// infos sur les epaisseurs
Tableau < BlocDdlLim<BlocScal_ou_fctnD> > tabEpaiss;
// infos sur les largeurs
Tableau < BlocDdlLim<BlocScal_ou_fctnD> > tabLargeurs;
// infos sur les sections de biellette
Tableau < BlocDdlLim<BlocScal_ou_fctnD> > tabSection;
// infos sur les variations de sections de biellette
Tableau < BlocDdlLim<BlocScal> > tabVarSection;
// infos sur les masses volumique
Tableau < BlocDdlLim<BlocScal_ou_fctnD> > tabMasseVolu;
// infos sur les masses additionnelles
Tableau < BlocDdlLim<BlocScal_ou_fctnD> > tabMasseAddi;
// infos sur les coefficients de dilatation
Tableau < BlocDdlLim<BlocScal_ou_fctnD> > tabCoefDila;
// infos sur la gestion d'hourglass
Tableau < BlocDdlLim<BlocGen_3_1> > tabGesHourglass;
// infos sur intégration de volume d'une grandeur queconque
Tableau < BlocDdlLim<BlocGen_3_0> > tabIntegVol;
// infos sur intégration de volume et en temps d'une grandeur queconque
Tableau < BlocDdlLim<BlocGen_3_0> > tabIntegVol_et_temps;
// infos sur la stabilisation transversale de membrane ou biel
// a priori de type 4,0 mais peut s'agrandir si nécessaire à la lecture !!
Tableau < BlocDdlLim<BlocGen_4_0> > tabStabMembraneBiel;
// infos sur la définition d'un repère d'anisotropie aux éléments
Tableau < BlocDdlLim<BlocGen_6_0> > tabRepAnisotrope;
// infos sur statistique d'une ref de noeuds pour une grandeur quelconque
Tableau < BlocDdlLim<BlocGen_3_0> > tabStatistique;
// infos sur statistique d'une ref de noeuds cumulée en temps pour une grandeur queconque
Tableau < BlocDdlLim<BlocGen_3_0> > tabStatistique_et_temps;
};
#endif

2216
Maillage/I_O_Condilineaire.cc Normal file
View file

File diff suppressed because it is too large Load diff

273
Maillage/I_O_Condilineaire.h Normal file
View file

@ -0,0 +1,273 @@
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 19/01/2007 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: gérer les conditions limites linéaires en I/O *
* en particulier comme conteneur. *
* informations: pour l'instant on considère une conditions *
* linéaires entre les ddl d'une même famille d'un noeud. *
* Une instance de I_O_Condilineaire peut générer un grand nombres *
* de conditions linéaires particulières, en fait autant que de *
* noeuds appartenant à la référence principal. Ces conditions *
* particulières ne sont pas stockées dans I_O_Condilineaire !! *
* par contre, elles peuvent être générées par I_O_Condilineaire. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef I_O_CONDILINEAIRE_H
#define I_O_CONDILINEAIRE_H
#include "Condilineaire.h"
#include "Plan.h"
#include "Droite.h"
/// @addtogroup Les_classes_relatives_aux_conditions_limites
/// @{
///
class I_O_Condilineaire : public Condilineaire
{ // surcharge de l'operator de lecture
// les informations sont typées
friend istream & operator >> (istream &, I_O_Condilineaire &);
// surcharge de l'operator d'ecriture typée
friend ostream & operator << (ostream &, const I_O_Condilineaire &);
public :
// CONSTRUCTEURS :
// par défaut
I_O_Condilineaire();
// de copie
I_O_Condilineaire(const I_O_Condilineaire& nd);
// DESTRUCTEUR :
~I_O_Condilineaire();
// METHODES PUBLIQUES :
// Retourne la reference attache à la condition linéaire
const string& NomRef () const { return refe; };
// retourne un pointeur de string donnant le nom du maillage associé
// = NULL si aucun maillage
const string* NomMaillage() const {return nom_maillage;};
// retourne le tableau des références associées (peut-être vide !)
const Tableau <string> & ReferenceAssociees() const {return refs_associe;};
// retourne le tableau des nom de maillage associées aux noms de ref (peut être = 0)
// tail = 0 si il n'y a pas de nom de maillage sur la ref principale
const Tableau <string > & NomMaillageAssociees() const {return nom_mail_associe;};
// examine si la condition passée en argument possède les mêmes cibles que this
// mais que les data associés sont différents
// ramène true si c'est vrai, false sinon
bool MemeCibleMaisDataDifferents(I_O_Condilineaire& d);
// Affiche les donnees
void Affiche () const ;
// Realise l'egalite
I_O_Condilineaire& operator= (const I_O_Condilineaire& d);
//Surcharge d'operateur logique: ne concerne que la condition initiale (pas la condition actuelle,
// c-a-d les coeff actuelles et les noeuds actuellement en cause etc.)
bool operator == ( I_O_Condilineaire& a) const ;
bool operator != ( I_O_Condilineaire& a) const { return !(*this == a);};
// lecture de la condition linéaire sur le fichier d'entree
void Lecture(UtilLecture & entreePrinc);
// retourne si la condition est relative ou pas
// une condition relative signifie que la condition s'effectue par rapport au pas de temps
// précédent i.e. t=t
// une condition non relative, donc absolue signifie que la condition s'effectue par rapport à
// t = 0
bool ConditionRelative() const {return condition_relative;};
//--- cas des conditions linéaires type plan ou droite ---------------------------------------------
// ramène true si on a effectivement une condi linéaire type plan ou droite
bool PlanDroite() const {return def_auto_par_rotation;};
// indique si le blocage qui existe déjà sur les noeuds à projeter, est cohérent
// avec la projection:
// typiquement si la direction de blocage est normale au plan de rotation
// ramène true si on peut concerver la condition de projection
// en entrée: indi qui donne la direction déjà bloquée
bool Coherence_condi_PlanDroite(int indi)const;
// ramène true si on a effectivement une condi linéaire type stricte_egalite
bool StricteEgalite() const {return stricte_egalite;};
// le nom du maillage éventuellement et le numéro du noeud s'il y a un noeud rotation
// sinon ramène un pointeur null
const String_et_entier* RefNoeudRotation() const {if (type_centre==1){return NULL;}
else {return &mailEtNumCentreNoeud;};};
// definition du noeud: centre rotation
void ChangeCentreNoeudRotation( Noeud* noe);
// définition de la direction actuelle ou normale pour plan droite
void ActualiseDirectionPlanDroite();
// projection (normale) du point M sur le plan ou droite, ramène le point M à la place du
// projeté, et calcul de la condition linéaire correspondant à la projection
Coordonnee& ProjectionSurPlanDroite_et_calValCondiLin(Coordonnee& M );
// --- fin des condi linéaires types plan droite ---------------------------------------------------
// Construction de la condition : en particulier les pointeurs de ddl permettant d'imposer la condition
// et def des coefficients en fonction éventuellement du temps ou de l'incrément du temps selon
// le paramètre condition_relative
// pour cela
// 1) on doit renseigner les fonctions de charge si elles existent
// a) retour du nombre de fonction de charge
int ExisteFonctionChargeCoef()const {return tab_co_charge.Taille();};
// b) le nom de la courbe
const string & NomFctch(int i) const {return tab_co_charge(i);};
// b) on renseigne les valeurs des fonctions de charge
void Valeur_fonctionChargeCoef(const Vecteur & fctch_,const Vecteur & delta_fctch_)
{fctch = fctch_;delta_fctch = delta_fctch_;};
// 2)
// Construction de la condition : 1) mise en place d'une valeur imposée due à la condition linéaire
// def des coefficients en fonction éventuellement des fonctions de charges et du paramètre condition_relative
// NB: pour les conditions correspondant à une projection sur un plan ou une droite, il faut que la direction du plan
// ou de la droite ait déjà été affecté auparavant
// !! la condition sur le ddl n'est pas imposée à ce niveau, par contre elle est stockée dans Condilineaire
Condilineaire& ConstructionCondition(Tableau <Noeud *> & t_noe,Condilineaire& condi_actuelle);
// affichage des commandes particulières à la définition d'une condition linéaire
void Info_commande_conditionLineaire(ofstream & sort,bool plusieurs_maillages);
// récupération de l'énuméré du type de ddl considéré par la condition limite linéaire
Enum_ddl TypeEnu() const {return enu;};
// retourne un booléen qui indique si oui ou non le temps passé en paramètre
// est situé entre le temps min et maxi de la condition linéaire
bool Temps_actif(const double& temps) const
{if ((t_min < temps) && (temps <= t_max)) return true;
else return false; };
// ramène vrai si le temps est inférieur au temps actif, ou supérieur au temps max
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
// il n'était pas également actif
bool Pas_a_prendre_en_compte(const double& temps) const
{if ((temps <= t_min) || ((temps > t_max) && !precedent))
return true;
else return false;
};
// ramène vrai si le temps est inférieur ou égale au temps actif, ou supérieur au temps max
bool Pas_a_prendre_en_compte_dans_intervalle(const double& temps) const
{if ((temps <= t_min) || (temps > t_max))
return true;
else return false;
};
// Validation on non de l'activité de la charge
void Validation(const double& temps) {precedent = Temps_actif(temps);
valeur_precedente_t = beta;};
// retour du statut de validation
// vrai signifie que l'état enregistré est actif
bool Etat_validation() const {return precedent;};
// initialisation des grandeurs de travail
void Initialisation_condil();
protected :
// informations: pour l'instant on considère une conditions linéaires entre les ddl d'une même
// famille d'un noeud.
// données
string* nom_maillage; // nom de maillage associé, éventuellement!
string refe; // reference principale attachee aux ddl
Tableau <string> refs_associe;
// dans le cas où il y a une condition linéaire entre plusieurs
// noeuds, la méthode retenue est la suivante: à chaque noeud de refe on associe un noeuds
// de chaque référence du tableau refs_associe, et on prend les ddl de type enu de chaque ref
// et on a une combinaison linéaire entre chacun. Dans ce cas, il faut donc que toutes les
// référence aient le même nombre de noeuds
Tableau <string > nom_mail_associe; // dans le cas où nom_maillage est non null
// il faut que toutes les références associées aient un nom de maillage associé
double t_min,t_max; // temps mini et maxi de durée des ddl imposés
double echelle; // échelle globale éventuelle
Enum_ddl enu; // identificateur du premier ddl de la famille pour laquelle on a une condition linéaire
// les ddl s'appliques d'abord à suivre à chaque noeud
int nbddlfamille; // nombre de ddl de la famille associée à enu
int condition_relative; // indique si oui ou non la condition à t+dt s'effectue
// par rapport à t ou par rapport à 0
int precedent; // pour la description de l'évolution d'un temps à l'autre
double valeur_precedente_t; // valeur à t
Tableau <string> tab_co_charge; // même dimension que (le nombre de ddl de type enu) * (1+le nombre
// de ref associé) s'il y a des courbes de charge
// Permet d'avoir des coefficients qui varient. S'il y a une courbe de charge
// alors toutes existent sinon aucune
Vecteur fctch,delta_fctch; // vecteur de travail qui contient les valeurs des fonctions de charge
// et leur acroissment entre t et t+deltat
//--- variables particulières pour la définition automatique d'une condition linéaire sur plan ou droite
bool def_auto_par_rotation;// signale le cas particulier du condition linéaire automatique
int type_centre; // = 1 on a un centre fixe c-a-d: centre_rotation, =2 le centre est centre_noeud à t=0
// =3 le centre est centre_noeud à t
Coordonnee centre_rotation; // position du centre de rotation fixe
String_et_entier mailEtNumCentreNoeud; // maillage et numéro du centre noeud s'il existe
Noeud* centre_noeud;
Plan pl;
Droite dr;
//--- variables particulières pour la condition particulière d'égalité exacte, pour tous les ddl
// du type enu, -> traitement particulier
bool stricte_egalite;
// 1) cas simple: pas de ref associe cela signifie que la condition linéaire concerne uniquement
// des ddl de chaque noeud de la ref principal. Pour chaque noeud on applique la même condition (au
// mvt solide près). La taille de val
// 1) cas où l'on a des références secondaire, celle-ci doivent avoir tous le même nombre de noeud,
// identique à la ref principal. Supposons qu'il y a na liste associé. La condition linéaire relie
// les ddl de na+1 noeud, chacun étant pris dans une ref associé + 1 sur la ref principal. Pour chaque
// noeud la liste des enu_ddl du même type que enu est parcouru: soit t_enu leur nombre. Donc au final,
// la taille de val (qui contient les coeff de la condition linéaire = (na+1)*t_enu
};
/// @} // end of group
#endif

2986
Maillage/LesCondLim.cc Normal file
View file

File diff suppressed because it is too large Load diff

581
Maillage/LesCondLim.h Normal file
View file

@ -0,0 +1,581 @@
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Gestion des differentes conditions limites *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef LESCONDLIM_H
#define LESCONDLIM_H
#include "LectBloc_T.h"
#include "Tableau_T.h"
#include "DdlLim.h"
#include "UtilLecture.h"
#include "LesReferences.h"
#include "MotCle.h"
#include "LesMaillages.h"
#include "CondLim.h"
#include "Condilineaire.h"
#include "Nb_assemb.h"
#include "LesCourbes1D.h"
#include "LesFonctions_nD.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"
#include "Basiques.h"
#include "I_O_Condilineaire.h"
#include "Temps_CPU_HZpp.h"
/** @defgroup Les_classes_relatives_aux_conditions_limites
*
* BUT:Gestion des differentes conditions limites
*
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
* \brief Gestion des differentes conditions limites
*
*/
/// @addtogroup Les_classes_relatives_aux_conditions_limites
/// @{
///
class LesCondLim
{
public :
// CONSTRUCTEURS :
LesCondLim (); // par defaut
// DESTRUCTEUR :
~LesCondLim ();
// METHODES PUBLIQUES :
// lecture des conditions limites : ddl bloque
void Lecture1(UtilLecture & entreePrinc,LesReferences& lesRef);
// lecture des conditions limites linéaires
void Lecture2(UtilLecture & entreePrinc,LesReferences& lesRef);
// lecture des conditions limites : initialisation
void Lecture3(UtilLecture & entreePrinc,LesReferences& lesRef);
// affichage des informations concernant les conditions limites
void Affiche() const ; // affichage de tous les infos
void Affiche1() const ; // affichage des ddl bloques
void Affiche2() const ; // affichage des conditions limites linéaires
void Affiche3() const ; // affichage des ddl d'initialisation
// introduction des données et variables pour leurs emplois futures, avec init par défaut
void IntroductionDonnees (LesMaillages * lesMail,LesReferences* lesRef
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD);
// initialisation des ddl avec le tableau de ddl d'init
// verif de l'existence de tous les ddl (initialisation et imposes)
// ajout si necessaire, dans ce dernier cas l'initialisation est a zero
// choix = false : indique qu'il faut initialiser que les ddl a t
// choix = true : indique qu'il faut initialiser les ddl a t et t+dt
// vérification de l'existence des courbes de charge adoc si nécessaire
// cas : indique le cas d'association de ddl en cours, ces ddl sont gérés globalement, c-a-d lorsque
// le statut d'un ddl est modifié (de bloqué à non bloqué par exemple) tous les ddl associés ont
// leur statut modifié de manière équivalente
// =0 pas d'association
// =1 association X V GAMMA
void Initial(LesMaillages * lesMail,LesReferences* lesRef,LesCourbes1D* lesCourbes1D
,LesFonctions_nD* lesFonctionsnD,bool choix,int cas);
// // mise à jour de l'initialisation, par exemple après un restart
// // même paramètres que Initial, par contre ici il n'y a aucune création
// void Re_initial(LesMaillages * lesMail,LesReferences* lesRef,LesCourbes1D* lesCourbes1D,bool choix,int cas);
// initialisation du nombre de cas d'assemblage
// si inf au nombre actuel, aucune action
void InitNombreCasAssemblage(int nb_cas)
{ if (nb_cas > condlim.Taille())
condlim.Change_taille(nb_cas);
};
// incrementation des coordonnees a t+dt et des ddl en fonctions des ddl imposes
// et du chargement
// coef: est un facteur multiplicatif des ddl sans courbes de charge,
// est suposé intégrer déjà le multiplicateur général
// en fait du chargement impose
// mult_gene : multiplicateur général de tous les chargements
// deltat : incrément de temps actuel
// temps : le temps courant où sont calculées les conditions
// ch_statut : indique s'il y a changement ou non de statut des conditions limites (pour les ddl aux noeuds)
// c-a-d un ddl qui passe de bloqué à non bloqué ou inversement: il s'agit uniquement des ddl aux noeuds
// c-a-d ceux qui ont une influence sur la mise en place des cl sur la raideur et le résidu
// cas : indique le cas d'association de ddl en cours, ces ddl sont gérés globalement, c-a-d lorsque
// le statut d'un ddl est modifié (de bloqué à non bloqué par exemple) tous les ddl associés ont
// leur statut modifié de manière équivalente
// =0 pas d'association
// =1 association X V GAMMA
// lorsque en_ddl est égal à NU_DDL, cela signifie que l'on met les conditions limites sur tous les
// ddl de noeud actifs
// lorsque en_ddl est différent de NU_DDL, il donne le type des seules ddl pour lesquels on met les
// conditions de blocage: par exemple X1 -> blocage sur X1,X2,X3 selon la dimension
void MiseAJour_tdt
(const double& mult_gene,LesMaillages * lesMail,const double& deltat,const LesReferences* lesRef
,const double& temps,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,const double& coef,bool& ch_statut
,int cas , Enum_ddl en_ddl = NU_DDL);
// mise en place de la répercussion sur les noeuds des conditions linéaires imposées externes (par les données d'entrées),
// ne prend pas en charge par exemple les CL dues aux contacts(gérés par CL)
// pour les paramètres: voir MiseAJour_tdt
void MiseAJour_condilineaire_tdt
(const double& mult_gene,LesMaillages * lesMail,const double& deltat,LesReferences* lesRef
,const double& temps,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,const double& coef,bool& ch_statut
,int cas ,Enum_ddl en_ddl = NU_DDL);
// validation des conditions de blocages et des conditions linéaire, pour l'incrément.
// concernant l'activité des ddlLim, elle est enregistrée en fonction du temps
// idem pour les conditions linéaires
void Validation_blocage (LesReferences* lesRef,const double& temps);
// test s'il y a changement de statut pour le temps indiqué par rapport à la situation actuelle ou pas
// n'effectue aucune autre opération
// si en_ddl est différent de NU_DDL on test le changement de statut uniquement pour le ddl en_ddl
bool Changement_statut(const LesMaillages * lesMail,const LesReferences* lesRef
,LesFonctions_nD* lesFonctionsnD
,const double& temps,const Enum_ddl en_ddl = NU_DDL) ;
// récupération des tableaux d'indices généraux des ddl bloqués
// cas : donne le type d'association de ddl que l'on veut
// =0 -> pas d'association
// =1 -> association de Xi avec Vi avec Gammai
// t_assemb: donne pour chaque type d'association, le numéro d'assemblage correspondant au different ddl
// de l'association
// cas=1 -> numéro d'assemblage de X1 puis V1 puis GAMMA1
// : en sortie une liste de Gene_asso, correspondant à tous les ddl bloqués et les
// les ddl associés
// définition d'un conteneur pour la routine Tableau_indice
class Gene_asso
{ public :
Gene_asso () : ty_prin(NU_DDL),pointe() {};
Gene_asso (Enum_ddl ty_prin,const Tableau <int>& pointes) :
ty_prin(ty_prin),pointe(pointes) {};
Gene_asso (const Gene_asso& a) : ty_prin(a.ty_prin),pointe(a.pointe) {};
Gene_asso& operator= (const Gene_asso& a)
{ty_prin=a.ty_prin;pointe=a.pointe;return (*this);};
bool operator== (const Gene_asso& a) const
{if((ty_prin==a.ty_prin)&&(pointe==a.pointe)) return true;else return false;};
bool operator!= (const Gene_asso& a) const
{if ( (*this)==a ) return true; else return false;};
Enum_ddl ty_prin; // le ddl principal bloqué
Tableau <int> pointe; // la position générale des ddl, principal et secondaire
// pour le cas 1 : pointe(k) -> la position du ddl Xi , puis Vi puis Gammai
};
list <Gene_asso> Tableau_indice(const LesMaillages * lesMail,const Tableau <Nb_assemb> & t_assemb
,const LesReferences* lesRef,const double& temps,int cas );
// mise en place des conditions limites sur les matrices et second membres
// (autres que les conditions linéaires)
// nb_casAssemb : le cas d'assemblage
// cas : indique un type d'association de ddl
// = 0 -> pas d'association, seules les ddl fournis par l'utilisateur sont considéré
// = 1 -> association de Xi Vi Gammai, qui sont pris en compte dès lors que l'un
// a été fixé par l'utilisateur
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
void ImposeConLimtdt(LesMaillages * lesMail,LesReferences* lesRef,
Mat_abstraite & matglob,Vecteur& vecglob
,const Nb_assemb& nb_casAssemb,int cas,Vecteur* vec2);
// mise en place des conditions limites sur le second membres
// nb_casAssemb : le cas d'assemblage
// cas : indique un type d'association de ddl
// = 0 -> pas d'association, seules les ddl fournis par l'utilisateur sont considéré
// = 1 -> association de Xi Vi Gammai, qui sont pris en compte dès lors que l'un
// a été fixé par l'utilisateur
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
void ImposeConLimtdt(LesMaillages * lesMail,LesReferences* lesRef,
Vecteur& vecglob,const Nb_assemb& nb_casAssemb,int cas,Vecteur* vec2);
// mise en place des conditions limites sur deux matrices
// utilisé par exemple pour le flambement
// la première matrice est initialisée avec des 1 sur la diagonale
// la seconde avec des 0 sur la diagonale
// nb_casAssemb : le cas d'assemblage
// cas : indique un type d'association de ddl
// = 0 -> pas d'association, seules les ddl fournis par l'utilisateur sont considéré
// = 1 -> association de Xi Vi Gammai, qui sont pris en compte dès lors que l'un
// a été fixé par l'utilisateur
void ImpConLimtdt2Mat(LesMaillages * lesMail,LesReferences* lesRef,
Mat_abstraite & matglob,Mat_abstraite & matgeom
,const Nb_assemb& nb_casAssemb,int cas);
// retourne la valeur absolu du maxi des efforts exterieurs
// et le numero ili du ddl correspondant dans l'assemblage global
double MaxEffort(int & ili,const Nb_assemb& nb_casAssemb)
{ return condlim(nb_casAssemb.n).MaxEffort(ili);};
// calcul des reactions et stockage des valeurs
// ceci dans le cas ou il n'y a pas de conditions lineaires appliquee
// on se sert des valeurs sauvegardees lors de la mise en place des CL bloquees
// nb_casAssemb : le cas d'assemblage
// cas : indique un type d'association de ddl
// = 0 -> pas d'association, seules les ddl fournis par l'utilisateur sont considéré
// = 1 -> association de Xi Vi Gammai, qui sont pris en compte dès lors que l'un
// a été fixé par l'utilisateur
void CalculReaction(LesMaillages * lesMail,LesReferences* lesRef
,const Nb_assemb& nb_casAssemb,int cas);
// récupération des reactions initiales, avant les rotations dues aux conditions linéaires
// il s'agit des réactions dues aux ddl bloqués et dues aux conditions linéaires
// et calcul des torseurs de réaction
void ReacAvantCHrepere(Vecteur& residu,LesMaillages * lesMail,
LesReferences* lesRef,const Nb_assemb& nb_casAssemb,int cas);
// récupération des reactions= residu et stockage des valeurs
// NB: après changement de repère, il n'y a plus que des ddl bloqués
// cas : indique un type d'association de ddl
// = 0 -> pas d'association, seules les ddl fournis par l'utilisateur sont considéré
// = 1 -> association de Xi Vi Gammai, qui sont pris en compte dès lors que l'un
// a été fixé par l'utilisateur
void ReacApresCHrepere(Vecteur& residu,LesMaillages * lesMail,
LesReferences* lesRef,const Nb_assemb& nb_casAssemb,int cas);
// affichage sur la sortie sort des reactions
void Affiche_reaction(ofstream& sort,const LesMaillages * lesMail) const ;
// ------------------ conditions linéaires externes ----------------------------------------------
// mise en place de condition externe lineaires
// expression de la raideur et du second membre dans un nouveau repere
// ramène si oui ou non, il y a eu un changement effectué
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
bool CoLinCHrepere_ext(Mat_abstraite & matglob,Vecteur& vecglob
,const Tableau <Condilineaire>& tabCondLine
,const Nb_assemb& nb_casAssemb,Vecteur* vec2);
// blocage des seconds membres pour les conditions lineaires
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
inline void CoLinBlocage(Mat_abstraite & matglob,Vecteur& vecglob
,const Nb_assemb& nb_casAssemb,Vecteur* vec2)
{ condlim(nb_casAssemb.n).CondlineaireImpose ( matglob, vecglob,vec2);};
// retour des ddl dans le repere general, ceci dans le cas d'utilisation
// de conditions lineaires
inline void RepInitiaux( Vecteur& sol,const Nb_assemb& nb_casAssemb)
{ condlim(nb_casAssemb.n).RepInitiaux(sol); };
// mise en place de condition externe lineaires en une opération
// retour de la raideur et du second membre sans changement de repere
// ramène si oui ou non, il y a eu un changement effectué
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
bool CoLinUneOpe_ext(Mat_abstraite & matglob,Vecteur& vecglob
,const Tableau <Condilineaire>& tabCondLine
,const Nb_assemb& nb_casAssemb,Vecteur* vec2);
// -------- conditions linéaires internes: imposées par les conditions limites en entrée -----------
// mise en place des conditions linéaires imposées par les données d'entrée
// expression de la raideur et du second membre dans un nouveau repere
// ramène si oui ou non, il y a eu un changement effectué
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
bool CoLinCHrepere_int(Mat_abstraite & matglob,Vecteur& vecglob,const Nb_assemb& nb_casAssemb,Vecteur* vec2);
// effacement du marquage de ddl bloque du au conditions lineaire imposées par les conditions d'entrée
void EffMarque();
// def de la largeur de bande en fonction des conditions linéaire limite en entrée
// casAssemb : donne le cas d'assemblage en cours
// les condi linéaires ne donnent pas des largeurs de bande sup et inf égales !!!
// demi = la demi largeur de bande ,
// total = le maxi = la largeur sup + la largeur inf +1
// cumule = la somme des maxis, ce qui donnera la largeur finale, due à des multiples multiplications: une par conditions linéaires
// dans le cas où on tiens compte des conditions linéaires par rotation (c-a-d sans multiplicateur ou pénalisation)
// en retour, ramène un booleen qui :
// = true : si la largeur de bande en noeud est supérieure à 1
// = false : si non, ce qui signifie dans ce cas qu'il n'y a pas d'augmentation de la largeur
// en noeud
bool Largeur_Bande(int& demi,int& total,const Nb_assemb& casAssemb,LesMaillages * lesMail,LesReferences* lesRef
,int& cumule);
// création d'un tableau de condition linéaire, correspondant à toutes les conditions linéaires d'entrées
// qu'elles soient actives ou pas (a prior cette méthode est conçu pour donner des infos relativement à la largeur
// de bandes en noeuds due aux CLL)
// chacune des condition ne contient "d'exploitable" que le tableau de noeuds associés à la CLL,
Tableau <Tableau <Condilineaire> > ConnectionCLL(const LesMaillages * lesMail,const LesReferences* lesRef) const;
// idem ConnectionCLL avec une liste, mais spécifiquement les conditions de type "stricte_egalite" entre ddl de noeud
// correspondant à toutes les conditions linéaires d'entrées actives uniquement
// (a priori cette méthode est conçu pour donner des infos pour condenser les pointeurs d'assemblages:
// LesMaillages::MiseAJourPointeurAssemblage() )
// chacune des condition ne contient "d'exploitable" que le tableau de noeuds associés à la CLL, et le type enumere de ddl
list <Condilineaire> ConnectionCLL_stricte_egalite
(const LesMaillages * lesMail,const LesReferences* lesRef) const;
// récupération du tableau de conditions linéaires en cours
//résultant de l'application des conditions lues (indépendamment du contact par exemple)
// mis à jour après la méthode: MiseAJour_condilineaire_tdt
const Tableau < Tableau <Condilineaire > >& Tab_CLinApplique() const {return tab_CLinApplique;};
// indique si oui ou non il y a des conditions limites linéaires en entrée
bool ExisteCondiLimite() const {return tab_iocondiline.Taille();};
// ----------------------- fin conditions linéaires -------------------------------------------
//initialisation, mise a zero des sauvegarde
void InitSauve(const Nb_assemb& nb_casAssemb);
// lecture de donnée en fonction d'un indicateur : int type
// pour l'instant ne fait rien
void LectureDonneesExternes(UtilLecture& ,LesReferences& ,const int ,const string&) {};
// affichage et definition interactive des commandes pour les conditions limites CL
void Info_commande_LesCondLim1(UtilLecture & entreePrinc);
// affichage et definition interactive des commandes pour les conditions limites CLL
void Info_commande_LesCondLim2(UtilLecture & entreePrinc);
// affichage et definition interactive des commandes pour les initialisations
void Info_commande_LesCondLim3(UtilLecture & entreePrinc);
//----- lecture écriture de restart -----
// 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)
void Lecture_base_info(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas);
//------- temps cpu -----
// retourne temps cumulé pour imposer les CL imposées
const Temps_CPU_HZpp& Temps_cpu_CL() const {return tempsCL;};
// retourne le temps cumulé pour imposer les CLL
const Temps_CPU_HZpp& Temps_cpu_CLL() const {return tempsCLL;};
// --- conteneur pour les réactions -----
class ReactStoc
{ public :
// surcharge de l'operator de lecture typée
friend istream & operator >> (istream &, ReactStoc &);
// surcharge de l'operator d'ecriture typée
friend ostream & operator << (ostream &, const ReactStoc &);
//Surcharge d'operateur logique
bool operator == ( const ReactStoc& a) const
{ return ((numMail==a.numMail)&&(numNoeud==a.numNoeud)
&&(ddl==a.ddl)&&(casAss==a.casAss));
};
bool operator != ( const ReactStoc& a) const { return !(*this == a);};
// !*!*!*! classement uniquement sur le numéro de noeud !*!*!*!
// --->> non: changement 3/1/2018
bool operator < ( const ReactStoc& a) const
{if (numMail < a.numMail) return true;
else if (numMail == a.numMail) return (numNoeud < a.numNoeud);
else // cas où numMail > a.numMail
return false;
//return (numNoeud < a.numNoeud);
};
bool operator > ( const ReactStoc& a) const { return !(*this < a);};;
public : int numMail; // numero de maillage
int numNoeud ; // numero de noeud
Ddl ddl; // le ddl bloque
int casAss; // cas d'assemblage
};
class TorseurReac
{// surcharge de l'operator de lecture typée
friend istream & operator >> (istream &, TorseurReac &);
// surcharge de l'operator d'ecriture typée
friend ostream & operator << (ostream &, const TorseurReac &);
public :
// constructeurs
TorseurReac():existe_torseur_reac(false),resultante(),moment(),bloque_ou_CLL(true) {};
TorseurReac(const TorseurReac& a):
existe_torseur_reac(a.existe_torseur_reac),resultante(a.resultante)
,moment(a.moment),bloque_ou_CLL(a.bloque_ou_CLL) {};
// méthodes
void Activation(int dima) {existe_torseur_reac=true;resultante.Change_dim(dima);
moment.Change_dim(dima);};
void Zero_init_torseur() {resultante.Zero();moment.Zero();};
// données
bool existe_torseur_reac; // indique si le Torseur doit-être calculé ou non
Coordonnee resultante; // la résultante du torseur
Coordonnee moment; // le moment du torseur par rapport à l'origine
bool bloque_ou_CLL; // true provient d'un ddl bloqué, false provient d'une CLL
};
// retourne les réactions aux conditions limites à un noeud noe d'un maillage mail
// s'il n'y a pas de conditions limites : retour d'une liste vide
// const list<const LesCondLim::ReactStoc*>& Reaction_noeud_mail(int mail,int noeud) const ;
// retourne la liste des types de ddl actuellement imposés
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io < Ddl_enum_etendu> > Les_type_de_ddl_en_reaction() const;
// retourne la liste des torseurs de réaction actuellement actif pour les maillages
// appelons tab_lili la liste:
// - tab_lili(i) concerne le maillage nb i
// - les éléments de tab_lili(i) sont les noms des références qui conduisent à un torseur de réaction
// actif, et un indice de gestion utilisé par LesCondLim pour retrouver
// rapidemment les informations
Tableau < List_io <String_et_entier > > TabListTorseurReaction(const LesMaillages & lesmail) const;
// retourne le torseur de réaction correspondant à l'indice i
const TorseurReac & Torseur_de_reaction(int i) const {return tab_torseurReac(i);};
private :
// VARIABLES PROTEGEES :
Tableau <DdlLim> tabBloq; // tableau des ddl bloques
Tableau <TorseurReac> tab_torseurReac; // tableau des torseurs de réaction
// relatif aux ddl bloqués et aux conditions linéaires
// de 1 à ttRG.Taille() on a les torseurs relatifs à tabBloq
// puis de ttRG.Taille() à la fin c-a-d ttRG.Taille()+ttRGCLL.Taille(),
// on a les torseurs relatifs à tab_iocondiline
// un tableau, qui permet de passer de tabBloq à tab_torseurReac
Tableau <int> ttRG; // tabBloq(i) contribue au torseur tab_torseurReac(ttRG(i))
// ttorBloq(i) contient tous les numéros de tabBloq qui contribue au torseur i
Tableau < List_io <int> > ttorBloq;
Tableau <DdlLim> tabInit; // tableau des ddl d'initialisation
Tableau <ReactStoc> reaction; // les reactions pour les ddl bloqués
Tableau <ReactStoc> reaction_CLin; // les reactions pour les conditions linéaires
Tableau <ReactStoc> reactionApresCHrepere; // les reactions après CHrepere
// tableau des conditions linéaires a imposer par les données d'entrée
Tableau <I_O_Condilineaire > tab_iocondiline;
Tableau < Tableau <Condilineaire > > tab_CLinApplique; // tableau des conditions linéaires
//résultant de l'application de tab_iocondiline
// un tableau à deux dim, qui permet de passer de tab_CLinApplique à tab_torseurReac
Tableau < Tableau <int> > ttRGCLL; // tab_CLinApplique(i)(j) contribue au torseur tab_torseurReac(ttRGCLL(i)(j))
// ttorCLL(i) contient tous les numéros de tab_iocondiline qui contribue au torseur i, avec
// le premier élément de l'instantce DeuxEntiers = le numéros dans tab_iocondiline, le second élement = le rang de
// la référence dans la condition linéaire
Tableau < List_io <DeuxEntiers> > ttorCLL;
//deux liste de noms de ref qui servent pour accèder aux grandeurs globales correspondantes
// aux composantes des torseurs de réaction
// voir: DimensionneTorseurs() :
// ttRG_noms_ref + _Re_ + i -> ième composante de Re a tdt
// et à la place de Re -> Mo pour le moment
Tableau <string> ttRG_noms_ref; // nom générique associé aux torseurs de ddl bloqué
Tableau <string> ttRGCLL_noms_ref; // idem pour les CLL
// une map pour faire l'association entre numéro de maillage et numéro de noeud d'une part
// et le tableau de réaction pour un accès quasi-directe
// map < string, list<const ReactStoc*> , std::less <string> > map_reaction;
int nb_maillage; // sauvegarde du nombre de maillage
Tableau < CondLim > condlim; // les fonctions et données qui permettent d'imposer les cl
// aux matrices, aux second membres, de remonter aux efforts apres
// resolution etc ..., le tableau est indicé par le numéro de cas d'assemblage
//------- temps cpu -----
Temps_CPU_HZpp tempsCL; // temps cumulé pour imposer les CL imposées
Temps_CPU_HZpp tempsCLL; // temps cumulé pour imposer les CLL
// ----fonctions internes pour simplifier
// cas de l'initialisation: prise en compte de l'appartenance à un groupe
// fixe : donne le type d'initialisation que l'on veut
// une_variable: indique si le ddl est une variable (=true) ou une donnée (=false)
void Init_appart_groupe(bool une_variable,Enum_ddl a,bool fixe,Noeud& noe, int cas,bool choix);
//cas courant: mise en place du blocage sur un ddl ou un groupe si besoin est
void Mise_cl(int nd,DdlLim& ddl,Enum_ddl a,Noeud& noe, int cas);
// cas courant : on retire le blocage sur un ddl ou un groupe si besoin est
void Retire_cl(int nd,DdlLim& ddlbloqu,Enum_ddl enu,Noeud& noe, int cas);
// vérification qu'il n'y a pas de surcharge de blocage
// choix indique si l'on vérifie à t ou à tdt
void Verif_surcharge_blocage(const LesMaillages * lesMail,const LesReferences* lesRef,const double& temps,int cas) ;
// fourni la liste des ddl associé de même dim, pour un du groupe et en fonction du cas d'association
// ramène une référence sur tab_travail qui est mis à jour
Tableau <Ddl>& Ddl_associe( Ddl& ddl,Noeud& noe,Tableau <Ddl>& tab_travail,int cas);
// cas particulier des mouvements solides, dans le second passage pour la méthode MiseAJour_tdt
void MiseAjour_tdt_second_passage_mvtSolide(const double& mult_gene,LesMaillages * lesMail
,const double& deltat,int cas
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD,const double& coef
,DdlLim& tabBloq_i,const ReferenceNE & ref,const double& temps,Enum_ddl en_ddl);
// mise à jour et calcul éventuel du torseur de réaction: uniquement pour les ddl X1, X2, X3
// --> pour au final obtenir le torseur des efforts globaux résultant de l'application d'un DdlLim
void CalculTorseurReaction(TorseurReac& tr, const Noeud& noe, ReactStoc& reac);
// récupération de valeurs à un noeud pour les grandeur enu
// ici il s'agit de grandeur scalaires
Tableau <double> Valeur_multi_interpoler_ou_calculer
(const Noeud& noe, Enum_dure temps,const List_io<Ddl_enum_etendu>& enu);
// récupération de valeurs à un noeud pour les grandeur enu
// ici il s'agit de grandeurs tensorielles
void Valeurs_Tensorielles_interpoler_ou_calculer
(const Noeud& noe, Enum_dure temps,List_io<TypeQuelconque>& enu);
// dimensionnement du tableau des torseurs ainsi que des tableaux ttRG et ttorBloq
// en fonction de tabBloq (utilisé plusieurs fois), puis de ttRGCLL en fonction de tab_iocondiline
void DimensionneTorseurs();
// DdlLim à un noeud: mise à jour des temps min et temps max, lorsque ceci dépendent de fonction nD
void Mise_a_jour_t_minmax_ddlLim(Noeud& noe,DdlLim& ddlLim,LesFonctions_nD* lesFonctionsnD);
// DdlLim général: mise à jour des temps min et temps max, lorsque ceci dépendent de fonction nD
// ici les fct nD doivent dépendre uniquement de grandeur générale
void Mise_a_jour_t_minmax_ddlLim(DdlLim& ddlLim,LesFonctions_nD* lesFonctionsnD);
};
/// @} // end of group
#endif

1965
Maillage/LesCondLim2.cc Normal file
View file

File diff suppressed because it is too large Load diff

3872
Maillage/LesMaillages.cc Normal file
View file

File diff suppressed because it is too large Load diff

957
Maillage/LesMaillages.h Normal file
View file

@ -0,0 +1,957 @@
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: definir le groupe de maillage *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef LESMAILLAGES_H
#define LESMAILLAGES_H
#include "Maillage.h"
#include "Tableau_T.h"
#include "UtilLecture.h"
#include "ParaGlob.h"
#include "LesReferences.h"
// #include "bool.h"
#include "DiversStockage.h"
#include "LesLoisDeComp.h"
#include "Front.h"
#include "Enum_dure.h"
#include "Nb_assemb.h"
#include "Basiques.h"
#include "Enum_dure.h"
#include "TypeQuelconque.h"
#include "Enum_IO_XML.h"
/** @defgroup Les_Maillages Les_Maillages
*
* BUT: definir le groupe de maillage *
*
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
* \brief Définition du groupe de maillage
*
*/
/// @addtogroup Les_Maillages
/// @{
///
//------------------------------------------------------------------
//! LesMaillages: l'ensemble des maillages
//------------------------------------------------------------------
/// \author Gérard Rio
/// \version 1.0
/// \date 23/01/97
class LesMaillages
{
public :
// VARIABLES PUBLIQUES :
// CONSTRUCTEURS : le pointeur sur UtilLecture permet d'avoir acces a la lecture
// le second pointe sur les variables globales
// le troisieme pointe sur l' instance des references
LesMaillages (UtilLecture * , ParaGlob *,LesReferences* lesRef);
// constructeur par défaut
LesMaillages();
// Constructeur de copie,
LesMaillages(const LesMaillages& lesmail);
// DESTRUCTEUR :
~LesMaillages();
// METHODES PUBLIQUES :
// lecture des maillages et des references s'y rapportant
void LectureLesMaillages();
// création et ajout d'un nouveau maillage en fonction d'un nom et d'une liste
// d'éléments
// *** il n'y a pas de création de nouveaux noeuds et de nouveaux éléments,
// ce sont les éléments et noeuds passés en paramètres qui sont ceux du maillage créé
// >> ramène le numéro du nouveau maillage
int Creation_nouveau_maillage
(list <Noeud*>& li_noeud,list <Element*>& list_elem,const string& nom_maillage);
// suppression d'un maillage existant
// par défaut, tous les noeuds et éléments du maillage sont supprimés
// si sans_conservation_noeuds_elements est false: les noeuds et les éléments ne sont pas supprimés
// mais ils ne sont plus référencés dans ce maillage !
void Suppression_maillage( const string& nom_maillage,const bool sans_conservation_noeuds_elements = true);
// ajout d'un tableau de noeud à un maillage
void Ajout_de_Noeuds(const list <Noeud *> & taN, int numMail)
{tabMaillage(numMail)->Ajout_de_Noeuds(taN);};
// -- ajout de noeuds, éléments et éventuellement de ref à un maillage
// ajout d'une liste d'éléments et de noeud à un maillage
// si le numéro de maillage associé à l'élément ou noeud est nul, il est remplacé par celui du maillage
// si le numéro de maillage est déjà existant et est différent ce celui de this, il y a
// création d'un nouvel item identique, avec le numéro this
// ajout éventuel d'une liste de références associées , si celle-ci est non-nulle
// il y a création de nouvelles ref correspondantes au numéro de maillage de this
// et ces références sont rajoutées à lesRef
// les noeuds qui sont associés aux éléments de taE, doivent faire partie : soit de taN, soit du maillage this
void Ajout_elements_et_noeuds(const list <Noeud *> & taN, const list <Element *> & taE,list <const Reference*>* lref,LesReferences* lesRef, int numMail )
{tabMaillage(numMail)->Ajout_elements_et_noeuds(taN,taE,lref,lesRef);};
// affichage et definition interactive des commandes
void Info_commande_lesMaillages();
// Affiche les donnees du maillage
void Affiche () const ;
// Affiche les donnees du maillage dans le fichier de nom nom_fichier
// au format du fichier ".her"
void Affiche (char* nom_fichier) const ;
// test si toutes les informations des maillages sont completes
// = true -> complet
// = false -> incomplet
bool Complet();
// introduction des lois de comportement dans les elements qui le necessite
// des sections pour les biellettes etc c-a-d , completer les elements
// avec les donnees qui ont ete acquises apres la lecture du maillage
// def des tableaux de ddl dans les noeuds
// def des pointeurs d'assemblage dans les noeuds
void Completer(DiversStockage* divers,LesLoisDeComp* lesLois
,LesFonctions_nD* lesFonctionsnD);
// mise à jour des repères d'anisotropie
void Mise_a_jour_repere_anisotropie(DiversStockage* divers,LesFonctions_nD* lesFonctionsnD);
// ramene le nombre de maillage
inline int NbMaillage() const
{ return nbMaillageTotal;};
// ramene le nombre d'element du maillage i
inline int Nombre_element(int i) const
{ return tabMaillage(i)->Nombre_element();};
// ramene le nombre de noeud du maillage i
inline int Nombre_noeud(int i) const
{ return tabMaillage(i)->Nombre_noeud();};
// ramene l'element j du maillage i
inline Element& Element_LesMaille(int i, int j) const
{return tabMaillage(i)->Element_mail(j);};
// idem mais en version constant
inline const Element& Element_LesMaille_const(int i, int j) const
{return tabMaillage(i)->Element_mail_const(j);};
// ramene le noeud j du maillage i
inline Noeud& Noeud_LesMaille(int i, int j) const
{return tabMaillage(i)->Noeud_mail(j);};
// Retourne le tableau des noeuds du maillage i
inline Tableau<Noeud *>& Tab_noeud (int i)
{ return tabMaillage(i)->Tab_noeud(); };
// Retourne le nom du maillage i
string NomMaillage(int i) const {return tabMaillage(i)->NomDuMaillage();};
// retourne le numéro du maillage de nom donné
// ou 0 si le nom ne correspond pas à un maillage
int NumMaillage(const string& nom) const
{map < string, int , std::less <string> >::const_iterator itmap = mapNomMail.find(nom);
if (itmap!=mapNomMail.end()) {return (*itmap).second;}
else {return 0;};
};
// suppression éventuelle des noeuds, non référencés par les éléments et les références
// dans tous les maillages
void SuppressionNoeudNonReferencer(LesReferences& lesRef)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->SuppressionNoeudNonReferencer(lesRef);};
// Affichage des noeuds, non référencés par les éléments
void AffichageNoeudNonReferencer()
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->AffichageNoeudNonReferencer();};
// renumérotation des noeuds de tous les maillagesen même temps, + prise en compte
// des conditions linéaires qui existent entre les noeuds
// ramène false si rien n'a changé (à cause d'un pb ou parce que la renumérotation n'est pas meilleure), vrai sinon
// si le pointeur d'assemblage est non nulle, cela veut dire que l'on veut également une mise à jour
// globale des pointeurs d'assemblages (ce qui est différent de la méthode : MiseAJourPointeurAssemblage(
// qui agit maillage après maillage)
// si le pointeur d'assemblage est non nulle et le drapeau: sans_changement_num_noeud = true
// cela signifie que l'on désire uniquement une renumérotation de pointeur sans les noeuds
// ramène dans tous les cas les nouvelles largeurs en ddl
// nouvelles_largeur_en_ddl.un = la largeur totale résultante
// nouvelles_largeur_en_ddl.deux = la demie largeur totale résultante
// nouvelles_largeur_en_ddl.trois = la demie largeur maximale pour la partie éléments finis
// uniquement (sans les CLL)
//
bool Renumerotation(LesReferences& lesRef,const Tableau <Tableau <Condilineaire> >& condCLL
,TroisEntiers& nouvelles_largeur_en_ddl,const Nb_assemb* nb_casAssemb = NULL
,bool sans_changement_num_noeud = false);
// renumérotation des noeuds maillages par maillage,
// === sans prise en compte de conditions linéaires ===
// en sortie les maillages sont mis à jour si la nouvelle numérotation conduit à une largeur de bande
// plus faible que la largeur initiale: en noeuds
// ramène: false si rien n'a changé (à cause d'un pb ou parce que la renumérotation n'est pas meilleure)
// vrai sinon
bool Renumerotation(LesReferences& lesRef);
// création éventuelle d'une référence sur les noeuds, non référencés par les éléments
// dans tous les maillages
void CreationRefNoeudNonReferencer(LesReferences& lesRef)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->CreationRefNoeudNonReferencer(lesRef);};
// ramène le numéro du noeud le plus proche du point donné pour t=0,
// ceci pour le maillage i, par défaut i vaut 1
inline int Noeud_le_plus_proche_0(const Coordonnee& M,int i = 1)
{ return tabMaillage(i)->Noeud_le_plus_proche_0(M); };
// idem à t
inline int Noeud_le_plus_proche_t(const Coordonnee& M,int i = 1)
{ return tabMaillage(i)->Noeud_le_plus_proche_t(M); };
// idem à tdt
inline int Noeud_le_plus_proche_tdt(const Coordonnee& M,int i = 1)
{ return tabMaillage(i)->Noeud_le_plus_proche_tdt(M); };
// ramène le numéro de l'élément qui contiend un point donné et le numéro du point
// d'intégration le plus proche pour les ddl de la liste (ddl spécifique à l'élément c'est-a-dire
// hors des ddl des noeuds de l'éléments)
// ceci pour le maillage i, (par défaut i vaut 1)
// si pas de numéro d'élément ramène un numéro d'élément nulle
// si les numéros de point d'intégration ne sont pas identique pour l'ensemble
// des ddl, pb !!, le numéro du pt integ de retour est alors négatif
// si pb ramène un numéro d'élément nulle
// enu_temps: dit si les coordonnées du point M sont à 0 ou t ou tdt
inline Maillage::NBelemEtptInteg Element_le_plus_proche
(Enum_dure enu_temps,const List_io <Ddl_enum_etendu>& list_enu,const Coordonnee& M,int i = 1)
{ return tabMaillage(i)->Element_le_plus_proche(enu_temps,list_enu,M); };
// ramène la liste des problèmes physiques gérés par les éléments de tous les maillages
inline const list <Enum_ddl >& Ddl_representatifs_des_physiques()const
{return ddl_representatifs_des_physiques;};
// ramene la liste des degrés de liberté inconnus, associés aux pb
// physiques gérés par les éléments qui existent dans tous les maillages
// Si éléments mécaniques -> ddl Xi voir Vi et gamma_i
// Si éléments thermiques -> ddl de température
// Si éléments méca + éléments thermiques -> ddl Xi et température
// etc. en fonction des éléments qui existent dans les maillages
inline const list <EnumElemTypeProblem >& Types_de_problemes() const
{return types_de_problemes;};
// ramene le nombre total de ddl actifs du pb
int NbTotalDdlActifs() const ;
// idem mais pour un type de ddl donné, dans le cas de type
// vectoriel on cumule les ddl de l'ensemble de la dimension
int NbTotalDdlActifs(Enum_ddl enum_ddl) const;
// ramene le nombre total de points d'intégration correspondant à un ddl donné
int NbTotalPtInteg(Enum_ddl enum_ddl) const ;
// ramene le nombre total de grandeurs génératrices, calculées aux points d'intégrations,
// correspondant à un ddl donné.
int NbTotalGrandeursGeneratrices(Enum_ddl enu) const ;
//récupération d'une grandeur vectoriel de dimension, la dimension
// de l'espace, défini au noeud et transféré dans un vecteur global
// qui cumule de manière séquentielle toutes les grandeurs
// en entrée : enum_ddl donne le type de la grandeur à récupérer
// en fait de la première composante
// duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
// enum_actif : le transfert s'effectue que si le ddl enum_actif est actif
// ce qui permet la différentiation entre les différents ddl
// vect : est le vecteur global de stockage qui normalement a été
// au préalable dimensionné avec NbTotalDdlActifs(Enum_ddl enum_ddl)
// en retour : une référence sur vect
Vecteur & Vect_loc_vers_glob(Enum_dure duree,Enum_ddl enum_actif
,Vecteur& vect,Enum_ddl enum_ddl);
// fonction inverse de Vect_loc_vers_glob, il s'agit ici de passer
// de la grandeur globale aux grandeurs locale
void Vect_glob_vers_local(Enum_dure duree,Enum_ddl enum_actif
,const Vecteur& vect,Enum_ddl enum_ddl) ;
//récupération d'une grandeur vectoriel de dimension, la dimension
// de l'espace, défini au noeud et transféré dans un vecteur global
// qui cumule de manière séquentielle toutes les grandeurs
// en entrée : tab_enum_ddl donne le tableau des type de la grandeur à récupérer
// en fait de la première composante
// duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
// tab_enum_actif : pour chaque élément tab_enum_ddl(i), le transfert s'effectue que si
// le ddl tab_enum_actif(i) est actif
// ce qui permet la différentiation entre les différents ddl
// vect : est le vecteur global de stockage qui normalement a été
// au préalable dimensionné avec somme des NbTotalDdlActifs(Enum_ddl enum_ddl), avec enum_ddl
// qui balaie l'ensemble des éléments de tab_enum_ddl
// Important: pour chaque famille de ddl, les ddl sont classés de manière croissante, ce qui signifie
// que c'est l'ordre des pointeurs d'assemblage si et seulement si, ces ddl ont été rangés dans les noeuds
// au préalable
// en retour : une référence sur vect
Vecteur & Vect_loc_vers_glob(Enum_dure duree,const Tableau <Enum_ddl>& tab_enum_actif
,Vecteur& vect,const Tableau <Enum_ddl>& tab_enum_ddl);
// fonction inverse de Vect_loc_vers_glob, il s'agit ici de passer
// de la grandeur globale aux grandeurs locale
void Vect_glob_vers_local(Enum_dure duree,const Tableau <Enum_ddl>& tab_enum_actif
,const Vecteur& vect,const Tableau <Enum_ddl>& tab_enum_ddl) ;
//récupération d'une grandeur scalaire
// défini au noeud et transféré dans un vecteur global
// qui cumule de manière séquentielle toutes les grandeurs
// en entrée : enum_ddl donne le type de la grandeur à récupérer
// duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
// enum_actif : le transfert s'effectue que si le ddl enum_actif est actif
// ce qui permet la différentiation entre les différents ddl
// vect : est le vecteur global de stockage qui normalement a été
// au préalable dimensionné avec NbTotalDdlActifs(Enum_ddl enum_ddl)
// en retour : une référence sur vect
Vecteur & Scalaire_loc_vers_glob(Enum_dure duree,Enum_ddl enum_actif
,Vecteur& vect,Enum_ddl enum_ddl);
// fonction inverse de Scalaire_loc_vers_glob, il s'agit ici de passer
// de la grandeur globale à la grandeur locale
void Scalaire_glob_vers_local(Enum_dure duree,Enum_ddl enum_actif
,Vecteur& vect,Enum_ddl enum_ddl);
// deux fonctions idem que pour les ddl : mais pour un Ddl_etendu
Vecteur & Scalaire_loc_vers_glob(Enum_ddl enum_actif,Vecteur& vect,const Ddl_enum_etendu& enum_ddl_etend);
void Scalaire_glob_vers_local(Enum_ddl enum_actif,Vecteur& vect,const Ddl_enum_etendu& enum_ddl_etend);
// deux fonctions idem que pour les ddl_etendu : mais pour une grandeur quelconque
Vecteur & Quelconque_loc_vers_glob(Enum_ddl enum_actif,Vecteur& vect,const TypeQuelconque& type_generique);
void Quelconque_glob_vers_local(Enum_ddl enum_actif,Vecteur& vect,const TypeQuelconque& type_generique);
// retourne la liste des types de ddl principaux actuellement utilisé
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io <Ddl_enum_etendu> > Les_type_de_ddl_par_noeud(bool absolue);
// retourne la liste des types de ddl étendu actuellement utilisé
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io <Ddl_enum_etendu> > Les_type_de_ddl_etendu_par_noeud(bool absolue);
// retourne la liste des types quelconque actuellement utilisé
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
Tableau <List_io <TypeQuelconque> > Les_type_de_TypeQuelconque_par_noeud(bool absolue);
// initialisation par défaut de tous les conteneurs aux noeuds
// de tous les maillages
// contenant li_restreinte_TQ
// ces conteneurs sont supposés déjà existés
// typiquement si le conteneurs est un scalaire, on met 0
void Init_par_defaut_conteneurs(List_io < TypeQuelconque >& li_restreinte_TQ);
// idem pour une seule grandeur
void Init_par_defaut_conteneurs(TypeQuelconque_enum_etendu enuTypeQuelconque);
// intro de certains conteneurs internes en relation par exemple avec les demandes de visualisation
// ou autre
// exemple: si VECT_REAC_N qui est un type quelconque, a été choisit
// il faut qu'il soit présent aux noeuds, alors qu'il est alimenter par les ddl pur ...
// on introduit donc le type quelconque associé
// NB: le conteneur passé en paramètre ne sert que pour localiser les grandeurs
void Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur
( const List_io < TypeQuelconque > & glob_noeud_evol_retenu);
// idem mais ciblé en fonction d'un tableau indicé sur les maillages
void Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur
( const Tableau < List_io < TypeQuelconque > > & tab_noeud_evol_retenu);
// retourne la liste des types de ddl actuellement utilisé
// aux éléments pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les éléments du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io <Ddl_enum_etendu> > Les_type_de_ddl_par_element(bool absolue);
// idem pour les grandeurs évoluées interne actuellement utilisés
// par les éléments, c'est-à-dire comme les ddl mais directement sous forme de vecteur, tenseurs ...
Tableau <List_io <TypeQuelconque> > Les_type_de_donnees_evolues_internes_par_element(bool absolue);
// idem pour les grandeurs particulières
Tableau <List_io <TypeQuelconque> > Les_type_de_donnees_particulieres_par_element(bool absolue);
// retourne la liste des types de grandeur quelconque actuellement utilisé
// aux faces élément pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que la grandeur en question soit présent
// pour tous les éléments du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io <TypeQuelconque> > Les_type_de_donnees_evolues_internes_par_face_element(bool absolue);
// idem pour les arêtes d'élément
Tableau <List_io <TypeQuelconque> > Les_type_de_donnees_evolues_internes_par_arete_element(bool absolue);
// Au niveau des noeuds: transfert des coordonnées de grandeurs vectorielles à des grandeurs évoluées
// stockée sous forme de grandeurs TypeQuelconque
// exemple: les réactions qui sont naturellement stockée en composantes
// le principe est que ce passage s'effectue si les conteneurs existent au niveau des noeuds
void PassageInterneDansNoeud_composantes_vers_vectorielles();
// ..... transfert de grandeurs des points d'intégration aux noeuds .....
// 1- en entrée les type évoluées et les types particuliers que l'on veut transférer
// 2- en entrée: cas qui indique la méthode de transfert à utiliser
// =1 : les valeurs aux noeuds sont obtenue par moyennage des valeurs des pts d'integ les plus près
// des éléments qui entourent le noeud
// on décompose le processus en 4 étapes pour éviter d'initialiser plusieurs fois lorque l'on refait à chaque fois
// le même transfert
// les méthodes: AjoutConteneurAuNoeud, InitUpdateAuNoeud, sont générales, peuvent être utilisés pour autres choses
// A) première étape def des conteneurs et c'est tout, la méthode peut donc être utilisée
// pour autre chose. tabQ: permet d'avoir plusieurs listes de TypeQuelconque
// en entrée: tabQ doit-être de dimension 2, donc pointe sur 2 listes, si un des pointeur
// est nulle on n'en tient pas compte
void AjoutConteneurAuNoeud(int num_maillage,const List_io < Ddl_enum_etendu >& lienu
,const Tableau <List_io < TypeQuelconque > * >& tabQ)
{ tabMaillage(num_maillage)->AjoutConteneurAuNoeud(lienu,tabQ);};
// fonctions utilitaires du même genre pour tous les maillages
// ajout sur tous les maillages d'un ou plusieur ddl_enum_etendu comme conteneur
// en entrée: tabQ doit-être de dimension 2, donc pointe sur 2 listes, si un des pointeur
// est nulle on n'en tient pas compte
void AjoutConteneurAuNoeud(const List_io < Ddl_enum_etendu >& lienu
,const Tableau <List_io < TypeQuelconque > * >& tabQ)
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->AjoutConteneurAuNoeud(lienu,tabQ);};
// B) initialisation des updates sur les noeuds
// lorsque l'on a des listes différentes pour chaque maillage on peut directement utiliser la routine de Maillage
void InitUpdateAuNoeud(const List_io < Ddl_enum_etendu >& lienu
, const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->InitUpdateAuNoeud(lienu,tabQ,cas);};
void InitUpdateAuNoeud(int numMail,const List_io < Ddl_enum_etendu >& lienu
, const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas)
{ tabMaillage(numMail)->InitUpdateAuNoeud(lienu,tabQ,cas);};
// C) exécution du transfert
// transfert de ddl des points d'intégrations (de tous) aux noeuds d'un éléments (on ajoute aux noeuds, on ne remplace pas)
// les ddl doivent déjà exister aux noeuds sinon erreur
// il doit s'agir du même type de répartition de pt d'integ pour toutes les grandeurs
void TransfertPtIntegAuNoeud(int numMail,Element& ele,const List_io < Ddl_enum_etendu >& lietendu
,const Tableau <Tableau <double> > & tab_val,int cas)
{ tabMaillage(numMail)->TransfertPtIntegAuNoeud(ele,lietendu,tab_val,cas);};
// idem pour des grandeurs quelconques
// les informations sont ici contenues dans les types quelconques
// liQ_travail: est une liste de travail qui sera utilisée dans le transfert
void TransfertPtIntegAuNoeud(int numMail,Element& ele,const Tableau <List_io < TypeQuelconque > >& tab_liQ
,List_io < TypeQuelconque > & liQ_travail,int cas)
{ tabMaillage(numMail)->TransfertPtIntegAuNoeud(ele,tab_liQ,liQ_travail,cas);};
// D) dernière étape: (par exemple calcul des moyennes en chaque noeuds)
void FinTransfertPtIntegAuNoeud(const List_io < Ddl_enum_etendu >& lienu
, const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas)
{ for (int i=1;i<=nbMaillageTotal;i++) tabMaillage(i)->FinTransfertPtIntegAuNoeud(lienu,tabQ,cas);};
void FinTransfertPtIntegAuNoeud(int numMail,const List_io < Ddl_enum_etendu >& lienu
, const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas)
{ tabMaillage(numMail)->FinTransfertPtIntegAuNoeud(lienu,tabQ,cas);};
// ..... cumul et moyenne de grandeurs venant des éléments vers les noeuds (exemple la pression appliquée) .....
// on décompose le processus en 4 étapes pour éviter d'initialiser plusieurs fois lorque l'on refait à chaque fois
// la même opération (typiquement à chaque incrément)
// on peut utiliser:
// A) AjoutConteneurAuNoeud : pour ajouter des conteneurs ad hoc aux noeuds
// B) InitUpdateElementAuNoeud: avant le cumul, initialise les conteneurs
// initialise uniquement les grandeurs qui sont gérées par l'élément
// C) Accumul_aux_noeuds : balaie les éléments avec cumul aux noeuds, uniquement des grandeurs gérées par l'élement
// D) MoyenneCompteurAuNoeud : effectue les moyennes aux noeuds
// accumulation aux noeuds de grandeurs venant de tous les éléments vers ses noeuds (exemple la pression appliquée)
// autres que celles aux pti classiques, mais directements disponibles
// le contenu du conteneur stockées dans liQ est utilisé en variable intermédiaire
void Accumul_aux_noeuds(int numMail,const List_io < Ddl_enum_etendu >& lietendu
,List_io < TypeQuelconque > & liQ,int cas)
{ tabMaillage(numMail)->Accumul_aux_noeuds(lietendu,liQ,cas);};
// fonctions utilitaires du même genre pour tous les maillages
// ajout sur tous les maillages d'un conteneur particulier quelconque
void AjoutConteneurAuNoeud(TypeQuelconque& tQ)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->AjoutConteneurAuNoeud(tQ);};
// ajout sur tous les maillages d'un ou plusieur ddl_enum_etendu comme conteneur
void AjoutConteneurAuNoeud(const List_io < Ddl_enum_etendu >& lienu)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->AjoutConteneurAuNoeud(lienu);};
// initialisation des updates de ddl_étendu uniquement sur les noeuds: on met à 0 les ddl_etendu correspondant,
// les compteurs, comptant le nombre de fois où les noeuds sont modifiés, sont mis à 0
void InitUpdateAuNoeud(const List_io < Ddl_enum_etendu >& lienu)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->InitUpdateAuNoeud(lienu);};
// idem pour un seul ddl_etendu
void InitUpdateAuNoeud(const Ddl_enum_etendu & enu)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->InitUpdateAuNoeud(enu);};
// moyenne des valeurs aux noeuds (en fonction du nombre ou le noeud a été modifié)
void MoyenneCompteurAuNoeud(const Ddl_enum_etendu & enu)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->MoyenneCompteurAuNoeud(enu);};
// initialisation d'un ou de plusieurs nouveau cas d'assemblage
// ramène le numéro du premier nouveau cas d'assemblage
Nb_assemb InitNouveauCasAssemblage(int nb_cas);
// ramène le nombre total de cas d'assemblage actuellement pris en compte dans les
// maillages
int Nb_total_en_cours_de_cas_Assemblage() const {return tab_nb_assemb;};
// met a jour les pointeurs d'assemblage dans les noeuds pour un cas d'assemblage
// a effectuer si l'on a changer de nb de noeuds, de nb de ddl, de nb de maillage
// casAssemb : donne le cas d'assemblage qui est a considérer
void MiseAJourPointeurAssemblage(const Nb_assemb& nb_casAssemb);
// mise a zero de tous les ddl actifs autres que les deplacements
// si indic = false; pas de creation des tableaux a t+dt
// si indic = true; creation des tableaux a t+dt
// cas = true; les coordonnées à t et éventuellement à t+dt sont initialisées
// aux valeurs de t=0 (cas par défaut),
// sinon on ne les modifies pas.
void ZeroDdl(bool indic,bool cas = true);
// force la mise à une valeur d'un ddl (ou de la liste de ddl fonction de la dimention) particulier, quelques soit son activité
// si fonction_de_la_dimension = true : c'est toute les ddl fct de la dimension qui sont mis à la valeur
void Force_Ddl_aux_noeuds_a_une_valeur(Enum_ddl enu, const double& val,Enum_dure temps, bool fonction_de_la_dimension)
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->Force_Ddl_aux_noeuds_a_une_valeur(enu,val,temps,fonction_de_la_dimension);};
// mise à zéro de dd_enum_etendu aux noeuds : force la mise à une valeur à 0
void Force_Ddl_etendu_aux_noeuds_a_zero(const Tableau<Ddl_enum_etendu>& tab_enu)
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->Force_Ddl_etendu_aux_noeuds_a_zero(tab_enu);};
// ramene la demi largeur de bande en ddl et la largeur de bande
// casAssemb : donne le cas d'assemblage qui est a considérer
void Largeur_Bande(int& demi, int& total,const Nb_assemb& nb_casAssemb);
// méthode permettant le calcul des matrices de connexion pour chaque
// élément ceci par rapport à la numérotation absolu des ddl
// casAssemb : donne le cas d'assemblage qui est a considérer
void Table_connexion
(Tableau < Tableau <int> >& petites_matricespetites_matrices
,const Nb_assemb& nb_casAssemb) const;
// actualisation des ddl et des grandeurs actives de t+dt vers t
void TdtversT();
// actualisation des ddl et des grandeurs actives de t vers tdt
void TversTdt();
// actualisation des ddl a t+dt, a partir du resultat de la resolution
// casAssemb : donne le cas d'assemblage qui est a considérer
void PlusDelta_tdt(Vecteur& sol,const Nb_assemb& nb_casAssemb);
// actualisation des ddl actifs a t, a partir du resultat de la resolution
// casAssemb : donne le cas d'assemblage qui est a considérer
void PlusDelta_t(Vecteur& sol,const Nb_assemb& nb_casAssemb);
// récupération du vecteur correspondant à l'incrément de ddl entre t et tdt
// en paramètre le vecteur vide et en sortie le vecteur rempli
// casAssemb : donne le cas d'assemblage qui est a considérer
Vecteur& RecupDepde_tatdt(Vecteur& sol,const Nb_assemb& nb_casAssemb);
// changement des ddl à tdt par ceux correspondant au vecteur passé en paramètre
// casAssemb : donne le cas d'assemblage qui est a considérer
void ChangeDdla_tdt(Vecteur& sol,const Nb_assemb& nb_casAssemb);
// retrouver le ddl correspondant a un pointeur de position
// d'assemblage, le nb du noeud et du maillage
// insol = le pointeur d'assemblage;
// ddl = le ddl en sortie; a t+dt si elle il existe
// sinon la valeur a t
// casAssemb : donne le cas d'assemblage qui est a considérer
Ddl NoeudIndice(int inSol,int& nbNoeud, int& nbMaillage
,const Nb_assemb& nb_casAssemb);
// idem en ramenant en plus la valeur du ddl a 0
// casAssemb : donne le cas d'assemblage qui est a considérer
Ddl NoeudIndice(int inSol,int& nbNoeud, int& nbMaillage, double& val0
,const Nb_assemb& nb_casAssemb);
// calcule des normales aux noeuds: dans le cas d'éléments 1D ou 2D uniquement
// a priori le calcul s'effectue par une moyenne des normales des éléments qui
// entourent le noeud.
// init -> calcul des normales à t=0
// et ajout conteneur aux noeuds des normales à t = 0 et t
void InitNormaleAuxNoeuds()
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->InitNormaleAuxNoeuds();};
// mise à jour -> mise à jour des normales à t
void MiseAjourNormaleAuxNoeuds()
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->MiseAjourNormaleAuxNoeuds();};
// mise à jour -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t
// cette méthode est utile si on veut utiliser des normales à t pour une valeur
// particulière (transitoire) de la géométrie à tdt
// cf: l'algo non dyna par exempel
void MiseAjourNormaleAuxNoeuds_de_tdt_vers_T()
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->MiseAjourNormaleAuxNoeuds_de_tdt_vers_T();};
// ---------- particularité aux contacts ----------
// creation des elements frontiere: cela n'a lieu qu'une seule fois
// si les frontières existent déjà, --> aucune action, --> ramène 0
// sinon il y a réellement création, et --> ramène 1
int CreeElemFront();
// ramene le nombre de maillage esclave
inline int NbEsclave() { return domEsclave;};
// ramene le tableau des list des elements frontiere
inline Tableau <LaLIST <Front>*>& ListFrontiere() { return listFrontiere;};
// ramene un tableau des noeuds des frontières des maillages esclaves
Tableau < Tableau <Noeud*> *> Tab_noeud_frontiere_esclave();
// ramene le tableau des noeuds des frontières des maillages
const Tableau <Tableau <Noeud*> *>& Tab_noeud_frontiere() {return tt_noeud_front;};
// calcul et ramene le tableau de tous les noeuds des maillages esclaves
// noeuds de la frontière et noeuds internes
// s'ils existent, sinon le tableau est vide
// le tableau n'est pas sauvegarde
const Tableau<Noeud *> Esclave();
// mise à jour des boites d'encombrements des éléments, qui contiennent des éléments frontières
// et des éléments frontières eux-même
void Mise_a_jour_boite_encombrement_elem_front(Enum_dure temps);
// crée et ramene pour tous les maillages, la liste des éléments qui contiennent chaque noeud
// mis à jour lorsque lors de la création des frontières
const Tableau < const Tableau <List_io < Element* > > *>& Indice() ;
// inactive tous les ddl et les données
void Inactive_ddl_et_donnees();
// inactive les ddl mais pas les données
void Inactive_ddl();
// inactive les ddl primaires
void Inactive_ddl_primaire();
// active les ddl primaires
void Active_ddl_primaire();
// introduction des ddl de contraintes si cela veut dire quelques chose
// pour l'élément
void Plus_ddl_Sigma();
// inactivation des ddls de contraintes si cela veut dire quelques chose
// pour l'élément
void Inactive_ddl_Sigma();
// activation des ddls de contraintes si cela veut dire quelques chose
// pour l'élément
void Active_ddl_Sigma();
// activation du premier ddl de contraintes si cela veut dire quelques chose
// pour l'élément
void Active_premier_ddl_Sigma();
// introduction des ddl d'erreur si cela veut dire quelques chose
// pour l'élément
void Plus_ddl_Erreur();
// inactivation des ddls d'erreur si cela veut dire quelques chose
// pour l'élément
void Inactive_ddl_Erreur();
// activation des ddls d'erreur si cela veut dire quelques chose
// pour l'élément
void Active_ddl_Erreur();
// d'une manière plus générique une fonction pour activer une série de ddl
// donnée par un identificateur, si c'est une grandeur vectoriel c'est l'ensemble
// des ddl du vecteur qui sont inactivé.
void Active_un_type_ddl_particulier(Enum_ddl en);
void Active_un_type_ddl_particulier(Tableau<Enum_ddl>& tab_en); // idem mais pour un tableau
void Active_un_type_ddl_particulier(const list<Enum_ddl>& list_en); // idem pour une liste
// idem la fonction Active_ddl_noeud mais ici pour l'inactivation
void Inactive_un_type_ddl_particulier(Enum_ddl en);
void Inactive_un_type_ddl_particulier(Tableau<Enum_ddl>& tab_en); // idem mais pour un tableau
void Inactive_un_type_ddl_particulier(const list <Enum_ddl>& list_en); // idem pour une liste
// -- encore plus générique
// changement de toutes les conditions données (service, variable, fixage ..)
// selon le tableau de ddl passé en paramètre
// par contre les valeurs de ta ne sont pas utilisé donc les valeurs actuelles restent inchangé
void ChangeToutesLesConditions(const Tableau<Ddl>& ta);
// changement de statu des ddl d'une combinaison, en fonction du statut
// de enuta dans chaque noeud, les ddl de la combinaison, prennent le même statut que celui
// de enuta dans chaque noeud.
// cas est la combinaison,
void ChangeStatut(int cas,Enum_ddl enuta);
// changement de statu des ddl d'une combinaison dans chaque noeud, en fonction
// de enubold, les ddl de la combinaison, prennent le même statut que enubold
// cas est la combinaison,
void ChangeStatut(int cas,Enum_boolddl enubold);
//change le statut de tous les ddl liés à la physique en cours
//par exemple: met à libre ou bloque les ddl liés à la physique en cours
void Libere_Ddl_representatifs_des_physiques(Enum_boolddl enubold);
// Calcul de l'erreur sur l'ensemble des éléments
// type indique le type d'erreur retenue
// type = 1 : cas d'un calcul aux moindres carrés
// et retour un tableau de tableau de grandeurs sur les maillages en cours
// ret(i) : concerne le maillage i
// ret(i)(1) : somme des erreurs sur l'ensemble des éléments: est homogêne à
// un |delta contrainte| * domaine
// ret(i)(2) : somme de la grandeur de ref du calcul d'erreur sur l'ensemble des
// éléments: est homogêne à une |contrainte| * domaine
// ret(i)(3) : le maxi pour les tous les éléments de |delta contrainte| * domaine
// ret(i)(4) : le maxi pour les tous les éléments de |contrainte| * domaine
Tableau <Tableau <double > > ErreurSurChaqueElement(int type);
// lecture de donnée en fonction d'un indicateur : type
// type = 1 , on lit les tenseurs de contraintes
void LectureDonneesExternes(const int type ,const string& nomMaillage);
// mise en place du travail à t sur les maillages
// indique que l'on va utiliser les ddl en 0, t
// si les grandeurs en tdt existaient, elles sont supprimées
void Travail_t();
// idem pour un maillage donné de numéro num
void Travail_t(int num);
// définition des coordonnées à t identiques à ceux à t=0,
void Insert_coord1();
// mise en place du travail à t tdt sur les maillages
// indique que l'on va utiliser les ddl en 0, t, tdt
void Travail_tdt();
// initialisation des coordonnées à t et tdt aux mêmes valeurs qu'à 0
// utile quand on veut utiliser les métriques pour un pb non couplés
void Init_Xi_t_et_tdt_de_0() { for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->Init_Xi_t_et_tdt_de_0();};
// ramène le maximum de variation de coordonnée entre t et tdt de tous les noeuds du maillage
double Max_var_dep_t_a_tdt() const;
// ramène le minimum de la distance entre deux noeuds de l'ensemble des éléments pour tous les maillages
double Min_dist2Noeud_des_elements(Enum_dure temps) const ;
// indique aux éléments un niveau de précision de calcul désiré pour les prochains calculs
// precision = 0 : aucune précision demandée, precision >=0 : précision maximale demandée
void Drapeau_preparation_calcul_precis(int precision);
// --------- calcul dynamique ---------
// ajout des ddl de vitesse pour tous les maillages
// val_fixe indique si l'on veut des ddl libres ou pas
void Plus_Les_ddl_Vitesse(Enum_boolddl val_fixe);
// ajout des ddl d'accélération pour tous les maillages
// val_fixe indique si l'on veut des ddl libres ou pas
void Plus_Les_ddl_Acceleration(Enum_boolddl val_fixe);
// calcul de la longueur d'arrête d'élément minimal
// divisé par la célérité dans le matériau
double Longueur_arrete_mini_sur_c(Enum_dure temps);
// initialisation éventuelle du bulk viscosity
// choix peut-être égale à 0, 1 ou 2
void Init_bulk_viscosity(int choix,const DeuxDoubles & coef);
//----- lecture écriture de restart -----
// 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)
void Lecture_base_info(ifstream& ent,const int cas);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas);
// sortie du schemaXML: en fonction de enu
void SchemaXML_LesMaillages(ofstream& sort,const Enum_IO_XML enu) const ;
// ------ informations utiles par exemples pour la visualisation
// retourne les dimensions minis et maxi suivant les axes du repère
// absolu du maillage numéro nbmail (en faite le calcul est fondé
// uniquement sur la position des noeuds du maillage
// le premier vecteur contient les minimums
// le deuxième vecteur contient les maximums
Tableau <Vecteur> Taille_boite(int nbmail);
// dans le cas ou aucun numéro de maillage n'est fournis
// c'est l'encombrement de tous les maillages qui est fourni
Tableau <Vecteur> Taille_boite();
// -------- utilitaires de manipulation de maillage
// création de maillage quadratiques incomplets à partir de maillages linéaires.
// En fait il y création de maillages identiques aux maillages déjà existants, les éléments qui sont de types
// linéaires sont remplacés par des éléments quadratiques incomplets correspondants.
// Il y a création de références correspondantes
void CreeMaillagesQuadratiques_a_partir_des_lineaires(LesReferences* lesRef);
// création de maillage quadratiques complets. En fait il y création de maillages identiques aux maillages
// déjà existants, les éléments qui sont de types quadratiques incomplets sont remplacés par des éléments
// quadratiques complets correspondants.
// Il y a création de références correspondantes
void CreeMaillagesQuadratiquesComplets_a_partir_des_incomplets(LesReferences* lesRef);
// création de maillages par extrusion
// Il y a création de références correspondantes
void CreeMaillageExtrusion2D3D(LesReferences* lesRef);
// définition interactive de listes de références
void CreationInteractiveListesRef(LesReferences* lesRef);
// modification de l'orientation d'éléments
void Modif_orientation_element(int cas_orientation,LesReferences* lesRef);
// collapse de noeuds très proche: appartenant à des éléments différents
// rayon : donne la distance maxi entre les noeuds qui doivent être collapsé
void Collapse_noeuds_proches(double rayon, LesReferences* lesRef);
// Collapse des éléments supperposés, c-a-d identiques, dans le cas où il en existe
void Collapse_element_supperpose(LesReferences* lesRef);
// création d'un nouveau maillage issue de la fusion de maillages existants
// nom_mails_a_fusionner : la liste des maillages à fusionner
// new_mail : le nom du nouveau maillage à construire
// NB: si new_mail correspond à un maillage déjà existant, il y a fusion de ce maillage
// avec les autres, sans création d'un nouveau maillage
void Fusion_maillages(List_io < string >& nom_mails_a_fusionner,const string& new_mail
,LesReferences* lesRef);
// création d'un nouveau maillage issue d'un maillages existants et d'une ref d'éléments
// le nouveau maillage = les éléments de la ref
void Cree_sous_maillage(int num_mail,LesReferences* lesRef, string nom_ref,const string& new_mail);
// création d'éléments SFE en fonction d'éléments classiques
// il y a création d'un nouveau maillage
void CreationMaillageSFE();
// Affiche les donnees des maillages dans des fichiers dont le nom est construit à partir du nom de
// chaque maillage au format ".her" et ".lis"
// le paramètre optionnel indique le numéro du maillage à afficher, s'il vaut -1, on affiche tous les maillages
void Affiche_maillage_dans_her_lis(Enum_dure temps,LesReferences &lesRef,int imail=-1);
// relocalisation des points milieux des arrêtes des éléments quadratiques
void RelocPtMilieuMailleQuadra();
// --- utilitaires pour calculs particuliers-------
// calcul des diverses intégrations: volume et volume + temps,
// alimentation des grandeurs globales associées
void Integration();
// calcul des diverses statistiques sur des ref de noeuds et avec éventuellement
// cumul sur le temps
// alimentation des grandeurs globales associées
void CalStatistique();
private :
// VARIABLES PROTEGEES :
Tableau<Maillage *> tabMaillage ; // tableau de maillages
// liste des noms de maillages associée à un numéro sous forme d'un arbre pour faciliter la recherche
// cette liste est modifiée que par chaque maillage
map < string, int , std::less <string> > mapNomMail;
// const int nbEnreg; // nb de maillage initiaux
int nbEnreg; // nb de maillage initiaux
int nbMaillageTotal; // nb de maillage effectivement en cours
int nbPortion ; // nbPortion = le nombre maxi de maillage enregistrable
// avant une nouvelle allocation dynamique de nbEnreg places supplementaires
UtilLecture * entreePrinc; // acces a la lecture du fichier principal
ParaGlob * paraGlob ; // parametres globaux
LesReferences* lesRef; // references
int domEsclave; // nombre de domaine esclave, lorsqu'il est different de zero
// il indique le nombre de maillage a partir de 1, qui sont esclave
// ---- stockage des intégrales de volumes sur des références d'éléments ----
// --- cas des intégrales volumiques: définition du conteneur, il peut également s'agir d'une intégration temporelle en +
// d'où la grandeur courante et celle à t
// 1) intégration de volume uniquement
Tableau <TypeQuelconque> integ_vol_typeQuel, integ_vol_typeQuel_t;
Tableau <const Reference*> ref_integ_vol; // les références associées
// si la référence est nulle, cela signifie que l'intégrale est figée: sa valeur ne change pas
// 2) intégration de volume et en temps: donc on commule le delta
Tableau <TypeQuelconque> integ_vol_t_typeQuel, integ_vol_t_typeQuel_t;
Tableau <const Reference*> ref_integ_vol_t; // les références associées
// si la référence est nulle, cela signifie que l'intégrale est figée: sa valeur ne change pas
// ---- stockage des statistiques sur des références de noeuds ----
// --- cas des statistique: définition du conteneur, il peut également s'agir d'un cumul temporelle en +
// d'où la grandeur courante et celle à t
// 1) statistique de ref de noeuds uniquement
Tableau <TypeQuelconque> statistique_typeQuel, statistique_typeQuel_t;
Tableau <const Reference*> ref_statistique; // les références associées
// si la référence est nulle, cela signifie que la statistique
// est figée: sa valeur ne change pas
//pour_statistique_de_ddl a la même dimension que ref_statistique
// 1) Dans le cas où ref_statistique(i) est une statistique de Ddl_enum_etendu
// pour_statistique_de_ddl(i) == le Ddl_enum_etendu
// 2) sinon, pour_statistique_de_ddl(i) == NU_DDL
Tableau < Ddl_enum_etendu > pour_statistique_de_ddl;
// 2) statistique avec cumul en temps: donc on commule le delta
Tableau <TypeQuelconque> statistique_t_typeQuel, statistique_t_typeQuel_t;
Tableau <const Reference*> ref_statistique_t; // les références associées
// si la référence est nulle, cela signifie que la statistique est figée: sa valeur ne change pas
//pour_statistique_t_de_ddl a la même dimension que ref_statistique_t
// 1) Dans le cas où ref_statistique_t(i) est une statistique de Ddl_enum_etendu
// pour_statistique_t_de_ddl(i) == le Ddl_enum_etendu
// 2) sinon, pour_statistique_de_ddl(i) == NU_DDL
Tableau < Ddl_enum_etendu > pour_statistique_t_de_ddl;
// cumule les liste des types de degrés de liberté inconnus,
// qui vont être calculés par la résolution des problèmes
// physiques gérés par les éléments qui existent dans les maillages
// Si éléments mécaniques -> ddl Xi voir Vi et gamma_i
// Si éléments thermiques -> ddl de température
// Si éléments méca + éléments thermiques -> ddl Xi et température
// etc. en fonction des éléments qui existent dans les maillages
// (généré à la lecture du maillage, ce qui permet d'optimiser la consultation par la suite)
list <Enum_ddl > ddl_representatifs_des_physiques;
// idem au niveau des types de problèmes gérés par les éléments
list <EnumElemTypeProblem > types_de_problemes;
// stockage des pointeurd de listes d'element frontiere
Tableau <LaLIST <Front>*> listFrontiere;
// idem pour les noeuds des frontières
Tableau <Tableau <Noeud*> *> tt_noeud_front;
// crée et ramene pour tous les maillages, la liste des éléments qui contiennent chaque noeud
// mis à jour lorsque lors de la création des frontières
Tableau < const Tableau <List_io < Element* > > *> tous_indices;
// tableau d'indexage des ddl géré par les noeuds
// t_i_n (i)(j) -> donne les infos pour retrouver le ddl numéro j du cas de charge i
Tableau < Tableau <Posi_ddl_noeud> > t_i_n;
// nombre actuellement de cas d'assemblage initialisé
int tab_nb_assemb;
// METHODES PROTEGEES :
// on s'occupe de mettre à jour les types de pb et les ddl types associés
void Mise_a_jour_type_pb_type_associe_ddl();
// met a jour les pointeurs d'assemblage dans les noeuds pour un cas d'assemblage
// a effectuer si l'on a changer de nb de noeuds, de nb de ddl, de nb de maillage
// casAssemb : donne le cas d'assemblage qui est a considérer
// ici, l'assemblage suit l'ordre du tableau de noeud passé en paramètre
// le tableau de noeuds rassemble tous les noeuds des maillages mais avec une numérotation propre
void MiseAJourPointeurAssemblage_interne(const Nb_assemb& nb_casAssemb,Tableau <Noeud* >& tab_N_final);
// remise à jour des tableaux de pointeurs t_i_n uniquement, due à un changement de numéro de noeud
// en fonction d'un changement de num de noeud (mais pas de changement de pointeur d'assemblage
// pour chaque noeud, tab_N_final(i) correspond au noeud qui avait le numéro i ancien
// et qui a maintenant le numéro tab_N_final(i)->Num_noeud()
void MiseAJourTableau_t_i_n(const Nb_assemb& nb_casAssemb,Tableau <Noeud* >& tab_N_final);
};
/// @} // end of group
#endif

2937
Maillage/LesMaillages2.cc Normal file
View file

File diff suppressed because it is too large Load diff

2649
Maillage/Maillage.cc Executable file
View file

File diff suppressed because it is too large Load diff

959
Maillage/Maillage.h Executable file
View file

@ -0,0 +1,959 @@
// FICHIER : Maillage.h
// CLASSE : Maillage
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: def de la classe Maillage, *
* Une instance de la classe Maillage est identifiee a partir *
* de la dimension, des tableaux des noeuds et des elements. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef MAILLAGE_H
#define MAILLAGE_H
#include <iostream>
#include <map>
#include "Noeud.h"
#include "Element.h"
#include "Tableau_T.h"
#include "UtilLecture.h"
#include "Enum_geom.h"
#include "Enum_interpol.h"
#include "LesReferences.h"
#include "Front.h"
#include "LaList.h"
#include "Nb_assemb.h"
#include "Ddl_enum_etendu.h"
#include "Droite.h"
#include "Plan.h"
#include "Sphere.h"
#include "Cylindre.h"
#include "Cercle.h"
#include "Condilineaire.h"
#include "DiversStockage.h"
/// @addtogroup Les_Maillages
/// @{
///
//------------------------------------------------------------------
//! Maillage: un maillage particulier
//------------------------------------------------------------------
/// \author Gérard Rio
/// \version 1.0
/// \date 23/01/97
class Maillage
{
public :
friend class LesMaillages;
// CONSTRUCTEURS :
// pour tous les constructeurs: map < string, int , std::less <string> >* lisNomMail,
// est un tableau associatif nom <=> numéro de maillage, qui est utilisé par
// les maillages, mais mis à jour par chaque maillage.
// nom_maillage : est facultatif, s'il est différent de ".", il est pris en compte
// Constructeur par defaut
Maillage (map < string, int , std::less <string> > & lisNomMail,int nmail=1,int dim=3
,const string& nom_maillage = ".");
// Constructeur fonction d'une dimension, du nombre de noeuds
// du nombre d'elements, et d'un numero d'identification (le nb de maillage)
Maillage (map < string, int , std::less <string> > & lisNomMail
,int dim,int n_noeud,int n_elt,int nmail
,const string& nom_maillage = ".");
// Constructeur fonction de la plupart des informations (qui peuvent être vide
// mais doivent être cohérentes)
// *** il n'y a pas de création de nouveaux noeuds et de nouveaux éléments,
// ce sont les éléments et noeuds passés en paramètres qui sont ceux du maillage créé
Maillage (map < string, int , std::less <string> > & lisNomMail
,int dim,list <Noeud* >& li_noeud, list <Element* > li_element
,int nmail
,const string& nom_maillage = ".");
// Constructeur de copie, cependant ici il n'y a pas de création de noeud ni d'élément
// c'est seulement une création de nouveaux conteneurs de pointeurs
// cependant le numéro de maillage et le nom de maillage n'est pas valide, il faut
// ensuite les définir
Maillage (const Maillage& mail);
// Constructeur de copie, avec création de nouveaux noeuds et éléments identiques à ceux passées
// en argument, nmail: donne le numéro du nouveau maillage créée, qui est donc a priori différent
// de celui de mail, idem pour le nom du maillage
// les frontières ne sont pas transmises ni calculées !
Maillage (map < string, int , std::less <string> > & lisNomMail
,int nmail, const string& nomDuMaillage, const Maillage& mail);
// DESTRUCTEUR :
~Maillage ();
// METHODES :
// lecture de maillages au travers des outils de la classe
// UtilLecture et def des references s'y rapportant
void LectureMaillage(UtilLecture * entreePrinc,LesReferences& lesRef);
// lecture et application des opérations d'affinages sur le maillage: ex:déplacement solide
void LectureEtApplicationAffinage(UtilLecture * entreePrinc,LesReferences& lesRef);
// ajout d'une liste de noeud à un maillage
// si le numéro de maillage associé au noeud est nul, il est remplacé par celui du maillage
// si le numéro de maillage est déjà existant et est différent ce celui de this, il y a
// création d'un nouveau noeud identique, avec le numéro this
// ajout éventuel d'une liste de référence de noeuds, si celle-ci est non-nulle
// il y a création de nouvelles ref correspondantes au numéro de maillage de this
// et ces références sont rajoutées à lesRef
void Ajout_de_Noeuds(const list <Noeud *> & taN,list <const Reference*>* lref=NULL,LesReferences* lesRef=NULL );
// ajout d'une liste d'éléments et de noeud à un maillage
// si le numéro de maillage associé à l'élément ou noeud est nul, il est remplacé par celui du maillage
// si le numéro de maillage est déjà existant et est différent ce celui de this, il y a
// création d'un nouvel item identique, avec le numéro this
// ajout éventuel d'une liste de références associées , si celle-ci est non-nulle
// il y a création de nouvelles ref correspondantes au numéro de maillage de this
// et ces références sont rajoutées à lesRef
// les noeuds qui sont associés aux éléments de taE, doivent faire partie : soit de taN, soit du maillage this
void Ajout_elements_et_noeuds(const list <Noeud *> & taN, const list <Element *> & taE,list <const Reference*>* lref,LesReferences* lesRef );
// affichage et definition interactive des commandes
// cas = 1: interactif complet
// cas = 2: entrée uniquement de noms de fichier
void Info_commande_Maillages(UtilLecture * entreePrinc,LesReferences& lesRef, int cas);
// Affiche les donnees du maillage
void Affiche () const ;
// Affiche les donnees du maillage dans un fichier
// dont le nom est construit à partir du nom du maillage
// au format ".her" et ".lis"
void Affiche_dans_her_lis(LesReferences &lesRef,Enum_dure temps);
//modification du maillage pour le restreindre aux seuls éléments de la référence passée en paramètre
// toutes les infos relatives à des éléments supprimés, sont également supprimés
void Restreint_sous_maillage(LesReferences* lesRef, string nom_ref);
// Surcharge de l'operateur = : realise l'egalite de deux maillages
// cependant le numéro de maillage et le nom de maillage n'est pas valide, il faut
// ensuite les définir
Maillage& operator= (Maillage& mail);
inline int Dimension () const
// Retourne la dimension
{ return dimension; };
// ramène la liste des problèmes physiques gérés par les éléments du maillage
inline const Tableau <Enum_ddl >& Ddl_representatifs_des_physiques()const
{return ddl_representatifs_des_physiques;};
// ramene la liste des degrés de liberté inconnus, associés aux pb
// physiques gérés par les éléments qui existent dans le maillage
// Si éléments mécaniques -> ddl Xi voir Vi et gamma_i
// Si éléments thermiques -> ddl de température
// Si éléments méca + éléments thermiques -> ddl Xi et température
// etc. en fonction des éléments qui existent dans le maillage
inline const Tableau <EnumElemTypeProblem >& Types_de_problemes() const
{return types_de_problemes;};
inline int Nombre_noeud_elt(int i) const
// Retourne le nombre de noeuds lies au ieme element
{ return tab_element(i)->Nombre_noeud(); };
inline int Nombre_noeud() const
// Retourne le nombre de noeuds du maillage
{ return tab_noeud.Taille(); };
inline int Nombre_element() const
// Retourne le nombre d'elements du maillage
{ return tab_element.Taille(); };
inline Tableau<Noeud *>& Tab_noeud()
// Retourne le tableau des noeuds
{ return tab_noeud; };
inline Tableau<Element *>& Tab_element()
// Retourne le tableau des elements
{ return tab_element; };
inline Noeud& Noeud_mail(int i)
// Retourne le ieme noeud Noeud du tableau tab_noeud
{ return *tab_noeud(i); };
inline Element& Element_mail(int i)
// Retourne le ieme element Element du tableau tab_element
{ return *tab_element(i); };
// idem mais en version constant
inline const Element& Element_mail_const(int i)
{ return *tab_element(i); };
// test si toutes les informations des maillages sont completes
// = true -> complet
// = false -> incomplet
bool Complet();
// ramene la demi largeur de bande en ddl et la largeur de bande
void Largeur_Bande(int& demi, int& total,const Nb_assemb& nb_casAssemb);
// test pour savoir si tous les coordonnées des noeuds d'un maillage sont imposé
// ramène 1 si tout est fixé, 0 sinon
int Tous_Xi_fixes(const Nb_assemb& casAss) const;
// calcule des normales aux noeuds: dans le cas d'éléments 1D ou 2D uniquement
// a priori le calcul s'effectue par une moyenne des normales des éléments qui
// entourent le noeud.
// init -> calcul des normales à t=0
// et ajout conteneur aux noeuds des normales à t = 0 et t
void InitNormaleAuxNoeuds();
// mise à jour -> mise à jour des normales à t
void MiseAjourNormaleAuxNoeuds();
// mise à jour -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t
// cette méthode est utile si on veut utiliser des normales à t pour une valeur
// particulière (transitoire) de la géométrie à tdt
// cf: l'algo non dyna par exempel
void MiseAjourNormaleAuxNoeuds_de_tdt_vers_T();
// creation des elements frontiere
void CreeElemFront();
// ramene un pointeur sur la liste des elements frontieres
inline LaLIST <Front>* ListFront() { return &listFrontiere;};
// ramene le tableau des noeuds de la frontière
Tableau<Noeud *>& Tab_noeud_front() {return tab_noeud_front; };
// ramene le nom du maillage
string NomDuMaillage() {return nomDuMaillage;};
// change le nom et le numéro du maillage
void ChangeNomNumeroMaillage(const string & nom,int num);
// ramène le numéro du noeud le plus proche du point donné à t=0,
int Noeud_le_plus_proche_0(const Coordonnee& M);
// idem à t
int Noeud_le_plus_proche_t(const Coordonnee& M);
// idem à tdt
int Noeud_le_plus_proche_tdt(const Coordonnee& M);
// ramène le maximum de variation de coordonnée entre t et tdt de tous les noeuds du maillage
double Max_var_dep_t_a_tdt() const;
// ramène le minimum de la distance entre deux noeuds de l'ensemble des éléments
double Min_dist2Noeud_des_elements(Enum_dure temps) const;
// transfert de grandeurs des points d'intégration aux noeuds
// 1- en entrée les type de ddl internes que l'on veut transférer
// idem pour les type évoluées et les types particuliers
// 2- en entrée: cas qui indique la méthode de transfert à utiliser
// =1 : les valeurs aux noeuds sont obtenue par moyennage des valeurs des pts d'integ les plus près
// des éléments qui entourent le noeud
// on décompose le processus en trois étapes pour éviter d'initialiser plusieurs fois lorque l'on refait à chaque fois
// le même transfert
// A) première étape def des conteneurs et c'est tout, la méthode peut donc être utilisée
// pour autre chose. tabQ: permet d'avoir plusieurs listes de TypeQuelconque
// en entrée: tabQ doit-être de dimension 2, donc pointe sur 2 listes, si un des pointeur
// est nulle on n'en tient pas compte
void AjoutConteneurAuNoeud(const List_io < Ddl_enum_etendu >& lienu
,const Tableau <List_io < TypeQuelconque > * >& tabQ);
// B) initialisation des updates sur les noeuds
void InitUpdateAuNoeud(const List_io < Ddl_enum_etendu >& lienu
,const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas);
// C) exécution du transfert
// transfert incrémental (pour un élément et tous les pt d'integ):
// transfert de ddl de tous les pt d'integ aux noeuds d'un éléments (on ajoute aux noeuds, on ne remplace pas)
// les ddl doivent déjà exister aux noeuds sinon erreur
// il doit s'agir du même type de répartition de pt d'integ pour toutes les grandeurs
void TransfertPtIntegAuNoeud(Element& ele,const List_io < Ddl_enum_etendu >& lietendu
,const Tableau <Tableau <double> > & tab_val,int cas)
{ele.TransfertAjoutAuNoeuds(lietendu,tab_val,cas);};
// idem pour des grandeurs quelconques, transfert de "tous" les points d'intégration en même temps
// ceci pour optimiser, les informations sont ici contenues dans les types quelconques
// liQ_travail: est une liste de travail qui sera utilisée dans le transfert
// - transfert de type quelconque des points d'intégrations (de tous) aux noeuds d'un éléments (on ajoute aux noeuds,
// - on ne remplace pas). Les types quelconques doivent déjà exister.
// - un tableau tab_liQ correspondent aux grandeurs quelconque pour tous les pt integ. tab_liQ(i) est associé au pt d'integ i
// - Toutes les listes sont identiques au niveau des descripteurs (types...) ce sont uniquement les valeurs numériques
// - c-a-dire les valeurs associées à TypeQuelconque::Grandeur qui sont différentes (elles sont associées à chaque pt d'integ)
// - liQ_travail: est une liste de travail qui sera utilisée dans le transfert
void TransfertPtIntegAuNoeud(Element& ele,const Tableau <List_io < TypeQuelconque > >& tab_liQ
,List_io < TypeQuelconque > & liQ_travail,int cas)
{ele.TransfertAjoutAuNoeuds(tab_liQ,liQ_travail,cas);};
// D) dernière étape: (par exemple calcul des moyennes en chaque noeuds)
// les résultats sont stockés aux noeuds
void FinTransfertPtIntegAuNoeud(const List_io < Ddl_enum_etendu >& lienu
,const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas);
// ..... cumul et moyenne de grandeurs venant des éléments vers les noeuds (exemple la pression appliquée) .....
// on décompose le processus en 4 étapes pour éviter d'initialiser plusieurs fois lorque l'on refait à chaque fois
// la même opération (typiquement à chaque incrément)
// on peut utiliser:
// A) AjoutConteneurAuNoeud : pour ajouter des conteneurs ad hoc aux noeuds
// B) InitUpdateAuNoeud: avant le cumul, initialise les conteneurs
// C) Accumul_aux_noeuds : balaie les éléments avec cumul aux noeuds
// D) MoyenneCompteurAuNoeud : effectue les moyennes aux noeuds
// accumulation aux noeuds de grandeurs venant des éléments vers leurs noeuds (exemple la pression appliquée)
// autres que celles aux pti classiques, mais directements disponibles
// le contenu du conteneur stockées dans liQ est utilisé en variable intermédiaire
void Accumul_aux_noeuds(const List_io < Ddl_enum_etendu >& lietendu
,List_io < TypeQuelconque > & liQ,int cas)
{int NBE=tab_element.Taille();
for (int i=1;i<=NBE;i++)
tab_element(i)->Accumul_aux_noeuds(lietendu,liQ,cas);
};
// fonctions utilitaires du même genre
// ajout sur le maillage d'un conteneur particulier quelconque
void AjoutConteneurAuNoeud(TypeQuelconque& tQ);
// ajout sur le maillage d'un ou plusieur ddl_enum_etendu comme conteneur
void AjoutConteneurAuNoeud(const List_io < Ddl_enum_etendu >& lienu);
// initialisation des updates de ddl_étendu uniquement sur les noeuds: on met à 0 les ddl_etendu correspondant,
// les compteurs, comptant le nombre de fois où les noeuds sont modifiés, sont mis à 0
void InitUpdateAuNoeud(const List_io < Ddl_enum_etendu >& lienu);
// idem pour un seul ddl_etendu
void InitUpdateAuNoeud(const Ddl_enum_etendu & enu);
// moyenne des valeurs aux noeuds (en fonction du nombre ou le noeud a été modifié)
void MoyenneCompteurAuNoeud(const Ddl_enum_etendu & enu);
// initialisation des coordonnées à t et tdt aux mêmes valeurs qu'à 0
// utile quand on veut utiliser les métriques pour un pb non couplés
void Init_Xi_t_et_tdt_de_0();
// def d'un conteneur pour deux numéros: elem et pti
class NBelemEtptInteg
{public: int nbElem; int nbPtInteg;
// surcharge de l'operator de lecture
friend istream & operator >> (istream & ent, NBelemEtptInteg & de)
{ ent >> de.nbElem >> de.nbPtInteg; return ent;};
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort , const NBelemEtptInteg & de)
{ sort << de.nbElem <<" " << de.nbPtInteg << " "; return sort;};
bool operator < (const NBelemEtptInteg& c) const; bool operator > (const NBelemEtptInteg& c) const;
bool operator == (const NBelemEtptInteg& c) const {return ((nbElem==c.nbElem)&&(nbPtInteg==c.nbPtInteg));};
bool operator != (const NBelemEtptInteg& c) const {return !((nbElem==c.nbElem)&&(nbPtInteg==c.nbPtInteg));};
};
// def d'un conteneur pour 3 numéros: elem, num face ou arete, et pti
class NBelemFAEtptInteg
{public: int nbElem; int nbFA; int nbPtInteg;
// surcharge de l'operator de lecture
friend istream & operator >> (istream & ent, NBelemFAEtptInteg & de)
{ ent >> de.nbElem >> de.nbFA >> de.nbPtInteg; return ent;};
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort , const NBelemFAEtptInteg & de)
{ sort << de.nbElem <<" "<< de.nbFA <<" " << de.nbPtInteg << " "; return sort;};
bool operator < (const NBelemFAEtptInteg& c) const; bool operator > (const NBelemFAEtptInteg& c) const;
bool operator == (const NBelemFAEtptInteg& c) const {return ((nbElem==c.nbElem)&&(nbFA==c.nbFA)&&(nbPtInteg==c.nbPtInteg));};
bool operator != (const NBelemFAEtptInteg& c) const {return !((nbElem==c.nbElem)&&(nbFA==c.nbFA)&&(nbPtInteg==c.nbPtInteg));};
};
// ramène le numéro de l'élément qui contiend un point donné et le numéro du point
// d'intégration le plus proche pour les ddl de la liste, (ddl spécifique à l'élément c'est-a-dire
// hors des ddl des noeuds de l'éléments)
// si pas de numéro d'élément ramène un numéro d'élément nulle
// si les numéros de point d'intégration ne sont pas identique pour l'ensemble
// des ddl, pb !!, le numéro du pt integ de retour est alors négatif
// enu_temps: dit si les coordonnées du point M sont à 0 ou t ou tdt
NBelemEtptInteg Element_le_plus_proche
(Enum_dure enu_temps,const List_io <Ddl_enum_etendu>& list_enu,const Coordonnee& M);
// ramène le numéro de l'élément dont le centre de gravité à t = enu_temps est le plus proche d'un point donné
// Le point peut être n'importe où, en particulier à l'extérieur de la matière
// si pb retour de null
const Element* Centre_de_Gravite_Element_le_plus_proche(Enum_dure enu_temps,const Coordonnee& M);
// ramène pour chaque noeud, la liste des éléments qui contiennent le noeud
// si le tableau n'existe pas, il est construit, sinon uniquement un retour
// et la miss à jour est uniquement faite lors de la création des frontières
const Tableau <List_io < Element* > >& Indice()
{if (indice.Taille() == 0) Calcul_indice();
return indice; };
//----- 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)
void Lecture_base_info(ifstream& ent,const int cas);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas);
// sortie du schemaXML: en fonction de enu
static void SchemaXML_Maillages(ofstream& sort,const Enum_IO_XML enu) ;
// ------ informations utiles par exemples pour la visualisation
// retourne les dimensions minis et maxi suivant les axes du repère
// absolu du maillage (en faite le calcul est fondé
// uniquement sur la position des noeuds du maillage
// le premier vecteur contient les minimums
// le deuxième vecteur contient les maximums
Tableau <Vecteur> Taille_boiteMail();
// --------- utilitaires de manipulation de maillage
// test pour savoir si le maillage contiend des éléments à interpolation linéaire
bool Contient_lineaire();
// test pour savoir si le maillage contiend des éléments à interpolation quadratique incomplète
bool Contient_quadratique_incomplet();
// transformation des éléments linéaires du maillage en quadratiques.
// les éléments linéaires sont supprimés,
// Important: dans la procédure de renumérotation, la routine modifie la numérotation initiale des noeuds !!
// il y a également création de référence adaptée au nouveau maillage en cohérence avec l'ancien maillage
void Transfo_lin_quadraIncomp(LesReferences &lesRef);
// transformation des éléments quadratiques incomplet du maillage en quadratiques complets.
// les éléments incomplets sont supprimée,
// Important: dans la procédure de renumérotation, la routine modifie la numérotation initiale des noeuds !!
// il y a également création de référence adaptée au nouveau maillage en cohérence avec l'ancien maillage
void Transfo_quadraIncomp_quadraComp(LesReferences &lesRef);
// relocalisation des points milieux des arrêtes des éléments quadratiques
void RelocPtMilieuMailleQuadra();
// définition interactive de listes de références
void CreationInteractiveListesRef(LesReferences* lesRef);
// modification de l'orientation d'éléments
void Modif_orientation_element(int cas_orientation,LesReferences* lesRef);
// Lecture et Collapse des éléments supperposés, c-a-d identiques, dans le cas où il en existe
void LectureEtCollapse_element_superpose(UtilLecture * entreePrinc,LesReferences* lesRef);
// Collapse des éléments supperposés, c-a-d identiques, dans le cas où il en existe
void Collapse_element_superpose(LesReferences* lesRef);
// Lecture et collapse de noeuds très proche: appartenant à des éléments différents
void LectureEtCollapse_noeuds_proches(UtilLecture * entreePrinc, LesReferences* lesRef);
// collapse de noeuds très proche: appartenant à des éléments différents
// rayon : donne la distance maxi entre les noeuds qui doivent être collapsé
void Collapse_noeuds_proches(double rayon, LesReferences* lesRef);
// Lecture et suppression d'elements à 2 noeuds, de distances très proches
void LectureEtSup_Elem_noeudsConfondu(UtilLecture * entreePrinc, LesReferences* lesRef);
// suppression d'elements à 2 noeuds, de distances très proches
// rayon : donne la distance maxi entre les noeuds
void Sup_Elem_noeudsConfondu(double rayon, LesReferences* lesRef);
// création d'éléments SFE en fonction d'éléments classiques
void CreationMaillageSFE();
// test pour savoir si le maillage est ok pour être transformée en sfe
bool OKPourTransSfe();
// lecture et suppression éventuelle des noeuds, non référencés par les éléments et les références
void LectureEtSuppressionNoeudNonReferencer(UtilLecture * entreePrinc,LesReferences& lesRef);
// uniquement suppression éventuelle des noeuds, non référencés par les éléments et les références
void SuppressionNoeudNonReferencer(LesReferences& lesRef);
// Affichage des noeuds, non référencés par les éléments
void AffichageNoeudNonReferencer();
// lecture et création éventuelle d'une ref sur les noeuds, non référencés par les éléments
void LectureEtCreationRefNoeudNonReferencer(UtilLecture * entreePrinc,LesReferences& lesRef);
// création éventuelle d'une référence sur les noeuds, non référencés par les éléments
void CreationRefNoeudNonReferencer(LesReferences& lesRef);
// vérification que toutes les références de noeuds, d'éléments, d'arêtes et de faces sont valides
// c-a-d se réfèrent à des éléments existants
void VerifReference(LesReferences& lesRef);
// lecture et renumérotation éventuelle des noeuds
void LectureEtRenumerotation(UtilLecture * entreePrinc,LesReferences& lesRef);
// renumérotation des noeuds du maillage, en fonction de conditions linéaires éventuelles
// ramène false si rien n'a changé (à cause d'un pb ou parce que la renumérotation n'est pas meilleure), vrai sinon
bool Renumerotation(LesReferences& lesRef,const Tableau <Tableau <Condilineaire> >& condCLL);
// création automatique des références globales de frontière si demandé dans le .info
void CreationRefFrontiere(UtilLecture * entreePrinc,LesReferences& lesRef);
// demande de création automatique des références globales de frontière
void CreationRefFrontiere(LesReferences& lesRef);
// force la mise à une valeur d'un ddl (ou de la liste de ddl fonction de la dimention) particulier, quelques soit son activité
// si fonction_de_la_dimension = true : c'est toute les ddl fct de la dimension qui sont mis à la valeur
void Force_Ddl_aux_noeuds_a_une_valeur(Enum_ddl enu, const double& val,Enum_dure temps, bool fonction_de_la_dimension);
// mise à zéro de dd_enum_etendu aux noeuds : force la mise à une valeur à 0
void Force_Ddl_etendu_aux_noeuds_a_zero(const Tableau<Ddl_enum_etendu>& tab_enu);
protected :
int idmail ; // numero de maillage
string nomDuMaillage;
// liste communes de tous les noms de maillages associée à un numéro
// sous forme d'un arbre pour faciliter la recherche
// cette liste n'est modifiée que par chaque maillage
map < string, int , std::less <string> >& listeNomMail;
int dimension; // dimension du maillage
Tableau<Noeud *> tab_noeud; // tableau des noeuds du maillage
Tableau<Element *> tab_element; // tableau des elements du maillage
// list des elements frontieres du maillage, c-a-d des frontières uniques
LaLIST <Front> listFrontiere;
// tableau des noeuds des éléments frontières
Tableau <Noeud *> tab_noeud_front;
// tableau utilitaire:
// indice(i) contient la liste des éléments qui contiennent le noeud i
Tableau <List_io < Element*> > indice;
// pour chaque élément "i" , mitoyen_de_chaque_element(i)(j) contient l'élément Front
// qui décrit la frontière "j" de l'élément et dedans, les éléments mitoyens de cette frontière
// appartenant à d'autres éléments (ce tableau est construit par la méthode : Mitoyen())
Tableau < Tableau <Front> > mitoyen_de_chaque_element;
// définie la liste des types de degrés de liberté inconnus, qui vont être calculés par la résolution des problèmes
// physiques gérés par les éléments qui existent dans le maillages
// Si éléments mécaniques -> ddl Xi voir Vi et gamma_i
// Si éléments thermiques -> ddl de température
// Si éléments méca + éléments thermiques -> ddl Xi et température
// etc. en fonction des éléments qui existent dans les maillages
// (généré à la lecture du maillage, ce qui permet d'optimiser la consultation par la suite)
Tableau <Enum_ddl > ddl_representatifs_des_physiques;
// idem au niveau des types de problèmes gérés par les éléments
Tableau <EnumElemTypeProblem > types_de_problemes;
//indicateur uniquement utilisé pour la destruction, par défaut est toujours vrai
// via la méthode Preparation_destruction_avec_conservation_noeuds_elements(), on peut le modifier
bool detruire_les_noeuds_et_elements;
// -- variables internes utilisées par Orientation_elements_mitoyens_recursif
// tab_sens_element(i) : = 1 au début, puis vaut -1 si le sens de l'élément i à été changé
Tableau <double> tab_sens_element; // pendant les différents appels de Orientation_elements_mitoyens_recursif
// - on définit un tableau d'indicateur, permettant de savoir si un élément a été traité ou pas
// une fois qu'un élément a été traité: a) on ne permet plus son changement de sens
// b) de plus dans le cas d'une suite d'appels récursif, il n'est plus retenue pour les nouvelles listes
Tableau <bool> ind_elem; // def et init à 0, c-à-d non traité
// -- fin variables internes utilisées par Orientation_elements_mitoyens_recursif
// METHODES PROTEGEES :
// cas particulier de destruction, sans suppression des noeuds et éléments
// l'utilisation de la méthode suivante, permet ensuite de supprimer le maillage
// tout en évitant la destruction des noeuds internes et éléments internes
// à utiliser avec précaution, intéressant si l'on veut créer un nouveau maillage
// avec les noeuds et éléments de ce maillage
void Preparation_destruction_avec_conservation_noeuds_elements()
{ detruire_les_noeuds_et_elements = false; };
// change le numéro de maillage
void Change_numero_maillage(int new_num);
// definition des elements mitoyens aux elements de frontiere
// à la fin du programme tous les éléments mitoyens sont stocké dant les éléments
// Front et non les éléments frontières qui eux sont supprimés
void MitoyenFront();
// création pour chaque noeud de la liste des éléments qui contiennent le noeud
void Calcul_indice();
// definition d'un stockage contenant tous les Front associés à toutes les frontières de tous les éléments
// puis définition des elements mitoyens à ces Front : deux éléments Front sont mitoyens
// s'ils correspondent à des Element différents, et si les frontières associées possèdent les mêmes noeuds
// toutes ces informations sont stockées dans : mitoyen_de_chaque_element (cf. sa description)
void Calcul_tous_les_front_et_leurs_mitoyens();
// dans le cas où les éléments frontières sont des lignes, on les ordonnes
// de manière à former une ligne continue
void OrdonancementDesLigne();
// lectures des infos pour le choix d'un élément
void Lecture_info_1element(UtilLecture * entreePrinc,int& num_elt,Enum_geom& id_geom
,Enum_interpol& id_interpol,EnumElemTypeProblem& id_typeProb
,string& discriminant);
// lecture des mouvements solides si nécessaire
void Lecture_des_mouvements_solides(UtilLecture * entreePrinc);
// une classe de travail qui sert pour pouvoir classer les noeuds par leur position géométrique initiale
// deux élément sont identiques si leur position initiale sont identique
// a >= b si : soit a.x >= b.x, ou a.x==b.x et a.y >= b.y, ou a.x==b.x et a.y == b.y et a.z >= b.z
class PosiEtNoeud
{ public:
Noeud * noe; // le noeud
Element * el; // l'élément auquel il est rattaché
// -------- constructeur ------------
PosiEtNoeud() : noe(NULL),el(NULL) {}; // constructeur par défaut
PosiEtNoeud(Noeud * no,Element * e) : noe(no),el(e) {}; // constructeur normal
PosiEtNoeud(const PosiEtNoeud& po) : noe(po.noe),el(po.el) {}; // constructeur de copie
//------ surcharges qui ne travaillent que sur la position --------
PosiEtNoeud& operator= (const PosiEtNoeud& po); // affectation
bool operator == (const PosiEtNoeud& po) const ; // test d'égalité
bool operator != (const PosiEtNoeud& po) const ; // test d'inégalité
bool operator < (const PosiEtNoeud& po) const ; // relation d'ordre
bool operator <= (const PosiEtNoeud& po) const ; // relation d'ordre
bool operator > (const PosiEtNoeud& po) const ; // relation d'ordre
bool operator >= (const PosiEtNoeud& po) const ; // relation d'ordre
};
// fonctions simples ayant pour but de bien repérer des opérations dangereuses
// affectation d'un noeud au maillage c-a-d au tableau de pointeur de noeud,
// a condition que la place ne soit pas déjà occupée sinon on change le numéro
// de noeud et on augmente le tableau
void Affectation_noeud (Noeud& noeud);
// affectation d'un element au maillage c-a-d au tableau de pointeur d'element,
// a condition que la place ne soit pas déjà occupée sinon on change le numéro
// de l'élément et on augmente le tableau
void Affectation_element (Element& element);
// Modifie le nombre de noeuds du maillage (N.B.: Fait appel
// a la methode Change_taille de la classe Tableau<Noeud>)
// les éléments supplémentaires ont un pointeur mis à Null
void Change_nb_noeud (int nouveau_nb);
// Modifie le nombre d'elements du maillage (N.B.: Fait appel
// a la methode Change_taille de la classe Tableau<Element>)
// les éléments supplémentaires ont un pointeur mis à Null
void Change_nb_element (int nouveau_nb);
// ** pour l'instant ne fonctionne que pour les éléments surfaces
// orientation automatique des éléments mitoyens, à l'élément num_elem, et ensuite
// récursivement à tous les éléments mitoyens des mitoyens jusqu'à ce que la chaine s'arrête
// L'ensemble des éléments est alors groupé dans une référence qui est construit à partir du numéro num_elem
// et qui est ajouté aux refs déjà existantes
// ensuite, le programme passe en revue les éléments restants, et regarde s'ils font parti
// d'un ensemble homogène orienté, si non, ramène la liste des éléments hors ensemble orienté
// *** ne concerne que les éléments surfaces, les autres sont ignorés
// ind_elem(i) : (tableau interne) indique si l'élément i a été traité (=true) ou non (=false)
// ind_elem: est pris en compte puis mis à jour par le programme, c-a-d que les nouveaux éléments orienté
// passe de false à true, par contre tous les éléments déjà à true, ne sont pas pris en compte dans le traitement
// angle_maxi : angle maximum entre deux éléments, au dessus duquel on considère qu'il y a une rupture de la mitoyenneté
// nom_ref : s'il est différent de "_", donne le nom de base voulu à la série de référence qui va être construite
// inverse : indique si l'on souhaite partir d'une orientation inverse de celle existante avant application de l'algo
// ceci pour l'élément de départ: au premier appel, l'opération est toujours possible, ensuite cela dépend
// si l'élément trouvé a déjà été traité ou pas
// recursiv : indique si l'on se situe dans une suite récursive d'appel de la méthode
// si oui, seule les éléments non déjà pris en compte dans les appels précédents, sont examiné
// c'est ind_elem qui permet de s'en assurer
// si non: cas par exemple d'un angle_maxi qui change, on réexamine tous les éléments, cependant
// la ré_orientation éventuelle n'est faite qu'une seule fois (toujours via ind_elem)
list <int> Orientation_elements_mitoyens_recursif(bool recursif,string& nom_ref,int num_elem
, LesReferences& lesRef,double& angle_maxi,bool inverse);
// méthode pour initialiser les différents tableaux utilisés par Orientation_elements_mitoyens_recursif
void Init_Orientation_elements_mitoyens_recursif();
// méthode pour orienter des éléments en fonction d'un rayon: AG, A étant un point donné, G étant le centre de
// gravité d'une facette
// A : coordonnée d'un point, si indic_G(i) est true, alors A(i) est remplacé par la coordonnée G(i) du centre
// de gravité de la facette
// zone_a_traiter: le nom de la référence des éléments a traiter
// inverse : si true, l'orientation des normales des facettes est identique à celles de AG, sinon c'est l'inverse
void Orientation_via_rayon(const Tableau <bool> & indic_G,const Coordonnee & A
,const string& zone_a_traiter, LesReferences& lesRef, bool inverse);
// ------- pour la définition interactive de liste de ref -------------
// def d'un conteneur pour deux numéros: nb element nb face
class NBelemEtFace {public: int nbElem; int nbFace;
bool operator < (const NBelemEtFace& c) const; bool operator > (const NBelemEtFace& c) const;
bool operator == (const NBelemEtFace& c) const {return ((nbElem==c.nbElem)&&(nbFace==c.nbFace));};
bool operator != (const NBelemEtFace& c) const {return !((nbElem==c.nbElem)&&(nbFace==c.nbFace));};
};
// def d'un conteneur pour deux numéros: nb element nb arête
class NBelemEtArete {public: int nbElem; int nbArete;
bool operator < (const NBelemEtArete& c) const; bool operator > (const NBelemEtArete& c) const;
bool operator == (const NBelemEtArete& c) const {return ((nbElem==c.nbElem)&&(nbArete==c.nbArete));};
bool operator != (const NBelemEtArete& c) const {return !((nbElem==c.nbElem)&&(nbArete==c.nbArete));};
};
// calcul des listes de références en fonction de la demande:
// list_nomReference: contient les types de refs que l'on veut
// list_methode: contient la ou les méthodes que l'on veut utiliser
// cas 1D
void CalculListRef_1D(list<string>& list_nomReference,LesReferences* lesRef,list<string>& list_methode
,const Enum_ddl & enu_ddl);
// cas 2D
void CalculListRef_2D(list<string>& list_nomReference,LesReferences* lesRef,list<string>& list_methode
,const Enum_ddl & enu_ddl);
// cas 3D
void CalculListRef_3D(list<string>& list_nomReference,LesReferences* lesRef,list<string>& list_methode
,const Enum_ddl & enu_ddl);
// les méthodes de bases
// fonction générique pour des condition PresDe
void PresDe(const list<string>& list_nomReference, list <Noeud *>& list_noeud_restant
,list <Element *>& list_element_restant,const Enum_ddl& enu_ddl
,list <NBelemEtptInteg>& list_elemPtin_restant,bool& premLpti
,list <NBelemEtFace>& list_elemFace_restant,bool& premLface
,list <NBelemEtArete>& list_elemArrete_restant,bool& premLarrete);
// fonction générique pour des condition "tout dedans"
void ToutDedans(const list<string>& list_nomReference, list <Noeud *>& list_noeud_restant
,list <Element *>& list_element_restant,const Enum_ddl& enu_ddl
,list <NBelemEtptInteg>& list_elemPtin_restant,bool& premLpti
,list <NBelemEtFace>& list_elemFace_restant,bool& premLface
,list <NBelemEtArete>& list_elemArrete_restant,bool& premLarrete);
// constitution des références
void EnregRef(const list<string>& list_nomReference,list <Noeud *>& list_noeud_restant
,list <NBelemEtptInteg>& list_elemPtin_restant,list <Element *>& list_element_restant
,list <NBelemEtFace>& list_elemFace_restant,list <NBelemEtArete>& list_elemArrete_restant
,LesReferences* lesRef);
// définition des fonctions conditions
// def de data internes qui servent pour les fonctions init et exe: dimensionnées dans init, utilisé dans exe
// donc: init et exe doivent être utilisé absolument à suivre
Tableau <Coordonnee> t_poi;
Tableau <Droite> t_droit;
Tableau <double> t_para;
Tableau <Plan> t_plan;
Tableau <Sphere> t_sphere;
Tableau <Cylindre> t_cylindre;
Tableau <Cercle> t_cercle;
// cas de croisement avec des références existantes: def de variables de passage pour InRef et OutRef
// les pointeurs qui suivent ne servent pas à créer des refs, mais uniquement a récupérer les adresses
list <const Reference*> list_refIn;
list <const Reference*> list_refOut;
LesReferences* lesRefin; // variable utilisée uniquement pour le passage d'info à
// ,InitInRef(), ExeInRef (), InitOutRef(), ExeOutRef()
// tout d'abord les pointeurs de fonctions en cours
// - pour les conditions Presde
// acquisition interactive des paramètres de la condition
void (Maillage::*initConditionPresDe) (double& dist);
// exécution de la condition : ramène true si ok, false sinon
bool (Maillage::*ExeConditionPresDe) (const double& dist,const Coordonnee& M)const;
// - pour les condition ToutDedans
// acquisition interactive des paramètres de la condition
void (Maillage::*initConditionToutDedans) ();
// exécution de la condition : ramène true si ok, false sinon
bool (Maillage::*ExeConditionToutDedans) (const Tableau <Coordonnee> & tab_M)const;
// recherche près d'un point
// def interactive du point et de la distance
void InitPresPoint(double& dist);
// exécution de la condition
bool ExePresPoint(const double& dist,const Coordonnee& M) const;
// recherche d'un coté d'un point (en 1D)
void InitCotePoint();
// ramène true si tous les points sont du même coté que t_poi(1)
bool ExeCotePoint(const Tableau <Coordonnee> & t_M)const;
// recherche entre deux points (1D)
void InitEntrePoint();
// ramène true si tous les points sont entre t_poi(1) et t_poi(2)
bool ExeEntrePoint(const Tableau <Coordonnee> & t_M)const;
// recherche entre deux points (1D) _avec_distance
void InitEntrePoint_avec_distance();
// ramène true si tous les points sont entre t_poi(1) et t_poi(2)
bool ExeEntrePoint_avec_distance(const Tableau <Coordonnee> & t_M)const;
// recherche près d'une ligne
void InitPresLigne(double& dist);
bool ExePresLigne(const double& dist,const Coordonnee& M)const;
// dans le cas particulier d'une ligne, on peut ordonner certaines listes résultantes / à la lignes
// il s'agit des noeuds et des pt d'integ: on les ordonnes par rapport à leurs projections sur la lignes
void InitOrdonneLigne();
void OrdonneLigne(list <Noeud *>& list_noeud_restant,list <NBelemEtptInteg>& list_elemPtin_restant
,const Enum_ddl& enu_ddl);
// recherche près d'un cercle
void InitPresCercle(double& dist);
bool ExePresCercle(const double& dist,const Coordonnee& M)const;
// recherche près d'un plan
void InitPresPlan(double& dist);
bool ExePresPlan(const double& dist,const Coordonnee& M)const;
// recherche près d'un cylindre
void InitPresCylindre(double& dist);
bool ExePresCylindre(const double& dist,const Coordonnee& M)const;
// recherche près d'une sphere
void InitPresSphere(double& dist);
bool ExePresSphere(const double& dist,const Coordonnee& M)const;
// recherche d'un coté d'un plan
void InitCotePlan();
// ramène true si tous les points sont du même coté que t_poi(1) du plan
bool ExeCotePlan(const Tableau <Coordonnee> & t_M)const;
// condition entre plans //
void InitEntrePlan();
// ramène true si tous les points sont entre les deux plans
bool ExeEntrePlan(const Tableau <Coordonnee> & t_M)const;
// condition entre plans _avec_distance //
void InitEntrePlan_avec_distance();
// ramène true si tous les points sont entre les deux plans
bool ExeEntrePlan_avec_distance(const Tableau <Coordonnee> & t_M)const;
// condition dans ou dehors un cylindre
void InitDansCylindre();
// ramène true si tous les points sont dans le cylindre
bool ExeDansCylindre(const Tableau <Coordonnee> & t_M)const;
// ramène true si tous les points sont à l'extérieur du cylindre
bool ExeOutCylindre(const Tableau <Coordonnee> & t_M)const;
// condition entre deux cylindre
void InitEntreCylindre();
// ramène true si tous les points sont entre les deux cylindres
bool ExeEntreCylindre(const Tableau <Coordonnee> & t_M)const;
// condition dans ou dehors d'une sphére
void InitDansSphere();
// ramène true si tous les points sont dans la sphère
bool ExeDansSphere(const Tableau <Coordonnee> & t_M)const;
// ramène true si tous les points sont à l'extérieur de la sphère
bool ExeOutSpheres(const Tableau <Coordonnee> & t_M)const;
// condition entre deux spheres concentriques
void InitEntreSpheres();
// ramène true si tous les points sont entre les deux sphères
bool ExeEntreSpheres(const Tableau <Coordonnee> & t_M)const;
// condition du même coté d'une droite (en 2D seulement)
void InitCoteDroite();
// ramène true si tous les points sont du même coté que t_poi(1) de la droite (en 2D uniquement)
bool ExeCoteDroite(const Tableau <Coordonnee> & t_M)const;
// condition entre 2 droites (en 2D seulement)
void InitEntreDroite();
// ramène true si tous les points sont entre les 2 droites (en 2D uniquement)
bool ExeEntreDroite(const Tableau <Coordonnee> & t_M)const;
// condition entre 2 droites (en 2D seulement) _avec_distance
void InitEntreDroite_avec_distance();
// ramène true si tous les points sont entre les 2 droites (en 2D uniquement)
bool ExeEntreDroite_avec_distance(const Tableau <Coordonnee> & t_M)const;
// condition dans ou dehors un cercle (en 2D seulement)
void InitDansCercle();
// ramène true si tous les points sont dans le cercle
bool ExeDansCercle(const Tableau <Coordonnee> & t_M)const;
// ramène true si tous les points sont à l'extérieur du cercle
bool ExeOutCercle(const Tableau <Coordonnee> & t_M)const;
// condition entre cercles concentriques (en 2D seulement)
void InitEntreCercles();
// ramène true si tous les points sont entre les deux cercles concentriques
bool ExeEntreCercles (const Tableau <Coordonnee> & t_M)const;
// acquisition d'un plan
Plan Acquisition_interactive_plan();
// acquisition d'un point
Coordonnee Acquisition_interactive_point();
// acquisition d'une droite
Droite Acquisition_interactive_droite();
// acquisition d'un vecteur=direction
Coordonnee Acquisition_interactive_vecteur();
// condition d'appartenance à une référence existante
void InitInRef();
// condition d'exclusion à une référence existante
void InitOutRef();
// ---- mise en place de la condition d'appartenance ou d'exclusion à des références existantes
// contrairement aux autres conditions, cette condition est prise en compte au moment de la création finale
// de la référence dans la méthode : EnregRef, via les méthodes du 2)
// 1) une fonction qui ne fait rien, mais est là pour que le tout fonctionne normalement
bool Exe_In_out_avecRefExistantes(const Tableau <Coordonnee> & t_M)const; // ne fait rien
// 2) fonctions qui réellement font quelque chose: utilisées dans la méthode EnregRef
void Exe_In_out_avecRefExistantes_N(list <Noeud *>& list_noeud_restant);
void Exe_In_out_avecRefExistantes_E(list <Element *>& list_element_restant);
void Exe_In_out_avecRefExistantes_G(list <NBelemEtptInteg>& list_elemPtin_restant);
void Exe_In_out_avecRefExistantes_F(list <NBelemEtFace>& list_elemFace_restant);
void Exe_In_out_avecRefExistantes_A(list <NBelemEtArete>& list_elemArrete_restant);
// void InterOuDiff_avecRefExistantes(const Tableau <Coordonnee> & t_M)const;
//-------------------- méthodes particulières pour l'optimisation de largeur de bande ------------------------
// une classe intermédiaire pour pouvoir classer les noeuds en fonction du degré
class Noeud_degre
{ public: Noeud* noe; int degre;
Noeud_degre (): noe(NULL), degre(0) {};
Noeud_degre (Noeud* no,int deg): noe(no),degre(deg) {};
Noeud_degre (const Noeud_degre& no ): noe(no.noe), degre(no.degre) {};
~Noeud_degre() {};
bool operator > (const Noeud_degre& a) const { return (this->degre > a.degre);};
bool operator >= (const Noeud_degre& a) const { return (this->degre >= a.degre);};
bool operator < (const Noeud_degre& a) const { return (this->degre < a.degre);};
bool operator <= (const Noeud_degre& a) const { return (this->degre <= a.degre);};
Noeud_degre& operator= (const Noeud_degre& de) { degre = de.degre; noe = de.noe; return (*this);};
};
// méthode static: c-a-d indépendante des données du maillage (elle est générale)
// calcul du point de départ, en fonction de conditions linéaires éventuelles
// il y a également calcul des voisins et de la descendance du noeud de retour
// s'il y a un pb, calcul_ok en retour est false
static Noeud* Point_de_depart(const Tableau<Element *>& tab_elem
,const Tableau<Noeud *>& tab_noe
,const Tableau <Tableau <Noeud*> *> tt_noeud_front
,Tableau < LaLIST_io <Noeud* > >& t_voisin
, list < list < Noeud_degre > > & lis_descent
,const Tableau <Tableau <Condilineaire> >& condCLL,bool& calcul_ok);
// méthode static: c-a-d indépendante des données du maillage (elle est générale)
// calcul des voisins de tous les noeuds du maillage en fonction des éléments et de conditions
// linéaires éventuelles,
// en entrée/sortie t_voisin
// restriction: il faut que tab_noe contienne tous les noeuds référencés dans tab_elem et tt_t_condCLL
// s'il y a un pb, calcul_ok en retour est false
static Tableau < LaLIST_io <Noeud* > >& Voisins(const Tableau<Element *>& tab_elem
,const Tableau<Noeud *>& tab_noe
,Tableau < LaLIST_io <Noeud* > >& t_voisin
,const Tableau <Tableau <Condilineaire> >& t_t_condCLL,bool& calcul_ok);
// méthode static: c-a-d indépendante des données du maillage (elle est générale)
// calcul de la descendance d'un noeud noeu,
// on considère que les voisins sont dèjà correctement définis
// en entrée la liste qui est modifiée en interne et retournée en sortie
// le premier élément de la liste c'est la dernière descendance
// s'il y a un pb, calcul_ok en retour est false
static list < list < Noeud_degre > > & Descendance (const int& taille_tabnoeud
,Noeud * noeu, Tableau < LaLIST_io <Noeud* > >& t_voisin
, list < list < Noeud_degre > > & lient,bool& calcul_ok);
// méthode static: c-a-d indépendante des données du maillage (elle est générale)
// algorithme de Cuthill Mac Kee directe
// noeu : le noeud de départ
// lis_descent : les descendants de noeu, qui va être modifié dans le processus
// ramène une nouvelle numérotation (mais les numéros internes des noeuds ne sont pas changé
static Tableau <Noeud* > Cuthill_Mac_Kee(const int& taille_tabnoeud,Noeud * noeu
,Tableau < LaLIST_io <Noeud* > >& t_voisin
, list < list < Noeud_degre > >& lis_descent);
// méthode static: c-a-d indépendante des données du maillage (elle est générale)
// calcul de la largeur de bande en noeuds
static int LargeurBandeEnNoeuds(const Tableau<Element *>& tab_elem);
// on s'occupe de mettre à jour les types de pb et les ddl types associés
void Mise_a_jour_type_pb_type_associe_ddl();
};
/// @} // end of group
#endif

1783
Maillage/Maillage2.cc Normal file
View file

File diff suppressed because it is too large Load diff

3331
Maillage/Maillage3.cc Normal file
View file

File diff suppressed because it is too large Load diff

1864
Maillage/Noeud.cc Normal file
View file

File diff suppressed because it is too large Load diff

860
Maillage/Noeud.h Normal file
View file

@ -0,0 +1,860 @@
// FICHIER : Noeud.h
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* Une instance de la classe Noeud est definie a partir d'un numero d'identification
* et du tableau de connexite des degres de liberte lies au noeud. Trois instances
* de la classe Coordonnee sont aussi associes a la classe Noeud (coordonnees initiales,
* aux instants t et t+dt).
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
// Une instance de la classe Noeud est definie a partir d'un numero d'identification
// et du tableau de connexite des degres de liberte lies au noeud. Trois instances
// de la classe Coordonnee sont aussi associes a la classe Noeud (coordonnees initiales,
// aux instants t et t+dt).
#ifndef NOEUD_H
#define NOEUD_H
#include <iostream>
#include "Coordonnee.h"
#include "Ddl.h"
#include "Tableau_T.h"
#include "ParaGlob.h"
#include "Vecteur.h"
#include "Tenseur.h"
#include "List_io.h"
#include "EnumTypeGrandeur.h"
#include "MathUtil.h"
#include "TypeQuelconque.h"
#include "Ddl_etendu.h"
#include "Enum_liaison_noeud.h"
/// @addtogroup Les_Maillages
/// @{
///
//------------------------------------------------------------------
//! Posi_ddl_noeud: un conteneur qui associe numéro de noeud, de maillage, et enu ddl
//------------------------------------------------------------------
/// \author Gérard Rio
/// \version 1.0
/// \date 23/01/97
// --------- class de stockage -----
class Posi_ddl_noeud
{ // surcharge lecture écriture
friend istream & operator >> (istream &, Posi_ddl_noeud &);
friend ostream & operator << (ostream &, const Posi_ddl_noeud &);
public :
// constructeurs
Posi_ddl_noeud () : nb_maillage(-1),nb_noeud(-1),enu(NU_DDL) {};
Posi_ddl_noeud (int aa, Enum_ddl enuu,int bb) :
nb_maillage(aa),nb_noeud(bb),enu(enuu) {};
Posi_ddl_noeud (const Posi_ddl_noeud & a):
nb_maillage(a.nb_maillage),nb_noeud(a.nb_noeud),enu(a.enu) {};
// opérateur
Posi_ddl_noeud& operator = ( const Posi_ddl_noeud & a)
{nb_maillage=a.nb_maillage;nb_noeud=a.nb_noeud;enu=a.enu; return *this;};
bool operator == ( const Posi_ddl_noeud & a)
{ if((nb_maillage==a.nb_maillage) && (nb_noeud==a.nb_noeud)
&& (enu==a.enu)) return true; else return false; };
bool operator != ( const Posi_ddl_noeud & a)
{ if((*this) == a) return false; else return true; };
// Affiche les donnees liees au noeud
void Affiche (ofstream& sort) const;
// récup des données en lecture écriture
int& Nb_maillage() {return nb_maillage;};
int& Nb_noeud() {return nb_noeud;};
Enum_ddl& Enu() {return enu;};
// récup des données en lecture uniquement
const int& Const_Nb_maillage() const {return nb_maillage;};
const int& Const_Nb_noeud() const {return nb_noeud;};
const Enum_ddl& Const_Enu() const {return enu;};
protected:
// données
int nb_maillage; // le numéro du maillage
int nb_noeud; // le numéro du noeud
Enum_ddl enu; // l'identifieur du ddl
};
/// @} // end of group
/// @addtogroup Les_Maillages
/// @{
///
//------------------------------------------------------------------
//! Noeud: un noeud
//------------------------------------------------------------------
/// \author Gérard Rio
/// \version 1.0
/// \date 23/01/97
class Noeud
{
// surcharge de l'operator de lecture, avec typage
friend istream & operator >> (istream &, Noeud &);
// surcharge de l'operator d'ecriture avec typage
friend ostream & operator << (ostream &, const Noeud &);
public :
// CONSTRUCTEURS :
// IMPORTANT!!! : l'ordre de succession des ddl doit etre conforme
// aux infos de l'enumeration (cf enum_ddl)
// Constructeur par defaut
Noeud (int num_id=-3,int num_maill=0);
// Constructeur fonction d'un numero d'identification et de la
// dimension de l'espace du probleme et du nb de maillage
Noeud (int num_id,int dimension,int num_maill);
// Constructeur fonction d'un numero d'identification et des coordonnees
// initiales et du nb de maillage
Noeud (int num_id,const Coordonnee& c0,int num_Mail);
// Constructeur fonction d'un numero d'identification, des coordonnees
// initiales et du tableau des degres de liberte, et du nb de maillage
// les ddl t=0 et t sont initialises avec les valeurs du tableaux
// par defaut les tableaux de ddl a 0 et t sont initialises mais pas
// a t+dt,
Noeud (int num_id,const Coordonnee& c0,const Tableau<Ddl>& tab,int num_Mail);
// Constructeur fonction d'un numero d'identification, des coordonnees
// initiales, a un instant t, et du tableau des degres de liberte, et du nb de maillage
// 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
Noeud (int num_id,const Coordonnee& c0,const Coordonnee& c1,const Tableau<Ddl>& tab,int num_Mail);
// Constructeur fonction d'un numero d'identification, de trois instances
// de Coordonnee et du tableau des degres de liberte, et du nb de maillage
Noeud (int num_id,const Coordonnee& c0,const Coordonnee& c1,const Coordonnee& c2,
const Tableau<Ddl>& tab,int num_Mail);
// Constructeur de copie
Noeud (const Noeud& nd);
// DESTRUCTEUR :
~Noeud ();
// METHODES :
// Affiche à l'ecran les donnees liees au noeud
// le niveau différent de 0 permet d'accèder à plus d'info
void Affiche(int niveau=0) const;
// Affiche dans sort les donnees liees au noeud
void Affiche(ofstream& sort) const;
inline void Change_num_noeud(int nouveau_num)
// Modifie le numero d'identification du noeud
// ATTENTION : Les modifications liees au changement de numero du noeud
// sont a la charge de l'utilisateur.
{ num_noeud=nouveau_num; };
inline void Change_num_Mail(int nouveau_num)
// Modifie le numero de maillage du noeud
{ num_Mail=nouveau_num; };
// récup du type de liaison entre noeud éventuel
// pour le cas d'assemblage nb_assemb
inline Enum_liaison_noeud Enu_liaison(int nb_assemb) const
{if (tab_enu_liaison != NULL) return (*tab_enu_liaison)(nb_assemb);
else return PAS_LIER;};
// récup d'un pointeur de tableau des ddl affectés par une liaison entre noeud
// pour le cas d'assemblage nb_assemb, NULL s'il n'y en a pas
inline const Tableau <Posi_ddl_noeud >* Ddl_Noeud_lier(int nb_assemb) const
{if (tab_ddl_lier != NULL) return &((*tab_ddl_lier)(nb_assemb));
else return NULL; };
// modification du type de laison entre noeud éventuel avec init des tableaux de liaison
// pour le cas d'assemblage nb_assemb
void Change_Enu_liason(int nb_assemb, Enum_liaison_noeud enu_liai
,const Tableau <Posi_ddl_noeud>& tab__lier);
// suppression de tous les liaisons noeuds
void Suppression_tous_liaisons_noeuds();
// Modifie les valeurs des coordonnees coord0
inline void Change_coord0(const Coordonnee& nouveau_coord0)
{ *coord0=nouveau_coord0;};
// 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 Insert_coord1(const Coordonnee& nouveau_coord1);
// 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 Insert_coord1();
// Modifie les valeurs des coordonnees coord1
void Change_coord1(const Coordonnee& nouveau_coord1);
// Modifie les valeurs des coordonnees coord2
inline void Change_coord2(const Coordonnee& nouveau_coord2)
{ *coord2=nouveau_coord2; };
// Modifie les valeurs des coordonnees coord2 par l'ajout d'un delta
inline void Ajout_coord2(const Coordonnee& delta_coord2)
{ *coord2=*coord2+delta_coord2; };
inline const Coordonnee& Coord0() const
// Retourne les coordonnees initiales du noeud
{ return *coord0; };
// test si les coordonnées à t=0 existent
inline bool ExisteCoord0() const
{ if (coord0 == NULL) return false; else return true;};
// Retourne les coordonnees coord1 du noeud
// uniquement pour la lecture
inline Coordonnee Coord1() const
{ int nbcoo = coord1.Taille();
Coordonnee coo(nbcoo);
for (int i=1;i<=nbcoo;i++)
coo(i) = *(coord1(i));
return coo;
};
// test si les coordonnées à t existent
inline bool ExisteCoord1() const
{ if (coord1.Taille() == 0) return false; else return true;};
// Retourne les coordonnees coord2 du noeud
inline const Coordonnee& Coord2() const
{ return *coord2; };
// retourne la valeur absolu du maximum de variation de coordonnée entre t et tdt
inline double Max_var_coor_t_a_tdt() const
{ double ret=0.;
if (ExisteCoord2() && ExisteCoord1())
{int nbcoo=coord2->Dimension();
for (int i=1;i<=nbcoo;i++) ret = MaX(Dabs((*coord2)(i) - *(coord1(i))),ret);
};
// sinon cela veut dire que le maillage n'a pas bougé (cas d'un solide fixe)
return ret;
};
// test si les coordonnées à tdt existent
inline bool ExisteCoord2() const
{ if (coord2 == NULL) return false; else return true;};
// Retourne le nombre de tous les degres de liberte du noeud
// qu'ils soient actifs ou non, fixes ou non
inline int Nombre_ddl() const
{ return tab_ddl.Taille(); };
// Retourne le nombre de variables degres de liberte du noeud
// qui sont actuellement actives
inline int Nombre_var_ddl_actives() const
{ return tab_var_actives.Taille();};
// Retourne le nombre de variables degres de liberte du noeud
// qui sont actives pour un cas d'assemblage donné.
// (ces ddl peuvent ne pas être actuellement actif !!)
inline int NB_ddl_actif_casAssemb (int nb_assemb) const
{ Tableau <int >& tib = (*t_enum_s(nb_assemb));
return (tib(tib.Taille()));};
// 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 Nombre_var_ddl_actives (Enum_ddl en) const ;
// retourne la liste de tous les types de ddl actuellement utilisé
// par le noeud (actif ou non)
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
List_io <Enum_ddl> Les_type_de_ddl(bool absolue);
// retourne la liste de tous les Ddl_enum_etendu disponibles
List_io <Ddl_enum_etendu> Les_type_de_ddl_etendu(bool absolue);
// retourne la liste de tous les TypeQuelconque disponibles
List_io <TypeQuelconque> Les_TypeQuelconque(bool absolue);
// 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> Valeur_multi_et_Tensorielle
(const List_io <Ddl_enum_etendu>& li_enu_scal,List_io <TypeQuelconque >& li_quelc) const;
// Retourne le numero d'identification du noeud
inline int Num_noeud() const
{ return num_noeud; };
// Retourne le numero de maillage auquel appartiend le noeud
inline int Num_Mail() const
{ return num_Mail; };
// Retourne la dimension des coordonnées
inline int Dimension() const
{ return coord0->Dimension(); };
// surcharge de l'affectation entre deux noeuds
// attention, le pointeur d'assemblage de this est identique a celui de n
// il faut donc l'updater pour pouvoir l'utiliser!!
Noeud& operator= (const Noeud& n);
// acces en lecture au pointeur de position pour l'assemblage
// i : donne le numéro du cas d'assemblage associé
inline int PosiAssemb(int i ) const
{ return posiAssemb(i);};
// initialisation d'un ou de plusieurs nouveau cas d'assemblage
void InitNouveauCasAssemb(int nb_cas);
// 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 Enreg_ordre_variable_ddl_actives(int nb_assemb);
// position d'un ddl par rapport à un cas d'assemblage donné (de 1 à ..)
// il n'y a pas de vérification que le ddl en question est actif ou pas
// cette fonction ne peut être utilisé, que après l'utilisation
// de la fonction Enreg_ordre_variable_ddl_actives
// si l'énuméré n'existe pas dans la liste des ddl actif du cas d'assemblage
// on retourne -1
inline int Position_ddl(Enum_ddl enu, int nb_assemb) const
{ int pointe = (*(t_enum_s(nb_assemb)))(enu);
if (pointe == 0) return -1; else return pointe; }
// modification du pointeur de position du noeud pour l'assemblage
// i : donne le numéro du cas d'assemblage associé
inline void ChangePosiAssemb(int a,int i )
{ posiAssemb(i) = a;};
// ramène le pointeur d'assemblage pour un ddl donné, et un cas d'assemblage
// le résultat correspond à la position globale d'assemblage du noeud +
// la position du ddl dans la liste des ddl actifs du cas d'assemblage
// si l'énuméré ne correspond pas à un ddl actif du cas d'assemblage
// on retourne -1, dans le cas ok, c'est un nombre de 1 à ...
inline int Pointeur_assemblage(Enum_ddl enu, int nb_assemb) const
{ int pointe = (*(t_enum_s(nb_assemb)))(enu);
if (pointe == 0) return -1;
return pointe + posiAssemb(nb_assemb); };
// le noeud peut contenir éventuellement une base rattachée
// récupération de la base, si le pointeur en retour est null
// cela signifie que la base n'existe pas
// a) en constant, la base actuelle
const BaseB* Const_BaseB_Noeud() const {return baseB;};
// b) en constant, la base à t
const BaseB* Const_BaseB_Noeud_t() const {return baseB_t;};
// c) en constant, la base initiale
const BaseB* Const_BaseB_Noeud_0() const {return baseB_0;};
// d) en lecture écriture, la base actuelle
BaseB* BaseB_Noeud() const {return baseB;};
// e) en lecture écriture, la base à t
BaseB* BaseB_Noeud_t() const {return baseB_t;};
// f) en lecture écriture, la base à 0
BaseB* BaseB_Noeud_0() const {return baseB_0;};
// test si le noeud est complet
// = 1 tout est ok, =0 element incomplet
int TestComplet() const;
// ajout de ddl
// 1) s'il n'y a pas de ddl il y a initialisation
// 2) si les ddl existent deja, on l'égalise au ddl passé en para
// 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 PlusDdl(Ddl& a);
// 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 PlusTabDdl(Tableau<Ddl>& ta);
// ajout du tableau de ddl d'un autre noeud
void PlusTabDdl(const Noeud & noe);
// modification du blocage ou non d'un ddl
inline void Change_fixe(Enum_ddl en,bool val)
{ tab_ddl((*pos_enum)(en)).Change_fixe(val); };
inline void Change_fixe(int nb,bool val)
{ tab_ddl(nb).Change_fixe(val); };
// test pour savoir si le ddl est fixé ou pas
inline bool Ddl_fixe(Enum_ddl en) const
{ return tab_ddl((*pos_enum)(en)).Fixe();};
// test pour savoir si le ddl est SURFIXE ou SOUSLIBRE
// (c-a-d plusieurs fois fixé ou libre à la suite)
inline bool Ddl_sous_ou_sur_fixe(Enum_ddl en) const
{ return tab_ddl((*pos_enum)(en)).SousSurFixe();};
// remise à normal si le ddl est en souslibre ou surfixe
// s'il est en souslibre il passe en libre et s'il est en surfixe il passe en fixe
inline void Retour_a_la_normal_sur_ou_sous_fixe(Enum_ddl en)
{ tab_ddl((*pos_enum)(en)).Retour_normal_sur_ou_sous_fixe();};
// modification du statut d'un ddl
// si est inconnu, aucune action
void Met_hors_service(Enum_ddl en);
void Met_en_service(Enum_ddl en);
// modification du statut d'un tableau de ddl
// si un des elements du tableau est inconnu, aucune action
void Met_hors_service(const Tableau<Enum_ddl>& taben);
void Met_en_service(const Tableau<Enum_ddl>& taben);
// 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 Met_hors_service();
void Met_en_service();
// idem mais restreint uniquement aux ddl (pas les données)
void Met_hors_service_ddl();
void Met_en_service_ddl();
// test si un ddl est en service ou pas
bool En_service (Enum_ddl en) const { return tab_ddl((*pos_enum)(en)).Service();};
// test si un ddl est une variable ou pas
bool UneVariable(Enum_ddl en) const { return tab_ddl((*pos_enum)(en)).UneVariable();};
// changement du statut de variable à donnée d'un ddl
void ChangeVariable_a_Donnee(Enum_ddl en)
{ tab_ddl((*pos_enum)(en)).ChangeVariable_a_Donnee();MiseAjourActif();};
// changement du statut de donnée à variable d'un ddl
void ChangeDonnee_a_Variable(Enum_ddl en)
{ tab_ddl((*pos_enum)(en)).ChangeDonnee_a_Variable();MiseAjourActif();};
// changement du statut de variable à donnée pour un tableau d'enum de ddl
void ChangeVariable_a_Donnee(const Tableau<Enum_ddl>& taben);
// changement du statut de donnée à variable pour un tableau d'enum de ddl
void ChangeDonnee_a_Variable(const Tableau<Enum_ddl>& taben);
// 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 ChangeToutesLesConditions(const Tableau<Ddl>& ta);
// 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 ChangeStatut(int cas,Enum_ddl enuta);
// changement de statu des ddl d'une combinaison, (cf. Enum_ddl)
// les ddl de la combinaison, prennent le même statut que celui de enuta
// cas est la combinaison,
void ChangeStatut(int cas,Enum_boolddl enubold);
// -------- manipulation de ddl identifié par un énuméré ------
// *****!!!!!***** attention il n'y a pas vérification de l'existence
// de ce type énuméré dans des ddl du noeud
// change la valeur du ddl identifie par en ,
inline void Change_val_0(Enum_ddl en,double val) // t=0
{ tab_0((*pos_enum)(en)) = val; };
inline void Change_val_t(Enum_ddl en,double val) // t=t
{ tab_ddl((*pos_enum)(en)).Valeur() = val;};
inline void Change_val_tdt(Enum_ddl en,double val) // t=tdt
{ tab_tdt((*pos_enum)(en)) = val;};
// incremente la valeur du ddl identifie par en ,
inline void Ajout_val_0(Enum_ddl en,double val) // t=0
{ tab_0((*pos_enum)(en)) += val; };
inline void Ajout_val_t(Enum_ddl en,double val) // t=t
{ tab_ddl((*pos_enum)(en)).Valeur() += val;};
inline void Ajout_val_tdt(Enum_ddl en,double val) // t=tdt
{ tab_tdt((*pos_enum)(en)) += val;};
// retourne la valeur du ddl identifie par en
inline double Valeur_0(Enum_ddl en) const // t=0
{ return tab_0((*pos_enum)(en)); };
inline double Valeur_t(Enum_ddl en) const // t=t
{ return tab_ddl((*pos_enum)(en)).Valeur();};
inline double Valeur_tdt(Enum_ddl en) const // t=tdt
{ return tab_tdt((*pos_enum)(en));};
// Retourne le ddl à t=0 identifie par enu, en lecture
inline Ddl Ddl_noeud_0(Enum_ddl enu) const
{return Ddl(enu,tab_0((*pos_enum)(enu)),tab_ddl((*pos_enum)(enu)).Retour_Fixe());};
// Retourne le ddl à t=t identifie par en, en lecture
inline Ddl Ddl_noeud_t(Enum_ddl enu) const
{return Ddl(enu,tab_ddl((*pos_enum)(enu)).Valeur(),tab_ddl((*pos_enum)(enu)).Retour_Fixe());};
// Retourne le ddl à t=tdt identifie par en, en lecture
inline Ddl Ddl_noeud_tdt(Enum_ddl enu) const
{return Ddl(enu,tab_tdt((*pos_enum)(enu)),tab_ddl((*pos_enum)(enu)).Retour_Fixe());};
// indique que l'on va utiliser les ddl en 0, t et tdt
// les grandeurs en tdt sont cree et initialisees par defaut
void Travail_tdt();
// indique que l'on va utiliser les ddl en 0, t
// si les grandeurs en tdt existaient, elles sont supprimées
void Travail_t();
// teste si un ddl existe
inline bool Existe_ici(const Enum_ddl en) const
{ if (Existe(en) == 0)
return false;
else
return true;
};
// 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 ZeroVariablesDdl(bool cas);
// actualisation des ddl actifs (variables et donnees) de t+dt vers t
// seuls sont actualisée, les ddl actifs
void TdtversT();
// actualisation des ddl actifs (variables et donnees) de t vers t+dt
// seuls sont actualisée, les ddl actifs
void TversTdt();
// retourne true si le tableau a t+dt existe , false sinon
inline bool Tdt()
{if (tab_tdt.Taille() != 0) return true; else return false; };
// 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 Contrainte(Vecteur& Sig);
// 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& Contrainte(TenseurHB& Sig);
// lecture du noeud dans la mémoire
void Lecture (UtilLecture *entreePrinc);
// sortie du schemaXML: en fonction de enu
static void SchemaXML_Noeud(ofstream& sort,const Enum_IO_XML enu);
// affichage et definition interactive des commandes
// coor: des coordonnees fixée pour un affichage different pour chaque noeud
void Info_commande_Noeud(UtilLecture * entreePrinc,Coordonnee& coor,int nb_du_noeud);
// lecture sur le flot d'entée de déplacement
// et mise à jour des positions à t et t+dt correspondantes
void LectureDeplacements(UtilLecture *entreePrinc);
//----- 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 Lecture_base_info(ifstream& ent,int cas);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,int cas);
// -------- manipulation de types quelconques stockées aux noeuds ------
// les opérations dans les types quelconques ne sont pas faites par le noeud
// le noeud gère les grandeurs, mais ne les modifies pas directement
// ajout d'un type quelconque au noeud (il s'agit ici de définir le conteneur)
// dans le cas où les types existent déjà, on ne fait rien
// cas d'un tableau
void AjoutTabTypeQuelconque(const Tableau <TypeQuelconque > & tab_t_quel);
// cas d'une seule grandeur quelconque
void AjoutUnTypeQuelconque(const TypeQuelconque & t_quel);
// supprime une grandeur quelconque (si elle est présente)
// opération aussi longue que l'ajout !!
void SupprimeUnTypeQuelconque(const TypeQuelconque & t_quel);
// supprime un tableau de grandeurs quelconques (si elles sont présentes)
// opération aussi longue que l'ajout !!
void SupprimeTabTypeQuelconque(const Tableau <TypeQuelconque > & tab_t_quel);
// ramène un booléen indiquant si la grandeur quelconque existe ou pas
inline bool Existe_ici(TypeQuelconque_enum_etendu en) const
{ if (Existe(en) == 0) return false; else return true;};
// récupération d'une grandeur quelconque pour modification
// après l'appel de cette méthode, la grandeur quelconque est réputée updaté
TypeQuelconque& ModifGrandeur_quelconque(TypeQuelconque_enum_etendu a);
// récupération d'une grandeur quelconque pour lecture uniquement
inline const TypeQuelconque& Grandeur_quelconque(TypeQuelconque_enum_etendu enu) const
{ return (tab_type_quel((*pos_Quelconque)(enu.Position())));};
// ramène le nombre de fois où la grandeur quelconque a été updaté
inline int Grandeur_quelconque_update(TypeQuelconque_enum_etendu enu) const
{ return (update_type_quel((*pos_Quelconque)(enu.Position())));};
// signale que toutes les grandeurs quelconques sont non-updatées
// en particulier les grandeurs en question ne seront pas sauvegarder dans base_info
void Mise_non_update_grandeurs_quelconques();
// signale qu'une grandeur quelconque est non-updatées
// en particulier la grandeur en question ne sera pas sauvegarder dans base_info
void Mise_non_update_grandeurs_quelconques(TypeQuelconque_enum_etendu enu);
// -------- manipulation de types Ddl_etendu stockées aux noeuds ------
// les opérations dans les types Ddl_enum_etendu ne sont pas faites par le noeud
// le noeud gère les grandeurs, mais ne les modifies pas directement
// ajout d'un type Ddl_enum_etendu au noeud (il s'agit ici de définir le conteneur)
// dans le cas où les types existent déjà, on ne fait rien
// cas d'un tableau
void AjoutTabDdl_etendu(const Tableau <Ddl_enum_etendu > & tab_ddletendu);
// cas d'un seul Ddl_enum_etendu
void AjoutUnDdl_etendu(const Ddl_enum_etendu & ddletendu);
// supprime un Ddl_enum_etendu (si elle est présente)
// opération aussi longue que l'ajout !!
void SupprimeUnDdl_etendu(const Ddl_enum_etendu & ddletendu);
// supprime un tableau de Ddl_enum_etendu (si ils sont présents)
// opération aussi longue que l'ajout !!
void SupprimeTabDdl_etendu(const Tableau <Ddl_enum_etendu > & tab_ddletendu);
// ramène un booléen indiquant si le Ddl_enum_etendu existe ou pas
inline bool Existe_ici_ddlEtendu(const Ddl_enum_etendu& ddletendu) const
{ if (Existe_ddlEtendu(ddletendu) == 0) return false; else return true;};
// récupération d'un Ddl_etendu pour modification
// après l'appel de cette méthode, le Ddl_enum_etendu est réputée updaté
Ddl_etendu& ModifDdl_etendu(const Ddl_enum_etendu& addletendu);
// récupération d'un Ddl_etendu pour lecture uniquement
inline const Ddl_etendu& DdlEtendue(const Ddl_enum_etendu& ddlenumetendu) const
{ return (tab_ddletendu((*pos_ddletendu)(ddlenumetendu.Position())));};
// ramène le nombre de fois que le ddl a été updaté
inline int DdlEtendue_update(const Ddl_enum_etendu& ddlenumetendu)
{ return (update_ddletendu((*pos_ddletendu)(ddlenumetendu.Position())));};
// signale que tous les Ddl_etendu sont non-updatées ( mise à zéro du nombre d'update)
// en particulier les grandeurs en question ne seront pas sauvegarder dans base_info
void Mise_non_update_Ddl_etendu();
// signale qu'un Ddl_etendu est non-updatées
// en particulier le Ddl_etendu en question ne sera pas sauvegarder dans base_info
void Mise_non_update_Ddl_etendu(Ddl_enum_etendu ddlenumetendu);
//=====================================================================================
protected :
//=====================================================================================
// donnees de base
int num_noeud; // numero d'identification dans le maillage
int num_Mail; // numero de maillage auquel appartiend le noeud
Tableau <Ddl > tab_ddl; // tableau des degres de liberte
// les valeurs sont celles a l'instant t
Coordonnee* coord0; // coordonnee initiale
// liaison entre noeuds : il s'agit d'un stockage uniquement: l'utilisation et la manipulation
// est à la charge des classes appelantes
Tableau <Enum_liaison_noeud>* tab_enu_liaison; // tab_enu_liaison(i) définit un type éventuel
// de liaison pour le cas d'assemblage i
Tableau < Tableau <Posi_ddl_noeud> >* tab_ddl_lier; // tab_ddl_lier(i) donne la liste des ddl liés
// avec les noeuds associés
// donnees evoluant avec le calcul
// les differents tableaux si-desous peuvent ne pas etre affecte
// cela depend du pb, certaines valeurs ont plusiurs meme nom
// comme coord0 cood1 et cood2, mais un seul endroit de stockage
Tableau<double> tab_0; // valeurs a l'instant 0 des ddl
Tableau<double> tab_tdt; // valeurs a l'instant t+dt des ddl
Tableau <double*> coord1; // coordonnee a un instant t
// pour l'exterieur le tableau est transforme en coordonnees mais
// en interne comme les infos peuvent etre en double avec le tableau de ddl
// et non contigues, on utilise un adressage indirecte
// Sa taille est différente de 0 si les coordonnées à t varie ou
// sont succeptibles de varier.
// a priori si coord1 est affecté c'est uniquement en pointant sur tab_ddl
// donc il ne crée pas avec new
Coordonnee* coord2; // coordonnee a un instant t+dt
// tableau pour une gestion rapide des ddl en service
// et que l'on appelle par leur identification
Tableau<short int> tab_var_actives; // les numéros des variables ddl actives
Tableau<short int> tab_actif; // les numéros des donnees et variables ddl actives
Tableau <int> posiAssemb; // tableau de pointeurs de position pour l'assemblage
// defini l'endroit ou est mis le premier ddl ds les seconds
//membres et raideurs globaux
// le noeud peut contenir éventuellement une base rattachée
BaseB* baseB_0; // actuelle
BaseB* baseB_t; // et à t
BaseB* baseB; // actuelle
Tableau <int> tab_nb_Elem; // tableau éventuel des numéros d'éléments qui contiennent le noeud
// --- cas des types quelconques
Tableau <TypeQuelconque > tab_type_quel; // grandeur quelconques stockées aux noeuds
Tableau <int> update_type_quel; // indique si la grandeur quelconque est update ou pas
static short int posi_type_quel; // utilisée par la méthode Existe_quelconque(..
// pour memoriser la dernière position accèdée
int nbTypeQ_update; // indique le nombre de type quelconque updaté actuel (pour optimiser vitesse)
// --- cas des ddl étendus
Tableau <Ddl_etendu > tab_ddletendu; // ddl étendu stockées aux noeuds
Tableau <int> update_ddletendu; // indique si le ddl étendu est update ou pas
static short int posi_ddletendu; // utilisée par la méthode Existe_ddletendu(..
// pour memoriser la dernière position accèdée
int nbddletendu_update; // indique le nombre de ddl étendu updaté actuel (pour optimiser vitesse)
// --- pour un acces rapide à un ddl donné repéré par un type énuméré on met en place ---
// une liste de type de succession d'enum ddl
// en ce servant de l'équivalence enum int
// il y a une liste pour tous les noeuds
static list <Tableau <int > > list_tab_enum;
// et un type de tableau pour chaque noeud
list <Tableau <int > >::iterator pos_enum ;
// (* posi_enum)(enum) = l'indice du ddl dans les
// tableau de ddl : tab_ddl, tab_0 etc..
// la liste n'est jamais diminuée, par contre comme les noeuds
// sont construit d'une manière automatique et systématique on
// suppose qu'il y aura en fait très peu d'élément dans la liste
// --- pour déterminer rapidement la position dans la liste
// des ddl actifs, d'un ddl donné repéré par un type énuméré
// même principe que pour list_tab_enum
static List_io <Tableau <int > > list_tab_posi_actif;
// et un tableau de pointeur d'élément de la liste,
// chaque tableau étant relatif à untype de combinaison de ddl actif
Tableau < List_io <Tableau <int > >::iterator > t_enum_s ;
// ---- idem pour les types quelconques repéré par un type énuméré
// même principe que pour list_tab_enum
static List_io <Tableau <int > > list_tab_typeQuelconque;
// et un type de tableau pour chaque noeud
list <Tableau <int > >::iterator pos_Quelconque ;
// ---- idem pour les types Ddl_etendu repéré par un type énuméré
// même principe que pour list_tab_enum
static List_io <Tableau <int > > list_tab_ddletendu;
// et un type de tableau pour chaque noeud
list <Tableau <int > >::iterator pos_ddletendu ;
// fonctions internes
// liaison des ddl et des deplacement a t et 0
// nb = le nb du début des deplacement dans les ddl
void Liaison_t(int nb);
// liaison des ddl et des deplacement a t,tdt et 0
// nb = le nb du début des deplacement dans les ddl
void Liaison_tdt(int nb);
// liaison des ddl et des deplacement a tdt seulement
// nb = le nb du début des deplacement dans les ddl
void LiaiSeuletdt(int nb);
// mise a jour des liaisons ddl/deplacement
void MiseAjour();
// mise a jour de l'adressage via l'identificateur d'énumération
// c'est-à-dire la gestion via list_tab_enum et pos_enum
// ne doit être appelé que si l'on a introduit un nouveau ddl !!
// ou changé l'ordre etc..
void MiseAjourEnum();
// mise a jour du tableau de ddl des variables actives
void MiseAjourActif();
// retourne le numero du ddl recherche identifie par en,
// s'il existe sinon 0
int Existe(const Enum_ddl en) const { return (*pos_enum)(en);};
// --- cas des grandeurs quelconques ----
// lecture des grandeurs quelconques sur flot
void Lecture_grandeurs_quelconque(istream & ent);
// écriture des grandeurs quelconques sur flot
void Ecriture_grandeurs_quelconque(ostream & sort) const;
// récupe de l'indice d'une grandeur quelconque
// si la grandeur n'existe pas -> ramène 0
int Indice_grandeur_quelconque(TypeQuelconque_enum_etendu a);
// mise a jour de l'adressage via l'identificateur d'énumération
// c'est-à-dire la gestion via list_tab_typeQuelconque et pos_Quelconque
// ne doit être appelé que si l'on a introduit un nouveau type quelconque !!
// ou changé l'ordre etc..
void MiseAjourTypeQuelconque();
// retourne le numero du type quelconque recherche identifie par en,
// s'il existe sinon 0
int Existe(TypeQuelconque_enum_etendu en)
const { return ( (pos_Quelconque == list_tab_typeQuelconque.end()) ? 0 : (*pos_Quelconque)(en.Position()));};
// --- cas des Ddl_etendu ----
// lecture des Ddl_etendu sur flot
void Lecture_Ddl_etendu(istream & ent);
// écriture des Ddl_etendu sur flot
void Ecriture_Ddl_etendu(ostream & sort) const;
// récupe de l'indice d'un Ddl_etendu
// si la grandeur n'existe pas -> ramène 0
int Indice_Ddl_etendu(const Ddl_enum_etendu& a);
// mise a jour de l'adressage via l'identificateur d'énumération
// c'est-à-dire la gestion via list_tab_ddletendu et pos_ddletendu
// ne doit être appelé que si l'on a introduit un nouveau Ddl_etendu !!
// ou changé l'ordre etc..
void MiseAjourDdl_etendu();
// retourne le numero du Ddl_enum_etendu recherche identifie par en,
// s'il existe sinon 0
int Existe_ddlEtendu(const Ddl_enum_etendu& en)
const { return ( (pos_ddletendu == list_tab_ddletendu.end()) ? 0 : (*pos_ddletendu)(en.Position()));};
// // ordonne et on met a suivre les ddl d'une même famille suivant un ordre croissant
// // ceci pour des ddl que l'on vient d'ajouter, QUE L'ON CONSIDÈRE ÊTRE À LA FIN DE TAB_DDL !
// // en paramètre le ou les ddl
// void OrdonneDdlMemeFamille(const Ddl& a);
// void OrdonneDdlMemeFamille(const Tableau<Ddl>& ta);
// // permutation de deux ddl (sert pour OrdonneDdlMemeFamille)
// void Permutation_2ddl(const int& ipo1,cont int& ipo2);
// ordonner un tableau de ddl suivant un ordre croissant et avec des ddl à suivre
void OrdonnerTableauDdl(Tableau<Ddl>& ta);
// liste des ddl (en famille) à ajouter
// recopie des ddl existant déjà
// change_donn_var indique si les ddl existant on été modifiée
void ListeDdlAajouter(list<Ddl>& liDdl,Tableau<Ddl>& ta,bool& change_donn_var);
};
/// @} // end of group
#endif

1174
Maillage/Noeud2.cc Normal file
View file

File diff suppressed because it is too large Load diff

3580
Maillage/VariablesExporter.cc Executable file
View file

File diff suppressed because it is too large Load diff

793
Maillage/VariablesExporter.h Executable file
View file

@ -0,0 +1,793 @@
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 06/03/2023 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: def d'une classe relative a l'exportation en variables *
* globales de grandeurs définies dans les maillages. *
* Cela concerne les constantes utilisateur et les variables *
* calculées par Herezh. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef VARIABLES_EXPORTER_H
#define VARIABLES_EXPORTER_H
#include <iostream>
#include <map>
#ifndef ENLINUX_STREAM
#include <sstream> // pour le flot en memoire centrale
#else
#include <strstream> // pour le flot en memoire centrale
#endif
#include "UtilLecture.h"
#include "Enum_IO_XML.h"
#include "LesMaillages.h"
#include "Basiques.h"
/** @defgroup Les_classes_exportation_en_variables
*
* BUT:def de classes relatives a l'exportation en variables
* globales de grandeurs définies dans les maillages.
* Cela concerne les constantes utilisateur et les variables
* calculées par Herezh.
*
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
* \brief Définition de classes relatives a l'exportation en variables
*
*/
/// @addtogroup Les_classes_exportation_en_variables
/// @{
///
class VariablesExporter
{
public :
friend class LesMaillages;
//=================%%%%%%%% classes de conteneurs %%%%%%%%=================
// classe conteneur de base pour noeud, élément etc.
class A_un_NE
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, A_un_NE &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const A_un_NE &);
public :
A_un_NE(); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
A_un_NE(string ref
,string nom_mail_,string nom_var_);
// constructeur de copie
A_un_NE (const A_un_NE& a);
// DESTRUCTEUR :
virtual ~A_un_NE ();
// opérateurs
A_un_NE& operator= (const A_un_NE& a);
bool operator== (const A_un_NE& a) const;
bool operator!= (const A_un_NE& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const A_un_NE& a) const;
bool operator <= (const A_un_NE& a) const;
bool operator > (const A_un_NE& a) const;
bool operator >= (const A_un_NE& a) const;
void Affiche();
// retour des grandeurs
const string& Ref_const() const {return ref;}; // la ref
const string& Nom_mail_const() const {return nom_mail;}; // le nom du maillage du noeud
const string& Nom_var_const() const {return nom_var;}; // nom de la variable associée
string& Ref_NE() {return ref;}; // la ref
string* Pointeur_Ref_NE() {return &ref;}; // la ref
string& Nom_mail() {return nom_mail;}; // le nom du maillage du noeud
string* Pointeur_Nom_mail() {return &nom_mail;}; // le nom du maillage du noeud
string& Nom_var() {return nom_var;}; // nom de la variable associée
// récupération du pointeur de la classe
const A_un_NE* PointeurClass_const() const {return this;};
A_un_NE* PointeurClass() {return this;};
protected :
string ref; // la ref associée
string nom_mail; // le nom du maillage du noeud ou élément
string nom_var; // nom de la variable associée
};
// classe conteneur pour un ddl à un noeud
class Ddl_a_un_noeud
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, Ddl_a_un_noeud &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const Ddl_a_un_noeud &);
public :
Ddl_a_un_noeud (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
Ddl_a_un_noeud (Ddl_enum_etendu e,string ref_noeud
, string nom_mail_,string nom_var_, Enum_dure tps);
// constructeur de copie
Ddl_a_un_noeud (const Ddl_a_un_noeud& a);
// DESTRUCTEUR :
virtual ~Ddl_a_un_noeud ();
// opérateurs
Ddl_a_un_noeud& operator= (const Ddl_a_un_noeud& a);
bool operator== (const Ddl_a_un_noeud& a) const;
bool operator!= (const Ddl_a_un_noeud& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const Ddl_a_un_noeud& a) const;
bool operator <= (const Ddl_a_un_noeud& a) const;
bool operator > (const Ddl_a_un_noeud& a) const;
bool operator >= (const Ddl_a_un_noeud& a) const;
void Affiche();
// retour des grandeurs
const Ddl_enum_etendu& Enu_const() const {return enu;} ; // le ddl
const string& Ref_Num_NE_const() const {return ref_num_NE;}; // la ref de num du noeud
const string& Nom_mail_const() const {return nom_mail;}; // le nom du maillage du noeud
const string& Nom_var_const() const {return nom_var;}; // nom de la variable associée
const Enum_dure& Temps_const() const {return temps;}; // temps de validation du ddl
string* Pointeur_Nom_mail() {return &nom_mail;}; // le nom du maillage du noeud
Ddl_enum_etendu& Enu() {return enu;} ; // le ddl
string& Ref_Num_NE() {return ref_num_NE;}; // la ref de num du noeud
string& Nom_mail() {return nom_mail;}; // le nom du maillage du noeud
string& Nom_var() {return nom_var;}; // nom de la variable associée
Enum_dure& Temps() {return temps;}; // temps de validation du ddl
protected :
Ddl_enum_etendu enu; // le ddl
string ref_num_NE; // le num du noeud
string nom_mail; // le nom du maillage du noeud
string nom_var; // nom de la variable associée
Enum_dure temps; // temps de validation du ddl
};
// classe conteneur pour un ddl étendu à un noeud
class Ddl_etendu_a_un_noeud : public A_un_NE
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, Ddl_etendu_a_un_noeud &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const Ddl_etendu_a_un_noeud &);
public :
Ddl_etendu_a_un_noeud (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
Ddl_etendu_a_un_noeud (Ddl_enum_etendu e,string ref_noeud
, string nom_mail_,string nom_var_);
// constructeur de copie
Ddl_etendu_a_un_noeud (const Ddl_etendu_a_un_noeud& a);
// DESTRUCTEUR :
virtual ~Ddl_etendu_a_un_noeud ();
// opérateurs
Ddl_etendu_a_un_noeud& operator= (const Ddl_etendu_a_un_noeud& a);
bool operator== (const Ddl_etendu_a_un_noeud& a) const;
bool operator!= (const Ddl_etendu_a_un_noeud& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const Ddl_etendu_a_un_noeud& a) const;
bool operator <= (const Ddl_etendu_a_un_noeud& a) const;
bool operator > (const Ddl_etendu_a_un_noeud& a) const;
bool operator >= (const Ddl_etendu_a_un_noeud& a) const;
void Affiche();
// retour des grandeurs
Ddl_enum_etendu Enu_const() const {return enu;} ; // le ddl
Ddl_enum_etendu& Enu() {return enu;} ; // le ddl
protected :
Ddl_enum_etendu enu; // le ddl
};
// classe conteneur pour une grandeur quelconque à un noeud
class Quelconque_a_un_noeud : public A_un_NE
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, Quelconque_a_un_noeud &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const Quelconque_a_un_noeud &);
public :
Quelconque_a_un_noeud (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
Quelconque_a_un_noeud (TypeQuelconque_enum_etendu e,string ref_noeud
, string nom_mail_,string nom_var_,int num_ord);
// constructeur de copie
Quelconque_a_un_noeud (const Quelconque_a_un_noeud& a);
// DESTRUCTEUR :
virtual ~Quelconque_a_un_noeud ();
// opérateurs
Quelconque_a_un_noeud& operator= (const Quelconque_a_un_noeud& a);
bool operator== (const Quelconque_a_un_noeud& a) const;
bool operator!= (const Quelconque_a_un_noeud& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const Quelconque_a_un_noeud& a) const;
bool operator <= (const Quelconque_a_un_noeud& a) const;
bool operator > (const Quelconque_a_un_noeud& a) const;
bool operator >= (const Quelconque_a_un_noeud& a) const;
void Affiche();
// retour des grandeurs
const TypeQuelconque_enum_etendu& Quelc_const() const {return quelc;} ; // la grandeur constante
TypeQuelconque_enum_etendu& Quelc() {return quelc;} ; // la grandeur en i/o
const int& Num_ordre_const() const {return num_ordre;};
int& Num_ordre() {return num_ordre;};
protected :
TypeQuelconque_enum_etendu quelc; // la grandeur
int num_ordre; // le numéro de la composante
};
// classe conteneur pour un pti d'élément
class A_un_E : public A_un_NE
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, A_un_E &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const A_un_E &);
public :
A_un_E (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
A_un_E (int absolu_,string ref_
,string nom_mail_,string nom_var_,int nbpti);
// constructeur de copie
A_un_E (const A_un_E& a);
// DESTRUCTEUR :
virtual ~A_un_E ();
// opérateurs
A_un_E& operator= (const A_un_E& a);
bool operator== (const A_un_E& a) const;
bool operator!= (const A_un_E& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const A_un_E& a) const;
bool operator <= (const A_un_E& a) const;
bool operator > (const A_un_E& a) const;
bool operator >= (const A_un_E& a) const;
void Affiche();
// récupération du pointeur de la classe
const A_un_E* PointeurClass_E_const() const {return this;};
A_un_E* PointeurClass_E() {return this;};
// retour des grandeurs
const int& NBpti_const() const {return num_pti;}; // num du pti en const
int& NBpti() {return num_pti;}; // idem direct
const int& Absolue_const() const {return absolu;}; // absolu ou pas
int& Absolue() {return absolu;};
protected :
int num_pti; // numéro du point d'intégration
int absolu; // indique si la grandeur est dans un repère absolu ou local
};
// classe conteneur pour un ddl à un élément
class Ddl_a_un_element : public A_un_E
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, Ddl_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const Ddl_a_un_element &);
public :
Ddl_a_un_element (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
Ddl_a_un_element (int absolu_,Ddl_enum_etendu e,string ref_noeud
,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti);
// constructeur de copie
Ddl_a_un_element (const Ddl_a_un_element& a);
// DESTRUCTEUR :
virtual ~Ddl_a_un_element ();
// opérateurs
Ddl_a_un_element& operator= (const Ddl_a_un_element& a);
bool operator== (const Ddl_a_un_element& a) const;
bool operator!= (const Ddl_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const Ddl_a_un_element& a) const;
bool operator <= (const Ddl_a_un_element& a) const;
bool operator > (const Ddl_a_un_element& a) const;
bool operator >= (const Ddl_a_un_element& a) const;
void Affiche();
// retour des grandeurs
const Ddl_enum_etendu& Enu_const() const {return enu;} ; // le ddl en const
Ddl_enum_etendu& Enu() {return enu;} ; // le ddl direct
const Enum_dure& Temps_const() const {return temps;}; // temps de validation du ddl
Enum_dure& Temps() {return temps;}; // temps de validation du ddl
protected :
Ddl_enum_etendu enu; // le ddl
Enum_dure temps; // temps de validation du ddl
};
// classe conteneur pour un TypeQuelconque à un élément
class TypeQuelconque_a_un_element : public A_un_E
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeQuelconque_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeQuelconque_a_un_element &);
public :
TypeQuelconque_a_un_element (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeQuelconque_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_NE
,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti,int num_ord);
// constructeur de copie
TypeQuelconque_a_un_element (const TypeQuelconque_a_un_element& a);
// DESTRUCTEUR :
virtual ~TypeQuelconque_a_un_element ();
// opérateurs
TypeQuelconque_a_un_element& operator= (const TypeQuelconque_a_un_element& a);
bool operator== (const TypeQuelconque_a_un_element& a) const;
bool operator!= (const TypeQuelconque_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeQuelconque_a_un_element& a) const;
bool operator <= (const TypeQuelconque_a_un_element& a) const;
bool operator > (const TypeQuelconque_a_un_element& a) const;
bool operator >= (const TypeQuelconque_a_un_element& a) const;
void Affiche();
// récupération du pointeur de la classe
const TypeQuelconque_a_un_element* PointeurClass_Quelc_const() const {return this;};
TypeQuelconque_a_un_element* PointeurClass_Quelc() {return this;};
// retour des grandeurs
const TypeQuelconque_enum_etendu& Quelc_const() const {return quelc;} ; // la grandeur constante
TypeQuelconque_enum_etendu& Quelc() {return quelc;} ; // la grandeur en i/o
const int& Num_ordre_const() const {return num_ordre;};
int& Num_ordre() {return num_ordre;};
protected :
TypeQuelconque_enum_etendu quelc; // la grandeur
int num_ordre; // le numéro de la composante
};
// classe conteneur pour les grandeurs particulières à un élément
class TypeParticulier_a_un_element : public TypeQuelconque_a_un_element
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeParticulier_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeParticulier_a_un_element &);
public :
TypeParticulier_a_un_element(): TypeQuelconque_a_un_element() {}; // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeParticulier_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_noeud
,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti,int num_ord):
TypeQuelconque_a_un_element(absolu_,e,ref_noeud,nom_mail_,tps,nom_var_,nbpti,num_ord) {} ;
// constructeur de copie
TypeParticulier_a_un_element(const TypeParticulier_a_un_element& a):
TypeQuelconque_a_un_element(a) {};
// DESTRUCTEUR :
virtual ~TypeParticulier_a_un_element() {};
// opérateurs
TypeParticulier_a_un_element& operator= (const TypeParticulier_a_un_element& a)
{(*PointeurClass_Quelc())= (*a.PointeurClass_Quelc_const());};
bool operator== (const TypeParticulier_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
bool operator!= (const TypeParticulier_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeParticulier_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) < (*a.PointeurClass_Quelc_const()));};
bool operator <= (const TypeParticulier_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) <= (*a.PointeurClass_Quelc_const()));};
bool operator > (const TypeParticulier_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) > (*a.PointeurClass_Quelc_const()));};
bool operator >= (const TypeParticulier_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
void Affiche();
};
// classe conteneur pour les grandeurs évoluées à un élément
class TypeEvoluee_a_un_element : public TypeQuelconque_a_un_element
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeEvoluee_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeEvoluee_a_un_element &);
public :
TypeEvoluee_a_un_element(): TypeQuelconque_a_un_element() {}; // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeEvoluee_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_noeud
,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti,int num_ord):
TypeQuelconque_a_un_element(absolu_,e,ref_noeud,nom_mail_,tps,nom_var_,nbpti,num_ord) {} ;
// constructeur de copie
TypeEvoluee_a_un_element(const TypeEvoluee_a_un_element& a):
TypeQuelconque_a_un_element(a) {};
// DESTRUCTEUR :
virtual ~TypeEvoluee_a_un_element() {};
// opérateurs
TypeEvoluee_a_un_element& operator= (const TypeEvoluee_a_un_element& a)
{(*PointeurClass_Quelc())= (*a.PointeurClass_Quelc_const());};
bool operator== (const TypeEvoluee_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
bool operator!= (const TypeEvoluee_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeEvoluee_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) < (*a.PointeurClass_Quelc_const()));};
bool operator <= (const TypeEvoluee_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) <= (*a.PointeurClass_Quelc_const()));};
bool operator > (const TypeEvoluee_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) > (*a.PointeurClass_Quelc_const()));};
bool operator >= (const TypeEvoluee_a_un_element& a) const
{return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
void Affiche();
};
// classe conteneur pour un TypeQuelconque à une face ou arête
class TypeQuelconque_a_Face_arete : public TypeQuelconque_a_un_element
{ public :
TypeQuelconque_a_Face_arete (); // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeQuelconque_a_Face_arete (int absolu_,TypeQuelconque_enum_etendu e,string ref_element
,string nom_mail_,int nbFA, Enum_dure tps,string nom_var_,int nbpti,int num_ord);
// constructeur de copie
TypeQuelconque_a_Face_arete (const TypeQuelconque_a_Face_arete& a);
// DESTRUCTEUR :
virtual ~TypeQuelconque_a_Face_arete ();
// opérateurs
TypeQuelconque_a_Face_arete& operator= (const TypeQuelconque_a_Face_arete& a);
bool operator== (const TypeQuelconque_a_Face_arete& a) const;
bool operator!= (const TypeQuelconque_a_Face_arete& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeQuelconque_a_Face_arete& a) const;
bool operator <= (const TypeQuelconque_a_Face_arete& a) const;
bool operator > (const TypeQuelconque_a_Face_arete& a) const;
bool operator >= (const TypeQuelconque_a_Face_arete& a) const;
// récupération du pointeur de la classe
const TypeQuelconque_a_Face_arete* PointClass_QuelcFA_const() const {return this;};
TypeQuelconque_a_Face_arete* PointClass_QuelcFA() {return this;};
// retour des grandeurs
const int& Num_FA_const() const {return num_FA;} ; // la grandeur constante
int& Num_FA() {return num_FA;} ; // la grandeur en i/O
protected :
int num_FA; // ref de numéro de la face ou de l'arête
};
// classe conteneur pour les grandeurs quelconque à une face d'élément
class TypeQuelc_face_a_un_element : public TypeQuelconque_a_Face_arete
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeQuelc_face_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeQuelc_face_a_un_element &);
public :
TypeQuelc_face_a_un_element(): TypeQuelconque_a_Face_arete() {}; // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeQuelc_face_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_element
,string nom_mail_,int nbFA, Enum_dure tps,string nom_var_,int nbpti,int num_ord):
TypeQuelconque_a_Face_arete(absolu_,e,ref_element,nom_mail,nbFA,tps,nom_var_,nbpti,num_ord)
{} ;
// constructeur de copie
TypeQuelc_face_a_un_element(const TypeQuelc_face_a_un_element& a):
TypeQuelconque_a_Face_arete(a) {};
// DESTRUCTEUR :
virtual ~TypeQuelc_face_a_un_element() {};
// opérateurs
TypeQuelc_face_a_un_element& operator= (const TypeQuelc_face_a_un_element& a)
{(*PointClass_QuelcFA())= (*a.PointClass_QuelcFA_const());};
bool operator== (const TypeQuelc_face_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
bool operator!= (const TypeQuelc_face_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeQuelc_face_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) < (*a.PointClass_QuelcFA_const()));};
bool operator <= (const TypeQuelc_face_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) <= (*a.PointClass_QuelcFA_const()));};
bool operator > (const TypeQuelc_face_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) > (*a.PointClass_QuelcFA_const()));};
bool operator >= (const TypeQuelc_face_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
void Affiche();
};
// classe conteneur pour les grandeurs quelconque à une arête d'élément
class TypeQuelc_arete_a_un_element : public TypeQuelconque_a_Face_arete
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeQuelc_arete_a_un_element &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeQuelc_arete_a_un_element &);
public :
TypeQuelc_arete_a_un_element(): TypeQuelconque_a_Face_arete() {}; // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeQuelc_arete_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_element
,string nom_mail_,int nbFA, Enum_dure tps,string nom_var_,int nbpti,int num_ord):
TypeQuelconque_a_Face_arete(absolu_,e,ref_element,nom_mail,nbFA,tps,nom_var_,nbpti,num_ord)
{} ;
// constructeur de copie
TypeQuelc_arete_a_un_element(const TypeQuelc_arete_a_un_element& a):
TypeQuelconque_a_Face_arete(a) {};
// DESTRUCTEUR :
virtual ~TypeQuelc_arete_a_un_element() {};
// opérateurs
TypeQuelc_arete_a_un_element& operator= (const TypeQuelc_arete_a_un_element& a)
{(*PointClass_QuelcFA())= (*a.PointClass_QuelcFA_const());};
bool operator== (const TypeQuelc_arete_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
bool operator!= (const TypeQuelc_arete_a_un_element& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeQuelc_arete_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) < (*a.PointClass_QuelcFA_const()));};
bool operator <= (const TypeQuelc_arete_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) <= (*a.PointClass_QuelcFA_const()));};
bool operator > (const TypeQuelc_arete_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) > (*a.PointClass_QuelcFA_const()));};
bool operator >= (const TypeQuelc_arete_a_un_element& a) const
{return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
void Affiche();
};
// classe conteneur pour une composante d'une grandeur globale
class TypeQuelc_Une_composante_Grandeur_globale
{ // surcharge de l'operator de lecture avec le type
friend istream & operator >> (istream &, TypeQuelc_Une_composante_Grandeur_globale &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const TypeQuelc_Une_composante_Grandeur_globale &);
public :
TypeQuelc_Une_composante_Grandeur_globale(): var() {}; // constructeur par défaut
// constructeur fonction de toutes les grandeurs
TypeQuelc_Une_composante_Grandeur_globale (string nom_var, string nom_glob, int num_ord):
var(nom_var,nom_glob,num_ord)
{} ;
// constructeur de copie
TypeQuelc_Une_composante_Grandeur_globale(const TypeQuelc_Une_composante_Grandeur_globale& a):
var(a.var) {};
// DESTRUCTEUR :
virtual ~TypeQuelc_Une_composante_Grandeur_globale() {};
// opérateurs
TypeQuelc_Une_composante_Grandeur_globale& operator= (const TypeQuelc_Une_composante_Grandeur_globale& a)
{var = a.var;};
bool operator== (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{return (var == a.var);};
bool operator!= (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{if ( (*this)==a ) return true; else return false;};
bool operator < (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{return (var < a.var);};
bool operator <= (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{return (var <= a.var);};
bool operator > (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{return (var > a.var);};
bool operator >= (const TypeQuelc_Une_composante_Grandeur_globale& a) const
{return (var >= a.var);};
void Affiche();
// retour des grandeurs
const string& Nom_var_const() const {return var.nom1;}; // nom de la variable associée
string& Nom_var() {return var.nom1;}; // nom de la variable associée
const string& Nom_grandeur_globale_const() const {return var.nom2;}; // nom de la grandeur globale associé
string& Nom_grandeur_globale() {return var.nom2;}; // nom de la grandeur globale associé
const int& Indice_const() const {return var.n;};
int& Indice() {return var.n;};
Deux_String_un_entier Deux_String_un_entier_const() const {return var;} ;
Deux_String_un_entier& Deux_String_un_entier_() {return var;} ;
protected :
Deux_String_un_entier var ;
// var.nom1 -> nom de la variable
// var.nom2 -> nom de la grandeur globale
// var.n -> le numéro de la composante
};
// METHODES :
//=================%%%%%%%% la classe principale %%%%%%%%=================
// CONSTRUCTEURS :
// Constructeur par defaut
VariablesExporter ();
// Constructeur de copie, cependant ici il n'y a pas de création de noeud ni d'élément
// c'est seulement une création de nouveaux conteneurs de pointeurs
// cependant le numéro de maillage et le nom de maillage n'est pas valide, il faut
// ensuite les définir
VariablesExporter (const VariablesExporter& var);
// DESTRUCTEUR :
~VariablesExporter ();
// lecture
void LectureVariablesExporter(UtilLecture * entreePrinc);
// insertion des constantes et variables utilisateurs vers globales
void InsertConstVarUtilisateur_dans_globale();
// initialisation des conteneurs quelconques
// création des conteneurs aux noeuds s'il s'agit d'une variable
// associée à un vecteur global (au sens des algorithmes globaux)
void InitialisationConteneursQuelconques(LesMaillages& lesMail,const List_io < TypeQuelconque >& listeVecGlob,const LesReferences& lesRef);
// ramène les liste des infos qui seront consultés pour les noeuds
const List_io < Ddl_a_un_noeud >& List_noeud_type_ddl() const {return list_noeud_type_ddl;}; // ddl pur aux noeuds
const List_io < Ddl_etendu_a_un_noeud >& List_noeud_type_ddlEtendu() const {return list_noeud_type_ddlEtendu;}; // idem pour les ddl étendu
const List_io <Quelconque_a_un_noeud>& List_noeud_type_quelconque() const {return list_noeud_type_quelconque;}; // idem en quelconque
// affichage et definition interactive des commandes
void Info_commande_VariablesExporters(UtilLecture * entreePrinc);
// Affiche
void Affiche () const ;
// Surcharge de l'operateur = : realise l'egalite de deux instances
VariablesExporter& operator= (VariablesExporter& var);
// test si toutes les informations sont completes
// = true -> complet
// = false -> incomplet
bool Complet_VariablesExporter(const LesReferences& lesRef);
// mises à jour de constantes globales définies par l'utilisateur
// permet de changer les valeurs, lors d'une suite .info par exemple
void MiseAjourConstantesUtilisateur(UtilLecture& lec);
// renseigne les variables définies par l'utilisateur
// via les valeurs calculées par Herezh
void RenseigneVarUtilisateur(LesMaillages& lesMail,const LesReferences& lesRef);
//----- 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)
void Lecture_base_info(ifstream& ent,const int cas);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas);
// sortie du schemaXML: en fonction de enu
static void SchemaXML_VariablesExporters(UtilLecture * entreePrinc,const Enum_IO_XML enu) ;
protected :
// données:
// ---- les constantes utilisateur
list<TypeQuelconque> li_Q; // les constantes
list<string> li_nom; // le nom des constantes
// ------- les variables
// -> noeuds
List_io < Ddl_a_un_noeud > list_noeud_type_ddl; // ddl pur aux noeuds
List_io < Ddl_etendu_a_un_noeud > list_noeud_type_ddlEtendu; // idem pour les ddl étendu
List_io <Quelconque_a_un_noeud> list_noeud_type_quelconque; // idem en quelconque
// -> éléments
List_io < Ddl_a_un_element > list_element_type_ddl; // ddl pur aux pti d'élément
// idem pour les grandeurs particulières et évoluées
List_io < TypeParticulier_a_un_element > list_element_type_particulier;
List_io < TypeQuelconque > list_quelc_element_type_particulier; // les conteneurs associés
List_io < TypeEvoluee_a_un_element > list_element_type_evoluee;
List_io < TypeQuelconque > list_quelc_element_type_evoluee; // les conteneurs associés
// -> face d'éléments
List_io <TypeQuelc_face_a_un_element > list_face_element_type_quelc;
List_io < TypeQuelconque > list_quelc_face_element_type_quelc; // les conteneurs associés
// -> arête d'éléments
List_io <TypeQuelc_arete_a_un_element > list_arete_element_type_quelc;
List_io < TypeQuelconque > list_quelc_arete_element_type_quelc; // les conteneurs associés
bool initiaConteneurQuelconque; // pour gérer une seule initialisation
// -> une composante d'une variable globale de type multidimentionnel
List_io <TypeQuelc_Une_composante_Grandeur_globale > list_var_glob_sur_grandeur_globale;
// méthodes
//---- constantes utilisateurs
// lecture éventuelle de constantes globales définies par l'utilisateur
void LecConstantesUtilisateur(UtilLecture& lec);
// insertion des constantes utilisateur dans les variables globales
void InsertConstUtilisateur_dans_globale();
// def de constantes utilisateur pour une sortie sur un fichier de commande
void Info_commande_ConstantesUtilisateur(UtilLecture * lec);
// ---- variables utilisateur
// lecture éventuelle des variables globales définies par l'utilisateur
void LecVariablesUtilisateur(UtilLecture& lec);
// def de variables utilisateur pour une sortie sur un fichier de commande
void Info_commande_VariablesUtilisateur(UtilLecture * lec);
// insertion et stockage des variables au niveau de ParaGlob
void Insert_VarUtilisateur_dans_globale();
// vérification que 2 nom de variables ne soient pas identique
// si avec_sortie = true -> arrêt
// si avec_sortie = false -> retour du test: true si c'est ok
// false si pb
bool VerifNomVariable(const string& nom,bool avec_sortie) const;
// lecture interactive du nom de la variable: hors variable relais
string Lect_interactive_nom_var();
// lecture interactive du nom d'une variable relais
string Lect_interactive_nom_var_relais();
// insertion d'une composante d'une grandeur quelconque en globale
// sous forme d'un double
void InsertCompGrandeurQuelc(const string& non_var,const TypeQuelconque_enum_etendu& enu);
};
/// @} // end of group
#endif