1187 lines
64 KiB
C++
1187 lines
64 KiB
C++
|
// This file is part of the Herezh++ application.
|
||
|
|
//
|
||
|
|
// The finite element software Herezh++ is dedicated to the field
|
||
|
|
// of mechanics for large transformations of solid structures.
|
||
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
||
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
||
|
|
//
|
||
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||
|
|
//
|
||
|
|
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||
|
|
// AUTHOR : Gérard Rio
|
||
|
|
// E-MAIL : gerardrio56@free.fr
|
||
|
|
//
|
||
|
|
// This program is free software: you can redistribute it and/or modify
|
||
|
|
// it under the terms of the GNU General Public License as published by
|
||
|
|
// the Free Software Foundation, either version 3 of the License,
|
||
|
|
// or (at your option) any later version.
|
||
|
|
//
|
||
|
|
// This program is distributed in the hope that it will be useful,
|
||
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
||
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||
|
|
// See the GNU General Public License for more details.
|
||
|
|
//
|
||
|
|
// You should have received a copy of the GNU General Public License
|
||
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||
|
|
//
|
||
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
||
|
|
|
||
|
|
|
||
|
|
#include "Algori.h"
|
||
|
|
#include "string"
|
||
|
|
#include "MathUtil.h"
|
||
|
|
#include <iostream> // pour utiliser la classe istrstream
|
||
|
|
#include <strstream> // nouveau dans CW5.3
|
||
|
|
// -- la liste des algorithems actuellement disponibles#include "Projet.h"
|
||
|
|
#include "AlgoriNonDyna.h"
|
||
|
|
#include "ImpliNonDynaCont.h"
|
||
|
|
#include "AlgoriFlambLineaire.h"
|
||
|
|
#include "AlgoInformations.h"
|
||
|
|
#include "AlgoUtils.h"
|
||
|
|
#include "AlgoriDynaExpli.h"
|
||
|
|
#include "AlgoriNewmark.h"
|
||
|
|
#include "Algori_chung_lee.h"
|
||
|
|
#include "AlgoriDynaExpli_zhai.h"
|
||
|
|
#include "Algori_tchamwa.h"
|
||
|
|
#include "AlgoUmatAbaqus.h"
|
||
|
|
#include "AlgoRungeKutta.h"
|
||
|
|
#include "AlgoBonelli.h"
|
||
|
|
#include "Algori_relax_dyna.h"
|
||
|
|
#include "AlgoriCombine.h"
|
||
|
|
//-- fin liste algo
|
||
|
|
|
||
|
|
#include "ReferenceNE.h"
|
||
|
|
#include "ReferenceAF.h"
|
||
|
|
|
||
|
|
|
||
|
|
// passage aux noeuds éventuellement des grandeurs globales, pour une sortie de post-traitement par exemple
|
||
|
|
// mais pas seulement, c'est aussi utilisé pour récupérer des infos dans le contact avec le type 4
|
||
|
|
// le principe est que ce passage s'effectue si les conteneurs existent au niveau des noeuds
|
||
|
|
void Algori::Passage_aux_noeuds_grandeurs_globales(LesMaillages * lesMail)
|
||
|
|
{ // on va boucler sur tous les grandeurs, mais on utilise le premier noeud actif pour savoir si
|
||
|
|
// a priori le transfert est à faire
|
||
|
|
int nb_maillage = lesMail->NbMaillage(); // récup du nombre de maillage
|
||
|
|
List_io < TypeQuelconque >::iterator il,ilfin=listeVecGlob.end();
|
||
|
|
for (il=listeVecGlob.begin();il!=ilfin;il++)
|
||
|
|
{TypeQuelconque& tq = (*il);
|
||
|
|
TypeQuelconque_enum_etendu enuq = tq.EnuTypeQuelconque(); // l'enumeré du type
|
||
|
|
Enum_ddl enuDdl = tq.Enum(); // de ddl associé definissant le point ou est calculé tq
|
||
|
|
Noeud* noe=NULL;
|
||
|
|
// on recherche un noeud où enuDdl est actif
|
||
|
|
for (int imail=1;imail<=nb_maillage;imail++)
|
||
|
|
{int nb_N = lesMail->Nombre_noeud(imail);
|
||
|
|
for (int inoe=1;inoe<=nb_N;inoe++)
|
||
|
|
if (lesMail->Noeud_LesMaille(imail,inoe).En_service(enuDdl))
|
||
|
|
{noe=&lesMail->Noeud_LesMaille(imail,inoe); break;}; // sort de la première boucle
|
||
|
|
if (noe != NULL) break; // sortie de la boucle sur les maillages
|
||
|
|
};
|
||
|
|
if (noe == NULL) // cela veut que la grandeur n'est pas active et donc pas à transférer
|
||
|
|
break; // on sort de la boucle sur les grandeurs globales
|
||
|
|
// arrivée ici la suite est spécifique à chaque grandeur
|
||
|
|
switch (enuq.EnumTQ())
|
||
|
|
{ case FORCE_GENE_EXT:
|
||
|
|
lesMail->Quelconque_glob_vers_local(enuDdl,F_ext_tdt,tq);
|
||
|
|
//debug
|
||
|
|
//cout << "\n debug: Algori::Passage_aux_noeuds_grandeurs_globales ";
|
||
|
|
//F_ext_tdt.Affiche();
|
||
|
|
//fin debug
|
||
|
|
break;
|
||
|
|
case FORCE_GENE_INT:
|
||
|
|
lesMail->Quelconque_glob_vers_local(enuDdl,F_int_tdt,tq);
|
||
|
|
break;
|
||
|
|
case FORCE_GENE_TOT:
|
||
|
|
F_totale_tdt.Change_taille(F_ext_tdt.Taille()); // au cas où
|
||
|
|
F_totale_tdt = F_ext_tdt; F_totale_tdt += F_int_tdt;
|
||
|
|
lesMail->Quelconque_glob_vers_local(enuDdl,F_totale_tdt,tq);
|
||
|
|
break;
|
||
|
|
case RESIDU_GLOBAL:
|
||
|
|
lesMail->Quelconque_glob_vers_local(enuDdl,residu_final,tq);
|
||
|
|
break;
|
||
|
|
case DELTA_XI:
|
||
|
|
lesMail->Quelconque_glob_vers_local(enuDdl,delta_X,tq);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
cout << "\n ** erreur, pour l'instant le transfert depuis global vers noeud de "
|
||
|
|
<< enuq.NomPlein() << " n'est pas implante ... le demander !! "
|
||
|
|
<< "\n Algori::Passage_aux_noeuds_grandeurs_globales(..."<<endl;
|
||
|
|
// dans le cas où un comptage du calcul est en cours on l'arrête
|
||
|
|
if (tempsCalEquilibre.Comptage_en_cours()) tempsCalEquilibre.Arret_du_comptage();
|
||
|
|
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
|
||
|
|
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
|
||
|
|
if (tempsSortieFilCalcul.Comptage_en_cours()) tempsSortieFilCalcul.Arret_du_comptage();
|
||
|
|
if (tempsSauvegarde.Comptage_en_cours()) tempsSauvegarde.Arret_du_comptage();
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// passage aux noeuds de F_int_t et F_ext_t
|
||
|
|
void Algori::Passage_aux_noeuds_F_int_t_et_F_ext_t(LesMaillages * lesMail)
|
||
|
|
{ int dim = ParaGlob::Dimension(); // dimension du pb
|
||
|
|
if(ParaGlob::AxiSymetrie())
|
||
|
|
dim--; // en axisymétrie on récupère uniquement les forces en x et y
|
||
|
|
// def d'un type générique, utilisé pour le transfert des forces internes, vers les conteneurs noeuds
|
||
|
|
Coordonnee coor(dim); // un type coordonnee typique
|
||
|
|
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
|
||
|
|
// def d'un type quelconque représentatif pour un vecteur force à chaque noeud
|
||
|
|
TypeQuelconque typQ_gene_int_t(FORCE_GENE_INT_t,X1,gt);
|
||
|
|
TypeQuelconque typQ_gene_ext_t(FORCE_GENE_EXT_t,X1,gt);
|
||
|
|
|
||
|
|
lesMail->Quelconque_glob_vers_local(X1,F_ext_t,typQ_gene_ext_t);
|
||
|
|
lesMail->Quelconque_glob_vers_local(X1,F_int_t,typQ_gene_int_t);
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
// passage aux noeuds éventuellement d'une grandeur globale particulière,
|
||
|
|
// typeGeneriqu : indique le type de grandeur à passer
|
||
|
|
// Le passage s'effectue si le conteneur existe au niveau des noeuds sinon erreur
|
||
|
|
// seules les grandeurs globales qui n'ont pas été transférées par la méthode
|
||
|
|
// Passage_aux_noeuds_grandeurs_globales , sont concernées
|
||
|
|
void Algori::Passage_aux_noeuds_grandeur_globale_particuliere(const TypeQuelconque& typeGeneriqu, LesMaillages * lesMail)
|
||
|
|
{ TypeQuelconque_enum_etendu enuq = typeGeneriqu.EnuTypeQuelconque(); // l'enumeré du type
|
||
|
|
Enum_ddl enuDdl = typeGeneriqu.Enum(); // de ddl associé definissant le point ou est calculé tq
|
||
|
|
// arrivée ici la suite est spécifique à chaque grandeur
|
||
|
|
switch (enuq.EnumTQ())
|
||
|
|
{ case FORCE_GENE_EXT:
|
||
|
|
lesMail->Quelconque_glob_vers_local(enuDdl,F_ext_tdt,typeGeneriqu);
|
||
|
|
//debug
|
||
|
|
//cout << "\n debug: Algori::Passage_aux_noeuds_grandeurs_globales ";
|
||
|
|
//F_ext_tdt.Affiche();
|
||
|
|
//fin debug
|
||
|
|
break;
|
||
|
|
case FORCE_GENE_INT:
|
||
|
|
lesMail->Quelconque_glob_vers_local(enuDdl,F_int_tdt,typeGeneriqu);
|
||
|
|
break;
|
||
|
|
case FORCE_GENE_TOT:
|
||
|
|
F_totale_tdt.Change_taille(F_ext_tdt.Taille()); // au cas où
|
||
|
|
F_totale_tdt = F_ext_tdt; F_totale_tdt += F_int_tdt;
|
||
|
|
lesMail->Quelconque_glob_vers_local(enuDdl,F_totale_tdt,typeGeneriqu);
|
||
|
|
break;
|
||
|
|
case RESIDU_GLOBAL:
|
||
|
|
lesMail->Quelconque_glob_vers_local(enuDdl,residu_final,typeGeneriqu);
|
||
|
|
break;
|
||
|
|
case DELTA_XI:
|
||
|
|
lesMail->Quelconque_glob_vers_local(enuDdl,delta_X,typeGeneriqu);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
cout << "\n ** erreur, pour l'instant le transfert depuis global vers noeud de "
|
||
|
|
<< enuq.NomPlein() << " n'est pas implante ... le demander !! "
|
||
|
|
<< "\n Algori::Passage_aux_noeuds_grandeur_globale(..."<<endl;
|
||
|
|
// dans le cas où un comptage du calcul est en cours on l'arrête
|
||
|
|
if (tempsCalEquilibre.Comptage_en_cours()) tempsCalEquilibre.Arret_du_comptage();
|
||
|
|
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
|
||
|
|
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
|
||
|
|
if (tempsSortieFilCalcul.Comptage_en_cours()) tempsSortieFilCalcul.Arret_du_comptage();
|
||
|
|
if (tempsSauvegarde.Comptage_en_cours()) tempsSauvegarde.Arret_du_comptage();
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// 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 Algori::Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales(LesMaillages * lesMail
|
||
|
|
,VariablesExporter* varExpor,const Nb_assemb& nb_casAssemb,const LesReferences& lesRef)
|
||
|
|
{ int dim = ParaGlob::Dimension(); // dimension du pb
|
||
|
|
if(ParaGlob::AxiSymetrie())
|
||
|
|
dim--; // en axisymétrie on récupère uniquement les forces en x et y
|
||
|
|
// récupération de la liste des variables en type quelconque
|
||
|
|
const List_io <VariablesExporter::Quelconque_a_un_noeud>& liQuel = varExpor->List_noeud_type_quelconque();
|
||
|
|
List_io <VariablesExporter::Quelconque_a_un_noeud>::const_iterator it,itfin=liQuel.end();
|
||
|
|
for (it = liQuel.begin(); it!=itfin;it++)
|
||
|
|
{ const TypeQuelconque_enum_etendu& ty = (*it).Quelc_const(); // la grandeur constante
|
||
|
|
switch (ty.EnumTQ())
|
||
|
|
{ case FORCE_GENE_EXT:
|
||
|
|
{// récup de la reférence
|
||
|
|
const ReferenceNE & ref =
|
||
|
|
((ReferenceNE &) lesRef.Trouve((*it).Ref_const(),&(*it).Nom_mail_const()));
|
||
|
|
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
|
||
|
|
|
||
|
|
// int ne = (*it).Num_NE_const(); // le num du noeud
|
||
|
|
int nmail = 1;
|
||
|
|
if ((*it).Nom_mail_const() != "")
|
||
|
|
nmail = lesMail->NumMaillage((*it).Nom_mail_const()); // num du maillage
|
||
|
|
// recup du noeud
|
||
|
|
Noeud * noo = & lesMail->Noeud_LesMaille(nmail,ne);
|
||
|
|
// si le noeud n'est pas actif pour ce ddl, on ne continue pas
|
||
|
|
if (noo->Existe_ici(X1)) // ellimine les noeuds non concernés
|
||
|
|
// ** en fait cela pourrait changer pour la thermique pure, mais pour l'instant ce n'est
|
||
|
|
// pas pris en compte, a voir si on veut les forces généralisées associées à de la thermique pure
|
||
|
|
{if ((noo->Existe_ici(ty)) && (noo->En_service(X1)))
|
||
|
|
{// FORCE_GENE_EXT est associé au type coordonnée
|
||
|
|
TypeQuelconque& typQ = noo->ModifGrandeur_quelconque(ty); // récup du conteneur du noeud
|
||
|
|
// récup de la grandeur
|
||
|
|
Grandeur_coordonnee* gcoor = (Grandeur_coordonnee*) typQ.Grandeur_pointee();
|
||
|
|
Coordonnee& conoe = *(gcoor->ConteneurCoordonnee()); // les coordonnées
|
||
|
|
int iglob = noo->Pointeur_assemblage(X1,nb_casAssemb.n);
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if ( iglob == -1 )
|
||
|
|
{ cout << "\nErreur : ddl " << X1
|
||
|
|
<< " inexistant pour le cas de charge " << nb_casAssemb.n
|
||
|
|
<< '\n'
|
||
|
|
<< "Algori::Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales(\n";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
switch (dim) // on rempli les coordonnées
|
||
|
|
{ case 3: conoe(3)=F_ext_tdt(iglob+2);
|
||
|
|
case 2: conoe(2)=F_ext_tdt(iglob+1);
|
||
|
|
case 1: conoe(1)=F_ext_tdt(iglob);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case FORCE_GENE_INT:
|
||
|
|
{// récup de la reférence
|
||
|
|
const ReferenceNE & ref =
|
||
|
|
((ReferenceNE &) lesRef.Trouve((*it).Ref_const(),&(*it).Nom_mail_const()));
|
||
|
|
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
|
||
|
|
// int ne = (*it).Num_NE_const(); // le num du noeud
|
||
|
|
int nmail = 1;
|
||
|
|
if ((*it).Nom_mail_const() != "")
|
||
|
|
nmail = lesMail->NumMaillage((*it).Nom_mail_const()); // num du maillage
|
||
|
|
// recup du noeud
|
||
|
|
Noeud * noo = & lesMail->Noeud_LesMaille(nmail,ne);
|
||
|
|
// le type FORCE_GENE_INT est associé au ddl X1
|
||
|
|
// si le noeud n'est pas actif pour ce ddl, on ne continue pas
|
||
|
|
if (noo->Existe_ici(X1)) // ellimine les noeuds non concernés
|
||
|
|
// ** en fait cela pourrait changer pour la thermique pure, mais pour l'instant ce n'est
|
||
|
|
// pas pris en compte, a voir si on veut les forces généralisées associées à de la thermique pure
|
||
|
|
{if ((noo->Existe_ici(ty)) && (noo->En_service(X1)))
|
||
|
|
{// FORCE_GENE_INT est associé au type coordonnée
|
||
|
|
TypeQuelconque& typQ = noo->ModifGrandeur_quelconque(ty); // récup du conteneur du noeud
|
||
|
|
// récup de la grandeur
|
||
|
|
Grandeur_coordonnee* gcoor = (Grandeur_coordonnee*) typQ.Grandeur_pointee();
|
||
|
|
Coordonnee& conoe = *(gcoor->ConteneurCoordonnee()); // les coordonnées
|
||
|
|
int iglob = noo->Pointeur_assemblage(X1,nb_casAssemb.n);
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if ( iglob == -1 )
|
||
|
|
{ cout << "\nErreur : ddl " << X1
|
||
|
|
<< " inexistant pour le cas de charge " << nb_casAssemb.n
|
||
|
|
<< '\n'
|
||
|
|
<< "Algori::Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales(\n";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
switch (dim) // on rempli les coordonnées
|
||
|
|
{ case 3: conoe(3)=F_int_tdt(iglob+2);
|
||
|
|
case 2: conoe(2)=F_int_tdt(iglob+1);
|
||
|
|
case 1: conoe(1)=F_int_tdt(iglob);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case FORCE_GENE_TOT:
|
||
|
|
{// récup de la reférence
|
||
|
|
const ReferenceNE & ref =
|
||
|
|
((ReferenceNE &) lesRef.Trouve((*it).Ref_const(),&(*it).Nom_mail_const()));
|
||
|
|
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
|
||
|
|
//int ne = (*it).Num_NE_const(); // le num du noeud
|
||
|
|
int nmail = 1;
|
||
|
|
if ((*it).Nom_mail_const() != "")
|
||
|
|
nmail = lesMail->NumMaillage((*it).Nom_mail_const()); // num du maillage
|
||
|
|
// recup du noeud
|
||
|
|
Noeud * noo = & lesMail->Noeud_LesMaille(nmail,ne);
|
||
|
|
// le type FORCE_GENE_TOT est associé au ddl X1
|
||
|
|
// si le noeud n'est pas actif pour ce ddl, on ne continue pas
|
||
|
|
if (noo->Existe_ici(X1)) // ellimine les noeuds non concernés
|
||
|
|
// ** en fait cela pourrait changer pour la thermique pure, mais pour l'instant ce n'est
|
||
|
|
// pas pris en compte, a voir si on veut les forces généralisées associées à de la thermique pure
|
||
|
|
{if ((noo->Existe_ici(ty)) && (noo->En_service(X1)))
|
||
|
|
{// FORCE_GENE_TOT est associé au type coordonnée
|
||
|
|
TypeQuelconque& typQ = noo->ModifGrandeur_quelconque(ty); // récup du conteneur du noeud
|
||
|
|
// récup de la grandeur
|
||
|
|
Grandeur_coordonnee* gcoor = (Grandeur_coordonnee*) typQ.Grandeur_pointee();
|
||
|
|
Coordonnee& conoe = *(gcoor->ConteneurCoordonnee()); // les coordonnées
|
||
|
|
int iglob = noo->Pointeur_assemblage(X1,nb_casAssemb.n);
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if ( iglob == -1 )
|
||
|
|
{ cout << "\nErreur : ddl " << X1
|
||
|
|
<< " inexistant pour le cas de charge " << nb_casAssemb.n
|
||
|
|
<< '\n'
|
||
|
|
<< "Algori::Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales(\n";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
switch (dim) // on rempli les coordonnées
|
||
|
|
{ case 3: conoe(3)=F_int_tdt(iglob+2)+F_ext_tdt(iglob+2);
|
||
|
|
case 2: conoe(2)=F_int_tdt(iglob+1)+F_ext_tdt(iglob+1);
|
||
|
|
case 1: conoe(1)=F_int_tdt(iglob)+F_ext_tdt(iglob);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case RESIDU_GLOBAL:
|
||
|
|
{// récup de la reférence
|
||
|
|
const ReferenceNE & ref =
|
||
|
|
((ReferenceNE &) lesRef.Trouve((*it).Ref_const(),&(*it).Nom_mail_const()));
|
||
|
|
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
|
||
|
|
|
||
|
|
// int ne = (*it).Num_NE_const(); // le num du noeud
|
||
|
|
int nmail = 1;
|
||
|
|
if ((*it).Nom_mail_const() != "")
|
||
|
|
nmail = lesMail->NumMaillage((*it).Nom_mail_const()); // num du maillage
|
||
|
|
// recup du noeud
|
||
|
|
Noeud * noo = & lesMail->Noeud_LesMaille(nmail,ne);
|
||
|
|
// le type RESIDU_GLOBAL est associé au ddl X1
|
||
|
|
// si le noeud n'est pas actif pour ce ddl, on ne continue pas
|
||
|
|
if (noo->Existe_ici(X1)) // ellimine les noeuds non concernés
|
||
|
|
// ** en fait cela pourrait changer pour la thermique pure, mais pour l'instant ce n'est
|
||
|
|
// pas pris en compte, a voir si on veut les forces généralisées associées à de la thermique pure
|
||
|
|
{if ((noo->Existe_ici(ty)) && (noo->En_service(X1)))
|
||
|
|
{// RESIDU_GLOBAL est associé au type coordonnée
|
||
|
|
TypeQuelconque& typQ = noo->ModifGrandeur_quelconque(ty); // récup du conteneur du noeud
|
||
|
|
// récup de la grandeur
|
||
|
|
Grandeur_coordonnee* gcoor = (Grandeur_coordonnee*) typQ.Grandeur_pointee();
|
||
|
|
Coordonnee& conoe = *(gcoor->ConteneurCoordonnee()); // les coordonnées
|
||
|
|
int iglob = noo->Pointeur_assemblage(X1,nb_casAssemb.n);
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if ( iglob == -1 )
|
||
|
|
{ cout << "\nErreur : ddl " << X1
|
||
|
|
<< " inexistant pour le cas de charge " << nb_casAssemb.n
|
||
|
|
<< '\n'
|
||
|
|
<< "Algori::Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales(\n";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
switch (dim) // on rempli les coordonnées
|
||
|
|
{ case 3: conoe(3)=residu_final(iglob+2);
|
||
|
|
case 2: conoe(2)=residu_final(iglob+1);
|
||
|
|
case 1: conoe(1)=residu_final(iglob);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case DELTA_XI:
|
||
|
|
{// récup de la reférence
|
||
|
|
const ReferenceNE & ref =
|
||
|
|
((ReferenceNE &) lesRef.Trouve((*it).Ref_const(),&(*it).Nom_mail_const()));
|
||
|
|
int ne = ref.Numero(1); // le num du noeud: uniquement le premier
|
||
|
|
//int ne = (*it).Num_NE_const(); // le num du noeud
|
||
|
|
int nmail = 1;
|
||
|
|
if ((*it).Nom_mail_const() != "")
|
||
|
|
nmail = lesMail->NumMaillage((*it).Nom_mail_const()); // num du maillage
|
||
|
|
// recup du noeud
|
||
|
|
Noeud * noo = & lesMail->Noeud_LesMaille(nmail,ne);
|
||
|
|
// le type DELTA_XI est associé au ddl X1
|
||
|
|
// si le noeud n'est pas actif pour ce ddl, on ne continue pas
|
||
|
|
if (noo->Existe_ici(X1)) // ellimine les noeuds non concernés
|
||
|
|
// ** en fait cela pourrait changer pour la thermique pure, mais pour l'instant ce n'est
|
||
|
|
// pas pris en compte, a voir si on veut les forces généralisées associées à de la thermique pure
|
||
|
|
{if ((noo->Existe_ici(ty)) && (noo->En_service(X1)))
|
||
|
|
{// DELTA_XI est associé au type coordonnée
|
||
|
|
TypeQuelconque& typQ = noo->ModifGrandeur_quelconque(ty); // récup du conteneur du noeud
|
||
|
|
// récup de la grandeur
|
||
|
|
Grandeur_coordonnee* gcoor = (Grandeur_coordonnee*) typQ.Grandeur_pointee();
|
||
|
|
Coordonnee& conoe = *(gcoor->ConteneurCoordonnee()); // les coordonnées
|
||
|
|
int iglob = noo->Pointeur_assemblage(X1,nb_casAssemb.n);
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if ( iglob == -1 )
|
||
|
|
{ cout << "\nErreur : ddl " << X1
|
||
|
|
<< " inexistant pour le cas de charge " << nb_casAssemb.n
|
||
|
|
<< '\n'
|
||
|
|
<< "Algori::Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales(\n";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
switch (dim) // on rempli les coordonnées
|
||
|
|
{ case 3: conoe(3)=delta_X(iglob+2);
|
||
|
|
case 2: conoe(2)=delta_X(iglob+1);
|
||
|
|
case 1: conoe(1)=delta_X(iglob);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: // on ne fait rien
|
||
|
|
break;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
// //------- temps cpu -----
|
||
|
|
// Temps_CPU_HZpp tempsInitialisation; // lesTempsCpu(1)
|
||
|
|
// Temps_CPU_HZpp tempsMiseAjourAlgo; // lesTempsCpu(2)
|
||
|
|
// Temps_CPU_HZpp tempsCalEquilibre; // lesTempsCpu(3)
|
||
|
|
// Temps_CPU_HZpp tempsRaidSmEner; // lesTempsCpu(4)
|
||
|
|
// Temps_CPU_HZpp tempsSecondMembreEnerg; // lesTempsCpu(5)
|
||
|
|
// Temps_CPU_HZpp tempsResolSystemLineaire; // lesTempsCpu(6)
|
||
|
|
// Temps_CPU_HZpp tempsSauvegarde; // lesTempsCpu(7)
|
||
|
|
// Temps_CPU_HZpp tempsSortieFilCalcul; // lesTempsCpu(8)
|
||
|
|
// Temps_CPU_HZpp tempsRaidSmEnerContact; // lesTempsCpu(9)
|
||
|
|
// Temps_CPU_HZpp tempsSecondMembreEnergContact; // lesTempsCpu(10)
|
||
|
|
// Temps_CPU_HZpp temps_CL; // lesTempsCpu(11)
|
||
|
|
// Temps_CPU_HZpp temps_CLL; // lesTempsCpu(12)
|
||
|
|
// Temps_CPU_HZpp temps_lois_comportement; // lesTempsCpu(13)
|
||
|
|
// Temps_CPU_HZpp temps_metrique_K_SM; // lesTempsCpu(14)
|
||
|
|
// Temps_CPU_HZpp temps_chargement; // lesTempsCpu(15)
|
||
|
|
// Temps_CPU_HZpp temps_rech_contact; // lesTempsCpu(16)
|
||
|
|
//
|
||
|
|
// 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
|
||
|
|
// méthode qui sert au transfert entre les variables "Temps_CPU_HZpp" et le tableau "lesTempsCpu"
|
||
|
|
// et qui doit-être appelé avant l'utilisation du tableau via listeVarGlob par exemple
|
||
|
|
void Algori::Temps_CPU_HZpp_to_lesTempsCpu
|
||
|
|
(const LesCondLim& lesCondLim, const Charge& charge, const LesContacts& contact)
|
||
|
|
{ lesTempsCpu(1)(1)=tempsInitialisation.Temps_CPU_User(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(1)(2)=tempsInitialisation.Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(1)(3)=tempsInitialisation.Temps_CPU_System(); // conversion de long long en double
|
||
|
|
lesTempsCpu(2)(1)=tempsMiseAjourAlgo.Temps_CPU_User(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(2)(2)=tempsMiseAjourAlgo.Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(2)(3)=tempsMiseAjourAlgo.Temps_CPU_System(); // conversion de long long en double
|
||
|
|
lesTempsCpu(3)(1)=tempsCalEquilibre.Temps_CPU_User(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(3)(2)=tempsCalEquilibre.Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(3)(3)=tempsCalEquilibre.Temps_CPU_System(); // conversion de long long en double
|
||
|
|
lesTempsCpu(4)(1)=tempsRaidSmEner.Temps_CPU_User(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(4)(2)=tempsRaidSmEner.Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(4)(3)=tempsRaidSmEner.Temps_CPU_System(); // conversion de long long en double
|
||
|
|
lesTempsCpu(5)(1)=tempsSecondMembreEnerg.Temps_CPU_User(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(5)(2)=tempsSecondMembreEnerg.Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(5)(3)=tempsSecondMembreEnerg.Temps_CPU_System(); // conversion de long long en double
|
||
|
|
lesTempsCpu(6)(1)=tempsResolSystemLineaire.Temps_CPU_User(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(6)(2)=tempsResolSystemLineaire.Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(6)(3)=tempsResolSystemLineaire.Temps_CPU_System(); // conversion de long long en double
|
||
|
|
lesTempsCpu(7)(1)=tempsSauvegarde.Temps_CPU_User(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(7)(2)=tempsSauvegarde.Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(7)(3)=tempsSauvegarde.Temps_CPU_System(); // conversion de long long en double
|
||
|
|
lesTempsCpu(8)(1)=tempsSortieFilCalcul.Temps_CPU_User(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(8)(2)=tempsSortieFilCalcul.Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(8)(3)=tempsSortieFilCalcul.Temps_CPU_System(); // conversion de long long en double
|
||
|
|
lesTempsCpu(9)(1)=tempsRaidSmEnerContact.Temps_CPU_User(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(9)(2)=tempsRaidSmEnerContact.Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(9)(3)=tempsRaidSmEnerContact.Temps_CPU_System(); // conversion de long long en double
|
||
|
|
lesTempsCpu(10)(1)=tempsSecondMembreEnergContact.Temps_CPU_User(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(10)(2)=tempsSecondMembreEnergContact.Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(10)(3)=tempsSecondMembreEnergContact.Temps_CPU_System(); // conversion de long long en double
|
||
|
|
// pour les temps cpu relatifs aux CL et CLL, on les récupères
|
||
|
|
temps_CL=lesCondLim.Temps_cpu_CL();
|
||
|
|
lesTempsCpu(11)(1)=temps_CL.Temps_CPU_User();
|
||
|
|
// lesTempsCpu(11)(2)=lesCondLim.Temps_cpu_CL().Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(11)(3)=lesCondLim.Temps_cpu_CL().Temps_CPU_System(); // conversion de long long en double
|
||
|
|
temps_CLL=lesCondLim.Temps_cpu_CLL();
|
||
|
|
lesTempsCpu(12)(1)=temps_CLL.Temps_CPU_User();
|
||
|
|
// lesTempsCpu(12)(2)=lesCondLim.Temps_cpu_CLL().Temps_CPU_Reel(); // conversion de long long en double
|
||
|
|
// lesTempsCpu(12)(3)=lesCondLim.Temps_cpu_CLL().Temps_CPU_System(); // conversion de long long en double
|
||
|
|
|
||
|
|
lesTempsCpu(13)(1)=temps_lois_comportement.Temps_CPU_User();
|
||
|
|
lesTempsCpu(14)(1)=temps_metrique_K_SM.Temps_CPU_User();
|
||
|
|
temps_chargement = charge.Temps_cpu_chargement();
|
||
|
|
lesTempsCpu(15)(1)= temps_chargement.Temps_CPU_User();
|
||
|
|
temps_rech_contact = contact.Temps_cpu_Contact();
|
||
|
|
lesTempsCpu(16)(1)= temps_rech_contact.Temps_CPU_User();
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
// idem la méthode de transfert si-dessus mais concerne uniquement les temps internes à l'algo
|
||
|
|
// ajoute au tableau passé en paramètre, les temps de l'algo
|
||
|
|
Tableau <Temps_CPU_HZpp> & Algori::Ajout_Temps_CPU_HZpp_to_lesTempsCpu(Tableau <Temps_CPU_HZpp> & lesTsCpu)
|
||
|
|
{ // test éventuel de la taille du tableau
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if (lesTsCpu.Taille() != 10)
|
||
|
|
{cout << "\n erreur de dim de tableau: dim lesTsCpu= " << lesTsCpu.Taille()
|
||
|
|
<< " au lieu de 10 !! "
|
||
|
|
<< "\n Algori::Ajout_Temps_CPU_HZpp_to_lesTempsCpu(... " ;
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// on stocke les infos
|
||
|
|
lesTsCpu(1) += tempsInitialisation; // conversion de long long en double
|
||
|
|
lesTsCpu(2) += tempsMiseAjourAlgo; // conversion de long long en double
|
||
|
|
lesTsCpu(3) += tempsCalEquilibre; // conversion de long long en double
|
||
|
|
lesTsCpu(4) += tempsRaidSmEner; // conversion de long long en double
|
||
|
|
lesTsCpu(5) += tempsSecondMembreEnerg; // conversion de long long en double
|
||
|
|
lesTsCpu(6) += tempsResolSystemLineaire; // conversion de long long en double
|
||
|
|
lesTsCpu(7) += tempsSauvegarde; // conversion de long long en double
|
||
|
|
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
|
||
|
|
// retour
|
||
|
|
return lesTsCpu;
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
// une méthode qui a pour objectif de terminer tous les comptages, utile
|
||
|
|
// dans le cas d'un arrêt impromptu
|
||
|
|
void Algori::Arret_du_comptage_CPU()
|
||
|
|
{ tempsInitialisation.Arret_du_comptage();
|
||
|
|
tempsMiseAjourAlgo.Arret_du_comptage();
|
||
|
|
tempsCalEquilibre.Arret_du_comptage();
|
||
|
|
tempsRaidSmEner.Arret_du_comptage();
|
||
|
|
tempsSecondMembreEnerg.Arret_du_comptage();
|
||
|
|
tempsResolSystemLineaire.Arret_du_comptage();
|
||
|
|
tempsSauvegarde.Arret_du_comptage();
|
||
|
|
tempsSortieFilCalcul.Arret_du_comptage();
|
||
|
|
tempsRaidSmEnerContact.Arret_du_comptage();
|
||
|
|
tempsSecondMembreEnergContact.Arret_du_comptage();
|
||
|
|
temps_CL.Arret_du_comptage();
|
||
|
|
temps_CLL.Arret_du_comptage();
|
||
|
|
temps_lois_comportement.Arret_du_comptage();
|
||
|
|
temps_metrique_K_SM.Arret_du_comptage();
|
||
|
|
temps_chargement.Arret_du_comptage();
|
||
|
|
temps_rech_contact.Arret_du_comptage();
|
||
|
|
};
|
||
|
|
|
||
|
|
// sortie sur fichier des temps cpu
|
||
|
|
void Algori::Sortie_temps_cpu(const LesCondLim& lesCondLim
|
||
|
|
, const Charge& charge,const LesContacts & contact)
|
||
|
|
{ // la petite méthode qui sert au transfert et qui doit-être appelé avant les sorties
|
||
|
|
Temps_CPU_HZpp_to_lesTempsCpu(lesCondLim,charge,contact);
|
||
|
|
// on récupère le fichier des temps cpu
|
||
|
|
entreePrinc->Ouverture_fichier_temps_cpu(); // ouverture au cas où
|
||
|
|
// récupération du fichier des temps cpu
|
||
|
|
ofstream & sort_cpu = entreePrinc->Sort_temps_cpu();
|
||
|
|
// on concatène la totalité pour ensuite sortir également des pourcentage
|
||
|
|
double total_cpu = tempsInitialisation.Temps_CPU_User();
|
||
|
|
total_cpu += tempsMiseAjourAlgo.Temps_CPU_User();
|
||
|
|
total_cpu += tempsCalEquilibre.Temps_CPU_User();
|
||
|
|
// total_cpu += tempsRaidSmEner.Temps_CPU_User();
|
||
|
|
// total_cpu += tempsSecondMembreEnerg.Temps_CPU_User();
|
||
|
|
// total_cpu += tempsResolSystemLineaire.Temps_CPU_User();
|
||
|
|
total_cpu += tempsSauvegarde.Temps_CPU_User();
|
||
|
|
total_cpu += tempsSortieFilCalcul.Temps_CPU_User();
|
||
|
|
// total_cpu += tempsRaidSmEnerContact.Temps_CPU_User();
|
||
|
|
// total_cpu += tempsSecondMembreEnergContact.Temps_CPU_User();
|
||
|
|
// total_cpu += temps_CL.Temps_CPU_User();
|
||
|
|
// total_cpu += temps_CLL.Temps_CPU_User();
|
||
|
|
// total_cpu += temps_lois_comportement.Temps_CPU_User();
|
||
|
|
// total_cpu += temps_metrique_K_SM.Temps_CPU_User(); // il ne faut pas ajouter la métrique
|
||
|
|
// total_cpu += temps_chargement.Temps_CPU_User();
|
||
|
|
// total_cpu += temps_rech_contact.Temps_CPU_User();
|
||
|
|
int nbdigit = 6; // pour le pourcentage
|
||
|
|
// int nbdigit_temps = 14; // pour les temps
|
||
|
|
|
||
|
|
|
||
|
|
// écriture des temps cpu de l'algo:
|
||
|
|
|
||
|
|
sort_cpu << "\n==========================================================================";
|
||
|
|
sort_cpu << "\n Herezh++ : bilan temps cpu pour l'algorithme: " << Nom_TypeCalcul(TypeDeCalcul());;
|
||
|
|
sort_cpu << "\n==========================================================================\n";
|
||
|
|
// puis affichage de la version
|
||
|
|
ParaGlob::Sortie_Version(sort_cpu);
|
||
|
|
#ifndef MISE_AU_POINT
|
||
|
|
sort_cpu << " (version la plus rapide )";
|
||
|
|
#endif
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
sort_cpu << " (version avec le plus de verifications pendant le calcul et les I/O ) ";
|
||
|
|
#endif
|
||
|
|
sort_cpu << "\n \n --------------- temps_locaux_cpu_en_milliseconde: ---------";
|
||
|
|
sort_cpu << fixed;
|
||
|
|
sort_cpu.precision(2);
|
||
|
|
// pour éviter de faire une division par 0
|
||
|
|
total_cpu = MaX(ConstMath::trespetit, total_cpu);
|
||
|
|
sort_cpu << "\n ---> tps_total_algo "
|
||
|
|
<< "("<< std::setw(nbdigit) << total_cpu/1000. << " ) ";
|
||
|
|
|
||
|
|
sort_cpu << "\n tps_InitAlgo "
|
||
|
|
<< "("<< std::setw(nbdigit) << (100*tempsInitialisation.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< tempsInitialisation.Temps_CPU_User_milli();
|
||
|
|
sort_cpu << "\n tps_MiseAJourAlgo "
|
||
|
|
<< "("<< std::setw(nbdigit) << (100*tempsMiseAjourAlgo.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< tempsMiseAjourAlgo.Temps_CPU_User_milli();
|
||
|
|
sort_cpu << "\n tps_CalEquilibre "
|
||
|
|
<< "("<< std::setw(nbdigit) << (100*tempsCalEquilibre.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< tempsCalEquilibre.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_MatSmLoc "
|
||
|
|
<< ".("<< std::setw(nbdigit) << (100*tempsRaidSmEner.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< tempsRaidSmEner.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_SmLoc "
|
||
|
|
<< ".("<< std::setw(nbdigit) << (100*tempsSecondMembreEnerg.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< tempsSecondMembreEnerg.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_lois_comp "
|
||
|
|
<< "..("<< std::setw(nbdigit) << (100*temps_lois_comportement.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< temps_lois_comportement.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_metrique_KSM "
|
||
|
|
<< "...("<< std::setw(nbdigit) << (100*temps_metrique_K_SM.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< temps_metrique_K_SM.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_chargement "
|
||
|
|
<< ".("<< std::setw(nbdigit) << (100*temps_chargement.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< temps_chargement.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_rech_contact "
|
||
|
|
<< ".("<< std::setw(nbdigit) << (100*temps_rech_contact.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< temps_rech_contact.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_contactMatSmLoc "
|
||
|
|
<< ".("<< std::setw(nbdigit) << (100*tempsRaidSmEnerContact.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< tempsRaidSmEnerContact.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_contactSmLoc "
|
||
|
|
<< ".("<< std::setw(nbdigit) << (100*tempsSecondMembreEnergContact.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< tempsSecondMembreEnergContact.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_CL "
|
||
|
|
<< ".("<< std::setw(nbdigit) << (100*temps_CL.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< temps_CL.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_CLL "
|
||
|
|
<< ".("<< std::setw(nbdigit) << (100*temps_CLL.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< temps_CLL.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
|
||
|
|
sort_cpu << "\n tps_ResSystLineaire "
|
||
|
|
<< "("<< std::setw(nbdigit) << (100*tempsResolSystemLineaire.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< tempsResolSystemLineaire.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_Sauvegarde "
|
||
|
|
<< "("<< std::setw(nbdigit) << (100*tempsSauvegarde.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< tempsSauvegarde.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n tps_SortieFilCalcul "
|
||
|
|
<< "("<< std::setw(nbdigit) << (100*tempsSortieFilCalcul.Temps_CPU_User()/total_cpu) << " % ) "
|
||
|
|
<< tempsSortieFilCalcul.Temps_CPU_User_milli()
|
||
|
|
;
|
||
|
|
sort_cpu << "\n";
|
||
|
|
};
|
||
|
|
|
||
|
|
// mise à jour qui sont gérées par la classe mère algo
|
||
|
|
// a priori que des choses génériques du type gestion des variables privées
|
||
|
|
void Algori::MiseAJourAlgoMere(ParaGlob * paraGlob,LesMaillages * lesMail,LesReferences* lesRef
|
||
|
|
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
|
||
|
|
,VariablesExporter* varExpor
|
||
|
|
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage
|
||
|
|
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
|
||
|
|
,Resultats* resultats)
|
||
|
|
{
|
||
|
|
// ---------- on initialise les conteneurs quelconques pour varExpor
|
||
|
|
varExpor->InitialisationConteneursQuelconques(*lesMail,listeVecGlob,*lesRef);
|
||
|
|
|
||
|
|
// -- modif concernant le stockage global pour volume déplacé: cas d'élément 2D dans un calcul 3D
|
||
|
|
// on met à jour le tableau de volume déplacé en fonction du nombre de maillage effectif
|
||
|
|
int nbMailMax = lesMail->NbMaillage();
|
||
|
|
// normalement ne fait rien si la taille n'est pas changé
|
||
|
|
if (vol_total2D_avec_plan_ref.Taille() != nbMailMax)
|
||
|
|
{vol_total2D_avec_plan_ref.Change_taille(nbMailMax,Coordonnee(ParaGlob::Dimension()));
|
||
|
|
// on remet à jour le stockage des grandeurs globales
|
||
|
|
if (pa.CalVolTotalEntreSurfaceEtPlansRef())
|
||
|
|
{ listeVarGlob["vol_total2D_avec_plan_yz"]=&(vol_total2D_avec_plan_ref(1)(1));
|
||
|
|
listeVarGlob["vol_total2D_avec_plan_xz"]=&(vol_total2D_avec_plan_ref(1)(2));
|
||
|
|
listeVarGlob["vol_total2D_avec_plan_xy"]=&(vol_total2D_avec_plan_ref(1)(3));
|
||
|
|
};
|
||
|
|
// s'il y a plus de 1 maillage, on définit de nouvelles variables globales
|
||
|
|
if (pa.CalVolTotalEntreSurfaceEtPlansRef())
|
||
|
|
for (int nbMail =2; nbMail<= nbMailMax; nbMail++)
|
||
|
|
{ // l'ordre des string est fait pour que le switch ensuite soit ok
|
||
|
|
string nom1("vol_total2D_avec_plan_xy_"+ChangeEntierSTring(nbMail));
|
||
|
|
listeVarGlob[nom1]=&(vol_total2D_avec_plan_ref(nbMail)(3));
|
||
|
|
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
|
||
|
|
(VOL_ELEM_AVEC_PLAN_REF,nom1,SCALAIRE_DOUBLE);
|
||
|
|
string nom2("vol_total2D_avec_plan_yz_"+ChangeEntierSTring(nbMail));
|
||
|
|
listeVarGlob[nom2]=&(vol_total2D_avec_plan_ref(nbMail)(1));
|
||
|
|
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
|
||
|
|
(VOL_ELEM_AVEC_PLAN_REF,nom2,SCALAIRE_DOUBLE);
|
||
|
|
string nom3("vol_total2D_avec_plan_xz_"+ChangeEntierSTring(nbMail));
|
||
|
|
listeVarGlob[nom3]=&(vol_total2D_avec_plan_ref(nbMail)(2));
|
||
|
|
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
|
||
|
|
(VOL_ELEM_AVEC_PLAN_REF,nom3,SCALAIRE_DOUBLE);
|
||
|
|
|
||
|
|
// --- on ajoute les grandeurs au niveau de paraglob
|
||
|
|
// si elles n'existent pas
|
||
|
|
double titi=0.; // une grandeur de travail
|
||
|
|
Grandeur_scalaire_double grand_courant(titi); // idem
|
||
|
|
TypeQuelconque typQ1(GENERIQUE_UNE_GRANDEUR_GLOBALE,NU_DDL,grand_courant); // idem
|
||
|
|
switch (ParaGlob::Dimension())
|
||
|
|
{ case 3: if (ParaGlob::param->GrandeurGlobal(nom1) == NULL)
|
||
|
|
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,nom1);
|
||
|
|
case 2: if (ParaGlob::param->GrandeurGlobal(nom2) == NULL)
|
||
|
|
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,nom2);
|
||
|
|
case 1: if (ParaGlob::param->GrandeurGlobal(nom3) == NULL)
|
||
|
|
ParaGlob::param->Ajout_grandeur_consultable(&typQ1,nom1);
|
||
|
|
default: break;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// on récupère éventuellement la modulation de précision
|
||
|
|
if (nom_modulation_precision.length())
|
||
|
|
{modulation_precision = lesFonctionsnD->Trouve(nom_modulation_precision);
|
||
|
|
if (modulation_precision->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
||
|
|
{// on vérifie qu'en retour on a un scalaire
|
||
|
|
modulation_precision->Valeur_pour_variables_globales(); // pour simplifier
|
||
|
|
if (modulation_precision->NbComposante() != 1)
|
||
|
|
{cout << "\n *** erreur parametre algorithme: la fonction nD " << nom_modulation_precision
|
||
|
|
<< " de modulation de la precision d'equilibre globale "
|
||
|
|
<< " ne retourne pas un scalaire unique !! a priori ce n'est pas correct ";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{cout << "\n *** erreur parametre algorithme: la fonction nD " << nom_modulation_precision
|
||
|
|
<< " de modulation de la precision d'equilibre globale "
|
||
|
|
<< " utilise des variables autres que globales, ce n'est pas possible ! ";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// on récupère éventuellement la fonction nD définissant la norme
|
||
|
|
if (pa.Norme().nom1 == "fonction_nD:")
|
||
|
|
{fct_norme = lesFonctionsnD->Trouve(pa.Norme().nom2);
|
||
|
|
if (fct_norme->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
||
|
|
{// on vérifie qu'en retour on a un scalaire
|
||
|
|
fct_norme->Valeur_pour_variables_globales(); // pour simplifier
|
||
|
|
if (fct_norme->NbComposante() != 1)
|
||
|
|
{cout << "\n *** erreur parametre algorithme: la fonction nD " << pa.Norme().nom2
|
||
|
|
<< " de definition de la norme de convergence d'equilibre globale "
|
||
|
|
<< " ne retourne pas un scalaire unique !! a priori ce n'est pas correct ";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{cout << "\n *** erreur parametre algorithme: la fonction nD " << pa.Norme().nom2
|
||
|
|
<< " de definition de la norme de convergence d'equilibre globale "
|
||
|
|
<< " utilise des variables autres que globales, ce n'est pas possible ! ";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// on récupère éventuellement la fonction correspondant à nom_fct_nD_inter_nb_entre_relax
|
||
|
|
if (nom_fct_nD_inter_nb_entre_relax.length())
|
||
|
|
{fct_nD_inter_nb_entre_relax = lesFonctionsnD->Trouve(nom_fct_nD_inter_nb_entre_relax);
|
||
|
|
if (fct_nD_inter_nb_entre_relax->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
||
|
|
{// on vérifie qu'en retour on a un scalaire
|
||
|
|
fct_nD_inter_nb_entre_relax->Valeur_pour_variables_globales(); // pour simplifier
|
||
|
|
if (fct_nD_inter_nb_entre_relax->NbComposante() != 1)
|
||
|
|
{cout << "\n *** erreur parametre algorithme: la fonction nD " << nom_fct_nD_inter_nb_entre_relax
|
||
|
|
<< " qui permet de cacluler la valeur du parametre inter_nb_entre_relax "
|
||
|
|
<< " ne retourne pas un scalaire unique !! a priori ce n'est pas correct ";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{cout << "\n *** erreur parametre algorithme: la fonction nD " << nom_fct_nD_inter_nb_entre_relax
|
||
|
|
<< " qui permet de cacluler la valeur du parametre inter_nb_entre_relax "
|
||
|
|
<< " utilise des variables autres que globales, ce n'est pas possible ! ";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// on met à jour les repères d'anisotropie éventuelle
|
||
|
|
lesMail->Mise_a_jour_repere_anisotropie(diversStockage,lesFonctionsnD);
|
||
|
|
|
||
|
|
// on introduit au niveau des noeuds, si cela n'est pas déjà fait
|
||
|
|
// les conteneurs pour les forces internes et externes à t
|
||
|
|
{// 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
|
||
|
|
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
|
||
|
|
// def d'un type quelconque représentatif pour un vecteur force à chaque noeud
|
||
|
|
TypeQuelconque typQ_gene_int(FORCE_GENE_INT_t,X1,gt);
|
||
|
|
lesMail->AjoutConteneurAuNoeud(typQ_gene_int);
|
||
|
|
TypeQuelconque typQ_gene_ext(FORCE_GENE_EXT_t,X1,gt);
|
||
|
|
lesMail->AjoutConteneurAuNoeud(typQ_gene_ext);
|
||
|
|
};
|
||
|
|
|
||
|
|
// on initialise certaines énergies qui sont stockées au niveau de l'algo
|
||
|
|
// mais qui sont en fait indépendantes de l'algo, donc il faut que ces énergies soient à jour
|
||
|
|
// elles sont donc initialisées à partir des grandeurs globales qui elles mêmes ont été mise à jour
|
||
|
|
// l'objectif est d'éviter une initialisation par défaut à 0 lorsque l'algo fait suite à un autre algo
|
||
|
|
// du coup, avant tout calcul du nouvel algo, on utilise les grandeurs déjà calculées par le précédent algo
|
||
|
|
//
|
||
|
|
// --- cas des énergies internes venants des lois de comportement :
|
||
|
|
// ENERGIE_ELASTIQUE,ENERGIE_PLASTIQUE,ENERGIE_VISQUEUSE,
|
||
|
|
{{void* pt_void = ParaGlob::param->Mise_a_jour_grandeur_consultable(ENERGIE_ELASTIQUE);
|
||
|
|
TypeQuelconque* pt_quelc = (TypeQuelconque*) pt_void;
|
||
|
|
Grandeur_scalaire_double& gr
|
||
|
|
= *((Grandeur_scalaire_double*) pt_quelc->Grandeur_pointee()); // pour simplifier
|
||
|
|
energTotal.ChangeEnergieElastique(*(gr.ConteneurDouble())) ;
|
||
|
|
};
|
||
|
|
{void* pt_void = ParaGlob::param->Mise_a_jour_grandeur_consultable(ENERGIE_PLASTIQUE);
|
||
|
|
TypeQuelconque* pt_quelc = (TypeQuelconque*) pt_void;
|
||
|
|
Grandeur_scalaire_double& gr
|
||
|
|
= *((Grandeur_scalaire_double*) pt_quelc->Grandeur_pointee()); // pour simplifier
|
||
|
|
energTotal.ChangeDissipationPlastique( *(gr.ConteneurDouble()) );
|
||
|
|
};
|
||
|
|
{void* pt_void = ParaGlob::param->Mise_a_jour_grandeur_consultable(ENERGIE_VISQUEUSE);
|
||
|
|
TypeQuelconque* pt_quelc = (TypeQuelconque*) pt_void;
|
||
|
|
Grandeur_scalaire_double& gr
|
||
|
|
= *((Grandeur_scalaire_double*) pt_quelc->Grandeur_pointee()); // pour simplifier
|
||
|
|
energTotal.ChangeDissipationVisqueuse(*(gr.ConteneurDouble()));
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// --- cas des énergies de contact :
|
||
|
|
// ENERGIE_PENALISATION,ENERGIE_FROT_ELAST,ENERGIE_FROT_PLAST,ENERGIE_FROT_VISQ
|
||
|
|
{{void* pt_void = ParaGlob::param->Mise_a_jour_grandeur_consultable(ENERGIE_PENALISATION);
|
||
|
|
TypeQuelconque* pt_quelc = (TypeQuelconque*) pt_void;
|
||
|
|
Grandeur_scalaire_double& gr
|
||
|
|
= *((Grandeur_scalaire_double*) pt_quelc->Grandeur_pointee()); // pour simplifier
|
||
|
|
////------- debug
|
||
|
|
//cout << "\n debug*** Algori::MiseAJourAlgoMere "
|
||
|
|
// << "\n pt_void= " << pt_void << " gr.ContDouble()= " << gr.ContDouble()
|
||
|
|
// << " (*(gr.ConteneurDouble())) = " << (*(gr.ConteneurDouble()))
|
||
|
|
// << flush;
|
||
|
|
//
|
||
|
|
//// --- fin debug
|
||
|
|
energPenalisation = *(gr.ConteneurDouble());
|
||
|
|
};
|
||
|
|
{void* pt_void = ParaGlob::param->Mise_a_jour_grandeur_consultable(ENERGIE_FROT_ELAST);
|
||
|
|
TypeQuelconque* pt_quelc = (TypeQuelconque*) pt_void;
|
||
|
|
Grandeur_scalaire_double& gr
|
||
|
|
= *((Grandeur_scalaire_double*) pt_quelc->Grandeur_pointee()); // pour simplifier
|
||
|
|
energFrottement.ChangeEnergieElastique(*(gr.ConteneurDouble()));
|
||
|
|
};
|
||
|
|
{void* pt_void = ParaGlob::param->Mise_a_jour_grandeur_consultable(ENERGIE_FROT_PLAST);
|
||
|
|
TypeQuelconque* pt_quelc = (TypeQuelconque*) pt_void;
|
||
|
|
Grandeur_scalaire_double& gr
|
||
|
|
= *((Grandeur_scalaire_double*) pt_quelc->Grandeur_pointee()); // pour simplifier
|
||
|
|
energFrottement.ChangeDissipationPlastique( *(gr.ConteneurDouble()) );
|
||
|
|
};
|
||
|
|
{void* pt_void = ParaGlob::param->Mise_a_jour_grandeur_consultable(ENERGIE_FROT_VISQ);
|
||
|
|
TypeQuelconque* pt_quelc = (TypeQuelconque*) pt_void;
|
||
|
|
Grandeur_scalaire_double& gr
|
||
|
|
= *((Grandeur_scalaire_double*) pt_quelc->Grandeur_pointee()); // pour simplifier
|
||
|
|
energFrottement.ChangeDissipationVisqueuse(*(gr.ConteneurDouble()));
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// gestion éventuelle d'une renumérotation, qui prend en compte les éléments de contact
|
||
|
|
// premier_calcul: indique s'il s'agit d'un premier calcul on non
|
||
|
|
// nouvelle_situation_contact : indique s'il y a du nouveau sur le contact
|
||
|
|
// 1) si niveau_substitution =0 : -> mise à jour de toutes les matrices
|
||
|
|
// 2) si niveau_substitution = i : -> uniquement mise à jour de la matrices i
|
||
|
|
// par contre la dimension de tab_matglob est toujours mis à jour si c'est nécessaire
|
||
|
|
// ramène true si la matrice a été changée
|
||
|
|
bool Algori::Gestion_stockage_et_renumerotation_avec_contact(bool premier_calcul
|
||
|
|
,LesMaillages * lesMail, bool & nouvelle_situation_contact
|
||
|
|
,LesCondLim* lesCondLim,LesReferences* lesRef
|
||
|
|
,Tableau <Mat_abstraite* >& tab_mato,const Nb_assemb& nb_casAssemb
|
||
|
|
,LesContacts* lescontacts,int niveau_substitution)
|
||
|
|
{ // --- 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())
|
||
|
|
|| (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
|
||
|
|
{// récup des connexions entre noeuds dues aux CLL externes
|
||
|
|
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 (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
|
||
|
|
{//lesMail->MiseAJourPointeurAssemblage(nb_casAssemb);// mise a jour des pointeurs d'assemblage
|
||
|
|
// il faut regarder un peu partout: élément, frontière etc
|
||
|
|
// on met à jour le tableau indice pour LesContacts
|
||
|
|
lescontacts->Mise_a_jour_indice(lesMail->Indice());
|
||
|
|
// enfin il faut renuméroter la matrice
|
||
|
|
Mise_a_jour_Choix_matriciel_contact
|
||
|
|
(tab_mato,nb_casAssemb,lescontacts,niveau_substitution,&nevez_largeurs);
|
||
|
|
retour = true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ Mise_a_jour_Choix_matriciel_contact
|
||
|
|
(tab_mato,nb_casAssemb,lescontacts,niveau_substitution,NULL);
|
||
|
|
retour = true;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ Mise_a_jour_Choix_matriciel_contact
|
||
|
|
(tab_mato,nb_casAssemb,lescontacts,niveau_substitution,NULL);
|
||
|
|
retour = true;
|
||
|
|
};
|
||
|
|
} //-- fin du cas si premier calcul
|
||
|
|
else
|
||
|
|
{if (nouvelle_situation_contact)
|
||
|
|
{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
|
||
|
|
{// 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());
|
||
|
|
int tailtabCLL = tabCLL.Taille();tabCLL.Change_taille(tailtabCLL+1);
|
||
|
|
tabCLL(tailtabCLL+1) = tabCondLine; // ajout de la partie 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
|
||
|
|
{
|
||
|
|
// on met à jour le tableau indice pour LesContacts
|
||
|
|
lescontacts->Mise_a_jour_indice(lesMail->Indice());
|
||
|
|
//lesMail->MiseAJourPointeurAssemblage(nb_casAssemb);// mise a jour des pointeurs d'assemblage
|
||
|
|
Mise_a_jour_Choix_matriciel_contact
|
||
|
|
(tab_mato,nb_casAssemb,lescontacts,niveau_substitution,&nevez_largeurs);
|
||
|
|
retour = true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ Mise_a_jour_Choix_matriciel_contact
|
||
|
|
(tab_mato,nb_casAssemb,lescontacts,niveau_substitution,NULL);
|
||
|
|
retour = true;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ Mise_a_jour_Choix_matriciel_contact
|
||
|
|
(tab_mato,nb_casAssemb,lescontacts,niveau_substitution,NULL);
|
||
|
|
retour = true;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{retour = false; };
|
||
|
|
}; //-- fin du cas si ce n'est pas un premier calcul
|
||
|
|
// retour
|
||
|
|
return retour;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// --- même chose mais sans le contact, par contre prise en compte d'un changement éventuelle
|
||
|
|
// imposé par exemple par les CLL
|
||
|
|
// gestion éventuelle d'une renumérotation des pointeurs d'assemblage , qui prend en compte les CLL
|
||
|
|
// premier_calcul : indique s'il s'agit d'un premier calcul on non
|
||
|
|
// nouvelle_situation_CLL : indique s'il y a du nouveau sur les CLL
|
||
|
|
// -> la renumérotation des pointeurs s'effectue que si:
|
||
|
|
// a) ParaAlgoControleActifs().Optimisation_pointeur_assemblage() est ok
|
||
|
|
// b) soit c'est un premier calcul, soit il y a du nouveau sur les CLL
|
||
|
|
|
||
|
|
// 1) si niveau_substitution =0 : -> mise à jour de toutes les matrices
|
||
|
|
// 2) si niveau_substitution = i : -> uniquement mise à jour de la matrices i
|
||
|
|
// par contre la dimension de tab_matglob est toujours mis à jour si c'est nécessaire
|
||
|
|
// ramène true si la matrice a été changée
|
||
|
|
// NB: lescontacts est quand même passé en paramètre, car on doit le renseigner au niveau d'un
|
||
|
|
// tableau d'indice (num de noeuds) lorsque les num ont changés, ceci pour être opérationnel
|
||
|
|
// par la suite si le contact devient actif
|
||
|
|
bool Algori::Gestion_stockage_et_renumerotation_sans_contact(LesContacts* lescontacts,bool premier_calcul
|
||
|
|
,LesMaillages * lesMail, bool & nouvelle_situation_CLL
|
||
|
|
,LesCondLim* lesCondLim,LesReferences* lesRef
|
||
|
|
,Tableau <Mat_abstraite* >& tab_mato,const Nb_assemb& nb_casAssemb
|
||
|
|
,int niveau_substitution)
|
||
|
|
{ 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
|
||
|
|
if (ParaGlob::param->ParaAlgoControleActifs().Optimisation_pointeur_assemblage())
|
||
|
|
{ // récup des connexions entre noeuds dues aux CLL externes
|
||
|
|
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 (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);
|
||
|
|
if (calcul_ok) // cas où il y a eu effectivement un changement de numérotation
|
||
|
|
{//lesMail->MiseAJourPointeurAssemblage(nb_casAssemb);// mise a jour des pointeurs d'assemblage
|
||
|
|
// il faut regarder un peu partout: élément, frontière etc
|
||
|
|
// on met à jour le tableau indice pour LesContacts
|
||
|
|
lescontacts->Mise_a_jour_indice(lesMail->Indice());
|
||
|
|
// enfin il faut renuméroter la matrice
|
||
|
|
// ici on ne se sert pas du contact
|
||
|
|
Mise_a_jour_Choix_matriciel_contact
|
||
|
|
(tab_mato,nb_casAssemb,NULL,niveau_substitution,&nevez_largeurs);
|
||
|
|
retour = true;
|
||
|
|
};
|
||
|
|
// sinon on ne fait rien
|
||
|
|
};
|
||
|
|
} //-- fin du cas si premier calcul
|
||
|
|
else
|
||
|
|
{if (nouvelle_situation_CLL)
|
||
|
|
{if (ParaGlob::param->ParaAlgoControleActifs().Optimisation_pointeur_assemblage())
|
||
|
|
{ // 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 (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);
|
||
|
|
if (calcul_ok) // cas où il y a eu effectivement un changement de numérotation
|
||
|
|
{
|
||
|
|
// on met à jour le tableau indice pour LesContacts
|
||
|
|
lescontacts->Mise_a_jour_indice(lesMail->Indice());
|
||
|
|
//lesMail->MiseAJourPointeurAssemblage(nb_casAssemb);// mise a jour des pointeurs d'assemblage
|
||
|
|
Mise_a_jour_Choix_matriciel_contact
|
||
|
|
(tab_mato,nb_casAssemb,NULL,niveau_substitution,&nevez_largeurs);
|
||
|
|
retour = true;
|
||
|
|
};
|
||
|
|
// sinon on ne fait rien
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; //-- fin du cas si ce n'est pas un premier calcul
|
||
|
|
// retour
|
||
|
|
return retour;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// mise à jour de delta_X, var_delta_X et passage en global des maxi
|
||
|
|
void Algori::Cal_Transfert_delta_et_var_X(double& max_delta_X, double& max_var_delta_X)
|
||
|
|
{ var_delta_X = -delta_X; // sauvegarde de la dernière valeur
|
||
|
|
// calcul du nouveau delta_X
|
||
|
|
delta_X.Zero(); delta_X += X_tdt; delta_X -= X_t;// X_tdt - X_t
|
||
|
|
// calcul de la variation de delta_X
|
||
|
|
var_delta_X += delta_X;
|
||
|
|
// calcul des maxis en valeurs absolue
|
||
|
|
max_delta_X = delta_X.Max_val_abs();
|
||
|
|
max_var_delta_X = var_delta_X.Max_val_abs();
|
||
|
|
// passage au niveau global
|
||
|
|
ParaGlob::param->Mise_a_jour_grandeur_consultable_Scalaire_double(MAXdeltaX,max_delta_X);
|
||
|
|
ParaGlob::param->Mise_a_jour_grandeur_consultable_Scalaire_double(MAXvarDeltaX,max_var_delta_X);
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// ---------- static pour la création d'un algorithme particulier ---------
|
||
|
|
// ramène un pointeur sur l'algorithme spécifique correspondant aux paramètres
|
||
|
|
// IMPORTANT : il y a création de l'algorithme correspondant (utilisation d'un new)
|
||
|
|
Algori* Algori::New_Agori(EnumTypeCalcul id_TypeCalcul,const bool avec_typeDeCalcul
|
||
|
|
,const list <EnumSousTypeCalcul>& soustype
|
||
|
|
,const list <bool>& avec_soustypeDeCalcul
|
||
|
|
,UtilLecture& entreePrinc)
|
||
|
|
|
||
|
|
{ // définition du pointeur de retour
|
||
|
|
Algori* algo_specifique;
|
||
|
|
|
||
|
|
switch (id_TypeCalcul)
|
||
|
|
{case NON_DYNA :
|
||
|
|
{ algo_specifique = new AlgoriNonDyna
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case NON_DYNA_CONT :
|
||
|
|
{ algo_specifique = new ImpliNonDynaCont
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case FLAMB_LINEAIRE :
|
||
|
|
{ algo_specifique = new AlgoriFlambLineaire
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case INFORMATIONS :
|
||
|
|
{ algo_specifique = new AlgoInformations
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case UTILITAIRES :
|
||
|
|
{ algo_specifique = new AlgoUtils
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case DYNA_EXP :
|
||
|
|
{ algo_specifique = new AlgoriDynaExpli
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case DYNA_EXP_TCHAMWA :
|
||
|
|
{ algo_specifique = new AlgoriTchamwa
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case DYNA_EXP_CHUNG_LEE :
|
||
|
|
{ algo_specifique = new Algori_chung_lee
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case DYNA_EXP_ZHAI :
|
||
|
|
{ algo_specifique = new AlgoriDynaExpli_zhai
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case DYNA_IMP :
|
||
|
|
{ algo_specifique = new AlgoriNewmark
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case UMAT_ABAQUS :
|
||
|
|
{ algo_specifique = new AlgoUmatAbaqus
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case DYNA_RUNGE_KUTTA :
|
||
|
|
{ algo_specifique = new AlgoriRungeKutta
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case DYNA_EXP_BONELLI :
|
||
|
|
{ algo_specifique = new AlgoBonelli
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case RELAX_DYNA :
|
||
|
|
{ algo_specifique = new AlgoriRelaxDyna
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case COMBINER :
|
||
|
|
{ algo_specifique = new AlgoriCombine
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default :
|
||
|
|
{ cout << "\n type d\'algorithme non encore implante, desole ! \n";
|
||
|
|
cout << " agorithme demande = " << Nom_TypeCalcul(id_TypeCalcul);
|
||
|
|
cout << endl;
|
||
|
|
entreePrinc.MessageBuffer("** lecture du type d\'algorithme **");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
return algo_specifique;
|
||
|
|
};
|
||
|
|
|
||
|
|
// 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)
|
||
|
|
Tableau <Algori *> Algori::New_tous_les_Algo
|
||
|
|
(const bool avec_typeDeCalcul
|
||
|
|
,const list <EnumSousTypeCalcul>& soustype
|
||
|
|
,const list <bool>& avec_soustypeDeCalcul
|
||
|
|
,UtilLecture& entreePrinc)
|
||
|
|
{ // définition du tableau de pointeurs de retour
|
||
|
|
Tableau <Algori* > tab_algo_specifique(15);
|
||
|
|
|
||
|
|
tab_algo_specifique(1) = new AlgoriNonDyna
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(2) = new ImpliNonDynaCont
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(3) = new AlgoriFlambLineaire
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(4) = new AlgoInformations
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(5) = new AlgoUtils
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(6) = new AlgoriDynaExpli
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(7) = new AlgoriTchamwa
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(8) = new Algori_chung_lee
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(9) = new AlgoriDynaExpli_zhai
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(10) = new AlgoriNewmark
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(11) = new AlgoUmatAbaqus
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(12) = new AlgoriRungeKutta
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(13) = new AlgoBonelli
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(14) = new AlgoriRelaxDyna
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
tab_algo_specifique(15) = new AlgoriCombine
|
||
|
|
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||
|
|
|
||
|
|
|
||
|
|
return tab_algo_specifique;
|
||
|
|
};
|