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

Compare commits

merge into: rio:V_7.011
Branches Tags
rio:master
rio:V_7.033
rio:V_7.031
rio:V_7.030
rio:V_7.029
rio:V_7.028
rio:V_7.023
rio:V_7.020
rio:V_7.019
rio:V_7.018
rio:V_7.017
rio:V_7.014
rio:V_7013
rio:V_7.011
rio:V6.991
...
pull from: rio:master
Branches Tags
rio:V_7.033
rio:V_7.031
rio:V_7.030
rio:V_7.029
rio:V_7.028
rio:V_7.023
rio:V_7.020
rio:V_7.019
rio:V_7.018
rio:master
rio:V_7.017
rio:V_7.014
rio:V_7013
rio:V_7.011
rio:V6.991

No commits in common. "V_7.011" and "master" have entirely different histories.
V_7.011 ... master

1069 changed files with 10387 additions and 28846 deletions
Show stats Expand all files Collapse all files

BIN
.DS_Store vendored Executable file
View file

Binary file not shown.

111
.gitignore vendored
View file

@ -1,111 +0,0 @@
CVS/
*copi*
essai*
*old*
*.cp
*essai
*save*
.DS_Store
*.zip
*.cpp
*.f
*copy*
*maxima
Readme
*yaca
*yaca*
*.txt
NRC/
untitled
*.texte
*.sav
FAQ
ConsoleSIOUX.*
ConsoleSIOUX.plc
Carbon*
*.xws
tata
*.sh
*yacas
*maxima*
*yacas*
*sauve*
*.tex
*.cpp*
Algo/GalerkinContinu/AlgoMixte/AlgoriStatExpli.cc
Algo/GalerkinContinu/AlgoMixte/AlgoriStatExpli.h
Documentation/
Elements/MecaFlu/
Elements/Mecanique/SFE/Met_Sfe1s3_28sep.cc
Elements/Mecanique/SFE/compaAnaHZ
Elements/Mecanique/SFE/derive_courbure
Elements/Remonte/
Elements/Thermique/ElemPoint/
Elements/Thermique/ElemThermiGene.h
Elements/Thermique/Hexaedre/
Elements/Thermique/Pentaedre/
Elements/Thermique/Quad_asisymetrie/
Elements/Thermique/SFE/
Elements/Thermique/Tetraedre/
Elements/Thermique/Tria_axisymetrie/
Elements/Thermique/Triangle/
Elements/Thermique/quadrangle/
Flambage/Valpro.h
G_Var_precompile/
General/creatio_tube.c
General/herezh.Projet
General/suppres_tube.c
Lecture/UtilXML.h
Maillage/Renumerotation.cc
Maillage/renume.cc
Parametres/TypeCalcul.h
Parametres/Type_Calcul.h
Resolin/Resolution_Condi/Assemblage.cp_11-9-2001
Resultats/Gid_25mars/
Resultats/Gmsh_25mars/
STL_bouquin/
Tableaux/Tableau_T.cc
TypeBase/Reels.h
TypeBase/Reels3.cc
TypeBase/Reels3.h
TypeBase/TypePremierXML.h
TypeBase/XPath.h
TypeBase/XPath_hz.h
TypeBase/XPointer.h
TypeBase/XPointer_hz.h
comportement/ComLoi_comp_abstraite.h
comportement/ExceptionsLoiComp.h
comportement/Hyper_elastique/Hyper1.cc
comportement/Hyper_elastique/Hyper1.h
comportement/Hyper_elastique/result
comportement/Hyper_elastique/verif_Epartielles
comportement/Hyper_elastique/verif_Etotal
comportement/Hyper_elastique/verif_Si
comportement/loi_visco_plastiques/
comportement/lois_speciales/Loi_rien2D.cc
comportement/lois_speciales/Loi_rien2D.h
comportement/plasticite/Prandtl_Reuss.h_version1
comportement/plasticite/Prandtl_Reuss1D.h.sept2001
comportement/plasticite/Prandtl_Reuss_23_11_02.h
macro/
tenseurs_mai99/Coordonnees/Coordonnee3_T.cc
tenseurs_mai99/Coordonnees/Coordonnee3_T.h
tenseurs_mai99/Reperes_bases/Base_T.cc
tenseurs_mai99/Reperes_bases/Bases.h
tenseurs_mai99/Reperes_bases/Repere.cc
tenseurs_mai99/Reperes_bases/Repere.h
tenseurs_mai99/Tenseur/TenseurO4.h
tenseurs_mai99/Tenseur/TenseurO4_1.cc
tenseurs_mai99/Tenseur/TenseurO4_2.cc
tenseurs_mai99/Tenseur/TenseurQgene-1.cc
tenseurs_mai99/Tenseur/TenseurQgene-2.cc
tenseurs_mai99/Vecteurs/Vecteur.c++
tenseurs_mai99/Vecteurs/Vecteur.hc
tenseurs_mai99/Vecteurs/Vecteur_de_pointeurs.cc
tenseurs_mai99/Vecteurs/Vecteur_de_pointeurs.h
tenseurs_mai99/Vecteurs/Vecteuri.cc
tenseurs_mai99/Vecteurs/Vecteuri.h
unix/makefile
caneva.h

145
Elements/Mecanique/SFE/Met_Sfe1_struc_donnees.h
View file

@ -1,145 +0,0 @@
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* *
* DATE: 15/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* deuxième partie du fichier Met_Sfe1.h
* contient en fait toutes les structures de données de passage d'informations
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS:
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* *
* $ *
* *
************************************************************************/
#include "Tenseur.h"
#include "Base.h"
// deuxième partie du fichier Met_Sfe1.h
// contient en fait toutes les structures de données de passage d'informations
/// @addtogroup groupe_des_metrique
/// @{
///
/// CLASSE CONTENEUR : cas des grandeurs relatives à la courbure, grandeurs à 0, t et tdt
/// les données sont publiques
class Courbure_t_tdt
{ public : Courbure_t_tdt () : // constructeur par défaut
aiB_0(NULL),aiH_0(NULL),aiB_t(NULL),aiH_t(NULL),aiB_tdt(NULL),aiH_tdt(NULL)
,aijBB_0(NULL),aijHH_0(NULL),aijBB_t(NULL),aijHH_t(NULL),aijBB_tdt(NULL),aijHH_tdt(NULL)
,curbBB_t(NULL),curbBB_tdt(NULL),curbBB_0(NULL)
,ajacobien_tdt(NULL),ajacobien_t(NULL),ajacobien_0(NULL)
{};
Courbure_t_tdt // constructeur normal
(BaseB * aaiB_0,BaseH * aaiH_0,BaseB * aaiB_t,BaseH * aaiH_t, BaseB * aaiB_tdt
,BaseH *aaiH_tdt
,TenseurBB* aaijBB_0,TenseurHH* aaijHH_0,TenseurBB* aaijBB_t
,TenseurHH* aaijHH_t,TenseurBB* aaijBB_tdt,TenseurHH* aaijHH_tdt
,TenseurBB * gcurbBB_t,TenseurBB * gcurbBB_tdt,TenseurBB * gcurbBB_0
,double* gjacobien,double* gajacobien_t,double* gajacobien_0) :
aiB_0(aaiB_0),aiH_0(aaiH_0),aiB_t(aaiB_t),aiH_t(aaiH_t),aiB_tdt(aaiB_tdt),
aiH_tdt(aaiH_tdt),
aijBB_0(aaijBB_0),aijHH_0(aaijHH_0)
,aijBB_t(aaijBB_t),aijHH_t(aaijHH_t),aijBB_tdt(aaijBB_tdt),aijHH_tdt(aaijHH_tdt)
,curbBB_t(gcurbBB_t),curbBB_tdt(gcurbBB_tdt),curbBB_0(gcurbBB_0),
ajacobien_tdt(gjacobien),ajacobien_t(gajacobien_t),ajacobien_0(gajacobien_0)
{};
Courbure_t_tdt (const Courbure_t_tdt& ex) : // constructeur de copie
aiB_0(ex.aiB_0),aiH_0(ex.aiH_0),aiB_t(ex.aiB_t),aiH_t(ex.aiH_t),aiB_tdt(ex.aiB_tdt)
,aiH_tdt(ex.aiH_tdt),
aijBB_0(ex.aijBB_0),aijHH_0(ex.aijHH_0),aijBB_t(ex.aijBB_t),aijHH_t(ex.aijHH_t)
,aijBB_tdt(ex.aijBB_tdt),aijHH_tdt(ex.aijHH_tdt)
,curbBB_t(ex.curbBB_t),curbBB_tdt(ex.curbBB_tdt),curbBB_0(ex.curbBB_0),
ajacobien_tdt(ex.ajacobien_tdt),ajacobien_t(ex.ajacobien_t),ajacobien_0(ex.ajacobien_0)
{};
Courbure_t_tdt& operator= (const Courbure_t_tdt& ex) // surcharge d'affectation
{aiB_0=ex.aiB_0;aiH_0=ex.aiH_0;aiB_t=ex.aiB_t;aiH_t=ex.aiH_t;aiB_tdt=ex.aiB_tdt;
aiH_tdt=ex.aiH_tdt;
aijBB_0=ex.aijBB_0;aijHH_0=ex.aijHH_0; aijBB_t=ex.aijBB_t;aijHH_t=ex.aijHH_t;
aijBB_tdt=ex.aijBB_tdt;aijHH_tdt=ex.aijHH_tdt;
curbBB_t=ex.curbBB_t;curbBB_tdt=ex.curbBB_tdt;curbBB_0=ex.curbBB_0;
ajacobien_tdt=ex.ajacobien_tdt;ajacobien_t=ex.ajacobien_t;ajacobien_0=ex.ajacobien_0;
return *this;};
// mise à jour des grandeurs
void Mise_a_jour_grandeur(BaseB * aaiB_0,BaseH * aaiH_0,BaseB * aaiB_t,BaseH* aaiH_t
,BaseB * aaiB_tdt,BaseH *aaiH_tdt
,TenseurBB* aaijBB_0,TenseurHH* aaijHH_0,TenseurBB* aaijBB_t,TenseurHH* aaijHH_t
,TenseurBB* aaijBB_tdt,TenseurHH* aaijHH_tdt
,TenseurBB * gcurbBB_t,TenseurBB * gcurbBB_tdt,TenseurBB * gcurbBB_0
,double* gjacobien,double* gajacobien_t,double* gajacobien_0)
{aiB_0=aaiB_0;aiH_0=aaiH_0;aiB_t=aaiB_t;aiH_t=aaiH_t;aiB_tdt=aaiB_tdt;
aiH_tdt=aaiH_tdt;
aijBB_0=aaijBB_0;aijHH_0=aaijHH_0;aijBB_t=aaijBB_t;aijHH_t=aaijHH_t;
aijBB_tdt=aaijBB_tdt;aijHH_tdt=aaijHH_tdt;
curbBB_t=gcurbBB_t;curbBB_tdt=gcurbBB_tdt;curbBB_0=gcurbBB_0;
ajacobien_tdt=gjacobien;ajacobien_t=gajacobien_t;ajacobien_0=gajacobien_0;
};
// mise à jour des grandeurs à 0 et à t sauf les variations (pas de tableau et pas à tdt)
// à partir de grandeurs stockées par ailleurs (il s'aait ici donc d'affectation de contenu et
// non de pointeur !)
void Recup_grandeur_0_t(BaseB & aaiB_0,BaseH & aaiH_0,BaseB & aaiB_t,BaseH& aaiH_t
,TenseurBB& aaijBB_0,TenseurHH& aaijHH_0,TenseurBB& aaijBB_t,TenseurHH& aaijHH_t
,TenseurBB & ,double& gajacobien_0,double& gajacobien_t)
{*aiB_0=aaiB_0;*aiH_0=aaiH_0;*aiB_t=aaiB_t;*aiH_t=aaiH_t;
*aijBB_0=aaijBB_0;*aijHH_0=aaijHH_0;*aijBB_t=aaijBB_t;*aijHH_t=aaijHH_t;
*ajacobien_t=gajacobien_t;*ajacobien_0=gajacobien_0;
};
// variables :
BaseB * aiB_0; BaseH * aiH_0; BaseB * aiB_t; BaseH * aiH_t;BaseB * aiB_tdt;
BaseH * aiH_tdt;
TenseurBB * aijBB_0; TenseurHH * aijHH_0;
TenseurBB * aijBB_t ; TenseurHH * aijHH_t ;TenseurBB * aijBB_tdt;TenseurHH * aijHH_tdt;
TenseurBB * curbBB_t;TenseurBB * curbBB_tdt;TenseurBB * curbBB_0;
double* ajacobien_tdt;double* ajacobien_t;double* ajacobien_0;
};
/// @} // end of group

165
Elements/ResRaid_MPI.cc
View file

