804 lines
41 KiB
C++
Executable file
804 lines
41 KiB
C++
Executable file
// 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 "AlgoriNonDyna.h"
|
|
#include "TypeQuelconqueParticulier.h"
|
|
|
|
// CONSTRUCTEURS :
|
|
AlgoriNonDyna::AlgoriNonDyna() : // par defaut
|
|
Algori()
|
|
{// a priori ce constructeur n'est pas utilisé
|
|
cout << "\n $$$$$$$$$ a priori ce constructeur n'est pas utilisable $$$$$$$ "
|
|
<< "\n revoir: AlgoriNonDyna::AlgoriNonDyna() " << endl;
|
|
Sortie(1);
|
|
};
|
|
|
|
// constructeur en fonction du type de calcul et du sous type
|
|
// il y a ici lecture des parametres attaches au type
|
|
AlgoriNonDyna::AlgoriNonDyna (const bool avec_typeDeCal
|
|
,const list <EnumSousTypeCalcul>& soustype
|
|
,const list <bool>& avec_soustypeDeCal
|
|
,UtilLecture& entreePrinc) :
|
|
Algori(NON_DYNA,avec_typeDeCal,soustype,avec_soustypeDeCal,entreePrinc)
|
|
// --------------------------------------------------------------------------------------
|
|
// -- variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
|
|
// --------------------------------------------------------------------------------------
|
|
,Ass_(NULL),cas_combi_ddl(0),icas(0),compteur(0),prepa_avec_remont(false)
|
|
,brestart(false),type_incre(OrdreVisu::INCRE_0),vglobin(),vglobex(),vglobaal(),vcontact()
|
|
,delta_prec_X(),forces_vis_num(0)
|
|
,matglob(NULL),assembMat(NULL),sauve_deltadept(NULL),sauve_dept_a_tdt(NULL)
|
|
,tab_mato(1),tab_matsauve(1),tab_tab_matmoysauve(1)
|
|
,Vres(NULL),v_travail(NULL),matsauve(NULL),tab_matmoysauve(NULL)
|
|
// ------------------------------------------------------------------------------------------
|
|
// -- fin variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
|
|
// ------------------------------------------------------------------------------------------
|
|
// --- accélération de convergence ---------
|
|
,Vi(),Yi(),coef_ai(),mat_ai(),Sm_ai(),X_extrapol(),S_0(),sauve_sol()
|
|
,nb_vec_cycle(8),cas_acceleration_convergence(1),acceleration_convergence(false)
|
|
// ------------------------------------------------------------------------------------------
|
|
// -- newton modifié --
|
|
// ------------------------------------------------------------------------------------------
|
|
,deb_newton_modifie(-1) // par défaut pas de Newton modifié
|
|
,fin_newton_modifie(-1) // par défaut pas de fin
|
|
,nb_iter_NM(3)
|
|
// ------------------------------------------------------------------------------------------
|
|
// -- moyenne de raideur --
|
|
// ------------------------------------------------------------------------------------------
|
|
,deb_raideur_moyenne(-1) // par défaut pas de moyenne
|
|
,fin_raideur_moyenne(-1) // par défaut pas de fin
|
|
,nb_raideur_moyenne(3) // par défaut on utilise 3 matrice successives
|
|
,cL_a_chaque_iteration(0)
|
|
|
|
{ // lecture des paramètres attachés au type de calcul (ici aucun)
|
|
switch (entreePrinc.Lec_ent_info())
|
|
{ case 0 :
|
|
{// appel de la méthode de lecture de paramètre
|
|
lecture_Parametres(entreePrinc); break;}
|
|
case -11 : // cas de la création d'un fichier de commande
|
|
{ Info_commande_parametres(entreePrinc); break;}
|
|
case -12 : // cas de la création d'un schéma XML, on ne fait rien à ce niveau
|
|
{ break;}
|
|
default:
|
|
Sortie(1);
|
|
};
|
|
// dimensionnement conditionnel
|
|
if (acceleration_convergence)
|
|
{ Vi.Change_taille(nb_vec_cycle+2);
|
|
Yi.Change_taille(nb_vec_cycle+2);
|
|
coef_ai.Change_taille(nb_vec_cycle+1);
|
|
mat_ai.Change_taille(nb_vec_cycle+1,nb_vec_cycle+1);
|
|
Sm_ai.Change_taille(nb_vec_cycle+1);
|
|
};
|
|
// associations pour les tableaux de matrices
|
|
tab_mato(1)=matglob;tab_matsauve(1)=matsauve;
|
|
tab_tab_matmoysauve(1)= tab_matmoysauve;
|
|
};
|
|
|
|
// constructeur de copie
|
|
AlgoriNonDyna::AlgoriNonDyna (const AlgoriNonDyna& algo):
|
|
Algori(algo)
|
|
// --------------------------------------------------------------------------------------
|
|
// -- variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
|
|
// --------------------------------------------------------------------------------------
|
|
,Ass_(NULL),cas_combi_ddl(0),icas(0)
|
|
,compteur(0),prepa_avec_remont(false)
|
|
,brestart(false),type_incre(OrdreVisu::INCRE_0),vglobin(),vglobex()
|
|
,vglobaal(),delta_prec_X(),forces_vis_num(0),vcontact()
|
|
,matglob(NULL),assembMat(NULL),sauve_deltadept(NULL),sauve_dept_a_tdt(NULL)
|
|
,tab_mato(1),tab_matsauve(1),tab_tab_matmoysauve(1)
|
|
,Vres(NULL),v_travail(NULL),matsauve(NULL),tab_matmoysauve(NULL)
|
|
// ------------------------------------------------------------------------------------------
|
|
// -- fin variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
|
|
// ------------------------------------------------------------------------------------------
|
|
// --- accélération de convergence ---------
|
|
,Vi(algo.Vi),Yi(algo.Yi),coef_ai(algo.coef_ai)
|
|
,mat_ai(algo.mat_ai),Sm_ai(algo.Sm_ai),X_extrapol(algo.X_extrapol),S_0(algo.S_0),sauve_sol()
|
|
,nb_vec_cycle(algo.nb_vec_cycle),cas_acceleration_convergence(algo.cas_acceleration_convergence)
|
|
,acceleration_convergence(algo.acceleration_convergence)
|
|
// ------------------------------------------------------------------------------------------
|
|
// -- newton modifié --
|
|
// ------------------------------------------------------------------------------------------
|
|
,deb_newton_modifie(algo.deb_newton_modifie)
|
|
,fin_newton_modifie(algo.fin_newton_modifie)
|
|
,nb_iter_NM(algo.nb_iter_NM)
|
|
// ------------------------------------------------------------------------------------------
|
|
// -- moyenne de raideur --
|
|
// ------------------------------------------------------------------------------------------
|
|
,deb_raideur_moyenne(algo.deb_raideur_moyenne) // par défaut pas de moyenne
|
|
,fin_raideur_moyenne(algo.fin_raideur_moyenne) // par défaut pas de fin
|
|
,nb_raideur_moyenne(algo.nb_raideur_moyenne) // par défaut on utilise 3 matrice successives
|
|
,cL_a_chaque_iteration(algo.cL_a_chaque_iteration)
|
|
{
|
|
// dimensionnement conditionnel
|
|
if (acceleration_convergence)
|
|
{ Vi.Change_taille(nb_vec_cycle+2);
|
|
Yi.Change_taille(nb_vec_cycle+2);
|
|
coef_ai.Change_taille(nb_vec_cycle+1);
|
|
mat_ai.Change_taille(nb_vec_cycle+1,nb_vec_cycle+1);
|
|
Sm_ai.Change_taille(nb_vec_cycle+1);
|
|
};
|
|
// associations pour les tableaux de matrices
|
|
tab_mato(1)=matglob;tab_matsauve(1)=matsauve;
|
|
tab_tab_matmoysauve(1)= tab_matmoysauve;
|
|
};
|
|
|
|
// destructeur
|
|
AlgoriNonDyna::~AlgoriNonDyna ()
|
|
{
|
|
// --------------------------------------------------------------------------------------
|
|
// -- variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
|
|
// --------------------------------------------------------------------------------------
|
|
if (Ass_ != NULL ) delete Ass_;
|
|
{int taille = tab_mato.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
if (tab_mato(i)!= NULL)
|
|
delete tab_mato(i);
|
|
}
|
|
// if (matglob != NULL) delete matglob;
|
|
{int taille = tab_matsauve.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
if (tab_matsauve(i)!= NULL)
|
|
delete tab_matsauve(i);
|
|
}
|
|
// if (matsauve != NULL) delete matsauve;
|
|
{int taille = tab_tab_matmoysauve.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
if (tab_tab_matmoysauve(i)!= NULL)
|
|
{Tableau <Mat_abstraite*> * tab_matmoysauve_i = tab_tab_matmoysauve(i); // par simplicité
|
|
int tail = tab_matmoysauve_i->Taille();
|
|
for (int j=1; j<= tail;j++)
|
|
if ((*tab_matmoysauve_i)(j) != NULL)
|
|
delete (*tab_matmoysauve_i)(j);
|
|
};
|
|
};
|
|
// if (tab_matmoysauve.Taille() != 0)
|
|
// { int tail = tab_matmoysauve.Taille();
|
|
// for (int i=1; i<= tail;i++)
|
|
// if (tab_matmoysauve(i) != NULL) {delete tab_matmoysauve(i);}
|
|
// };
|
|
if (sauve_deltadept != NULL) delete sauve_deltadept;
|
|
if (sauve_dept_a_tdt != NULL) delete sauve_dept_a_tdt;
|
|
if (Vres != NULL) delete Vres;
|
|
if (v_travail != NULL) delete v_travail;
|
|
// ------------------------------------------------------------------------------------------
|
|
// -- fin variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
|
|
// ------------------------------------------------------------------------------------------
|
|
// suppression des variables consultables
|
|
// ParaGlob::param->Suppression_place_grandeur_consultable(description_compteur);
|
|
// ParaGlob::param->Suppression_place_grandeur_consultable(description_icharge);
|
|
|
|
};
|
|
|
|
// execution de l'algorithme dans le cas non dynamique, implicit, sans contact
|
|
void AlgoriNonDyna::Execution(ParaGlob * paraGlob,LesMaillages * lesMail
|
|
,LesReferences* lesRef,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
|
|
,VariablesExporter* varExpor,LesLoisDeComp* lesLoisDeComp, DiversStockage* divStock
|
|
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts,Resultats* resultats)
|
|
{ Tableau < Fonction_nD* > * tb_combiner = NULL; // ici ne sert pas
|
|
// on définit le type de calcul a effectuer :
|
|
if ( soustypeDeCalcul->size()==0 )
|
|
// cas où il n'y a pas de sous type, on fait le calcul d'équilibre classique
|
|
// signifie que le type principal est forcément valide
|
|
{ // initialisation du calcul : deux cas, soit avec une lecture initiale du .info, soit une lecture secondaire
|
|
if (paraGlob->EtatDeLaLecturePointInfo() == 0)
|
|
{InitAlgorithme(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
|
|
,divStock,charge,lesCondLim,lesContacts,resultats );}
|
|
else {MiseAJourAlgo(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
|
|
,divStock,charge,lesCondLim,lesContacts,resultats );
|
|
};
|
|
// on ne continue que si on n'a pas dépasser le nombre d'incréments maxi ou le temps maxi
|
|
// bref que l'on n'a pas fini, sinon on passe
|
|
if (! (charge->Fin(icharge,true) ) )
|
|
{ // calcul de l'équilibre
|
|
CalEquilibre(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
|
|
,divStock,charge,lesCondLim,lesContacts,resultats
|
|
,tb_combiner);
|
|
// fin du calcul, pour l'instant on ne considère pas les autres sous-types
|
|
FinCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
|
|
,divStock,charge,lesCondLim,lesContacts,resultats );
|
|
};
|
|
}
|
|
else
|
|
{if ( avec_typeDeCalcul )
|
|
// cas où le type principal est valide et qu'il y a des sous_types
|
|
{ // on regarde si le sous-type "commandeInteractive" existe, si oui on le met en place
|
|
// détermine si le sous type de calcul existe et s'il est actif
|
|
if (paraGlob->SousTypeCalcul(commandeInteractive))
|
|
{// -- cas avec commandes interactives
|
|
// initialisation du calcul
|
|
InitAlgorithme(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
|
|
,divStock,charge,lesCondLim,lesContacts,resultats );
|
|
// calcul de l'équilibre tant qu'il y a des commandes
|
|
while (ActionInteractiveAlgo())
|
|
{// on ne continue que si on n'a pas dépasser le nombre d'incréments maxi ou le temps maxi
|
|
if (! (charge->Fin(icharge,true) ) )
|
|
CalEquilibre(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
|
|
,divStock,charge,lesCondLim,lesContacts,resultats
|
|
,tb_combiner);
|
|
};
|
|
// fin du calcul, pour l'instant on ne considère pas les autres sous-types
|
|
FinCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
|
|
,divStock,charge,lesCondLim,lesContacts,resultats );
|
|
}
|
|
else // cas sans commandes interactives
|
|
{// on fait le calcul d'équilibre
|
|
// initialisation du calcul : deux cas, soit avec une lecture initiale du .info, soit une lecture secondaire
|
|
if (paraGlob->EtatDeLaLecturePointInfo() == 0)
|
|
{InitAlgorithme(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
|
|
,divStock,charge,lesCondLim,lesContacts,resultats );;}
|
|
else {// on est en lecture secondaire
|
|
|
|
MiseAJourAlgo(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
|
|
,divStock,charge,lesCondLim,lesContacts,resultats );;
|
|
};
|
|
|
|
// on ne continue que si on n'a pas dépasser le nombre d'incréments maxi ou le temps maxi
|
|
if (! (charge->Fin(icharge,true) ) )
|
|
{ // calcul de l'équilibre
|
|
CalEquilibre(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
|
|
,divStock,charge,lesCondLim,lesContacts,resultats
|
|
,tb_combiner);
|
|
// fin du calcul, pour l'instant on ne considère pas les autres sous-types
|
|
FinCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
|
|
,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
|
|
// dépendant des sous_types. Pour l'instant ici uniquement la remontée
|
|
list <EnumSousTypeCalcul>::const_iterator ili,ili_fin = soustypeDeCalcul->end();
|
|
list <bool>::const_iterator ila;
|
|
for (ili = soustypeDeCalcul->begin(),ila = avec_soustypeDeCalcul->begin();
|
|
ili!=ili_fin;ili++,ila++)
|
|
if (*ila) // cas où le sous type est valide
|
|
{if (Remonte_in(*ili)) // on test la présence du calcul de remonté
|
|
{ // certaines initialisations sont nécessaires car c'est le premier calcul
|
|
Algori::InitRemontSigma(lesMail,lesRef,divStock,charge,lesCondLim,lesContacts,resultats);
|
|
Algori::InitErreur(lesMail,lesRef,divStock,charge,lesCondLim,lesContacts,resultats);
|
|
Algori::RemontSigma(lesMail);
|
|
Algori::RemontErreur(lesMail);
|
|
}
|
|
else if ( (*ili) == sauveMaillagesEnCours )
|
|
{ cout << "\n================================================================="
|
|
<< "\n| ecriture des maillages en cours en .her et .lis |"
|
|
<< "\n================================================================="
|
|
<< endl;
|
|
|
|
// ----- sort les informations sur fichiers
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_tdt,*lesRef);
|
|
};
|
|
};
|
|
}
|
|
else
|
|
// cas ou le type principal n'est pas valide
|
|
// on ne fait que le calcul complémentaire
|
|
{ list <EnumSousTypeCalcul>::const_iterator ili,ili_fin = soustypeDeCalcul->end();
|
|
list <bool>::const_iterator ila;
|
|
for (ili = soustypeDeCalcul->begin(),ila = avec_soustypeDeCalcul->begin();
|
|
ili!=ili_fin;ili++,ila++)
|
|
if (*ila) // cas où le sous type est valide
|
|
{if (Remonte_in(*ili)) // on test la présence du calcul de remonté
|
|
{ // certaines initialisations sont nécessaires car c'est le premier calcul
|
|
Algori::InitRemontSigma(lesMail,lesRef,divStock,charge,lesCondLim,lesContacts,resultats);
|
|
Algori::InitErreur(lesMail,lesRef,divStock,charge,lesCondLim,lesContacts,resultats);
|
|
Algori::RemontSigma(lesMail);
|
|
Algori::RemontErreur(lesMail);
|
|
}
|
|
else if ( (*ili) == sauveMaillagesEnCours )
|
|
{ cout << "\n================================================================="
|
|
<< "\n| ecriture des maillages en cours en .her et .lis |"
|
|
<< "\n================================================================="
|
|
<< endl;
|
|
|
|
// ----- sort les informations sur fichiers
|
|
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
|
|
// à partir du nom de chaque maillage au format ".her" et ".lis"
|
|
// a priori ici on n'a pas fait de calcul donc on sort les grandeurs à t
|
|
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef);
|
|
};
|
|
};
|
|
}
|
|
}
|
|
// si on a forcé la sortie des itérations et incréments, il faut réinitialiser l'indicateur
|
|
if (!(pa.EtatSortieEquilibreGlobal()))
|
|
pa.ChangeSortieEquilibreGlobal(false);
|
|
|
|
};
|
|
|
|
// lecture des paramètres du calcul
|
|
void AlgoriNonDyna::lecture_Parametres(UtilLecture& entreePrinc)
|
|
{ MotCle motCle; // ref aux mots cle
|
|
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(NON_DYNA); // transfert info
|
|
deja_lue_entete_parametre = 1; // a priori pas de lecture d'entête
|
|
// on se positionne sur le prochain mot clé
|
|
do
|
|
{ entreePrinc.NouvelleDonnee();
|
|
}
|
|
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;
|
|
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
|
|
deja_lue_entete_parametre=2;
|
|
// lecture du premier paramètres de l'algorithme
|
|
entreePrinc.NouvelleDonnee(); // ligne suivante
|
|
|
|
// on initialise tous les paramètres par défaut
|
|
// non, car cela permettra éventuellement de garder les anciens paramètres
|
|
// acceleration_convergence = false;
|
|
// cas_acceleration_convergence = 1;
|
|
// nb_vec_cycle = 8;
|
|
|
|
// on s'arrête lorsqu'il n'y a plus de mot clé spécifique à lire
|
|
while ( (strstr(entreePrinc.tablcar,"acceleration_convergence_=")!=NULL)
|
|
|| (strstr(entreePrinc.tablcar,"cas_acceleration_convergence_=")!=NULL)
|
|
|| (strstr(entreePrinc.tablcar,"nb_vec_cycle_=")!=NULL)
|
|
|| (strstr(entreePrinc.tablcar,"deb_newton_modifie_=")!=NULL)
|
|
|| (strstr(entreePrinc.tablcar,"fin_newton_modifie_=")!=NULL)
|
|
|| (strstr(entreePrinc.tablcar,"nb_iter_NM_=")!=NULL)
|
|
|| (strstr(entreePrinc.tablcar,"deb_raideur_moyenne_=")!=NULL)
|
|
|| (strstr(entreePrinc.tablcar,"fin_raideur_moyenne_=")!=NULL)
|
|
|| (strstr(entreePrinc.tablcar,"nb_raideur_moyenne_=")!=NULL)
|
|
|| (strstr(entreePrinc.tablcar,"cL_a_chaque_iteration_")!=NULL)
|
|
)
|
|
|
|
{ string nom_mot_cle="";
|
|
*(entreePrinc.entree) >> nom_mot_cle;
|
|
if (nom_mot_cle == "acceleration_convergence_=")
|
|
{ // lecture du parametre
|
|
*(entreePrinc.entree) >> acceleration_convergence;
|
|
lecture_effective = true;
|
|
}
|
|
else if (nom_mot_cle == "cas_acceleration_convergence_=")
|
|
{ // on lit cas_acceleration_convergence
|
|
*(entreePrinc.entree) >> cas_acceleration_convergence;
|
|
// on vérifie la valeur lue
|
|
if ((cas_acceleration_convergence<1)||(cas_acceleration_convergence>4))
|
|
{ cout << "\n erreur en lecture de cas_acceleration_convergence "
|
|
<< "\n on attendait une valeur comprise entre 1 et 4 au lieu de: " << cas_acceleration_convergence
|
|
<< "\n AlgoriNonDyna::lecture_Parametres( ... ";
|
|
Sortie(1);
|
|
};
|
|
lecture_effective = true;
|
|
}
|
|
else if (nom_mot_cle == "nb_vec_cycle_=")
|
|
{ // on lit nb_vec_cycle
|
|
*(entreePrinc.entree) >> nb_vec_cycle;
|
|
// on vérifie la valeur lue
|
|
if (nb_vec_cycle<1)
|
|
{ cout << "\n erreur en lecture de nb_vec_cycle "
|
|
<< "\n on attendait une valeur positive non nulle " << nb_vec_cycle
|
|
<< "\n AlgoriNonDyna::lecture_Parametres( ... ";
|
|
Sortie(1);
|
|
};
|
|
lecture_effective = true;
|
|
if ((cas_acceleration_convergence==4) && (nb_vec_cycle<4))
|
|
{ cout << "\n ***warning**** en lecture de nb_vec_cycle "
|
|
<< "\n dans le cas ou cas_acceleration_convergence == 4 , nb_vec_cycle doit etre sup a 2 par defaut ";
|
|
nb_vec_cycle = 2;
|
|
};
|
|
}
|
|
else if (nom_mot_cle == "deb_newton_modifie_=")
|
|
{ // on lit deb_newton_modifie
|
|
*(entreePrinc.entree) >> deb_newton_modifie;
|
|
lecture_effective = true;
|
|
}
|
|
else if (nom_mot_cle == "fin_newton_modifie_=")
|
|
{ // on lit fin_newton_modifie
|
|
*(entreePrinc.entree) >> fin_newton_modifie;
|
|
lecture_effective = true;
|
|
}
|
|
else if (nom_mot_cle == "nb_iter_NM_=")
|
|
{ // on lit nb_iter_NM
|
|
*(entreePrinc.entree) >> nb_iter_NM;
|
|
lecture_effective = true;
|
|
}
|
|
else if (nom_mot_cle == "deb_raideur_moyenne_=")
|
|
{ // on lit deb_raideur_moyenne
|
|
*(entreePrinc.entree) >> deb_raideur_moyenne;
|
|
lecture_effective = true;
|
|
}
|
|
else if (nom_mot_cle == "fin_raideur_moyenne_=")
|
|
{ // on lit fin_raideur_moyenne
|
|
*(entreePrinc.entree) >> fin_raideur_moyenne;
|
|
lecture_effective = true;
|
|
}
|
|
else if (nom_mot_cle == "nb_raideur_moyenne_=")
|
|
{ // on lit nb_raideur_moyenne
|
|
*(entreePrinc.entree) >> nb_raideur_moyenne;
|
|
lecture_effective = true;
|
|
}
|
|
else if (nom_mot_cle == "cL_a_chaque_iteration_")
|
|
{ // on lit le paramètre
|
|
*(entreePrinc.entree) >> cL_a_chaque_iteration;
|
|
lecture_effective = true;
|
|
}
|
|
// gestion des fins de ligne
|
|
|
|
|
|
if ( ((strstr(entreePrinc.tablcar,"acceleration_convergence_=")==NULL)
|
|
&& (strstr(entreePrinc.tablcar,"cas_acceleration_convergence_=")==NULL)
|
|
&& (strstr(entreePrinc.tablcar,"nb_vec_cycle_=")==NULL)
|
|
&& (strstr(entreePrinc.tablcar,"deb_newton_modifie_=")==NULL)
|
|
&& (strstr(entreePrinc.tablcar,"fin_newton_modifie_=")==NULL)
|
|
&& (strstr(entreePrinc.tablcar,"nb_iter_NM_=")==NULL)
|
|
&& (strstr(entreePrinc.tablcar,"deb_raideur_moyenne_=")==NULL)
|
|
&& (strstr(entreePrinc.tablcar,"fin_raideur_moyenne_=")==NULL)
|
|
&& (strstr(entreePrinc.tablcar,"nb_raideur_moyenne_=")==NULL)
|
|
&& (strstr(entreePrinc.tablcar,"cL_a_chaque_iteration_")==NULL)
|
|
)
|
|
&& ((lecture_effective) && ( !motCle.SimotCle(entreePrinc.tablcar)))
|
|
)
|
|
// s'il n'y a plus rien et que l'on vient de lire dans ce cas on tente la ligne suivante
|
|
entreePrinc.NouvelleDonnee(); // ligne suivante
|
|
|
|
#ifdef ENLINUX
|
|
if ((entreePrinc.entree)->fail())
|
|
// on a atteind la fin de la ligne et on appelle un nouvel enregistrement
|
|
{ entreePrinc.NouvelleDonnee(); // lecture d'un nouvelle enregistrement
|
|
}
|
|
#else
|
|
if ((entreePrinc.entree)->eof())
|
|
// la lecture est bonne mais on a atteind la fin de la ligne
|
|
{ entreePrinc.NouvelleDonnee(); // lecture d'un nouvelle enregistrement
|
|
}
|
|
// #endif
|
|
#endif
|
|
// sinon ce n'est pas une ligne ad hoc, la lecture s'arrêtera
|
|
};
|
|
};
|
|
|
|
// on met en cohérence les pb des raideurs moyennes
|
|
if (deb_raideur_moyenne > -1)
|
|
deb_raideur_moyenne = MaX(deb_raideur_moyenne, nb_raideur_moyenne);
|
|
|
|
// // lecture du nom du paramètre et vérification
|
|
// string st1;
|
|
// if (strstr(entreePrinc.tablcar,"acceleration_convergence_=")!=NULL)
|
|
// { *(entreePrinc.entree) >> st1 ;
|
|
// if (st1 != "acceleration_convergence_=")
|
|
// { cout << "\n erreur en lecture du parametre de l'algorithme implicite statique "
|
|
// << "\n on attendait le mot : acceleration_convergence_= , au lieu de " << st1
|
|
// << "\n AlgoriNonDyna::lecture_Parametres( ... ";
|
|
// Sortie(1);
|
|
// }
|
|
// // lecture du parametre
|
|
// *(entreePrinc.entree) >> acceleration_convergence;
|
|
// lecture_effective = true;
|
|
// }
|
|
// else // sinon paramètre par défaut
|
|
// {acceleration_convergence = false;};
|
|
//
|
|
// // cas où le paramètre cas_acceleration_convergence existe
|
|
// if (strstr(entreePrinc.tablcar,"cas_acceleration_convergence_=")!=NULL)
|
|
// { // on lit cas_acceleration_convergence
|
|
// string st1;
|
|
// *(entreePrinc.entree) >> st1 >> cas_acceleration_convergence;
|
|
// if (st1 != "cas_acceleration_convergence_=")
|
|
// { cout << "\n erreur en lecture de cas_acceleration_convergence "
|
|
// << "\n on attendait le mot : cas_acceleration_convergence_= , au lieu de " << st1
|
|
// << "\n AlgoriNonDyna::lecture_Parametres( ... ";
|
|
// Sortie(1);
|
|
// };
|
|
// // on vérifie la valeur lue
|
|
// if ((cas_acceleration_convergence<1)||(cas_acceleration_convergence>4))
|
|
// { cout << "\n erreur en lecture de cas_acceleration_convergence "
|
|
// << "\n on attendait une valeur comprise entre 1 et 4 au lieu de: " << cas_acceleration_convergence
|
|
// << "\n AlgoriNonDyna::lecture_Parametres( ... ";
|
|
// Sortie(1);
|
|
// };
|
|
// lecture_effective = true;
|
|
// }
|
|
// else // sinon paramètre par défaut
|
|
// {cas_acceleration_convergence = 1;};
|
|
|
|
// // cas où le paramètre nb_vec_cycle existe
|
|
// if (strstr(entreePrinc.tablcar,"nb_vec_cycle_=")!=NULL)
|
|
// { // on lit nb_vec_cycle
|
|
// string st1;
|
|
// *(entreePrinc.entree) >> st1 >> nb_vec_cycle;
|
|
// if (st1 != "nb_vec_cycle_=")
|
|
// { cout << "\n erreur en lecture de nb_vec_cycle "
|
|
// << "\n on attendait le mot : nb_vec_cycle_= , au lieu de " << st1
|
|
// << "\n AlgoriNonDyna::lecture_Parametres( ... ";
|
|
// Sortie(1);
|
|
// };
|
|
// // on vérifie la valeur lue
|
|
// if (nb_vec_cycle<1)
|
|
// { cout << "\n erreur en lecture de nb_vec_cycle "
|
|
// << "\n on attendait une valeur positive non nulle " << nb_vec_cycle
|
|
// << "\n AlgoriNonDyna::lecture_Parametres( ... ";
|
|
// Sortie(1);
|
|
// };
|
|
// lecture_effective = true;
|
|
// if ((cas_acceleration_convergence==4) && (nb_vec_cycle<4))
|
|
// { cout << "\n ***warning**** en lecture de nb_vec_cycle "
|
|
// << "\n dans le cas ou cas_acceleration_convergence == 4 , nb_vec_cycle doit etre sup a 2 par defaut ";
|
|
// nb_vec_cycle = 2;
|
|
// };
|
|
// }
|
|
// else // sinon paramètre par défaut
|
|
// {if (cas_acceleration_convergence!=4){nb_vec_cycle = 8;}else {nb_vec_cycle = 2;};
|
|
// };
|
|
|
|
// // si on a déjà lue une ligne on passe à l'enreg suivant
|
|
// if ((lecture_effective) && ( !motCle.SimotCle(entreePrinc.tablcar)))
|
|
// { entreePrinc.NouvelleDonnee(); lecture_effective=false;}// ligne suivante
|
|
//
|
|
// }
|
|
// else // sinon on met une valeur par défaut qui ici correspond au cas
|
|
// // des différences centrées pour l'accélération, mais décalé à gauche
|
|
// // pour la vitesse (ce qui est aussi le cas quand phi est différent de 1.)
|
|
// { acceleration_convergence = false;cas_acceleration_convergence = 1; nb_vec_cycle = 8;
|
|
// };
|
|
// // on prépare la prochaine lecture si la lecture a été effective et que l'on n'est pas
|
|
// // sur un mot clé
|
|
// if ((lecture_effective) && ( !motCle.SimotCle(entreePrinc.tablcar)))
|
|
// entreePrinc.NouvelleDonnee(); // ligne suivante
|
|
// puis appel de la méthode de la classe mère
|
|
Algori::lecture_Parametres(entreePrinc);
|
|
|
|
};
|
|
|
|
// écriture des paramètres dans la base info
|
|
// = 1 : on écrit tout
|
|
// = 2 : on écrit uniquement les données variables (supposées comme telles)
|
|
void AlgoriNonDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
|
|
{
|
|
// récup du flot
|
|
ofstream * sort = entreePrinc.Sort_BI();
|
|
// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
|
|
if (cas == 1)
|
|
{// ecriture du parametre
|
|
*(sort) << "\n acceleration_convergence= " << acceleration_convergence
|
|
<< " cas_acceleration_convergence= " << cas_acceleration_convergence
|
|
<< " nb_vec_cycle= " << nb_vec_cycle
|
|
<< " nb_vec_cycle= " << nb_vec_cycle
|
|
<< " nb_vec_cycle= " << nb_vec_cycle
|
|
<< " deb_newton_modifie= " << deb_newton_modifie
|
|
<< " fin_newton_modifie= " << fin_newton_modifie
|
|
<< " nb_iter_NM= "<< nb_iter_NM
|
|
<< " deb_raideur_moyenne= " << deb_raideur_moyenne
|
|
<< " fin_raideur_moyenne= " << fin_raideur_moyenne
|
|
<< " nb_raideur_moyenne= "<< nb_raideur_moyenne
|
|
<< " cL_a_chaque_iteration "<< cL_a_chaque_iteration
|
|
<< " ";
|
|
};
|
|
// (*sort) << "\n fin_parametres_algo_specifiques_ ";
|
|
};
|
|
|
|
// lecture des paramètres dans la base info
|
|
// = 1 : on récupère tout
|
|
// = 2 : on récupère uniquement les données variables (supposées comme telles)
|
|
// choix = true : fonctionnememt normal
|
|
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
|
|
// car la lecture est impossible
|
|
void AlgoriNonDyna::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
|
|
{
|
|
if (cas == 1)
|
|
{// dimensionnement
|
|
if (choix)
|
|
{if ((ParaGlob::NiveauImpression() > 3) || (permet_affichage > 2))
|
|
{cout << "\n Lecture_Base_info_Parametre: cas ou les parametres sont disponibles"
|
|
<< " en lecture, que l'on effectue "<< flush;
|
|
};
|
|
|
|
// cas d'une lecture normale
|
|
// récup du flot
|
|
ifstream * ent = entreePrinc.Ent_BI();
|
|
string toto;
|
|
// lecture de acceleration_convergence
|
|
*(ent) >> toto ;
|
|
if (toto != "acceleration_convergence=")
|
|
{ cout << "\n erreur en lecture du parametre acceleration_convergence de l'algorithme implicite statique"
|
|
<< "\n on attendait le mot : acceleration_convergence= , au lieu de " << toto
|
|
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
|
|
Sortie(1);
|
|
}
|
|
*(ent) >> acceleration_convergence ;
|
|
// lecture de cas_acceleration_convergence
|
|
*(ent) >> toto ;
|
|
if (toto != "cas_acceleration_convergence=")
|
|
{ cout << "\n erreur en lecture du parametre cas_acceleration_convergence"
|
|
<< "\n on attendait le mot : acceleration_convergence= , au lieu de " << toto
|
|
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
|
|
Sortie(1);
|
|
}
|
|
*(ent) >> acceleration_convergence ;
|
|
// lecture de nb_vec_cycle
|
|
*(ent) >> toto ;
|
|
if (toto != "nb_vec_cycle=")
|
|
{ cout << "\n erreur en lecture du parametre nb_vec_cycle"
|
|
<< "\n on attendait le mot : nb_vec_cycle= , au lieu de " << toto
|
|
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
|
|
Sortie(1);
|
|
}
|
|
*(ent) >> nb_vec_cycle ;
|
|
// lecture de deb_newton_modifie
|
|
*(ent) >> toto ;
|
|
if (toto != "deb_newton_modifie=")
|
|
{ cout << "\n erreur en lecture du parametre deb_newton_modifie"
|
|
<< "\n on attendait le mot : deb_newton_modifie= , au lieu de " << toto
|
|
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
|
|
Sortie(1);
|
|
}
|
|
*(ent) >> deb_newton_modifie ;
|
|
// lecture de fin_newton_modifie
|
|
*(ent) >> toto ;
|
|
if (toto != "fin_newton_modifie=")
|
|
{ cout << "\n erreur en lecture du parametre fin_newton_modifie"
|
|
<< "\n on attendait le mot : fin_newton_modifie= , au lieu de " << toto
|
|
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
|
|
Sortie(1);
|
|
}
|
|
*(ent) >> fin_newton_modifie ;
|
|
// lecture de nb_iter_NM
|
|
*(ent) >> toto ;
|
|
if (toto != "nb_iter_NM=")
|
|
{ cout << "\n erreur en lecture du parametre nb_iter_NM"
|
|
<< "\n on attendait le mot : nb_iter_NM= , au lieu de " << toto
|
|
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
|
|
Sortie(1);
|
|
}
|
|
*(ent) >> nb_iter_NM ;
|
|
// lecture de deb_raideur_moyenne
|
|
*(ent) >> toto ;
|
|
if (toto != "deb_raideur_moyenne=")
|
|
{ cout << "\n erreur en lecture du parametre deb_raideur_moyenne"
|
|
<< "\n on attendait le mot : deb_raideur_moyenne= , au lieu de " << toto
|
|
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
|
|
Sortie(1);
|
|
}
|
|
*(ent) >> deb_raideur_moyenne ;
|
|
// lecture de fin_raideur_moyenne
|
|
*(ent) >> toto ;
|
|
if (toto != "fin_raideur_moyenne=")
|
|
{ cout << "\n erreur en lecture du parametre fin_raideur_moyenne"
|
|
<< "\n on attendait le mot : fin_raideur_moyenne= , au lieu de " << toto
|
|
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
|
|
Sortie(1);
|
|
}
|
|
*(ent) >> fin_raideur_moyenne ;
|
|
// lecture de nb_raideur_moyenne
|
|
*(ent) >> toto ;
|
|
if (toto != "nb_raideur_moyenne=")
|
|
{ cout << "\n erreur en lecture du parametre nb_raideur_moyenne"
|
|
<< "\n on attendait le mot : nb_raideur_moyenne= , au lieu de " << toto
|
|
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
|
|
Sortie(1);
|
|
}
|
|
*(ent) >> nb_raideur_moyenne ;
|
|
// lecture de cL_a_chaque_iteration
|
|
*(ent) >> toto ;
|
|
if (toto != "cL_a_chaque_iteration")
|
|
{ cout << "\n erreur en lecture du parametre cL_a_chaque_iteration"
|
|
<< "\n on attendait le mot : cL_a_chaque_iteration , au lieu de " << toto
|
|
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
|
|
Sortie(1);
|
|
}
|
|
*(ent) >> cL_a_chaque_iteration ;
|
|
}
|
|
else
|
|
{// cas où la lecture n'est pas possible, attribution des valeurs par défaut
|
|
nb_vec_cycle = 8; acceleration_convergence=false; cas_acceleration_convergence=1;
|
|
deb_newton_modifie = -1;fin_newton_modifie = -1;nb_iter_NM = 3;
|
|
deb_raideur_moyenne = -1;fin_raideur_moyenne = -1;nb_raideur_moyenne = 3;
|
|
cL_a_chaque_iteration=0;
|
|
if ((ParaGlob::NiveauImpression() > 3) || (permet_affichage > 2))
|
|
{cout << "\n Lecture_Base_info_Parametre: cas ou les parametres ne sont pas disponibles"
|
|
<< " on utilise et initialise les parametres par defaut "<< flush;
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// création d'un fichier de commande: cas des paramètres spécifiques
|
|
void AlgoriNonDyna::Info_commande_parametres(UtilLecture& entreePrinc)
|
|
{ // écriture dans le fichier de commande
|
|
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
|
|
cout << "\n# exemple des para facultatifs algo AlgoriNonDyna (rep o ou n defaut) ? ";
|
|
string rep;
|
|
// procédure de lecture avec prise en charge d'un retour chariot
|
|
rep = lect_return_defaut(true,"n");
|
|
// si la taille de rep == 0 cela veut dire que c'est un retour chariot
|
|
if (rep.size()==0)
|
|
{rep = "n";
|
|
cout << "--> valeur par defaut : n "<<endl;
|
|
};
|
|
if ((rep == "o") || (rep == "O") ||(rep == "0"))
|
|
{ sort << "\n#-----------------------------------------------------------------------"
|
|
<< "\n#| parametres (falcultatifs ) associes au calcul implicite statique |"
|
|
<< "\n#-----------------------------------------------------------------------"
|
|
<< "\n"
|
|
<< "\n ## PARA_TYPE_DE_CALCUL"
|
|
<< "\n # ................................................................"
|
|
<< "\n # / acceleration de convergence par extrapolation methode MMPE /"
|
|
<< "\n #.................................................................."
|
|
<< "\n ## acceleration_convergence_= 1 cas_acceleration_convergence_= 1 nb_vec_cycle_= 8 "
|
|
<< "\n # "
|
|
<< "\n # acceleration_convergence_= indique si oui (=1) ou non (=0) on veut une acceleration "
|
|
<< "\n # cas_acceleration_convergence_= 1 : on projette sur les vecteurs positions"
|
|
<< "\n # 2 : on projette sur les vecteurs residus "
|
|
<< "\n # nb_vec_cycle_= indique le nombre de vecteur maxi que l'on prendre en compte "
|
|
<< "\n # pour la projection"
|
|
|
|
<< "\n # ................................................................"
|
|
<< "\n # / utilisation de Newton modifie /"
|
|
<< "\n #.................................................................."
|
|
<< "\n # deb_newton_modifie_= indique le numero d'iteration de demarrage de la methode "
|
|
<< "\n # (negatif => pas d'utilisation de NM) "
|
|
<< "\n # nb_iter_NM_= nb de fois consecutive ou l'on utilise la raideur non mise a jour "
|
|
<< "\n # ensuite la matrice est mise a jour, et on recommence nb_iter_NM "
|
|
<< "\n # fin_newton_modifie_= indique le numero d'iteration de fin de la methode "
|
|
<< "\n # (negatif => pas de fin) "
|
|
<< "\n # ensuite retour sur du Newton classique "
|
|
|
|
<< "\n # ................................................................"
|
|
<< "\n # / utilisation d'une moyenne de raideurs /"
|
|
<< "\n #.................................................................."
|
|
<< "\n # deb_raideur_moyenne_= indique le numero d'iteration de demarrage de la methode "
|
|
<< "\n # (negatif => pas d'utilisation ) "
|
|
<< "\n # nb_raideur_moyenne_= nb de raideur utilise pour la moyenne "
|
|
<< "\n # fin_raideur_moyenne_= indique le numero d'iteration de fin de la methode "
|
|
<< "\n # (negatif => pas de fin) "
|
|
<< "\n # ensuite retour sur du Newton classique "
|
|
|
|
<< "\n # ................................................................"
|
|
<< "\n # / mise en place des conditions limites a chaque iteration /"
|
|
<< "\n #.................................................................."
|
|
<< "\n # mot cle : cL_a_chaque_iteration_ suivi de 0 ou 1 "
|
|
<< "\n # par defaut == 0, c-a-d que les CL sont mises en place "
|
|
<< "\n # au debut de chaque increment et ensuite reste fixe pendant les iterations "
|
|
<< "\n # == 1 : a chaque iteration, les CL sont de nouveaux imposes "
|
|
|
|
<< "\n #.................................................................."
|
|
<< "\n # / mode debug /"
|
|
<< "\n #.................................................................."
|
|
<< "\n ## mode_debug_= 0 "
|
|
<< "\n # "
|
|
<< "\n # mode_debug_= parametre de debug (=0) calcul classique "
|
|
<< "\n # 1 : a chaque iteration on sort une visualisation "
|
|
<< "\n # **important**: ce parametre doit etre mis sur une ligne differente de "
|
|
<< "\n # l'acceleration de convergence"
|
|
<< "\n # ";
|
|
};
|
|
// appel de la classe mère
|
|
Algori::Info_com_parametres(entreePrinc);
|
|
sort << "\n" << endl;
|
|
};
|
|
|