@ -1,165 +0,0 @@
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "ResRaid_MPI.h"
#include <boost/mpi/environment.hpp>
#include <boost/mpi/communicator.hpp>
#include <boost/serialization/string.hpp>
#include <boost/mpi.hpp>
namespace mpi = boost::mpi;
// constructeur par défaut
ResRaid_MPI::ResRaid_MPI():
res(NULL),raid(NULL),val_de_base()
{};
// constructeur de copie
ResRaid_MPI::ResRaid_MPI (const ResRaid_MPI& a):
res(NULL),raid(NULL)
,val_de_base(a.val_de_base)
{ // création et affectation des vecteurs
Creation_res_raid(true,a.res,a.raid);
};
// fonction d'un resraid et d'un élément particulier
// avec_recopie : indique si on veut une recopie ou pas
// si false: c'est seulement les tailles qui sont utilisées
ResRaid_MPI::ResRaid_MPI(const DeuxEntiers& elem, const Vecteur* ress, const Mat_pleine* raidd,bool avec_recopie):
res(NULL),raid(NULL),val_de_base()
{ // on remplit val_de_base
// 1) on dimensionne
int taille = 2; // init avec les numéros
if (ress != NULL)
taille +=ress->Taille();
if (raidd != NULL)
taille +=raidd->Nb_ligne() * raidd->Nb_colonne();
// mise à jour de la taille globale
val_de_base.Change_taille(taille);
// affectation des numéros
val_de_base(1) = elem.un;
val_de_base(2) = elem.deux;
// création et affectation des vecteurs
Creation_res_raid(avec_recopie,ress,raidd);
};
// DESTRUCTEUR :
ResRaid_MPI::~ResRaid_MPI()
{ // comme on a fait des new, il faut faire des delete
delete res; delete raid;
} ;
// affectation à partir d'un élément particulier et d'un resraid
// opération analogue à la construction, mais dédié à une instance déjà existante
// correspond à la surcharge d'affectation, mais je préfère une fonction plus explicite !
// pour éviter des affectations non voulues
void ResRaid_MPI::Affectation(const DeuxEntiers& elem, const Vecteur* ress, const Mat_pleine* raidd)
{// tout d'abord les num
// num_elt=elem.un;
// num_maillage=elem.deux;
// // puis les conteneurs
// if (ress != NULL)
// res = *(ress);
// if (raidd != NULL)
// raid = *(raidd);
};
// 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 ResRaid_MPI::Lecture_base_info(ifstream& ent,const int cas)
{ // on suit exactement la même procédure que pour archive
// load(ent,cas);
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void ResRaid_MPI::Ecriture_base_info(ofstream& sort,const int cas)
{ // on suit exactement la même procédure que pour archive
// save(sort,cas);
};
// méthode interne pour créer les vecteurs tranches
// ce qui crée une liaison entre les deux stockages
// avec_recopie : indique si on veut une recopie ou pas
void ResRaid_MPI::Creation_res_raid(bool avec_recopie,const Vecteur* ress, const Mat_pleine* raidd)
{
double * pt = val_de_base.Pointeur_vect(); // le début du tableau
pt++; pt++; // on passe les numéros
bool memoire = false; // on va faire des tranches
if (ress != NULL)
{int taille1 = ress->Taille();
// on crée un vecteur lié
res = new Vecteur(taille1,pt,memoire);
if (avec_recopie) // on recopie si c'est demandé
*res = *ress;
pt = &pt[2+taille1]; // on pointe sur le début de la suite
};
if (raidd != NULL)
{// on crée une matrice liée
raid = new Mat_pleine(avec_recopie,pt,*raidd);
};
};
// idem pour modifier éventuellement les tailles uniquement
void ResRaid_MPI::Change_tailles_res_raid(bool avec_recopie,const Vecteur* ress, const Mat_pleine* raidd)
{
double * pt = val_de_base.Pointeur_vect(); // le début du tableau
pt++; pt++; // on passe les numéros
bool memoire = false; // on travaille avec des tranches
#ifdef MISE_AU_POINT
int taille_globale = 2; // init
if (ress != NULL)
taille_globale += ress->Taille();
if (raidd != NULL)
taille_globale += raidd->Nb_ligne() * raidd->Nb_colonne();
if (taille_globale != val_de_base.Taille())
{ cout << "\n*** Erreur : la taille de val_de_base: " << val_de_base.Taille()
<< " est differente de 2 + la taille du vecteur: " << ress->Taille()
<< " + la taille de la matrice : nb_lig*nb_col: " << raidd->Nb_ligne() * raidd->Nb_colonne();
cout << "ResRaid_MPI::Change_tailles_res_raid(.. \n" << endl;
Sortie(1);
}
#endif
//à continuer à modifier ...
// if (ress != NULL)
// {int taille1 = ress->Taille();
// // on crée un vecteur lié
// res = new Vecteur(taille1,pt,memoire);
// if (avec_recopie) // on recopie si c'est demandé
// *res = *ress;
// pt = &pt[2+taille1]; // on pointe sur le début de la suite
// };
// if (raidd != NULL)
// {// on crée une matrice liée
// raid = new Mat_pleine(avec_recopie,pt,*raidd);
// };
};

183
Elements/ResRaid_MPI.h
View file

@ -1,183 +0,0 @@
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 03/01/2022 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: une classe qui a pour objectif de servir, *
* d'interface entre un conteneur Element::ResRaid et *
* un conteneur qui est transmis entre CPU via MPI *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
************************************************************************/
#ifndef RESRAID_MPI_H
#define RESRAID_MPI_H
#include <boost/serialization/split_member.hpp>
#include <boost/mpi/packed_oarchive.hpp>
#include "Vecteur.h"
#include "Mat_pleine.h"
#include "Basiques.h"
/**
*
* BUT: une classe qui a pour objectif de servir,
* d'interface entre un conteneur Element::ResRaid et
* un conteneur qui est transmis entre CPU via MPI
*
*
* \author Gérard Rio
* \version 1.0
* \date 03/01/2022
* \brief classe d'interface entre Element::ResRaid et un conteneur transmis entre CPU via MPI
*
*/
class ResRaid_MPI
{
public :
// CONSTRUCTEURS :
// par défaut
ResRaid_MPI();
// fonction d'un resraid et d'un élément particulier
// avec_recopie : indique si on veut une recopie ou pas
// si false: c'est seulement les tailles qui sont utilisées
ResRaid_MPI(const DeuxEntiers& elem, const Vecteur* res, const Mat_pleine* raid,bool avec_recopie);
// constructeur de copie
ResRaid_MPI (const ResRaid_MPI& a);
// DESTRUCTEUR :
~ResRaid_MPI() ;
// METHODES PUBLIQUES :
// affectation à partir d'un élément particulier et d'un resraid
// opération analogue à la construction, mais dédié à une instance déjà existante
// correspond à la surcharge d'affectation, mais je préfère une fonction plus explicite !
// pour éviter des affectations non voulues
void Affectation(const DeuxEntiers& elem, const Vecteur* res, const Mat_pleine* raid);
//============= 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);
// récupération des infos
int Num_elt() const {return val_de_base(1);}; // numero d'identification de l'element
int Num_mail() const {return val_de_base(2);}; // numéro de maillage
const Vecteur & Const_res() const {return *res;}; // vecteur résidu
const Mat_pleine & Const_raid() const {return *raid ;}; // vecteur raideur
private :
// VARIABLES PROTEGEES :
// l'idée c'est d'avoir un seul gros conteneur qui englobe toutes les infos
// pour pouvoir faire un passage MPI natif: c-a-d un pointeur + un nombre
// --1) le vecteur qui contient tout
Vecteur val_de_base;
// val_de_base(1) contient le num de l'element
// val_de_base(2) contient le num du maillage
// --2) puis les grandeurs qui sont une tranche de val_de_base (vecteur et mat_pleine)
Vecteur* res; // vecteur résidu
Mat_pleine* raid ; // vecteur raideur
// méthode interne pour créer les vecteurs tranches
// ce qui crée une liaison entre les deux stockages
// avec_recopie : indique si on veut une recopie ou pas
void Creation_res_raid(bool avec_recopie,const Vecteur* ress, const Mat_pleine* raidd);
// idem pour modifier éventuellement les tailles uniquement
void Change_tailles_res_raid(bool avec_recopie,const Vecteur* ress, const Mat_pleine* raidd);
// on supprime la sérialisation, qui ne devrait plus être utilisée
// // METHODES PROTEGEES :
// // -- serialisation ---
// // NB: pas trouvé comment déclarer l'implantation des méthodes template
// // en dehors du .h, donc on décrit le fct ici en inline
// // déclaration en friend pour l'acces direct de boost
// friend class boost::serialization::access;
// // on spécialise la sauvegarde et la restitution
// // version == 0 pour la première sauvegarde et ensuite > 0
// // NB: c'est toujours la version en cours au moment de la sauvegarde
// // ==> dans notre cas, on ne sent sert pas pour l'instant: supposé tjs == 0
// template<class Archive>
// void save(Archive & ar, unsigned int version) const
// { // on commence par les num mail et élément
// ar << std::string(" num_maillage ")<< num_maillage
// << std::string(" num_elem ") << num_elt;
// // puis le vecteur résidu
// ar << res;
// // puis la raideur
// ar << raid;
// }
//
// // en lecture, le num de version permet de ce positionner sur une version particulière
// template<class Archive>
// void load(Archive & ar, const unsigned int version)
// { // opération inverse de save
// std::string toto;
// // on commence par les num mail et élément
// ar >> toto >> num_maillage
// >> toto >> num_elt;
// // puis le vecteur résidu
// ar >> res;
// // puis la raideur
// ar >> raid;
// }
//
// // la macro suivante va définir automatiquement la méthode : "serialize"
// BOOST_SERIALIZATION_SPLIT_MEMBER()
// // pour mémoire on indique l'entête de la méthode "serialize"
//// // la méthode serialize fonctionne dans les deux sens: lecture et écriture dans ar
//// // << et >> est remplacé par &
//// // le choix dépend du fait que ar est un flux entrant ou sortant
//// template<class Archive>
//// void serialize(Archive & ar, const unsigned int version);
};
#endif

310
Elements/Thermique/PtIntegThermiInterne.cc
View file

@ -1,310 +0,0 @@
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "PtIntegThermiInterne.h"
#include "NevezTenseur.h"
#include "Tenseur3.h"
#include "Tenseur2.h"
// contructeur par défaut
PtIntegThermiInterne::PtIntegThermiInterne():
temperature(0.),temperature_t(0.)
,gradTB(),dgradTB(),deltaGradTB(),fluxH(),fluxH_t()
,norme_gradT(),norme_dGradT(),norme_flux()
,tpsMetrique(),tps_cpu_loi_comp()
{};
// contructeur fonction de la dimension
PtIntegThermiInterne::PtIntegThermiInterne(int dimcoor) :
temperature(0.),temperature_t(0.)
,gradTB(dimcoor),dgradTB(dimcoor),deltaGradTB(dimcoor)
,fluxH(dimcoor),fluxH_t(dimcoor)
,norme_gradT(0.),norme_dGradT(0.),norme_flux(0.)
,tpsMetrique(),tps_cpu_loi_comp()
{ };
// contructeur de copie
PtIntegThermiInterne::PtIntegThermiInterne(const PtIntegThermiInterne& pti):
temperature(pti.temperature),temperature_t(pti.temperature_t)
,gradTB(pti.gradTB),dgradTB(pti.dgradTB),deltaGradTB(pti.deltaGradTB)
,fluxH(pti.fluxH),fluxH_t(pti.fluxH_t)
,norme_gradT(pti.norme_gradT),norme_dGradT(pti.norme_dGradT)
,norme_flux(pti.norme_flux)
,tpsMetrique(pti.tpsMetrique),tps_cpu_loi_comp(pti.tps_cpu_loi_comp)
{ };
// DESTRUCTEUR :
PtIntegThermiInterne::~PtIntegThermiInterne()
{ };
// Surcharge de l'operateur =
PtIntegThermiInterne& PtIntegThermiInterne::operator= ( const PtIntegThermiInterne& pti)
{ temperature=pti.temperature;temperature_t=pti.temperature_t;
gradTB=pti.gradTB;dgradTB=pti.dgradTB;deltaGradTB=pti.deltaGradTB;
fluxH=pti.fluxH;fluxH_t=pti.fluxH_t;
norme_gradT=pti.norme_gradT;norme_dGradT=pti.norme_dGradT;
norme_flux=pti.norme_flux;
// --- les temps cpu
tpsMetrique=pti.tpsMetrique;tps_cpu_loi_comp=pti.tps_cpu_loi_comp;
// retour
return *this;
};
//============= 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 PtIntegThermiInterne::Lecture_base_info (ifstream& ent,const int )
{ // lecture des différents éléments que l'on trouve utiles (pour l'instant)
string nom;
ent >> nom >> temperature >> nom >> temperature_t;
ent >> nom >> gradTB
>> nom >> dgradTB
>> nom >> deltaGradTB;
ent >> nom >> fluxH_t;
ent >> nom >> norme_gradT
>> nom >> norme_dGradT
>> nom >> norme_flux ;
// temps cpu
ent >> nom >> tpsMetrique >> nom >> tps_cpu_loi_comp;
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void PtIntegThermiInterne::Ecriture_base_info(ofstream& sort,const int )
{ // les différents éléments que l'on considère intéressant (pour l'instant)
sort << "\n temperature= " << temperature << " temperature_t= " << temperature_t;
sort << "\n gradTB= " << gradTB
<< " dgradTB= " << dgradTB
<< " deltaGradTB= " << deltaGradTB
<< "\n fluxDH= " << fluxH_t;
sort << "\n norme_gradT " << norme_gradT
<< " norme_dGradT= " << norme_dGradT
<< " norme_fluxD= " << norme_flux ;
sort << "\n tpsmetrique= " << tpsMetrique << " tpsLoiComp= " << tps_cpu_loi_comp;
};
// actualisation des grandeurs actives de t+dt vers t, pour celles qui existent
// sous ces deux formes
void PtIntegThermiInterne::TdtversT()
{ fluxH_t = fluxH;temperature_t=temperature;};
// actualisation des grandeurs actives de t vers tdt, pour celles qui existent
// sous ces deux formes
void PtIntegThermiInterne::TversTdt()
{ fluxH = fluxH_t;temperature=temperature_t;};
// plusZero: = true: indique qu'il faut complèter les grandeurs manquantes avec des 0
// = false: on ne complète pas
// il faut que ptintmec comporte des tenseurs d'ordre 2 et this des tenseurs 3D
void PtIntegThermiInterne::Affectation_2D_a_3D(const PtIntegThermiInterne& ptintmec,bool plusZero)
{ // vérif éventuelle des dimensions
#ifdef MISE_AU_POINT
{// - les dimensions
if (gradTB.Dimension() != 3)
{cout << "\n *** erreur la dimension de this->gradTB ("<<gradTB.Dimension() <<") est different de 3"
<< "\n PtIntegThermiInterne::Affectation_2D_a_3D(.."; Sortie(1);};
if (ptintmec.gradTB.Dimension() != 2)
{cout << "\n *** erreur la dimension de ptintmec.gradTB ("<< ptintmec.gradTB.Dimension() <<") est different de 2"
<< "\n PtIntegThermiInterne::Affectation_2D_a_3D(.."; Sortie(1);};
}
#endif
// pour tout ce qui est def
temperature_t=ptintmec.temperature_t;
temperature=ptintmec.temperature;
gradTB(1) = ptintmec.gradTB(1);gradTB(2) = ptintmec.gradTB(2);
dgradTB(1) = ptintmec.dgradTB(1);dgradTB(2) = ptintmec.dgradTB(2);
deltaGradTB(1) = ptintmec.deltaGradTB(1);deltaGradTB(2) = ptintmec.deltaGradTB(2);
fluxH(1) = ptintmec.fluxH(1);fluxH(2) = ptintmec.fluxH(2);
fluxH_t(1) = ptintmec.fluxH_t(1);fluxH_t(2) = ptintmec.fluxH_t(2);
if (plusZero)
{gradTB(3) = 0.;
dgradTB(3) = 0.;
deltaGradTB(3) = 0.;
fluxH(3) = 0.;
fluxH_t(3) = 0.;
};
norme_gradT = ptintmec.norme_gradT;
norme_dGradT = ptintmec.norme_dGradT;
norme_flux = ptintmec.norme_flux;
// --- les temps cpu
tpsMetrique=ptintmec.tpsMetrique;tps_cpu_loi_comp=ptintmec.tps_cpu_loi_comp;
};
// l'inverse: comme le conteneur d'arrivée est plus petit, il n'y a pas de complétion
// il faut que ptintmec comporte des tenseurs d'ordre 3 et this des tenseurs 2D
void PtIntegThermiInterne::Affectation_3D_a_2D(const PtIntegThermiInterne& ptintmec)
{ // vérif éventuelle des dimensions
#ifdef MISE_AU_POINT
{// - les dimensions
if (gradTB.Dimension() != 2)
{cout << "\n *** erreur la dimension de this.gradTB ("<<gradTB.Dimension() <<") est different de 2"
<< "\n PtIntegThermiInterne::Affectation_3D_a_2D(.."; Sortie(1);};
if (ptintmec.gradTB.Dimension() != 3)
{cout << "\n *** erreur la dimension de ptintmec.gradTB ("<< ptintmec.gradTB.Dimension() <<") est different de 3"
<< "\n PtIntegThermiInterne::Affectation_3D_a_2D(.."; Sortie(1);};
}
#endif
// pour tout ce qui est def
temperature_t=ptintmec.temperature_t;
temperature=ptintmec.temperature;
gradTB(1) = ptintmec.gradTB(1);gradTB(2) = ptintmec.gradTB(2);
dgradTB(1) = ptintmec.dgradTB(1);dgradTB(2) = ptintmec.dgradTB(2);
deltaGradTB(1) = ptintmec.deltaGradTB(1);deltaGradTB(2) = ptintmec.deltaGradTB(2);
fluxH(1) = ptintmec.fluxH(1);fluxH(2) = ptintmec.fluxH(2);
fluxH_t(1) = ptintmec.fluxH_t(1);fluxH_t(2) = ptintmec.fluxH_t(2);
norme_gradT = ptintmec.norme_gradT;
norme_dGradT = ptintmec.norme_dGradT;
norme_flux = ptintmec.norme_flux;
// --- les temps cpu
tpsMetrique=ptintmec.tpsMetrique;tps_cpu_loi_comp=ptintmec.tps_cpu_loi_comp;
};
// plusZero: = true: indique qu'il faut complèter les grandeurs manquantes avec des 0
// = false: on ne complète pas
// il faut que ptintmec comporte des tenseurs d'ordre 1 et this des tenseurs 3D
void PtIntegThermiInterne::Affectation_1D_a_3D(const PtIntegThermiInterne& ptintmec,bool plusZero)
{ // vérif éventuelle des dimensions
#ifdef MISE_AU_POINT
{// - les dimensions
if (gradTB.Dimension() != 3)
{cout << "\n *** erreur la dimension de this.gradTB ("<<gradTB.Dimension() <<") est different de 3"
<< "\n PtIntegThermiInterne::Affectation_1D_a_3D(.."; Sortie(1);};
if (ptintmec.gradTB.Dimension() != 1)
{cout << "\n *** erreur la dimension de ptintmec.gradTB ("<< ptintmec.gradTB.Dimension() <<") est different de 1"
<< "\n PtIntegThermiInterne::Affectation_1D_a_3D(.."; Sortie(1);};
}
#endif
// pour tout ce qui est def
temperature_t=ptintmec.temperature_t;
temperature=ptintmec.temperature;
gradTB(1) = ptintmec.gradTB(1);
dgradTB(1) = ptintmec.dgradTB(1);
deltaGradTB(1) = ptintmec.deltaGradTB(1);
fluxH(1) = ptintmec.fluxH(1);
fluxH_t(1) = ptintmec.fluxH_t(1);
if (plusZero)
{gradTB(3) = gradTB(2) = 0.;
dgradTB(3) = dgradTB(2) = 0.;
deltaGradTB(3) = deltaGradTB(2) = 0.;
fluxH(3) = fluxH(2) = 0.;
fluxH_t(3) = fluxH_t(2) = 0.;
};
norme_gradT = ptintmec.norme_gradT;
norme_dGradT = ptintmec.norme_dGradT;
norme_flux = ptintmec.norme_flux;
// --- les temps cpu
tpsMetrique=ptintmec.tpsMetrique;tps_cpu_loi_comp=ptintmec.tps_cpu_loi_comp;
};
// l'inverse: comme le conteneur d'arrivée est plus petit, il n'y a pas de complétion
// il faut que ptintmec comporte des tenseurs d'ordre 3 et this des tenseurs 1D
void PtIntegThermiInterne::Affectation_3D_a_1D(const PtIntegThermiInterne& ptintmec)
{ // vérif éventuelle des dimensions
#ifdef MISE_AU_POINT
{ // - les dimensions
if (gradTB.Dimension() != 1)
{cout << "\n *** erreur la dimension de this.gradTB ("<<gradTB.Dimension() <<") est different de 1"
<< "\n PtIntegThermiInterne::Affectation_3D_a_1D(.."; Sortie(1);};
if (ptintmec.gradTB.Dimension() != 3)
{cout << "\n *** erreur la dimension de ptintmec.gradTB ("<< ptintmec.gradTB.Dimension() <<") est different de 3"
<< "\n PtIntegThermiInterne::Affectation_3D_a_1D(.."; Sortie(1);};
}
#endif
// pour tout ce qui est def
temperature_t=ptintmec.temperature_t;
temperature=ptintmec.temperature;
gradTB(1) = ptintmec.gradTB(1);
dgradTB(1) = ptintmec.dgradTB(1);
deltaGradTB(1) = ptintmec.deltaGradTB(1);
fluxH(1) = ptintmec.fluxH(1);
fluxH_t(1) = ptintmec.fluxH_t(1);
norme_gradT = ptintmec.norme_gradT;
norme_dGradT = ptintmec.norme_dGradT;
norme_flux = ptintmec.norme_flux;
// --- les temps cpu
tpsMetrique=ptintmec.tpsMetrique;tps_cpu_loi_comp=ptintmec.tps_cpu_loi_comp;
};
// surcharge de l'operateur de lecture
istream & operator >> (istream & entree, PtIntegThermiInterne & pti)
{ // vérification du type
string nom;
entree >> nom;
#ifdef MISE_AU_POINT
if (nom != "PtIntegThermiInterne")
{ cout << "\nErreur, en lecture d'une instance PtIntegThermiInterne "
<< " on attendait PtIntegThermiInterne et on a lue: " << nom ;
cout << "istream & operator >> (istream & entree, PtIntegThermiInterne & pti)\n";
Sortie(1);
};
#endif
// puis lecture des différents éléments
entree >> nom >> pti.temperature >> nom >> pti.temperature_t;
entree >> nom >> pti.gradTB
>> nom >> pti.dgradTB
>> nom >> pti.deltaGradTB;
entree >> nom >> pti.fluxH_t;
entree >> nom >> pti.norme_gradT
>> nom >> pti.norme_dGradT
>> nom >> pti.norme_flux ;
// --- les temps cpu
entree >> nom >> pti.tpsMetrique >> nom >> pti.tps_cpu_loi_comp;
return entree;
};
// surcharge de l'operateur d'ecriture
ostream & operator << ( ostream & sort,const PtIntegThermiInterne & pti)
{ // tout d'abord un indicateur donnant le type
sort << "PtIntegThermiInterne " ;
// puis les différents éléments
sort << "\n temperature= " << pti.temperature << " temperature_t= " << pti.temperature_t;
sort << "\n gradTB= " << pti.gradTB
<< " dgradTB= " << pti.dgradTB
<< " deltaGradTB= " << pti.deltaGradTB
<< "\n fluxH= " << pti.fluxH_t;
sort << "\n norme_gradT " << pti.norme_gradT
<< " norme_dGradT= " << pti.norme_dGradT
<< " norme_flux= " << pti.norme_flux ;
sort << "\n tpsmetrique= " << pti.tpsMetrique << " tpsLoiComp= " << pti.tps_cpu_loi_comp;
return sort;
};

201
Elements/Thermique/PtIntegThermiInterne.h
View file

@ -1,201 +0,0 @@
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 06/03/2023 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Classe pour stocker les informations aux points *
* d'intégration thermique *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef PTINTEGTHERMIINTERNE_H
#define PTINTEGTHERMIINTERNE_H
#include "Tenseur.h"
#include "Vecteur.h"
#include "Temps_CPU_HZpp.h"
/// @addtogroup Groupe_concernant_les_points_integration
/// @{
///
class PtIntegThermiInterne
{// surcharge de l'operator de lecture
friend istream & operator >> (istream &, PtIntegThermiInterne &);
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream &, const PtIntegThermiInterne &);
public :
// CONSTRUCTEURS :
// contructeur par défaut
PtIntegThermiInterne();
// contructeur fonction de la dimension de tenseurs
PtIntegThermiInterne(int dimtens);
// contructeur de copie
PtIntegThermiInterne(const PtIntegThermiInterne& pti);
// DESTRUCTEUR :
~PtIntegThermiInterne();
// METHODES PUBLIQUES :
// Surcharge de l'operateur =
PtIntegThermiInterne& operator= ( const PtIntegThermiInterne& pti);
// la température
double& Temperature() {return temperature;};
// la température à t
double& Temperature_t() {return temperature_t;};
// gradient thermique finale
CoordonneeB& GradTB() {return gradTB;};
// vitesse finale du gradient thermique
CoordonneeB& DgradTB() {return dgradTB;};
// variation du gradient thermique entre t et t + delta t
CoordonneeB& DeltaGradTB() {return deltaGradTB;};
// vecteur densité du flux thermique finale
CoordonneeH& FluxH() {return fluxH;};
// vecteur densité du flux thermique en début d'incrément
CoordonneeH& FluxH_t() {return fluxH_t;};
// --- temps cpu
// tps cpu relatif à la métrique uniquement
Temps_CPU_HZpp& TpsMetrique() {return tpsMetrique;};
// temps cumulé relatif à la loi de comportement
Temps_CPU_HZpp& Tps_cpu_loi_comp() {return tps_cpu_loi_comp;};
// ---- acces idem en constants
// la température
const double& Temperature_const() const {return temperature;};
// la température à t
const double& Temperature_t_const() const {return temperature_t;};
// gradient thermique finale
const CoordonneeB & GradTB_const() const {return gradTB;};
// vitesse finale du gradient thermique
const CoordonneeB & DgradTB_const() const {return dgradTB;};
// variation du gradient thermique entre t et t + delta t
const CoordonneeB & DeltaGradTB_const() const {return deltaGradTB;};
// densité de flux finale
const CoordonneeH & FluxH_const() const {return fluxH;};
// densité de flux en début d'incrément
const CoordonneeH & FluxH_t_const() const {return fluxH_t;};
// --- temps cpu
// tps cpu relatif à la métrique uniquement
const Temps_CPU_HZpp& TpsMetrique_const() const {return tpsMetrique;};
// temps cumulé relatif à la loi de comportement
const Temps_CPU_HZpp& Tps_cpu_loi_comp_const() const {return tps_cpu_loi_comp;};
// invariant du gradient thermique
double& Norme_gradT() {return norme_gradT;};
const double& Norme_gradT_const() const {return norme_gradT;};
// invariant de la vitesse du gradient thermique
double& Norme_DGradT() {return norme_dGradT;};
const double& Norme_DGradT_const() const {return norme_dGradT;};
// invariant de la densité de flux
double& Norme_flux() {return norme_flux;};
const double& Norme_flux_const() const {return norme_flux;};
// actualisation des grandeurs actives de t+dt vers t, pour celles qui existent
// sous ces deux formes
void TdtversT();
// actualisation des grandeurs actives de t vers tdt, pour celles qui existent
// sous ces deux formes
void TversTdt();
//========= méthode particulière pour un passage de l'ordre 2D à 3D des tenseurs et l'inverse ===========
// plusZero: = true: indique qu'il faut complèter les grandeurs manquantes avec des 0
// = false: on ne complète pas
// il faut que ptintmec comporte des tenseurs d'ordre 2 et this des tenseurs 3D
void Affectation_2D_a_3D(const PtIntegThermiInterne& ptinther,bool plusZero);
// l'inverse: comme le conteneur d'arrivée est plus petit, il n'y a pas de complétion
// il faut que ptintmec comporte des tenseurs d'ordre 3 et this des tenseurs 2D
void Affectation_3D_a_2D(const PtIntegThermiInterne& ptinther);
//========= méthode particulière pour un passage de l'ordre 1D à 3D des tenseurs et l'inverse ===========
// plusZero: = true: indique qu'il faut complèter les grandeurs manquantes avec des 0
// = false: on ne complète pas
// il faut que ptintmec comporte des tenseurs d'ordre 1 et this des tenseurs 3D
void Affectation_1D_a_3D(const PtIntegThermiInterne& ptinther,bool plusZero);
// l'inverse: comme le conteneur d'arrivée est plus petit, il n'y a pas de complétion
// il faut que ptintmec comporte des tenseurs d'ordre 3 et this des tenseurs 1D
void Affectation_3D_a_1D(const PtIntegThermiInterne& ptinther);
//============= 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);
protected :
// VARIABLES PROTÉGÉES :
double temperature,temperature_t;
CoordonneeB gradTB; // gradient thermique finale
CoordonneeB dgradTB; // vitesse finale du gradient thermique
CoordonneeB deltaGradTB; // variation du gradient thermique entre t et t + delta t
CoordonneeH fluxH; // vecteur densité du flux thermique finale
CoordonneeH fluxH_t; // vecteur densité du flux thermique en début d'incrément
// ---- les invariants
double norme_gradT ; // norme du gradient thermique = invariant
double norme_dGradT ; // norme de la vitesse du gradient thermique = invariant
double norme_flux ; // norme du vecteur l densité de flux thermique
// --- temps cpu
Temps_CPU_HZpp tpsMetrique; // tps cpu relatif à la métrique uniquement
Temps_CPU_HZpp tps_cpu_loi_comp; // temps cumulé relatif à la loi de comportement
};
/// @} // end of group
#endif

928
Elements/Trans_val_multi_tensoriel.cc
View file

@ -1,928 +0,0 @@
// FICHIER : Trans_val_multi_tensoriel.cc
// CLASSE : Trans_val_multi_tensoriel
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// récupération des valeurs au numéro d'ordre = iteg pour
// les grandeur enu
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
// cas = -1 ou -2: cela signifie que la métrique vient juste d'être calculée au pti iteg
// sinon il faut recalculer qq éléments de la métrique
// NB Importante: il faut faire attention à ce que ces métriques soient identiques à celles qui ont servit
// pour le calcul des tenseurs: en particulier si c'est utilisé pour calculer les grandeurs pour le chargement
// il faut s'assurer que ce sont les "mêmes pti" qui servent pour la charge et pour la raideur !!
//Tableau <double> ElemMeca::Valeur_multi
// (bool absolue, Enum_dure temps,const List_io<Ddl_enum_etendu>& enu,int iteg,int cas
// )
//
// { // ----- def de grandeurs de travail
// // il y a deux pb a gérer: 1) le fait que la dimension absolue peut-être différente de la dimension des tenseurs
// // 2) le fait que l'on veut une sortie dans une base ad hoc ou pas
// int dim = lesPtIntegMecaInterne->DimTens();int dim_sortie_tenseur = dim;
// // dans le cas ou l'on veut une sortie en base absolue, il faut que dim_sortie_tenseur = la dimension de la base absolue
// if (absolue)
// dim_sortie_tenseur = ParaGlob::Dimension();
// // --- pour ne faire qu'un seul test ensuite
// bool prevoir_change_dim_tenseur = false;
// // initialement on faisait le test suivant,
// // if ((absolue) && (dim != dim_sortie_tenseur))
// if (absolue)
// // mais en fait, quand on sort en absolu on est obligé d'utiliser un tenseur intermédiaire
// // car BaseAbsolue(.. modifie tenseur passé en paramètre, donc dans tous les cas de sortie absolue
// // il faut un tenseur intermédiaire qui a ou non une dimension différente
// prevoir_change_dim_tenseur = true;
//
// #ifdef MISE_AU_POINT
// if(iteg > lesPtIntegMecaInterne->NbPti())
// { cout << "\n erreur, les informations demandees au pti "<<iteg <<" ne sont pas disponibles "
// << " sans doute, que l'element n'a pas ce nombre de point d'integration !! ";
// if (ParaGlob::NiveauImpression() > 3 )
// cout << "\n ElemMeca::Valeur_multi(..";
// cout << endl;
// Sortie (1);
// };
// #endif
//
// PtIntegMecaInterne & ptIntegMeca = (*lesPtIntegMecaInterne)(iteg);
// // recup de l'incrément de temps
// double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();
// double unSurDeltat=0;
// if (Abs(deltat) >= ConstMath::trespetit)
// {unSurDeltat = 1./deltat;}
// else // si l'incrément de temps est tres petit on remplace 1/deltat par un nombre tres grand
// { // un pas de temps doit être positif !! or certaine fois il peut y avoir des pb
// if (unSurDeltat < 0)
// { cout << "\n le pas de temps est négatif !! "; };
// unSurDeltat = ConstMath::tresgrand;
// };
//
// // -- def des tenseurs locaux
// TenseurHB* sigHB = NULL ; TenseurHB* sig_barreHB = NULL ;
// TenseurHB* epsHB = NULL ; TenseurHB* eps_barreHB = NULL ;
// TenseurBB* DepsBB = NULL ; TenseurHB* Deps_barreHB = NULL ;
// TenseurHB* DepsHB = NULL ;
//
// TenseurBB* epsAlmTotalBB=NULL; // pour la déformation totale d'almansi
// TenseurBB* epsGLTotalBB=NULL; // pour la déformation totale de green_lagrange
// TenseurBB* epsLogTotalBB=NULL; // pour la déformation totale logarithmique
// Coordonnee* Mtdt = NULL; // coordonnées finales éventuelles du point d'intégration considéré
// Coordonnee* Mt = NULL; // coordonnées à t éventuelles du point d'intégration considéré
// Coordonnee* M0 = NULL; // coordonnées initiales éventuelles du point d'intégration considéré
// Coordonnee* N_surf = NULL; // coordonnée d'un vecteur normal si c'est adéquate
// Coordonnee* N_surf_t = NULL; // coordonnée d'un vecteur normal à t si c'est adéquate
// Coordonnee* N_surf_t0 = NULL; // coordonnée d'un vecteur normal à t0 si c'est adéquate
// Coordonnee* Vitesse = NULL; // cas des vitesses
//
// // on définie des indicateurs pour ne pas faire plusieurs fois le même calcul
// List_io<Ddl_enum_etendu>::const_iterator ie,iefin=enu.end();
// bool besoin_des_contraintes=false; bool besoin_des_deformation=false;
// bool besoin_des_contraintes_barre=false; bool besoin_des_deformation_barre=false;
// bool besoin_des_vitesses_deformation=false; bool besoin_des_vitesse_deformation_barre=false;
// bool besoin_des_valpropre_sigma=false;
// bool besoin_des_valpropre_deformation = false; bool besoin_des_valpropre_vitdef = false;
// bool besoin_deformation_logarithmique = false; bool besoin_deformation_greenlagrange = false;
// bool besoin_deformation_almansi = false;
// bool besoin_coordonnees = false; bool besoin_deplacements = false;
// bool besoin_coordonnees_t = false;bool besoin_coordonnees_t0 = false;
// for (ie=enu.begin(); ie!=iefin;ie++)
// { if (Meme_famille((*ie).Enum(),SIG11)) besoin_des_contraintes=true;
// if (Meme_famille((*ie).Enum(),EPS11)) besoin_des_deformation=true;
// if (Meme_famille((*ie).Enum(),DEPS11)) besoin_des_vitesses_deformation=true;
// if (Meme_famille((*ie).Enum(),X1)) besoin_coordonnees=true;
// if (Meme_famille((*ie).Enum(),UX)) {besoin_deplacements=true;besoin_coordonnees=true;};
// int posi = (*ie).Position()-NbEnum_ddl();
//
// switch (posi)
// { case 1: case 2: case 3: case 4: case 5: case 6:
// {besoin_deformation_greenlagrange=true; break;}
// case 7: case 8: case 9: case 10: case 11: case 12:
// {besoin_deformation_almansi=true; break;}
// case 28: case 29: case 30: case 31: case 32:
// {besoin_des_valpropre_sigma=true; break;}
// case 25: case 26: case 27: case 77:
// {besoin_des_valpropre_deformation=true;break;}
// case 40: case 41: case 42:
// {besoin_des_valpropre_vitdef=true;break;}
// case 49: case 50: case 51: case 52: case 53: case 54:
// {besoin_deformation_logarithmique=true;break;}
// case 55: case 56: case 57: case 58: case 59: case 60:
// {if ((epsAlmTotalBB == NULL) && (dilatation))
// {epsAlmTotalBB = (NevezTenseurBB(dim_sortie_tenseur));};
// break;
// }
// case 61: case 62: case 63: case 64: case 65: case 66:
// { if ((epsGLTotalBB == NULL) && (dilatation))
// {epsGLTotalBB = (NevezTenseurBB(dim_sortie_tenseur));};
// break;
// }
// case 67: case 68: case 69: case 70: case 71: case 72:
// {if ((epsLogTotalBB == NULL) && (dilatation))
// {epsLogTotalBB = (NevezTenseurBB(dim_sortie_tenseur));};
// break;
// }
// case 78: case 79: case 80:
// {besoin_des_deformation_barre=true;break;}
// case 81: case 82: case 83:
// {besoin_des_contraintes_barre=true;break;}
// case 84: case 85: case 86:
// {besoin_des_vitesse_deformation_barre=true;break;}
// case 114: case 115: case 116: // le vecteur normal
// { N_surf = new Coordonnee(ParaGlob::Dimension()); break;}
// case 117: case 118: case 119: // le vecteur normal à t
// { N_surf_t = new Coordonnee(ParaGlob::Dimension()); break;}
// case 120: case 121: case 122: // le vecteur normal à t0
// { N_surf_t0 = new Coordonnee(ParaGlob::Dimension()); break;}
// case 123: case 124: case 125: // la position à t
// { Mt = new Coordonnee(ParaGlob::Dimension());
// besoin_coordonnees_t = true;
// break;
// }
// case 126: case 127: case 128: // la position à t0
// { M0 = new Coordonnee(ParaGlob::Dimension());
// besoin_coordonnees_t0 = true;
// break;
// }
// default:
// break;
// };
//
// };
//
//
// // -- def de tenseurs pour la sortie
// TenseurHH* sigHH = NULL ;
// TenseurBB* eps0BB = NULL ; // pour def green-lagrange
// TenseurBB* epsBB = NULL ; // pour def courante
// TenseurBB* epslogBB = NULL ; // pour def logarithmique
// TenseurBB* epsAlmBB = NULL ; // pour def d'almansi
// TenseurBB* DeltaEpsBB = NULL ;
// bool besoin_matrice_chg_base = false;
// if (besoin_des_contraintes || besoin_des_valpropre_sigma || besoin_des_contraintes_barre)
// {sigHH = (NevezTenseurHH(dim_sortie_tenseur)) ;
// sigHB = (NevezTenseurHB(dim)) ;
// sig_barreHB = (NevezTenseurHB(dim)) ;besoin_matrice_chg_base=true;
// };
// if (besoin_des_deformation || besoin_deformation_almansi || besoin_des_deformation_barre
// || besoin_deformation_greenlagrange || besoin_deformation_logarithmique )
// {eps0BB = (NevezTenseurBB(dim_sortie_tenseur)) ; // pour def green-lagrange
// epsBB = (NevezTenseurBB(dim_sortie_tenseur)) ; // pour def courante
// epslogBB = (NevezTenseurBB(dim_sortie_tenseur)) ; // pour def logarithmique
// epsAlmBB = (NevezTenseurBB(dim_sortie_tenseur)) ; // pour def d'almansi
// epsHB = (NevezTenseurHB(dim)) ; eps_barreHB = (NevezTenseurHB(dim)) ;
// DeltaEpsBB = (NevezTenseurBB(dim_sortie_tenseur)) ;
// besoin_matrice_chg_base=true;
// };
// if (besoin_des_valpropre_vitdef || besoin_des_vitesses_deformation )
// {DepsBB = (NevezTenseurBB(dim)) ; Deps_barreHB = (NevezTenseurHB(dim)) ;
// DepsHB = (NevezTenseurHB(dim)) ;
// besoin_matrice_chg_base=true;
// };
//
//
// Tableau <double> tab_ret (enu.size());
// // on recupère le tableau pour la lecture des coordonnées des tenseurs
// int nbcompo = ParaGlob::NbCompTens();
// // définition des grandeurs qui sont indépendante de la boucle sur les ddl_enum_etendue
//
// def->ChangeNumInteg(iteg); // on change le numéro de point d'intégration courant
// if (((cas == 1) || (cas == 2)))
// { // cas d'une premiere initialisation
// Tableau<Enum_variable_metrique> tab(5);
// tab(1) = iM0; tab(2) = iMt; tab(3) = iMtdt;
// tab(4) = igiH_0; tab(5) = igijHH_0;
// met->PlusInitVariables(tab) ;
// };
// // éléments de métrique et matrices de passage
// TenseurHH* gijHH=NULL;TenseurBB* gijBB=NULL;BaseB* giB=NULL;
// BaseH* giH_0=NULL;BaseH* giH=NULL;
// BaseB* giB_0=NULL;
// BaseB* giB_t=NULL; // n'est définit "que" pour certains cas
// Mat_pleine* Aa0 = NULL;Mat_pleine* Aafin = NULL;
// Mat_pleine* gamma0 = NULL;Mat_pleine* gammafin = NULL;
// Mat_pleine* beta0 = NULL;Mat_pleine* betafin = NULL;
// if (besoin_matrice_chg_base)
// // dans le cas où on n'est pas en absolue => on sort dans un repère ad hoc donc
// // il a la dimension locale
// // sinon on sort dans le repère globale => il a la dimension globale
// {int dim_effective = dim; // init
// if (absolue) dim_effective = ParaGlob::Dimension();
// Aa0 = new Mat_pleine(dim_effective,dim_effective);
// Aafin = new Mat_pleine(dim_effective,dim_effective);
// gamma0 = new Mat_pleine(dim_effective,dim_effective);
// gammafin = new Mat_pleine(dim_effective,dim_effective);
// beta0 = new Mat_pleine(dim_effective,dim_effective);
// betafin = new Mat_pleine(dim_effective,dim_effective);
// };
//
// switch (cas)
// { case 1: case 11:
// // calcul d'une ortho interessance de visualisation des tenseurs
// // cas de tenseur 3D -> Ia, cas 1D on prend un vecteur norme collineaire
// // avec g1, dans le cas 2D
// // la nouvelle base gamma est calculee dans def par projection de "Ipa" sur Galpha
// // le resultat est une matrice de passage utilisable pour le changement de base
// // Aa(i,a) = Aa^i_{.a}, avec g^i = Aa^i_{.a} * Ip^a
// // tout ce passe comme si Ip^a est la nouvelle base vers laquelle on veut évoluer
// {if (besoin_matrice_chg_base)
// {const Met_abstraite::InfoImp& ex = def->RemontImp(absolue,*Aa0,*Aafin);
// gijHH = ex.gijHH_tdt;gijBB = ex.gijBB_tdt;
// giB = ex.giB_tdt; giH_0 = ex.giH_0;giH = ex.giH_tdt;
// giB_0 = ex.giB_0;
// }
// else
// {const Met_abstraite::InfoImp& ex = def->RemontImp();
// gijHH = ex.gijHH_tdt;gijBB = ex.gijBB_tdt;
// giB = ex.giB_tdt; giH_0 = ex.giH_0;giH = ex.giH_tdt;
// giB_0 = ex.giB_0;
// };
// break;
// }
// case -1: case -2:
// // identique au cas 1 mais avec le fait que la métrique est directement disponible
// // car le calcul est supposé suivre un calcul implicit au bon pti
// {if (besoin_matrice_chg_base)
// {Mat_pleine Aat(dim,dim);
// // a priori Aat ne sert pas par la suite, mais est nécessaire pour le passage de par
// const Met_abstraite::Info_et_metrique_0_t_tdt ex
// = def->Remont_et_metrique_0_t_tdtSansCalMet(absolue,*Aa0,Aat,*Aafin);
// gijHH = ex.gijHH_tdt;gijBB = ex.gijBB_tdt;
// giB = ex.giB_tdt; giH_0 = ex.giH_0;giH = ex.giH_tdt;
// giB_0 = ex.giB_0;giB_t = ex.giB_t;
// }
// else
// {const Met_abstraite::Info_et_metrique_0_t_tdt ex = def->Remont_et_metrique_0_t_tdtSansCalMet();
// gijHH = ex.gijHH_tdt;gijBB = ex.gijBB_tdt;
// giB = ex.giB_tdt; giH_0 = ex.giH_0;giH = ex.giH_tdt;
// giB_0 = ex.giB_0;giB_t = ex.giB_t;
// }
// break;
// }
// case 2: case 12:
// // resultat a t
// {if (besoin_matrice_chg_base)
// {const Met_abstraite::InfoExp_tdt& ex= def->RemontExp_tdt(absolue,*Aa0,*Aafin);
// gijHH = ex.gijHH_tdt;gijBB = ex.gijBB_tdt;
// giB = ex.giB_tdt; giH_0 = ex.giH_0;giH = ex.giH_tdt;
// giB_0 = ex.giB_0;
// }
// else
// {const Met_abstraite::InfoExp_tdt& ex= def->RemontExp_tdt();
// gijHH = ex.gijHH_tdt;gijBB = ex.gijBB_tdt;
// giB = ex.giB_tdt; giH_0 = ex.giH_0;giH = ex.giH_tdt;
// giB_0 = ex.giB_0;
// }
// break;
// };
// default:
// cout << "\n *** cas non prevu cas = "<< cas
// << "\n ElemMeca::Valeur_multi(..." << endl;
// Sortie(1);
// };
// if (besoin_matrice_chg_base)
// {// pour les formules de passage de repère il nous faut :
// // Ip_a = beta_a^{.j} g_j et Ip^b = gamma^b_{.j} g^j
// // on a: [beta_a^{.j}] = [Aa^j_{.a}]^T
// // et [gamma^b_{.j}] = [beta_a^{.j}]^{-1T} = [Aa^j_{.a}]^{-1}
// (*gamma0) = (Aa0->Inverse());
// (*gammafin) = (Aafin->Inverse());
// // on détermine également les matrices beta
// (*beta0) = (Aa0->Transpose());
// (*betafin) = (Aafin->Transpose());
// };
//
// // définition des tenseurs si nécessaire
//
//
// // ----- maintenant on calcule les grandeurs nécessaires -----
// // calcul des tenseurs
// bool plusZero = true; // s'il faut rajouter des termes, on met des 0
// if (besoin_des_contraintes)
// { if (absolue) {(ptIntegMeca.SigHH())->BaseAbsolue(*sigHH,*giB);}// changement de base finale
// else {(*sigHH) = *(ptIntegMeca.SigHH());sigHH->ChBase(*gammafin);};
// (*sigHB) = *(ptIntegMeca.SigHH()) * (*gijBB);
// };
// if (besoin_des_deformation)
// {(*epsHB) = (*gijHH) * (*(ptIntegMeca.EpsBB()));
// if (absolue)// changement de base finale
// {(ptIntegMeca.DeltaEpsBB())->BaseAbsolue((*DeltaEpsBB),*giH);
// (ptIntegMeca.EpsBB())->BaseAbsolue((*epsBB),*giH);}
// else {(*DeltaEpsBB) = *(ptIntegMeca.DeltaEpsBB());DeltaEpsBB->ChBase(*betafin);
// (*epsBB) = *(ptIntegMeca.EpsBB());epsBB->ChBase(*betafin);};
// switch (def->Type_de_deformation())
// { case DEFORMATION_STANDART : // c'est à dire almansi
// { // Green-Lagrange
// if ( besoin_deformation_greenlagrange)
// { if (absolue) {(ptIntegMeca.EpsBB())->BaseAbsolue((*eps0BB),*giH_0);}// changement de base finale
// else {(*eps0BB) = *(ptIntegMeca.EpsBB());eps0BB->ChBase(*beta0);};
// };
// (*epsAlmBB) = (*epsBB);
// if (epsAlmTotalBB!=NULL) // cas avec dilatation et demande de def Almansi totale
// {TenseurBB* epsAlmTotal_local_BB = epsAlmTotalBB; // par défaut
// if (prevoir_change_dim_tenseur)
// epsAlmTotal_local_BB = NevezTenseurBB(dim);
// def->Cal_deformation (temps,*epsAlmTotal_local_BB);
// if (absolue)// changement de base finale
// {epsAlmTotal_local_BB->BaseAbsolue(*epsAlmTotalBB,*giH);}
// else {epsAlmTotalBB->ChBase(*betafin);}; // ici epsAlmTotal_local_BB == epsAlmTotalBB
// if (prevoir_change_dim_tenseur) delete epsAlmTotal_local_BB; // car pas utilisé ensuite
// };
//
// if (epsGLTotalBB!=NULL) // cas avec dilatation et demande de def Green_Lagrange totale
// {TenseurBB* epsGLTotal_local_BB = epsGLTotalBB; // par défaut
// if (prevoir_change_dim_tenseur)
// epsGLTotal_local_BB = NevezTenseurBB(dim);
// def->Cal_deformation (temps,*epsGLTotal_local_BB);
// if (absolue)// changement de base finale
// {epsGLTotal_local_BB->BaseAbsolue(*epsGLTotalBB,*giH_0);}
// else {epsGLTotalBB->ChBase(*beta0);}; // ici epsGLTotal_local_BB == epsGLTotalBB
// if (prevoir_change_dim_tenseur) delete epsGLTotal_local_BB; // car pas utilisé ensuite
// };
// // si l'on veut sortir la déformation logarithmique le plus simple est de la calculer
// if ((besoin_deformation_logarithmique) || (epsLogTotalBB!=NULL))
// {def->Change_type_de_deformation(DEFORMATION_LOGARITHMIQUE);
// if (besoin_deformation_logarithmique) // cas du calcul de la def logarithmique
// {TenseurBB* epslog_local_BB = epslogBB; // par défaut
// if (prevoir_change_dim_tenseur)
// epslog_local_BB = NevezTenseurBB(dim);
// def->Cal_deformation (temps,*epslog_local_BB);
// if (absolue)// changement de base finale
// {epslog_local_BB->BaseAbsolue((*epslogBB),*giH);}
// else {epslogBB->ChBase(*betafin);}; // ici epslog_local_BB == epslogBB
// if (prevoir_change_dim_tenseur)
// delete epslog_local_BB; // car pas utilisé ensuite
// };
// if (epsLogTotalBB!=NULL) // cas avec dilatation et demande de def log totale
// {TenseurBB* epsLogTotal_local_BB = epsLogTotalBB; // par défaut
// if (prevoir_change_dim_tenseur)
// epsLogTotal_local_BB = NevezTenseurBB(dim);
// def->Cal_deformation (temps,*epsLogTotal_local_BB);
// if (absolue)// changement de base finale
// {epsLogTotal_local_BB->BaseAbsolue(*epsLogTotalBB,*giH);}
// else {epsLogTotalBB->ChBase(*betafin);}; // ici epsLogTotal_local_BB == epsLogTotalBB
// if (prevoir_change_dim_tenseur) delete epsLogTotal_local_BB; // car pas utilisé ensuite
// };
// def->Change_type_de_deformation(DEFORMATION_STANDART); // on revient au type initial
// };
// break;
// }
// case DEFORMATION_LOGARITHMIQUE :
// { (*epslogBB) = (*epsBB);
// if (epsLogTotalBB!=NULL) // cas avec dilatation et demande de def log totale
// {TenseurBB* epsLogTotal_local_BB = epsLogTotalBB; // par défaut
// if (prevoir_change_dim_tenseur)
// epsLogTotal_local_BB = NevezTenseurBB(dim);
// def->Cal_deformation (temps,*epsLogTotal_local_BB);
// if (absolue)// changement de base finale
// {epsLogTotal_local_BB->BaseAbsolue(*epsLogTotalBB,*giH);}
// else {epsLogTotalBB->ChBase(*betafin);}; // ici epsLogTotal_local_BB == epsLogTotalBB
// if (prevoir_change_dim_tenseur) delete epsLogTotal_local_BB; // car pas utilisé ensuite
// };
// // si l'on veut sortir la déformation d'Almansi ou de green-lagrange le plus simple est de les calculer
// if (( besoin_deformation_greenlagrange || besoin_deformation_almansi)
// || (epsAlmTotalBB!=NULL) || (epsGLTotalBB!=NULL))
// {def->Change_type_de_deformation(DEFORMATION_STANDART);
// if ( ( besoin_deformation_greenlagrange || besoin_deformation_almansi) ) // cas de la def d'almansi
// { TenseurBB* eps_local_BB = epsAlmBB; // par défaut
// if (prevoir_change_dim_tenseur)
// eps_local_BB = NevezTenseurBB(dim);
// def->Cal_deformation (temps,*eps_local_BB);
// if (absolue)// changement de base finale
// {eps_local_BB->BaseAbsolue(*epsAlmBB,*giH);
// eps_local_BB->BaseAbsolue(*eps0BB,*giH_0);}
// else {epsAlmBB->ChBase(*betafin);
// eps0BB->ChBase(*beta0);};// ici eps_local_BB == epsAlmBB
// };
// if (epsAlmTotalBB!=NULL) // cas avec dilatation et demande de def Almansi totale
// {TenseurBB* epsAlmTotal_local_BB = epsAlmTotalBB; // par défaut
// if (prevoir_change_dim_tenseur)
// epsAlmTotal_local_BB = NevezTenseurBB(dim);
// def->Cal_deformation (temps,*epsAlmTotal_local_BB);
// if (absolue)// changement de base finale
// {epsAlmTotal_local_BB->BaseAbsolue(*epsAlmTotalBB,*giH);}
// else {epsAlmTotalBB->ChBase(*betafin);}; // ici epsAlmTotal_local_BB == epsAlmTotalBB
// if (prevoir_change_dim_tenseur) delete epsAlmTotal_local_BB; // car pas utilisé ensuite
// };
// if (epsGLTotalBB!=NULL) // cas avec dilatation et demande de def Green_Lagrange totale
// {TenseurBB* epsGLTotal_local_BB = epsGLTotalBB; // par défaut
// if (prevoir_change_dim_tenseur)
// epsGLTotal_local_BB = NevezTenseurBB(dim);
// def->Cal_deformation (temps,*epsGLTotal_local_BB);
// if (absolue)// changement de base finale
// {epsGLTotal_local_BB->BaseAbsolue(*epsGLTotalBB,*giH_0);}
// else {epsGLTotalBB->ChBase(*beta0);}; // ici epsGLTotal_local_BB == epsGLTotalBB
// if (prevoir_change_dim_tenseur) delete epsGLTotal_local_BB; // car pas utilisé ensuite
// };
// def->Change_type_de_deformation(DEFORMATION_LOGARITHMIQUE); // on revient au type initial
// };
// break;
// }
// default:
// cout << "\n cas de deformation non encore implante en sortie de visualisation "
// << Nom_type_deformation(def->Type_de_deformation())
// << " affichage donc errone des valeurs !!!";
// };
// };
// if (besoin_des_vitesses_deformation)
// { if (absolue) {(ptIntegMeca.DepsBB())->BaseAbsolue(*DepsBB,*giH);}// changement de base finale
// else {(*DepsBB) = *(ptIntegMeca.DepsBB());DepsBB->ChBase(*betafin);};
// (*DepsHB) = (*gijHH) * (*(ptIntegMeca.DepsBB()));
// };
//
// int caas=0; Coordonnee valPropreSig,valPropreEps,valPropreDeps; // init a dim=0
// if (besoin_des_valpropre_sigma)
// {valPropreSig = sigHB->ValPropre(caas);
// if (caas == -1)
// { cout << "\n warning *** erreur dans le calcul des valeurs propres de la contrainte (Valeur_multi)";
// if (ParaGlob::NiveauImpression() >= 7) {sigHB->Ecriture(cout); cout << "\nElemMeca::Valeur_multi(...";};
// cout << endl;
// // valPropreSig = sigHB.ValPropre(caas); // !!!!!!! pour débug
// };
// };
// if (besoin_des_valpropre_deformation)
// {valPropreEps = epsHB->ValPropre(caas);
// if (caas == -1) { cout << "\n warning *** erreur dans le calcul des valeurs propres de la deformation";
// if (ParaGlob::NiveauImpression() >= 7) {epsHB->Ecriture(cout); cout << "\nElemMeca::Valeur_multi(...";};
// cout << endl;};
// };
// if (besoin_des_valpropre_vitdef)
// {valPropreDeps = DepsHB->ValPropre(caas);
// if (caas == -1) { cout << "\n warning *** erreur dans le calcul des valeurs propres de la vitesse de deformation";
// if (ParaGlob::NiveauImpression() >= 7) {DepsHB->Ecriture(cout); cout << "\nElemMeca::Valeur_multi(...";};
// cout << endl;};
// };
// if (besoin_coordonnees)
// {Mtdt = new Coordonnee(ParaGlob::Dimension());
// *Mtdt = def->Position_tdt();
// }
// if (besoin_coordonnees_t )
// {*Mt = def->Position_tdt();
// };
// if (besoin_deplacements || besoin_coordonnees_t0)
// {if (M0 == NULL)
// M0 = new Coordonnee(ParaGlob::Dimension());
// (*M0) = def->Position_0();
// };
// if (Vitesse != NULL)
// {Vitesse = new Coordonnee(ParaGlob::Dimension());
// (*Vitesse) = def->VitesseM_tdt();
// }
// if (besoin_des_contraintes_barre)
// {double Isig = sigHB->Trace(); // trace de la déformation
// (*sig_barreHB) = (*sigHB) - (Isig/ParaGlob::Dimension()) * (*Id_dim_HB(dim));
// };
// if (besoin_des_deformation_barre)
// {double Ieps = epsHB->Trace(); // trace de la déformation
// (*eps_barreHB) = (*epsHB) - (Ieps/ParaGlob::Dimension()) * (*Id_dim_HB(dim));
// };
// if (besoin_des_vitesse_deformation_barre)
// {double IDeps = DepsHB->Trace(); // trace de la déformation
// (*Deps_barreHB) = (*DepsHB) - (IDeps/ParaGlob::Dimension()) * (*Id_dim_HB(dim));
// };
//
// // def éventuelle de la contrainte de Mises
// double Mises = 0.; Coordonnee& vv = valPropreSig; int dimvec=vv.Dimension();// pour condenser l'écriture
// switch (dimvec) // dans le cas où dimvec=0 on ne fait rien, cas ou on n'a pas besoin de mises
// { case 1: Mises = Dabs(vv(1)); break;
// case 2: Mises = sqrt( ((vv(1)-vv(2))*(vv(1)-vv(2)) + vv(1) * vv(1)
// + vv(2) * vv(2)) * 0.5); break;
// case 3: Mises = sqrt( ((vv(1)-vv(2))*(vv(1)-vv(2)) + (vv(1)-vv(3))*(vv(1)-vv(3))
// + (vv(3)-vv(2))*(vv(3)-vv(2))) * 0.5); break;
// };
//
// // def éventuelle du vecteur normal: ceci n'est correct qu'avec une métrique 2D
// if (N_surf != NULL)
// { // on vérifie que la métrique est correcte
// if (giB->NbVecteur() != 2)
// {if (ParaGlob::NiveauImpression() > 0)
// {cout << "\n *** attention il ne s'agit pas d'un element 2D,"
// << " le vecteur normal ne sera pas disponible";
// if (ParaGlob::NiveauImpression() > 2)
// cout << "\n element: " << Num_elt() << " pti "<< iteg
// << "\n ElemMeca::Valeur_multi(... ";
// };
// cout << endl;
// }
// else // sinon c'est ok
// {// la normale vaut le produit vectoriel des 2 premiers vecteurs
// (*N_surf) = Util::ProdVec_coorBN( (*giB)(1), (*giB)(2));
// N_surf->Normer(); // que l'on norme
// };
// // on n'arrête pas l'exécution, car on pourrait vouloir sortir les normales pour un ensemble
// // d'éléments contenant des volumes, des surfaces, des lignes: bon... il y aura quand même des
// // pb au niveau des iso par exemple, du au fait que l'on va faire des moyennes sur des éléments
// // de type différents (à moins de grouper par type du coup on n'aura pas le warning
// };
// // idem à l'instant t
// if (N_surf_t != NULL)
// { // on vérifie que la métrique est correcte
// if (giB_t->NbVecteur() != 2)
// {if (ParaGlob::NiveauImpression() > 0)
// {cout << "\n *** attention il ne s'agit pas d'une metrique 2D 2D,"
// << " le vecteur normal ne sera pas correctement calcule";
// if (ParaGlob::NiveauImpression() > 2)
// cout << "\n ElemMeca::Valeur_multi_interpoler_ou_calculer(... ";
// };
// cout << endl;
// }
// else // sinon c'est ok
// {// la normale vaut le produit vectoriel des 2 premiers vecteurs
// (*N_surf_t) = Util::ProdVec_coorBN( (*giB_t)(1), (*giB_t)(2));
// N_surf_t->Normer(); // que l'on norme
// };
// };
// // idem à l'instant t0
// if (N_surf_t0 != NULL)
// { // on vérifie que la métrique est correcte
// if (giB_0->NbVecteur() != 2)
// {if (ParaGlob::NiveauImpression() > 0)
// {cout << "\n *** attention il ne s'agit pas d'une metrique 2D 2D,"
// << " le vecteur normal ne sera pas correctement calcule";
// if (ParaGlob::NiveauImpression() > 2)
// cout << "\n ElemMeca::Valeur_multi_interpoler_ou_calculer(... ";
// };
// cout << endl;
// }
// else // sinon c'est ok
// {// la normale vaut le produit vectoriel des 2 premiers vecteurs
// (*N_surf_t0) = Util::ProdVec_coorBN( (*giB_0)(1), (*giB_0)(2));
// N_surf_t0->Normer(); // que l'on norme
// };
// };
//
// // def éventuelle de la déformation duale de mises = sqrt(2/3 * epsB:epsB)
////--- on utilise directement la grandeur stockée au pt d'integ, mais ici ne sert à rien, puis cette grandeur n'est pas utilisée par la suite !
//
//
//// // l'expression est la même que celle de mises, ormis un coeff 4/9 qui permet de passer de 3/2 à 2/3
//// double defDualMises = 0.; Coordonnee& vdef = valPropreEps; int dimvdef=vdef.Dimension();// pour condenser l'écriture
//// switch (dimvdef) // dans le cas où dimvdef=0 on ne fait rien, cas ou on n'a pas besoin de defDualMises
//// { case 1: defDualMises = Dabs(vdef(1)); break;
//// case 2: defDualMises = sqrt( ((vdef(1)-vdef(2))*(vdef(1)-vdef(2)) + vdef(1) * vdef(1)
//// + vdef(2) * vdef(2)) * 2./9.); break;
//// case 3: defDualMises = sqrt( ((vdef(1)-vdef(2))*(vdef(1)-vdef(2)) + (vdef(1)-vdef(3))*(vdef(1)-vdef(3))
//// + (vdef(3)-vdef(2))*(vdef(3)-vdef(2))) * 2./9.); break;
//// };
//
// // donnees propre a la loi mécanique au pt d'integ
// Loi_comp_abstraite::SaveResul * sDon = tabSaveDon(iteg);
// // donnees propre a la loi thermo physique au pt d'integ
// CompThermoPhysiqueAbstraite::SaveResul* sTP=NULL; // les données spécifique thermo physiques
// if (loiTP != NULL) {sTP = tabSaveTP(iteg);}; // au pt d'integ si elles existes
// // donnees propre a la déformation mécanique au pt d'integ
// Deformation::SaveDefResul * sDefDon = tabSaveDefDon(iteg);
//
// // pour la sortie des grandeurs polaires (def et contrainte)
// double mini_Q = 5.e-5;
// double * Q_eps=NULL,* Q_sig=NULL,* Q_Deps;
//
// //----- fin du calcul des grandeurs nécessaires -----
//
// // on balaie maintenant la liste des grandeurs à sortir
// int it; // it est l'indice dans le tableau de retour
// for (it=1,ie=enu.begin(); ie!=iefin;ie++,it++)
// { // dans le cas où c'est une contrainte, une déformation ou d'une vitesse de déformation
// // il y a préparation des grandeurs à sortir
// if ((Meme_famille((*ie).Enum(),SIG11)) || (Meme_famille((*ie).Enum(),EPS11))
// || (Meme_famille((*ie).Enum(),DEPS11)) || (Meme_famille((*ie).Enum(),X1))
// || (Meme_famille((*ie).Enum(),UX)) )
// {// def du numéro de référence du ddl_enum_etendue
// int posi = (*ie).Position()-NbEnum_ddl();
// // récupération des informations en fonction des différents cas
// // **** 1 >>>>> -- cas des ddl pur, que l'on sort dans le repère global par défaut
// // cas des contraintes
// if ((Meme_famille((*ie).Enum(),SIG11)) && ((*ie).Nom_vide()))
// { // récup de l'ordre
// Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*sigHH)(ij.i,ij.j);
// }
// else if ((Meme_famille((*ie).Enum(),EPS11)) && ((*ie).Nom_vide()))
// { // récup de l'ordre
// Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*epsBB)(ij.i,ij.j);
// }
// else if ((Meme_famille((*ie).Enum(),DEPS11)) && ((*ie).Nom_vide()))
// { // récup de l'ordre
// Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*DepsBB)(ij.i,ij.j);
// }
// else if ((Meme_famille((*ie).Enum(),X1)) && ((*ie).Nom_vide()))
// { tab_ret(it)= (*Mtdt)((*ie).Enum() - X1 +1);
// }
// else if ((Meme_famille((*ie).Enum(),UX)) && ((*ie).Nom_vide()))
// { int i_cor = (*ie).Enum() - UX +1; // l'indice de coordonnée
// tab_ret(it)= (*Mtdt)(i_cor) - (*M0)(i_cor);
// }
// else if ((Meme_famille((*ie).Enum(),V1)) && ((*ie).Nom_vide()))
// { int i_cor = (*ie).Enum() - V1 +1; // l'indice de coordonnée
// tab_ret(it)= (*Vitesse)(i_cor);
// }
// // --- a complèter ----
//
// else
// {// **** 2 >>>>> -- cas des grandeurs déduites des ddl pures
// switch (posi)
// { case 1: case 2: case 3: case 4: case 5: case 6:
// /*Green-Lagrange */
// { Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*eps0BB)(ij.i,ij.j);break;}
// case 7: case 8: case 9: case 10: case 11: case 12:
// /*Almansi */ { Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*epsAlmBB)(ij.i,ij.j);break;}
// case 49: case 50: case 51: case 52: case 53: case 54:
// /*logarithmique */ { Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*epslogBB)(ij.i,ij.j);break;}
// case 55: case 56: case 57: case 58: case 59: case 60:
// /*Almansi totale */ { Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*epsAlmTotalBB)(ij.i,ij.j);break;}
// case 61: case 62: case 63: case 64: case 65: case 66:
// /*Green_Lagrange totale */ { Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*epsGLTotalBB)(ij.i,ij.j);break;}
// case 67: case 68: case 69: case 70: case 71: case 72:
// /*Log totale */ { Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*epsLogTotalBB)(ij.i,ij.j);break;}
// case 13: case 14: case 15: case 16: case 17: case 18:
// /*Cauchy_local */ { Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*ptIntegMeca.SigHH())(ij.i,ij.j);break;}
// case 19: case 20: case 21: case 22: case 23: case 24:
// /*Almansi_local */ { Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*ptIntegMeca.EpsBB())(ij.i,ij.j);break; }
// case 25: /*Def_principaleI*/ tab_ret(it)=valPropreEps(1);break;
// case 26: /*Def_principaleII*/
// if (valPropreEps.Dimension() > 1) {tab_ret(it)=valPropreEps(2);} else {tab_ret(it)= 0.;};break;
// case 27: /*Def_principaleIII*/
// if (valPropreEps.Dimension() > 2) {tab_ret(it)=valPropreEps(3);} else {tab_ret(it)= 0.;};break;
// case 28: /*Sigma_principaleI*/ tab_ret(it)=valPropreSig(1);break;
// case 29: /*Sigma_principaleII*/
// if (valPropreSig.Dimension() > 1) {tab_ret(it)=valPropreSig(2);} else {tab_ret(it)= 0.;};break;
// case 30: /*Sigma_principaleIII*/
// if (valPropreSig.Dimension() > 2) {tab_ret(it)=valPropreSig(3);} else {tab_ret(it)= 0.;};break;
// case 31: /*contrainte_mises*/ tab_ret(it)=Mises;break;
//// case 77: /*def_duale_mises*/ tab_ret(it)=defDualMises;break;
// case 77: /*def_duale_mises*/ tab_ret(it)=ptIntegMeca.Deformation_equi_const()(2);break;
// case 87: /*def_equivalente*/ tab_ret(it)=ptIntegMeca.Deformation_equi_const()(1);break;
// case 88: /*def_duale_mises_maxi*/ tab_ret(it)=ptIntegMeca.Deformation_equi_const()(3);break;
// case 89: /*vitesse_def_equivalente*/ tab_ret(it)=ptIntegMeca.Deformation_equi_const()(4) * unSurDeltat;break;
// case 32: /*contrainte_tresca*/
// { switch (dim)
// {case 1: tab_ret(it)=0.5 * valPropreSig(1);break;
// case 2: tab_ret(it)=0.5 * (valPropreSig(1)-valPropreSig(2));break;
// case 3: tab_ret(it)=0.5 * (valPropreSig(1)-valPropreSig(3));break;
// }
// break;
// }
// case 33: /*def_plastique_cumulee*/
// { string nom_comport(loiComp->Nom_comport());
// if ((strstr(nom_comport.c_str(),"PRANDTL_REUSS")!=NULL))
// { tab_ret(it) = tabSaveDon(iteg)->Deformation_plastique();
// }
// else
// { cout << "\n erreur, la déformation plastique n'est pas disponible"
// << "dans l element " << this->Num_elt()
// << "\n ElemMeca::Valeur_multi(....";
// Sortie(1);
// }
// break;
// }
// case 34: case 35: case 36: case 37: case 38: case 39:
// /*Vit_def11 et suite */ { Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*DepsBB)(ij.i,ij.j);break; }
// case 40: /*Vit_principaleI*/ tab_ret(it)=valPropreDeps(1);break;
// case 41: /*Vit_principaleII*/
// if (valPropreDeps.Dimension() > 1) {tab_ret(it)=valPropreDeps(2);} else {tab_ret(it)= 0.;};break;
// case 42: /*Vit_principaleIII*/ tab_ret(it)=valPropreDeps(3);break;
// if (valPropreDeps.Dimension() > 2) {tab_ret(it)=valPropreDeps(3);} else {tab_ret(it)= 0.;};break;
// case 43: case 44: case 45: case 46: case 47: case 48:
// /*Delta_def11 et suite */ { Deuxentiers_enu ij = IJind((*ie).Enum(),nbcompo);
// tab_ret(it)= (*DeltaEpsBB)(ij.i,ij.j);break; }
// case 73: /*energie_elastique*/
// if (temps==TEMPS_tdt) {tab_ret(it)=tab_energ(iteg).EnergieElastique();}
// else {tab_ret(it)=tab_energ_t(iteg).EnergieElastique();};break;
// case 74: /*dissipation_plastique*/
// if (temps==TEMPS_tdt) {tab_ret(it)=tab_energ(iteg).DissipationPlastique();}
// else {tab_ret(it)=tab_energ_t(iteg).DissipationPlastique();};break;
// case 75: /*dissipation_visqueuse*/
// if (temps==TEMPS_tdt) {tab_ret(it)=tab_energ(iteg).DissipationVisqueuse();}
// else {tab_ret(it)=tab_energ_t(iteg).DissipationVisqueuse();};break;
//
// case 78: /*Spherique_eps*/ tab_ret(it)=epsHB->Trace()/3.; break; //ParaGlob::Dimension();break; modi du 5/2/2012
// case 79: /*Q_eps*/ {Q_eps = new double; tab_ret(it)=*Q_eps = sqrt(eps_barreHB->II());break;}
// case 80: /*Cos3phi_eps*/
// { double Qepsilon = ( (Q_eps!=NULL) ? *Q_eps : sqrt(eps_barreHB->II()));
// double Qepsilon3 = Qepsilon * Qepsilon * Qepsilon;
// if (Qepsilon > mini_Q )
// { // on peut calculer un cos3phi pas débile
// double bIIIb = eps_barreHB->III() / 3.;
// tab_ret(it) = 3. * sqrt(6.) * bIIIb/ Qepsilon3;
//////------ debug
////cout << "\n debug: ElemMeca::Valeur_multi "
//// << "\n Qepsilon3= "<< Qepsilon3 << " bIIIb= "<< bIIIb
//// << " Cos3phi_eps= " << tab_ret(it) << " ";
////
//////--- fin debug
// }
// else tab_ret(it)=0.; // sinon on le met à 0
// break;
// }
// case 81: /*Spherique_sig*/ tab_ret(it)=sigHB->Trace()/ParaGlob::Dimension();;break;
// case 82: /*Q_sig*/ {Q_sig = new double; tab_ret(it)=*Q_sig = sqrt(sig_barreHB->II());break;}
// case 83: /*Cos3phi_sig*/
// { double Qsig = ( (Q_sig!=NULL) ? *Q_sig : sqrt(sig_barreHB->II()));
// double Qsig3 = Qsig * Qsig * Qsig;
// if (Qsig > mini_Q )
// { // on peut calculer un cos3phi pas débile
// double bIIIb = sig_barreHB->III() / 3.;
// tab_ret(it) = 3. * sqrt(6.) * bIIIb/ Qsig3;
// }
// else tab_ret(it)=0.; // sinon on le met à 0
// break;
// }
// case 84: /*Spherique_Deps*/ tab_ret(it)=DepsHB->Trace()/ParaGlob::Dimension();break;
// case 85: /*Q_Deps*/ {Q_Deps = new double; tab_ret(it)=*Q_Deps = sqrt(Deps_barreHB->II());break;}
// case 86: /*Cos3phi_Deps*/
// { double QDepsilon = ( (Q_Deps!=NULL) ? *Q_Deps : sqrt(Deps_barreHB->II()));
// double QDepsilon3 = QDepsilon * QDepsilon * QDepsilon;
// if (QDepsilon > mini_Q )
// { // on peut calculer un cos3phi pas débile
// double bIIIb = Deps_barreHB->III() / 3.;
// tab_ret(it) = 3. * sqrt(6.) * bIIIb/ QDepsilon3;
// }
// else tab_ret(it)=0.; // sinon on le met à 0
// break;
// }
//// le cas 94 est a priori ok, mais il y a un pb de logique: en fait les pti d'efforts externes ne sont pas
//// a priori les mêmes que ceux de la raideur, donc cela va entrainer des pb
//// il faudrait une autre méthode spécifique aux efforts externes.
//// je laisse le code en prévision, mais je commente pour éviter les pb
//
//// case 94: /* "pression_ext */
//// { if (lesChargeExtSurEle != NULL)
//// {if (lesChargeExtSurEle->LesPressionsExternes() != NULL) // cas où il existe des pressions sauvegardées
//// { Tableau <Tableau <Pression_appliquee> >& lesPressionsExternes = *lesChargeExtSurEle->LesPressionsExternes();
//// int nb_face = lesPressionsExternes.Taille();
//// if (nb_face != 1)
//// {cout << "\n pas de sortie de pression possible en dehors d'element face "<< endl;
//// tab_ret(it)= 0.;
//// }
//// else
//// {int n_face=1;
//// int t_tail = lesPressionsExternes(n_face).Taille();
//// if (t_tail != 0)
//// { Tableau <Pression_appliquee>& tab_press_appliquee = (lesPressionsExternes(n_face)); // pour simplifier
//// if (t_tail != 0) // cas où on a une face chargée
//// { tab_ret(it)=tab_press_appliquee(it).press;}
//// else {tab_ret(it)= 0.;}; // sinon rien
//// }
//// else {tab_ret(it)= 0.;}; // sinon rien
//// };
//// }
//// else {tab_ret(it)= 0.;}; // sinon rien
//// }
//// else {tab_ret(it)= 0.;}; // sinon rien
//// break;
//// }
// case 114: // le vecteur normal N_surf_1
// {tab_ret(it)= (*N_surf)(1);break;}
// case 115: // le vecteur normal N_surf_2
// {tab_ret(it)= (*N_surf)(2);break;}
// case 116: // le vecteur normal N_surf_3
// {tab_ret(it)= (*N_surf)(3);break;}
// case 117: // le vecteur normal N_surf_1_t
// {tab_ret(it)= (*N_surf_t)(1);break;}
// case 118: // le vecteur normal N_surf_2_t
// {tab_ret(it)= (*N_surf_t)(2);break;}
// case 119: // le vecteur normal N_surf_3_t
// {tab_ret(it)= (*N_surf_t)(3);break;}
// case 120: // le vecteur normal N_surf_1_t0
// {tab_ret(it)= (*N_surf_t0)(1);break;}
// case 121: // le vecteur normal N_surf_2_t0
// {tab_ret(it)= (*N_surf_t0)(2);break;}
// case 122: // le vecteur normal N_surf_3_t0
// {tab_ret(it)= (*N_surf_t0)(3);break;}
// case 123: // la position géométrique Mt
// {tab_ret(it)= (*Mt)(1);break;}
// case 124: // la position géométrique Mt
// {tab_ret(it)= (*Mt)(2);break;}
// case 125: // la position géométrique Mt
// {tab_ret(it)= (*Mt)(3);break;}
// case 126: // la position géométrique M0
// {tab_ret(it)= (*M0)(1);break;}
// case 127: // la position géométrique M0
// {tab_ret(it)= (*M0)(2);break;}
// case 128: // la position géométrique M0
// {tab_ret(it)= (*M0)(3);break;}
// case 137: // l'erreur relative
// {if (sigErreur_relative != NULL)
// {tab_ret(it)= *sigErreur_relative;}
// else {tab_ret(it)= 0.;};
// break;
// }
// default :
// {cout << "\n cas de ddl actuellement non traite "
// << "\n pas de ddl " << (*ie).Nom() << " dans l'element "
// << "\n ou cas non implante pour l'instant"
// << "\n ElemMeca::Valeur_multi(....";
// tab_ret(it) = 0.;
// };
// } // fin cas **** 2 >>>>>
// } // " " "
// } // -- fin du cas ou c'est une grandeur liée aux contraintes ou déformations
// // cas de l'erreur
// else if (( (*ie).Enum() == ERREUR) && ((*ie).Nom_vide()))
// {if (sigErreur != NULL)
// tab_ret(it)= *sigErreur;
// else if (ParaGlob::NiveauImpression()>4)
// {cout << "\n pas encore de ddl erreur dans l'element "
// << "\n ElemMeca::Valeur_multi(....";
// // this->Affiche();
// };
// }
// else if (( (*ie).Enum() == TEMP) && ((*ie).Nom_vide()))
// {// on vérifie que le ddl existe au premier noeud
// if (tab_noeud(1)->Existe_ici(TEMP))
// {tab_ret(it)= def->DonneeInterpoleeScalaire(TEMP,temps);}
// else if (ParaGlob::NiveauImpression()>3)
// {cout << "\n pas de ddl temperature disponible au noeud "
// << "\n ElemMeca::Valeur_multi(....";
// // this->Affiche();
// };
// }
// else
// { tab_ret(it) = 0.;
// cout << "\n cas de ddl actuellement non traite "
// << "\n pas de ddl " << (*ie).Nom() << " dans l'element "
// << "\n ou cas non implante pour l'instant, on retourne 0"
// << "\n ElemMeca::Valeur_multi(....";
// };
// };// -- fin de la boucle sur la liste de Ddl_enum_etendu
//
// // delete des tenseurs
// if (sigHH != NULL); delete sigHH;
// if (eps0BB != NULL); delete eps0BB;
// if (epsBB != NULL); delete epsBB;
// if (epslogBB != NULL); delete epslogBB;
// if (epsAlmBB != NULL); delete epsAlmBB;
// if (sigHB != NULL); delete sigHB;
// if (epsHB != NULL); delete epsHB;
// if (DepsBB != NULL); delete DepsBB;
// if (DepsHB != NULL); delete DepsHB;
// if (DeltaEpsBB != NULL); delete DeltaEpsBB;
// if (eps_barreHB != NULL); delete eps_barreHB;
// if (Deps_barreHB != NULL); delete Deps_barreHB;
// if (sig_barreHB != NULL); delete sig_barreHB;
// // cas des pointeurs
// if (epsAlmTotalBB!=NULL) delete epsAlmTotalBB; // pour la déformation totale d'almansi
// if (epsGLTotalBB!=NULL) delete epsGLTotalBB; // pour la déformation totale de green_lagrange
// if (epsLogTotalBB!=NULL) delete epsLogTotalBB; // pour la déformation totale logarithmique
// if (Q_sig != NULL) delete Q_sig; // grandeurs polaires
// if (Q_eps != NULL) delete Q_eps; // grandeurs polaires
// if (Mtdt != NULL) delete Mtdt; // coordonnée du point à t
// if (Mt != NULL ) delete Mt; // la position à t
// if (M0 != NULL ) delete M0; // coordonnée du point à 0
// if (N_surf != NULL) delete N_surf; // vecteur normal à la surface
// if (N_surf_t != NULL) delete N_surf_t; // vecteur normal à la surface à t
// if (N_surf_t0 != NULL) delete N_surf_t0; // vecteur normal à la surface à t0
// if (Vitesse != NULL) delete Vitesse; // vitesse
// // pointeurs de matrice
// if (Aa0 != NULL) delete Aa0;
// if (Aafin != NULL) delete Aafin;
// if (gamma0 != NULL) delete gamma0;
// if (gammafin != NULL) delete gammafin;
// if (beta0 != NULL) delete beta0;
// if (betafin != NULL) delete betafin;
//
// // liberation des tenseurs intermediaires
// LibereTenseur();
// def->Retour_pti_precedant(); // on revient au pti précédent
//
// return tab_ret;
// };
//

212
Elements/Trans_val_multi_tensoriel.h
View file

@ -1,212 +0,0 @@
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 27/07/2022 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Méthodes génériques de transformations *
* de tenseurs. Utilisées en particulier par ElemMeca et les
* lois de comportement
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef TRANS_VAL_MULTI_TENSORIEL_H
#define TRANS_VAL_MULTI_TENSORIEL_H
#include "Tenseur.h"
#include "NevezTenseur.h"
#include "Enum_calcul_masse.h"
#include "Basiques.h"
#include "Enum_dure.h"
#include "LesPtIntegMecaInterne.h"
#include "Enum_StabHourglass.h"
#include "Temps_CPU_HZpp.h"
/**
*
* BUT: Méthodes génériques de transformations
* de tenseurs. Utilisées en particulier par ElemMeca et les
* lois de comportement
*
* \author Gérard Rio
* \version 1.0
* \date 27/07/2022
* \brief Méthodes génériques de transformations de tenseurs
*
*/
class Trans_val_multi_tensoriel :
{
public :
// VARIABLES PUBLIQUES :
/* // CONSTRUCTEURS par défaut:
Trans_val_multi_tensoriel();
// Constructeur de copie
Trans_val_multi_tensoriel(const Trans_val_multi_tensoriel& a);
// DESTRUCTEUR :
~Trans_val_multi_tensoriel();
// METHODES PUBLIQUES :
// récupération des valeurs au numéro d'ordre = iteg pour
// les grandeur enu
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
// NB Importante: il faut faire attention à ce que ces métriques soient identiques à celles qui ont servit
// pour le calcul des tenseurs: en particulier si c'est utilisé pour calculer les grandeurs pour le chargement
// il faut s'assurer que ce sont les "mêmes pti" qui servent pour la charge et pour la raideur !!
Tableau <double> Valeur_multi(bool absolue,Enum_dure enu_t,const List_io<Ddl_enum_etendu>& enu
,int iteg,int cas
) ;
// récupération des valeurs Tensorielles (et non scalaire comme avec Valeur_multi)
// au numéro d'ordre = iteg pour les grandeur enu
// enu contient les grandeurs de retour
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
// NB Importante: il faut faire attention à ce que ces métriques soient identiques à celles qui ont servit
// pour le calcul des tenseurs: en particulier si c'est utilisé pour calculer les grandeurs pour le chargement
// il faut s'assurer que ce sont les "mêmes pti" qui servent pour la charge et pour la raideur !!
void Valeurs_Tensorielles(bool absolue, Enum_dure enu_t,List_io<TypeQuelconque>& enu
,int iteg,int cas
) ;
// récupération de valeurs interpolées pour les grandeur enu
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
// une seule des 3 métriques doit-être renseigné, les autres doivent être un pointeur nul
void Valeurs_Tensorielles_interpoler_ou_calculer
(bool absolue, Enum_dure temps,List_io<TypeQuelconque>& enu
,Deformation & defor
,const Met_abstraite::Impli* ex_impli
,const Met_abstraite::Expli_t_tdt* ex_expli_tdt
,const Met_abstraite::Expli* ex_expli
);
// récupération de valeurs interpolées pour les grandeur enu ou directement calculées
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
// exclure_dd_etend: donne une liste de Ddl_enum_etendu à exclure de la recherche
// parce que par exemple, ils sont calculés par ailleurs
// on peut également ne pas définir de métrique et matrice de passage (c-a-d gijHH == NULL)
// ==> tous les autres pointeurs d'éléments de métrique et matrices de passages sont alors réputés NULL
// donc inutilisable
// , dans ce cas on ne peut pas calculer certaines grandeurs
// -> il y a vérification
Tableau <double> Valeur_multi_interpoler_ou_calculer
(bool absolue, Enum_dure temps,const List_io<Ddl_enum_etendu>& enu
// éléments de métrique et matrices de passage
,TenseurHH* gijHH,TenseurBB* gijBB,BaseB* giB
,BaseH* giH_0,BaseH* giH
,BaseB* giB_0
,BaseB* giB_t // n'est définit "que" pour certains cas
,Mat_pleine* Aa0,Mat_pleine* Aafin
,Mat_pleine* gamma0,Mat_pleine* gammafin
,Mat_pleine* beta0,Mat_pleine* betafin
// exclusion du calcul
,const List_io<Ddl_enum_etendu>* exclure_dd_etend
);
// récupération de valeurs interpolées pour les grandeur enu
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
// exclure_Q: donne une liste de grandeur quelconque à exclure de la recherche
// parce que par exemple, ils sont calculés par ailleurs
// on peut également ne pas définir de métrique et matrice de passage (c-a-d gijHH == NULL)
// ==> tous les autres pointeurs d'éléments de métrique et matrices de passages sont alors réputés NULL
// donc inutilisable
// , dans ce cas on ne peut pas calculer certaines grandeurs
// -> il y a vérification
void Valeurs_Tensorielles_interpoler_ou_calculer
(bool absolue, Enum_dure temps,List_io<TypeQuelconque>& enu
// éléments de métrique et matrices de passage
,TenseurHH* gijHH,TenseurBB* gijBB,BaseB* giB
,BaseH* giH_0,BaseH* giH
,BaseB* giB_0
,BaseB* giB_t // n'est définit "que" pour certains cas
,Mat_pleine* Aa0,Mat_pleine* Aafin
,Mat_pleine* gamma0,Mat_pleine* gammafin
,Mat_pleine* beta0,Mat_pleine* betafin
// exclusion du calcul
,const List_io<EnumTypeQuelconque>* exclure_Q
);
// récupération de valeurs interpolées pour les grandeur ici considéré quelconque enu
// ces grandeurs ne sont pas définies dans la liste des Ddl_enum_etendu : ex mises à t
// ou le numéro de l'élément etc.
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
// exclure_Q: donne une liste de grandeur quelconque à exclure de la recherche
// parce que par exemple, ils sont calculés par ailleurs
// on peut également ne pas définir de métrique et matrice de passage (c-a-d gijHH == NULL)
// ==> tous les autres pointeurs d'éléments de métrique et matrices de passages sont alors réputés NULL
// donc inutilisable
// , dans ce cas on ne peut pas calculer certaines grandeurs
// -> il y a vérification
// retour: la list li_quelc
void Valeurs_quelconque_interpoler_ou_calculer
(bool absolue, Enum_dure temps
,const Tableau <EnumTypeQuelconque>& tqi
,List_io<TypeQuelconque>& li_quelc
// éléments de métrique et matrices de passage
,TenseurHH* gijHH,TenseurBB* gijBB,BaseB* giB
,BaseH* giH_0,BaseH* giH
,BaseB* giB_0
,BaseB* giB_t // n'est définit "que" pour certains cas
,Mat_pleine* Aa0,Mat_pleine* Aafin
,Mat_pleine* gamma0,Mat_pleine* gammafin
,Mat_pleine* beta0,Mat_pleine* betafin
// exclusion du calcul
,const List_io<EnumTypeQuelconque>* exclure_Q
);
*/
};
#endif

253
General/Distribution_CPU.cc
View file

@ -1,253 +0,0 @@
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Distribution_CPU.h"
#include <boost/mpi/environment.hpp>
#include <boost/mpi/communicator.hpp>
#include <boost/serialization/string.hpp>
#include <boost/mpi.hpp>
namespace mpi = boost::mpi;
// constructeur par défaut
Distribution_CPU::Distribution_CPU():
tab_list_maillage_element(),tab_indic()
,total_elem(0)
,tab_vide_list_maillage_element()
{};
// constructeur de copie
Distribution_CPU::Distribution_CPU (const Distribution_CPU& a):
tab_list_maillage_element(a.tab_list_maillage_element)
,tab_indic(a.tab_indic),total_elem(a.total_elem)
,tab_vide_list_maillage_element()
{};
// calcul de l'équilibrage initiale
void Distribution_CPU::Calcul_Equilibrage_initiale(const LesMaillages * lesMaillages)
{
if (ParaGlob::Monde()->rank() == 0)
{ // on équilibre sur tous les cpu excepté le maître, qui lui ne calcule pas
int nb_proc_calcul = ParaGlob::Monde()->size() - 1;
// si nb_proc_calcul == 0 on ne peut pas continuer, aucun cpu n'étant disponible
// pour le calcul, on arrête
if (nb_proc_calcul == 0)
{cout << "\n *** erreur en calcul d'equilibrage initial: le nombre de cpu "
<< " disponible pour le calcul est nul ! on ne peut pas continuer "
<< " (il faut utiliser la version mono-processeur d'Herezh++ ! ) "
<< endl;
Sortie(1);
};
tab_indic.Change_taille(nb_proc_calcul);
// dans une première étape on ne s'intéresse qu'aux éléments
// on suppose que les éléments sont identiques en temps de calcul
// on repère les éléments par le numéro de maillage + le numéro d'élément, en cours
// on récupère le nombre total d'éléments
int nb_mail = lesMaillages->NbMaillage();
total_elem = 0; // init
Tableau <Tableau <bool > > inter(nb_mail); // inter utilisé ensuite pour dimensionner tab_indic
for (int i=1;i<=nb_mail;i++)
{int nb_elem_mail = lesMaillages->Nombre_element(i);
total_elem += nb_elem_mail;
inter(i).Change_taille(nb_elem_mail,false);
};
// on dimensionne tab_indic, tout est à false
tab_indic.Change_taille(nb_proc_calcul,inter);
// il faut que le nombre d'élément soit au moins >= au nb de proc de calcul
// pour que l'on puisse distribuer au moin un elem par proc de calcul
if (total_elem < nb_proc_calcul)
{cout << "\n *** erreur en calcul d'equilibrage initial: le nombre de cpu "
<< " disponible pour le calcul \n est inferieur au nb d'element total ! on ne peut pas continuer "
<< "\n (il faut utiliser la version mono-processeur d'Herezh++ ! ) "
<< endl;
Sortie(1);
};
// le nombre théorique d'élément par cpu
int nb_elem_un_cpu = total_elem/nb_proc_calcul; // arrondi inférieur
// on adapte le tableau de liste
tab_list_maillage_element.Change_taille(nb_proc_calcul);
for (int iproc =1;iproc <= nb_proc_calcul; iproc++)
{tab_list_maillage_element(iproc).Change_taille(nb_mail);
for (int imail=1; imail<= nb_mail; imail++)
tab_list_maillage_element(iproc)(imail).clear();
};
// on parcours tous les éléments et on remplit les tableaux
int iproc = 1; // le num du proc en cours
int nb_ele_enreg_iproc = 1; // init le nombre d'élément enregistré pour le proc
for (int imail=1;imail<=nb_mail;imail++)
{
int nb_ele = lesMaillages->Nombre_element(imail);
{list <int > * li_maillage_element = & tab_list_maillage_element(iproc)(imail); // init
// de la liste courante
for (int ile = 1; ile<=nb_ele;ile++,nb_ele_enreg_iproc++)
{ li_maillage_element->push_back(ile);
tab_indic(iproc)(imail)(ile)=true; // on signale
// on regarde s'il faut changer de cpu
// si c'est le dernier cpu, on ne change pas -> pour éviter
// les pb d'arrondi
if ((nb_ele_enreg_iproc > nb_elem_un_cpu)
&& (iproc < nb_proc_calcul) )
{iproc++;
nb_ele_enreg_iproc=1; // reinit du compteur
li_maillage_element = & tab_list_maillage_element(iproc)(imail); // pointage liste associée
};
};
};
};
}
};
// passage de l'équilibrage à tous les cpu autres que 0
void Distribution_CPU::Passage_Equilibrage_aux_CPU()
{ //if (ParaGlob::Monde()->rank() == 0)
broadcast(*ParaGlob::Monde(), *this, 0);
// synchronisation ici de tous les process
// ParaGlob::Monde()->barrier();
// mise à jour de ParaGlob, qui peut transmettre à tous
// la liste des numéros d'éléments concernés
ParaGlob::param->Init_tableau(&tab_list_maillage_element);
};
// -- serialisation ---
// on spécialise la sauvegarde et la restitution
// version == 0 pour la première sauvegarde et ensuite > 0
// NB: c'est toujours la version en cours au moment de la sauvegarde
// ==> dans notre cas, on ne sent sert pas pour l'instant: supposé tjs == 0
template<class Archive>
void Distribution_CPU::save(Archive & ar, const unsigned int version) const
{ // comme on a des listes on sauvegarde explicitement
int nb_proc_calcul = tab_list_maillage_element.Taille();
ar << std::string("Distribution_CPU:taille= ") << nb_proc_calcul ;
for (int i_proc=1;i_proc<= nb_proc_calcul; i_proc++)
{int nb_mail = tab_list_maillage_element(i_proc).Taille();
ar << std::string(" nb_mail= ")<< nb_mail ;
// on sauvegarde également le nombre total d'élément par maillage
// pour cela on se sert de tab_indic pour le premier cpu
for (int num_mail = 1; num_mail <= nb_mail;num_mail++)
ar << (int) tab_indic(1)(num_mail).Taille();
for (int imail=1;imail<=nb_mail;imail++)
{ const list <int >& list_maillage_element = tab_list_maillage_element(i_proc)(imail);
ar << std::string(" list:i_taille= ")<< (int) list_maillage_element.size() ;
list <int >::const_iterator il, ilfin= list_maillage_element.end();
for (il = list_maillage_element.begin(); il != ilfin; il++)
{ int truc = (*il);
ar << truc ;
};
};
};
}
// en lecture, le num de version permet de ce positionner sur une version particulière
// ==> dans notre cas, on ne sent sert pas pour l'instant: supposé tjs == 0
template<class Archive>
void Distribution_CPU::load(Archive & ar, const unsigned int version)
{ // opération inverse de save
std::string toto; int taille;
ar >> toto >> taille;
// on vérifie que c'est cohérent avec le nombre de CPU en cours
int nb_proc_calcul = ParaGlob::Monde()->size() - 1;
if (taille != nb_proc_calcul)
{cout << "\n **** erreur en recuperation d'une distribution CPU, le nombre de cpu "
<< " en cours: "<<nb_proc_calcul << "est different de celui archive: "
<< taille << " on ne peut pas continuer l'execution !!!";
Sortie(1);
};
// redimentionnement éventuel, si même taille, aucune action
tab_list_maillage_element.Change_taille(nb_proc_calcul);
// idem tab_indic
tab_indic.Change_taille(nb_proc_calcul);
total_elem = 0; // init
for (int i_proc=1;i_proc<= nb_proc_calcul; i_proc++)
{ int nb_mail;
ar >> toto >> nb_mail;
tab_list_maillage_element(i_proc).Change_taille(nb_mail);
tab_indic(i_proc).Change_taille(nb_mail);
// on va lire le nombre total d'éléments pour chaque maillage
for (int num_mail = 1; num_mail <= nb_mail;num_mail++)
{ int nb_elem_mail;
ar >> nb_elem_mail;
tab_indic(i_proc)(num_mail).Change_taille(nb_elem_mail,false);
};
for (int imail=1;imail<=nb_mail;imail++)
{ Tableau <bool > & tab_indic_cpu_mail = tab_indic(i_proc)(imail); // pour simplifier
// tab_indic_cpu_mail.Inita(false); // par défaut init à false pour tous les éléments
list <int >& list_maillage_element = tab_list_maillage_element(i_proc)(imail);
int size_list;
ar >> toto >> size_list;
if (size_list == list_maillage_element.size())
{// si la liste existante a la bonne taille, on ne fait que lire
int inter;
list <int >::iterator il, ilfin= list_maillage_element.end();
for (il = list_maillage_element.begin(); il != ilfin; il++)
{ar >> inter; (*il)=inter;
tab_indic_cpu_mail(inter)=true; // on rempli tab_indic
}
}
else // cas où la taille n'est pas bonne
{list_maillage_element.clear();
int inter; // élément de travail
for (int j=1;j<= size_list;j++)
{ar >> inter;
list_maillage_element.push_back(inter);
tab_indic_cpu_mail(inter)=true; // on rempli tab_indic
};
};
// mise à jour du nombre total d'élément
total_elem += list_maillage_element.size();
};
}
};
// 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 Distribution_CPU::Lecture_base_info(ifstream& ent,const int cas)
{ // on récupère le tableau de list : tab_list_maillage_element
// on suit exactement la même procédure que pour archive
load(ent,cas);
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Distribution_CPU::Ecriture_base_info(ofstream& sort,const int cas)
{ // on sauvegarde le tableau de list : tab_list_maillage_element
// on suit exactement la même procédure que pour archive
save(sort,cas);
};

162
General/Distribution_CPU.h
View file

@ -1,162 +0,0 @@
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 03/01/2022 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: une classe qui a pour objectif de gérer, calculer, *
* certaines particularités liées à la parallélisation: *
* - l'équilibrage de charge de calcul sur les processeurs *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
************************************************************************/
#ifndef DISTRIBUTION_CPU_H
#define DISTRIBUTION_CPU_H
#include <boost/serialization/split_member.hpp>
#include "LesMaillages.h"
#include "Basiques.h"
/**
*
* BUT: une classe qui a pour objectif de gérer, calculer,
* certaines particularités liées à la parallélisation:
* - l'équilibrage de charge de calcul sur les processeurs
*
*
* \author Gérard Rio
* \version 1.0
* \date 03/01/2022
* \brief classe pour gérer certaines particularités liées à la parallélisation, ex: l'équilibrage de charge de calcul sur les processeurs
*
*/
class Distribution_CPU
{
public :
// CONSTRUCTEURS :
// par défaut
Distribution_CPU();
// constructeur de copie
Distribution_CPU (const Distribution_CPU& a);
// DESTRUCTEUR :
~Distribution_CPU() {};
// METHODES PUBLIQUES :
// calcul de l'équilibrage initiale par le cpu 0
void Calcul_Equilibrage_initiale(const LesMaillages * lesMaillages);
// passage de l'équilibrage à tous les cpu autres que 0
void Passage_Equilibrage_aux_CPU();
// retour de tab_list_maillage_element(i)(j) contient la liste
// pour le maillage j des num <élément> associés au cpu i
// NB: si la taille du tableau == 0, cela signifie qu'il n'a pas encore été construit
// on peut dans ce cas déclancher un calcul d'équilibrage initial
const Tableau <Tableau < list <int > > > * Tableau_element_CPU_en_cours() const
{return &tab_list_maillage_element;};
// retour de la liste des éléments relatif au cpu en cours
// si c'est le cpu 0, retourne un tableau vide
const Tableau < list <int > > & List_element_CPU_en_cours() const
{if (ParaGlob::Monde()->rank() != 0)
return tab_list_maillage_element(ParaGlob::Monde()->rank());
else return tab_vide_list_maillage_element;
};
// indicateur permettant de dire si un élément est concerné par un CPU donné
// tab_indic(CPU)(mail)(ele) : = 1 si l'élément ele du maillage mail est concerné
// par le CPU
bool Element_concerner(int CPU,int mail,int ele) const
{return tab_indic(CPU)(mail)(ele);};
// récup du nombre total d'éléments, cumul sur tous les maillages
int NB_total_element() const {return total_elem ;};
//============= 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 :
// tab_list_maillage_element(i)(j) contient la liste
// pour le maillage j des num <élément> associés au cpu i
Tableau <Tableau < list <int > > > tab_list_maillage_element;
// un tableau vide, qui correspond au cas du CPU 0
Tableau < list <int > > tab_vide_list_maillage_element;
// indicateur permettant de dire si un élément est concerné par un CPU donné
// tab_indic(CPU)(mail)(ele) : = 1 si l'élément ele du maillage mail est concerné
// par le CPU
Tableau <Tableau < Tableau <bool > > > tab_indic;
int total_elem ; // nombre total d'éléments cumulé sur tous les maillages
// METHODES PROTEGEES :
// -- serialisation ---
// déclaration en friend pour l'acces direct de boost
friend class boost::serialization::access;
// on spécialise la sauvegarde et la restitution
// version == 0 pour la première sauvegarde et ensuite > 0
// NB: c'est toujours la version en cours au moment de la sauvegarde
// ==> dans notre cas, on ne sent sert pas pour l'instant: supposé tjs == 0
template<class Archive>
void save(Archive & ar, const unsigned int version) const;
// en lecture, le num de version permet de ce positionner sur une version particulière
template<class Archive>
void load(Archive & ar, const unsigned int version);
// la macro suivante va définir automatiquement la méthode : "serialize"
BOOST_SERIALIZATION_SPLIT_MEMBER()
// pour mémoire on indique l'entête de la méthode "serialize"
// // la méthode serialize fonctionne dans les deux sens: lecture et écriture dans ar
// // << et >> est remplacé par &
// // le choix dépend du fait que ar est un flux entrant ou sortant
// template<class Archive>
// void serialize(Archive & ar, const unsigned int version);
};
#endif

232
LICENSE Executable file
View file

@ -0,0 +1,232 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright © 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for software and other kinds of works.
The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too.
When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.
Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.
Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and modification follow.
TERMS AND CONDITIONS
0. Definitions.
“This License” refers to version 3 of the GNU General Public License.
“Copyright” also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.
“The Program” refers to any copyrightable work licensed under this License. Each licensee is addressed as “you”. “Licensees” and “recipients” may be individuals or organizations.
To “modify” a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a “modified version” of the earlier work or a work “based on” the earlier work.
A “covered work” means either the unmodified Program or a work based on the Program.
To “propagate” a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.
To “convey” a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays “Appropriate Legal Notices” to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.
1. Source Code.
The “source code” for a work means the preferred form of the work for making modifications to it. “Object code” means any non-source form of a work.
A “Standard Interface” means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.
The “System Libraries” of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A “Major Component”, in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.
The “Corresponding Source” for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.
The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.
The Corresponding Source for a work in source code form is that same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.
When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified it, and giving a relevant date.
b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to “keep intact all notices”.
c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.
A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an “aggregate” if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:
a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.
d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.
A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.
A “User Product” is either (1) a “consumer product”, which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, “normally used” refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.
“Installation Information” for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.
If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).
The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.
7. Additional Terms.
“Additional permissions” are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or authors of the material; or
e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.
All other non-permissive additional terms are considered “further restrictions” within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).
However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.
Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License.
An “entity transaction” is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.
11. Patents.
A “contributor” is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's “contributor version”.
A contributor's “essential patent claims” are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, “control” includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.
In the following three paragraphs, a “patent license” is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To “grant” such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.
If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. “Knowingly relying” means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.
A patent license is “discriminatory” if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License “or any later version” applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.
If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.
Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the “copyright” line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
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 <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an “about box”.
You should also get your employer (if you work as a programmer) or school, if any, to sign a “copyright disclaimer” for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read <http://www.gnu.org/philosophy/why-not-lgpl.html>.

1
Lecture/LectBloc_T.cc
View file

@ -1 +0,0 @@
#include "LectBloc_T.h" // lecture d'un bloc void LectBloc::Lecture(UtilLecture & entreePrinc,LesReferences& lesRef, char * motcle,string message) { MotCle motCle; // ref aux mots cle if (strstr(entreePrinc.tablcar,motcle)!=NULL) { entreePrinc.NouvelleDonnee(); list <T> lili; T elem; // double t1; string s1; while ( !motCle.SimotCle(entreePrinc.tablcar)) { elem.Lecture(entreePrinc); // *(entreePrinc.entree) >> elem.Nomref() >> t1; // on regarde si cela correspond bien a une reference existante if (!lesRef.Existe(elem.nomRef())) { cout << "\n erreur, la ref "<< elem.nomRef() << " de " << motcle << "ne correspond a aucun element" << " de la liste de reference lue !! \n"; elem.Affiche(); cout << " LectBloc::Lecture( etc ..." << endl; entreePrinc.MessageBuffer(message); exit (1); } // on verifie que l'on n'utilise pas deux fois la meme reference // pour deux cibles differentes list <T>::iterator ii; for (ii=lili.begin() ; ii != lili.end(); ii++) if (((*ii).nomRef() == elem.nomRef()) && ((*ii)::Valeur != elem::valeur)) { cout << "\n erreur , un meme nom de reference est utilisee pour" << " deux cibles differentes \n" << " nom de la ref = " << elem.nomRef() << ", valeurs des deux cibles =" << (*ii)::Valeur <<", "<< elem::valeur ; cout << " LectBloc::Lecture( etc etc .." << endl; entreePrinc.MessageBuffer(message); exit (1); } // stockage lili.push_back(elem); entreePrinc.NouvelleDonnee(); } // enregistrement des infos tabElem.Change_taille(lili.size()); list <T>::iterator i; int j; for (i=lili.begin(),j=1 ; i != lili.end(); i++,j++) tabEpaiss(j) = *i; } };

3097
Maillage/maillage4.cc
View file

File diff suppressed because it is too large Load diff

96
Parametres/Banniere.h
View file

@ -1,96 +0,0 @@
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 07/01/2003 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Bannière du programme *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef BANNIERE_H
#define BANNIERE_H
#include "ParaGlob.h"
#include "Tableau_T.h"
/// @addtogroup Les_parametres_generaux
/// @{
///
class Banniere
{
public :
// CONSTRUCTEURS :
// création de la banniére
Banniere() {};
// DESTRUCTEUR :
~Banniere();
// METHODES PUBLIQUES :
// affichage de la banniere sur la sortie passée en argument
static void Sortie_banniere(ofstream & sort);
// affichage de la banniere sur cout
static void Sortie_banniere();
// passage en lecture de la banniere
static void Passage_lecture_banniere(ifstream& entr);
// retour du copie pirate
static string CopiPirate(){return copipirate;};
private :
// VARIABLES PROTEGEES :
class Construc_banniere
{ public: Construc_banniere(); };
friend class Construc_banniere;
static Tableau <string> la_banniere;
static string copipirate;
static Construc_banniere construc_ban;
};
/// @} // end of group
#endif

96
Parametres/banniere.cc
View file

@ -1,96 +0,0 @@
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Banniere.h"
// VARIABLES static :
Tableau <string> Banniere::la_banniere; // création du tableau par défaut
string Banniere::copipirate; // le copipirate
// création de la banniére par un artifice
// 1° préparation
Banniere::Construc_banniere::Construc_banniere()
{ la_banniere.Change_taille(16);
la_banniere(1) = "\n#######################################################################";
la_banniere(2) = "\n# #";
la_banniere(3) = "\n# | | ==== === ==== ==== | | | | #";
la_banniere(4) = "\n# | | | | | | / | | | | #";
la_banniere(5) = "\n# |====| |=== === |=== / |====| ------- ------- #";
la_banniere(6) = "\n# | | | | \\ | / | | | | #";
la_banniere(7) = "\n# | | ==== | \\ ==== ==== | | | | #";
la_banniere(8) = "\n# #";
la_banniere(9) = "\n#######################################################################";
la_banniere(10) = "\n# Herezh++ is distributed under GPL 3 license ou ultérieure. #";
la_banniere(11) = "\n# Copyright (C) 1997-2022 Université Bretagne Sud (France) #";
la_banniere(12) = "\n# AUTHOR : Gérard Rio #";
la_banniere(13) = "\n# E-MAIL : gerardrio56@free.fr #";
la_banniere(14) = "\n# Certification IDDN.FR.010.0106078.000.R.P.2006.035.20600 #";
la_banniere(15) = "\n# #";
la_banniere(16) = "\n#######################################################################";
copipirate="Copyright (C) 1997-2022 Université Bretagne Sud (France), AUTHOR : Gérard Rio (gerardrio56@free.fr)/";
};
// 2° création réelle
Banniere::Construc_banniere Banniere::construc_ban;
// affichage de la banniere sur la sortie passée en argument
void Banniere::Sortie_banniere(ofstream & sort)
{ int taille = la_banniere.Taille();
for (int i=1;i<= taille;i++)
sort << la_banniere(i);
#ifndef MISE_AU_POINT
sort << "\n# (version la plus rapide )";
#endif
#ifdef MISE_AU_POINT
sort << "\n# (version avec le plus de verifications pendant le calcul et les I/O ) ";
#endif
};
// affichage de la banniere sur cout
void Banniere::Sortie_banniere()
{ int taille = la_banniere.Taille();
for (int i=1;i<= taille;i++)
cout << la_banniere(i);
#ifndef MISE_AU_POINT
cout << "\n# (version la plus rapide )";
#endif
#ifdef MISE_AU_POINT
cout << "\n# (version avec le plus de verifications pendant le calcul et les I/O ) ";
#endif
};
// passage en lecture de la banniere
void Banniere::Passage_lecture_banniere(ifstream& entr)
{ int taille = la_banniere.Taille();
string toto;
for (int i=1;i<= taille;i++)
entr >> toto;
};

69
README.md Executable file
View file

@ -0,0 +1,69 @@
# Herezh_dev
Sources d'Herezh++
Ce dépôt est dédié aux corrections/évolutions du code
===================================================
le fichier makefile permet de compiler et créer un exécutable
Herezh utilise les bibliothèques:
sparselib++ cf. https://math.nist.gov/sparselib++/
IML++ cf. https://math.nist.gov/iml++/
BOOST cf. https://www.boost.org/
lapack et blas cf. http://performance.netlib.org/lapack/
muparser cf. https://beltoforion.de/en/muparser/
et un compilateur C++
===================================================
L'utilisation d'un environnement de développement permet de simplifier la navigation entre tous les fichiers sources et de générer automatiquement des exécutables.
L'utilisation de codeblocs (https://www.codeblocks.org/) a été testée avec succès.
Le paramétrage de codeblocs avec Herezh s'effectue via le fichier de configuration "Herezh.cbp" que l'on peut éditer. Il se trouve dans le répertoire "linux" à partir de la version 7.017 d'Herezh. La signification du contenu du fichier est intuitive: il s'agit d'un fichier xml donc avec balises.
Avant une première utilisation, après avoir édité le fichier et en fonction de la hiérarchie des répertoires existants, on pourra adapter les différents chemins indiqués et éventuellement les paramètres.
Au lancement codeblocks lit toute la configuration et permets ensuite:
- d'accéder aux sources (I/O)
- compiler et créer un exécutable (version debug ou non)
- débugger via gdb (il est possible d'utiliser un autre débugger)
Ensuite pendant l'utilisation de codeblocks on peut directement accéder à des menus qui permettent de modifier interactivement la configuration.
===================================================
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/>.

1
References/Lect_reference.cc
View file

File diff suppressed because one or more lines are too long

54
References/Lect_reference.h
View file

@ -1,54 +0,0 @@
/*! \file Lect_reference.h
\brief Lecture des references definies dans le fichier au format ".lis" de nom : nom_fichier
*/
// FICHIER : Lect_reference.h
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#ifndef LECT_REFERENCE_H
#define LECT_REFERENCE_H
#include "Liste_T.cc
#include "Reference.h"
#include "Tableau_T.h"
/// @addtogroup Les_classes_Reference
/// @{
///
/// Lecture des references definies dans le fichier au format ".lis" de nom : nom_fichier
Tableau<Reference> Lect_reference (char* nom_fichier);
/// @} // end of group
#endif

48
References/Reference_static.cc
View file

@ -1,48 +0,0 @@
/*! \file ReferenceNE.cc
\brief def d'une variable static motCle
*/
// FICHIER : ReferenceNE.cc
// CLASSE : ReferenceNE
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "ReferenceNE.h"
#include "PtTabRel.h"
/// @addtogroup Les_classes_Reference
/// @{
///
/// --------------- variables statiques ---------
MotCle Reference::motCle; /// liste des mots clés
/// @} // end of group

0
Util/Courbes/Courbe_1-cos.cc
View file

2199
comportement/Hyper_elastique/IsoHyper3DFavier3.cc
View file

File diff suppressed because it is too large Load diff

2045
comportement/Hypo_elastique/Hypo_hooke1D.cc
View file

File diff suppressed because it is too large Load diff

367
comportement/Hypo_elastique/Hypo_hooke1D.h
View file

@ -1,367 +0,0 @@
// FICHIER : Hypo1D.h
// CLASSE : Hypo1D
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 18/07/2020 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: La classe Hypo1D definit une loi 1D hypo-élastique *
* qui sous forme intégrée peut dans certain cas être *
* équivalente à hooke. *
* On a donc : *
* sigma_point = f(..) * D *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef HYPO_ELAS1D_H
#define HYPO_ELAS1D_H
#include "Loi_comp_abstraite.h"
/** @defgroup Les_lois_hypoelastiques
*
* BUT: groupe des lois hypoélastiques
*
*
* \author Gérard Rio
* \version 1.0
* \date 28/06/2004
* \brief Définition des lois hypoélastiques
*
*/
/// @addtogroup Les_lois_hypoelastiques
/// @{
///
class Hypo_hooke1D : public Loi_comp_abstraite
{
public :
// CONSTRUCTEURS :
// Constructeur par defaut
Hypo_hooke1D ();
// Constructeur de copie
Hypo_hooke1D (const Hypo_hooke1D& loi) ;
// DESTRUCTEUR :
~Hypo_hooke1D ();
// initialise les donnees particulieres a l'elements
// de matiere traite ( c-a-dire au pt calcule)
// Il y a creation d'une instance de SaveResul particuliere
// a la loi concernee
// la SaveResul classe est remplie par les instances heritantes
// le pointeur de SaveResul est sauvegarde au niveau de l'element
// c'a-d que les info particulieres au point considere sont stocke
// au niveau de l'element et non de la loi.
class SaveResulLoi_Hypo1D: public SaveResul
{ public :
SaveResulLoi_Hypo1D(); // constructeur par défaut à ne pas utiliser
// le constructeur courant
SaveResulLoi_Hypo1D (SaveResul* );
// de copie
SaveResulLoi_Hypo1D(const SaveResulLoi_Hypo1D& sav): // de copie
Kc(sav.Kc),Kc_t(sav.Kc_t),f(sav.f),f_t(sav.f_t)
,eps22(sav.eps22),eps22_t(sav.eps22_t),eps33(sav.eps33),eps33_t(sav.eps33_t)
,eps_cumulBB(sav.eps_cumulBB),eps_cumulBB_t(sav.eps_cumulBB_t)
{};
virtual ~SaveResulLoi_Hypo1D() {}; // destructeur
// définition d'une nouvelle instance identique
// appelle du constructeur via new
SaveResul * Nevez_SaveResul() const{return (new SaveResulLoi_Hypo1D(*this));};
// affectation
virtual SaveResul & operator = ( const SaveResul & a)
{ SaveResulLoi_Hypo1D& sav = *((SaveResulLoi_Hypo1D*) &a);
Kc=sav.Kc;Kc_t=sav.Kc_t;f=sav.f;f_t=sav.f_t;
eps22=sav.eps22;eps22_t=sav.eps22_t;eps33=sav.eps33;eps33_t=sav.eps33_t;
eps_cumulBB=sav.eps_cumulBB;eps_cumulBB_t=sav.eps_cumulBB_t;
return *this;
};
//============= 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);
// mise à jour des informations transitoires
void TdtversT()
{Kc_t = Kc; f_t=f; eps22_t=eps22;eps33_t=eps33;
eps_cumulBB_t = eps_cumulBB;
};
void TversTdt()
{Kc = Kc_t; f=f_t;eps22=eps22_t;eps33=eps33_t;
eps_cumulBB = eps_cumulBB_t;
};
// affichage à l'écran des infos
void Affiche() const
{ cout <<"\n Kc= "<< Kc << " f= " << f
<< " eps22= "<< eps22 << " eps33= "<< eps33
<< " eps_cumulBB= " << eps_cumulBB
<< " ";
};
//changement de base de toutes les grandeurs internes tensorielles stockées
// beta(i,j) represente les coordonnees de la nouvelle base naturelle gpB dans l'ancienne gB
// gpB(i) = beta(i,j) * gB(j), i indice de ligne, j indice de colonne
// gpH(i) = gamma(i,j) * gH(j)
virtual void ChBase_des_grandeurs(const Mat_pleine& beta,const Mat_pleine& gamma) ;
// procedure permettant de completer éventuellement les données particulières
// de la loi stockées
// au niveau du point d'intégration par exemple: exemple: un repère d'anisotropie
// completer est appelé apres sa creation avec les donnees du bloc transmis
// peut etre appeler plusieurs fois
virtual SaveResul* Complete_SaveResul(const BlocGen & bloc, const Tableau <Coordonnee>& tab_coor
,const Loi_comp_abstraite* loi) {return NULL;};
//-------------------------------------------------------------------
// données
//-------------------------------------------------------------------
double Kc,Kc_t; // les paramètres matériaux réellement utilisés
double f,f_t;
double eps33,eps22; // déformations transversale courantes
double eps33_t,eps22_t; // les dernières enregistrées
Tenseur1BB eps_cumulBB,eps_cumulBB_t; // déformation cumulée associée à la loi
};
SaveResul * New_et_Initialise();
friend class SaveResulLoi_Hypo1D;
// Lecture des donnees de la classe sur fichier
void LectureDonneesParticulieres (UtilLecture * ,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD);
// affichage de la loi
void Affiche() const ;
// test si la loi est complete
// = 1 tout est ok, =0 loi incomplete
int TestComplet();
//----- 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_loi(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_loi(ofstream& sort,const int cas);
// récupération des grandeurs particulière (hors ddl )
// correspondant à liTQ
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
void Grandeur_particuliere
(bool absolue,List_io<TypeQuelconque>& ,Loi_comp_abstraite::SaveResul * ,list<int>& decal) const;
// récupération de la liste de tous les grandeurs particulières
// ces grandeurs sont ajoutées à la liste passées en paramètres
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
void ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& ) const;
// calcul d'un module d'young équivalent à la loi
double Module_young_equivalent(Enum_dure temps,const Deformation & ,SaveResul * saveResul);
// récupération d'un module de compressibilité équivalent à la loi, ceci pour un chargement nul
// il s'agit ici de la relation -pression = sigma_trace/3. = module de compressibilité * I_eps
// >>> en fait ici il s'agit du dernier module tangent calculé !!
double Module_compressibilite_equivalent(Enum_dure temps,const Deformation & def,SaveResul * saveResul);
// récupération de la dernière déformation d'épaisseur calculée: cette déformaion n'est utile que pour des lois en contraintes planes ou doublement planes
// - pour les lois 3D : retour d'un nombre très grand, indiquant que cette fonction est invalide
// - pour les lois 2D def planes: retour de 0
// les infos nécessaires à la récupération de la def, sont stockées dans saveResul
// qui est le conteneur spécifique au point où a été calculé la loi
double Eps33BH(SaveResul * saveDon) const
{ SaveResulLoi_Hypo1D & save_resul = *((SaveResulLoi_Hypo1D*) saveDon);
return save_resul.eps33;
};
// récupération de la dernière déformation de largeur calculée: cette déformaion n'est utile que pour des lois en contraintes doublement planes
// - pour les lois 3D et 2D : retour d'un nombre très grand, indiquant que cette fonction est invalide
// les infos nécessaires à la récupération de la def, sont stockées dans saveResul
// qui est le conteneur spécifique au point où a été calculé la loi
double Eps22BH(SaveResul * saveDon) const
{ SaveResulLoi_Hypo1D & save_resul = *((SaveResulLoi_Hypo1D*) saveDon);
return save_resul.eps22;
};
// récupération de la variation relative d'épaisseur calculée: h/h0
// cette variation n'est utile que pour des lois en contraintes planes
// - pour les lois 3D : retour d'un nombre très grand, indiquant que cette fonction est invalide
// - pour les lois 2D def planes: retour de 0
// les infos nécessaires à la récupération , sont stockées dans saveResul
// qui est le conteneur spécifique au point où a été calculé la loi
double HsurH0(SaveResul * saveResul) const;
// récupération de la variation relative d'épaisseur calculée: h/h0
// et de sa variation par rapport aux ddls la concernant: d_hsurh0
// cette variation n'est utile que pour des lois en contraintes planes
// - pour les lois 3D : retour d'un nombre très grand, indiquant que cette fonction est invalide
// - pour les lois 2D def planes: retour de 0
// les infos nécessaires à la récupération , sont stockées dans saveResul
// qui est le conteneur spécifique au point où a été calculé la loi
// pour l'instant en attente *** virtual double d_HsurH0(SaveResul * saveResul,Vecteur & d_hsurh0) const ;
// récupération de la variation relative de largeur calculée: b/b0
// cette variation n'est utile que pour des lois en contraintes planes double
// - pour les lois 3D et 2D : retour d'un nombre très grand, indiquant que cette fonction est invalide
// les infos nécessaires à la récupération , sont stockées dans saveResul
// qui est le conteneur spécifique au point où a été calculé la loi
double BsurB0(SaveResul * saveResul) const ;
// création d'une loi à l'identique et ramène un pointeur sur la loi créée
Loi_comp_abstraite* Nouvelle_loi_identique() const { return (new Hypo_hooke1D(*this)); };
// affichage et definition interactive des commandes particulières à chaques lois
void Info_commande_LoisDeComp(UtilLecture& lec);
// calcul de grandeurs de travail aux points d'intégration via la def et autres
// ici permet de récupérer la compressibilité
// fonction surchargée dans les classes dérivée si besoin est
virtual void CalculGrandeurTravail
(const PtIntegMecaInterne& ptintmeca
,const Deformation & def,Enum_dure temps,const ThermoDonnee& dTP
,const Met_abstraite::Impli* ex_impli
,const Met_abstraite::Expli_t_tdt* ex_expli_tdt
,const Met_abstraite::Umat_cont* ex_umat
,const List_io<Ddl_etendu>* exclure_dd_etend
,const List_io<const TypeQuelconque *>* exclure_Q
)
{if (compress_thermophysique) Kc = 3./dTP.Compressibilite(); };
protected :
// donnée de la loi
double f; // coef de proportionalité entre sig_1^{.1} et D_1^{.1}
Courbe1D* f_temperature; // courbe éventuelle d'évolution de f en fonction de la température
Courbe1D* f_IIeps; // courbe éventuelle d'évolution de f en fonction du deuxième invariant d'epsilon
Fonction_nD* f_nD; // fonction nD éventuelle pour f
double Kc; // 3 * coefficient de compressibilité tangent
Courbe1D* Kc_temperature; // courbe éventuelle d'évolution de Kc en fonction de la température
Courbe1D* Kc_IIeps; // courbe éventuelle d'évolution de Kc en fonction du deuxième invariant d'epsilon
Fonction_nD * Kc_nD; // fonction nD éventuelle pour Kc
bool compress_thermophysique; // indique si oui ou non la compressibilité est calculée par une loi
// thermophysique et donc
// récupéré par la fonction "CalculGrandeurTravail"
int type_derive; // type de dérivée objective utilisée pour sigma
int restriction_traction_compression; // =0 -> pas de restriction
// = -1 : traction uniquement autorisée, la compression est mise à 0
// = 1 : compression uniquement autorisée, la traction est mise à 0
// on introduit un certain nombre de tenseur du quatrième ordre, qui vont nous servir pour
// Calcul_dsigma_deps, dans le cas où on n'est pas en orthonormee
Tenseur3HHHH I_x_I_HHHH,I_xbarre_I_HHHH,I_x_eps_HHHH,I_x_D_HHHH,I_xbarre_D_HHHH,d_sig_t_HHHH;
Tenseur3HHHH d_spherique_sig_t_HHHH;
// codage des METHODES VIRTUELLES protegees:
// calcul des contraintes a t+dt
// calcul des contraintes
void Calcul_SigmaHH (TenseurHH & sigHH_t,TenseurBB& DepsBB,DdlElement & tab_ddl
,TenseurBB & gijBB_t,TenseurHH & gijHH_t,BaseB& giB,BaseH& gi_H, TenseurBB & epsBB_
,TenseurBB & delta_epsBB_
,TenseurBB & gijBB_,TenseurHH & gijHH_,Tableau <TenseurBB *>& d_gijBB_
,double& jacobien_0,double& jacobien,TenseurHH & sigHH
,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement
,const Met_abstraite::Expli_t_tdt& ex);
// calcul des contraintes et de ses variations a t+dt
void Calcul_DsigmaHH_tdt (TenseurHH & sigHH_t,TenseurBB& DepsBB,DdlElement & tab_ddl
,BaseB& giB_t,TenseurBB & gijBB_t,TenseurHH & gijHH_t
,BaseB& giB_tdt,Tableau <BaseB> & d_giB_tdt,BaseH& giH_tdt,Tableau <BaseH> & d_giH_tdt
,TenseurBB & epsBB_tdt,Tableau <TenseurBB *>& d_epsBB
,TenseurBB & delta_epsBB,TenseurBB & gijBB_tdt,TenseurHH & gijHH_tdt
,Tableau <TenseurBB *>& d_gijBB_tdt
,Tableau <TenseurHH *>& d_gijHH_tdt,double& jacobien_0,double& jacobien
,Vecteur& d_jacobien_tdt,TenseurHH& sigHH,Tableau <TenseurHH *>& d_sigHH
,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement
,const Met_abstraite::Impli& ex);
// calcul des contraintes et ses variations par rapport aux déformations a t+dt
// en_base_orthonormee: le tenseur de contrainte en entrée est en orthonormee
// le tenseur de déformation et son incrémentsont également en orthonormees
// si = false: les bases transmises sont utilisées
// ex: contient les éléments de métrique relativement au paramétrage matériel = X_(0)^a
void Calcul_dsigma_deps (bool en_base_orthonormee, TenseurHH & sigHH_t,TenseurBB& DepsBB
,TenseurBB & epsBB_tdt,TenseurBB & delta_epsBB,double& jacobien_0,double& jacobien
,TenseurHH& sigHH,TenseurHHHH& d_sigma_deps
,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement
,const Met_abstraite::Umat_cont& ex) ; //= 0;
};
/// @} // end of group
#endif

2473
contact/ElContact.cc
View file

File diff suppressed because it is too large Load diff

731
Algo/AlgoRef/Algori.cc → herezh_pp/Algo/AlgoRef/Algori.cc Normal file → Executable file
View file

File diff suppressed because it is too large Load diff

76
Algo/AlgoRef/Algori.h → herezh_pp/Algo/AlgoRef/Algori.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -80,10 +80,6 @@
#include "Temps_CPU_HZpp.h"
#include "TypeQuelconqueParticulier.h"
#include "VariablesExporter.h"
#ifdef UTILISATION_MPI
#include "Distribution_CPU.h"
#include "ResRaid_MPI.h"
#endif
// peut-être à modifier sur linux
#ifdef BIBLIOTHEQUE_STL_CODE_WARRIOR
@ -156,8 +152,7 @@ class Algori
Algori (EnumTypeCalcul type,const bool avec_typeDeCalcul
,const list <EnumSousTypeCalcul>& soustype
,const list <bool>& avec_soustypeDeCalcul
,UtilLecture& entreePrinc
);
,UtilLecture& entreePrinc);
// constructeur de copie
Algori (const Algori& algo);
@ -176,16 +171,14 @@ class Algori
static Algori* New_Agori(EnumTypeCalcul type,const bool avec_typeDeCalcul
,const list <EnumSousTypeCalcul>& soustype
,const list <bool>& avec_soustypeDeCalcul
,UtilLecture& entreePrinc
);
,UtilLecture& entreePrinc);
// ramène un tableau de pointeurs sur tous les algorithmes spécifique existants
// IMPORTANT : il y a création des algorithmes (utilisation d'un new)
static Tableau <Algori *> New_tous_les_Algo
(const bool avec_typeDeCalcul
,const list <EnumSousTypeCalcul>& soustype
,const list <bool>& avec_soustypeDeCalcul
,UtilLecture& entreePrinc
);
,UtilLecture& entreePrinc);
//lecture des parametres de controle
// peut être modifié dans le cas d'un algo particulier
@ -310,12 +303,12 @@ class Algori
// type_incre :signal permet de localiser le dernier incrément
virtual void Ecriture_base_info
(int cas,LesMaillages *lesMaillages,
LesReferences* lesReferences,LesCourbes1D* lesCourbes1D,
LesFonctions_nD* lesFonctionsnD,
LesLoisDeComp* lesLoisDeComp,
DiversStockage* diversStockage,Charge* charge,
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats,
OrdreVisu::EnumTypeIncre type_incre,int incre = 0);
LesReferences* lesReferences,LesCourbes1D* lesCourbes1D,
LesFonctions_nD* lesFonctionsnD,
LesLoisDeComp* lesLoisDeComp,
DiversStockage* diversStockage,Charge* charge,
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats,
OrdreVisu::EnumTypeIncre type_incre,int incre = 0);
// cas d'un démarrage à partir de base_info
// éventuellement est définit de manière spécifique pour chaque algorithme
// dans les classes filles
@ -323,14 +316,13 @@ class Algori
// incrément voulu et qu'il faut simplement faire la lecture des infos
// cas = 3 : on met à jour uniquement les données variables, il y a modification des grandeurs,
// mais pas redimentionnement lorsque cela est viable (sinon on redimentionne)
virtual void Lecture_base_info
(int cas,LesMaillages *lesMaillages,
LesReferences* lesReferences,LesCourbes1D* lesCourbes1D,
LesFonctions_nD* lesFonctionsnD,
LesLoisDeComp* lesLoisDeComp,
DiversStockage* diversStockage,Charge* charge,
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats,
int inc_voulu=0);
virtual void Lecture_base_info(int cas,LesMaillages *lesMaillages,
LesReferences* lesReferences,LesCourbes1D* lesCourbes1D,
LesFonctions_nD* lesFonctionsnD,
LesLoisDeComp* lesLoisDeComp,
DiversStockage* diversStockage,Charge* charge,
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats,
int inc_voulu=0);
// visualisation intéractive via le standard vrml
// la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée
@ -452,11 +444,6 @@ class Algori
streampos Debut_increment() const {return debut_increment;};
// ==============VARIABLES PROTEGEES :
#ifdef UTILISATION_MPI
// cas d'un calcul parallèle
Distribution_CPU distribution_CPU_algo; // gestion de la distribution de charge sur CPU
#endif
// 1)----------- protégées: spécifiques à un algo ----------
int mode_debug; // permet de spécifier des options particulières pour débugger
// controle de la sortie des informations: utilisé par les classes dérivées
@ -543,16 +530,6 @@ class Algori
// variables privées internes servant au pilotage de la convergence
int PhaseDeConvergence() const {return phase_de_convergence;}; // pour l'acces en lecture uniquement
void Change_PhaseDeConvergence(int phase) {phase_de_convergence=phase;};
#ifdef UTILISATION_MPI
// cas d'un calcul parallèle
void Passage_indicConvergenceAuxProcCalcul() ; // passage des indicateurs aux process de calcul
// globalisation des grandeurs globales: proc de calcul -> maitre puis transmission à ParaGlob
// et transmission aux proc de calcul:
// on ne demande pas à ParaGlob de faire la transmission, car il ne sait pas ce qu'il transmet
// et les infos ne sont pas contigües, le transfert ne sera pas performant
void Globalisation_et_transfert_auxProcCalcul_grandeurs_globales();
#endif
private :
int phase_de_convergence; // =0 indique si l'on est en phase de convergence
// =1 on a convergé soit très bien soit correctement
@ -573,7 +550,7 @@ class Algori
// que si on veut une vérification double (deux fois) de la convergence
Tableau <double> max_var_residu; // tableau qui garde en souvenir la suite des maxi pour le pilotage
int nb_cycle_test_max_var_residu; // utilisé dans Convergence()
//--- gestion des stockages
// -- une classe de stockage de paramètres pour le changement de largeur de bande
class ParaStockage {public: Nb_assemb nbass; int demi,total;
@ -739,13 +716,7 @@ class Algori
Temps_CPU_HZpp temps_metrique_K_SM; // lesTempsCpu(14)
Temps_CPU_HZpp temps_chargement; // lesTempsCpu(15)
Temps_CPU_HZpp temps_rech_contact; // lesTempsCpu(16)
#ifdef UTILISATION_MPI
// cas d'un calcul parallèle: // passage des infos entre process
Temps_CPU_HZpp temps_transfert_court ; // lesTempsCpu(17)
Temps_CPU_HZpp temps_transfert_long ; // lesTempsCpu(19)
Temps_CPU_HZpp temps_attente ; // lesTempsCpu(18)
#endif
Tableau <Coordonnee3> lesTempsCpu; // un tableau intermédiaire qui récupère et globalise les temps pour les sorties
// via listeVarGlob, mais c'est les variables Temps_CPU_HZpp qui stockent
// réellement les temps
@ -894,7 +865,7 @@ class Algori
// nouvelle_largeur_imposee.deux = la demie largeur
// nouvelles_largeur_en_ddl.trois = la demie largeur maximale pour la partie éléments finis
// uniquement (sans les CLL)
void Mise_a_jour_Choix_matriciel_contact
Tableau <Mat_abstraite* > Mise_a_jour_Choix_matriciel_contact
(Tableau <Mat_abstraite* >& tab_matglob,const Nb_assemb& nb_casAssemb
, LesContacts*lescontacts
,int niveau_substitution ,TroisEntiers* nouvelle_largeur_imposee = NULL);
@ -1061,9 +1032,7 @@ class Algori
// mise à jour de la viscosité critique en continu: spécifique au algo de relaxation dynamique, appelé par Cal_mat_visqueux_num_expli
void CalculEnContinuMatriceViscositeCritique(const Mat_abstraite& mat_mass,Mat_abstraite& mat_C_pt
,const Vecteur & delta_X, const Vecteur & vitesse);
protected:
protected:
// passage des grandeurs gérées par l'algorithme de tdt à t
// en particulier les énergies et les puissances
void TdtversT();
@ -1113,8 +1082,7 @@ class Algori
// passage des grandeurs globales aux noeuds où il y a des variables globales attachées
// nb_casAssemb correspond au cas d'assemblage de X1
void Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales
(LesMaillages * lesMail,VariablesExporter* varExpor,const Nb_assemb& nb_casAssemb,const LesReferences& lesRef);
void Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales(LesMaillages * lesMail,VariablesExporter* varExpor,const Nb_assemb& nb_casAssemb,const LesReferences& lesRef);
// des fonctions inlines pour mettre à jour des grandeurs globales
// -- initialisation du compteur d'itérations

159
Algo/AlgoRef/Algori2.cc → herezh_pp/Algo/AlgoRef/Algori2.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -64,9 +64,8 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
{bool inc_trouve = entreePrinc->Positionnement_base_info(inc_voulu);
if (!inc_trouve)
{ cout << "\nErreur : On ne trouve pas l'increment de restart demande !\n";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
cout << "Algori::Lecture_base_info(....)"
<< " increment = " << inc_voulu << endl;
cout << "Algori::Lecture_base_info(....)"
<< " increment = " << inc_voulu << endl;
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
@ -109,9 +108,8 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
// dans le cas où on n'a pas trouvé le bon incrément message d'erreur
if (!inc_trouve)
{ cout << "\nErreur : On ne trouve pas l'increment demande !\n";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
cout << "Algori::Lecture_base_info(....)"
<< " incrément = " << inc_voulu << endl;
cout << "Algori::Lecture_base_info(....)"
<< " incrément = " << inc_voulu << endl;
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
@ -121,9 +119,8 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
}
default :
{ cout << "\nErreur : valeur incorrecte du type de restart !\n";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
cout << "Algori::Lecture_base_info(....)"
<< " cas= " << cas << endl;
cout << "Algori::Lecture_base_info(....)"
<< " cas= " << cas << endl;
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
@ -134,10 +131,7 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
// lecture particulière à l'algorithme
Lecture_base_info(*entrons,cas);
#ifdef UTILISATION_MPI
// si calcul on sauvegarde la distribution
distribution_CPU_algo.Lecture_base_info(*entrons,cas);
#endif
// ******* reste lescontacts
lesMaillages->Lecture_base_info(*entrons,cas); // lecture des maillages et des references
lesReferences->Lecture_base_info(*entrons,cas); // lecture des références
lesCourbes1D->Lecture_base_info(*entrons,cas); // lecture des courbes1D
@ -248,9 +242,8 @@ void Algori::Ecriture_base_info
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
cout << "Algori::Ecriture_base_info(....)"
<< " cas= " << cas << endl;
cout << "Algori::Ecriture_base_info(....)"
<< " cas= " << cas << endl;
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsSauvegarde.Comptage_en_cours()) tempsSauvegarde.Arret_du_comptage();
if (tempsSortieFilCalcul.Comptage_en_cours()) tempsSortieFilCalcul.Arret_du_comptage();
@ -263,10 +256,6 @@ void Algori::Ecriture_base_info
{
// ******* reste lescontacts
Ecriture_base_info(*sortons,cas);
#ifdef UTILISATION_MPI
// si calcul on sauvegarde la distribution
distribution_CPU_algo.Ecriture_base_info(*sortons,cas);
#endif
lesMaillages->Ecriture_base_info(*sortons,cas); // Ecriture des maillages et des references
lesReferences->Ecriture_base_info(*sortons,cas); // Ecriture des references
lesCourbes1D->Ecriture_base_info(*sortons,cas); // Ecriture des courbes1D
@ -294,13 +283,12 @@ void Algori::Visu_vrml(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// écriture de l'en-tête
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== module de visualisation format vrml ========\n";
cout << "\n ======== module de visualisation format vrml ========\n";
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
// ifstream * entrons = entreePrinc->Ent_BI();
ifstream * entrons = entreePrinc->Ent_BI();
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe l'instance de visualisation de la liste des incréments possibles
@ -389,8 +377,7 @@ void Algori::Visu_vrml(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
// entreePrinc->Fermeture_fichier_legende_vrml();
}
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== fin du module de visualisation format vrml ========\n";
cout << "\n ======== fin du module de visualisation format vrml ========\n";
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
@ -401,8 +388,7 @@ void Algori::Visu_vrml(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format vrml";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::Visu_vrml(..";
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::Visu_vrml(..";
cout << endl;
};
};
@ -420,13 +406,12 @@ void Algori::Visu_maple(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefer
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// écriture de l'en-tête
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== module de visualisation par fichiers de points au format maple ========\n";
cout << "\n ======== module de visualisation par fichiers de points au format maple ========\n";
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
// ifstream * entrons = entreePrinc->Ent_BI();
ifstream * entrons = entreePrinc->Ent_BI();
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe l'instance de visualisation de la liste des incréments possibles
@ -524,8 +509,7 @@ void Algori::Visu_maple(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefer
// entreePrinc->Fermeture_fichier_principal_maple();
}
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== fin module de visualisation par fichiers de points au format maple ========\n";
cout << "\n ======== fin module de visualisation par fichiers de points au format maple ========\n";
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
@ -536,8 +520,7 @@ void Algori::Visu_maple(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefer
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format maple";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::Visu_maple(..";
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::Visu_maple(..";
cout << endl;
};
};
@ -555,13 +538,12 @@ void Algori::Visu_geomview(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRe
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// écriture de l'en-tête
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== module de visualisation format geomview ========\n";
cout << "\n ======== module de visualisation format geomview ========\n";
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
// ifstream * entrons = entreePrinc->Ent_BI();
ifstream * entrons = entreePrinc->Ent_BI();
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe l'instance de visualisation de la liste des incréments possibles
@ -674,8 +656,7 @@ void Algori::Visu_geomview(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRe
// entreePrinc->Fermeture_fichier_legende_geomview();
}
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== fin du module de visualisation format geomview ========\n";
cout << "\n ======== fin du module de visualisation format geomview ========\n";
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
@ -686,8 +667,7 @@ void Algori::Visu_geomview(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRe
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format geomview";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::Visu_geomview(..";
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::Visu_geomview(..";
cout << endl;
};
};
@ -705,13 +685,12 @@ void Algori::Visu_Gid(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferen
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// écriture de l'en-tête
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== module de visualisation format Gid ========\n";
cout << "\n ======== module de visualisation format Gid ========\n";
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
// ifstream * entrons = entreePrinc->Ent_BI();
ifstream * entrons = entreePrinc->Ent_BI();
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe l'instance de visualisation de la liste des incréments possibles
@ -830,8 +809,7 @@ void Algori::Visu_Gid(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferen
// entreePrinc->Fermeture_fichier_resultat_Gid();
}
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== fin du module de visualisation format GID ========\n";
cout << "\n ======== fin du module de visualisation format GID ========\n";
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
@ -842,8 +820,7 @@ void Algori::Visu_Gid(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferen
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format GID";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::Visu_Gid(..";
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::Visu_Gid(..";
cout << endl;
};
};
@ -861,13 +838,12 @@ void Algori::Visu_Gmsh(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// écriture de l'en-tête
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== module de visualisation format Gmsh ========\n";
cout << "\n ======== module de visualisation format Gmsh ========\n";
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
// ifstream * entrons = entreePrinc->Ent_BI();
ifstream * entrons = entreePrinc->Ent_BI();
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe l'instance de visualisation de la liste des incréments possibles
@ -987,8 +963,7 @@ void Algori::Visu_Gmsh(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
// entreePrinc->Fermeture_TousLesFichiersResultats_Gmsh();
}
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== fin du module de visualisation format Gmsh ========\n";
cout << "\n ======== fin du module de visualisation format Gmsh ========\n";
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
@ -999,8 +974,7 @@ void Algori::Visu_Gmsh(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format Gmsh";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n Algori::Visu_Gmsh(..";
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::Visu_Gmsh(..";
cout << endl;
};
};
@ -1025,13 +999,12 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
return;
}
// écriture de l'en-tête
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== lecture du fichier de commande de visualisation ========\n";
cout << "\n ======== lecture du fichier de commande de visualisation ========\n";
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
// ifstream * entrons = entreePrinc->Ent_BI();
ifstream * entrons = entreePrinc->Ent_BI();
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe les instances de visualisation de la liste des incréments possibles
@ -1059,7 +1032,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
{ // cas où pas de liste -> on initialise à 0 et au dernier incrément si différent
list_incre_init_inter = &(visualise.List_balaie_init(-1));
}
// const list<int> & list_incre_init = * list_incre_init_inter;
const list<int> & list_incre_init = * list_incre_init_inter;
// on impose la liste pour les autres types de visualisation
visualise_maple.List_balaie_init(*list_incre_init_inter);//list_incre_init);
visualise_geomview.List_balaie_init(*list_incre_init_inter);//list_incre_init);
@ -1150,14 +1123,14 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
<< " fin_fichier_commande_visu ! "
<< "\n normalement ce mot cle doit finir le fichier, on continue quand meme, mais"
<< "\n il y a peut-etre un probleme";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Algori::LectureCommandeVisu(..";
}
else
{ // erreur en lecture
cout << "\n **** ERREUR en lecture du fichier de commande de visualisation "
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Algori::LectureCommandeVisu(..";
}
}
@ -1170,13 +1143,12 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
catch (...)// erreur inconnue
{ cout << "\n **** ERREUR inconnuee en lecture du fichier de commande de visualisation "
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Algori::LectureCommandeVisu(..";
};
// avertissement de la fin de lecture du fichier de commande
// if (ParaGlob::NiveauImpression() >= 0)
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n ======== fin de la lecture du fichier de commande de visualisation ========\n";
// visualisation en fonction de l'activité des différents types de sortie
// récup de la list des incréments à balayer
@ -1296,7 +1268,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
// entreePrinc->Fermeture_fichier_principal_vrml();
// entreePrinc->Fermeture_fichier_legende_vrml();
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n ======== fin du module de visualisation format vrml ========\n";
}
if (visualise_maple.Visu_maple_valide())
@ -1306,7 +1278,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
// // on ferme la sortie maple (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_principal_maple();
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n ======== fin module de visualisation par fichiers de points au format maple ========\n";
}
if (visualise_geomview.Visu_geomview_valide())
@ -1316,7 +1288,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
// entreePrinc->Fermeture_fichier_principal_geomview();
// entreePrinc->Fermeture_fichier_legende_geomview();
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n ======== fin du module de visualisation format geomview ========\n";
}
if (visualise_Gid.Visu_Gid_valide())
@ -1326,7 +1298,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
// entreePrinc->Fermeture_fichier_initial_Gid();
// entreePrinc->Fermeture_fichier_resultat_Gid();
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n ======== fin du module de visualisation format Gid ========\n";
}
if (visualise_Gmsh.Visu_Gmsh_valide())
@ -1336,7 +1308,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
// entreePrinc->Fermeture_fichier_initial_Gmsh();
// entreePrinc->Fermeture_TousLesFichiersResultats_Gmsh();
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n ======== fin du module de visualisation format Gmsh ========\n";
}
}
@ -1349,8 +1321,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur inconnue en lecture du fichier commande Visu";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::LectureCommandeVisu(..";
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::LectureCommandeVisu(..";
cout << "endl";
};
};
@ -1379,7 +1350,7 @@ void Algori::EcritureCommandeVisu()
catch (...)// erreur en écriture
{ cout << "\n **** ERREUR en ecriture du fichier de commande de visualisation "
<< "\n on continue quand meme";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Algori::EcritureCommandeVisu(..";
};
};
@ -1430,8 +1401,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
return;
}
// écriture de l'en-tête
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 1)) || (permet_affichage > 2))
{cout << "\n ======== lecture du fichier de commande "
if (ParaGlob::NiveauImpression() >= 2) {cout << "\n ======== lecture du fichier de commande "
<< "de visualisation ========\n";
};
//-- initialisation des grandeurs globales par maillage
@ -1545,19 +1515,19 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
<< " fin_fichier_commande_visu ! "
<< "\n normalement ce mot cle doit finir le fichier, on continue quand meme, mais"
<< "\n il y a peut-etre un probleme";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Algori::VisuAuFilDuCalcul(..";
}
else if ( erreur.lecture == 0) // on ne peut pas ouvrir le fichier
{ cout << "\n **** erreur en ouverture du fichier ";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Algori::VisuAuFilDuCalcul(..";
}
else
{ // erreur en lecture
cout << "\n **** ERREUR en lecture du fichier de commande de visualisation "
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Algori::VisuAuFilDuCalcul(..";
}
}
@ -1570,13 +1540,12 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
catch (...)// erreur inconnue
{ cout << "\n **** ERREUR inconnuee en lecture du fichier de commande de visualisation "
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Algori::VisuAuFilDuCalcul(..";
}
// avertissement de la fin de lecture du fichier de commande
// if (ParaGlob::NiveauImpression() >= 2)
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 2))
cout << "\n ======== fin de la lecture du fichier de commande de visualisation ========\n";
if (ParaGlob::NiveauImpression() >= 2)
cout << "\n ======== fin de la lecture du fichier de commande de visualisation ========\n";
// initialisation de la sortie vrml (fichier) si la sortie vrml est valide
if (visualise.Visu_vrml_valide())
{ entreePrinc->Ouverture_fichier_principal_vrml();
@ -1706,7 +1675,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
// entreePrinc->Fermeture_fichier_principal_vrml();
// entreePrinc->Fermeture_fichier_legende_vrml();
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n ======== fin du module de visualisation format vrml ========\n";
};
if (visualise_maple.Visu_maple_valide())
@ -1716,7 +1685,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
// // on ferme la sortie maple (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_principal_maple();
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n ======== fin module de visualisation par fichiers de points au format maple ========\n";
};
if (visualise_geomview.Visu_geomview_valide())
@ -1726,7 +1695,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
// entreePrinc->Fermeture_fichier_principal_geomview();
// entreePrinc->Fermeture_fichier_legende_geomview();
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n ======== fin du module de visualisation format geomview ========\n";
};
if (visualise_Gid.Visu_Gid_valide())
@ -1736,7 +1705,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
// entreePrinc->Fermeture_fichier_initial_Gid();
// entreePrinc->Fermeture_fichier_resultat_Gid();
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n ======== fin du module de visualisation format Gid ========\n";
};
if (visualise_Gmsh.Visu_Gmsh_valide())
@ -1746,7 +1715,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
// entreePrinc->Fermeture_fichier_initial_Gmsh();
// entreePrinc->Fermeture_TousLesFichiersResultats_Gmsh();
// fin de la visualisation
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n ======== fin du module de visualisation format Gmsh ========\n";
};
}; //-- fin du if (type_incre == OrdreVisu::DERNIER_INCRE)
@ -1759,10 +1728,9 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
throw (toto);
}
catch ( ... )
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur en ecriture pour la visualisation au fil du calcul";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::VisuAuFilDuCalcul(..";
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::VisuAuFilDuCalcul(..";
cout << endl;
};
};
@ -1892,11 +1860,6 @@ void Algori::Ecriture_base_info
sort << "\n tps_metrique_KSM "<< temps_metrique_K_SM;
sort << "\n tps_chargement "<< temps_chargement;
sort << "\n tps_rech_contact "<< temps_rech_contact;
#ifdef UTILISATION_MPI
sort << "\n tps_transfert_court_proc "<< temps_transfert_court;
sort << "\n tps_transfert_long_proc "<< temps_transfert_long;
sort << "\n tps_attente_proc "<< temps_attente;
#endif
// ----- écriture éventuelle des paramètres de l'algorithme et informations particulières
sort << "\n -----parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul);
@ -2083,11 +2046,7 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas)
ent >> nom1 >> temps_metrique_K_SM;
ent >> nom1 >> temps_chargement;
ent >> nom1 >> temps_rech_contact;
#ifdef UTILISATION_MPI
ent >> nom1 >> temps_transfert_court;
ent >> nom1 >> temps_transfert_long;
ent >> nom1 >> temps_attente;
#endif
// --- lecture éventuelle des paramètres de l'algorithme
// on regarde tout d'abord si l'algo en lecture correspond

79
Algo/AlgoRef/Algori3.cc → herezh_pp/Algo/AlgoRef/Algori3.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -1189,8 +1189,7 @@ int Algori::AmortissementCinetique(const Vecteur & delta_ddl,const double& coef_
if (fct_nD_inter_nb_entre_relax != NULL)
{int old_valeur = inter_nb_entre_relax;
inter_nb_entre_relax = (fct_nD_inter_nb_entre_relax->Valeur_pour_variables_globales())(1);
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 1))
if (old_valeur != inter_nb_entre_relax)
if ((ParaGlob::NiveauImpression() > 2) && (old_valeur != inter_nb_entre_relax))
cout << "\n >>> changement de inter_nb_entre_relax de " << old_valeur
<< " en ==> "<< inter_nb_entre_relax;
};
@ -1253,7 +1252,7 @@ int Algori::AmortissementCinetique(const Vecteur & delta_ddl,const double& coef_
else {moy_gliss_t= 0.; moyenne_glissante = 0.;}; // au cas où on met une valeur très grande
};
// écriture d'info pour le débug au cas où
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 6)) || (permet_affichage > 3))
if ((ParaGlob::NiveauImpression() > 6) || (permet_affichage >3 ))
{if (taille_moyenne_glissante == 1)
{cout << "\n E_cin_tdt= " << E_cin_tdt << " compteur_decroit_pourRelaxDyn= " << compteur_decroit_pourRelaxDyn
<< " pic_E_cint_t= " << pic_E_cint_t << endl;
@ -1372,7 +1371,7 @@ int Algori::AmortissementCinetique(const Vecteur & delta_ddl,const double& coef_
{ if (delta_ddl.Max_val_abs() <= max_deltaX_pourRelaxDyn) nb_dX_OK_pourRelaxDyn++;
if (nb_dX_OK_pourRelaxDyn > nb_max_dX_OK_pourRelaxDyn)
{ relax_vit = -1;
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 6)) || (permet_affichage > 3))
if (ParaGlob::NiveauImpression() > 6)
cout << "\n critere en deplacement ok: max_deltaX= " << delta_ddl.Max_val_abs();
nb_dX_OK_pourRelaxDyn=0; // on initialise pour une prochaine fois
// dans le cas ou l'arrêt réel n'est pas drivé par le déplacement
@ -1386,8 +1385,7 @@ int Algori::AmortissementCinetique(const Vecteur & delta_ddl,const double& coef_
// on tente d'afficher que si l'amortissement a effectivement eu lieu
// if (relax_vit && pa.AfficheIncrEnergie())
if (relaxation_effectuee)
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
if (relaxation_effectuee && ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0)))
{cout << "\n N:" << icharge << " relaxation cinetique effectuee "
<< " pic_E_cint_t("<<compteur_pic_energie<<") " << dernier_pic
<< " max_pic_E_cin= " << max_pic_E_cin;
@ -1564,9 +1562,8 @@ int Algori::AmortissementCinetique_individuel_aux_noeuds(const Vecteur & delta_d
// }
//// fin debug
// on tente d'afficher que si l'amortissement a effectivement eu lieu
if (relaxation_effectuee)
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 7)) || (permet_affichage > 5))
{cout << "\n relax effectue au noeud " << noe
if (relaxation_effectuee && (ParaGlob::NiveauImpression() > 7))
{cout << "\n relax effectue au noeud " << noe
<< " pic_eN_cint_t("<<compteur_pic_energie_noe<<") " << dernier_pic_eN
<< " max_pic_eN_cin= " << max_pic_eN_cin;
if (compt_decroit_pourRelaxDyn_noe == -2)
@ -1576,9 +1573,8 @@ int Algori::AmortissementCinetique_individuel_aux_noeuds(const Vecteur & delta_d
cout << endl;
};
}; // fin de la boucle sur les noeuds
if (compteur_relaxation_ok>0) // affichage global éventuel
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 4)) || (permet_affichage > 2))
cout << "\n nb de relaxation individuelle effectuee: " << compteur_relaxation_ok;
if ((ParaGlob::NiveauImpression() > 4)&&(compteur_relaxation_ok>0)) // affichage global éventuel
cout << "\n nb de relaxation individuelle effectuee: " << compteur_relaxation_ok;
};// -- fin du cas où l'on applique l'amortissement
@ -1739,7 +1735,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
else if (compteur > pa.Iterations())
{ nombre_de_mauvaises_convergences++;
nombre_de_bonnes_convergences = 0;
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{ cout << "\n============================================================================"
<< "\n ******* NON convergence des iterations d'equilibre ********* "
<< "\n============================================================================";
@ -1754,7 +1750,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
}
else if (phase_de_convergence == -2) // cas où c'est Convergence() qui est la cause de l'arret
// pour cause d'évolution divergente des résidus
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{ cout << "\n============================================================================"
<< "\n *** NON convergence equilibre: evolution divergente des residus ********* "
<< "\n============================================================================";
@ -1770,7 +1766,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
}
else if (phase_de_convergence == -3) // cas où c'est Convergence() qui est la cause de l'arret
// pour cause de variation de ddl minimal atteinte
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{ cout << "\n============================================================================"
<< "\n *** NON convergence equilibre: variation de ddl minimal atteinte ********* "
<< "\n============================================================================";
@ -1786,7 +1782,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
}
else if (phase_de_convergence == -4) // cas où c'est Convergence() qui est la cause de l'arret
// pour cause de variation de ddl maximal atteinte
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{ cout << "\n============================================================================"
<< "\n *** NON convergence equilibre: variation de ddl maximum atteinte ********* "
<< "\n============================================================================";
@ -1801,7 +1797,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
fin_iter = false; // on signale qu'il n'y a pas convergence
}
else if (phase_de_convergence == -5) // cas d'un arrêt à cause d'un jacobien négatif, qui est géré
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{ cout << "\n============================================================================"
<< "\n *** NON convergence due a la gestion de jacobien negatif ********* "
<< "\n============================================================================";
@ -1816,7 +1812,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
nombre_de_mauvaises_convergences++;
}
else if (phase_de_convergence == -6) // cas d'un arrêt à cause d'une variation de jacobine trop grande
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{ cout << "\n============================================================================"
<< "\n *** NON convergence due a une variation de jacobien trop grande ********* "
<< "\n============================================================================";
@ -1831,7 +1827,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
nombre_de_mauvaises_convergences++;
}
else if (phase_de_convergence == -7) // cas d'un arrêt à cause d'une non convergence de la loi de comp
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{if(ParaGlob::Francais())
{ cout << "\n============================================================================"
<< "\n *** NON convergence due a la loi de comportement ********* "
@ -1849,7 +1845,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
}
else if (phase_de_convergence == -8) // cas d'un arrêt à cause d'une non convergence de la loi de comp
// mais pour un pb qui couve depuis plusieurs incréments
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{if(ParaGlob::Francais())
{ cout << "\n============================================================================"
<< "\n *** NON convergence du a la loi de comportement ********* "
@ -1868,7 +1864,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
nombre_de_mauvaises_convergences++;
}
else if (phase_de_convergence == -9) // cas d'un arrêt à cause d'un pb de la résolution du syteme linéaire
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{if(ParaGlob::Francais())
{ cout << "\n=============================================================================="
<< "\n *** NON convergence due a un pb de resolution du systeme lineaire ********* "
@ -1885,7 +1881,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
nombre_de_mauvaises_convergences++;
}
else if (phase_de_convergence == -10) // cas d'un arrêt à cause d'un pb de calcul des efforts extérieurs
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{if(ParaGlob::Francais())
{ cout << "\n=============================================================================="
<< "\n *** NON convergence due a un pb de calcul des efforts exterieurs ********* "
@ -1902,7 +1898,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
nombre_de_mauvaises_convergences++;
}
else if (phase_de_convergence == -11) // cas d'un arrêt à cause d'un nan ou infini sur forces ext, int
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{if(ParaGlob::Francais())
{ cout << "\n=============================================================================="
<< "\n *** NON convergence due a un nan ou infini sur forces int, ext, totales ********* "
@ -1919,7 +1915,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
nombre_de_mauvaises_convergences++;
}
else // cas d'une erreur de pilotage: on ne sait pas pourquoi il s'est arrêté sans convergence
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{if(ParaGlob::Francais())
{cout << "\n cas de pilotage de fin d'iteration inconnues ? ou alors qui suit une erreur signalee precedemment ";
if (ParaGlob::NiveauImpression() > 5)
@ -1944,7 +1940,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
}
return fin_iter;
//debug
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{ cout << "\n Algori::Pilotage_fin_iteration_implicite: phase_de_convergence=" << phase_de_convergence
<< " nombre_de_bonnes_convergences= " << nombre_de_bonnes_convergences
<< " nombre_de_mauvaises_convergences " << nombre_de_mauvaises_convergences << endl ;
@ -2033,8 +2029,7 @@ void Algori::Pilotage_chaque_iteration(Vecteur* sol,double& maxDeltaDdl,const in
{ // -- sur ou sous relaxation
double sursousrelax = pa.SurSousRelaxation();
(*sol) *= sursousrelax;
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
if (sursousrelax != 1.)
if ((ParaGlob::NiveauImpression() >= 4) && (sursousrelax != 1.))
{if(ParaGlob::Francais())
{cout << "\n intervention d'une sur-sous relaxation: ";}
else {cout << "\n intervention of an over or under relaxation: ";};
@ -2046,7 +2041,7 @@ void Algori::Pilotage_chaque_iteration(Vecteur* sol,double& maxDeltaDdl,const in
{// cas d'une limitation globale (tout le vecteur sol change
if (maxDeltaDdl > pa.NormeMax_increment())
{ double facteur=(pa.NormeMax_increment()/maxDeltaDdl);
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{if(ParaGlob::Francais())
{cout << "\n ===>>>>> intervention de la reduction du vecteur increment de ddl ";}
else {cout << "\n ===>>>>> intervention of the reduction for the vector increment of dof ";};
@ -2069,7 +2064,7 @@ void Algori::Pilotage_chaque_iteration(Vecteur* sol,double& maxDeltaDdl,const in
{ vect(i) = Signe(vect(i),maxa); modif = true;};
};
if (modif)
{if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
{if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{if(ParaGlob::Francais())
{cout << "\n ===>>>>> intervention de la reduction du vecteur increment de ddl, limitation des maxis ";}
else {cout << "\n ===>>>>> intervention of the reduction for the vector increment of dof, limitation of the maxis ";};
@ -2119,7 +2114,7 @@ void Algori::Pilotage_maxi_X_V(const Vecteur& X_t,Vecteur& X_tdt,const Vecteur&
double maxDeltaDdl=vec_trav.Max_val_abs();
if (maxDeltaDdl > normeMax_X_increment)
{ double facteur=(normeMax_X_increment/maxDeltaDdl);
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 0))
if (ParaGlob::NiveauImpression() > 2)
{if(ParaGlob::Francais())
{cout << "\n ===>>>>> intervention de la reduction du vecteur delta X ";}
else {cout << "\n ===>>>>> intervention of the reduction for the vector delta X ";};
@ -2144,7 +2139,7 @@ void Algori::Pilotage_maxi_X_V(const Vecteur& X_t,Vecteur& X_tdt,const Vecteur&
{ vec_trav(i) = Signe(vec_trav(i),maxa); modif = true;};
};
if (modif)
{if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 0))
{if (ParaGlob::NiveauImpression() > 2)
{if(ParaGlob::Francais())
{cout << "\n ===>>>>> intervention de la reduction du vecteur delta X, limitation des maxis ";}
else {cout << "\n ===>>>>> intervention of the reduction for the vector delta X, limitation of the maxis ";};
@ -2164,7 +2159,7 @@ void Algori::Pilotage_maxi_X_V(const Vecteur& X_t,Vecteur& X_tdt,const Vecteur&
double maxDeltaDdl=vec_trav.Max_val_abs();
if (maxDeltaDdl > normeMax_V_increment)
{ double facteur=(normeMax_V_increment/maxDeltaDdl);
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 0))
if (ParaGlob::NiveauImpression() > 2)
{if(ParaGlob::Francais())
{cout << "\n ===>>>>> intervention de la reduction du vecteur delta V ";}
else {cout << "\n ===>>>>> intervention of the reduction for the vector delta V ";};
@ -2189,7 +2184,7 @@ void Algori::Pilotage_maxi_X_V(const Vecteur& X_t,Vecteur& X_tdt,const Vecteur&
{ vec_trav(i) = Signe(vec_trav(i),maxa); modif = true;};
};
if (modif)
{if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 4)) || (permet_affichage > 0))
{if (ParaGlob::NiveauImpression() > 4)
{if(ParaGlob::Francais())
{cout << "\n ===>>>>> intervention de la reduction du vecteur delta V, limitation des maxis ";}
else {cout << "\n ===>>>>> intervention of the reduction for the vector delta V, limitation of the maxis ";};
@ -2227,15 +2222,9 @@ void Algori::TdtversT()
// pour un problème de mécanique, en comparant le nombre de point d'intégration total
// et le nombre totale de degré de liberté
void Algori::VerifSingulariteRaideurMeca(int nbddl,const LesMaillages& lesMail) const
{
#ifdef UTILISATION_MPI
// cas d'un calcul //, seule la matrice du CPU 0 est concernée
if (ParaGlob::Monde()->rank() != 0)
return ;
#endif
if (ParaGlob::NiveauImpression() != 0)
{ if (ParaGlob::NiveauImpression() != 0)
{ // récup du nombre de grandeurs génératrices
// Enum_ddl enu(SIG11); // init par défaut
Enum_ddl enu(SIG11); // init par défaut
// on récupère la liste des problèmes physiques gérés par les éléments de tous les maillages
const list <Enum_ddl >& li = lesMail.Ddl_representatifs_des_physiques();
@ -2247,12 +2236,12 @@ void Algori::VerifSingulariteRaideurMeca(int nbddl,const LesMaillages& lesMail)
// affichage
const double ratio = 1.2; // le pourcentage
if (nbpt < ratio * nbddl)
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
{ cout << "\n *** Attention, le nombre total de grandeurs generatrices aux point d'integrations dans "
<< " le probleme: " << nbpt << " est inferieur "
<< " a " << ratio << " * le nombre total de ddl du probleme !! c-a-d: "<< int(ratio * nbddl)
<< "\n en consequence il est possible que la matrice de raideur soit naturellement singuliere \n\n ";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 7)) || (permet_affichage > 0))
if (ParaGlob::NiveauImpression() > 7)
cout << "\n void Algori::VerifSingulariteRaideurMeca(... ";
};
};
@ -2293,7 +2282,7 @@ void Algori::Coherence_Algo_typeConvergence()
&& (Evolution_temporelle_du_calcul(typeCalcul) != AUCUNE_EVOLUTION))
{ cout << "\n *** erreur: utilisation de la norme E_cinetique/E_statique avec un calcul non dynamique"
<< " arret ! ";
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 5)) || (permet_affichage > 0))
if (ParaGlob::NiveauImpression() > 5)
cout << "\n Algori::Coherence_Algo_typeConvergence() ";
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsCalEquilibre.Comptage_en_cours())

200
Algo/AlgoRef/Algori4.cc → herezh_pp/Algo/AlgoRef/Algori4.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -421,11 +421,6 @@ void Algori::Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales(L
// Temps_CPU_HZpp temps_metrique_K_SM; // lesTempsCpu(14)
// Temps_CPU_HZpp temps_chargement; // lesTempsCpu(15)
// Temps_CPU_HZpp temps_rech_contact; // lesTempsCpu(16)
// si calcul //
// Temps_CPU_HZpp temps_transfert_court; // lesTempsCpu(17)
// Temps_CPU_HZpp temps_transfert_long ; // lesTempsCpu(19)
// Temps_CPU_HZpp temps_attente; // lesTempsCpu(18)
//
// Tableau <Coordonnee3> lesTempsCpu; // un tableau intermédiaire qui récupère et globalise les temps pour les sorties
// // via listeVarGlob, mais c'est les variables Temps_CPU_HZpp qui stockent
@ -480,12 +475,7 @@ void Algori::Temps_CPU_HZpp_to_lesTempsCpu
lesTempsCpu(15)(1)= temps_chargement.Temps_CPU_User();
temps_rech_contact = contact.Temps_cpu_Contact();
lesTempsCpu(16)(1)= temps_rech_contact.Temps_CPU_User();
#ifdef UTILISATION_MPI
lesTempsCpu(17)(1)= temps_transfert_court.Temps_CPU_User();
lesTempsCpu(19)(1)= temps_transfert_long.Temps_CPU_User();
lesTempsCpu(18)(1)= temps_attente.Temps_CPU_User();
#endif
};
// idem la méthode de transfert si-dessus mais concerne uniquement les temps internes à l'algo
@ -512,11 +502,6 @@ Tableau <Temps_CPU_HZpp> & Algori::Ajout_Temps_CPU_HZpp_to_lesTempsCpu(Tableau <
lesTsCpu(8) += tempsSortieFilCalcul; // conversion de long long en double
lesTsCpu(9) += tempsRaidSmEnerContact; // conversion de long long en double
lesTsCpu(10) += tempsSecondMembreEnergContact; // conversion de long long en double
#ifdef UTILISATION_MPI
lesTsCpu(17) += temps_transfert_court;
lesTsCpu(19) += temps_transfert_long;
lesTsCpu(18) += temps_attente;
#endif
// retour
return lesTsCpu;
@ -541,11 +526,6 @@ void Algori::Arret_du_comptage_CPU()
temps_metrique_K_SM.Arret_du_comptage();
temps_chargement.Arret_du_comptage();
temps_rech_contact.Arret_du_comptage();
#ifdef UTILISATION_MPI
temps_transfert_court.Arret_du_comptage();
temps_transfert_long.Arret_du_comptage();
temps_attente.Arret_du_comptage();
#endif
};
// sortie sur fichier des temps cpu
@ -581,11 +561,7 @@ void Algori::Sortie_temps_cpu(const LesCondLim& lesCondLim
// écriture des temps cpu de l'algo:
sort_cpu << "\n==========================================================================";
#ifndef UTILISATION_MPI
sort_cpu << "\n Herezh++ : bilan temps cpu pour l'algorithme: " << Nom_TypeCalcul(TypeDeCalcul());;
#else
sort_cpu << "\n Herezh++ : (CPU "<< ParaGlob::Monde()->rank() << ") bilan temps cpu pour l'algorithme: " << Nom_TypeCalcul(TypeDeCalcul());;
#endif
sort_cpu << "\n==========================================================================\n";
// puis affichage de la version
ParaGlob::Sortie_Version(sort_cpu);
@ -666,20 +642,6 @@ void Algori::Sortie_temps_cpu(const LesCondLim& lesCondLim
<< "("<< std::setw(nbdigit) << (100*tempsSortieFilCalcul.Temps_CPU_User()/total_cpu) << " % ) "
<< tempsSortieFilCalcul.Temps_CPU_User_milli()
;
#ifdef UTILISATION_MPI
sort_cpu << "\n tps__transfert_cour_inter_cpu "
<< "("<< std::setw(nbdigit) << (100*temps_transfert_court.Temps_CPU_User()/total_cpu) << " % ) "
<< temps_transfert_court.Temps_CPU_User_milli()
;
sort_cpu << "\n tps__transfert_long_inter_cpu "
<< "("<< std::setw(nbdigit) << (100*temps_transfert_long.Temps_CPU_User()/total_cpu) << " % ) "
<< temps_transfert_long.Temps_CPU_User_milli()
;
sort_cpu << "\n tps__attente_inter_cpu "
<< "("<< std::setw(nbdigit) << (100*temps_attente.Temps_CPU_User()/total_cpu) << " % ) "
<< temps_attente.Temps_CPU_User_milli()
;
#endif
sort_cpu << "\n";
};
@ -894,19 +856,16 @@ bool Algori::Gestion_stockage_et_renumerotation_avec_contact(bool premier_calcul
,LesCondLim* lesCondLim,LesReferences* lesRef
,Tableau <Mat_abstraite* >& tab_mato,const Nb_assemb& nb_casAssemb
,LesContacts* lescontacts,int niveau_substitution)
{
#ifdef UTILISATION_MPI
// cas d'un calcul //, seule la (ou les) matrices du CPU 0 sont concernées
// donc s'il s'agit d'un CPU différent, on revient immédiatement
if (ParaGlob::Monde()->rank() != 0)
return false;
#endif
{ // --- calcul des éléments de contact: (correspond à la définition de la surface de contact)
// definition ou mise à jour, des elements de contact eventuels
// - imposition (en fonction de l'algorithme de contact) de conditions particulières de penetration (nulle par exemple)
TroisEntiers nevez_largeurs;
bool retour = false; // init pas de changement a priori au niveau des matrices
if (premier_calcul)
{// si demandé, renumérotation en fonction des éléments en contact
if (ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
if ((ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
|| (ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
)
{ // récup des connexions entre noeud dues aux contacts
const Tableau <Condilineaire>& tabCondLine= lescontacts->ConnectionCLL();
if (tabCondLine.Taille() > 0) //cas où il faut en tenir compte
@ -914,7 +873,7 @@ bool Algori::Gestion_stockage_et_renumerotation_avec_contact(bool premier_calcul
Tableau <Tableau <Condilineaire> > tabCLL(lesCondLim->ConnectionCLL(lesMail,lesRef));
int tailtabCLL = tabCLL.Taille();tabCLL.Change_taille(tailtabCLL+1);
tabCLL(tailtabCLL+1) = tabCondLine; // ajout de la partie contact
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 3)
cout << "\n -- renumerotation en tenant compte des elements de contact ";
// appel de l'utilitaire dans lesMaillages: avec mise à jour dans la foulée de l'assemblage
bool calcul_ok = lesMail->Renumerotation(*lesRef,tabCLL,nevez_largeurs,&nb_casAssemb,true);
@ -943,7 +902,9 @@ bool Algori::Gestion_stockage_et_renumerotation_avec_contact(bool premier_calcul
} //-- fin du cas si premier calcul
else
{if (nouvelle_situation_contact)
{if (ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
{if ((ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
|| (ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
)
{ // récup des connexions entre noeud dues aux contacts
const Tableau <Condilineaire>& tabCondLine= lescontacts->ConnectionCLL();
if (tabCondLine.Taille() > 0) //cas où il faut en tenir compte
@ -952,8 +913,8 @@ bool Algori::Gestion_stockage_et_renumerotation_avec_contact(bool premier_calcul
Tableau <Tableau <Condilineaire> > tabCLL(lesCondLim->Tab_CLinApplique());
int tailtabCLL = tabCLL.Taille();tabCLL.Change_taille(tailtabCLL+1);
tabCLL(tailtabCLL+1) = tabCondLine; // ajout de la partie contact
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 2))
cout << "\n -- renumerotation en tenant compte d'un changement de contact ";
if (ParaGlob::NiveauImpression() >= 3)
cout << "\n -- renumerotation en tenant compte des elements de contact ";
// appel de l'utilitaire dans lesMaillages: avec mise à jour dans la foulée de l'assemblage
bool calcul_ok = lesMail->Renumerotation(*lesRef,tabCLL,nevez_largeurs,&nb_casAssemb,true);
if (calcul_ok) // cas où il y a eu effectivement un changement de numérotation
@ -1007,15 +968,7 @@ bool Algori::Gestion_stockage_et_renumerotation_sans_contact(LesContacts* lesco
,LesCondLim* lesCondLim,LesReferences* lesRef
,Tableau <Mat_abstraite* >& tab_mato,const Nb_assemb& nb_casAssemb
,int niveau_substitution)
{
#ifdef UTILISATION_MPI
// cas d'un calcul //, seule la (ou les) matrices du CPU 0 sont concernées
// donc s'il s'agit d'un CPU différent, on revient immédiatement
if (ParaGlob::Monde()->rank() != 0)
return false;
#endif
TroisEntiers nevez_largeurs;
{ TroisEntiers nevez_largeurs;
bool retour = false; // init pas de changement a priori au niveau des matrices
if (premier_calcul)
{// si demandé, renumérotation des pointeurs d'assemblage
@ -1024,7 +977,7 @@ bool Algori::Gestion_stockage_et_renumerotation_sans_contact(LesContacts* lesco
Tableau <Tableau <Condilineaire> > tabCLL(lesCondLim->ConnectionCLL(lesMail,lesRef));
// int tailtabCLL = tabCLL.Taille();tabCLL.Change_taille(tailtabCLL+1);
// tabCLL(tailtabCLL+1) = tabCondLine; // ajout de la partie contact
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 3)
cout << "\n -- renumerotation des pointeurs d'assemblage en tenant compte des CLL ";
// appel de l'utilitaire dans lesMaillages: avec mise à jour dans la foulée de l'assemblage
bool calcul_ok = lesMail->Renumerotation(*lesRef,tabCLL,nevez_largeurs,&nb_casAssemb,true);
@ -1048,7 +1001,7 @@ bool Algori::Gestion_stockage_et_renumerotation_sans_contact(LesContacts* lesco
{ // récup des connexions entre noeuds dues aux CLL externes: comme les cll ont été mises à jour
// on récupère directement le tableau
Tableau <Tableau <Condilineaire> > tabCLL(lesCondLim->Tab_CLinApplique());
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 2))
if (ParaGlob::NiveauImpression() >= 3)
cout << "\n -- renumerotation des pointeurs d'assemblage en tenant compte des CLL ";
// appel de l'utilitaire dans lesMaillages: avec mise à jour dans la foulée de l'assemblage
bool calcul_ok = lesMail->Renumerotation(*lesRef,tabCLL,nevez_largeurs,&nb_casAssemb,true);
@ -1093,8 +1046,7 @@ void Algori::Cal_Transfert_delta_et_var_X(double& max_delta_X, double& max_var_d
Algori* Algori::New_Agori(EnumTypeCalcul id_TypeCalcul,const bool avec_typeDeCalcul
,const list <EnumSousTypeCalcul>& soustype
,const list <bool>& avec_soustypeDeCalcul
,UtilLecture& entreePrinc
)
,UtilLecture& entreePrinc)
{ // définition du pointeur de retour
Algori* algo_specifique;
@ -1197,8 +1149,7 @@ Tableau <Algori *> Algori::New_tous_les_Algo
,UtilLecture& entreePrinc)
{ // définition du tableau de pointeurs de retour
Tableau <Algori* > tab_algo_specifique(15);
// la méthode ne doit pas fonctionner dans le cas d'un calcul //
#ifndef UTILISATION_MPI
tab_algo_specifique(1) = new AlgoriNonDyna
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
tab_algo_specifique(2) = new ImpliNonDynaCont
@ -1229,118 +1180,7 @@ Tableau <Algori *> Algori::New_tous_les_Algo
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
tab_algo_specifique(15) = new AlgoriCombine
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
#else
// c'est une erreur
cout << "\n *** erreur: la methode Algori::New_tous_les_Algo n'est pas prevu "
<< " pour fonctionner en calcul parallele, veuillez utiliser la version "
<< " mono processeur! "<< endl;
Sortie(1);
#endif
return tab_algo_specifique;
};
#ifdef UTILISATION_MPI
// cas d'un calcul parallèle, passage des indicateurs
// calculés par le process 0 aux process de calcul
void Algori::Passage_indicConvergenceAuxProcCalcul()
{// seule le process 0 a fait la résolution globale
// il gère seul également la convergence, mais il doit tenir au courant les autres process
// on utilise un std::array pour passer en une fois les infos
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
std::array<int,6> indic_convergence = {phase_de_convergence,nombre_de_bonnes_convergences
,nombre_de_mauvaises_convergences,a_converge
,a_converge_iterMoins1,nb_cycle_test_max_var_residu
};
broadcast(*ParaGlob::Monde(), indic_convergence, 0);
// ParaGlob::Monde()->barrier();
if (ParaGlob::Monde()->rank() != 0)
// on récupère les grandeurs
{phase_de_convergence = indic_convergence[0];
nombre_de_bonnes_convergences = indic_convergence[1];
nombre_de_mauvaises_convergences = indic_convergence[2];
a_converge = indic_convergence[3];
a_converge_iterMoins1 = indic_convergence[4];
nb_cycle_test_max_var_residu = indic_convergence[5];
};
temps_transfert_court.Arret_du_comptage(); // fin comptage cpu
};
// globalisation des grandeurs globales: proc de calcul -> maitre puis transmission à ParaGlob
// et transmission aux proc de calcul:
// on ne demande pas à ParaGlob de faire la transmission, car il ne sait pas ce qu'il transmet
// et les infos ne sont pas contigües, le transfert ne sera pas performant
void Algori::Globalisation_et_transfert_auxProcCalcul_grandeurs_globales()
{ // on s'occupe tout d'abord des grandeurs directement gérées par Algori
Vecteur inter(10); // vecteur de passage
// inter(1) =
// ENERGIE_CINETIQUE -> inter(1)
// ENERGIE_EXTERNE -> 2
// ENERGIE_INTERNE -> 3
// PUISSANCE_ACCELERATION);
// PUISSANCE_INTERNE);
// PUISSANCE_EXTERNE);
// PUISSANCE_BILAN);
// ENERGIE_ELASTIQUE);
// ENERGIE_PLASTIQUE);
// ENERGIE_VISQUEUSE);
// ENERGIE_BILAN);
// QUANTITE_MOUVEMENT);
// ENERGIE_PENALISATION);
// ENERGIE_FROT_ELAST);
// ENERGIE_FROT_PLAST);
// ENERGIE_FROT_VISQ);
// ENERGIE_VISCO_NUMERIQUE);
// ENERGIE_BULK_VISCOSITY);
// ENERGIE_HOURGLASS_);
// ENERGIE_STABILISATION_MEMB_BIEL);
// VOLUME_TOTAL_MATIERE);
// MAXPUISSEXT);
// MAXPUISSINT);
// MAXREACTION);
// MAXRESIDUGLOBAL);
// MAXdeltaX);
// MAXvarDeltaX);
// MAXvarDdl);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_CINETIQUE);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_EXTERNE);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_INTERNE);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,PUISSANCE_ACCELERATION);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,PUISSANCE_INTERNE);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,PUISSANCE_EXTERNE);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,PUISSANCE_BILAN);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_ELASTIQUE);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_PLASTIQUE);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_VISQUEUSE);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_BILAN);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,QUANTITE_MOUVEMENT);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_PENALISATION);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_FROT_ELAST);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_FROT_PLAST);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_FROT_VISQ);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_VISCO_NUMERIQUE);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_BULK_VISCOSITY);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_HOURGLASS_);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_STABILISATION_MEMB_BIEL);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,VOLUME_TOTAL_MATIERE);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXPUISSEXT);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXPUISSINT);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXREACTION);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXRESIDUGLOBAL);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXdeltaX);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXvarDeltaX);
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXvarDdl);
};
#endif

2
Algo/AlgoUtilitaires/AlgoInformations.cc → herezh_pp/Algo/AlgoUtilitaires/AlgoInformations.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

3
Algo/AlgoUtilitaires/AlgoInformations.h → herezh_pp/Algo/AlgoUtilitaires/AlgoInformations.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -90,7 +90,6 @@ class AlgoInformations : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ AlgoInformations* inter = (AlgoInformations*) algo;

6
Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc → herezh_pp/Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -522,7 +522,7 @@ void AlgoUmatAbaqus::Calcul_Umat(ParaGlob * paraGlob,LesMaillages * lesMail,
void AlgoUmatAbaqus::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
{
// récup du flot
// ofstream * sort = entreePrinc.Sort_BI();
ofstream * sort = entreePrinc.Sort_BI();
// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
// ecriture: rien pour l'instant
// if (cas == 1)
@ -542,7 +542,7 @@ void AlgoUmatAbaqus::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const
{if (choix)
{// cas d'une lecture normale
// récup du flot
// ifstream * ent = entreePrinc.Ent_BI();
ifstream * ent = entreePrinc.Ent_BI();
// pour l'instant on ne lit rien
}
}

2
Algo/AlgoUtilitaires/AlgoUmatAbaqus.h → herezh_pp/Algo/AlgoUtilitaires/AlgoUmatAbaqus.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

7
Algo/AlgoUtilitaires/AlgoUtils.cc → herezh_pp/Algo/AlgoUtilitaires/AlgoUtils.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -91,13 +91,10 @@ void AlgoUtils::Execution(ParaGlob * p,LesMaillages * lesMail
// on vérifie que les noeuds sont bien attachés à un élément sinon on met un warning si niveau > 2
if (ParaGlob::NiveauImpression() > 2)
lesMail->AffichageNoeudNonReferencer();
// definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// dans le cas d'un contact éventuel on initialise les frontières et la répartition esclave et maître
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
if (lesContacts->Init_contact_pas_effectue())
{// initialisation des zones de contacts éventuelles

3
Algo/AlgoUtilitaires/AlgoUtils.h → herezh_pp/Algo/AlgoUtilitaires/AlgoUtils.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -94,7 +94,6 @@ class AlgoUtils : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ AlgoUtils* inter = (AlgoUtils*) algo;

2
Algo/AlgoUtilitaires/AlgoriRemontErreur.h → herezh_pp/Algo/AlgoUtilitaires/AlgoriRemontErreur.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

2
Algo/AlgoUtilitaires/RemontErreur.cc → herezh_pp/Algo/AlgoUtilitaires/RemontErreur.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

11
Algo/AlgorithmeCombiner/AlgoriCombine.cc → herezh_pp/Algo/AlgorithmeCombiner/AlgoriCombine.cc
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -316,7 +316,7 @@ void AlgoriCombine::lecture_Parametres(UtilLecture& entreePrinc)
while ( !motCle.SimotCle(entreePrinc.tablcar)) ;
// si le mot clé est "PARA_TYPE_DE_CALCUL" cela signifie
// qu'il y a un paramètre à lire
// bool lecture_effective = false;
bool lecture_effective = false;
if (strstr(entreePrinc.tablcar,"PARA_TYPE_DE_CALCUL")!=NULL)
{ //cas de la définition de paramètres
// on signale à Algori qu'il y a eu déjà une lecture de paramètre
@ -846,8 +846,7 @@ void AlgoriCombine::Lecture_algo_interne(const bool avec_typeDeCal
string nom_class_methode("AlgoriCombine::Lecture_algo_interne(..."); // pour info lecture
// on passe le mot clé de début de liste
string mot_cle = "liste_algorithmes_a_combiner_";
// bool lec_eff = entreePrinc.Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
entreePrinc.Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
bool lec_eff = entreePrinc.Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
list < Algori * > list_algori_inter; // une liste de travail pour la lecture
// maintenant on va lire chaque algorithme
entreePrinc.NouvelleDonnee();
@ -925,10 +924,6 @@ void AlgoriCombine::AutreSortieTempsCPU(ofstream& sort,const int ) const
// Temps_CPU_HZpp temps_metrique_K_SM; // lesTempsCpu(14)
// Temps_CPU_HZpp temps_chargement; // lesTempsCpu(15)
// Temps_CPU_HZpp temps_rech_contact; // lesTempsCpu(16)
// cas d'un calcul parallèle: // passage des infos entre process
// Temps_CPU_HZpp temps_transfert_court ; // lesTempsCpu(17)
// Temps_CPU_HZpp temps_transfert_long ; // lesTempsCpu(19)
// Temps_CPU_HZpp temps_attente ; // lesTempsCpu(18)
sort << "\n tps_InitAlgo " << lesTsCpu(1);
sort << "\n tps_MiseAJourAlgo "<< lesTsCpu(2);
sort << "\n tps_CalEquilibre "<< lesTsCpu(3);

3
Algo/AlgorithmeCombiner/AlgoriCombine.h → herezh_pp/Algo/AlgorithmeCombiner/AlgoriCombine.h
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -94,7 +94,6 @@ class AlgoriCombine : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ AlgoriCombine* inter = (AlgoriCombine*) algo;

38
Algo/AlgorithmeCombiner/AlgoriCombine2.cc → herezh_pp/Algo/AlgorithmeCombiner/AlgoriCombine2.cc
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -47,16 +47,7 @@ void AlgoriCombine::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(COMBINER); // transfert info
#ifdef UTILISATION_MPI
// calcul de l'équilibrage initiale par le cpu 0
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
};
#endif
// on s'occupe des fonctions nD de pilotage
// 1) cas de choix_algo
if ((nom_choix_algo.length()) && (choix_algo == NULL))
@ -126,10 +117,6 @@ void AlgoriCombine::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
int nb_algo = tab_algo.Taille();
for (int i=1;i<=nb_algo;i++)
{ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
#ifdef UTILISATION_MPI
// passage de l'équilibrage à ParaGlob
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
#endif
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
tab_algo(i)->InitAlgorithme(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
,lesLoisDeComp,diversStockage,charge,lesCondLim,lesContacts,resultats);
@ -183,10 +170,6 @@ void AlgoriCombine::MiseAJourAlgo(ParaGlob * paraGlob,LesMaillages * lesMail,
int nb_algo = tab_algo.Taille();
for (int i=1;i<=nb_algo;i++)
{ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
#ifdef UTILISATION_MPI
// passage de l'équilibrage à ParaGlob
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
#endif
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
tab_algo(i)->MiseAJourAlgo(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
,lesLoisDeComp,diversStockage,charge,lesCondLim,lesContacts,resultats);
@ -258,11 +241,6 @@ void AlgoriCombine::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
// << "\n tab_algo(3)->pa.Deltat()= " << tab_algo(3)->pa.Deltat() << flush;
// //--- fin debug
ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
#ifdef UTILISATION_MPI
// passage de l'équilibrage à ParaGlob
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
#endif
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
bool aff_incr=pa.Vrai_commande_sortie(icharge,temps_derniere_sauvegarde); // pour simplifier
if (aff_incr)
@ -328,11 +306,6 @@ void AlgoriCombine::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
if ((i >0)&&(i <= nb_algo))
{// on met à jour
ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
#ifdef UTILISATION_MPI
// passage de l'équilibrage à ParaGlob
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
#endif
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
bool aff_incr=pa.Vrai_commande_sortie(icharge,temps_derniere_sauvegarde); // pour simplifier
if (aff_incr)
@ -401,15 +374,10 @@ void AlgoriCombine::FinCalcul(ParaGlob * paraGlob,LesMaillages * lesMail,LesRefe
// // on passe en revue tous les algorithmes et on demande la fin des calculs
// non, sinon on a plusieurs dernières sauvegardes !!
// donc on ne sauvegarde la fin que via le dernier sous_algo qui a sauvegardé
// int nb_algo = tab_algo.Taille();
int nb_algo = tab_algo.Taille();
// for (int i=1;i<=nb_algo;i++)
int i=nb_dernier_algo_qui_a_fait_une_sauvegarde;
{ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
#ifdef UTILISATION_MPI
// passage de l'équilibrage à ParaGlob
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
#endif
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
tab_algo(i)->FinCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
,lesLoisDeComp,diversStockage,charge,lesCondLim,lesContacts,resultats);

24
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.cc → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -957,16 +957,7 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_RUNGE_KUTTA); // transfert info
#ifdef UTILISATION_MPI
// calcul de l'équilibrage initiale par le cpu 0
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
};
#endif
// avant toute chose, au cas où l'algo interviendrait après un autre algo
// on inactive tous les ddl existants
lesMail->Inactive_ddl();
@ -1101,10 +1092,6 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
// initialisation du compteur d'increments de charge
icharge = 0;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -1112,6 +1099,7 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -1120,7 +1108,6 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
// definition des elements de contact eventuels
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
};
//--cas de restart et/ou de sauvegarde------------
// tout d'abord récup du restart si nécessaire
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
@ -1142,7 +1129,7 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -1182,6 +1169,9 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
}
}
//--fin cas de restart et/ou de sauvegarde--------
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// ajout d'un conteneur pour les coordonnées à l'itération 0
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique

3
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.h → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -89,7 +89,6 @@ class AlgoriRungeKutta : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ AlgoriRungeKutta* inter = (AlgoriRungeKutta*) algo;

20
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.cc → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -288,9 +288,6 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP); // transfert info
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
// cas du chargement, on verifie egalement la bonne adequation des references
charge->Initialise(lesMail,lesRef,pa,*lesCourbes1D,*lesFonctionsnD);
// on indique que l'on ne souhaite pas le temps fin stricte
@ -395,10 +392,6 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
// initialisation du compteur d'increments de charge
icharge = 1;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -406,6 +399,7 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -436,7 +430,7 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -548,10 +542,10 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
double maxPuissInt; // maxi de la puissance des efforts internes
double maxReaction; // maxi des reactions
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
// double maxDeltaDdl=0; // // maxi de variation de ddl
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
double maxDeltaDdl=0; // // maxi de variation de ddl
// initialisation de la variable puissance_précédente d'une itération à l'autre
// double puis_precedente = 0.;
double puis_precedente = 0.;
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t
@ -872,7 +866,7 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
Algori::TdtversT();
if (pa.ContactType())
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
lesContacts->Actualisation(0); // si on n'a plus de projection
lesContacts->Actualisation(); // si on n'a plus de projection
// on inactive les éléments de contact qui se relache: testé soit via la réaction
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
};

3
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.h → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -93,7 +93,6 @@ class AlgoriDynaExpli : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ AlgoriDynaExpli* inter = (AlgoriDynaExpli*) algo;

59
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli2.cc → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli2.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -43,8 +43,6 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP); // transfert info
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
// cas du chargement, on verifie egalement la bonne adequation des references
charge->Initialise(lesMail,lesRef,pa,*lesCourbes1D,*lesFonctionsnD);
// on indique que l'on ne souhaite pas le temps fin stricte
@ -150,10 +148,6 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
// au premier passage il y a un traitement spécial: pas d'incrémentation du temps, pas de sauvegarde
// in s'agit d'un incrément de mise en place, l'équilibre se faisant à la fin
icharge = 0;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -161,6 +155,7 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -193,7 +188,7 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -309,10 +304,10 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
double maxPuissInt; // maxi de la puissance des efforts internes
double maxReaction; // maxi des reactions
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
// double maxDeltaDdl=0; // // maxi de variation de ddl
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
double maxDeltaDdl=0; // // maxi de variation de ddl
// initialisation de la variable puissance_précédente d'une itération à l'autre
// double puis_precedente = 0.;
double puis_precedente = 0.;
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t
@ -658,7 +653,7 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
// actualisation des éléments de contact et éventuellement suppression
if (pa.ContactType())
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
lesContacts->Actualisation(0); // si on n'a plus de projection
lesContacts->Actualisation(); // si on n'a plus de projection
// on inactive les éléments de contact qui se relache: testé soit via la réaction
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
};
@ -799,16 +794,7 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP); // transfert info
#ifdef UTILISATION_MPI
// calcul de l'équilibrage initiale par le cpu 0
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
};
#endif
// avant toute chose, au cas où l'algo interviendrait après un autre algo
// on inactive tous les ddl existants
lesMail->Inactive_ddl();
@ -941,10 +927,6 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// in s'agit d'un incrément de mise en place, l'équilibre se faisant à la fin
compteur_demarrage = 0; // pas vraiment utile, car sera redéfini dans CalEquilibre
icharge = 0;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -952,6 +934,7 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -960,7 +943,6 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// definition des elements de contact eventuels
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
};
//--cas de restart et/ou de sauvegarde------------
// tout d'abord récup du restart si nécessaire
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
@ -982,7 +964,7 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -1022,6 +1004,9 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
}
};
//--fin cas de restart et/ou de sauvegarde--------
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// ajout d'un conteneur pour les coordonnées à l'itération 0
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
@ -1134,12 +1119,8 @@ void AlgoriDynaExpli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
{
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP); // transfert info
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
// récup des entités
Assemblage& Ass1 = *Ass1_;
// Assemblage& Ass2 = *Ass2_;
Assemblage& Ass3 = *Ass3_;
Assemblage& Ass1 = *Ass1_;Assemblage& Ass2 = *Ass2_;Assemblage& Ass3 = *Ass3_;
// préparation pour les aspects validation du calcul et sortie contrôlée des incréments
int validation_calcul = 1; // init : par défaut la validation est effective si le calcul converge
@ -1154,7 +1135,7 @@ void AlgoriDynaExpli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
bool arret=false; // booleen pour arrêter indépendamment de la charge
bool premier_calcul = true; // utilisé pour le contact
icharge++; // on incrémente le chargement -> donne le num d'incr du prochain incr chargé
// int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
// au premier passage il y a un traitement spécial: pas d'incrémentation du temps, pas de sauvegarde
compteur_demarrage=0; // donc compteur pour les premiers incréments
double max_delta_X=0.; // le maxi du delta X
@ -1168,10 +1149,10 @@ void AlgoriDynaExpli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
double maxPuissInt; // maxi de la puissance des efforts internes
double maxReaction; // maxi des reactions
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
// double maxDeltaDdl=0; // // maxi de variation de ddl
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
double maxDeltaDdl=0; // // maxi de variation de ddl
// initialisation de la variable puissance_précédente d'une itération à l'autre
// double puis_precedente = 0.;
double puis_precedente = 0.;
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t
@ -1251,7 +1232,7 @@ void AlgoriDynaExpli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
{lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_tdt);
if (pa.ContactType()==4) // dans le cas d'un contact de type 4
// on actualise évenuellement la position des noeuds esclaves sur la surface maître
lesContacts->Actualisation(0);
lesContacts->Actualisation();
};
// dans le cas ou il y a changement de statut il faut remettre à jour
@ -1557,7 +1538,7 @@ void AlgoriDynaExpli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
if (compteur_demarrage != 0) Algori::TdtversT();
if ((pa.ContactType())&&(compteur_demarrage > 0))
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
lesContacts->Actualisation(0); // si on n'a plus de projection
lesContacts->Actualisation(); // si on n'a plus de projection
// on inactive les éléments de contact qui se relache: testé soit via la réaction
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
};

52
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.cc → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -290,16 +290,7 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_ZHAI); // transfert info
#ifdef UTILISATION_MPI
// calcul de l'équilibrage initiale par le cpu 0
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
};
#endif
// avant toute chose, au cas où l'algo interviendrait après un autre algo
// on inactive tous les ddl existants
lesMail->Inactive_ddl();
@ -431,10 +422,6 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
// initialisation du compteur d'increments de charge
icharge = 0;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -442,6 +429,7 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -450,7 +438,6 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
// definition des elements de contact eventuels
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
};
//--cas de restart et/ou de sauvegarde------------
// tout d'abord récup du restart si nécessaire
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
@ -472,7 +459,7 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -512,6 +499,9 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
}
};
//--fin cas de restart et/ou de sauvegarde--------
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// ajout d'un conteneur pour les coordonnées à l'itération 0
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
@ -620,11 +610,8 @@ void AlgoriDynaExpli_zhai::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMa
{
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_ZHAI); // transfert info
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
// récup des entités
Assemblage& Ass1 = *Ass1_;//Assemblage& Ass2 = *Ass2_;
Assemblage& Ass3 = *Ass3_;
Assemblage& Ass1 = *Ass1_;Assemblage& Ass2 = *Ass2_;Assemblage& Ass3 = *Ass3_;
// préparation pour les aspects validation du calcul et sortie contrôlée des incréments
int validation_calcul = 1; // init : par défaut la validation est effective si le calcul converge
@ -641,7 +628,7 @@ void AlgoriDynaExpli_zhai::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMa
bool arret=false; // booleen pour arrêter indépendamment de la charge
bool premier_calcul = true; // utilisé pour le contact
icharge++; // on incrémente le chargement -> donne le num d'incr du prochain incr chargé
// int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
while (((!charge->Fin(icharge))||(icharge == 1))
&& (charge->Fin(icharge,true)!=2) // si on a dépassé le nombre d'incrément permis on s'arrête dans tous les cas
&& (charge->Fin(icharge,false)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
@ -653,10 +640,10 @@ void AlgoriDynaExpli_zhai::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMa
double maxPuissInt; // maxi de la puissance des efforts internes
double maxReaction; // maxi des reactions
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
// double maxDeltaDdl=0; // // maxi de variation de ddl
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
double maxDeltaDdl=0; // // maxi de variation de ddl
// initialisation de la variable puissance_précédente d'une itération à l'autre
// double puis_precedente = 0.;
double puis_precedente = 0.;
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t
@ -1016,7 +1003,7 @@ void AlgoriDynaExpli_zhai::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMa
if (pa.ContactType())
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
lesContacts->Actualisation(0); // si on n'a plus de projection
lesContacts->Actualisation(); // si on n'a plus de projection
// on inactive les éléments de contact qui se relache: testé soit via la réaction
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
};
@ -1097,8 +1084,6 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_ZHAI); // transfert info
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
// cas du chargement, on verifie egalement la bonne adequation des references
charge->Initialise(lesMail,lesRef,pa,*lesCourbes1D,*lesFonctionsnD);
// on indique que l'on ne souhaite pas le temps fin stricte
@ -1203,10 +1188,6 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l
// initialisation du compteur d'increments de charge
icharge = 1;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -1214,6 +1195,7 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -1353,10 +1335,10 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l
double maxPuissInt; // maxi de la puissance des efforts internes
double maxReaction; // maxi des reactions
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
// double maxDeltaDdl=0; // // maxi de variation de ddl
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
double maxDeltaDdl=0; // // maxi de variation de ddl
// initialisation de la variable puissance_précédente d'une itération à l'autre
// double puis_precedente = 0.;
double puis_precedente = 0.;
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t

3
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.h → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -94,7 +94,6 @@ class AlgoriDynaExpli_zhai : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ AlgoriDynaExpli_zhai* inter = (AlgoriDynaExpli_zhai*) algo;

58
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.cc → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -280,15 +280,6 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_CHUNG_LEE); // transfert info
#ifdef UTILISATION_MPI
// calcul de l'équilibrage initiale par le cpu 0
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
};
#endif
// avant toute chose, au cas où l'algo interviendrait après un autre algo
// on inactive tous les ddl existants
lesMail->Inactive_ddl();
@ -424,10 +415,6 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
// initialisation du compteur d'increments de charge
icharge = 0;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -435,6 +422,7 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -444,7 +432,6 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
// definition des elements de contact eventuels
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
};
//--cas de restart et/ou de sauvegarde------------
// tout d'abord récup du restart si nécessaire
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
@ -466,7 +453,7 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -506,6 +493,9 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
}
};
//--fin cas de restart et/ou de sauvegarde--------
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// ajout d'un conteneur pour les coordonnées à l'itération 0
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
@ -622,11 +612,8 @@ void Algori_chung_lee::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail,
{
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_CHUNG_LEE); // transfert info
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
// récup des entités
Assemblage& Ass1 = *Ass1_;//Assemblage& Ass2 = *Ass2_;
Assemblage& Ass3 = *Ass3_;
Assemblage& Ass1 = *Ass1_;Assemblage& Ass2 = *Ass2_;Assemblage& Ass3 = *Ass3_;
// préparation pour les aspects validation du calcul et sortie contrôlée des incréments
int validation_calcul = 1; // init : par défaut la validation est effective si le calcul converge
@ -643,7 +630,7 @@ void Algori_chung_lee::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail,
bool arret=false; // booleen pour arrêter indépendamment de la charge
bool premier_calcul = true; // utilisé pour le contact
icharge++; // on incrémente le chargement -> donne le num d'incr du prochain incr chargé
// int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
while (((!charge->Fin(icharge))||(icharge == 1))
&& (charge->Fin(icharge,true)!=2) // si on a dépassé le nombre d'incrément permis on s'arrête dans tous les cas
&& (charge->Fin(icharge,false)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
@ -653,10 +640,10 @@ void Algori_chung_lee::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail,
double maxPuissInt; // maxi de la puissance des efforts internes
double maxReaction; // maxi des reactions
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
// double maxDeltaDdl=0; // // maxi de variation de ddl
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
double maxDeltaDdl=0; // // maxi de variation de ddl
// initialisation de la variable puissance_précédente d'une itération à l'autre
// double puis_precedente = 0.;
double puis_precedente = 0.;
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t
@ -726,7 +713,7 @@ void Algori_chung_lee::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail,
{lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_tdt);
if (pa.ContactType()==4) // dans le cas d'un contact de type 4
// on actualise évenuellement la position des noeuds esclaves sur la surface maître
lesContacts->Actualisation(0);
lesContacts->Actualisation();
};
// dans le cas ou il y a changement de statut il faut remettre à jour
@ -1009,7 +996,7 @@ void Algori_chung_lee::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail,
Algori::TdtversT();
if (pa.ContactType())
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
lesContacts->Actualisation(0); // si on n'a plus de projection
lesContacts->Actualisation(); // si on n'a plus de projection
// on inactive les éléments de contact qui se relache: testé soit via la réaction
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
};
@ -1094,8 +1081,6 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_CHUNG_LEE); // transfert info
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
// 000 --<C L>-- valeurs figées pour les paramètres de l'algorithme
const double betachapeau = 0.5 - (*beta_cl);
const double gammaa = 1.5; const double gammachapeau = 1.-gammaa;
@ -1198,13 +1183,10 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
F_int_tdt.Change_taille(nbddl_X); F_ext_tdt.Change_taille(nbddl_X); // forces généralisées int et ext au pas actuel
residu_final.Change_taille(nbddl_X); // pour la sauvegarde du résidu pour le post-traitement
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// cas avec contact potentiel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -1240,7 +1222,7 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -1360,10 +1342,10 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
double maxPuissInt; // maxi de la puissance des efforts internes
double maxReaction; // maxi des reactions
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
// double maxDeltaDdl=0; // // maxi de variation de ddl
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
double maxDeltaDdl=0; // // maxi de variation de ddl
// initialisation de la variable puissance_précédente d'une itération à l'autre
// double puis_precedente = 0.;
double puis_precedente = 0.;
// gestion du pas de temps, vérif / pas critique
this->Gestion_pas_de_temps(false,lesMail,2); // 2 signifie cas courant
bool modif_temps = charge->Avance(); // avancement de la charge et donc du temps courant
@ -1397,7 +1379,7 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
{lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_tdt);
if (pa.ContactType()==4) // dans le cas d'un contact de type 4
// on actualise évenuellement la position des noeuds esclaves sur la surface maître
lesContacts->Actualisation(0);
lesContacts->Actualisation();
};
// mise en place des conditions linéaires
@ -1683,7 +1665,7 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
Algori::TdtversT();
if (pa.ContactType())
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
lesContacts->Actualisation(0); // si on n'a plus de projection
lesContacts->Actualisation(); // si on n'a plus de projection
// on inactive les éléments de contact qui se relache: testé soit via la réaction
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
};

3
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.h → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -95,7 +95,6 @@ class Algori_chung_lee : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ Algori_chung_lee* inter = (Algori_chung_lee*) algo;

144
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -1102,12 +1102,12 @@ void AlgoriRelaxDyna::Info_commande_parametres(UtilLecture& entreePrinc)
<< "\n # (ici apres la transition vers l'amortissement visqueux, option_recalcul_mass "
<< "\n # initialement a 0, passe à 3) "
<< "\n # "
<< "\n # typeCalRelaxation= 4 lambda= 0.6 type_calcul_mass= 2 option_recalcul_mass= 0 \\ "
<< "\n # typeCalRelaxation= 4 lambda= 0.6 type_calcul_mass= 2 option_recalcul_mass= 0 \ "
<< "\n # opt_visqueux_recal_mass= 3 "
<< "\n # parametre_calcul_de_la_masse_ casMass_relax= 3 "
<< "\n # proportion_cinetique= 0.1 "
<< "\n # parametre_recalcul_de_la_masse_ ncycle_calcul= 100 et_pas_recalcul_masse_a_la_transition_"
<< "\n # parametre_calcul_de_la_viscosite_ type_calcul_visqu_critique= 2 \\ "
<< "\n # parametre_calcul_de_la_viscosite_ type_calcul_visqu_critique= 2 \ "
<< "\n # opt_cal_C_critique= 1 f_= 0.9 "
<< "\n # mode_debug_= 100 "
<< "\n # "
@ -1311,16 +1311,7 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(RELAX_DYNA); // transfert info
#ifdef UTILISATION_MPI
// calcul de l'équilibrage initiale par le cpu 0
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
};
#endif
// avant toute chose, au cas où l'algo interviendrait après un autre algo
// on inactive tous les ddl existants
lesMail->Inactive_ddl();
@ -1461,10 +1452,6 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
compteur_demarrage = -1; // pas vraiment utile, car sera redéfini dans CalEquilibre
icharge = 0; // par défaut
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -1472,6 +1459,7 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t); //
// initialisation des zones de contacts éventuelles
lescontacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -1511,7 +1499,7 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
////--debug
@ -1557,6 +1545,9 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
}
};
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// ajout d'un conteneur pour les coordonnées à l'itération 0
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
@ -1834,11 +1825,7 @@ Vecteur V_ext(F_int_tdt);
// def d'un type quelconque représentatif pour un vecteur force à chaque noeud
TypeQuelconque typQ_gene_int(FORCE_GENE_INT,X1,gt);
// on définit un type générique qui sert pour passer aux noeuds les positions à l'itération 0
TypeQuelconque typQ_XI_ITER_0(XI_ITER_0,X1,gt);
bool arret=false; // booleen pour arrêter indépendamment de la charge
bool arret_pilotage=false; // pour arrêt du calcul au niveau du pilotage
bool premier_calcul = true; // utilisé pour l'initialisation de l'incrément avec le pas précédent
int indicCycleContact = 0; // def d'un indicateur donnant la situation dans le cycle de contact
// un booléen pour uniquement gérer le fait que dans la boucle globale on fait le test après le test du while
@ -1851,10 +1838,9 @@ Vecteur V_ext(F_int_tdt);
// que si on a eu convergence
|| pas_de_convergence_pour_l_instant ||(compteur_demarrage <= 1)
)
&& (charge->Fin(icharge,true)!=1) // si on a dépassé le temps fin on s'arrête
// si on a dépassé le nombre d'incrément permis on s'arrête dans tous les cas
&& ((compteur_demarrage < 1)? (charge->Fin(icharge,false)!=2) : (charge->Fin(icharge,true)!=2))
&& (charge->Fin(icharge,true)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
&& (charge->Fin(icharge,false)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
// 1er appel avec true: pour affichage et second avec false car c'est déjà affiché
&& (!pa.EtatSortieEquilibreGlobal())
)
@ -1879,19 +1865,6 @@ Vecteur V_ext(F_int_tdt);
// bilan: on traite différamment selon que c'est le premier passage le second et les autres
bool aff_incr = true; // par défaut, est ensuite renseigné dans le switch qui suit
bool change_statut = false; // init des changements de statut
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t
// comme on est au début de l'incrément, la géométrie à tdt est identique à celle à t
// sauf "au premier incrément", si l'algo est un sous algo d'un algo combiné
// et que l'on suit un précédent algo sur un même pas de temps
// qui a aboutit à une géométrie à tdt différente de celle de t
// du coup cela permet d'utiliser la nouvelle géométrie pour ce premier incrément
lesMail->MiseAjourNormaleAuxNoeuds_de_tdt_vers_T();
// passage aux noeuds des vecteurs globaux: F_INT, F_EXT
Algori::Passage_aux_noeuds_F_int_t_et_F_ext_t(lesMail);
// qui, pour provoquer un arrêt de la boucle sur les incrément
switch (compteur_demarrage)
{case -1:
{// gestion du pas de temps, mis transitoirement à 0
@ -1909,17 +1882,12 @@ Vecteur V_ext(F_int_tdt);
this->Gestion_pas_de_temps(false,lesMail,2); // 2 signifie cas courant
if (!indicCycleContact) // modification de la charge et du pas de temps qu'au premier passage
// mais pas après un changement de statut
{ bool modif_temps = Pilotage_du_temps(charge,arret_pilotage); // appel du Pilotage
{ bool modif_temps = Pilotage_du_temps(charge,arret); // appel du Pilotage
//-- si le temps a changé il faut de nouveau appeler la gestion du pas de temps
// car il y a des grandeurs reliées au pas de temps qui y sont calculé
if (modif_temps)
this->Gestion_pas_de_temps(true,lesMail,2); // 2 signifie cas courant
if (arret_pilotage) break; // pilotage -> arret du calcul, on sort du switch
#ifdef UTILISATION_MPI
// seule le process 0 s'occupe de la sortie
if (ParaGlob::Monde()->rank() == 0)
{
#endif
if (arret) break; // pilotage -> arret du calcul
// affichage de l'increment de charge
aff_incr=pa.Vrai_commande_sortie(icharge,temps_derniere_sauvegarde); // pour simplifier
if (aff_incr)
@ -1930,12 +1898,7 @@ Vecteur V_ext(F_int_tdt);
<< " dt= " << ParaGlob::Variables_de_temps().IncreTempsCourant()
<< "\n======================================================================";
};
#ifdef UTILISATION_MPI
// seule le process 0 s'occupe de la sortie
}
else {aff_incr = false;};
#endif
// -- initialisation des coordonnees et des ddl a tdt en fonctions des
// -- initialisation des coordonnees et des ddl a tdt en fonctions des
// ddl imposes et de l'increment du chargement: change_statut sera recalculé ensuite
lesCondLim->MiseAJour_tdt
(pa.Multiplicateur(),lesMail,charge->Increment_de_Temps(),lesRef,charge->Temps_courant()
@ -1972,11 +1935,7 @@ Vecteur V_ext(F_int_tdt);
};
}
else
{ if (arret_pilotage) break; // pilotage -> arret du calcul
#ifdef UTILISATION_MPI
// seule le process 0 s'occupe de la sortie
if (ParaGlob::Monde()->rank() == 0)
#endif
{ if (arret) break; // pilotage -> arret du calcul
cout << "\n============================================================================="
<< "\n ....... re-analyse du contact ........ "
<< "\nINCREMENT DE CHARGE : " << icharge << " intensite " << charge->IntensiteCharge()
@ -1986,18 +1945,11 @@ Vecteur V_ext(F_int_tdt);
};
};
}; // fin du switch sur compteur_demarrage
#ifdef UTILISATION_MPI
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
broadcast(*ParaGlob::Monde(), arret_pilotage, 0);
temps_transfert_court.Arret_du_comptage(); // fin comptage cpu
#endif
if (arret_pilotage) break; // si dans le switch précédent on a un arret de pilotage qui est demandé
lesLoisDeComp->MiseAJour_umat_nbincr(icharge); // init pour les lois Umat éventuelles
// mise à jour éventuelle de la matrice de raideur en fonction de l'existence du contact et du type de modèle de contact
// if (pa.ContactType())
// Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
// mato = Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
// --- récupération (initialisation) des ddl position, vitesse et accélération
// récupe X_t initiale
@ -2038,9 +1990,6 @@ Vecteur V_ext(F_int_tdt);
// force_recalcul_masse : un indicateur de retour pour la méthode Cinetique_ou_visqueux:
bool force_recalcul_masse= false; // par défaut on ne force pas
// on démarre avec le compteur à 0 et on sauvegarde la position finale à l'itération 0
lesMail->Quelconque_glob_vers_local(X1,X_tdt,typQ_XI_ITER_0);
for (compteur = 0; (compteur<= pa.Iterations())&&(!pa.EtatSortieEquilibreGlobal()); compteur++)
//---//\\//\\// début de la boucle sur les itérations d'équilibres //\\//\\//
@ -2091,12 +2040,7 @@ Vecteur V_ext(F_int_tdt);
lesMail->Force_Ddl_etendu_aux_noeuds_a_zero(Ddl_enum_etendu::Tab_FN_FT()); // idem pour les composantes normales et tangentielles
// affichage ou non de l'itération
bool aff_iteration = (pa.freq_affich_iter() > 0) ?
(aff_incr && (compteur % pa.freq_affich_iter()==0) &&(compteur!=0)) : false ;
#ifdef UTILISATION_MPI
// seule le process 0 s'occupe de la sortie
if (ParaGlob::Monde()->rank() != 0) aff_iteration=false;
#endif
(aff_incr && (compteur % pa.freq_affich_iter()==0) &&(compteur!=0)) : false ;
/* // --- imposition des ddls bloqués
// initialisation des coordonnees et des ddl a tdt en fonctions des
// ddl imposes et de l'increment du chargement et des conditions linéaires imposées
@ -2222,14 +2166,14 @@ Vecteur V_ext(F_int_tdt);
// quand un noeud glisse d'une facette sur une voisine, peut changer la position du noeud
// qui est projeté sur la facette dans le cas de l'algorithme cinématique
if (((compteur != 0)&&(pa.ContactType()))&&(compteur_demarrage > 0))
{ lescontacts->Actualisation(0); // en particulier: pour le type 4 on a projection
{ lescontacts->Actualisation(); // en particulier: pour le type 4 on a projection
// des noeuds sur les facettes maîtres
// mise à jour éventuelle des répercussions du contact sur les noeuds en contact
AlgoriRelaxDyna::Repercussion_algo_sur_cinematique(lescontacts,X_tdt,vitesse_tdt);
// lesMail->Vect_loc_vers_glob(TEMPS_tdt,X1,X_tdt,X1);
// lesMail->Vect_loc_vers_glob(TEMPS_tdt,V1,vitesse_tdt,V1);
// mise à jour éventuelle de la matrice de raideur en fonction du contact
// Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
// mato = Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
};
// -+-+ sinon l'actualisation du contact s'effectue à la fin de l'itération (un peu plus loin)
@ -2365,14 +2309,8 @@ Vecteur V_ext(F_int_tdt);
InfoIncrementReac(lesMail,inReaction,maxReaction,Ass3.Nb_cas_assemb());
};
bool arretResidu = false; // pour gérer le cas particulier ou on veut un arrêt et sur le résidu et sur le déplacement
bool demande_de_break=false; // pour gestion du break en tenant compte ou non du MPI
#ifdef UTILISATION_MPI
// seule le process 0 s'occupe de la convergence
if (ParaGlob::Monde()->rank() == 0)
{
#endif
// examen de la convergence si nécessaire, utilisant le résidu
bool arretResidu = false; // pour gérer le cas particulier ou on veut un arrêt et sur le résidu et sur le déplacement
if (ArretEquilibreStatique() && (compteur>1) && (compteur_demarrage != 0) )// cas d'une convergence en utilisant le résidu
{ double toto=0.; int itera = 0; // valeur par defaut pour ne pas se mettre dans un cas itératif de type algo de Newton
bool arret_demande = false; // normalement n'intervient pas ici, car il n'y a pas de prise en compte d'iteration
@ -2391,26 +2329,12 @@ Vecteur V_ext(F_int_tdt);
)
)
{ arretResidu=true;} // cas relaxation avec amortissement cinétique
else {demande_de_break=true;}//break;}; // cas normal,
else {break;}; // cas normal,
};
};
};
#ifdef UTILISATION_MPI
};
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
broadcast(*ParaGlob::Monde(), arretResidu, 0);
broadcast(*ParaGlob::Monde(), arret, 0);
temps_transfert_court.Arret_du_comptage(); // fin comptage cpu
#endif
if (demande_de_break)
break;
// 4 --<ARD>-- calcul des nouvelles accélérations
#ifdef UTILISATION_MPI
// seule le process 0 fait la résolution globale
if (ParaGlob::Monde()->rank() == 0)
{
#endif
// resolution simple (fonction du type de matrice)
// ou non suivant modif_repere
tempsResolSystemLineaire.Mise_en_route_du_comptage(); // temps cpu
@ -2431,17 +2355,6 @@ Vecteur V_ext(F_int_tdt);
// retour des accélération dans les reperes generaux, dans le cas où ils ont ete modifie
// par des conditions linéaires
lesCondLim->RepInitiaux( acceleration_tdt,Ass3.Nb_cas_assemb());
#ifdef UTILISATION_MPI
}
else // s'il s'agit d'un process de calcul élémentaire
{sol = &vglobaal; // il faut affecter sol pour récupérer ensuite la solution
};
// le process 0 transmet aux autres process le vecteur résultat
temps_transfert_long.Mise_en_route_du_comptage(); // comptage cpu
sol->Broadcast(0);
temps_transfert_long.Arret_du_comptage(); // fin comptage cpu
#endif
// effacement du marquage de ddl bloque du au conditions lineaire imposée par l'entrée
lesCondLim->EffMarque();
if (pa.ContactType()) lescontacts->EffMarque();
@ -2461,7 +2374,7 @@ Vecteur V_ext(F_int_tdt);
// dans le cas ou la recherche de nouveaux contacts est effectuée à chaque itération
if (((type_activation_contact== 1) && (pa.ContactType()))&&(compteur_demarrage > 0))
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
lescontacts->Actualisation(0); // si on n'a plus de projection
lescontacts->Actualisation(); // si on n'a plus de projection
// on inactive les éléments de contact qui se relache: testé soit via la réaction
lescontacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
};
@ -2538,13 +2451,6 @@ Vecteur V_ext(F_int_tdt);
};
// gestion de la fin des itérations
#ifdef UTILISATION_MPI
// seule le process 0 a fait la résolution globale
// il gère seul également la convergence, mais il doit tenir au courant les autres process
Algori::Passage_indicConvergenceAuxProcCalcul();
// ce qui permet le déroulement correct de la suite pour tous les process
#endif
if ( ((compteur_demarrage > 0) && (!Pilotage_fin_iteration_implicite(compteur))))
{ // cas d'une non convergence
pas_de_convergence_pour_l_instant = 1;
@ -2565,7 +2471,7 @@ Vecteur V_ext(F_int_tdt);
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -2588,9 +2494,9 @@ Vecteur V_ext(F_int_tdt);
cout << " \n ... convergence en " << compteur << " iterations "<< endl ;
// traitement du contact dans le cas où son activation n'a pas été faite à chaque itération
if ((pa.ContactType()) && (type_activation_contact != 1))
{ lescontacts->Actualisation(0); // actualisation du contact en fonction du dernier incrément
{ lescontacts->Actualisation(); // actualisation du contact en fonction du dernier incrément
// mise à jour éventuelle de la matrice de raideur en fonction du contact
// Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
// mato = Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
// réexamen du contact pour voir s'il n'y a pas de nouveau element de contact
// en fait on fera au plus deux passages supplémentaire, sinon la boucle peut être infini,
// à la fin du second passage, on regarde s'il y a décollement, si oui on relâche et on refait un passage
@ -2643,7 +2549,7 @@ Vecteur V_ext(F_int_tdt);
// cas du calcul des énergies, passage des grandeurs de tdt à t
if (compteur_demarrage != -1) Algori::TdtversT();
// actualisation des éléments de contact et éventuellement suppression
if (pa.ContactType()) lescontacts->Actualisation(0); // des éléments qui ne sont plus en contact
if (pa.ContactType()) lescontacts->Actualisation(); // des éléments qui ne sont plus en contact
if (compteur_demarrage != -1)
{// on valide l'activité des conditions limites et condition linéaires
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());

2
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.h → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

34
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.cc → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -868,16 +868,7 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_TCHAMWA); // transfert info
#ifdef UTILISATION_MPI
// calcul de l'équilibrage initiale par le cpu 0
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
};
#endif
// avant toute chose, au cas où l'algo interviendrait après un autre algo
// on inactive tous les ddl existants
lesMail->Inactive_ddl();
@ -1003,10 +994,6 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// initialisation du compteur d'increments de charge
icharge = 0;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -1014,6 +1001,7 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -1022,7 +1010,7 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// definition des elements de contact eventuels
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
};
//--cas de restart et/ou de sauvegarde------------
// tout d'abord récup du restart si nécessaire
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
@ -1045,7 +1033,7 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -1086,6 +1074,9 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
}
}
//--fin cas de restart et/ou de sauvegarde--------
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// ajout d'un conteneur pour les coordonnées à l'itération 0
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
@ -1197,11 +1188,8 @@ void AlgoriTchamwa::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
{
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_TCHAMWA); // transfert info
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
// récup des entités
Assemblage& Ass1 = *Ass1_;//Assemblage& Ass2 = *Ass2_;
Assemblage& Ass3 = *Ass3_;
Assemblage& Ass1 = *Ass1_;Assemblage& Ass2 = *Ass2_;Assemblage& Ass3 = *Ass3_;
// préparation pour les aspects validation du calcul et sortie contrôlée des incréments
int validation_calcul = 1; // init : par défaut la validation est effective si le calcul converge
@ -1229,7 +1217,7 @@ void AlgoriTchamwa::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
double maxDeltaDdl=0; // // maxi de variation de ddl
// initialisation de la variable puissance_précédente d'une itération à l'autre
// double puis_precedente = 0.;
double puis_precedente = 0.;
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t
@ -1631,7 +1619,7 @@ void AlgoriTchamwa::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
Algori::TdtversT();
if (pa.ContactType())
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
lesContacts->Actualisation(0); // si on n'a plus de projection
lesContacts->Actualisation(); // si on n'a plus de projection
// on inactive les éléments de contact qui se relache: testé soit via la réaction
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
};

7
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.h → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -91,19 +91,16 @@ class AlgoriTchamwa : public Algori
// constructeur de copie à partie d'une instance indifférenciée
Algori * New_idem(const Algori* algo) const
{// on vérifie qu'il s'agit bien d'une instance
Algori * retour = NULL;
if (algo->TypeDeCalcul() != DYNA_EXP_TCHAMWA)
{ cout << "\n *** erreur lors de la creation par copie d'un algo DYNA_EXP_TCHAMWA "
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
retour = NULL;
}
else
{ AlgoriTchamwa* inter = (AlgoriTchamwa*) algo;
retour = ((Algori *) new AlgoriTchamwa(*inter));
return ((Algori *) new AlgoriTchamwa(*inter));
};
return retour;
};
// DESTRUCTEUR :

14
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa2.cc → herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa2.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -40,8 +40,6 @@ void AlgoriTchamwa::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMail
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_TCHAMWA); // transfert info
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
// cas du chargement, on verifie egalement la bonne adequation des references
charge->Initialise(lesMail,lesRef,pa,*lesCourbes1D,*lesFonctionsnD);
// on indique que l'on ne souhaite pas le temps fin stricte
@ -183,7 +181,7 @@ void AlgoriTchamwa::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMail
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -296,7 +294,7 @@ void AlgoriTchamwa::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMail
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
double maxDeltaDdl=0; // // maxi de variation de ddl
// initialisation de la variable puissance_précédente d'une itération à l'autre
// double puis_precedente = 0.;
double puis_precedente = 0.;
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t
@ -628,8 +626,6 @@ void AlgoriTchamwa::Calcul_Equilibre4(ParaGlob * paraGlob,LesMaillages * lesMail
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_TCHAMWA); // transfert info
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
// cas du chargement, on verifie egalement la bonne adequation des references
charge->Initialise(lesMail,lesRef,pa,*lesCourbes1D,*lesFonctionsnD);
// on indique que l'on ne souhaite pas le temps fin stricte
@ -766,7 +762,7 @@ void AlgoriTchamwa::Calcul_Equilibre4(ParaGlob * paraGlob,LesMaillages * lesMail
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -884,7 +880,7 @@ void AlgoriTchamwa::Calcul_Equilibre4(ParaGlob * paraGlob,LesMaillages * lesMail
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
double maxDeltaDdl=0; // // maxi de variation de ddl
// initialisation de la variable puissance_précédente d'une itération à l'autre
// double puis_precedente = 0.;
double puis_precedente = 0.;
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t

2
Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc → herezh_pp/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

3
Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.h → herezh_pp/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -92,7 +92,6 @@ class AlgoriNewmark : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ AlgoriNewmark* inter = (AlgoriNewmark*) algo;

40
Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark2.cc → herezh_pp/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark2.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -46,16 +46,7 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_IMP); // transfert info
#ifdef UTILISATION_MPI
// calcul de l'équilibrage initiale par le cpu 0
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
};
#endif
// avant toute chose, au cas où l'algo interviendrait après un autre algo
// on inactive tous les ddl existants
lesMail->Inactive_ddl();
@ -220,10 +211,6 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// boucle sur les increments de charge
icharge = 0; // init
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -233,6 +220,7 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
bool premier_calcul = true;
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -241,8 +229,7 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// definition des elements de contact eventuels
bool nevez_contact = lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
// mise à jour éventuelle de la matrice de raideur en fonction du contact
//bool changement_sur_matrice =
Gestion_stockage_et_renumerotation_avec_contact
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
(premier_calcul,lesMail,nevez_contact,lesCondLim
,lesRef,tab_mato,Ass1.Nb_cas_assemb(),lesContacts,niveau_substitution);
matglob=tab_mato(1);
@ -276,7 +263,7 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on réinitialise des ddl avec les conditions initiales because on vient de tout libérer les ddl
// or dans Initial, il y a des inits à faire au niveau des statuts
// lesCondLim->Initial(lesMail,lesRef,lesCourbes1D,lesFonctionsnD,true,cas_combi_ddl);
@ -299,10 +286,9 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
if (lesMail->NbEsclave() != 0)
{// on met à jour la boite d'encombrement compte tenue des nouvelles coordonnées
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
bool nevez_contact = lesContacts->Actualisation(0);
bool nevez_contact = lesContacts->Actualisation();
// mise à jour éventuelle de la matrice de raideur en fonction du contact
//bool changement_sur_matrice =
Gestion_stockage_et_renumerotation_avec_contact
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
(premier_calcul,lesMail,nevez_contact,lesCondLim
,lesRef,tab_mato,Ass1.Nb_cas_assemb(),lesContacts,niveau_substitution);
matglob=tab_mato(1);
@ -345,6 +331,9 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
};
};
//--fin cas de restart et/ou de sauvegarde--------
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// ajout d'un conteneur pour les coordonnées à l'itération 0
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
@ -798,11 +787,10 @@ void AlgoriNewmark::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
{ int niveau_substitution = 0; // on intervient sur toutes les matrices
bool a_changer = false; // init
if (compteur != 0)
a_changer = lescontacts->Actualisation(1);
a_changer = lescontacts->Actualisation();
// mise à jour éventuelle des matrices de raideur en fonction du contact
if (a_changer)
{//bool changement_sur_matrice =
Gestion_stockage_et_renumerotation_avec_contact
{bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
(premier_calcul,lesMail,a_changer,lesCondLim,lesRef
,tab_mato,Ass1.Nb_cas_assemb(),lescontacts,niveau_substitution);
matglob=tab_mato(1);
@ -1141,7 +1129,7 @@ void AlgoriNewmark::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -1165,7 +1153,7 @@ void AlgoriNewmark::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
{ cout << "\n --- |max_var_DeltaDdl|= "<< max_var_delta_X
<< " , |max_deltaDdl|= " << max_delta_X << flush;};
if (pa.ContactType())
{ bool nevez_contact = lescontacts->Actualisation(0); // actualisation du contact en fonction du dernier incrément
{ bool nevez_contact = lescontacts->Actualisation(); // actualisation du contact en fonction du dernier incrément
// réexamen du contact pour voir s'il n'y a pas de nouveau element de contact
// en fait on fera au plus deux passages supplémentaire, sinon la boucle peut être infini,
// à la fin du second passage, on regarde s'il y a décollement, si oui on relâche et on refait un passage

15
Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.cc → herezh_pp/Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.cc
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -390,10 +390,6 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
// initialisation du compteur d'increments de charge
icharge = 1;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -401,6 +397,7 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -430,7 +427,7 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -541,10 +538,10 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
double maxPuissInt; // maxi de la puissance des efforts internes
double maxReaction; // maxi des reactions
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
// double maxDeltaDdl=0; // // maxi de variation de ddl
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
double maxDeltaDdl=0; // // maxi de variation de ddl
// initialisation de la variable puissance_précédente d'une itération à l'autre
// double puis_precedente = 0.;
double puis_precedente = 0.;
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t

5
Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.h → herezh_pp/Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.h
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -90,7 +90,6 @@ class AlgoristatExpli : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ AlgoristatExpli* inter = (AlgoristatExpli*) algo;
@ -241,7 +240,7 @@ class AlgoristatExpli : public Algori
// écoute et prise en compte d'une commande interactive
// ramène true tant qu'il y a des commandes en cours
///**** inexploitable pour l'instant
bool ActionInteractiveAlgo(){return false;};
bool ActionInteractiveAlgo(){};

13
Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.cc → herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -162,10 +162,6 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
// boucle sur les increments de charge
icharge = 1;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -173,6 +169,7 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -197,7 +194,7 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -254,7 +251,7 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
// de calculer meme si l'utilisateur indique un increment de charge supÈrieur
// au temps final
bool arret=false; // pour arrÍt du calcul au niveau du pilotage
while (((!charge->Fin(icharge))||(icharge == 1))
while ((!charge->Fin(icharge))||(icharge == 1)
&& (charge->Fin(icharge,true)!=2) // si on a dépassé le nombre d'incrément permis on s'arrête dans tous les cas
&& (charge->Fin(icharge,false)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
// 1er appel avec true: pour affichage et second avec false car c'est déjà affiché
@ -311,7 +308,7 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
else
lesLoisDeComp->Loi_simplifie(false);
// bool sur_raideur = false; // pour l'instant pas de prise en compte sur la raideur
// bool sur_raideur = true; // essai
bool sur_raideur = true; // essai
// mise en place du chargement impose, c-a-d calcul de la puissance externe
// si pb on sort de la boucle
if (!(charge->ChargeSMembreRaideur_Im_mecaSolid

3
Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.h → herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -91,7 +91,6 @@ class AlgoriFlambLineaire : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ AlgoriFlambLineaire* inter = (AlgoriFlambLineaire*) algo;

6
Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.cc → herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -269,6 +269,10 @@ void AlgoriNonDyna::Execution(ParaGlob * paraGlob,LesMaillages * lesMail
,divStock,charge,lesCondLim,lesContacts,resultats );
};
//---- fonction obsolete >> a virer !! ---------------------
// Calcul_Equilibre(paraGlob,lesMail,lesRef,lesCourbes1D,lesLoisDeComp
// ,divStock,charge,lesCondLim,lesContacts,resultats );
//---- fin fonction obsolete >> a virer !! -----------------
};// fin du cas sans commandes interactives
// ensuite on teste en fonction des calculs complémentaires

3
Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.h → herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -91,7 +91,6 @@ class AlgoriNonDyna : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ AlgoriNonDyna* inter = (AlgoriNonDyna*) algo;

191
Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc → herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -48,26 +48,6 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(NON_DYNA); // transfert info
#ifdef UTILISATION_MPI
// calcul de l'équilibrage initiale par le cpu 0
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
temps_transfert_court.Arret_du_comptage(); // fin comptage cpu
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
};
#endif
////------- debug
//cout << "\n debug AlgoriNonDyna::InitAlgorithme ";
//lesMail->Noeud_LesMaille(1,120).Affiche(9);
//cout << endl;
////-------- fin debug
// avant toute chose, au cas où l'algo interviendrait après un autre algo
// on inactive tous les ddl existants
lesMail->Inactive_ddl();
@ -188,7 +168,7 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// vérification d'une singularité éventuelle de la matrice de raideur
// à cause d'un trop faible nombre de pti
VerifSingulariteRaideurMeca(nbddl_X,*lesMail);
// def vecteurs globaux
// def vecteurs globaux
vglobin.Change_taille(nbddl_X); // puissance interne
vglobex.Change_taille(nbddl_X); // puissance externe
vglobaal.Change_taille(nbddl_X,0.); // puissance totale
@ -238,24 +218,22 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// initi boucle sur les increments de charge
icharge = 0;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
// par exemple il faut initialiser les frontières et la répartition esclave et maître
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
// verification qu'il n'y a pas de contact avant le premier increment de charge
lesContacts->Verification();
// // definition des elements de contact eventuels
// // et imposition éventuel de certaines des conditions de contact (dépend du modèle de contact)
// lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
// definition des elements de contact eventuels
// et imposition éventuel de certaines des conditions de contact (dépend du modèle de contact)
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
if (pa.ContactType() == 4) // cas particulier du type 4 de contact où on utilise les forces internes
{// def d'un type générique, utilisé pour le transfert des forces internes, vers les conteneurs noeuds
Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
@ -269,14 +247,11 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// double diam_mini = lesMail->Min_dist2Noeud_des_elements(TEMPS_0);
// lesContacts->DefElemCont(2. * diam_mini);
try {
// definition des elements de contact eventuels
// et imposition éventuel de certaines des conditions de contact (dépend du modèle de contact)
bool nevez_contact = lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
int niveau_substitution = 0; // on intervient sur toutes les matrices
bool premier_calcul = true;
// mise à jour éventuelle de la matrice de raideur en fonction du contact
//bool changement_sur_matrice =
Gestion_stockage_et_renumerotation_avec_contact
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
(premier_calcul,lesMail,nevez_contact,lesCondLim
,lesRef,tab_mato,Ass.Nb_cas_assemb(),lesContacts,niveau_substitution);
matglob=tab_mato(1);
@ -297,7 +272,6 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
};
//--cas de restart et/ou de sauvegarde------------
// tout d'abord récup du restart si nécessaire
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
@ -337,7 +311,8 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -359,15 +334,11 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
};
// sinon ok, et on met à jour la boite d'encombrement compte tenue des nouvelles coordonnées
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
bool nevez_contact = lesContacts->Actualisation(0);
// *** test
bool nevez_bis_contact = lesContacts->Nouveau(0.);
nevez_contact = (nevez_contact || nevez_bis_contact); //double dep_max)
bool nevez_contact = lesContacts->Actualisation();
int niveau_substitution = 0; // on intervient sur toutes les matrices
bool premier_calcul = true;
// mise à jour éventuelle de la matrice de raideur en fonction du contact
//bool changement_sur_matrice =
Gestion_stockage_et_renumerotation_avec_contact
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
(premier_calcul,lesMail,nevez_contact,lesCondLim
,lesRef,tab_mato,Ass.Nb_cas_assemb(),lesContacts,niveau_substitution);
matglob=tab_mato(1);
@ -411,11 +382,14 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
};
};
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// init de var glob
Transfert_ParaGlob_COMPTEUR_INCREMENT_CHARGE_ALGO_GLOBAL(icharge);
//--fin cas de restart et/ou de sauvegarde--------
type_incre = OrdreVisu::PREMIER_INCRE; // pour la visualisation au fil du calcul
// ajout d'un conteneur pour les coordonnées à l'itération 0
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
@ -578,10 +552,6 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
// mais pas après un changement de statut
{ Pilotage_du_temps(charge,arret_pilotage); // appel du Pilotage
if (arret_pilotage) break; // pilotage -> arret du calcul
#ifdef UTILISATION_MPI
// seule le process 0 s'occupe de la sortie
if (ParaGlob::Monde()->rank() == 0)
#endif
if (aff_incr)
{cout << "\n======================================================================"
<< "\nINCREMENT DE CHARGE : " << icharge
@ -623,13 +593,11 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
else
{ // on supprime les éléments inactifs testés à l'incr prec dans Actualisation()
a_changer = lescontacts->SuppressionDefinitiveElemInactif();
bool a_changer_nouveau = lescontacts->Nouveau(max_delta_X);
a_changer = a_changer || a_changer_nouveau;
a_changer = a_changer || lescontacts->Nouveau(max_delta_X);
};
int niveau_substitution = 0; // on intervient sur toutes les matrices
if (premier_calcul || a_changer)
{//bool changement_sur_matrice =
Gestion_stockage_et_renumerotation_avec_contact
{bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
(premier_calcul,lesMail,a_changer,lesCondLim,lesRef
,tab_mato,Ass.Nb_cas_assemb(),lescontacts,niveau_substitution);
matglob=tab_mato(1);
@ -639,11 +607,7 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
}
else
{if (arret_pilotage) break; // pilotage -> arret du calcul
#ifdef UTILISATION_MPI
// seule le process 0 s'occupe de la sortie
if (ParaGlob::Monde()->rank() == 0)
#endif
cout << "\n============================================================================="
cout << "\n============================================================================="
<< "\n ....... re-analyse du contact ........ "
<< "\nINCREMENT DE CHARGE : " << icharge << " intensite " << charge->IntensiteCharge()
<< " t= " << charge->Temps_courant()
@ -729,11 +693,10 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
// qui est projeté sur la facette dans le cas de l'algorithme cinématique
if (pa.ContactType())
{ int niveau_substitution = 0; // on intervient sur toutes les matrices
bool a_changer = lescontacts->Actualisation(1);
bool a_changer = lescontacts->Actualisation();
// mise à jour éventuelle des matrices de raideur en fonction du contact
if (a_changer)
{//bool changement_sur_matrice =
Gestion_stockage_et_renumerotation_avec_contact
{bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
(premier_calcul,lesMail,a_changer,lesCondLim,lesRef
,tab_mato,Ass.Nb_cas_assemb(),lescontacts,niveau_substitution);
matglob=tab_mato(1);
@ -916,12 +879,7 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
// calcul de la variation de ddl / delta t
// delta_X = X_tdt; delta_X -= X_t; // X_tdt - X_t
Algori::Cal_Transfert_delta_et_var_X(max_delta_X,max_var_delta_X);
#ifdef UTILISATION_MPI
// cas d'un calcul //, pour l'instant seul le CPU 0 sont concerné
if ((ParaGlob::Monde()->rank() == 0)&&(permet_affichage > 3))
#else
if (permet_affichage > 3)
#endif
if (permet_affichage > 3)
{ cout << "\n --- |max_var_DeltaDdl|= "<< max_var_delta_X
<< " , |max_deltaDdl|= " << max_delta_X << flush;};
// ---dans le cas du mode debug on sort éventuellement les infos au fil du calcul (un peu bricolé)
@ -948,13 +906,7 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
// en tenant compte éventuellement du contact (non decollement) decol = false systématiquement si pas de contact
decol = false; // pour debugger
bool arret_iteration = false;
#ifdef UTILISATION_MPI
// seule le process 0 s'occupe de la convergence
if (ParaGlob::Monde()->rank() == 0)
{
#endif
if (Convergence(aff_iteration,last_var_ddl_max,vglobaal,maxPuissExt,maxPuissInt,maxReaction,compteur,arret_convergence)
&& !decol)
{ // on sort de la boucle des itérations sauf si l'on est en loi simplifiée
@ -963,19 +915,10 @@ decol = false; // pour debugger
{ lesLoisDeComp->Loi_simplifie(false);}
else
// cas normal,
{arret_iteration = true; }; //break;};
{break;};
}
else if (arret_convergence)
{arret_iteration = true; }; //break;} // cas ou la méthode Convergence() demande l'arret
#ifdef UTILISATION_MPI
};
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
broadcast(*ParaGlob::Monde(), arret_iteration, 0);
temps_transfert_court.Arret_du_comptage(); // fin comptage cpu
#endif
if (arret_iteration)
break;
{break;} // cas ou la méthode Convergence() demande l'arret
// sinon on continue
// pour le pilotage ou pour l'accélération de convergence, sauvegarde du résidu
if (pa.Line_search() || (acceleration_convergence))
@ -986,11 +929,6 @@ decol = false; // pour debugger
bool erreur_resolution_syst_lineaire = false; // init
int nb_matrice_secondaire = tab_mato.Taille(); // = 1 par défaut, mais on peut en avoir d'autre
int niveau_substitution = 1; // par défaut on utilise la matrice de raideur matglob = tab_mato(1)
#ifdef UTILISATION_MPI
// seule le process 0 fait la résolution globale
if (ParaGlob::Monde()->rank() == 0)
{
#endif
while (niveau_substitution <= nb_matrice_secondaire)
{ // on sauvegarde éventuellement le second membre
if (nb_matrice_secondaire > 1) // cela veut dire que l'on est suceptible de faire plusieurs boucles
@ -1046,6 +984,11 @@ decol = false; // pour debugger
};
tempsResolSystemLineaire.Arret_du_comptage(); // temps cpu
// effacement du marquage de ddl bloque du au conditions lineaire imposée par l'entrée
lesCondLim->EffMarque();
if ((pa.ContactType()==1) || (pa.ContactType()==3))
lescontacts->EffMarque();
// cas où on a eu au final une erreur de résolution
if (erreur_resolution_syst_lineaire)
{Change_PhaseDeConvergence(-9); // on signale une divergence due à la résolution
@ -1072,44 +1015,6 @@ decol = false; // pour debugger
// sortie d'info sur l'increment concernant les variations de ddl
if ((aff_iteration)&&(ParaGlob::NiveauImpression() > 1))
InfoIncrementDdl(lesMail,inSol,maxDeltatDdl_signe,Ass.Nb_cas_assemb());
#ifdef UTILISATION_MPI
}
else // s'il s'agit d'un process de calcul élémentaire
{sol = &vglobaal; // il faut affecter sol pour récupérer ensuite la solution
};
// le process 0 transmet aux autres process le vecteur résultat
temps_transfert_long.Mise_en_route_du_comptage(); // comptage cpu
//// essai pour remplacer broadcast
// int nb_process = ParaGlob::Monde()->size();
// mpi::request reqs1;
// if (ParaGlob::Monde()->rank() == 0)
// // NB: le process 0 c'est le main
// {for (int i=1;i<nb_process;i++) // < absolu, donc le max c'est nb_process-1
// {reqs1 = sol->Ienvoi_MPI(i, 38);}
// }
// else
// {reqs1 = sol->Irecup_MPI(0,38);};
//// ParaGlob::Monde()->barrier();
// reqs1.wait();
// mpi::request Ienvoi_MPI(int dest, int tag) const
// {return ParaGlob::Monde()->isend(dest,tag,v,taille);};
// mpi::request Irecup_MPI(int source, int tag) const
sol->Broadcast(0);
// broadcast(*ParaGlob::Monde(), *sol, 0);
// synchronisation ici de tous les process (à supprimer par la suite car n'est
// pas nécessaire pour le déroulementa priori ?? )
// ParaGlob::Monde()->barrier();
temps_transfert_long.Arret_du_comptage(); // fin comptage cpu
#endif
// effacement du marquage de ddl bloque du au conditions lineaire imposée par l'entrée
lesCondLim->EffMarque();
if ((pa.ContactType()==1) || (pa.ContactType()==3))
lescontacts->EffMarque();
// suite du pilotage
// ------------------------------------------------------------
@ -1165,15 +1070,7 @@ decol = false; // pour debugger
};
if ((pa.ContactType()==1) || (pa.ContactType()==3)) lescontacts->EffMarque();
// === gestion de la fin des itérations ===
#ifdef UTILISATION_MPI
// seule le process 0 a fait la résolution globale
// il gère seul également la convergence, mais il doit tenir au courant les autres process
Algori::Passage_indicConvergenceAuxProcCalcul();
// ce qui permet le déroulement correct de la suite pour tous les process
#endif
// gestion de la fin des itérations
if ((!Pilotage_fin_iteration_implicite(compteur))||(pa.EtatSortieEquilibreGlobal()))
// if ((!Pilotage_fin_iteration_implicite(compteur))
// && (!pa.EtatSortieEtatActuelDansBI()))
@ -1200,7 +1097,7 @@ decol = false; // pour debugger
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -1221,15 +1118,14 @@ decol = false; // pour debugger
<< " , |max_deltaDdl|= " << max_delta_X << flush;};
if (pa.ContactType())
{ // actualisation du contact en fonction du dernier incrément
bool nevez_contact = lescontacts->Actualisation(0);
bool nevez_contact = lescontacts->Actualisation();
// réexamen du contact pour voir s'il n'y a pas de nouveau element de contact
// en fait on fera au plus deux passages supplémentaire, sinon la boucle peut être infini,
// à la fin du second passage, on regarde s'il y a décollement, si oui on relâche et on refait un passage
// sinon on valide
//I)--------------
if (indicCycleContact == 0 )
{ bool nouveau_contact = lescontacts->Nouveau(lesMail->Max_var_dep_t_a_tdt());
nevez_contact = nevez_contact || nouveau_contact;
{ nevez_contact = nevez_contact || lescontacts->Nouveau(lesMail->Max_var_dep_t_a_tdt());
if (nevez_contact)
{indicCycleContact=1;} // on a de nouveau contact on refait le deuxième cycle
else
@ -1254,8 +1150,7 @@ decol = false; // pour debugger
)
{int niveau_substitution = 0; // on intervient sur toutes les matrices
bool nouveau = (nevez_contact || relachement_contact);
//bool changement_sur_matrice =
Gestion_stockage_et_renumerotation_avec_contact
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
(premier_calcul,lesMail,nouveau,lesCondLim
,lesRef,tab_mato,Ass.Nb_cas_assemb(),lescontacts,niveau_substitution);
matglob=tab_mato(1);
@ -1767,10 +1662,6 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
// boucle sur les increments de charge
icharge = 1;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -1778,6 +1669,7 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -1791,8 +1683,7 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
int niveau_substitution = 0; // on intervient sur toutes les matrices
bool premier_calcul = true;
// mise à jour éventuelle de la matrice de raideur en fonction du contact
//bool changement_sur_matrice =
Gestion_stockage_et_renumerotation_avec_contact
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
(premier_calcul,lesMail,nevez_contact,lesCondLim
,lesRef,tab_mato,Ass.Nb_cas_assemb(),lesContacts,niveau_substitution);
matglob=tab_mato(1);
@ -1827,7 +1718,7 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -1874,7 +1765,7 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
// de calculer meme si l'utilisateur indique un increment de charge supérieur
// au temps final
bool arret_pilotage=false; // pour arrêt du calcul au niveau du pilotage
while (((!charge->Fin(icharge))||(icharge == 1))
while ((!charge->Fin(icharge))||(icharge == 1)
&& (charge->Fin(icharge,true)!=2) // si on a dépassé le nombre d'incrément permis on s'arrête dans tous les cas
&& (charge->Fin(icharge,false)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
// 1er appel avec true: pour affichage et second avec false car c'est déjà affiché
@ -1982,7 +1873,7 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
(aff_incr && (compteur % pa.freq_affich_iter()==0) &&(compteur!=0)) : false ;
lesLoisDeComp->MiseAJour_umat_nbiter(compteur); // init pour les lois Umat éventuelles
// bool sur_raideur = false; // pour l'instant pas de prise en compte sur la raideur
// bool sur_raideur = true; // essai
bool sur_raideur = true; // essai
// mise en place du chargement impose, c-a-d calcul de la puissance externe
// si pb on sort de la boucle
if (!(charge->ChargeSMembreRaideur_Im_mecaSolid

9
Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.cc → herezh_pp/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -255,10 +255,6 @@ void ImpliNonDynaCont::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
//--** // un premier increment pour demmarer le processus
//--** charge->Avance(); // premier increment de charge ????????? différent des autres algos
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -266,6 +262,7 @@ void ImpliNonDynaCont::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lescontacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -481,7 +478,7 @@ void ImpliNonDynaCont::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
// actualisation des conditions de contact qui peuvent changer
// la largeur de bande, quand un noeud glisse d'une facette sur une voisine
if (compteur != 0)
{ lescontacts->Actualisation(1);
{ lescontacts->Actualisation();
// mise à jour éventuelle de la matrice de raideur en fonction du contact
Mise_a_jour_Choix_matriciel_contact(tab_mato,Ass.Nb_cas_assemb(),lescontacts,niveau_substitution);
mato=tab_mato(1);

3
Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.h → herezh_pp/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.h Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -88,7 +88,6 @@ class ImpliNonDynaCont : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ ImpliNonDynaCont* inter = (ImpliNonDynaCont*) algo;

36
Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.cc → herezh_pp/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.cc Normal file → Executable file
View file

@ -7,7 +7,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -320,7 +320,7 @@ void AlgoBonelli::Gestion_pas_de_temps(LesMaillages * lesMail,int cas,int )
case 1 :
{ // --<DG>-- récup du pas de temps, proposé par l'utilisateur
delta_t = pa.Deltat(); double delta_t_old = delta_t;
// double delta_tSauve = delta_t; // sauvegarde de la situation actuelle
double delta_tSauve = delta_t; // sauvegarde de la situation actuelle
// --<DG>-- on calcul le pas de temps minimal pour cela on utilise
// les caractéristiques dynamiques d'une biellette de longueur
// valant le minimum d'un coté d'arrête
@ -647,15 +647,6 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_BONELLI); // transfert info
#ifdef UTILISATION_MPI
// calcul de l'équilibrage initiale par le cpu 0
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
};
#endif
// avant toute chose, au cas où l'algo interviendrait après un autre algo
// on inactive tous les ddl existants
lesMail->Inactive_ddl();
@ -789,10 +780,6 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// initialisation du compteur d'increments de charge
icharge = 0;
// definition des elements de frontiere, ces elements sont utilises pour le contact
lesMail->CreeElemFront();
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// --- init du contact ---
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
// qui ensuite est utilisée en restart
@ -800,8 +787,7 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// pour préparer la lecture de restart éventuel
if (lesMail->NbEsclave() != 0)
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
// int cal_front =
lesMail->CreeElemFront();
int cal_front = lesMail->CreeElemFront();
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
// initialisation des zones de contacts éventuelles
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
@ -810,7 +796,6 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// definition des elements de contact eventuels
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
};
//--cas de restart et/ou de sauvegarde------------
// tout d'abord récup du restart si nécessaire
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
@ -832,7 +817,7 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
if (ParaGlob::AxiSymetrie())
lesMail->Inactive_un_ddl_particulier(X3);
lesMail->Inactive_un_type_ddl_particulier(X3);
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
@ -872,6 +857,9 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
}
}
//--fin cas de restart et/ou de sauvegarde--------
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
// ajout d'un conteneur pour les coordonnées à l'itération 0
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
@ -984,8 +972,6 @@ void AlgoBonelli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
{
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_BONELLI); // transfert info
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
OrdreVisu::EnumTypeIncre type_incre = OrdreVisu::PREMIER_INCRE; // pour la visualisation au fil du calcul
// préparation pour les aspects validation du calcul et sortie contrôlée des incréments
@ -1438,8 +1424,8 @@ void AlgoBonelli::AvanceDDL_avec_CL(const Vecteur & phii,enuTypePhase phasage)
for(ie=li_gene_asso.begin(),ih=1;ie!=iefin;ie++,ih++)
{LesCondLim::Gene_asso & s = (*ie); // pour simplifier
int ix=s.pointe(1); // début des Xi
// int iv=s.pointe(2); // début des Vi
// int ig=s.pointe(3); // début des gammai
int iv=s.pointe(2); // début des Vi
int ig=s.pointe(3); // début des gammai
q_2(ix) = X_Bl(ih);
q_1(ix) = X_t(ix);
};
@ -1488,8 +1474,8 @@ void AlgoBonelli::AvanceDDL_avec_CL(const Vecteur & phii,enuTypePhase phasage)
for(ie=li_gene_asso.begin(),ih=1;ie!=iefin;ie++,ih++)
{LesCondLim::Gene_asso & s = (*ie); // pour simplifier
int ix=s.pointe(1); // début des Xi
// int iv=s.pointe(2); // début des Vi
// int ig=s.pointe(3); // début des gammai
int iv=s.pointe(2); // début des Vi
int ig=s.pointe(3); // début des gammai
q_2(ix) = X_Bl(ih);
q_1(ix) = X_t(ix);
};

3
Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.h → herezh_pp/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -107,7 +107,6 @@ class AlgoBonelli : public Algori
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
<< " arret !! " << flush;
Sortie(1);
return NULL;
}
else
{ AlgoBonelli* inter = (AlgoBonelli*) algo;

6
Chargement/BlocCharge.cc → herezh_pp/Chargement/BlocCharge.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -93,7 +93,7 @@ void BlocScalVecTypeCharge::Lecture_champ_de_valeurs(UtilLecture & entreePrinc)
{ list <double> lili; // une liste de travail
// on va lire tant que l'on n'aura pas trouvé le mot clé de fin de champ
entreePrinc.NouvelleDonnee(); // lecture d'un nouvelle enregistrement
while (strstr(entreePrinc.tablcar,"fin_champ_de_valeurs:")==NULL)
while (strstr(entreePrinc.tablcar,"fin_champ_de_valeurs:")!=NULL)
{ double grandeur;
*(entreePrinc.entree) >> grandeur;
// on contrôle le flux
@ -873,7 +873,7 @@ void PTorseurPonct::Force(const Tableau <Coordonnee >& tab_P, Tableau <Coordonne
{for (int i =1; i<= nb_Pi; i++)
{Coordonnee& tab_P_i = tab_P(i);
t_force(i) = Re ; // première partie du calcul de force
G += tab_P_i ;
G += tab_P(i) ;
poids_total += 1.;
};
// d'où

2
Chargement/BlocCharge.h → herezh_pp/Chargement/BlocCharge.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

2
Chargement/BlocCharge_T.h → herezh_pp/Chargement/BlocCharge_T.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

6
Chargement/Charge.cc → herezh_pp/Chargement/Charge.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -758,7 +758,7 @@ void Charge::Initialise(LesMaillages * lesmail,LesReferences* lesRef,ParaAlgoCon
// dans le cas où il s'agit d'une ref relative à un champ, on vérifie que le nombre
// de valeurs enregistrées correspond bien au nombre de noeuds
if (tabPresUnif(i).Champ() != 0)
{ if (tabPresUnif(i).DimVal() != ref.Taille())
{ if (tabPresUnif(i).DimVect() != ref.Taille())
{ cout << "\n ERREUR la reference: " << ref.Nom()
<< " contiens "<<ref.Taille() << " facette "
<< " alors que le champ de valeurs lues stocke "
@ -1041,7 +1041,7 @@ void Charge::Initialise(LesMaillages * lesmail,LesReferences* lesRef,ParaAlgoCon
for (int i=1;i<= tabTorseurPonct.Taille();i++)
{ { // recup de la reference correspondant au mot cle
const Reference& ref = lesRef->Trouve(tabTorseurPonct(i).NomRef(),tabTorseurPonct(i).NomMaillage());
//const ReferenceNE & refN = ((ReferenceNE &) ref);
const ReferenceNE & refN = ((ReferenceNE &) ref);
if (ref.Indic() != 1)
// cas où la référence ne correspond pas à des noeuds
{ cout << "\n ERREUR la reference: " << ref.Nom()

2
Chargement/Charge.h → herezh_pp/Chargement/Charge.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

16
Chargement/Charge2.cc → herezh_pp/Chargement/Charge2.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -45,11 +45,6 @@ bool Charge::ChargeSecondMembre_Ex_mecaSolid
(Assemblage & assemb,LesMaillages * lesMail,LesReferences* lesRef,Vecteur& vecglob
,const ParaAlgoControle & pa,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD)
{
#ifdef UTILISATION_MPI
// cas d'un calcul //, pour l'instant seule la (ou les) matrices du CPU 0 sont concernées
if (ParaGlob::Monde()->rank() != 0)
return true;
#endif
temps_cpu_chargement.Mise_en_route_du_comptage(); // temps cpu
bool retour = true; // init par défaut
try
@ -1082,13 +1077,8 @@ bool Charge::ChargeSMembreRaideur_Im_mecaSolid
const DdlElement& tab_ddl,const Tableau<Noeud *>&tab_noeud)
,const ParaAlgoControle & pa
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD)
{
#ifdef UTILISATION_MPI
// cas d'un calcul //, pour l'instant seule la (ou les) matrices du CPU 0 sont concernées
if (ParaGlob::Monde()->rank() != 0)
return true;
#endif
temps_cpu_chargement.Mise_en_route_du_comptage();
{
temps_cpu_chargement.Mise_en_route_du_comptage();
bool retour = true; // init par défaut
try
{// pour tous les maillages, pour tous les éléments on effectue une initialisation éventuelle

122
Chargement/Charge3.cc → herezh_pp/Chargement/Charge3.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -1256,31 +1256,19 @@ void Charge::Precedent7()
int Charge::Fin1(const int & icharge,bool affichage)
{ double temps = paAlgo->Variables_de_temps().TempsCourant();
if ((temps > paAlgo->Tempsfin()) || (Dabs(temps - paAlgo->Tempsfin()) <= paAlgo->Prectemps()))
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
{ if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
{ cout << "\n >>>> temps fin ("<<paAlgo->Tempsfin()<<") atteint <<<<< " << temps << endl ;};
return 1;
}
// else if (icharge >= paAlgo->Maxincre())
else if (icharge > paAlgo->Maxincre()) // modif 14 sept 2015
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
{if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
<< "\n (pour info: maximum d'essai calcul increments = "<< paAlgo->Max_essai_incre()<<") "
<< endl ;
return 2;
}
else if (compteur_essai_increment > paAlgo->Max_essai_incre())
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
{if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
return 3;
}
else
@ -1289,25 +1277,17 @@ int Charge::Fin1(const int & icharge,bool affichage)
int Charge::Fin2(const int & icharge,bool affichage)
{ double temps = paAlgo->Variables_de_temps().TempsCourant();
if ((temps > paAlgo->Tempsfin()) || (Dabs(temps - paAlgo->Tempsfin()) <= paAlgo->Prectemps()))
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
{ if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
{ cout << "\n >>>> temps fin ("<<paAlgo->Tempsfin()<<") atteint <<<<< " << temps << endl ;};
return 1;
}
}
// else if (icharge >= paAlgo->Maxincre())
else if (icharge > paAlgo->Maxincre()) // modif 14 sept 2015
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
{if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
<< "\n (pour info: maximum d'essai calcul increments = "<< paAlgo->Max_essai_incre()<<") "
<< endl ;
return 2;
}
}
else if (compteur_essai_increment >= paAlgo->Max_essai_incre())
{if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
return 3;
@ -1318,66 +1298,42 @@ int Charge::Fin2(const int & icharge,bool affichage)
int Charge::Fin3(const int & icharge,bool affichage)
{ double temps = paAlgo->Variables_de_temps().TempsCourant();
if ((temps > paAlgo->Tempsfin()) || (Dabs(temps - paAlgo->Tempsfin()) <= paAlgo->Prectemps()))
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
{ if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
{ cout << "\n >>>> temps fin ("<<paAlgo->Tempsfin()<<") atteint <<<<< " << temps << endl ;};
return 1;
}
}
// else if (icharge >= paAlgo->Maxincre())
else if (icharge > paAlgo->Maxincre()) // modif 14 sept 2015
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
{if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
<< "\n (pour info: maximum d'essai calcul increments = "<< paAlgo->Max_essai_incre()<<") "
<< endl ;
return 2;
return 2;
}
else if (compteur_essai_increment >= paAlgo->Max_essai_incre())
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
{if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
return 3;
}
}
else
return 0;
};
int Charge::Fin4(const int & icharge,bool affichage)
{ double temps = paAlgo->Variables_de_temps().TempsCourant();
if ((temps > paAlgo->Tempsfin()) || (Dabs(temps - paAlgo->Tempsfin()) <= paAlgo->Prectemps()))
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
{ if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
{ cout << "\n >>>> temps fin ("<<paAlgo->Tempsfin()<<") atteint <<<<< " << temps << endl ;};
return 1;
}
}
// else if (icharge >= paAlgo->Maxincre())
else if (icharge > paAlgo->Maxincre()) // modif 14 sept 2015
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
{if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
<< "\n (pour info: maximum d'essai calcul increments = "<< paAlgo->Max_essai_incre()<<") "
<< endl ;
return 2;
}
return 2;
}
else if (compteur_essai_increment >= paAlgo->Max_essai_incre())
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
return 3;
}
{if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
return 3;
}
else
return 0;
};
@ -1386,41 +1342,25 @@ int Charge::Fin5(const int & icharge,bool affichage)
CourbePolyLineaire1D* fconnue_charge = (CourbePolyLineaire1D*) f_charge;
double temps = paAlgo->Variables_de_temps().TempsCourant(); // puis le temps
if ((temps > paAlgo->Tempsfin()) || (Dabs(temps - paAlgo->Tempsfin()) <= paAlgo->Prectemps()))
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
{ if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
{ cout << "\n >>>> temps fin ("<<paAlgo->Tempsfin()<<") atteint <<<<< " << temps << endl ;};
return 1;
}
}
else if ( num_pt_courant_type5 == fconnue_charge->NombrePoint())
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if (affichage) cout << "\n >>>> dernier temps de la courbe de charge atteint <<<<< " << endl ;
{ if (affichage) cout << "\n >>>> dernier temps de la courbe de charge atteint <<<<< " << endl ;
return 1;
}
}
// else if (icharge >= paAlgo->Maxincre())
else if (icharge > paAlgo->Maxincre()) // modif 14 sept 2015
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
{if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
<< "\n (pour info: maximum d'essai calcul increments = "<< paAlgo->Max_essai_incre()<<") "
<< endl ;
return 2;
return 2;
}
else if (compteur_essai_increment >= paAlgo->Max_essai_incre())
{
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
#endif
if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
return 3;
}
{if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
return 3;
}
else
return 0;
};

2
Chargement/VariablesTemps.cc → herezh_pp/Chargement/VariablesTemps.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

2
Chargement/VariablesTemps.h → herezh_pp/Chargement/VariablesTemps.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

43
Elements/Element.cc → herezh_pp/Elements/Element.cc Normal file → Executable file
View file

@ -11,7 +11,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -792,7 +792,7 @@ Element::operator= (Element& elt)
// en 2D: quadrangle: racine carré de la surface; triangle: racine carré de 2*surface
// en 3D: hexa: racine cubique de vol; penta: racine cub de 2*vol, tétra: racine cub 6*vol
// cas = 3: 1D idem cas 2, 2D: distance mini noeud arrête opposée, 3D: distance mini noeud face opposé
double Element::LongueurGeometrique_mini(int cas) const
double Element::LongueurGeometrique(int cas) const
{ double longueur=0.; // valeur de retour
switch (cas)
{ case 1:
@ -823,7 +823,7 @@ double Element::LongueurGeometrique_mini(int cas) const
// traitement d'une erreur éventuelle
if (dist <= ConstMath::petit)
{ cout << "\n **** ERREUR une longueur d'arrête de l'element est nulle"
<< "\n Element::LongueurGeometrique_mini(int cas)"
<< "\n Element::LongueurGeometrique(int cas)"
<< "\n element: "; this->Affiche(1);
#ifdef MISE_AU_POINT
cout << "\n *** version mise au point: on continue neanmoins avec une longueur "
@ -837,7 +837,7 @@ double Element::LongueurGeometrique_mini(int cas) const
}
default :
cout << "\nErreur : cas:" << cas <<" non encore traite !\n"
<< "Element::LongueurGeometrique_mini(int cas) ) \n";
<< "Element::LongueurGeometrique(int cas) ) \n";
Sortie(1);
}
//cout << " longueur= "<< longueur << endl;
@ -917,34 +917,29 @@ int Element::Num_de_frontiere_dans_le_type(int i) const
{ // on supprime les cas hors du tableau tabb
if (i<1) return 0;
int tailletab = tabb.Taille();
if (i>tailletab) return 0;
// cas normal
if (i <= posi_tab_front_lin)
// cela veut dire que i est une surface car les premières frontières sont les surfaces, de plus i est directement le numéro de surface
{ return i;}
else if (i <= posi_tab_front_point)
// cela veut dire que i est une ligne car les frontières après les surfaces sont les lignes
{ return (i-posi_tab_front_lin); }
else
// cela veut dire que i est un point car les frontières après les lignes sont des points
{ return (i-posi_tab_front_point);};
};
if (i>tailletab) return 0;
// cas normal
if (i <= posi_tab_front_lin)
// cela veut dire que i est une surface car les premières frontières sont les surfaces, de plus i est directement le numéro de surface
{ return i;}
else if (i <= posi_tab_front_point)
// cela veut dire que i est une ligne car les frontières après les surfaces sont les lignes
{ return (i-posi_tab_front_lin); }
else
// cela veut dire que i est un point car les frontières après les lignes sont des points
{ return (i-posi_tab_front_point);};
};
// ramene le numero de la frontière passée en argument si elle existe actuellement au niveau de l'élément
// sinon ramène 0
// ramene également type_front: qui indique le type de frontière: POINT_G, LIGNE ou SURFACE
// c'est une méthode très longue, a utiliser avec précaution
int Element::Num_frontiere(const ElFrontiere& fronti, Enum_type_geom& type_front) const
int Element::Num_frontiere(const ElFrontiere& fronti, Enum_type_geom& type_front)
{ int num=0; type_front = RIEN_TYPE_GEOM; // initialisation du retour
// on commence par balayer toutes les frontières pour trouver le numéro global
int tail_tab=tabb.Taille();
for (int i=1;i<=tail_tab;i++)
{// le tableau global peut avoir été correctement dimensionné
// mais les éléments frontières peuvent avoir été supprimés
if (tabb(i) != NULL) // cas où la frontière existe
{if (fronti == (*tabb(i))) {num = i; break;}
}
};
if (fronti == (*tabb(i))) {num = i; break;}
// si num est diff de 0 c'est ok, on recherche le type de frontière
if (num != 0)
{ // les frontières sont rangées selon: surface, ligne, point
@ -955,7 +950,7 @@ int Element::Num_frontiere(const ElFrontiere& fronti, Enum_type_geom& type_front
else if ((num > posi_tab_front_lin)&&(ind_front_lin!=0)) {type_front = LIGNE;num -= posi_tab_front_lin;}
// si ce n'est ni un point ni une ligne, vue que ça doit-être quelque chose ça ne peut être qu'une surface
else {type_front = SURFACE;}; // et num a directement la bonne valeur que ce sont d'abord les faces qui sont stockées
};
}
// retour des infos
return num;
};

33
Elements/Element.h → herezh_pp/Elements/Element.h Normal file → Executable file
View file

@ -10,7 +10,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -39,8 +39,6 @@
#ifndef ELEMENT_H
#define ELEMENT_H
using namespace std;
#include <iostream>
#include <stdlib.h>
@ -299,8 +297,6 @@ class Element
// pour le schema implicite
class ResRaid { public : Vecteur* res; Mat_pleine * raid ; };
virtual ResRaid Calcul_implicit (const ParaAlgoControle & pa ) = 0;
// récup uniquement du conteneur raideur (pas forcément rempli, mais de la bonne taille)
Mat_pleine * Conteneur_raideur () {return raideur; };
// Calcul du residu local a l'instant t
// pour le schema explicit, resultat dans le vecteur pointe
@ -309,9 +305,7 @@ class Element
// Calcul du residu local a l'instant tdt
// pour le schema explicit, resultat dans le vecteur pointe
virtual Vecteur* CalculResidu_tdt (const ParaAlgoControle & pa) = 0;
// récup uniquement du conteneur résidu (pas forcément rempli, mais de la bonne taille)
Vecteur* Conteneur_Residu () {return residu;};
// Calcul de la matrice masse pour l'élément
virtual Mat_pleine * CalculMatriceMasse (Enum_calcul_masse id_calcul_masse) = 0;
@ -342,7 +336,7 @@ class Element
// en 2D: quadrangle: racine carré de la surface; triangle: racine carré de 2*surface
// en 3D: hexa: racine cubique de vol; penta: racine cub de 2*vol, tétra: racine cub 6*vol
// cas = 3: 1D idem cas 2, 2D: distance mini noeud arrête opposée, 3D: distance mini noeud face opposé
double LongueurGeometrique_mini(int cas) const;
double LongueurGeometrique(int cas) const;
// récupération du volume de l'élément (qui doit avoir été calculé dans une des classes dérivées
// par exemple en mécanique via un calcul explicite ou implicite d'équilibre mécanique
// pour un élément 3D: le volume au sens classique
@ -607,14 +601,14 @@ class Element
// ============ Calcul des frontieres de l'element================
// tout d'abord une explication sur la terminologie
// on appelle frontières minimales de l'éléments les frontières naturelles c'est-à-dire
// on appelle frontières de l'éléments les frontières naturelles c'est-à-dire
// pour les éléments 1D : les noeuds aux l'extrémitées en monde 1D
// sinon également l'élément en monde 2D et 3D
// pour les éléments 2D : les arrêtes de l'élément en monde 2D
// sinon également la surface de l'élément en monde 2D et 3D
// pour les éléments 3D : les surfaces externes de l'élément
// Calcul des frontieres minimales de l'element et retour d'un tableau tabb des frontières
// Calcul des frontieres de l'element et retour d'un tableau tabb des frontières
// creation des elements frontieres et stockage dans l'element
// si c'est la première fois sinon il y a seulement retour du tableau de ces elements
// a moins que le paramètre force est mis a true dans ce dernier cas seul les frontière effacées sont recréée
@ -681,22 +675,7 @@ class Element
// sinon ramène 0
// ramene également type_front: qui indique le type de frontière: POINT_G, LIGNE ou SURFACE
// c'est une méthode très longue, a utiliser avec précaution
int Num_frontiere(const ElFrontiere& fronti, Enum_type_geom& type_front) const;
// Calcul spécifiques des frontieres de l'element et retour d'un tableau tabb des frontières
// creation des elements frontieres et stockage dans l'element
// la création n'a lieu qu'au premier appel
// ou lorsque l'on force le paramètre force a true
// dans ce dernier cas seul les frontière effacées sont recréée
// cas :
// = 0 -> on veut toutes les frontières
// = 1 -> on veut uniquement les surfaces
// = 2 -> on veut uniquement les lignes
// = 3 -> on veut uniquement les points
// = 4 -> on veut les surfaces + les lignes
// = 5 -> on veut les surfaces + les points
// = 6 -> on veut les lignes + les points
// virtual Tableau <ElFrontiere*> const & Frontiere_specifique(int cas, bool force = false) = 0;
int Num_frontiere(const ElFrontiere& fronti, Enum_type_geom& type_front);
// mise à jour de la boite d'encombrement de l'élément, suivant les axes I_a globales
// en retour coordonnées du point mini dans retour.Premier() et du point maxi dans .Second()

2
Elements/Geometrie/ElemGeom/ElemGeomC0.cc → herezh_pp/Elements/Geometrie/ElemGeom/ElemGeomC0.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

10
Elements/Geometrie/ElemGeom/ElemGeomC0.h → herezh_pp/Elements/Geometrie/ElemGeom/ElemGeomC0.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -114,13 +114,13 @@ class ElemGeomC0
// retourne les coordonnees du point d'integration i
inline Coordonnee const & CoorPtInteg(int i) const { return ptInteg(i);};
// retourne les fonctions d'interpolation au point d'integration i
inline Vecteur const & Phi(int i) const { return tabPhi(i);};
inline Vecteur const & Phi(int i) { return tabPhi(i);};
// retourne les tableau de fonctions d'interpolation
inline Tableau <Vecteur> const & TaPhi() const { return tabPhi;};
// retourne les derivees des fonctions d'interpolation au point d'integration i
inline Mat_pleine const& Dphi(int i) { return tabDPhi(i);};
// retourne le tableau des derivees des fonctions d'interpolation
inline Tableau < Mat_pleine > const& TaDphi() const { return tabDPhi;};
inline Tableau < Mat_pleine > const& TaDphi() { return tabDPhi;};
// retourne les poids d'integration du point d'integration i
inline double Wi(int i) const { return WI(i);};
// retourne le vecteur des poids d'integration
@ -200,9 +200,9 @@ class ElemGeomC0
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
virtual const Vecteur& Phi_point(const Coordonnee& M) = 0;
virtual const Vecteur& Phi(const Coordonnee& M) = 0;
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
virtual const Mat_pleine& Dphi_point(const Coordonnee& M) = 0;
virtual const Mat_pleine& Dphi(const Coordonnee& M) = 0;
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
// de l'element, false sinon
virtual bool Interieur(const Coordonnee& M) = 0;

2
Elements/Geometrie/ElemGeom/ElemGeomC1.h → herezh_pp/Elements/Geometrie/ElemGeom/ElemGeomC1.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

6
Elements/Geometrie/ElemGeom/Ligne/GeomSeg.cc → herezh_pp/Elements/Geometrie/ElemGeom/Ligne/GeomSeg.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -339,7 +339,7 @@ ElemGeomC0 * GeomSeg::newElemGeomC0(ElemGeomC0 * pt)
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& GeomSeg::Phi_point(const Coordonnee& M)
const Vecteur& GeomSeg::Phi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales
@ -381,7 +381,7 @@ const Vecteur& GeomSeg::Phi_point(const Coordonnee& M)
return phi_M;
};
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& GeomSeg::Dphi_point(const Coordonnee& M)
const Mat_pleine& GeomSeg::Dphi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales

6
Elements/Geometrie/ElemGeom/Ligne/GeomSeg.h → herezh_pp/Elements/Geometrie/ElemGeom/Ligne/GeomSeg.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -114,9 +114,9 @@ class GeomSeg : public ElemGeomC0
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& Phi_point(const Coordonnee& M);
const Vecteur& Phi(const Coordonnee& M);
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& Dphi_point(const Coordonnee& M);
const Mat_pleine& Dphi(const Coordonnee& M);
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
// de l'element, false sinon
bool Interieur(const Coordonnee& M);

6
Elements/Geometrie/ElemGeom/Point/GeomPoint.cc → herezh_pp/Elements/Geometrie/ElemGeom/Point/GeomPoint.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -82,7 +82,7 @@ ElemGeomC0 * GeomPoint::newElemGeomC0(ElemGeomC0 * pt)
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& GeomPoint::Phi_point(const Coordonnee& M)
const Vecteur& GeomPoint::Phi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales
@ -99,7 +99,7 @@ const Vecteur& GeomPoint::Phi_point(const Coordonnee& M)
return phi_M;
};
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& GeomPoint::Dphi_point(const Coordonnee& M)
const Mat_pleine& GeomPoint::Dphi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales

6
Elements/Geometrie/ElemGeom/Point/GeomPoint.h → herezh_pp/Elements/Geometrie/ElemGeom/Point/GeomPoint.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -84,9 +84,9 @@ class GeomPoint : public ElemGeomC0
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& Phi_point(const Coordonnee& M);
const Vecteur& Phi(const Coordonnee& M);
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& Dphi_point(const Coordonnee& M);
const Mat_pleine& Dphi(const Coordonnee& M);
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
// de l'element, false sinon
bool Interieur(const Coordonnee& M);

12
Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.cc → herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -531,7 +531,7 @@ ElemGeomC0 * GeomQuadrangle::newElemGeomC0(ElemGeomC0 * pt)
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& GeomQuadrangle::Phi_point(const Coordonnee& M)
const Vecteur& GeomQuadrangle::Phi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales
@ -559,7 +559,7 @@ const Vecteur& GeomQuadrangle::Phi_point(const Coordonnee& M)
Vecteur tabPhiT(NBNE);
for (int iy = 1;iy<= nbnes; iy++)
for (int ix =1;ix<=nbnes;ix++)
{ tabPhiT(ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Phi_point(Y)(iy);
{ tabPhiT(ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy);
ne++;
}
// numerotation suivant le standard habituel
@ -644,7 +644,7 @@ const Vecteur& GeomQuadrangle::Phi_point(const Coordonnee& M)
return phi_M;
};
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& GeomQuadrangle::Dphi_point(const Coordonnee& M)
const Mat_pleine& GeomQuadrangle::Dphi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales
@ -673,8 +673,8 @@ const Mat_pleine& GeomQuadrangle::Dphi_point(const Coordonnee& M)
Mat_pleine tabDPhiT(2,NBNE);
for (int iy = 1;iy<= nbnes; iy++)
for (int ix =1;ix<=nbnes;ix++)
{ tabDPhiT(1,ne) = seg(1)->Dphi_point(X)(1,ix) * seg(1)->Phi_point(Y)(iy);
tabDPhiT(2,ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Dphi_point(Y)(1,iy);
{ tabDPhiT(1,ne) = seg(1)->Dphi(X)(1,ix) * seg(1)->Phi(Y)(iy);
tabDPhiT(2,ne) = seg(1)->Phi(X)(ix) * seg(1)->Dphi(Y)(1,iy);
ne++;
}
// numerotation suivant le standard habituel

6
Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.h → herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -162,9 +162,9 @@ class GeomQuadrangle : public ElemGeomC0
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& Phi_point(const Coordonnee& M);
const Vecteur& Phi(const Coordonnee& M);
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& Dphi_point(const Coordonnee& M);
const Mat_pleine& Dphi(const Coordonnee& M);
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
// de l'element, false sinon
bool Interieur(const Coordonnee& M);

6
Elements/Geometrie/ElemGeom/surface/GeomTriangle.cc → herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomTriangle.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -590,7 +590,7 @@ ElemGeomC0 * GeomTriangle::newElemGeomC0(ElemGeomC0 * pt)
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& GeomTriangle::Phi_point(const Coordonnee& M)
const Vecteur& GeomTriangle::Phi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales
@ -692,7 +692,7 @@ const Vecteur& GeomTriangle::Phi_point(const Coordonnee& M)
return phi_M;
};
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& GeomTriangle::Dphi_point(const Coordonnee& M)
const Mat_pleine& GeomTriangle::Dphi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales

6
Elements/Geometrie/ElemGeom/surface/GeomTriangle.h → herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomTriangle.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -147,9 +147,9 @@ class GeomTriangle : public ElemGeomC0
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& Phi_point(const Coordonnee& M);
const Vecteur& Phi(const Coordonnee& M);
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& Dphi_point(const Coordonnee& M);
const Mat_pleine& Dphi(const Coordonnee& M);
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
// de l'element, false sinon
bool Interieur(const Coordonnee& M);

2
Elements/Geometrie/ElemGeom/volume/GeomHexaCom.cc → herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaCom.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

2
Elements/Geometrie/ElemGeom/volume/GeomHexaCom.h → herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaCom.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

18
Elements/Geometrie/ElemGeom/volume/GeomHexaCubique.cc → herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaCubique.cc
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -172,9 +172,9 @@ GeomHexaCubique::GeomHexaCubique(int nbi) :
// on utilise les méthodes internes pour calculer les fonctions
// d'interpolation aux points d'intégrations
for (int ptint=1;ptint<= Nbi(); ptint++)
tabPhi(ptint) = Phi_point( ptInteg(ptint));
tabPhi(ptint) = Phi( ptInteg(ptint));
for (int ptint=1;ptint<= Nbi(); ptint++)
tabDPhi(ptint) = Dphi_point( ptInteg(ptint));
tabDPhi(ptint) = Dphi( ptInteg(ptint));
// ---- constitution du tableau Extrapol -----
Calcul_extrapol(nbi);
@ -246,7 +246,7 @@ ElemGeomC0 * GeomHexaCubique::newElemGeomC0(ElemGeomC0 * pt)
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& GeomHexaCubique::Phi_point(const Coordonnee& M)
const Vecteur& GeomHexaCubique::Phi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales
@ -274,7 +274,7 @@ const Vecteur& GeomHexaCubique::Phi_point(const Coordonnee& M)
for (int iz = 1;iz<= nbnes; iz++)
for (int iy = 1;iy<= nbnes; iy++)
for (int ix =1;ix<=nbnes;ix++)
{ tabPhiT(ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Phi_point(Z)(iz);
{ tabPhiT(ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy) * seg(1)->Phi(Z)(iz);
ne++;
}
// numerotation suivant le standard habituel
@ -307,7 +307,7 @@ const Vecteur& GeomHexaCubique::Phi_point(const Coordonnee& M)
return phi_M;
};
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& GeomHexaCubique::Dphi_point(const Coordonnee& M)
const Mat_pleine& GeomHexaCubique::Dphi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales
@ -336,9 +336,9 @@ const Mat_pleine& GeomHexaCubique::Dphi_point(const Coordonnee& M)
for (int iz = 1;iz<= nbnes; iz++)
for (int iy = 1;iy<= nbnes; iy++)
for (int ix =1;ix<=nbnes;ix++)
{ tabDPhiT(1,ne) = seg(1)->Dphi_point(X)(1,ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Phi_point(Z)(iz);
tabDPhiT(2,ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Dphi_point(Y)(1,iy) * seg(1)->Phi_point(Z)(iz);
tabDPhiT(3,ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Dphi_point(Z)(1,iz);
{ tabDPhiT(1,ne) = seg(1)->Dphi(X)(1,ix) * seg(1)->Phi(Y)(iy) * seg(1)->Phi(Z)(iz);
tabDPhiT(2,ne) = seg(1)->Phi(X)(ix) * seg(1)->Dphi(Y)(1,iy) * seg(1)->Phi(Z)(iz);
tabDPhiT(3,ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy) * seg(1)->Dphi(Z)(1,iz);
ne++;
}
// numerotation suivant le standard habituel

8
Elements/Geometrie/ElemGeom/volume/GeomHexaCubique.h → herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaCubique.h
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -59,7 +59,7 @@
// l'élément cubique complet
/*
// ***********************************************************************
//***********************************************************************
// *
// ELEMENT DE REFERENCE , POINTS D'INTEGRATION: *
// *
@ -262,9 +262,9 @@ class GeomHexaCubique : public GeomHexaCom
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& Phi_point(const Coordonnee& M);
const Vecteur& Phi(const Coordonnee& M);
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& Dphi_point(const Coordonnee& M);
const Mat_pleine& Dphi(const Coordonnee& M);
protected :

20
Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.cc → herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.cc Normal file → Executable file
View file

@ -10,7 +10,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -146,21 +146,21 @@ GeomHexaQuad::GeomHexaQuad(int nbi) :
{ // on utilise les méthodes internes pour calculer les fonctions
// d'interpolation aux points d'intégrations
for (int ptint=1;ptint<= Nbi(); ptint++)
tabPhi(ptint) = Phi_point( ptInteg(ptint));
tabPhi(ptint) = Phi( ptInteg(ptint));
for (int ptint=1;ptint<= Nbi(); ptint++)
tabDPhi(ptint) = Dphi_point( ptInteg(ptint));
tabDPhi(ptint) = Dphi( ptInteg(ptint));
}
// vérification suivant OK a priori
// essai de calcul directe des fonctions d'interpolation
for (int ptint=1;ptint<= Nbi(); ptint++)
tabPhi(ptint) = Phi_point( ptInteg(ptint));
tabPhi(ptint) = Phi( ptInteg(ptint));
for (int ptint=1;ptint<= Nbi(); ptint++)
tabDPhi(ptint) = Dphi_point( ptInteg(ptint)); //*/
tabDPhi(ptint) = Dphi( ptInteg(ptint)); //*/
// vérification des fonctions d'interpolation analytique et numériques
for (int ptint=1;ptint<= Nbi(); ptint++)
{
Vecteur a = tabPhi(ptint);Vecteur b = Phi_point( ptInteg(ptint));
Vecteur a = tabPhi(ptint);Vecteur b = Phi( ptInteg(ptint));
for (int ne=1;ne<= NBNE;ne++)
if (Dabs(a(ne) - b(ne)) >= 1.E-14)
{
@ -173,7 +173,7 @@ GeomHexaQuad::GeomHexaQuad(int nbi) :
// et numériques
for (int ptint=1;ptint<= Nbi(); ptint++)
{
Mat_pleine a = tabDPhi(ptint);Mat_pleine b = Dphi_point( ptInteg(ptint));
Mat_pleine a = tabDPhi(ptint);Mat_pleine b = Dphi( ptInteg(ptint));
for (int ne=1;ne<= NBNE;ne++)
for (int ia =1; ia<= 3; ia++)
if (Dabs(a(ia,ne) - b(ia,ne)) >= 1.E-14)
@ -218,7 +218,7 @@ ElemGeomC0 * GeomHexaQuad::newElemGeomC0(ElemGeomC0 * pt)
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& GeomHexaQuad::Phi_point(const Coordonnee& M)
const Vecteur& GeomHexaQuad::Phi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales
@ -275,7 +275,7 @@ const Vecteur& GeomHexaQuad::Phi_point(const Coordonnee& M)
return phi_M;
};
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& GeomHexaQuad::Dphi_point(const Coordonnee& M)
const Mat_pleine& GeomHexaQuad::Dphi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales
@ -428,7 +428,7 @@ void GeomHexaQuad::Calcul_extrapol(int nbi)
// maintenant on calcule les fct d'interpolation au noeud ne
// via ses coordonnées locales theta
const Vecteur& phiphi = hexa.Phi_point(theta);
const Vecteur& phiphi = hexa.Phi(theta);
// et on enregistre
indir(ne).Change_taille(8);
tab(ne).Change_taille(nbi);

6
Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.h → herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -239,9 +239,9 @@ class GeomHexaQuad : public GeomHexaCom
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& Phi_point(const Coordonnee& M);
const Vecteur& Phi(const Coordonnee& M);
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& Dphi_point(const Coordonnee& M);
const Mat_pleine& Dphi(const Coordonnee& M);
protected :

2
Elements/Geometrie/ElemGeom/volume/GeomHexaQuad2.cc → herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuad2.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//

24
Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.cc → herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.cc Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -149,9 +149,9 @@ GeomHexaQuadComp::GeomHexaQuadComp(int nbi) :
// on utilise les méthodes internes pour calculer les fonctions
// d'interpolation aux points d'intégrations
for (int ptint=1;ptint<= Nbi(); ptint++)
tabPhi(ptint) = Phi_point( ptInteg(ptint));
tabPhi(ptint) = Phi( ptInteg(ptint));
for (int ptint=1;ptint<= Nbi(); ptint++)
tabDPhi(ptint) = Dphi_point( ptInteg(ptint));
tabDPhi(ptint) = Dphi( ptInteg(ptint));
// ---- constitution du tableau Extrapol -----
Calcul_extrapol(nbi);
@ -223,7 +223,7 @@ ElemGeomC0 * GeomHexaQuadComp::newElemGeomC0(ElemGeomC0 * pt)
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& GeomHexaQuadComp::Phi_point(const Coordonnee& M)
const Vecteur& GeomHexaQuadComp::Phi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales
@ -251,7 +251,7 @@ const Vecteur& GeomHexaQuadComp::Phi_point(const Coordonnee& M)
for (int iz = 1;iz<= nbnes; iz++)
for (int iy = 1;iy<= nbnes; iy++)
for (int ix =1;ix<=nbnes;ix++)
{ tabPhiT(ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Phi_point(Z)(iz);
{ tabPhiT(ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy) * seg(1)->Phi(Z)(iz);
ne++;
}
// numerotation suivant le standard habituel
@ -284,7 +284,7 @@ const Vecteur& GeomHexaQuadComp::Phi_point(const Coordonnee& M)
return phi_M;
};
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& GeomHexaQuadComp::Dphi_point(const Coordonnee& M)
const Mat_pleine& GeomHexaQuadComp::Dphi(const Coordonnee& M)
{
#ifdef MISE_AU_POINT
// verification de la dimension des coordonnees locales
@ -313,9 +313,9 @@ const Mat_pleine& GeomHexaQuadComp::Dphi_point(const Coordonnee& M)
for (int iz = 1;iz<= nbnes; iz++)
for (int iy = 1;iy<= nbnes; iy++)
for (int ix =1;ix<=nbnes;ix++)
{ tabDPhiT(1,ne) = seg(1)->Dphi_point(X)(1,ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Phi_point(Z)(iz);
tabDPhiT(2,ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Dphi_point(Y)(1,iy) * seg(1)->Phi_point(Z)(iz);
tabDPhiT(3,ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Dphi_point(Z)(1,iz);
{ tabDPhiT(1,ne) = seg(1)->Dphi(X)(1,ix) * seg(1)->Phi(Y)(iy) * seg(1)->Phi(Z)(iz);
tabDPhiT(2,ne) = seg(1)->Phi(X)(ix) * seg(1)->Dphi(Y)(1,iy) * seg(1)->Phi(Z)(iz);
tabDPhiT(3,ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy) * seg(1)->Dphi(Z)(1,iz);
ne++;
}
// numerotation suivant le standard habituel
@ -435,7 +435,7 @@ void GeomHexaQuadComp::Calcul_extrapol(int nbi)
// maintenant on calcule les fct d'interpolation au noeud ne
// via ses coordonnées locales theta
const Vecteur& phiphi = hexa.Phi_point(theta);
const Vecteur& phiphi = hexa.Phi(theta);
// et on enregistre
indir(ne).Change_taille(8);
tab(ne).Change_taille(nbi);
@ -738,7 +738,7 @@ void GeomHexaQuadComp::Calcul_extrapol(int nbi)
// maintenant on calcule les fct d'interpolation au noeud ne
// via ses coordonnées locales theta
const Vecteur& phiphi = hexa.Phi_point(theta);
const Vecteur& phiphi = hexa.Phi(theta);
// et on enregistre
// on boucle sur les pti de l'hexa linéaire d'interpolation
tab(ne).Change_taille(nbi);
@ -991,7 +991,7 @@ void GeomHexaQuadComp::Calcul_extrapol(int nbi)
}
// maintenant on calcule les fct d'interpolation au noeud ne
// via ses coordonnées locales theta
const Vecteur& phiphi = hexa.Phi_point(theta);
const Vecteur& phiphi = hexa.Phi(theta);
// et on enregistre
tab(ne).Change_taille(nbi);
// on boucle sur les pti de l'hexa linéaire d'interpolation

8
Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.h → herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.h Normal file → Executable file
View file

@ -8,7 +8,7 @@
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
@ -60,7 +60,7 @@
/*
// ***********************************************************************
//***********************************************************************
// *
// ELEMENT DE REFERENCE , POINTS D'INTEGRATION: *
// *
@ -243,9 +243,9 @@ class GeomHexaQuadComp : public GeomHexaCom
//--------- cas de coordonnees locales quelconques ----------------
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
const Vecteur& Phi_point(const Coordonnee& M);
const Vecteur& Phi(const Coordonnee& M);
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
const Mat_pleine& Dphi_point(const Coordonnee& M);
const Mat_pleine& Dphi(const Coordonnee& M);
protected :

Some files were not shown because too many files have changed in this diff Show more